Drift SDK

https://docs.rs/drift-rs/latest/drift_rs/
Admin
Drift SDK is a comprehensive client library providing tools for interacting with the Drift protocol,...
Tokens:165,182
Snippets:1,903
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Result::is_ok_and Example

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Example demonstrating the is_ok_and method with a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### Result::is_ok Example

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Example demonstrating the is_ok method.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

--------------------------------

### Configuring GrpcSubscribeOpts

Source: https://docs.rs/drift-rs/latest/drift_rs/grpc/struct.GrpcSubscribeOpts.html?search=

Examples of how to initialize and configure GrpcSubscribeOpts for different subscription needs.

```rust
  // subscribe to all user and users stats accounts
  let opts = GrpcSubscribeOpts::default()
               .usermap_on() // subscribe to ALL user accounts
               .statsmap_on(); // subscribe to ALL user stats accounts

 // cache specific user accounts only and set a new slot callback
 let first_3_subaccounts = (0_u16..3).into_iter().map(|i| wallet.sub_account(i)).collect();
 let opts = GrpcSubscribeOpts::default()
                .user_accounts(first_3_subaccounts);
                .on_slot(move |new_slot| {}) // slot callback
```

--------------------------------

### Result::flatten Examples

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Examples demonstrating the flatten method to remove one level of nesting.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

--------------------------------

### Result::transpose Example

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Example demonstrating the transpose method on a Result containing an Option.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

--------------------------------

### Build Accounts List

Source: https://docs.rs/drift-rs/latest/drift_rs/math/account_list_builder/struct.AccountsListBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Basic usage example for initializing the builder and constructing an accounts list.

```rust
let mut builder = AccountsListBuilder::default();
let accounts_list = builder.try_build(client, user).expect("build accounts");
```

--------------------------------

### AccountSub::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/account_map/struct.AccountSub.html

Starts the subscriber task.

```APIDOC
### AccountSub::subscribe

#### Description
Starts the background task for the subscriber.

#### Signature
`pub async fn subscribe(self, accounts: Arc<DashMap<Pubkey, AccountSlot, RandomState>>) -> SdkResult<AccountSub<Subscribed>>`

#### Parameters
- **accounts** (Arc<DashMap<Pubkey, AccountSlot, RandomState>>) - The map to store account updates.
```

--------------------------------

### subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/websocket_account_subscriber/struct.WebsocketAccountSubscriber.html?search=u32+-%3E+bool

Starts a WebSocket account subscription task.

```APIDOC
### pub async fn subscribe<F>(&self, subscription_name: &'static str, sync: bool, on_update: F) -> SdkResult<UnsubHandle>
where F: 'static + Send + Fn(&AccountUpdate)

Starts a background task to subscribe to account updates. 

- **subscription_name** (&'static str) - A user-defined identifier for the subscription.
- **sync** (bool) - If true, the subscriber will fetch the initial account data upon starting.
- **on_update** (F) - A callback function invoked whenever an account update is received.
```

--------------------------------

### AccountSub::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/account_map/struct.AccountSub.html?search=std%3A%3Avec

Starts the subscriber task.

```APIDOC
## AccountSub::subscribe

### Description
Starts the background task for the subscriber to begin tracking account updates.

### Signature
`pub async fn subscribe(self, accounts: Arc<DashMap<Pubkey, AccountSlot, RandomState>>) -> SdkResult<AccountSub<Subscribed>>`

### Parameters
- **accounts** (Arc<DashMap<Pubkey, AccountSlot, RandomState>>) - The shared map to store account updates.
```

--------------------------------

### Initializing and Using DriftClient

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html

Example showing how to initialize a new DriftClient, perform RPC queries, and manage WebSocket subscriptions for live updates.

```rust
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();
```

--------------------------------

### Subscription Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to start background subscriptions for live updates from the network.

```APIDOC
## Subscription Methods

### Description
These methods initiate background subscriptions for various data feeds. They are no-ops if the client is already subscribed.

### Methods
- **subscribe_markets(&self, markets: &[MarketId]) -> SdkResult<()>**: Subscribes to live market account updates.
- **subscribe_oracles(&self, markets: &[MarketId]) -> SdkResult<()>**: Subscribes to live oracle account updates.
- **subscribe_all_markets(&self) -> SdkResult<()>**: Subscribes to all spot and perp markets.
- **subscribe_all_oracles(&self) -> SdkResult<()>**: Subscribes to all available oracles.
- **subscribe_swift_orders(&self, markets: &[MarketId]) -> SdkResult<SwiftOrderStream>**: Subscribes to swift order feeds for specific markets.
```

--------------------------------

### DriftGrpcClient::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/grpc/grpc_subscriber/struct.DriftGrpcClient.html?search=u32+-%3E+bool

Starts the gRPC subscription process.

```APIDOC
## pub async fn subscribe(self, commitment: CommitmentLevel, subscribe_opts: GeyserSubscribeOpts) -> Result<UnsubHandle, GrpcError>

### Description
Starts the subscription for geyser updates. Returns an `UnsubHandle` on success.

### Parameters
- **commitment** (CommitmentLevel) - The commitment level for the subscription.
- **subscribe_opts** (GeyserSubscribeOpts) - Options for the geyser subscription.
```

--------------------------------

### Result::cloned Examples

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Examples demonstrating the use of cloned on Result types.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### SlotSubscriber Usage Example

