Rust Examples

The Rust SDK provides type-safe examples demonstrating core CDP SDK functionality with idiomatic Rust patterns and full async/await support.

Setup

Get CDP Credentials

Get your CDP API key and wallet secret from the CDP Portal

Configure Environment

Copy .env.example to .env and add your credentials:

cd examples/rust
cp .env.example .env

Edit .env:

.env

CDP_API_KEY_ID=your_api_key_id
CDP_API_KEY_SECRET=your_api_key_secret
CDP_WALLET_SECRET=your_wallet_secret

Verify Dependencies

cargo check

The Rust SDK requires Rust 1.70 or higher.

Running Examples

Run examples using cargo run --example:

cargo run --example example_name

For example:

cargo run --example wallet_client
cargo run --example evm_account_management
cargo run --example solana_signing

Available Examples

The Rust SDK includes 7 comprehensive examples:

wallet_client - Basic wallet client initialization and usage
evm_account_management - EVM account creation and management
evm_signing - EVM transaction signing examples
smart_account_management - Smart account operations and management
solana_account_management - Solana account creation and management
solana_signing - Solana transaction signing examples
token_balances - Retrieving and displaying token balances

Wallet Client Example

The wallet client example demonstrates basic CDP client initialization and account operations.

wallet_client.rs - Client initialization and basic operations

examples/wallet_client.rs

use cdp_sdk::{auth::WalletAuth, types, Client, Error, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    // Initialize the CDP client
    let wallet_auth = ClientBuilder::new(reqwest::Client::new())
        .with(WalletAuth::default())
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, wallet_auth);

    // Example 1: List EVM accounts
    println!("Listing EVM accounts...");
    let accounts_result = client.list_evm_accounts().send().await;

    match accounts_result {
        Ok(response) => {
            println!("Successfully retrieved accounts: {:?}", response);
        }
        Err(e) => {
            println!("Error listing accounts: {:?}", e);
        }
    }

    // Example 2: Create a new EVM account
    println!("\nCreating a new EVM account...");
    let body = types::CreateEvmAccountBody::builder()
        .name(Some("my-test-account".parse()?));
    
    let create_result = client
        .create_evm_account()
        .x_wallet_auth("") // added by WalletAuth middleware
        .x_idempotency_key("unique-request-id-123")
        .body(body)
        .send()
        .await;

    match create_result {
        Ok(response) => {
            println!("Successfully created account: {:?}", response);
        }
        Err(e) => match e {
            Error::ErrorResponse(err_resp) => {
                println!(
                    "API Error Response: {} - {} {}",
                    err_resp.status(),
                    err_resp.error_type,
                    err_resp.error_message
                );
            }
            _ => {
                println!("Other error: {:?}", e);
            }
        },
    }

    // Example 3: Get account by name
    println!("\nGetting account by name...");
    let get_result = client
        .get_evm_account_by_name()
        .name("my-test-account")
        .send()
        .await;

    match get_result {
        Ok(response) => {
            println!("Successfully retrieved account: {:?}", response);
        }
        Err(e) => {
            println!("Error getting account: {:?}", e);
        }
    }

    // Example 4: List EVM smart accounts
    println!("\nListing EVM smart accounts...");
    let smart_accounts_result = client.list_evm_smart_accounts().send().await;

    match smart_accounts_result {
        Ok(response) => {
            println!("Successfully retrieved smart accounts: {:?}", response);
        }
        Err(e) => {
            println!("Error listing smart accounts: {:?}", e);
        }
    }

    Ok(())
}

What it does:

Initializes CDP client with wallet authentication
Lists existing EVM accounts
Creates a new EVM account with idempotency
Retrieves account by name
Lists smart accounts
Demonstrates error handling patterns

Run: cargo run --example wallet_client

EVM Examples

Account Management

evm_account_management.rs - Complete EVM account lifecycle

examples/evm_account_management.rs

