Struct DriftClient

pub struct DriftClient {
    pub context: Context,
    pub wallet: Wallet,
    /* private fields */
}

DriftClient

It is cheaply clone-able and consumers are encouraged to do so. It is not recommended to create multiple instances with ::new() as this will not re-use underlying resources such as network connections or memory allocations

The client can be used as is to fetch data ad-hoc over RPC or subscribed to receive live updates (transparently)

let client = DriftClient::new(
    Context::MainNet,
    RpcClient::new("https://rpc.example.com"),
    key_pair.into()
).await.expect("initializes");

// queries over RPC
let sol_perp_price = client.oracle_price(MarketId::perp(0)).await;

// Subscribe to live program changes e.g oracle prices, spot/perp market changes, user accounts
let markets = [MarketId::perp(0), MarketId::spot(2)];
client.subscribe_markets(&markets).await.expect("subscribes");
client.subscribe_oracles(&markets).await.expect("subscribes");

// after subscribing, uses Ws-backed local storage
let sol_perp_price = client.oracle_price(MarketId::perp(0)).await;

client.unsubscribe();

Fields

context: Context

wallet: Wallet

Implementations

impl DriftClient

pub async fn new( context: Context, rpc_client: RpcClient, wallet: Wallet, ) -> SdkResult<Self>

Create a new DriftClient instance

• context - devnet or mainnet
• rpc_client - an RpcClient instance
• wallet - wallet to use for tx signing convenience

pub async fn subscribe_blockhashes(&self) -> SdkResult<()>

Starts background subscriptions for live blockhashes

This is a no-op if already subscribed

pub async fn subscribe_markets(&self, markets: &[MarketId]) -> SdkResult<()>

Starts background subscriptions for live market account updates

• markets - list of markets to subscribe

This is a no-op if already subscribed

pub async fn subscribe_all_markets(&self) -> SdkResult<()>

Subscribe to all spot and perp markets

This is a no-op if already subscribed

pub async fn subscribe_all_spot_markets(&self) -> SdkResult<()>

Subscribe to all spot markets

This is a no-op if already subscribed

pub async fn subscribe_all_perp_markets(&self) -> SdkResult<()>

Subscribe to all perp markets

This is a no-op if already subscribed

pub async fn subscribe_oracles(&self, markets: &[MarketId]) -> SdkResult<()>

Starts background subscriptions for live oracle account updates by market

• markets - list of markets to subscribe for oracle updates

This is a no-op if already subscribed

pub async fn subscribe_all_oracles(&self) -> SdkResult<()>

Subscribe to all oracles

This is a no-op if already subscribed

pub async fn subscribe_all_spot_oracles(&self) -> SdkResult<()>

Subscribe to all spot market oracles

This is a no-op if already subscribed

pub async fn subscribe_all_perp_oracles(&self) -> SdkResult<()>

Subscribe to all perp market oracles

This is a no-op if already subscribed

pub async fn subscribe_swift_orders( &self, markets: &[MarketId], ) -> SdkResult<SwiftOrderStream>

Subscribe to swift order feed(s) for given markets

• markets - list of markets to watch for swift orders

Returns a stream of swift orders

pub fn get_all_spot_market_ids(&self) -> Vec<MarketId>

Returns the MarketIds for all active spot markets (ignores de-listed and settled markets)

Useful for iterating over all spot markets

pub fn get_all_perp_market_ids(&self) -> Vec<MarketId>

Returns the MarketIds for all active perp markets (ignores de-listed and settled markets)

Useful for iterating over all perp markets

pub fn get_all_market_ids(&self) -> Vec<MarketId>

Returns the MarketIds for all active markets (ignores de-listed and settled markets)

Useful for iterating over all markets

pub async fn unsubscribe(&self) -> SdkResult<()>

Unsubscribe from network resources Subsequent queries will pull from the network ad-hoc

This is a no-op if not subscribed

pub fn inner(&self) -> &RpcClient

