Carrot SDK

A Rust SDK for interacting with the Carrot Protocol on Solana. This SDK provides a simple interface for depositing stablecoins (USDC, USDT, pyUSD) and withdrawing CRT tokens.

Features

Deposit stablecoins (USDC, USDT, pyUSD) to receive CRT tokens
Withdraw CRT tokens to receive stablecoins
Automatic ATA (Associated Token Account) creation
Simple, Anchor-free implementation using core Solana libraries

Installation

Add this to your Cargo.toml:

[dependencies]
carrot-sdk = "0.1.0"

Usage

Basic Example - Deposit USDC

use carrot_sdk::{CarrotClient, USDC_MINT};
use solana_sdk::signature::Keypair;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client with RPC URL
    let rpc_url = "https://api.mainnet-beta.solana.com".to_string();
    let client = CarrotClient::new(rpc_url);
    
    // Load your keypair
    let keypair = Keypair::new(); // or read_keypair_file()
    
    // Deposit 1 USDC (6 decimals)
    let amount = 1_000_000u64;
    let signature = client.deposit(&keypair, &USDC_MINT, amount)?;
    
    println!("Deposit successful! Signature: {}", signature);
    Ok(())
}

Withdraw CRT

use carrot_sdk::{CarrotClient, USDC_MINT};
use solana_sdk::signature::Keypair;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rpc_url = "https://api.mainnet-beta.solana.com".to_string();
    let client = CarrotClient::new(rpc_url);
    let keypair = Keypair::new();
    
    // Withdraw 0.5 CRT (9 decimals)
    let amount = 500_000_000u64;
    let signature = client.withdraw(&keypair, &USDC_MINT, amount)?;
    
    println!("Withdrawal successful! Signature: {}", signature);
    Ok(())
}

Check Balances

use carrot_sdk::{CarrotClient, USDC_MINT};
use solana_sdk::pubkey::Pubkey;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rpc_url = "https://api.mainnet-beta.solana.com".to_string();
    let client = CarrotClient::new(rpc_url);
    let user = Pubkey::new_unique();
    
    // Check USDC balance
    let usdc_balance = client.get_asset_balance(&user, &USDC_MINT)?;
    println!("USDC: {} USDC", usdc_balance as f64 / 1_000_000.0);
    
    // Check CRT balance
    let crt_balance = client.get_crt_balance(&user)?;
    println!("CRT: {} CRT", crt_balance as f64 / 1_000_000_000.0);
    
    Ok(())
}

Convenience Functions

The SDK provides convenience functions for common operations:

use carrot_sdk::{deposit_usdc, withdraw_crt};
use solana_sdk::signature::Keypair;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rpc_url = "https://api.mainnet-beta.solana.com".to_string();
    let keypair = Keypair::new();
    
    // Deposit 1 USDC
    let sig = deposit_usdc(rpc_url.clone(), &keypair, 1_000_000)?;
    println!("Deposited: {}", sig);
    
    // Withdraw 0.5 CRT
    let sig = withdraw_crt(rpc_url, &keypair, 500_000_000)?;
    println!("Withdrew: {}", sig);
    
    Ok(())
}

Running Examples

The SDK includes example programs that demonstrate real-world usage:

Deposit Example

Deposits 1 USDC to the Carrot Protocol:

cargo run --example deposit

Withdraw Example

Withdraws half of your CRT balance:

cargo run --example withdraw

Important Constants

The SDK provides pre-configured constants for mainnet:

use carrot_sdk::*;

// Program and addresses
CARROT_PROGRAM_ID  // CarrotwivhMpDnm27EHmRLeQ683Z1PufuqEmBZvD282s
VAULT_ADDRESS      // FfCRL34rkJiMiX5emNDrYp3MdWH2mES3FvDQyFppqgpJ

// Token mints
CRT_MINT          // CRTx1JouZhzSU6XytsE42UQraoGqiHgxabocVfARTy2s
USDC_MINT         // EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
USDT_MINT         // Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB
PYUSD_MINT        // 2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo

Token Decimals

USDC: 6 decimals (1 USDC = 1,000,000)
USDT: 6 decimals (1 USDT = 1,000,000)
pyUSD: 6 decimals (1 pyUSD = 1,000,000)
CRT: 9 decimals (1 CRT = 1,000,000,000)

API Reference

CarrotClient

Main client for interacting with Carrot Protocol.

Methods

new(rpc_url: String) -> Self - Create a new client
deposit(user: &Keypair, asset_mint: &Pubkey, amount: u64) -> Result<Signature> - Deposit assets
withdraw(user: &Keypair, asset_mint: &Pubkey, amount: u64) -> Result<Signature> - Withdraw assets
get_asset_balance(user: &Pubkey, asset_mint: &Pubkey) -> Result<u64> - Check asset balance
get_crt_balance(user: &Pubkey) -> Result<u64> - Check CRT balance
fetch_vault() -> Result<Vault> - Fetch vault data from blockchain

Error Handling

The SDK uses a custom error type that wraps common Solana and token errors:

use carrot_sdk::CarrotError;

match client.deposit(&keypair, &USDC_MINT, amount) {
    Ok(sig) => println!("Success: {}", sig),
    Err(CarrotError::InsufficientBalance { required, available }) => {
        println!("Need {} but only have {}", required, available);
    }
    Err(e) => println!("Error: {}", e),
}

Testing

Run the test suite:

cargo test

The tests verify:

Vault PDA derivation
ATA address derivation
Program ID and constant correctness

Dependencies

This SDK uses the following Solana crates:

solana-sdk = "2.3.1"
solana-client = "2.3.2"
spl-token = "8.0.0"
spl-associated-token-account = "7.0.0"
borsh = "1.5.7"

License

MIT

Support

For issues and questions, please open an issue on GitHub.

carrot-sdk 0.1.0