use cdp_sdk::{auth::WalletAuth, types, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    // Initialize the CDP client
    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("🏬 EVM Account Management Example");
    println!("=================================\n");

    // 1. Create a new EVM account
    println!("1. Creating a new EVM account...");
    let create_body = types::CreateEvmAccountBody::builder()
        .name(Some("my-demo-account".parse()?));

    let response = client
        .create_evm_account()
        .x_wallet_auth("")
        .body(create_body)
        .send()
        .await?;

    let account = response.into_inner();
    println!("✅ Created account: {}", &*account.address);
    println!("   Name: {:?}", account.name);

    // 2. Get account by address
    println!("\n2. Retrieving account by address...");
    let get_response = client
        .get_evm_account()
        .address(&*account.address)
        .send()
        .await?;

    let retrieved_account = get_response.into_inner();
    println!("✅ Retrieved account: {}", &*retrieved_account.address);
    println!("   Name: {:?}", retrieved_account.name);

    // 3. Get account by name
    println!("\n3. Retrieving account by name...");
    let get_by_name_response = client
        .get_evm_account_by_name()
        .name("my-demo-account")
        .send()
        .await?;

    let account_by_name = get_by_name_response.into_inner();
    println!("✅ Found account by name: {}", &*account_by_name.address);

    // 4. List all accounts
    println!("\n4. Listing all EVM accounts...");
    let list_response = client
        .list_evm_accounts()
        .page_size(5)
        .send()
        .await?;

    let accounts_list = list_response.into_inner();
    println!("✅ Found {} accounts:", accounts_list.accounts.len());
    for (i, acc) in accounts_list.accounts.iter().enumerate() {
        println!("   {}. {} - {:?}", i + 1, &*acc.address, acc.name);
    }

    // 5. Update account name
    println!("\n5. Updating account name...");
    let update_body = types::UpdateEvmAccountBody::builder()
        .name(Some("my-updated-account".parse()?));

    let update_response = client
        .update_evm_account()
        .address(&*account.address)
        .body(update_body)
        .send()
        .await?;

    let updated_account = update_response.into_inner();
    println!("✅ Updated account name: {:?}", updated_account.name);

    println!("\n🎉 EVM Account Management Complete!");
    Ok(())
}

What it does:

Creates a new EVM account with a name
Retrieves account by address
Retrieves account by name
Lists all accounts with pagination
Updates account name
Demonstrates full CRUD operations

Run: cargo run --example evm_account_management

Transaction Signing

evm_signing.rs - Sign messages and transactions

examples/evm_signing.rs

use cdp_sdk::{auth::WalletAuth, types, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("✍️  EVM Signing Example");
    println!("===================\n");

    // Create an account to use for signing
    let create_body = types::CreateEvmAccountBody::builder()
        .name(Some("signing-demo".parse()?));
    
    let response = client
        .create_evm_account()
        .x_wallet_auth("")
        .body(create_body)
        .send()
        .await?;
    
    let account = response.into_inner();
    println!("✅ Created account: {}\n", &*account.address);

    // Example 1: Sign a message
    println!("1. Signing a message...");
    let message = "Hello from CDP SDK!";
    
    let sign_body = types::SignEvmMessageBody::builder()
        .message(message.to_string());
    
    let sign_response = client
        .sign_evm_message()
        .address(&*account.address)
        .body(sign_body)
        .send()
        .await?;
    
    let signature = sign_response.into_inner();
    println!("✅ Message: {}", message);
    println!("   Signature: {}\n", &*signature.signature);

    // Example 2: Sign a transaction
    println!("2. Signing a transaction...");
    
    // Create a simple transfer transaction (serialized as RLP)
    let transaction = "0x..."; // RLP-encoded transaction
    
    let sign_tx_body = types::SignEvmTransactionBody::builder()
        .transaction(transaction.to_string());
    
    let sign_tx_response = client
        .sign_evm_transaction()
        .address(&*account.address)
        .body(sign_tx_body)
        .send()
        .await;
    
    match sign_tx_response {
        Ok(response) => {
            let signed_tx = response.into_inner();
            println!("✅ Signed transaction: {}", &*signed_tx.signed_transaction);
        }
        Err(e) => {
            println!("⚠️  Transaction signing demo (requires valid RLP): {:?}", e);
        }
    }

    println!("\n🎉 EVM Signing Complete!");
    Ok(())
}

What it does:

Creates an account for signing operations
Signs an arbitrary text message
Demonstrates transaction signing (with RLP-encoded transaction)
Shows signature verification patterns

Run: cargo run --example evm_signing

Smart Accounts

smart_account_management.rs - EIP-4337 smart accounts

examples/smart_account_management.rs