👎Deprecated

Return a handle to the inner RPC client

pub fn rpc(&self) -> Arc<RpcClient>

Return a handle to the inner RPC client

pub fn ws(&self) -> Arc<PubsubClient>

Return a handle to the inner Ws client

pub fn program_data(&self) -> &ProgramData

Return on-chain program metadata

Useful for inspecting market ids and config

pub async fn get_order_by_id( &self, account: &Pubkey, order_id: u32, ) -> SdkResult<Option<Order>>

Get an account’s open order by id

• account - the drift user PDA
• order_id - order id to query

Returns the Order if it exists

pub async fn get_order_by_user_id( &self, account: &Pubkey, user_order_id: u8, ) -> SdkResult<Option<Order>>

Get an account’s open order by user assigned id

• account - the drift user PDA
• user_order_id - user defined order id to query

Returns the Order if it exists

pub async fn all_orders(&self, account: &Pubkey) -> SdkResult<Vec<Order>>

Get the account’s open orders

• account - the drift user PDA

Returns the list of open orders

pub async fn unsettled_positions( &self, account: &Pubkey, ) -> SdkResult<Vec<PerpPosition>>

Get the account’s unsettled positions

• account - the drift user PDA

Returns the list of unsettled positions

pub async fn all_positions( &self, account: &Pubkey, ) -> SdkResult<(Vec<SpotPosition>, Vec<PerpPosition>)>

Get all the account’s open positions

• account - the drift user PDA

pub async fn perp_position( &self, account: &Pubkey, market_index: u16, ) -> SdkResult<Option<PerpPosition>>

Get a perp position by market

• account - the drift user PDA

Returns the position if it exists

pub async fn spot_position( &self, account: &Pubkey, market_index: u16, ) -> SdkResult<Option<SpotPosition>>

Get a spot position by market

• account - the drift user PDA

Returns the position if it exists

pub fn wallet(&self) -> &Wallet

Return the DriftClient’s wallet

pub async fn get_user_account(&self, account: &Pubkey) -> SdkResult<User>

Get the user account data Uses cached value if subscribed, falls back to network query

• account - the drift user PDA (subaccount)

Returns the deserialized account data (User)

pub async fn get_user_stats(&self, authority: &Pubkey) -> SdkResult<UserStats>

Get a stats account

Returns the deserialized account data (UserStats)

pub async fn get_latest_blockhash(&self) -> SdkResult<Hash>

Get the latest recent_block_hash uses latest cached if subscribed, otherwise falls back to network query

pub async fn get_account_value<T: AccountDeserialize>( &self, account: &Pubkey, ) -> SdkResult<T>

Get some account value deserialized as T Uses cached value if subscribed, falls back to network query

• account - any onchain account

Returns the deserialized account data (User)

pub fn try_get_account<T: AccountDeserialize>( &self, account: &Pubkey, ) -> SdkResult<T>

Try to get account as T using latest local value

requires account was previously subscribed too. like get_account_value without async/network fallback

pub fn state_account(&self) -> SdkResult<State>

Try get the Drift State config account It contains various exchange level config parameters

pub async fn sign_and_send(&self, tx: VersionedMessage) -> SdkResult<Signature>

Sign and send a tx to the network

Returns the signature on success

pub async fn sign_and_send_with_config( &self, tx: VersionedMessage, recent_block_hash: Option<Hash>, config: RpcSendTransactionConfig, ) -> SdkResult<Signature>

Sign and send a tx to the network

• recent_block_hash - some block hash to use for tx signing, if not provided it will be automatically set
• config - custom RPC config to use when submitting the tx

Returns the signature on success

pub async fn get_spot_market_account( &self, market_index: u16, ) -> SdkResult<SpotMarket>

Get spot market account

• market_index - spot market index

uses latest cached value if subscribed, otherwise falls back to network query

pub async fn get_perp_market_account( &self, market_index: u16, ) -> SdkResult<PerpMarket>

