Struct KobeClient 

pub struct KobeClient { /* private fields */ }

Main client for interacting with Jito APIs

Implementations

impl KobeClient

pub fn new(config: Config) -> Self

Create a new Jito API client with the given configuration

pub fn mainnet() -> Self

Create a client with mainnet defaults

pub fn testnet() -> Self

Create a client with testnet defaults

pub fn base_url(&self) -> &str

Get the base URL

pub async fn get_staker_rewards( &self, limit: Option<u32>, ) -> Result<StakerRewardsResponse, KobeApiError>

Get staker rewards

Retrieves individual claimable MEV and priority fee rewards from the tip distribution merkle trees.

Arguments

• limit - Optional limit on the number of results (default: API default)

Example

let client = KobeClient::mainnet();
let rewards = client.get_staker_rewards(Some(10)).await?;

pub async fn get_staker_rewards_with_params( &self, params: &QueryParams, ) -> Result<StakerRewardsResponse, KobeApiError>

Get staker rewards with full query parameters

pub async fn get_validator_rewards( &self, epoch: Option<u64>, limit: Option<u32>, ) -> Result<ValidatorRewardsResponse, KobeApiError>

Get validator rewards for a specific epoch

Retrieves aggregated MEV and priority fee rewards data per validator.

Arguments

• epoch - Epoch number (optional, defaults to latest)
• limit - Optional limit on the number of results

pub async fn get_validators( &self, epoch: Option<u64>, ) -> Result<ValidatorsResponse, KobeApiError>

Get all validators for a given epoch

Returns validator state for a given epoch (defaults to latest).

Arguments

• epoch - Optional epoch number (defaults to latest)

Examples found in repository

examples/validators.rs (line 16)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let validators = client.get_validators(Some(current_epoch)).await.unwrap();

    println!("Found {} validators", validators.validators.len());
}

pub async fn get_jitosol_validators( &self, epoch: Option<u64>, ) -> Result<ValidatorsResponse, KobeApiError>

Get JitoSOL stake pool validators for a given epoch

Returns only validators that are actively part of the JitoSOL validator set.

Examples found in repository

examples/jitosol_validators.rs (line 16)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let jitosol_validators = client.get_jitosol_validators(Some(873)).await.unwrap();

    println!(
        "Found {} jito_sol Validators",
        jitosol_validators.validators.len()
    );
}

pub async fn get_validator_info_by_vote_account( &self, vote_account: &str, ) -> Result<Vec<ValidatorByVoteAccount>, KobeApiError>

Get historical data for a single validator

Returns historical reward data for a validator, sorted by epoch (descending).

Arguments

• vote_account - The validator’s vote account public key

Examples found in repository

examples/validator_by_vote_account.rs (line 16)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let vote_account = "J1to1yufRnoWn81KYg1XkTWzmKjnYSnmE2VY8DGUJ9Qv";

    let validator_info = client
        .get_validator_info_by_vote_account(vote_account)
        .await
        .unwrap();

    println!("Validator Info Length: {}", validator_info.len());
}

pub async fn get_mev_rewards( &self, epoch: Option<u64>, ) -> Result<MevRewards, KobeApiError>

Get MEV rewards network statistics for an epoch

Returns network-level statistics including total MEV, stake weight, and reward per lamport.

Arguments

• epoch - Optional epoch number (defaults to latest)

Examples found in repository

examples/mev_rewards.rs (line 16)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let mev_rewards = client.get_mev_rewards(Some(current_epoch)).await.unwrap();

    println!("MEV Rewards: {:?}", mev_rewards);
}

pub async fn get_daily_mev_rewards( &self, ) -> Result<Vec<DailyMevRewards>, KobeApiError>

Get daily MEV rewards

Returns aggregated MEV rewards per calendar day.

Examples found in repository

examples/daily_mev_rewards.rs (line 13)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let daily_mev_tips = client.get_daily_mev_rewards().await.unwrap();

    println!("Daily MEV Tips: {:?}", daily_mev_tips);
}

pub async fn get_jito_stake_over_time( &self, ) -> Result<JitoStakeOverTime, KobeApiError>

Get Jito stake over time

Returns a map of epoch to percentage of all Solana stake delegated to Jito-running validators.

Examples found in repository

examples/jito_stake_over_time.rs (line 13)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let stake_over_time = client.get_jito_stake_over_time().await.unwrap();

    println!("Stake over time: {:?}", stake_over_time);
}

pub async fn get_mev_commission_average_over_time( &self, ) -> Result<MevCommissionAverageOverTime, KobeApiError>

Get MEV commission average over time

Returns stake-weighted average MEV commission along with other metrics.