use cdp_sdk::{auth::WalletAuth, types, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("💼 Smart Account Management Example");
    println!("===================================\n");

    // 1. Create an owner account (EOA)
    println!("1. Creating owner account...");
    let owner_body = types::CreateEvmAccountBody::builder()
        .name(Some("smart-account-owner".parse()?));
    
    let owner_response = client
        .create_evm_account()
        .x_wallet_auth("")
        .body(owner_body)
        .send()
        .await?;
    
    let owner = owner_response.into_inner();
    println!("✅ Owner account: {}", &*owner.address);

    // 2. Create a smart account
    println!("\n2. Creating smart account...");
    let smart_account_body = types::CreateEvmSmartAccountBody::builder()
        .owners(vec![owner.address.to_string()])
        .name(Some("my-smart-account".parse()?));
    
    let smart_response = client
        .create_evm_smart_account()
        .body(smart_account_body)
        .send()
        .await?;
    
    let smart_account = smart_response.into_inner();
    println!("✅ Smart account: {}", &*smart_account.address);
    println!("   Owners: {:?}", smart_account.owners);

    // 3. List all smart accounts
    println!("\n3. Listing smart accounts...");
    let list_response = client
        .list_evm_smart_accounts()
        .send()
        .await?;
    
    let smart_accounts = list_response.into_inner();
    println!("✅ Found {} smart accounts", smart_accounts.smart_accounts.len());

    println!("\n🎉 Smart Account Management Complete!");
    println!("\n💡 Smart accounts enable:");
    println!("   • Gasless transactions (sponsored gas)");
    println!("   • Batch operations (multiple calls in one tx)");
    println!("   • Social recovery");
    println!("   • Custom validation logic");
    
    Ok(())
}

What it does:

Creates an EOA (Externally Owned Account) as the smart account owner
Creates an EIP-4337 smart account
Lists all smart accounts
Demonstrates smart account capabilities

Run: cargo run --example smart_account_management

Solana Examples

Account Management

solana_account_management.rs - Solana account operations

examples/solana_account_management.rs

use cdp_sdk::{auth::WalletAuth, types, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("☀️  Solana Account Management Example");
    println!("====================================\n");

    // 1. Create a new Solana account
    println!("1. Creating a new Solana account...");
    let create_body = types::CreateSolanaAccountBody::builder()
        .name(Some("my-solana-account".parse()?));

    let response = client
        .create_solana_account()
        .x_wallet_auth("")
        .body(create_body)
        .send()
        .await?;

    let account = response.into_inner();
    println!("✅ Created Solana account: {}", &*account.address);
    println!("   Name: {:?}", account.name);
    println!("   Created: {:?}", account.created_at);

    // 2. Get account by address
    println!("\n2. Retrieving account by address...");
    let get_response = client
        .get_solana_account()
        .address(&*account.address)
        .send()
        .await?;

    let retrieved_account = get_response.into_inner();
    println!("✅ Retrieved account: {}", &*retrieved_account.address);
    println!("   Name: {:?}", retrieved_account.name);

    // 3. Get account by name
    println!("\n3. Retrieving account by name...");
    let get_by_name_response = client
        .get_solana_account_by_name()
        .name("my-solana-account")
        .send()
        .await?;

    let account_by_name = get_by_name_response.into_inner();
    println!("✅ Found account by name: {}", &*account_by_name.address);

    // 4. List all Solana accounts
    println!("\n4. Listing all Solana accounts...");
    let list_response = client
        .list_solana_accounts()
        .page_size(5)
        .send()
        .await?;

    let accounts_list = list_response.into_inner();
    println!("✅ Found {} Solana accounts:", accounts_list.accounts.len());
    for (i, acc) in accounts_list.accounts.iter().enumerate() {
        println!("   {}. {} - {:?}", i + 1, &*acc.address, acc.name);
    }

    // 5. Update account name
    println!("\n5. Updating account name...");
    let update_body = types::UpdateSolanaAccountBody::builder()
        .name(Some("my-updated-solana-account".parse()?));

    let update_response = client
        .update_solana_account()
        .address(&*account.address)
        .body(update_body)
        .send()
        .await?;

    let updated_account = update_response.into_inner();
    println!("✅ Updated account name: {:?}", updated_account.name);

    println!("\n🎉 Solana Account Management Complete!");
    println!("\n💡 Solana accounts enable:");
    println!("   • Fast, low-cost transactions");
    println!("   • SPL token interactions");
    println!("   • DeFi protocol participation");
    println!("   • NFT minting and trading");
    Ok(())
}

What it does:

Creates a Solana account
Retrieves account by address and name
Lists all Solana accounts
Updates account metadata
Shows Solana-specific features

Run: cargo run --example solana_account_management

Transaction Signing

solana_signing.rs - Sign Solana transactions and messages

examples/solana_signing.rs

