Skip to content

rust

Directory actions

More options

Directory actions

More options

Latest commit

 

History

History
 
 

rust

README.md

Coinbase Developer Platform (CDP) Rust SDK

Crates.io Documentation License: MIT

Table of Contents

Tip

If you're looking to contribute to the SDK, please see the Contributing Guide.

CDP SDK

This module contains the Rust CDP SDK, which is a library that provides a client for interacting with the Coinbase Developer Platform (CDP). It includes a CDP Client for interacting with EVM and Solana APIs to create accounts and send transactions, policy APIs to govern transaction permissions, as well as authentication tools for interacting directly with the CDP APIs.

Documentation

CDP SDK has auto-generated docs for the Rust SDK.

Further documentation is also available on the CDP docs website:

Features

  • 🔐 Automatic Authentication: Built-in JWT-based authentication with support for both API keys and wallet secrets
  • 🚀 Async/Await Support: Fully async API with Tokio runtime
  • 📦 Type-Safe: Generated OpenAPI client with full type safety
  • 🌐 Multi-Chain Support: EVM and Solana blockchain support
  • 🧪 Trait-Based Architecture: Easy testing and mocking with comprehensive trait interfaces

Installation

Warning

While this library is unpublished, if you'd like to use it, you must specify cdp-sdk as a git dependency.

Add this to your Cargo.toml:

[dependencies]
cdp-sdk = { git = "https://github.com/coinbase/cdp-sdk" }
tokio = { version = "1.0", features = ["full"] }

API Keys

To start, create a CDP API Key. Save the API Key ID and API Key Secret for use in the SDK. You will also need to create a wallet secret in the Portal to sign transactions.

Usage

Initialization

Load client config from shell

One option is to export your CDP API Key and Wallet Secret as environment variables:

export CDP_API_KEY_ID="YOUR_API_KEY_ID"
export CDP_API_KEY_SECRET="YOUR_API_KEY_SECRET"
export CDP_WALLET_SECRET="YOUR_WALLET_SECRET"

Then, initialize the client:

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the CDP client using environment variables
    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);

    Ok(())
}

Pass the API Key and Wallet Secret to the client

Another option is to directly pass the API Key and Wallet Secret to the client:

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize with explicit credentials
    let wallet_auth = WalletAuth::builder()
        .api_key_id("your-api-key-id".to_string())
        .api_key_secret("your-api-key-secret".to_string())
        .wallet_secret("your-wallet-secret".to_string())
        .build()?;

    let http_client = ClientBuilder::new(reqwest::Client::new())
        .with(wallet_auth)
        .build();

    let client = Client::new_with_client(CDP_BASE_URL, http_client);

    Ok(())
}

Creating EVM Accounts

Create a new EVM account:

use cdp_sdk::types;

// Create a new EVM account with a name
let body = types::CreateEvmAccountBody::builder()
    .name(Some("my-evm-account".parse()?));

let response = client
    .create_evm_account()
    .x_wallet_auth("") // Added by WalletAuth middleware
    .x_idempotency_key("unique-request-id")
    .body(body)
    .send()
    .await?;

let account = response.into_inner();
println!("Created account: {:?}", account);

Retrieving EVM Accounts

Get account by address:

// Get an account by its address
let response = client
    .get_evm_account()
    .address("0x1234567890123456789012345678901234567890")
    .send()
    .await?;

let account = response.into_inner();
println!("Account: {:?}", account);

Get account by name:

// Get an account by its name
let response = client
    .get_evm_account_by_name()
    .name("my-evm-account")
    .send()
    .await?;

let account = response.into_inner();
println!("Account: {:?}", account);

Updating EVM Accounts

Update an existing EVM account:

use cdp_sdk::types;

// Update an account's name
let update_body = types::UpdateEvmAccountBody::builder()
    .name(Some("updated-account-name".parse()?));

let response = client
    .update_evm_account()
    .address("0x1234567890123456789012345678901234567890")
    .body(update_body)
    .send()
    .await?;

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

Listing EVM Accounts

List all EVM accounts:

// List all EVM accounts with pagination
let response = client
    .list_evm_accounts()
    .page_size(10)
    .send()
    .await?;

let accounts_list = response.into_inner();
println!("Found {} accounts", accounts_list.accounts.len());

for account in accounts_list.accounts {
    println!("Account: {} - {:?}", account.address, account.name);
}

Authentication Tools

This SDK also contains simple tools for authenticating REST API requests to the Coinbase Developer Platform (CDP). The authentication is handled automatically when using the high-level client, but you can access the underlying authentication mechanisms if needed.

Development

Building

make build

Testing

Run all tests (unit + integration):

make test

Run unit tests only:

make test-unit

Run end-to-end tests:

make test-e2e

Linting

make lint

Fix linting issues:

make lint-fix

Code Formatting

make format

Documentation

Generate documentation:

make docs

Other Commands

Clean build artifacts:

make clean

Generate client from OpenAPI spec:

make client

For a full list of available commands:

make help

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

For feature requests, feedback, or questions, please reach out to us in the #cdp-sdk channel of the Coinbase Developer Platform Discord.

Security

If you discover a security vulnerability within this SDK, please see our Security Policy for disclosure information.