Struct Client 

pub struct Client { /* private fields */ }

Client for ChainStream API

ChainStream Unified API

Version: 2.0

Implementations

impl Client

pub fn new(baseurl: &str) -> Self

Create a new client.

baseurl is the base URL provided to the internal reqwest::Client, and should include a scheme and hostname, as well as port and a path stem if applicable.

pub fn new_with_client(baseurl: &str, client: ClientWithMiddleware) -> Self

Construct a new client with an existing reqwest_middleware::ClientWithMiddleware, allowing more control over its configuration.

baseurl is the base URL provided to the internal reqwest_middleware::ClientWithMiddleware, and should include a scheme and hostname, as well as port and a path stem if applicable.

impl Client

pub fn get_supported_blockchains(&self) -> GetSupportedBlockchains<'_>

Blockchain - List

Get list of supported blockchains

Sends a GET request to /v2/blockchain

let response = client.get_supported_blockchains()
    .send()
    .await;

pub fn get_latest_block(&self) -> GetLatestBlock<'_>

Blockchain - Latest Block

Get the latest block information for a specific blockchain

Sends a GET request to /v2/blockchain/{chain}/latest_block

Arguments:

• chain: A chain name listed in supported networks

let response = client.get_latest_block()
    .chain(chain)
    .send()
    .await;

pub fn list_dex(&self) -> ListDex<'_>

Dex - List

Obtain information about all DEXs on a specified blockchain.

Sends a GET request to /v2/dex

Arguments:

• chains: Filter by blockchain networks
• cursor: Pagination cursor
• dex_program: Filter by DEX program address
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.list_dex()
    .chains(chains)
    .cursor(cursor)
    .dex_program(dex_program)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn create_token(&self) -> CreateToken<'_>

Dex - Create Token

Create a new token on the specified DEX

Sends a POST request to /v2/dex/{chain}/create

Arguments:

• chain: A chain name listed in supported networks
• body: Token creation parameters

let response = client.create_token()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn quote(&self) -> Quote<'_>

Dex - Get Quote

Get DEX trading quote information

Sends a GET request to /v2/dex/{chain}/quote

Arguments:

• chain: A chain name listed in supported networks
• amount: Trading amount
• dex: DEX protocol type
• exact_in: Exact input mode
• input_mint: Input token address
• output_mint: Output token address
• slippage: Slippage tolerance

let response = client.quote()
    .chain(chain)
    .amount(amount)
    .dex(dex)
    .exact_in(exact_in)
    .input_mint(input_mint)
    .output_mint(output_mint)
    .slippage(slippage)
    .send()
    .await;

pub fn route(&self) -> Route<'_>

Dex - Route

Calculate the best route for token swap considering price impact and fees. Returns the optimal path and a prepared transaction.

Sends a POST request to /v2/dex/{chain}/route

Arguments:

• chain: A chain name listed in supported networks
• body

let response = client.route()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn swap(&self) -> Swap<'_>

Dex - Swap

Swap parameters including input token, output token, amount and slippage

Sends a POST request to /v2/dex/{chain}/swap

Arguments:

• chain: A chain name listed in supported networks
• body

let response = client.swap()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn get_dexpool(&self) -> GetDexpool<'_>

DexPool - Detail

Retrieve detailed information about a specific DEX pool

Sends a GET request to /v2/dexpools/{chain}/{poolAddress}

Arguments:

• chain: A chain name listed in supported networks
• pool_address: A pool address

let response = client.get_dexpool()
    .chain(chain)
    .pool_address(pool_address)
    .send()
    .await;

pub fn get_dexpool_snapshots(&self) -> GetDexpoolSnapshots<'_>

DexPool - Liquidity Snapshots

Retrieve historical liquidity snapshots for a specific pool. If a time parameter is provided, returns the nearest snapshot before or at that time.

Sends a GET request to /v2/dexpools/{chain}/{poolAddress}/snapshots

Arguments:

• chain: A chain name listed in supported networks
• pool_address: A pool address
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• time: Target Unix timestamp for snapshot query

