Event Subscriber

EventSubscriber

The EventSubscriber provides streaming of Drift protocol events from user sub-accounts. It supports multiple backend implementations: WebSocket, RPC polling, and gRPC.

WebSocket Subscription

pub async fn subscribe(
    ws: Arc<PubsubClient>,
    sub_account: Pubkey,
) -> SdkResult<DriftEventStream>

Subscribe to Drift events using WebSocket-backed logsSubscribe API. Parameters:

ws - Shared PubsubClient instance
sub_account - Pubkey of the user’s sub-account (use Drift Program ID for all program events)

Example:

use std::sync::Arc;
use drift_pubsub_client::PubsubClient;
use futures_util::StreamExt;

let ws = Arc::new(PubsubClient::new("wss://api.mainnet-beta.solana.com").await?);
let sub_account = user_pubkey;

let mut event_stream = EventSubscriber::subscribe(ws, sub_account).await?;

while let Some(event) = event_stream.next().await {
    match event {
        DriftEvent::OrderFill { .. } => { /* handle fill */ },
        DriftEvent::OrderCreate { .. } => { /* handle create */ },
        _ => {}
    }
}

Note: Pass the Drift Program ID dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH to receive events from all sub-accounts.

RPC Polling Subscription

pub fn subscribe_polled(
    provider: impl EventRpcProvider,
    account: Pubkey
) -> DriftEventStream

Subscribe to Drift events by polling RPC APIs. Useful when WebSocket connections are not available. Parameters:

provider - RPC provider implementing EventRpcProvider trait
account - Account pubkey to monitor

Example:

use solana_rpc_client::nonblocking::rpc_client::RpcClient;

let rpc = RpcClient::new("https://api.mainnet-beta.solana.com".to_string());
let event_stream = EventSubscriber::subscribe_polled(rpc, sub_account);

gRPC Subscription

pub async fn subscribe_grpc(
    endpoint: String,
    x_token: String,
    sub_account: Pubkey,
) -> SdkResult<DriftEventStream>

Subscribe to Drift events using high-performance gRPC streaming. Parameters:

endpoint - gRPC server endpoint
x_token - Authentication token
sub_account - Account pubkey to monitor

Example:

let event_stream = EventSubscriber::subscribe_grpc(
    "https://grpc.example.com".to_string(),
    "your-token".to_string(),
    sub_account
).await?;

DriftEventStream

A stream of Drift protocol events implementing the Stream trait.

Methods

unsubscribe

pub fn unsubscribe(&self)

End the event stream and clean up resources. Example:

let event_stream = EventSubscriber::subscribe(ws, sub_account).await?;
// ... process events ...
event_stream.unsubscribe();

DriftEvent

Enum representing all Drift protocol events.

Variants

OrderFill

OrderFill {
    maker: Option<Pubkey>,
    maker_fee: i64,
    maker_order_id: u32,
    maker_side: Option<PositionDirection>,
    taker: Option<Pubkey>,
    taker_fee: u64,
    taker_order_id: u32,
    taker_side: Option<PositionDirection>,
    base_asset_amount_filled: u64,
    quote_asset_amount_filled: u64,
    market_index: u16,
    market_type: MarketType,
    oracle_price: i64,
    signature: String,
    tx_idx: usize,
    ts: u64,
    bit_flags: u8,
}

Emitted when an order is filled.

OrderCreate

OrderCreate {
    order: Order,
    user: Pubkey,
    ts: u64,
    signature: String,
    tx_idx: usize,
}

Emitted when a new order is placed.

OrderCancel

OrderCancel {
    taker: Option<Pubkey>,
    maker: Option<Pubkey>,
    taker_order_id: u32,
    maker_order_id: u32,
    signature: String,
    tx_idx: usize,
    ts: u64,
}

Emitted when an order is cancelled.

OrderExpire

OrderExpire {
    order_id: u32,
    user: Option<Pubkey>,
    fee: u64,
    ts: u64,
    signature: String,
    tx_idx: usize,
}

Emitted when an order expires.

OrderCancelMissing

OrderCancelMissing {
    user_order_id: u8,
    order_id: u32,
    signature: String,
}

Emitted when attempting to cancel a missing order.

FundingPayment

FundingPayment {
    amount: i64,
    market_index: u16,
    user: Pubkey,
    ts: u64,
    signature: String,
    tx_idx: usize,
}

Emitted when a funding payment is processed.

Swap

Swap {
    user: Pubkey,
    amount_in: u64,
    amount_out: u64,
    market_in: u16,
    market_out: u16,
    fee: u64,
    ts: u64,
    signature: String,
    tx_idx: usize,
}

Emitted when a swap is executed.

OrderTrigger

OrderTrigger {
    user: Pubkey,
    order_id: u32,
    oracle_price: u64,
    amount: u64,
}

Emitted when a trigger order is activated.

EventRpcProvider

Trait for custom RPC providers to support polled event subscriptions.

pub trait EventRpcProvider: Send + Sync + 'static {
    fn get_tx_signatures(
        &self,
        account: Pubkey,
        after: Option<Signature>,
        limit: Option<usize>,
    ) -> BoxFuture<'_, SdkResult<Vec<String>>>;
    
    fn get_tx(
        &self,
        signature: Signature,
    ) -> BoxFuture<'_, SdkResult<EncodedTransactionWithStatusMeta>>;
}

Note: RpcClient from solana-rpc-client automatically implements this trait.

Event Parsing

try_parse_log

pub fn try_parse_log(raw: &str, signature: &str, tx_idx: usize) -> Option<DriftEvent>

Manually parse a Drift event from a raw log string. Parameters:

raw - Raw log string from transaction logs
signature - Transaction signature
tx_idx - Index of the log within the transaction

Returns:

Some(DriftEvent) if the log is a valid Drift event
None otherwise

Example:

let log = "Program data: <base64-encoded-event-data>";
if let Some(event) = try_parse_log(log, signature, 0) {
    // Process the parsed event
}

Client

Markets

Oracles

Accounts

Orders & Positions

DLOB

Subscribers

Math

Types