Source: https://docs.rs/drift-rs/latest/drift_rs/slot_subscriber/struct.SlotSubscriber.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates initializing a subscriber, registering a callback for slot updates, and retrieving the current slot.

```rust
let slot_subscriber = SlotSubscriber::new("http://rpc.example.com");
slot_subscriber.subscribe(move |slot| {
    dbg!("new slot", slot);
}).expect("subd");

// get latest slot
let latest_slot = slot_subscriber.current_slot();
```

--------------------------------

### Result::is_err Example

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Example demonstrating the is_err method.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Result::copied Examples

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.SdkResult.html

Examples demonstrating the use of copied on Result types.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### BlockhashSubscriber Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/blockhash_subscriber/struct.BlockhashSubscriber.html?search=

Methods for initializing, starting, and querying the blockhash subscriber.

```APIDOC
## BlockhashSubscriber

### new(refresh_frequency: Duration, rpc_client: Arc<RpcClient>) -> Self
Creates a new instance of the blockhash subscriber. Note that the subscriber must be started by calling `subscribe()`.

### subscribe(&self)
Starts the background task to poll for the latest network blockhashes.

### get_latest_blockhash(&self) -> Option<Hash>
Returns the most recent blockhash polled by the subscriber.

### get_valid_blockhash(&self) -> Option<Hash>
Returns the oldest valid blockhash, which is more likely to be finalized.

### unsubscribe(&self)
Stops the blockhash subscriber background task.
```

--------------------------------

### spawn_retry_task Usage Example

Source: https://docs.rs/drift-rs/latest/drift_rs/async_utils/fn.spawn_retry_task.html

Demonstrates how to define a task generator and pass it to spawn_retry_task with a retry policy.

```rust
let task_gen = move || {
    async move {
        1 + 1
    }
};

spawn_retry_task(task_gen, FailFast {})
```

--------------------------------

### subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/websocket_program_account_subscriber/struct.WebsocketProgramAccountSubscriber.html

Starts a GPA (GetProgramAccounts) subscription task.

```APIDOC
## pub fn subscribe<T, F>(&self, subscription_name: &'static str, on_update: F) -> UnsubHandle

### Description
Starts a GPA subscription task. The `subscription_name` is a user-defined identifier for the subscription, and `on_update` is a callback function that handles updates from the subscription task.

### Parameters
- **subscription_name** (&'static str) - A unique identifier for the subscription.
- **on_update** (F) - A closure or function that processes updates of type `ProgramAccountUpdate<T>`.

### Returns
- **UnsubHandle** - A handle used to manage or cancel the subscription.
```

--------------------------------

### Subscription Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html

Methods for starting background subscriptions to live market, oracle, and blockhash updates.

```APIDOC
## Subscription Methods

### Description
These methods initiate background subscriptions to receive live updates from the network. They are no-ops if the client is already subscribed.

### Methods
- **subscribe_blockhashes()** - Subscribes to live blockhashes.
- **subscribe_markets(markets: &[MarketId])** - Subscribes to updates for specific markets.
- **subscribe_all_markets()** - Subscribes to all spot and perp markets.
- **subscribe_oracles(markets: &[MarketId])** - Subscribes to oracle updates for specific markets.
- **subscribe_all_oracles()** - Subscribes to all available oracles.
```

--------------------------------

### Convert FfiResult to References

Source: https://docs.rs/drift-rs/latest/drift_rs/ffi/abi_types/type.FfiResult.html

Examples of converting FfiResult to references using as_ref and as_mut.

```rust
assert_eq!(ROk::<u32, u32>(10).as_ref(), ROk(&10));
assert_eq!(RErr::<u32, u32>(5).as_ref(), RErr(&5));
```

```rust
assert_eq!(ROk::<u32, u32>(10).as_mut(), ROk(&mut 10));
assert_eq!(RErr::<u32, u32>(5).as_mut(), RErr(&mut 5));
```

--------------------------------

### Initialize a transaction with DriftClient

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html

Use init_tx to start building a transaction for a specific subaccount. The returned builder supports chaining operations like canceling or placing orders.

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

--------------------------------

### AuctionSubscriber::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/auction_subscriber/struct.AuctionSubscriber.html

Starts the auction subscription task with a handler function.

```APIDOC
## pub fn subscribe<F>(&self, handler_fn: F)

### Description
Starts the background task to listen for auction events. The provided handler function is invoked for each update.

### Parameters
- **handler_fn** (F) - Required - A function that takes a reference to `ProgramAccountUpdate<User>` and processes the update.
```

--------------------------------

### Subscribe to Account Updates

Source: https://docs.rs/drift-rs/latest/drift_rs/polled_account_subscriber/struct.PolledAccountSubscriber.html?search=

Starts the subscription process and provides a callback for handling account updates, returning a handle for unsubscription.

```rust
pub fn subscribe<F>(&self, on_update: F) -> UnsubHandle
where F: 'static + Send + Fn(&AccountUpdate),
```

--------------------------------

### Initialize Wallet from String

Source: https://docs.rs/drift-rs/latest/drift_rs/wallet/struct.Wallet.html

Shows how to initialize a wallet using either a private key string or a file path.

```rust
// from private key str
let wallet = Wallet::try_from_str("PRIVATE_KEY").unwrap();

// from file path
let wallet = Wallet::try_from_str("/path/to/wallet.json").unwrap();
```

--------------------------------

### Initialize Wallet Variants

