crv 0.1.5

Features

REST API Clients

Bindings to the Curve Finance REST APIs at api.curve.finance and prices.curve.finance:

• Pools API - Query all Curve pools across chains
• Volumes API - 24h volumes and base APYs
• Gauges API - Gauge data and CRV rewards
• Lending API - Lending vault information
• Tokens API - Token metadata from pools
• crvUSD API - crvUSD and scrvUSD supply data
• Prices API - Token pricing via prices.curve.finance

Local Router Implementation

A Rust port of the routing algorithm from curve-js:

• Route Finding - Build a graph from pool data and find optimal swap paths
• Calldata Generation - Encode transactions for the on-chain curve-router-ng contract

Note: The Curve REST API does not provide routing endpoints. Like curve-js, our router fetches pool data from the API, builds a local graph, and computes routes client-side.

Installation

[dependencies]
crv = "0.1"
tokio = { version = "1", features = ["full"] }

Quick Start

use crv::Client;

#[tokio::main]
async fn main() -> Result<(), crv::Error> {
    let client = Client::new()?;

    // Get all pools on Ethereum
    let pools = client.pools().get_all_on_chain("ethereum").await?;
    println!("Found {} pools", pools.data.pool_data.len());

    Ok(())
}

Router

The router builds a graph of tokens and pools, then uses depth-first search to find optimal swap routes. This mirrors the approach used by the official curve-js SDK.

How It Works

1. Fetch pool data from the Curve REST API
2. Build a graph where nodes are tokens and edges are pool swaps
3. Find routes using DFS with TVL-based ranking
4. Generate calldata for the on-chain router contract

use crv::Client;

#[tokio::main]
async fn main() -> Result<(), crv::Error> {
    let client = Client::new()?;

    // Build router from pool data (fetches from API)
    let router = client.build_router("ethereum").await?;
    println!("Graph: {} tokens, {} edges",
        router.stats().token_count,
        router.stats().edge_count);

    // Find routes between tokens
    let dai = "0x6B175474E89094C44Da98b954EedeAC495271d0F";
    let usdc = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

    let routes = router.find_routes(dai, usdc);
    println!("Found {} routes", routes.len());

    if let Some(best) = routes.first() {
        println!("Best route: {} hops, min TVL: ${:.0}",
            best.steps.len(), best.min_tvl);

        // Generate calldata for the on-chain router contract
        let calldata = router.encode_swap(best, "1000000000000000000", "990000")?;
        println!("Calldata: {} bytes", calldata.len());

        // Use calldata with ethers/alloy to send transaction to router contract
        let router_addr = router.router_address().unwrap();
        println!("Send to router: {}", router_addr);
    }

    Ok(())
}

Swap Types

The router supports all 9 swap types from curve-router-ng:

Router Contract Addresses

Prices API

Query token prices via the separate prices.curve.finance API:

use crv::PricesClient;

#[tokio::main]
async fn main() -> Result<(), crv::Error> {
    let client = PricesClient::new()?;

    // Get USD price for WETH
    let weth = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
    let price = client.get_usd_price("ethereum", weth).await?;

    Ok(())
}

Terms of Service

This is an unofficial client. By using this library, you agree to comply with Curve Finance Terms of Use.

Disclaimer

This crate is not affiliated with or endorsed by Curve Finance.

License

MIT