Get perp market account

• market_index - perp market index

uses latest cached value if subscribed, otherwise falls back to network query

pub fn try_get_spot_market_account( &self, market_index: u16, ) -> SdkResult<SpotMarket>

Try to spot market account from cache

• market_index - spot market index

Returns error if not subscribed

pub fn try_get_perp_market_account( &self, market_index: u16, ) -> SdkResult<PerpMarket>

Try to get perp market account from cache

• market_index - spot market index

Returns error if not subscribed

pub fn market_lookup(&self, symbol: &str) -> Option<MarketId>

Lookup a market by symbol

This operation is not free so lookups should be reused/cached by the caller

Returns None if symbol does not map to any known market

pub async fn oracle_price(&self, market: MarketId) -> SdkResult<i64>

Get live oracle price for market uses latest cached if subscribed, otherwise falls back to network query

pub async fn init_tx( &self, account: &Pubkey, delegated: bool, ) -> SdkResult<TransactionBuilder<'_>>

Initialize a transaction given a (sub)account address

let tx = client
    .init_tx(&wallet.sub_account(3), false)
    .cancel_all_orders()
    .place_orders(...)
    .build();

Returns a TransactionBuilder for composing the tx

pub async fn get_recent_priority_fees( &self, writable_markets: &[MarketId], window: Option<usize>, ) -> SdkResult<Vec<u64>>

pub fn try_get_oracle_price_data_and_slot( &self, market: MarketId, ) -> Option<Oracle>

Try get the latest oracle data for market

If only the price is required use oracle_price instead

pub async fn get_oracle_price_data_and_slot( &self, market: MarketId, ) -> SdkResult<Oracle>

Get the latest oracle data for market

If only the price is required use oracle_price instead

pub async fn subscribe_account(&self, account: &Pubkey) -> SdkResult<()>

Subscribe to live WebSocket updates for some account

The latest value may be retrieved with client.get_account(..)

let subaccount = Wallet::derive_user_account(authority, 1);
client.subscribe_account(&subaccount).await;
let subaccount_data = client.get_account::<User>(&subaccount);

pub async fn subscribe_account_polled( &self, account: &Pubkey, interval: Duration, ) -> SdkResult<()>

Same as subscribe_account but uses RPC polling

pub fn unsubscribe_account(&self, account: &Pubkey) -> SdkResult<()>

Unsubscribe from updates for account

pub fn check_libs() -> SdkResult<()>

Check IDL and libdrift_ffi_sys version

panics if there’s a mismatch

pub async fn grpc_subscribe( &self, endpoint: String, x_token: String, opts: GrpcSubscribeOpts, ) -> SdkResult<()>

Subscribe to all: markets, oracles, users, and slot updates over gRPC

Updates are transparently handled by the DriftClient and calls to get User accounts, markets, oracles, etc. will utilize the latest cached updates from the gRPC subscription.

use opts to control what is cached by the client. The gRPC connection will always subscribe to all drift accounts regardless.

• endpoint - the gRPC endpoint
• x_token - gRPC authentication X token
• opts - configure callbacks and caching

pub fn grpc_unsubscribe(&self)

Unsubscribe the gRPC connection

Trait Implementations

impl Clone for DriftClient

fn clone(&self) -> DriftClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl UserMargin for DriftClient

fn calculate_perp_buying_power( &self, user: &User, market: &PerpMarket, oracle_price: i64, collateral_buffer: u64, ) -> SdkResult<u128>

Calculate buying power = free collateral / initial margin ratio

Returns buying power in QUOTE_PRECISION units

fn calculate_margin_info(&self, user: &User) -> SdkResult<MarginCalculation>

Calculate the user’s live margin information

fn max_trade_size( &self, user: &Pubkey, market: MarketId, trade_side: PositionDirection, ) -> SdkResult<u64>

Calculate user’s max. trade size in USDC for a given market and direction