let response = client.get_dexpool_snapshots()
    .chain(chain)
    .pool_address(pool_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time(time)
    .send()
    .await;

pub fn get_dexscr_ads(&self) -> GetDexscrAds<'_>

DexScreener - Ads

Retrieve a list of paid DexScreener advertisements

Sends a GET request to /v2/dexscr/{chain}/ads

Arguments:

• chain: A chain name listed in supported networks
• limit: Number of results to return

let response = client.get_dexscr_ads()
    .chain(chain)
    .limit(limit)
    .send()
    .await;

pub fn get_dexscr_boosts(&self) -> GetDexscrBoosts<'_>

DexScreener - Boosts

Retrieve a list of token boosts with spending amounts from DexScreener

Sends a GET request to /v2/dexscr/{chain}/boosts

Arguments:

• chain: A chain name listed in supported networks
• limit: Number of results to return

let response = client.get_dexscr_boosts()
    .chain(chain)
    .limit(limit)
    .send()
    .await;

pub fn get_dexscr_link_updates(&self) -> GetDexscrLinkUpdates<'_>

DexScreener - Link Updates

Retrieve recently updated token profile links from DexScreener

Sends a GET request to /v2/dexscr/{chain}/link-updates

Arguments:

• chain: A chain name listed in supported networks
• limit: Number of results to return

let response = client.get_dexscr_link_updates()
    .chain(chain)
    .limit(limit)
    .send()
    .await;

pub fn get_dexscr_token_info(&self) -> GetDexscrTokenInfo<'_>

DexScreener - Token Info

Retrieve DexScreener ad, boost, and link update information for a specific token

Sends a GET request to /v2/dexscr/{chain}/token/{tokenAddress}

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_dexscr_token_info()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_dexscr_trending(&self) -> GetDexscrTrending<'_>

DexScreener - Trending

Retrieve trending meta categories from DexScreener

Sends a GET request to /v2/dexscr/{chain}/trending

Arguments:

• chain: A chain name listed in supported networks
• limit: Number of results to return

let response = client.get_dexscr_trending()
    .chain(chain)
    .limit(limit)
    .send()
    .await;

pub fn presign(&self) -> Presign<'_>

IPFS - Presign

Create a Presign URL for IPFS content

Sends a POST request to /v2/ipfs/presign

let response = client.presign()
    .send()
    .await;

pub fn get(&self) -> Get<'_>

Job - Get

Retrieve the current status and result of a job by its ID

Sends a GET request to /v2/job/{id}

Arguments:

• id: Job identifier

let response = client.get()
    .id(id)
    .send()
    .await;

pub fn streaming(&self) -> Streaming<'_>

Job - Streaming

Subscribe to real-time job status updates via Server-Sent Events (SSE). The connection will remain open until the job completes or an error occurs

Sends a GET request to /v2/job/{id}/streaming

Arguments:

• id: Job identifier

let response = client.streaming()
    .id(id)
    .send()
    .await;

pub fn register_address(&self) -> RegisterAddress<'_>

KYT - Register Address

Register an address for KYT monitoring

Sends a POST request to /v2/kyt/address

let response = client.register_address()
    .body(body)
    .send()
    .await;

pub fn get_address_risk(&self) -> GetAddressRisk<'_>

KYT - Get Address Risk

Retrieve risk assessment for a registered address

Sends a GET request to /v2/kyt/addresses/{address}/risk

Arguments:

• address: Address

let response = client.get_address_risk()
    .address(address)
    .send()
    .await;

pub fn register_transfer(&self) -> RegisterTransfer<'_>

KYT - Register Transfer

Register a transfer for KYT (Know Your Transaction) analysis

Sends a POST request to /v2/kyt/transfer

let response = client.register_transfer()
    .body(body)
    .send()
    .await;

pub fn get_transfer_alerts(&self) -> GetTransferAlerts<'_>

KYT - Get Transfer Alerts

Retrieve alerts associated with a transfer

Sends a GET request to /v2/kyt/transfers/{transferId}/alerts

Arguments:

• transfer_id: Transfer ID

let response = client.get_transfer_alerts()
    .transfer_id(transfer_id)
    .send()
    .await;

pub fn get_transfer_direct_exposure(&self) -> GetTransferDirectExposure<'_>

KYT - Get Transfer Direct Exposure

Get direct exposure information for a transfer

Sends a GET request to /v2/kyt/transfers/{transferId}/exposures/direct

Arguments:

• transfer_id: Transfer ID

let response = client.get_transfer_direct_exposure()
    .transfer_id(transfer_id)
    .send()
    .await;

pub fn get_transfer_network_identifications( &self, ) -> GetTransferNetworkIdentifications<'_>

KYT - Get Transfer Network Identifications

Get network identifications for a transfer

Sends a GET request to /v2/kyt/transfers/{transferId}/network-identifications

Arguments:

• transfer_id: Transfer ID

let response = client.get_transfer_network_identifications()
    .transfer_id(transfer_id)
    .send()
    .await;

pub fn get_transfer_summary(&self) -> GetTransferSummary<'_>

KYT - Get Transfer Summary

Retrieve summary information for a registered transfer

Sends a GET request to /v2/kyt/transfers/{transferId}/summary

Arguments:

• transfer_id: Transfer ID

let response = client.get_transfer_summary()
    .transfer_id(transfer_id)
    .send()
    .await;

pub fn register_withdrawal(&self) -> RegisterWithdrawal<'_>

KYT - Register Withdrawal

Register a withdrawal for KYT (Know Your Transaction) analysis

Sends a POST request to /v2/kyt/withdrawal

let response = client.register_withdrawal()
    .body(body)
    .send()
    .await;

pub fn get_withdrawal_address_identifications( &self, ) -> GetWithdrawalAddressIdentifications<'_>

KYT - Get Withdrawal Address Identifications

Get address identifications for a withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/address-identifications

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_address_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_withdrawal_alerts(&self) -> GetWithdrawalAlerts<'_>

KYT - Get Withdrawal Alerts

Retrieve alerts associated with a withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/alerts

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_alerts()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_withdrawal_direct_exposure(&self) -> GetWithdrawalDirectExposure<'_>

KYT - Get Withdrawal Direct Exposure

Get direct exposure information for a withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/exposures/direct

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_direct_exposure()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_withdrawal_fraud_assessment( &self, ) -> GetWithdrawalFraudAssessment<'_>

KYT - Get Withdrawal Fraud Assessment

Get fraud assessment results for a withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/fraud-assessment

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_fraud_assessment()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_withdrawal_network_identifications( &self, ) -> GetWithdrawalNetworkIdentifications<'_>

KYT - Get Withdrawal Network Identifications

Get network identifications for a withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/network-identifications

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_network_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_withdrawal_summary(&self) -> GetWithdrawalSummary<'_>

KYT - Get Withdrawal Summary

Retrieve summary information for a registered withdrawal

Sends a GET request to /v2/kyt/withdrawal/{withdrawalId}/summary

Arguments:

• withdrawal_id: Withdrawal ID

let response = client.get_withdrawal_summary()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;

pub fn get_final_stretch_tokens(&self) -> GetFinalStretchTokens<'_>

Ranking - FinalStretch Tokens

Return the finalStretch tokens

Sends a GET request to /v2/ranking/{chain}/finalStretch

Arguments:

• chain: A chain name listed in supported networks
• exclude_keywords: Exclude Keywords
• filters: Filters
• launchpad_platform: Launchpad Platform
• range_filters: Filter field
• search_keywords: Search Keywords
• sort_by: Sort field
• sort_direction: Sort Direction
• tag: Ranking tag filter

let response = client.get_final_stretch_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;

pub fn get_hot_tokens(&self) -> GetHotTokens<'_>

Ranking - Hot Tokens

Retrieve a list of trending tokens

Sends a GET request to /v2/ranking/{chain}/hotTokens/{duration}

Arguments:

• chain: A chain name listed in supported networks
• duration: Duration of the ranking
• exclude_keywords: Exclude Keywords
• filters: Filters
• launchpad_platform: Launchpad Platform
• range_filters: Filter field
• search_keywords: Search Keywords
• sort_by: Sort field
• sort_direction: Sort Direction
• tag: Ranking tag filter

let response = client.get_hot_tokens()
    .chain(chain)
    .duration(duration)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;

pub fn get_migrated_tokens(&self) -> GetMigratedTokens<'_>

Ranking - Migrated Tokens

Return the migrated tokens

Sends a GET request to /v2/ranking/{chain}/migrated

Arguments:

• chain: A chain name listed in supported networks
• exclude_keywords: Exclude Keywords
• filters: Filters
• launchpad_platform: Launchpad Platform
• range_filters: Filter field
• search_keywords: Search Keywords
• sort_by: Sort field
• sort_direction: Sort Direction
• tag: Ranking tag filter

let response = client.get_migrated_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;

pub fn get_new_tokens(&self) -> GetNewTokens<'_>

Ranking - New Tokens

Return the latest 100 tokens

Sends a GET request to /v2/ranking/{chain}/newTokens

Arguments:

• chain: A chain name listed in supported networks
• exclude_keywords: Exclude Keywords
• filters: Filters
• launchpad_platform: Launchpad Platform
• range_filters: Filter field
• search_keywords: Search Keywords
• sort_by: Sort field
• sort_direction: Sort Direction
• tag: Ranking tag filter

let response = client.get_new_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;

pub fn get_stocks_tokens(&self) -> GetStocksTokens<'_>

Ranking - Stocks Tokens

Return the stocks tokens

Sends a GET request to /v2/ranking/{chain}/stocks

Arguments:

• chain: A chain name listed in supported networks
• exclude_keywords: Exclude Keywords
• filters: Filters
• launchpad_platform: Launchpad Platform
• range_filters: Filter field
• search_keywords: Search Keywords
• sort_by: Sort field
• sort_direction: Sort Direction
• tag: Ranking tag filter

let response = client.get_stocks_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;

pub fn get_redpackets(&self) -> GetRedpackets<'_>

RedPacket - GetRedpackets

Get the redpackets list

Sends a GET request to /v2/redpacket

Arguments:

• chain: Blockchain network for the red packet
• creator: Creator wallet address
• cursor: Pagination cursor
• direction: Pagination direction
• limit: Number of results per page

let response = client.get_redpackets()
    .chain(chain)
    .creator(creator)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_claims_by_address(&self) -> GetClaimsByAddress<'_>

RedPacket - GetClaimsByAddress

Check the record of redpacket collection by the claimer address

Sends a GET request to /v2/redpacket/wallet/{address}/claims

Arguments:

• address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction
• limit: Number of results per page

let response = client.get_claims_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_redpackets_by_address(&self) -> GetRedpacketsByAddress<'_>

RedPacket - GetRedpacketsByAddress

Get the redpackets list by the creator address

Sends a GET request to /v2/redpacket/wallet/{address}/redpackets

Arguments:

• address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction
• limit: Number of results per page

let response = client.get_redpackets_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn claim_redpacket(&self) -> ClaimRedpacket<'_>

RedPacket - Claim

Claim tokens from an existing red packet

Sends a POST request to /v2/redpacket/{chain}/claim

Arguments:

• chain: A chain name listed in supported networks
• body

let response = client.claim_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn create_redpacket(&self) -> CreateRedpacket<'_>

RedPacket - Create

Create a new red packet with specified amount and quantity

Sends a POST request to /v2/redpacket/{chain}/create

Arguments:

• chain: A chain name listed in supported networks
• body

let response = client.create_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn redpacket_send(&self) -> RedpacketSend<'_>

RedPacket - Send

Transactions related to redpacket

Sends a POST request to /v2/redpacket/{chain}/send

Arguments:

• chain: A chain name listed in supported networks
• body

let response = client.redpacket_send()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn get_redpacket(&self) -> GetRedpacket<'_>

RedPacket - Get

Query redpacket information

Sends a GET request to /v2/redpacket/{id}

Arguments:

• id: Red packet identifier

let response = client.get_redpacket()
    .id(id)
    .send()
    .await;

pub fn get_claims(&self) -> GetClaims<'_>

RedPacket - GetClaims

Check the record of redpacket collection

Sends a GET request to /v2/redpacket/{id}/claims

Arguments:

• id: Red packet identifier
• cursor: Pagination cursor
• direction: Pagination direction
• limit: Number of results per page

let response = client.get_claims()
    .id(id)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn search(&self) -> Search<'_>

Token - Search

Search tokens by name, symbol or address

Sends a GET request to /v2/token/search

Arguments:

• chains: Chain filter
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• mode: Search mode: fast (default, returns basic fields) or normal (returns full token details)
• protocols: Protocol filter
• q: Search query string for token name, symbol or address
• sort: Sort direction
• sort_by: Field to sort by

let response = client.search()
    .chains(chains)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .mode(mode)
    .protocols(protocols)
    .q(q)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;

pub fn get_dev_tokens(&self) -> GetDevTokens<'_>

Token - Get Dev Tokens

Retrieve all tokens created by a specific developer address

Sends a GET request to /v2/token/{chain}/dev/{devAddress}/tokens

Arguments:

• chain: A chain name listed in supported networks
• dev_address: An address of a user
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_dev_tokens()
    .chain(chain)
    .dev_address(dev_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn list_token(&self) -> ListToken<'_>

Token - List (Filtered)

Get filtered token list with range conditions

Sends a GET request to /v2/token/{chain}/list

Arguments:

• chain: A chain name listed in supported networks
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• max_h1_buy_volume_in_usd: Maximum 1h buy volume in USD
• max_h1_buyers: Maximum 1h buyer count
• max_h1_buys: Maximum 1h buy count
• max_h1_price_change_ratio: Maximum 1h price change ratio
• max_h1_sell_volume_in_usd: Maximum 1h sell volume in USD
• max_h1_sellers: Maximum 1h seller count
• max_h1_sells: Maximum 1h sell count
• max_h1_trades: Maximum 1h trade count
• max_h1_volume_in_usd: Maximum 1h volume in USD
• max_h24_buy_volume_in_usd: Maximum 24h buy volume in USD
• max_h24_buyers: Maximum 24h buyer count
• max_h24_buys: Maximum 24h buy count
• max_h24_price_change_ratio: Maximum 24h price change ratio
• max_h24_sell_volume_in_usd: Maximum 24h sell volume in USD
• max_h24_sellers: Maximum 24h seller count
• max_h24_sells: Maximum 24h sell count
• max_h24_trades: Maximum 24h trade count
• max_h24_volume_in_usd: Maximum 24h volume in USD
• max_h4_buy_volume_in_usd: Maximum 4h buy volume in USD
• max_h4_buyers: Maximum 4h buyer count
• max_h4_buys: Maximum 4h buy count
• max_h4_price_change_ratio: Maximum 4h price change ratio
• max_h4_sell_volume_in_usd: Maximum 4h sell volume in USD
• max_h4_sellers: Maximum 4h seller count
• max_h4_sells: Maximum 4h sell count
• max_h4_trades: Maximum 4h trade count
• max_h4_volume_in_usd: Maximum 4h volume in USD
• max_m15_buy_volume_in_usd: Maximum 15min buy volume in USD
• max_m15_buyers: Maximum 15min buyer count
• max_m15_buys: Maximum 15min buy count
• max_m15_price_change_ratio: Maximum 15min price change ratio
• max_m15_sell_volume_in_usd: Maximum 15min sell volume in USD
• max_m15_sellers: Maximum 15min seller count
• max_m15_sells: Maximum 15min sell count
• max_m15_trades: Maximum 15min trade count
• max_m15_volume_in_usd: Maximum 15min volume in USD
• max_m1_buy_volume_in_usd: Maximum 1min buy volume in USD
• max_m1_buyers: Maximum 1min buyer count
• max_m1_buys: Maximum 1min buy count
• max_m1_price_change_ratio: Maximum 1min price change ratio
• max_m1_sell_volume_in_usd: Maximum 1min sell volume in USD
• max_m1_sellers: Maximum 1min seller count
• max_m1_sells: Maximum 1min sell count
• max_m1_trades: Maximum 1min trade count
• max_m1_volume_in_usd: Maximum 1min volume in USD
• max_m30_buy_volume_in_usd: Maximum 30min buy volume in USD
• max_m30_buyers: Maximum 30min buyer count
• max_m30_buys: Maximum 30min buy count
• max_m30_price_change_ratio: Maximum 30min price change ratio
• max_m30_sell_volume_in_usd: Maximum 30min sell volume in USD
• max_m30_sellers: Maximum 30min seller count
• max_m30_sells: Maximum 30min sell count
• max_m30_trades: Maximum 30min trade count
• max_m30_volume_in_usd: Maximum 30min volume in USD
• max_m5_buy_volume_in_usd: Maximum 5min buy volume in USD
• max_m5_buyers: Maximum 5min buyer count
• max_m5_buys: Maximum 5min buy count
• max_m5_price_change_ratio: Maximum 5min price change ratio
• max_m5_sell_volume_in_usd: Maximum 5min sell volume in USD
• max_m5_sellers: Maximum 5min seller count
• max_m5_sells: Maximum 5min sell count
• max_m5_trades: Maximum 5min trade count
• max_m5_volume_in_usd: Maximum 5min volume in USD
• min_h1_buy_volume_in_usd: Minimum 1h buy volume in USD
• min_h1_buyers: Minimum 1h buyer count
• min_h1_buys: Minimum 1h buy count
• min_h1_price_change_ratio: Minimum 1h price change ratio
• min_h1_sell_volume_in_usd: Minimum 1h sell volume in USD
• min_h1_sellers: Minimum 1h seller count
• min_h1_sells: Minimum 1h sell count
• min_h1_trades: Minimum 1h trade count
• min_h1_volume_in_usd: Minimum 1h volume in USD
• min_h24_buy_volume_in_usd: Minimum 24h buy volume in USD
• min_h24_buyers: Minimum 24h buyer count
• min_h24_buys: Minimum 24h buy count
• min_h24_price_change_ratio: Minimum 24h price change ratio
• min_h24_sell_volume_in_usd: Minimum 24h sell volume in USD
• min_h24_sellers: Minimum 24h seller count
• min_h24_sells: Minimum 24h sell count
• min_h24_trades: Minimum 24h trade count
• min_h24_volume_in_usd: Minimum 24h volume in USD
• min_h4_buy_volume_in_usd: Minimum 4h buy volume in USD
• min_h4_buyers: Minimum 4h buyer count
• min_h4_buys: Minimum 4h buy count
• min_h4_price_change_ratio: Minimum 4h price change ratio
• min_h4_sell_volume_in_usd: Minimum 4h sell volume in USD
• min_h4_sellers: Minimum 4h seller count
• min_h4_sells: Minimum 4h sell count
• min_h4_trades: Minimum 4h trade count
• min_h4_volume_in_usd: Minimum 4h volume in USD
• min_m15_buy_volume_in_usd: Minimum 15min buy volume in USD
• min_m15_buyers: Minimum 15min buyer count
• min_m15_buys: Minimum 15min buy count
• min_m15_price_change_ratio: Minimum 15min price change ratio
• min_m15_sell_volume_in_usd: Minimum 15min sell volume in USD
• min_m15_sellers: Minimum 15min seller count
• min_m15_sells: Minimum 15min sell count
• min_m15_trades: Minimum 15min trade count
• min_m15_volume_in_usd: Minimum 15min volume in USD
• min_m1_buy_volume_in_usd: Minimum 1min buy volume in USD
• min_m1_buyers: Minimum 1min buyer count
• min_m1_buys: Minimum 1min buy count
• min_m1_price_change_ratio: Minimum 1min price change ratio
• min_m1_sell_volume_in_usd: Minimum 1min sell volume in USD
• min_m1_sellers: Minimum 1min seller count
• min_m1_sells: Minimum 1min sell count
• min_m1_trades: Minimum 1min trade count
• min_m1_volume_in_usd: Minimum 1min volume in USD
• min_m30_buy_volume_in_usd: Minimum 30min buy volume in USD
• min_m30_buyers: Minimum 30min buyer count
• min_m30_buys: Minimum 30min buy count
• min_m30_price_change_ratio: Minimum 30min price change ratio
• min_m30_sell_volume_in_usd: Minimum 30min sell volume in USD
• min_m30_sellers: Minimum 30min seller count
• min_m30_sells: Minimum 30min sell count
• min_m30_trades: Minimum 30min trade count
• min_m30_volume_in_usd: Minimum 30min volume in USD
• min_m5_buy_volume_in_usd: Minimum 5min buy volume in USD
• min_m5_buyers: Minimum 5min buyer count
• min_m5_buys: Minimum 5min buy count
• min_m5_price_change_ratio: Minimum 5min price change ratio
• min_m5_sell_volume_in_usd: Minimum 5min sell volume in USD
• min_m5_sellers: Minimum 5min seller count
• min_m5_sells: Minimum 5min sell count
• min_m5_trades: Minimum 5min trade count
• min_m5_volume_in_usd: Minimum 5min volume in USD
• sort: Sort direction (asc or desc)
• sort_by: Sort by field

let response = client.list_token()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_h1_buy_volume_in_usd(max_h1_buy_volume_in_usd)
    .max_h1_buyers(max_h1_buyers)
    .max_h1_buys(max_h1_buys)
    .max_h1_price_change_ratio(max_h1_price_change_ratio)
    .max_h1_sell_volume_in_usd(max_h1_sell_volume_in_usd)
    .max_h1_sellers(max_h1_sellers)
    .max_h1_sells(max_h1_sells)
    .max_h1_trades(max_h1_trades)
    .max_h1_volume_in_usd(max_h1_volume_in_usd)
    .max_h24_buy_volume_in_usd(max_h24_buy_volume_in_usd)
    .max_h24_buyers(max_h24_buyers)
    .max_h24_buys(max_h24_buys)
    .max_h24_price_change_ratio(max_h24_price_change_ratio)
    .max_h24_sell_volume_in_usd(max_h24_sell_volume_in_usd)
    .max_h24_sellers(max_h24_sellers)
    .max_h24_sells(max_h24_sells)
    .max_h24_trades(max_h24_trades)
    .max_h24_volume_in_usd(max_h24_volume_in_usd)
    .max_h4_buy_volume_in_usd(max_h4_buy_volume_in_usd)
    .max_h4_buyers(max_h4_buyers)
    .max_h4_buys(max_h4_buys)
    .max_h4_price_change_ratio(max_h4_price_change_ratio)
    .max_h4_sell_volume_in_usd(max_h4_sell_volume_in_usd)
    .max_h4_sellers(max_h4_sellers)
    .max_h4_sells(max_h4_sells)
    .max_h4_trades(max_h4_trades)
    .max_h4_volume_in_usd(max_h4_volume_in_usd)
    .max_m15_buy_volume_in_usd(max_m15_buy_volume_in_usd)
    .max_m15_buyers(max_m15_buyers)
    .max_m15_buys(max_m15_buys)
    .max_m15_price_change_ratio(max_m15_price_change_ratio)
    .max_m15_sell_volume_in_usd(max_m15_sell_volume_in_usd)
    .max_m15_sellers(max_m15_sellers)
    .max_m15_sells(max_m15_sells)
    .max_m15_trades(max_m15_trades)
    .max_m15_volume_in_usd(max_m15_volume_in_usd)
    .max_m1_buy_volume_in_usd(max_m1_buy_volume_in_usd)
    .max_m1_buyers(max_m1_buyers)
    .max_m1_buys(max_m1_buys)
    .max_m1_price_change_ratio(max_m1_price_change_ratio)
    .max_m1_sell_volume_in_usd(max_m1_sell_volume_in_usd)
    .max_m1_sellers(max_m1_sellers)
    .max_m1_sells(max_m1_sells)
    .max_m1_trades(max_m1_trades)
    .max_m1_volume_in_usd(max_m1_volume_in_usd)
    .max_m30_buy_volume_in_usd(max_m30_buy_volume_in_usd)
    .max_m30_buyers(max_m30_buyers)
    .max_m30_buys(max_m30_buys)
    .max_m30_price_change_ratio(max_m30_price_change_ratio)
    .max_m30_sell_volume_in_usd(max_m30_sell_volume_in_usd)
    .max_m30_sellers(max_m30_sellers)
    .max_m30_sells(max_m30_sells)
    .max_m30_trades(max_m30_trades)
    .max_m30_volume_in_usd(max_m30_volume_in_usd)
    .max_m5_buy_volume_in_usd(max_m5_buy_volume_in_usd)
    .max_m5_buyers(max_m5_buyers)
    .max_m5_buys(max_m5_buys)
    .max_m5_price_change_ratio(max_m5_price_change_ratio)
    .max_m5_sell_volume_in_usd(max_m5_sell_volume_in_usd)
    .max_m5_sellers(max_m5_sellers)
    .max_m5_sells(max_m5_sells)
    .max_m5_trades(max_m5_trades)
    .max_m5_volume_in_usd(max_m5_volume_in_usd)
    .min_h1_buy_volume_in_usd(min_h1_buy_volume_in_usd)
    .min_h1_buyers(min_h1_buyers)
    .min_h1_buys(min_h1_buys)
    .min_h1_price_change_ratio(min_h1_price_change_ratio)
    .min_h1_sell_volume_in_usd(min_h1_sell_volume_in_usd)
    .min_h1_sellers(min_h1_sellers)
    .min_h1_sells(min_h1_sells)
    .min_h1_trades(min_h1_trades)
    .min_h1_volume_in_usd(min_h1_volume_in_usd)
    .min_h24_buy_volume_in_usd(min_h24_buy_volume_in_usd)
    .min_h24_buyers(min_h24_buyers)
    .min_h24_buys(min_h24_buys)
    .min_h24_price_change_ratio(min_h24_price_change_ratio)
    .min_h24_sell_volume_in_usd(min_h24_sell_volume_in_usd)
    .min_h24_sellers(min_h24_sellers)
    .min_h24_sells(min_h24_sells)
    .min_h24_trades(min_h24_trades)
    .min_h24_volume_in_usd(min_h24_volume_in_usd)
    .min_h4_buy_volume_in_usd(min_h4_buy_volume_in_usd)
    .min_h4_buyers(min_h4_buyers)
    .min_h4_buys(min_h4_buys)
    .min_h4_price_change_ratio(min_h4_price_change_ratio)
    .min_h4_sell_volume_in_usd(min_h4_sell_volume_in_usd)
    .min_h4_sellers(min_h4_sellers)
    .min_h4_sells(min_h4_sells)
    .min_h4_trades(min_h4_trades)
    .min_h4_volume_in_usd(min_h4_volume_in_usd)
    .min_m15_buy_volume_in_usd(min_m15_buy_volume_in_usd)
    .min_m15_buyers(min_m15_buyers)
    .min_m15_buys(min_m15_buys)
    .min_m15_price_change_ratio(min_m15_price_change_ratio)
    .min_m15_sell_volume_in_usd(min_m15_sell_volume_in_usd)
    .min_m15_sellers(min_m15_sellers)
    .min_m15_sells(min_m15_sells)
    .min_m15_trades(min_m15_trades)
    .min_m15_volume_in_usd(min_m15_volume_in_usd)
    .min_m1_buy_volume_in_usd(min_m1_buy_volume_in_usd)
    .min_m1_buyers(min_m1_buyers)
    .min_m1_buys(min_m1_buys)
    .min_m1_price_change_ratio(min_m1_price_change_ratio)
    .min_m1_sell_volume_in_usd(min_m1_sell_volume_in_usd)
    .min_m1_sellers(min_m1_sellers)
    .min_m1_sells(min_m1_sells)
    .min_m1_trades(min_m1_trades)
    .min_m1_volume_in_usd(min_m1_volume_in_usd)
    .min_m30_buy_volume_in_usd(min_m30_buy_volume_in_usd)
    .min_m30_buyers(min_m30_buyers)
    .min_m30_buys(min_m30_buys)
    .min_m30_price_change_ratio(min_m30_price_change_ratio)
    .min_m30_sell_volume_in_usd(min_m30_sell_volume_in_usd)
    .min_m30_sellers(min_m30_sellers)
    .min_m30_sells(min_m30_sells)
    .min_m30_trades(min_m30_trades)
    .min_m30_volume_in_usd(min_m30_volume_in_usd)
    .min_m5_buy_volume_in_usd(min_m5_buy_volume_in_usd)
    .min_m5_buyers(min_m5_buyers)
    .min_m5_buys(min_m5_buys)
    .min_m5_price_change_ratio(min_m5_price_change_ratio)
    .min_m5_sell_volume_in_usd(min_m5_sell_volume_in_usd)
    .min_m5_sellers(min_m5_sellers)
    .min_m5_sells(min_m5_sells)
    .min_m5_trades(min_m5_trades)
    .min_m5_volume_in_usd(min_m5_volume_in_usd)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;

pub fn get_market_data_multi(&self) -> GetMarketDataMulti<'_>

Token - Market Data (Multi)

Get market data for multiple tokens

Sends a GET request to /v2/token/{chain}/marketData/multi

Arguments:

• chain: A chain name listed in supported networks
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_market_data_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_metadata_multi(&self) -> GetMetadataMulti<'_>

Token - Metadata (Multi)

Get metadata for multiple tokens

Sends a GET request to /v2/token/{chain}/metadata/multi

Arguments:

• chain: A chain name listed in supported networks
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_metadata_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_tokens(&self) -> GetTokens<'_>

Token - Detail (Multi)

Get detail of tokens

Sends a GET request to /v2/token/{chain}/multi

Arguments:

• chain: A chain name listed in supported networks
• filter_by: DTO.TOKEN.REQUEST.FILTER_BY (JSON array of filter conditions)
• sort_by: Sort field
• sort_direction: Sort Direction
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_tokens()
    .chain(chain)
    .filter_by(filter_by)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_pair_candles(&self) -> GetPairCandles<'_>

Pair - Candles

Get OHLCV candlestick data for a trading pair (format: TOKEN_A_ADDRESS-TOKEN_B_ADDRESS)

Sends a GET request to /v2/token/{chain}/pair/{pair}/candles

Arguments:

• chain: A chain name listed in supported networks
• pair: Trading pair identifier (format: TOKEN_A_ADDRESS-TOKEN_B_ADDRESS). The pair will be automatically sorted
• from: Start timestamp (Unix epoch in seconds)
• limit: Number of candles to return
• price_type: Price type: usd (default) or native token price
• resolution: Time resolution for candle data
• to: End timestamp (Unix epoch in seconds)

let response = client.get_pair_candles()
    .chain(chain)
    .pair(pair)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;

pub fn get_pool_candles(&self) -> GetPoolCandles<'_>

Pool - Candles

Get OHLCV candlestick data for a specific liquidity pool

Sends a GET request to /v2/token/{chain}/pool/{poolAddress}/candles

Arguments:

• chain: A chain name listed in supported networks
• pool_address: A pool address
• from: Start timestamp (Unix epoch in seconds)
• limit: Number of candles to return
• price_type: Price type: usd (default) or native token price
• resolution: Time resolution for candle data
• to: End timestamp (Unix epoch in seconds)

let response = client.get_pool_candles()
    .chain(chain)
    .pool_address(pool_address)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;

pub fn get_stats_multi(&self) -> GetStatsMulti<'_>

Token - Stats (Multi)

Get statistics for multiple tokens

Sends a GET request to /v2/token/{chain}/stats/multi

Arguments:

• chain: A chain name listed in supported networks
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_stats_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_token(&self) -> GetToken<'_>

Token - Detail

Get detail of token

Sends a GET request to /v2/token/{chain}/{tokenAddress}

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_token()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_candles(&self) -> GetCandles<'_>

Token - Candles

Get token price candles

Sends a GET request to /v2/token/{chain}/{tokenAddress}/candles

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• from: Start timestamp (Unix epoch in seconds)
• limit: Number of candles to return
• price_type: Price type: usd (default) or native token price
• resolution: Time resolution for candle data
• to: End timestamp (Unix epoch in seconds)

let response = client.get_candles()
    .chain(chain)
    .token_address(token_address)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;

pub fn get_creation(&self) -> GetCreation<'_>

Token - Creation

Get token creation information

Sends a GET request to /v2/token/{chain}/{tokenAddress}/creation

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_creation()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_holder_trend(&self) -> GetHolderTrend<'_>

CONTROLLER.TOKEN.GET_HOLDER_TREND.SUMMARY

CONTROLLER.TOKEN.GET_HOLDER_TREND.DESCRIPTION

Sends a GET request to /v2/token/{chain}/{tokenAddress}/holderTrend

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• from: DTO.TOKEN.HOLDER_TREND.FROM Start timestamp in Unix milliseconds (default: 30 days ago)
• resolution: DTO.TOKEN.HOLDER_TREND.RESOLUTION Aggregation resolution: 1h (default) | 1d
• to: DTO.TOKEN.HOLDER_TREND.TO End timestamp in Unix milliseconds (default: now)

let response = client.get_holder_trend()
    .chain(chain)
    .token_address(token_address)
    .from(from)
    .resolution(resolution)
    .to(to)
    .send()
    .await;

pub fn get_holders(&self) -> GetHolders<'_>

Token - Holders

Get holders of a token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/holders

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_holders()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_holders_multi(&self) -> GetHoldersMulti<'_>

Token - Holders (Multi)

Get holders information for multiple wallet addresses

Sends a GET request to /v2/token/{chain}/{tokenAddress}/holders/multi

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• wallet_addresses: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed

let response = client.get_holders_multi()
    .chain(chain)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;

pub fn get_token_liquidity_snapshots(&self) -> GetTokenLiquiditySnapshots<'_>

Token - Liquidity Snapshots

Retrieve historical liquidity snapshots for a token. If a time parameter is provided, returns the nearest snapshot before or at that time.

Sends a GET request to /v2/token/{chain}/{tokenAddress}/liquiditySnapshots

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• time: Target Unix timestamp for liquidity snapshot query

let response = client.get_token_liquidity_snapshots()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time(time)
    .send()
    .await;

pub fn get_market_data(&self) -> GetMarketData<'_>

Token - Market Cap

Get the market cap of a token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/marketData

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_market_data()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_metadata(&self) -> GetMetadata<'_>

Token - Metadata

Get metadata of token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/metadata

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_metadata()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_mint_and_burn(&self) -> GetMintAndBurn<'_>

Token - Mint and Burn

Get mint and burn information for a token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/mintAndBurn

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• type_: Filter type for mint and burn operations

let response = client.get_mint_and_burn()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .type_(type_)
    .send()
    .await;

pub fn get_pools(&self) -> GetPools<'_>

Token - Pools

Get all pools containing this token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/pools

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• max_tvl_in_sol: Maximum TVL in SOL
• max_tvl_in_usd: Maximum TVL in USD
• min_tvl_in_sol: Minimum TVL in SOL
• min_tvl_in_usd: Minimum TVL in USD
• sort_by: Sort field (tvlInSol or tvlInUsd)
• sort_direction: Sort direction (asc or desc)

let response = client.get_pools()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_tvl_in_sol(max_tvl_in_sol)
    .max_tvl_in_usd(max_tvl_in_usd)
    .min_tvl_in_sol(min_tvl_in_sol)
    .min_tvl_in_usd(min_tvl_in_usd)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .send()
    .await;

pub fn get_price_by_time(&self) -> GetPriceByTime<'_>

Token - Price by Time

Get token price at a specific timestamp

Sends a GET request to /v2/token/{chain}/{tokenAddress}/price

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• timestamp: Price timestamp (Unix epoch in seconds)

let response = client.get_price_by_time()
    .chain(chain)
    .token_address(token_address)
    .timestamp(timestamp)
    .send()
    .await;

pub fn get_prices(&self) -> GetPrices<'_>

Token - Prices

Get historical price data for a token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/prices

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_prices()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_security(&self) -> GetSecurity<'_>

Token - Security

Get token security information

Sends a GET request to /v2/token/{chain}/{tokenAddress}/security

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_security()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_token_similar(&self) -> GetTokenSimilar<'_>

Get tokens similar to the specified token by image or name

Sends a GET request to /v2/token/{chain}/{tokenAddress}/similar

Arguments:

• chain: Chain identifier
• token_address: Token address
• limit: Max results (1-100)
• type_: Similarity type: image or name

let response = client.get_token_similar()
    .chain(chain)
    .token_address(token_address)
    .limit(limit)
    .type_(type_)
    .send()
    .await;

pub fn get_stats(&self) -> GetStats<'_>

Token - Stats

Get token statistics

Sends a GET request to /v2/token/{chain}/{tokenAddress}/stats

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token

let response = client.get_stats()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;

pub fn get_top_holders(&self) -> GetTopHolders<'_>

Token - Top Holders

Get the top 20 holders for a token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/topHolders

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_top_holders()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_token_traders(&self) -> GetTokenTraders<'_>

Token - Get Token Traders

Retrieve traders for a token by tag (fresh, sandwish, bundle, sniper, dev, pro, insider)

Sends a GET request to /v2/token/{chain}/{tokenAddress}/traders/{tag}

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• tag: Token trader tag (fresh, sandwish, bundle, sniper, dev, pro, insider)
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_token_traders()
    .chain(chain)
    .token_address(token_address)
    .tag(tag)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_token_transfer_total(&self) -> GetTokenTransferTotal<'_>

Token - Transfer Total

Get total count of transfers for a specific token with filters

Sends a GET request to /v2/token/{chain}/{tokenAddress}/transfer-total

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• after_timestamp: Filter transfers after this timestamp (Unix epoch seconds)
• before_timestamp: Filter transfers before this timestamp (Unix epoch seconds)

let response = client.get_token_transfer_total()
    .chain(chain)
    .token_address(token_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .send()
    .await;

pub fn get_token_transfers(&self) -> GetTokenTransfers<'_>

Token - Transfer List

Get transfer history for a specific token

Sends a GET request to /v2/token/{chain}/{tokenAddress}/transfers

Arguments:

• chain: A chain name listed in supported networks
• token_address: An address of a token
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• from_timestamp: Start timestamp (Unix epoch in seconds)
• limit: Number of results per page
• to_timestamp: End timestamp (Unix epoch in seconds)

let response = client.get_token_transfers()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .from_timestamp(from_timestamp)
    .limit(limit)
    .to_timestamp(to_timestamp)
    .send()
    .await;

pub fn get_trades(&self) -> GetTrades<'_>

Trade - List

Retrieve a list of token transactions

Sends a GET request to /v2/trade/{chain}

Arguments:

• chain: A chain name listed in supported networks
• after_block_height: Filter trades after this block height
• after_timestamp: End timestamp for filtering trades (Unix epoch in seconds)
• before_block_height: Filter trades before this block height
• before_timestamp: Start timestamp for filtering trades (Unix epoch in seconds)
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• pool_address: A pool address
• token_address: An address of a token
• transactions_signature: Transaction signature/hash
• type_: Trade type filter
• wallet_address: An address of a wallet

let response = client.get_trades()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .pool_address(pool_address)
    .token_address(token_address)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;

pub fn get_activities(&self) -> GetActivities<'_>

Activity - List

Get token activities including trades, liquidity operations, and other token-related activities

Sends a GET request to /v2/trade/{chain}/activities

Arguments:

• chain: A chain name listed in supported networks
• after_block_height: Filter trades after this block height
• after_timestamp: End timestamp for filtering trades (Unix epoch in seconds)
• before_block_height: Filter trades before this block height
• before_timestamp: Start timestamp for filtering trades (Unix epoch in seconds)
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• min_amount_usd: Minimum trade value in USD (inclusive). Filters out small trades.
• pool_address: A pool address
• sort_by: DTO.TRADE.SORT_BY Sort by: timestamp (default) | totalUsd
• token_address: An address of a token
• trader_tags: Filter by trader tag(s). Comma-separated list from: kol, smart, sniper, bundle, dev, bluechip, insider, fresh. Returns activities where the trader has ANY of the specified tags.
• transactions_signature: Transaction signature/hash
• type_: Activity type filter
• wallet_address: An address of a wallet

let response = client.get_activities()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .min_amount_usd(min_amount_usd)
    .pool_address(pool_address)
    .sort_by(sort_by)
    .token_address(token_address)
    .trader_tags(trader_tags)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;

pub fn get_top_traders(&self) -> GetTopTraders<'_>

Trade - Top Traders

Get top traders for a specific token

Sends a GET request to /v2/trade/{chain}/top-traders

Arguments:

• chain: A chain name listed in supported networks
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• sort_by: Field to sort trades by
• sort_type: Sort type for trade results
• time_frame: Time frame for filtering trades
• token_address: An address of a token

let response = client.get_top_traders()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .sort_by(sort_by)
    .sort_type(sort_type)
    .time_frame(time_frame)
    .token_address(token_address)
    .send()
    .await;

pub fn get_trader_gainers_losers(&self) -> GetTraderGainersLosers<'_>

Trader - Gainers/Losers

Get top gainers or losers ranked by PnL

Sends a GET request to /v2/trade/{chain}/trader-gainers-losers

Arguments:

• chain: A chain name listed in supported networks
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• resolution: PnL time resolution (1d, 7d, or 30d)
• sort_type: Sort order (desc for gainers, asc for losers)

let response = client.get_trader_gainers_losers()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .resolution(resolution)
    .sort_type(sort_type)
    .send()
    .await;

pub fn get_gas_limit(&self) -> GetGasLimit<'_>

Transaction - Estimate Gas Limit

Estimate the gas limit for an EVM transaction

Sends a POST request to /v2/transaction/{chain}/estimate-gas-limit

Arguments:

• chain: A chain name listed in supported networks
• body: Gas estimation parameters

let response = client.get_gas_limit()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn get_gas_price(&self) -> GetGasPrice<'_>

Transaction - Gas Price

Get the current gas price for an EVM chain

Sends a GET request to /v2/transaction/{chain}/gas-price

Arguments:

• chain: A chain name listed in supported networks

let response = client.get_gas_price()
    .chain(chain)
    .send()
    .await;

pub fn send(&self) -> Send<'_>

Transaction - Send

Submit a signed transaction to the blockchain

Sends a POST request to /v2/transaction/{chain}/send

Arguments:

• chain: A chain name listed in supported networks
• body: Transaction parameters

let response = client.send()
    .chain(chain)
    .body(body)
    .send()
    .await;

pub fn get_wallet_first_tx(&self) -> GetWalletFirstTx<'_>

Wallet - First Tx Funded

Get the first funded transaction for one or more wallets

Sends a GET request to /v2/wallet/{chain}/first-tx

Arguments:

• chain: A chain name listed in supported networks
• wallet_addresses: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed

let response = client.get_wallet_first_tx()
    .chain(chain)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;

pub fn get_net_worth_summary(&self) -> GetNetWorthSummary<'_>

Wallet - Net Worth Summary (Multi)

Get current net worth summary for multiple wallets

Sends a GET request to /v2/wallet/{chain}/net-worth-summary

Arguments:

• chain: A chain name listed in supported networks
• wallet_addresses: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed

let response = client.get_net_worth_summary()
    .chain(chain)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;

pub fn get_pnl_by_wallet(&self) -> GetPnlByWallet<'_>

Wallet - PnL By Wallet

Get PnL for a specific token across multiple wallets

Sends a GET request to /v2/wallet/{chain}/pnl-by-wallet

Arguments:

• chain: A chain name listed in supported networks
• resolution: DTO.WALLET.PNL_DETAILS.RESOLUTION
• token_address: An address of a token
• wallet_addresses: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed

let response = client.get_pnl_by_wallet()
    .chain(chain)
    .resolution(resolution)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;

pub fn get_balance_updates(&self) -> GetBalanceUpdates<'_>

Wallet - Balance Updates

Get wallet balance change history with filtering and pagination

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/balance-updates

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• change_type: Balance change direction filter (INCREASE or DECREASE)
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• time_from: Start timestamp (Unix epoch in seconds)
• time_to: End timestamp (Unix epoch in seconds)
• token_address: An address of a token
• type_: Balance type filter (SOL for native, SPL for tokens)

let response = client.get_balance_updates()
    .chain(chain)
    .wallet_address(wallet_address)
    .change_type(change_type)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time_from(time_from)
    .time_to(time_to)
    .token_address(token_address)
    .type_(type_)
    .send()
    .await;

pub fn calculate_pnl(&self) -> CalculatePnl<'_>

Wallet - Calculate PNL

Calculate profit and loss for wallet tokens

Sends a POST request to /v2/wallet/{chain}/{walletAddress}/calculate-pnl

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• body

let response = client.calculate_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .body(body)
    .send()
    .await;

pub fn get_net_worth(&self) -> GetNetWorth<'_>

Wallet - Net Worth

Get current net worth of a wallet including all token holdings with prices

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/net-worth

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_net_worth()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_net_worth_chart(&self) -> GetNetWorthChart<'_>

Wallet - Net Worth Chart

Get historical net worth chart data for a wallet with hourly snapshots

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/net-worth-chart

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• hours: DTO.WALLET.NET_WORTH_CHART.HOURS (1-720, default 24)

let response = client.get_net_worth_chart()
    .chain(chain)
    .wallet_address(wallet_address)
    .hours(hours)
    .send()
    .await;

pub fn get_net_worth_details(&self) -> GetNetWorthDetails<'_>

Wallet - Net Worth Details

Get detailed net worth breakdown for a wallet, supporting both real-time and historical snapshots

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/net-worth-details

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• hours: DTO.WALLET.NET_WORTH_DETAILS.HOURS (0=realtime, 1-720=historical snapshot, default 0)
• limit: Number of results per page

let response = client.get_net_worth_details()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .hours(hours)
    .limit(limit)
    .send()
    .await;

pub fn get_net_worth_by_tokens(&self) -> GetNetWorthByTokens<'_>

Wallet - Net Worth By Tokens

Get net worth breakdown by tokens for a wallet

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/net-worth/tokens

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_net_worth_by_tokens()
    .chain(chain)
    .wallet_address(wallet_address)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_pnl(&self) -> GetPnl<'_>

Wallet - PnL Summary

Get aggregated profit and loss summary for a wallet

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/pnl

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• resolution: PnL time resolution (1d, 7d, 30d, or all)

let response = client.get_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .resolution(resolution)
    .send()
    .await;

pub fn get_pnl_by_token(&self) -> GetPnlByToken<'_>

Wallet - PnL By Token

Get PnL for specific tokens in a wallet

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/pnl-by-token

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• resolution: DTO.WALLET.PNL_DETAILS.RESOLUTION
• token_addresses: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed

let response = client.get_pnl_by_token()
    .chain(chain)
    .wallet_address(wallet_address)
    .resolution(resolution)
    .token_addresses(token_addresses)
    .send()
    .await;

pub fn get_pnl_details(&self) -> GetPnlDetails<'_>

Wallet - PnL Details

Get per-token PnL breakdown for a wallet

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/pnl-details

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page
• resolution: DTO.WALLET.PNL_DETAILS.RESOLUTION

let response = client.get_pnl_details()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .resolution(resolution)
    .send()
    .await;

pub fn get_tokens_balance(&self) -> GetTokensBalance<'_>

Wallet - Tokens Balance

Get token balances for a wallet with current prices

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/tokens-balance

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• limit: Number of results per page

let response = client.get_tokens_balance()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;

pub fn get_wallet_transfer_total(&self) -> GetWalletTransferTotal<'_>

Wallet - Transfer Total

Get total count of transfers for a wallet with optional token filter

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/transfer-total

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• from_timestamp: Filter transfers after this timestamp (Unix epoch seconds)
• max_token_amount: Maximum token amount filter (inclusive)
• max_token_amount_in_usd: Maximum token amount in USD filter (inclusive)
• min_token_amount: Minimum token amount filter (inclusive)
• min_token_amount_in_usd: Minimum token amount in USD filter (inclusive)
• to_timestamp: Filter transfers before this timestamp (Unix epoch seconds)
• token_address: An address of a token

let response = client.get_wallet_transfer_total()
    .chain(chain)
    .wallet_address(wallet_address)
    .from_timestamp(from_timestamp)
    .max_token_amount(max_token_amount)
    .max_token_amount_in_usd(max_token_amount_in_usd)
    .min_token_amount(min_token_amount)
    .min_token_amount_in_usd(min_token_amount_in_usd)
    .to_timestamp(to_timestamp)
    .token_address(token_address)
    .send()
    .await;

pub fn get_wallet_transfers(&self) -> GetWalletTransfers<'_>

Wallet - Transfer List

Get transfer history for a wallet with optional token filter

Sends a GET request to /v2/wallet/{chain}/{walletAddress}/transfers

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet
• cursor: Pagination cursor
• direction: Pagination direction (next or prev)
• from_timestamp: Filter transfers after this timestamp (Unix epoch seconds)
• limit: Number of results per page
• max_token_amount: Maximum token amount filter (inclusive)
• max_token_amount_in_usd: Maximum token amount in USD filter (inclusive)
• min_token_amount: Minimum token amount filter (inclusive)
• min_token_amount_in_usd: Minimum token amount in USD filter (inclusive)
• to_timestamp: Filter transfers before this timestamp (Unix epoch seconds)
• token_address: An address of a token

let response = client.get_wallet_transfers()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .from_timestamp(from_timestamp)
    .limit(limit)
    .max_token_amount(max_token_amount)
    .max_token_amount_in_usd(max_token_amount_in_usd)
    .min_token_amount(min_token_amount)
    .min_token_amount_in_usd(min_token_amount_in_usd)
    .to_timestamp(to_timestamp)
    .token_address(token_address)
    .send()
    .await;

pub fn watchlist_add(&self) -> WatchlistAdd<'_>

Watchlist - Add

Add the wallet address to the watchlist. Only the addresses in the watchlist have PNL data

Sends a POST request to /v2/watchlist/{chain}/{walletAddress}

Arguments:

• chain: A chain name listed in supported networks
• wallet_address: An address of a wallet

let response = client.watchlist_add()
    .chain(chain)
    .wallet_address(wallet_address)
    .send()
    .await;

pub fn list_endpoints(&self) -> ListEndpoints<'_>

Endpoint - List

Get list of webhook endpoints

Sends a GET request to /v2/webhook/endpoint

Arguments:

• iterator: Pagination iterator
• limit: Number of results per page
• order: Sort order

let response = client.list_endpoints()
    .iterator(iterator)
    .limit(limit)
    .order(order)
    .send()
    .await;

pub fn create_endpoint(&self) -> CreateEndpoint<'_>

Endpoint - Create

Create a new webhook endpoint

Sends a POST request to /v2/webhook/endpoint

let response = client.create_endpoint()
    .body(body)
    .send()
    .await;

pub fn update_endpoint(&self) -> UpdateEndpoint<'_>

Endpoint - Update

Update webhook endpoint configuration

Sends a PATCH request to /v2/webhook/endpoint

let response = client.update_endpoint()
    .body(body)
    .send()
    .await;

pub fn get_endpoint(&self) -> GetEndpoint<'_>

Endpoint - Get

Get webhook endpoint details

Sends a GET request to /v2/webhook/endpoint/{id}

Arguments:

• id: Endpoint ID

let response = client.get_endpoint()
    .id(id)
    .send()
    .await;

pub fn delete_endpoint(&self) -> DeleteEndpoint<'_>

Endpoint - Delete

Delete a webhook endpoint

Sends a DELETE request to /v2/webhook/endpoint/{id}

Arguments:

• id: Endpoint ID

let response = client.delete_endpoint()
    .id(id)
    .send()
    .await;

pub fn get_endpoint_secret(&self) -> GetEndpointSecret<'_>

Endpoint - Get Secret

Get webhook endpoint secret

Sends a GET request to /v2/webhook/endpoint/{id}/secret

Arguments:

• id: Endpoint ID

let response = client.get_endpoint_secret()
    .id(id)
    .send()
    .await;

pub fn rotate_endpoint_secret(&self) -> RotateEndpointSecret<'_>

Endpoint - Rotate Secret

Rotate the secret key for a webhook endpoint

Sends a POST request to /v2/webhook/endpoint/{id}/secret/rotate

Arguments:

• id: Endpoint ID

let response = client.rotate_endpoint_secret()
    .id(id)
    .send()
    .await;

Trait Implementations

impl ClientHooks for &Client

async fn pre<E>( &self, request: &mut Request, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs prior to the execution of the request. This may be used to modify the request before it is transmitted.

async fn post<E>( &self, result: &Result<Response, Error>, info: &OperationInfo, ) -> Result<(), Error<E>>

Runs after completion of the request.

async fn exec( &self, request: Request, info: &OperationInfo, ) -> Result<Response, Error>

Execute the request. Note that for almost any reasonable implementation this will include code equivalent to this:

impl ClientInfo<()> for Client

fn api_version() -> &'static str

Get the version of this API.

fn baseurl(&self) -> &str

Get the base URL to which requests are made.

fn client(&self) -> &ClientWithMiddleware

Get the internal reqwest_middleware::ClientWithMiddleware used to make requests.

fn inner(&self) -> &()

Get the inner value of type T if one is specified.

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.