Struct Client 

pub struct Client { /* private fields */ }

Client for interacting with the Enso Finance API

Implementations

impl Client

pub fn new() -> Result<Self>

Create a new client with default configuration

pub fn with_api_key(api_key: impl Into<String>) -> Result<Self>

Create a new client with an API key

pub fn with_config(config: Config) -> Result<Self>

Create a new client with custom configuration

pub fn base(&self) -> &BaseClient

Get the underlying base client

pub fn config(&self) -> &Config

Get the configuration

pub async fn get_route(&self, request: &RouteRequest) -> Result<RouteResponse>

Get optimal route for token swap

Returns the best route for swapping tokens with transaction data.

Arguments

• request - Route request parameters

Example

use enso_api::{Client, Chain, RouteRequest};

#[tokio::main]
async fn main() -> Result<(), enso_api::Error> {
    let client = Client::with_api_key("your-key")?;

    let request = RouteRequest::new(
        1, // Ethereum
        "0xYourAddress",
        "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "1000000000000000000",
        100,
    );

    let route = client.get_route(&request).await?;
    println!("Output: {}", route.amount_out);

    Ok(())
}

pub async fn bundle(&self, request: &BundleRequest) -> Result<BundleResponse>

Bundle multiple DeFi actions into one transaction

Allows combining multiple actions (swap, deposit, stake) into a single transaction.

Arguments

• request - Bundle request with actions

Example

use enso_api::{Client, BundleRequest, BundleAction};

#[tokio::main]
async fn main() -> Result<(), enso_api::Error> {
    let client = Client::with_api_key("your-key")?;

    let actions = vec![
        BundleAction::swap("0xTokenA", "0xTokenB", "1000000"),
    ];

    let request = BundleRequest::new(1, "0xYourAddress", actions);
    let bundle = client.bundle(&request).await?;

    println!("Send to: {}", bundle.tx.to);

    Ok(())
}

pub async fn get_token_price( &self, chain_id: u64, token: &str, ) -> Result<TokenPrice>

Get token price

Arguments

• chain_id - Chain ID
• token - Token address

pub async fn get_balances( &self, chain_id: u64, address: &str, ) -> Result<Vec<TokenBalance>>

Get token balances for address

Arguments

• chain_id - Chain ID
• address - Wallet address

Trait Implementations

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.