Error Types

pub enum SdkError {
    Rpc(Box<solana_rpc_client_api::client_error::Error>),
    Ws(Box<drift_pubsub_client::PubsubClientError>),
    Anchor(Box<anchor_lang::error::Error>),
    Deserializing,
    InvalidAccount,
    InvalidOracle,
    InvalidSeed,
    InvalidBase58,
    NoPosition(u16),
    OutOfSOL,
    Signing(Box<solana_sdk::signer::SignerError>),
    WebsocketError,
    MissedHeartbeat,
    UnsupportedAccountData,
    CouldntDecode(base64::DecodeError),
    CouldntJoin(tokio::task::JoinError),
    CouldntUnsubscribe,
    MathError(&'static str),
    BorrowMutError(BorrowMutError),
    BorrowError(BorrowError),
    Generic(String),
    MaxReconnectionAttemptsReached,
    JitOrderNotFound,
    NoMarketData(MarketId),
    NoAccountData(Pubkey),
    AlreadySubscribed,
    InvalidUrl,
    WsClient(Box<tungstenite::Error>),
    LibDriftVersion,
    WalletSigningDisabled,
    Grpc(Box<GrpcError>),
}

pub type SdkResult<T> = Result<T, SdkError>;

SdkError::Rpc(Box<solana_rpc_client_api::client_error::Error>)

SdkError::Ws(Box<drift_pubsub_client::PubsubClientError>)

SdkError::Grpc(Box<GrpcError>)

SdkError::InvalidAccount

SdkError::InvalidOracle

SdkError::Deserializing

SdkError::NoPosition(u16)  // market_index

match result {
    Err(SdkError::NoPosition(market_index)) => {
        println!("No position in market {}", market_index);
    }
    Ok(position) => {
        // Use position
    }
    Err(e) => return Err(e),
}

SdkError::NoMarketData(MarketId)

match result {
    Err(SdkError::NoMarketData(market_id)) => {
        println!("Please subscribe to market {:?}", market_id);
    }
    Ok(data) => {
        // Use data
    }
    Err(e) => return Err(e),
}

SdkError::NoAccountData(Pubkey)

SdkError::OutOfSOL

SdkError::Signing(Box<solana_sdk::signer::SignerError>)

SdkError::WalletSigningDisabled

SdkError::MathError(&'static str)  // description

SdkError::AlreadySubscribed

SdkError::CouldntUnsubscribe

SdkError::MissedHeartbeat

SdkError::MaxReconnectionAttemptsReached

SdkError::WebsocketError

SdkError::Generic(String)

SdkError::InvalidSeed

SdkError::JitOrderNotFound

pub fn to_anchor_error_code(&self) -> Option<ProgramError>

if let Some(program_error) = sdk_error.to_anchor_error_code() {
    match program_error {
        ProgramError::Drift(ErrorCode::InsufficientCollateral) => {
            println!("Insufficient collateral for trade");
        }
        ProgramError::Other { ix_idx, code } => {
            println!("Error in instruction {}: code {}", ix_idx, code);
        }
    }
}

pub fn to_out_of_sol_error(&self) -> Option<SdkError>

if let Some(SdkError::OutOfSOL) = sdk_error.to_out_of_sol_error() {
    println!("Need more SOL for transaction fees");
}

pub enum ProgramError {
    Drift(ErrorCode),
    Other { ix_idx: u8, code: u32 },
}

pub enum ErrorCode {
    InvalidSpotMarketAuthority,
    InsufficientDeposit,
    InsufficientCollateral,
    SufficientCollateral,
    MaxNumberOfPositions,
    MarketDelisted,
    UserHasNoPositionInMarket,
    SlippageOutsideLimit,
    OrderSizeTooSmall,
    MathError,
    ExchangePaused,
    InsufficientCollateralForSettlingPnl,
    InvalidOrderNotRiskReducing,
    OrderAmountTooSmall,
    OrderDoesNotExist,
    OrderNotTriggerable,
    OrderMustBeTriggeredFirst,
    OrderNotOpen,
    OrderWouldBeLiquidated,
    UserOrderIdAlreadyInUse,
    // ... many more
}

use drift_rs::{DriftClient, SdkError};

match drift_client.place_perp_order(order_params).await {
    Ok(signature) => {
        println!("Order placed: {}", signature);
    }
    Err(e) => {
        eprintln!("Error placing order: {}", e);
    }
}

match drift_client.place_perp_order(order_params).await {
    Ok(sig) => println!("Success: {}", sig),
    Err(SdkError::OutOfSOL) => {
        println!("Need more SOL for fees");
    }
    Err(SdkError::NoMarketData(market_id)) => {
        println!("Subscribe to market {:?} first", market_id);
    }
    Err(e) => {
        if let Some(program_err) = e.to_anchor_error_code() {
            println!("Program error: {}", program_err);
        } else {
            eprintln!("Other error: {}", e);
        }
    }
}

use drift_rs::SdkError;

let mut retries = 0;
let max_retries = 3;

loop {
    match drift_client.get_user_account(&user_pubkey).await {
        Ok(user) => break Ok(user),
        Err(SdkError::Rpc(_)) if retries < max_retries => {
            retries += 1;
            println!("RPC error, retrying... ({}/{})", retries, max_retries);
            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
        }
        Err(e) => break Err(e),
    }
}