Source: https://docs.rs/drift-rs/latest/drift_rs/wallet/struct.Wallet.html

Demonstrates creating different types of wallets including standard, delegated, and read-only configurations.

```rust
// load wallet from base58 private key or path to wallet.json
let wallet = Wallet::try_from_str("PRIVATE_KEY").unwrap();

// construct wallet for delegated signing
let delegated_keypair = solana_sdk::signature::Keypair::new();
let delegated_wallet = Wallet::delegated(delegated_keypair, drift_account_key);

// place holder wallet for readonly apps
let ro_wallet = Wallet::read_only(drift_authority);
```

--------------------------------

### Wallet Initialization Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/wallet/struct.Wallet.html

Methods for creating a Wallet instance from various sources including private keys, file paths, seeds, or existing keypairs.

```APIDOC
## Wallet::try_from_str(path_or_key: &str) -> SdkResult<Self>

### Description
Initializes a wallet from a string representing either a file path to a JSON wallet or a base58 encoded private key.

### Parameters
- **path_or_key** (str) - Required - The file path or base58 private key string.

## Wallet::new(authority: Keypair) -> Self

### Description
Initializes a wallet with a provided Solana Keypair.

### Parameters
- **authority** (Keypair) - Required - The keypair used for transaction signing.

## Wallet::delegated(signer: Keypair, authority: Pubkey) -> Self

### Description
Creates a delegated wallet for signing on behalf of another Drift account.

### Parameters
- **signer** (Keypair) - Required - The delegated keypair for transaction signing.
- **authority** (Pubkey) - Required - The Drift account authority to sign for.
```

--------------------------------

### DriftClient::new

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html?search=std%3A%3Avec

Initializes a new DriftClient instance with the specified context, RPC client, and wallet.

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

### Description
Creates a new DriftClient instance. It is recommended to reuse the client rather than creating multiple instances to share network connections and memory.

### Parameters
- **context** (Context) - Required - The network context (e.g., MainNet, DevNet).
- **rpc_client** (RpcClient) - Required - An initialized RpcClient instance.
- **wallet** (Wallet) - Required - The wallet used for transaction signing.
```

--------------------------------

### BlockhashSubscriber::new

Source: https://docs.rs/drift-rs/latest/drift_rs/blockhash_subscriber/struct.BlockhashSubscriber.html

Creates a new instance of the BlockhashSubscriber. Note that the subscriber must be started by calling the subscribe method.

```APIDOC
## pub fn new(refresh_frequency: Duration, rpc_client: Arc<RpcClient>) -> Self

### Description
Creates a new blockhash subscriber instance. The subscriber must be started by calling `subscribe()` after initialization.