use cdp_sdk::{auth::WalletAuth, types, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("✍️  Solana Signing Example");
    println!("======================\n");

    // Create a Solana account for signing
    let create_body = types::CreateSolanaAccountBody::builder()
        .name(Some("solana-signer".parse()?));
    
    let response = client
        .create_solana_account()
        .x_wallet_auth("")
        .body(create_body)
        .send()
        .await?;
    
    let account = response.into_inner();
    println!("✅ Created Solana account: {}\n", &*account.address);

    // Example: Sign a message
    println!("1. Signing a message...");
    let message = "Hello from CDP SDK on Solana!";
    
    let sign_body = types::SignSolanaMessageBody::builder()
        .message(message.to_string());
    
    let sign_response = client
        .sign_solana_message()
        .address(&*account.address)
        .body(sign_body)
        .send()
        .await?;
    
    let signature = sign_response.into_inner();
    println!("✅ Message: {}", message);
    println!("   Signature: {}", &*signature.signature);

    println!("\n🎉 Solana Signing Complete!");
    Ok(())
}

What it does:

Creates a Solana account
Signs an arbitrary message
Returns the signature

Run: cargo run --example solana_signing

Token Balances

token_balances.rs - Query token balances across chains

examples/token_balances.rs

use cdp_sdk::{auth::WalletAuth, Client, CDP_BASE_URL};
use dotenv::dotenv;
use reqwest_middleware::ClientBuilder;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let wallet_auth = WalletAuth::builder().build()?;
    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();
    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    println!("💰 Token Balances Example");
    println!("=======================\n");

    // Create an account
    let create_body = cdp_sdk::types::CreateEvmAccountBody::builder()
        .name(Some("balance-checker".parse()?));
    
    let response = client
        .create_evm_account()
        .x_wallet_auth("")
        .body(create_body)
        .send()
        .await?;
    
    let account = response.into_inner();
    println!("✅ Account: {}\n", &*account.address);

    // List token balances
    println!("Fetching token balances on Base Sepolia...");
    let balances_response = client
        .list_evm_token_balances()
        .address(&*account.address)
        .network("base-sepolia")
        .send()
        .await?;
    
    let balances = balances_response.into_inner();
    
    if balances.balances.is_empty() {
        println!("⚠️  No token balances found");
    } else {
        println!("✅ Found {} token balances:", balances.balances.len());
        for balance in balances.balances.iter() {
            println!("   {} {}", &*balance.amount, &*balance.symbol);
        }
    }

    println!("\n🎉 Token Balances Check Complete!");
    Ok(())
}

What it does:

Creates an EVM account
Queries all token balances on Base Sepolia
Displays balance information

Run: cargo run --example token_balances

Type Safety and Error Handling

The Rust SDK provides strong type safety and ergonomic error handling:

use cdp_sdk::Error;

match result {
    Ok(response) => {
        // Success path
        let data = response.into_inner();
        println!("Success: {:?}", data);
    }
    Err(Error::ErrorResponse(err)) => {
        // API error with details
        println!("API Error: {} - {}", err.error_type, err.error_message);
    }
    Err(e) => {
        // Other errors
        println!("Error: {:?}", e);
    }
}

Full Example List

View all examples in the repository:

Browse Rust Examples

View all Rust examples on GitHub

Next Steps

Rust SDK Reference

Explore the full Rust SDK API

TypeScript Examples

See TypeScript examples

Python Examples

View Python examples

Go Examples

Check Go examples

Get Started

Core Concepts

Guides

Examples

Setup

Running Examples

Available Examples

Wallet Client Example

EVM Examples

Account Management

Transaction Signing

Smart Accounts

Solana Examples

Account Management

Transaction Signing

Token Balances

Type Safety and Error Handling

Full Example List

Browse Rust Examples

Next Steps

Rust SDK Reference

TypeScript Examples

Python Examples

Go Examples

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Examples

​Setup

​Running Examples

​Available Examples

​Wallet Client Example

​EVM Examples

​Account Management

​Transaction Signing

​Smart Accounts

​Solana Examples

​Account Management

​Transaction Signing

​Token Balances

​Type Safety and Error Handling

​Full Example List

Browse Rust Examples

​Next Steps

Rust SDK Reference

TypeScript Examples

Python Examples

Go Examples

Build docs developers (and LLMs) love

Setup

Running Examples

Available Examples

Wallet Client Example

EVM Examples

Account Management

Transaction Signing

Smart Accounts

Solana Examples

Account Management

Transaction Signing

Token Balances

Type Safety and Error Handling

Full Example List

Next Steps