pub async fn get_jitosol_sol_ratio( &self, start: DateTime<Utc>, end: DateTime<Utc>, ) -> Result<JitoSolRatio, KobeApiError>

Get JitoSOL to SOL exchange ratio over time

Arguments

• start - Start datetime for the range
• end - End datetime for the range

pub async fn get_stake_pool_stats( &self, request: Option<&StakePoolStatsRequest>, ) -> Result<StakePoolStats, KobeApiError>

Get stake pool statistics

Returns stake pool analytics including TVL, APY, validator count, supply metrics, and aggregated MEV rewards over time.

Examples found in repository

examples/stake_pool_stats.rs (line 25)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let end = Utc::now();

    let start = end - chrono::Duration::days(1);
    let request = StakePoolStatsRequest::new()
        .with_bucket_type("Daily")
        .with_range_filter(start, end)
        .sort_asc();

    let stake_pool_stats = client.get_stake_pool_stats(Some(&request)).await.unwrap();

    println!("Stake Pool Stats: {:?}", stake_pool_stats);
}

pub async fn get_current_epoch(&self) -> Result<u64, KobeApiError>

Get the current epoch from the latest MEV rewards data

Examples found in repository

examples/mev_rewards.rs (line 13)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let mev_rewards = client.get_mev_rewards(Some(current_epoch)).await.unwrap();

    println!("MEV Rewards: {:?}", mev_rewards);
}

examples/validators.rs (line 13)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let validators = client.get_validators(Some(current_epoch)).await.unwrap();

    println!("Found {} validators", validators.validators.len());
}

examples/jitosol_validators.rs (line 13)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let jitosol_validators = client.get_jitosol_validators(Some(873)).await.unwrap();

    println!(
        "Found {} jito_sol Validators",
        jitosol_validators.validators.len()
    );
}

examples/stake_pool_stats.rs (line 14)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .timeout(Duration::from_secs(45))
        .retry(true)
        .max_retries(5)
        .build();

    let current_epoch = client.get_current_epoch().await.unwrap();
    println!("Current epoch: {}\n", current_epoch);

    let end = Utc::now();

    let start = end - chrono::Duration::days(1);
    let request = StakePoolStatsRequest::new()
        .with_bucket_type("Daily")
        .with_range_filter(start, end)
        .sort_asc();

    let stake_pool_stats = client.get_stake_pool_stats(Some(&request)).await.unwrap();

    println!("Stake Pool Stats: {:?}", stake_pool_stats);
}

pub async fn get_jito_validators( &self, ) -> Result<Vec<ValidatorInfo>, KobeApiError>

Get all validators currently running Jito

pub async fn get_validators_by_stake( &self, epoch: Option<u64>, limit: usize, ) -> Result<Vec<ValidatorInfo>, KobeApiError>

Get validators sorted by active stake

pub async fn is_validator_running_jito( &self, vote_account: &str, ) -> Result<bool, KobeApiError>

Check if a validator is running Jito

pub async fn calculate_total_mev_rewards( &self, start_epoch: u64, end_epoch: u64, ) -> Result<u64, KobeApiError>

Calculate total MEV rewards for a time period

pub async fn get_bam_delegation_blacklist( &self, ) -> Result<Vec<BamDelegationBlacklistEntry>, KobeApiError>

Get BAM Delegation Blacklist

Returns bam delegation blacklist

Examples found in repository

examples/bam_delegation_blacklist.rs (line 9)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .base_url("http://localhost:8080")
        .build();

    let blacklist = client.get_bam_delegation_blacklist().await.unwrap();

    println!("Bam Delegation Blacklist: {:?}", blacklist);
}

pub async fn get_bam_epoch_metrics( &self, epoch: u64, ) -> Result<BamEpochMetricsResponse, KobeApiError>

Get BAM Epoch Metrics

Returns bam epoch metrics

Examples found in repository

examples/bam_epoch_metrics.rs (line 9)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .base_url("http://localhost:8080")
        .build();

    let bam_epoch_metrics = client.get_bam_epoch_metrics(892).await.unwrap();

    println!("Bam Epoch Metrics: {:?}", bam_epoch_metrics);
}

pub async fn get_bam_validators( &self, epoch: u64, ) -> Result<BamValidatorsResponse, KobeApiError>

Get BAM Validators

Returns bam validators

Examples found in repository

examples/bam_validators.rs (line 9)

async fn main() {
    let client = KobeApiClientBuilder::new()
        .base_url("http://localhost:8080")
        .build();

    let bam_validators = client.get_bam_validators(892).await.unwrap();

    println!("Bam Validators: {:?}", bam_validators);
}

Trait Implementations

impl Clone for KobeClient

fn clone(&self) -> KobeClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KobeClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.