### Parameters
- **refresh_frequency** (Duration) - The frequency at which the subscriber polls for new blockhashes.
- **rpc_client** (Arc<RpcClient>) - The RPC client used to fetch blockhash data.
```

--------------------------------

### Subscribe to Account Updates

Source: https://docs.rs/drift-rs/latest/drift_rs/websocket_account_subscriber/struct.WebsocketAccountSubscriber.html?search=std%3A%3Avec

Starts a websocket subscription task that triggers a callback on account updates. The sync parameter determines if initial account data is fetched upon startup.

```rust
pub async fn subscribe<F>( &self, subscription_name: &'static str, sync: bool, on_update: F, ) -> SdkResult<UnsubHandle>
where F: 'static + Send + Fn(&AccountUpdate),
```

--------------------------------

### Initialize RpcClient

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Constructs an HTTP RpcClient with default settings.

```rust
let url = "http://localhost:8899".to_string();
let client = RpcClient::new(url);
```

--------------------------------

### Try get mutable reference

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.MapOf.html

Attempts to get a mutable reference without blocking. Returns TryResult::Locked if the shard is currently locked.

```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

*map.try_get_mut("Johnny").unwrap() += 1;
assert_eq!(*map.get("Johnny").unwrap(), 22);

let _result1_locking = map.get("Johnny");

let result2 = map.try_get_mut("Johnny");
assert!(result2.is_locked());
```

--------------------------------

### Try get immutable reference

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.MapOf.html

Attempts to get an immutable reference without blocking. Returns TryResult::Locked if the shard is currently locked.

```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

assert_eq!(*map.try_get("Johnny").unwrap(), 21);

let _result1_locking = map.get_mut("Johnny");

let result2 = map.try_get("Johnny");
assert!(result2.is_locked());
```

--------------------------------

### Oneshot Sender Usage

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.UnsubHandle.html?search=

Examples demonstrating the usage of the underlying Sender type from tokio::sync::oneshot.

```rust
use tokio::sync::oneshot;

let (tx, rx) = oneshot::channel();

tokio::spawn(async move {
    if let Err(_) = tx.send(3) {
        println!("the receiver dropped");
    }
});

match rx.await {
    Ok(v) => println!("got = {:?}", v),
    Err(_) => println!("the sender dropped"),
}
```

```rust
use tokio::sync::oneshot;

let (mut tx, rx) = oneshot::channel::<()>();

tokio::spawn(async move {
    drop(rx);
});

tx.closed().await;
println!("the receiver dropped");
```

```rust
use tokio::sync::oneshot;
use tokio::time::{self, Duration};

async fn compute() -> String {
    // Complex computation returning a `String`
}

let (mut tx, rx) = oneshot::channel();

tokio::spawn(async move {
    tokio::select! {
        _ = tx.closed() => {
            // The receiver dropped, no need to do any further work
        }
        value = compute() => {
            // The send can fail if the channel was closed at the exact same
            // time as when compute() finished, so just ignore the failure.
            let _ = tx.send(value);
        }
    }
});

// Wait for up to 10 seconds
let _ = time::timeout(Duration::from_secs(10), rx).await;
```

```rust
use tokio::sync::oneshot;

let (tx, rx) = oneshot::channel();

assert!(!tx.is_closed());

drop(rx);

assert!(tx.is_closed());
assert!(tx.send("never received").is_err());
```

```rust
use tokio::sync::oneshot;

use std::future::poll_fn;

let (mut tx, mut rx) = oneshot::channel::<()>();

tokio::spawn(async move {
    rx.close();
});

poll_fn(|cx| tx.poll_closed(cx)).await;

println!("the receiver dropped");
```

--------------------------------

### simulate_will_auction_params_sanitize

Source: https://docs.rs/drift-rs/latest/drift_rs/ffi/fn.simulate_will_auction_params_sanitize.html

Simulates using the program’s update_perp_auction_params function to determine if an order’s auction params will get sanitized. Returns true if the order’s auctions will get sanitized.

```APIDOC
## Function: simulate_will_auction_params_sanitize

### Description
Simulates using the program’s update_perp_auction_params function to determine if an order’s auction params will get sanitized.

### Signature
`pub fn simulate_will_auction_params_sanitize(order_params: &mut OrderParams, perp_market: &PerpMarket, oracle_price: i64, is_signed_msg: bool) -> SdkResult<bool>`

### Parameters
- **order_params** (&mut OrderParams) - The order parameters to be checked.
- **perp_market** (&PerpMarket) - The perpetual market context.
- **oracle_price** (i64) - The current oracle price.
- **is_signed_msg** (bool) - Flag indicating if the message is signed.

### Returns
- **SdkResult<bool>** - Returns true if the order’s auctions will get sanitized.
```

--------------------------------

### Configuring AccountFilter modes

Source: https://docs.rs/drift-rs/latest/drift_rs/grpc/grpc_subscriber/struct.AccountFilter.html

Demonstrates how to initialize full and partial filters and chain criteria methods.

```rust
// match on discriminator AND memcmp
 let full = AccountFilter::full()
    .with_discriminator(User::DISCRIMINATOR)
    .with_memcmp(..);

// match on discriminator OR accounts
let partial = AccountFilter::partial()
    .with_discriminator(User::DISCRIMINATOR)
    .with_accounts([acc1,acc2])
```

--------------------------------

### Instantiate and use TransactionBuilder

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.TransactionBuilder.html

Demonstrates initializing a transaction builder and chaining operations like cancelling and placing orders before signing and sending.

```rust
use drift_rs::{types::Context, TransactionBuilder, Wallet};

let wallet = Wallet::from_seed_bs58("seed");
let client = DriftClient::new(Context::DevNet, "api.example.com", wallet).await.unwrap();
let account_data = client.get_account(wallet.default_sub_account()).await.unwrap();

let tx = TransactionBuilder::new(client.program_data, wallet.default_sub_account(), account_data.into())
    .cancel_all_orders()
    .place_orders(&[
        NewOrder::default().build(),
        NewOrder::default().build(),
    ])
    .legacy()
    .build();

let signature = client.sign_and_send(tx, &wallet).await?;
```

--------------------------------

### Get program accounts with custom configuration

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves program accounts with advanced filtering, data slicing, and commitment settings.

```rust
let memcmp = RpcFilterType::Memcmp(Memcmp::new(
    0,                                                    // offset
    MemcmpEncodedBytes::Base64(base64_bytes.to_string()), // encoded bytes
));
let config = RpcProgramAccountsConfig {
    filters: Some(vec![
        RpcFilterType::DataSize(128),
        memcmp,
    ]),
    account_config: RpcAccountInfoConfig {
        encoding: Some(UiAccountEncoding::Base64),
        data_slice: Some(UiDataSliceConfig {
            offset: 0,
            length: 5,
        }),
        commitment: Some(CommitmentConfig::processed()),
        min_context_slot: Some(1234),
    },
    with_context: Some(false),
    sort_results: Some(true),
};
let accounts = rpc_client.get_program_accounts_with_config(
    &alice.pubkey(),
    config,
).await?;
```

--------------------------------

### get_account_data

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Gets the raw data associated with an account.

```APIDOC
## get_account_data

### Description
Gets the raw data associated with an account.

### Parameters
- **pubkey** (&Pubkey) - Required - The public key of the account.

### Response
- Result<Vec<u8>, Error>
```

--------------------------------

### try_build

Source: https://docs.rs/drift-rs/latest/drift_rs/math/account_list_builder/struct.AccountsListBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs an accounts list from user positions synchronously. This method relies on the client being already subscribed to all necessary markets and oracles.

```APIDOC
## pub fn try_build(&mut self, client: &DriftClient, user: &User, force_markets: &[MarketId]) -> SdkResult<AccountsList<'_>>

### Description
Constructs an accounts list from user positions synchronously. It relies on the client being subscribed to all the necessary markets and oracles.

### Parameters
- **client** (&DriftClient) - Required - The drift client instance.
- **user** (&User) - Required - The account to build against.
- **force_markets** (&[MarketId]) - Required - Additional market accounts that should be included in the account list.
```

--------------------------------

### Get block production with configuration

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html

Retrieves block production statistics using a custom configuration for epoch and commitment.

```rust
let leader = rpc_client.get_slot_leaders(start_slot, limit).await?;
let leader = leader[0];
let range = RpcBlockProductionConfigRange {
    first_slot: start_slot,
    last_slot: Some(start_slot + limit),
};
let config = RpcBlockProductionConfig {
    identity: Some(leader.to_string()),
    range: Some(range),
    commitment: Some(CommitmentConfig::processed()),
};
let production = rpc_client.get_block_production_with_config(
    config
).await?;
```

--------------------------------

### Create a mock RpcClient

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Initialize a mock RpcClient for testing purposes using a string directive to control success or failure behavior.

```rust
// Create an `RpcClient` that always succeeds
let url = "succeeds".to_string();
let successful_client = RpcClient::new_mock(url);
```

```rust
// Create an `RpcClient` that always fails
let url = "fails".to_string();
let successful_client = RpcClient::new_mock(url);
```

--------------------------------

### DriftGrpcClient Implementation Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/grpc/grpc_subscriber/struct.DriftGrpcClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing, configuring, and managing subscriptions with the DriftGrpcClient.

```rust
pub fn new(endpoint: String, x_token: String) -> Self
```

```rust
pub fn grpc_connection_opts(self, grpc_opts: GrpcConnectionOpts) -> Self
```

```rust
pub fn on_slot<F: Fn(Slot) + Send + Sync + 'static>(&mut self, on_slot: F)
```

```rust
pub fn on_account<T: Fn(&AccountUpdate<'_>) + Send + Sync + 'static>( &mut self, filter: AccountFilter, on_account: T, )
```

```rust
pub async fn subscribe( self, commitment: CommitmentLevel, subscribe_opts: GeyserSubscribeOpts, ) -> Result<UnsubHandle, GrpcError>
```

--------------------------------

### get_max_shred_insert_slot

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Get the max slot seen from after shred insert.

```APIDOC
## get_max_shred_insert_slot

### Description
Get the max slot seen from after shred insert.

### Response
- Result<u64, Error>
```

--------------------------------

### build

Source: https://docs.rs/drift-rs/latest/drift_rs/math/account_list_builder/struct.AccountsListBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs an accounts list from user positions, fetching from RPC as necessary if the client is not already subscribed to the required accounts.

```APIDOC
## pub async fn build(&mut self, client: &DriftClient, user: &User, force_markets: &[MarketId]) -> SdkResult<AccountsList<'_>>

### Description
Constructs an accounts list from user positions, fetching from RPC as necessary. If the client is already subscribed to necessary market/oracles, no network requests are made.

### Parameters
- **client** (&DriftClient) - Required - The drift client instance.
- **user** (&User) - Required - The account to build against.
- **force_markets** (&[MarketId]) - Required - Additional market accounts that should be included in the account list.
```

--------------------------------

### get_max_retransmit_slot

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Get the max slot seen from retransmit stage.

```APIDOC
## get_max_retransmit_slot

### Description
Get the max slot seen from retransmit stage.

### Response
- Result<u64, Error>
```

--------------------------------

### DriftGrpcClient::new

Source: https://docs.rs/drift-rs/latest/drift_rs/grpc/grpc_subscriber/struct.DriftGrpcClient.html?search=

Creates a new instance of the DriftGrpcClient.

```APIDOC
## pub fn new(endpoint: String, x_token: String) -> Self

### Description
Creates a new `DriftGrpcClient` instance. It can be started by calling `subscribe`.

### Parameters
- **endpoint** (String) - The gRPC endpoint address.
- **x_token** (String) - The authentication token.
```

--------------------------------

### get_signatures_for_address

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Get confirmed signatures for transactions involving an address.

```APIDOC
## get_signatures_for_address(address: &Pubkey)

### Description
Retrieves up to 1000 confirmed signatures for transactions involving the specified address, ordered from newest to oldest.

### Parameters
- **address** (&Pubkey) - Required - The address to query.

### Returns
- Result<Vec<RpcConfirmedTransactionStatusWithSignature>, Error> - A list of transaction statuses.
```

--------------------------------

### Constructing RpcClient

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=

Various methods to initialize an RpcClient with different configurations for URL, timeout, and commitment levels.

```rust
let url = "http://localhost:8899".to_string();
let client = RpcClient::new(url);
```

```rust
let url = "http://localhost:8899".to_string();
let commitment_config = CommitmentConfig::processed();
let client = RpcClient::new_with_commitment(url, commitment_config);
```

```rust
let url = "http://localhost::8899".to_string();
let timeout = Duration::from_secs(1);
let client = RpcClient::new_with_timeout(url, timeout);
```

```rust
let url = "http://localhost::8899".to_string();
let timeout = Duration::from_secs(1);
let commitment_config = CommitmentConfig::processed();
let client = RpcClient::new_with_timeout_and_commitment(
    url,
    timeout,
    commitment_config,
);
```

```rust
let url = "http://localhost::8899".to_string();
let timeout = Duration::from_secs(1);
let commitment_config = CommitmentConfig::processed();
let confirm_transaction_initial_timeout = Duration::from_secs(10);
let client = RpcClient::new_with_timeouts_and_commitment(
    url,
    timeout,
    commitment_config,
    confirm_transaction_initial_timeout,
);
```

--------------------------------

### Create a mock RpcClient with custom responses

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Initialize a mock RpcClient with a custom HashMap of RpcRequest responses to override default behavior.

```rust
// Create a mock with a custom response to the `GetBalance` request
let account_balance = 50;
let account_balance_response = json!(Response {
    context: RpcResponseContext { slot: 1, api_version: None },
    value: json!(account_balance),
});

let mut mocks = HashMap::new();
mocks.insert(RpcRequest::GetBalance, account_balance_response);
let url = "succeeds".to_string();
let client = RpcClient::new_mock_with_mocks(url, mocks);
```

--------------------------------

### WebsocketAccountSubscriber::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/websocket_account_subscriber/struct.WebsocketAccountSubscriber.html

Starts a WebSocket account subscription task.

```APIDOC
## pub async fn subscribe<F>(&self, subscription_name: &'static str, sync: bool, on_update: F) -> SdkResult<UnsubHandle>

### Description
Starts a background task to listen for account updates. It optionally fetches the initial account state if sync is enabled and executes the provided callback on updates.

### Parameters
- **subscription_name** (&'static str) - Required - A user-defined identifier for the subscription.
- **sync** (bool) - Required - If true, fetches the account data immediately upon starting the subscription.
- **on_update** (F) - Required - A callback function (Fn(&AccountUpdate)) to be executed when an update is received.
```

--------------------------------

### PriorityFeeSubscriber Initialization Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/priority_fee_subscriber/struct.PriorityFeeSubscriber.html?search=std%3A%3Avec

Methods to create a new instance of the subscriber with or without a custom configuration.

```rust
pub fn new(endpoint: String, writeable_accounts: &[Pubkey]) -> Self
```

```rust
pub fn with_config( rpc_client: RpcClient, writeable_accounts: &[Pubkey], config: PriorityFeeSubscriberConfig, ) -> Self
```

--------------------------------

### BlockhashSubscriber::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/blockhash_subscriber/struct.BlockhashSubscriber.html

Starts the background task for the blockhash subscriber.

```APIDOC
## pub fn subscribe(&self)

### Description
Starts the blockhash subscriber task to begin polling for network blockhashes.
```

--------------------------------

### SlotSubscriber::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/slot_subscriber/struct.SlotSubscriber.html?search=

Starts the slot subscription task with a callback function.

```APIDOC
## pub fn subscribe<F>(&mut self, on_slot: F) -> SdkResult<()>

### Description
Starts the slot subscription task. The provided callback is invoked whenever a new slot update is received.

### Parameters
- **on_slot** (F) - Required - A callback function invoked on new slot updates, where F must be 'static + Send + Fn(SlotUpdate).
```

--------------------------------

### Pubkey Implementation Methods

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.Pubkey.html?search=

Methods for creating and deriving Pubkey instances.

```rust
pub const fn new_from_array(pubkey_array: [u8; 32]) -> Pubkey
```

```rust
pub const fn from_str_const(s: &str) -> Pubkey
```

```rust
pub fn new_unique() -> Pubkey
```

```rust
pub fn create_with_seed( base: &Pubkey, seed: &str, owner: &Pubkey, ) -> Result<Pubkey, PubkeyError>
```

```rust
pub fn find_program_address( seeds: &[&[u8]], program_id: &Pubkey, ) -> (Pubkey, u8)
```

--------------------------------

### PolledAccountSubscriber::subscribe

Source: https://docs.rs/drift-rs/latest/drift_rs/polled_account_subscriber/struct.PolledAccountSubscriber.html

Starts the account subscriber and registers a callback for updates.

```APIDOC
## fn subscribe<F>(&self, on_update: F) -> UnsubHandle
where F: 'static + Send + Fn(&AccountUpdate)

### Description
Starts the account subscriber. Returns a channel for unsubscribing.

### Parameters
- **on_update** (F) - Callback to receive new account values.
```

--------------------------------

### DriftClient::new

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html?search=

Creates a new instance of the DriftClient.

```APIDOC
## DriftClient::new

### Description
Initializes a new DriftClient instance with the specified context, RPC client, and wallet.

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

### Parameters
- **context** (Context) - Required - The network context (e.g., MainNet, DevNet).
- **rpc_client** (RpcClient) - Required - The RPC client instance for network communication.
- **wallet** (Wallet) - Required - The wallet used for transaction signing.
```

--------------------------------

### Initialize and Subscribe to Account Updates

Source: https://docs.rs/drift-rs/latest/drift_rs/websocket_account_subscriber/struct.WebsocketAccountSubscriber.html

Methods for creating a new subscriber instance and initiating an asynchronous subscription task.

```rust
pub fn new( pubsub: Arc<PubsubClient>, pubkey: Pubkey, commitment: CommitmentConfig, ) -> Self
```

```rust
pub async fn subscribe<F>( &self, subscription_name: &'static str, sync: bool, on_update: F, ) -> SdkResult<UnsubHandle>
where F: 'static + Send + Fn(&AccountUpdate),
```

--------------------------------

### PubsubClient::new

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.PubsubClient.html

Creates a new PubsubClient instance connected to the specified URL.

```APIDOC
## pub async fn new(url: &str) -> Result<PubsubClient, PubsubClientError>

### Description
Initializes a new PubsubClient connected to the provided RPC server URL.

### Parameters
- **url** (&str) - Required - The URL of the RPC server to connect to.
```

--------------------------------

### Get block production

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html

Retrieves block production statistics for the current epoch.

```rust
let production = rpc_client.get_block_production().await?;
```

--------------------------------

### Get slot with commitment

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html

Retrieves the slot that has reached a specific commitment level.

```rust
let commitment_config = CommitmentConfig::processed();
let slot = rpc_client.get_slot_with_commitment(commitment_config).await?;
```

--------------------------------

### Get Solana Version

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves the current Solana version running on the node.

```rust
let expected_version = semver::Version::new(1, 7, 0);
let version = rpc_client.get_version().await?;
let version = semver::Version::parse(&version.solana_core)?;
assert!(version >= expected_version);
```

--------------------------------

### init_tx

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.DriftClient.html?search=u32+-%3E+bool

Initializes a transaction builder for the Drift client.

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

### Description
Initializes a new transaction builder for the specified account, with an option to set the delegated status.

### Parameters
- **account** (&Pubkey) - Required - The public key of the account to initialize the transaction for.
- **delegated** (bool) - Required - Whether the transaction is delegated.
```

--------------------------------

### Get Inflation Rate

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves specific inflation values for the current epoch.

```rust
let inflation_rate = rpc_client.get_inflation_rate().await?;
```

--------------------------------

### Get Node Identity

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves the identity public key for the current node.

```rust
let identity = rpc_client.get_identity().await?;
```

--------------------------------

### Implement Off-Chain Client PDA Vault Creation

Source: https://docs.rs/drift-rs/latest/drift_rs/struct.Pubkey.html

Derives the PDA, calculates rent, and sends the transaction to the Solana network.

```rust
fn create_vault_account(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair,
) -> Result<()> {
    // Derive the PDA from the payer account, a string representing the unique
    // purpose of the account ("vault"), and the address of our on-chain program.
    let (vault_pubkey, vault_bump_seed) = Pubkey::find_program_address(
        &[b"vault", payer.pubkey().as_ref()],
        &program_id
    );

    // Get the amount of lamports needed to pay for the vault's rent
    let vault_account_size = usize::try_from(VAULT_ACCOUNT_SIZE)?;
    let lamports = client.get_minimum_balance_for_rent_exemption(vault_account_size)?;

    // The on-chain program's instruction data, imported from that program's crate.
    let instr_data = InstructionData {
        vault_bump_seed,
        lamports,
    };

    // The accounts required by both our on-chain program and the system program's
    // `create_account` instruction, including the vault's address.
    let accounts = vec![
        AccountMeta::new(payer.pubkey(), true),
        AccountMeta::new(vault_pubkey, false),
        AccountMeta::new(system_program::ID, false),
    ];

    // Create the instruction by serializing our instruction data via borsh
    let instruction = Instruction::new_with_borsh(
        program_id,
        &instr_data,
        accounts,
    );

    let blockhash = client.get_latest_blockhash()?;

    let transaction = Transaction::new_signed_with_payer(
        &[instruction],
        Some(&payer.pubkey()),
        &[payer],
        blockhash,
    );

    client.send_and_confirm_transaction(&transaction)?;

    Ok(())
}
```

--------------------------------

### get_signatures_for_address_with_config

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Get confirmed signatures for transactions involving an address with custom configuration.

```APIDOC
## get_signatures_for_address_with_config(address: &Pubkey, config: GetConfirmedSignaturesForAddress2Config)

### Description
Retrieves confirmed signatures for transactions involving an address based on the provided configuration.

### Parameters
- **address** (&Pubkey) - Required - The address to query.
- **config** (GetConfirmedSignaturesForAddress2Config) - Required - Configuration for the query.

### Returns
- Result<Vec<RpcConfirmedTransactionStatusWithSignature>, Error> - A list of transaction statuses.
```

--------------------------------

### Initialize RpcClient with commitment

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Constructs an HTTP RpcClient with a specific commitment configuration.

```rust
let url = "http://localhost:8899".to_string();
let commitment_config = CommitmentConfig::processed();
let client = RpcClient::new_with_commitment(url, commitment_config);
```

--------------------------------

### get_blocks_with_limit

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Returns a list of finalized blocks starting at a given slot with a limit.

```APIDOC
## get_blocks_with_limit(start_slot: u64, limit: usize)

### Description
Returns a list of finalized blocks starting at the given slot, limited by the specified count.

### Parameters
- **start_slot** (u64) - Required - The starting slot.
- **limit** (usize) - Required - The maximum number of blocks to return.

### Returns
- Result<Vec<u64>, Error> - A list of block numbers.
```

--------------------------------

### RpcClient Constructors

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Methods for initializing an RpcClient instance with different configuration options.

```APIDOC
## RpcClient::new(url: String)

### Description
Creates an HTTP RpcClient with a default timeout of 30 seconds and a default commitment level of Finalized.

### Parameters
- **url** (String) - Required - The HTTP URL of the RPC server (e.g., "http://localhost:8899").

## RpcClient::new_with_commitment(url: String, commitment_config: CommitmentConfig)

### Description
Creates an HTTP RpcClient with a specified commitment level and a default timeout of 30 seconds.

### Parameters
- **url** (String) - Required - The HTTP URL of the RPC server.
- **commitment_config** (CommitmentConfig) - Required - The desired commitment level.

## RpcClient::new_with_timeout(url: String, timeout: Duration)

### Description
Creates an HTTP RpcClient with a specified timeout and a default commitment level of Finalized.

### Parameters
- **url** (String) - Required - The HTTP URL of the RPC server.
- **timeout** (Duration) - Required - The request timeout duration.

## RpcClient::new_with_timeout_and_commitment(url: String, timeout: Duration, commitment_config: CommitmentConfig)

### Description
Creates an HTTP RpcClient with both a specified timeout and commitment level.

### Parameters
- **url** (String) - Required - The HTTP URL of the RPC server.
- **timeout** (Duration) - Required - The request timeout duration.
- **commitment_config** (CommitmentConfig) - Required - The desired commitment level.

## RpcClient::new_with_timeouts_and_commitment(url: String, timeout: Duration, commitment_config: CommitmentConfig, confirm_transaction_initial_timeout: Duration)

### Description
Creates an HTTP RpcClient with specified timeouts and commitment level, including a custom initial timeout for transaction confirmation.

### Parameters
- **url** (String) - Required - The HTTP URL of the RPC server.
- **timeout** (Duration) - Required - The request timeout duration.
- **commitment_config** (CommitmentConfig) - Required - The desired commitment level.
- **confirm_transaction_initial_timeout** (Duration) - Required - Time allowed for the server to initially process a transaction.
```

--------------------------------

### Wait for receiver closure

Source: https://docs.rs/drift-rs/latest/drift_rs/types/type.UnsubHandle.html

Examples of checking if the receiver has dropped using closed() and select!.

```rust
use tokio::sync::oneshot;

let (mut tx, rx) = oneshot::channel::<()>();

tokio::spawn(async move {
    drop(rx);
});

tx.closed().await;
println!("the receiver dropped");
```

```rust
use tokio::sync::oneshot;
use tokio::time::{self, Duration};

async fn compute() -> String {
    // Complex computation returning a `String`
}

let (mut tx, rx) = oneshot::channel();

tokio::spawn(async move {
    tokio::select! {
        _ = tx.closed() => {
            // The receiver dropped, no need to do any further work
        }
        value = compute() => {
            // The send can fail if the channel was closed at the exact same
            // time as when compute() finished, so just ignore the failure.
            let _ = tx.send(value);
        }
    }
});

// Wait for up to 10 seconds
let _ = time::timeout(Duration::from_secs(10), rx).await;
```

--------------------------------

### OracleMap::new

Source: https://docs.rs/drift-rs/latest/drift_rs/oraclemap/struct.OracleMap.html

Creates a new instance of OracleMap with the provided PubsubClient and oracle configuration.

```APIDOC
## pub fn new(pubsub_client: Arc<PubsubClient>, all_oracles: &[(MarketId, Pubkey, OracleSource)], commitment: CommitmentConfig) -> Self

### Description
Initializes a new OracleMap instance to track oracle data for specified markets.

### Parameters
- **pubsub_client** (Arc<PubsubClient>) - Required - Shared Pubsub client for WebSocket updates.
- **all_oracles** (&[(MarketId, Pubkey, OracleSource)]) - Required - List of all Drift oracle pubkeys and sources mapped by market.
- **commitment** (CommitmentConfig) - Required - The commitment level for RPC operations.
```

--------------------------------

### Get current slot

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html

Retrieves the current slot based on the configured commitment level.

```rust
let slot = rpc_client.get_slot().await?;
```

--------------------------------

### Get stake minimum delegation

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves the minimum stake delegation amount in lamports.

```rust
let stake_minimum_delegation = rpc_client.get_stake_minimum_delegation().await?;
```

--------------------------------

### Initialize RpcClient with timeout

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Constructs an HTTP RpcClient with a custom timeout duration.

```rust
let url = "http://localhost::8899".to_string();
let timeout = Duration::from_secs(1);
let client = RpcClient::new_with_timeout(url, timeout);
```

--------------------------------

### Get raw account data

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves the raw byte data associated with an account.

```rust
let alice_pubkey = Pubkey::from_str("BgvYtJEfmZYdVKiptmMjxGzv8iQoo4MWjsP3QsTkhhxa").unwrap();
let account_data = rpc_client.get_account_data(&alice_pubkey).await?;
```

--------------------------------

### JitProxyClient::new

Source: https://docs.rs/drift-rs/latest/drift_rs/jit_client/struct.JitProxyClient.html

Creates a new instance of the JitProxyClient.

```APIDOC
## pub fn new(drift_client: DriftClient, config: Option<RpcSendTransactionConfig>, cu_params: Option<ComputeBudgetParams>) -> Self

### Description
Initializes a new JitProxyClient with the provided DriftClient, optional RPC configuration, and compute budget parameters.
```

--------------------------------

### Get max retransmit slot

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves the maximum slot seen from the retransmit stage.

```rust
let slot = rpc_client.get_max_retransmit_slot().await?;
```

--------------------------------

### Get Inflation Reward

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Retrieves inflation rewards for a list of addresses for a specific epoch.

```rust
let addresses = vec![alice.pubkey(), bob.pubkey()];
let inflation_reward = rpc_client.get_inflation_reward(
    &addresses,
    Some(epoch),
).await?;
```

--------------------------------

### Retrieve Block Time

Source: https://docs.rs/drift-rs/latest/drift_rs/event_subscriber/struct.RpcClient.html?search=u32+-%3E+bool

Get the estimated production time for a specific block slot.

```rust
// Get the time of the most recent finalized block
let slot = rpc_client.get_slot().await?;
let block_time = rpc_client.get_block_time(slot).await?;
```
Tokens:
Raw