Struct DeribitWebSocketClient 

pub struct DeribitWebSocketClient {
    pub config: Arc<WebSocketConfig>,
    pub session: Arc<WebSocketSession>,
    /* private fields */
}

WebSocket client for Deribit

Fields

config: Arc<WebSocketConfig>

WebSocket configuration

session: Arc<WebSocketSession>

WebSocket session

Implementations

impl DeribitWebSocketClient

pub fn new(config: &WebSocketConfig) -> Result<Self, WebSocketError>

Create a new WebSocket client

pub fn new_with_url(ws_url: String) -> Result<Self, WebSocketError>

Create a new WebSocket client with default configuration

pub fn new_testnet() -> Result<Self, WebSocketError>

Create a new WebSocket client for testnet

pub fn new_production() -> Result<Self, WebSocketError>

Create a new WebSocket client for production

pub async fn connect(&self) -> Result<(), WebSocketError>

Connect to the WebSocket server

pub async fn disconnect(&self) -> Result<(), WebSocketError>

Disconnect from the WebSocket server

pub async fn is_connected(&self) -> bool

Check if connected

pub async fn authenticate( &self, client_id: &str, client_secret: &str, ) -> Result<AuthResponse, WebSocketError>

Authenticate with the server

Authenticates the connection using API credentials and returns authentication details including access token and refresh token.

Arguments

• client_id - API client ID
• client_secret - API client secret

Returns

Returns AuthResponse containing access token, token type, expiration, and scope

Errors

Returns an error if authentication fails or credentials are invalid

pub async fn subscribe( &self, channels: Vec<String>, ) -> Result<JsonRpcResponse, WebSocketError>

Subscribe to channels

pub async fn unsubscribe( &self, channels: Vec<String>, ) -> Result<JsonRpcResponse, WebSocketError>

Unsubscribe from channels

pub async fn public_unsubscribe_all(&self) -> Result<String, WebSocketError>

Unsubscribe from all public channels

Unsubscribes from all public channels subscribed so far and clears the local subscription manager state.

Returns

Returns "ok" on success

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn private_unsubscribe_all(&self) -> Result<String, WebSocketError>

Unsubscribe from all private channels

Unsubscribes from all private channels subscribed so far and clears the local subscription manager state. Requires authentication.

Returns

Returns "ok" on success

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn send_request( &self, request: JsonRpcRequest, ) -> Result<JsonRpcResponse, WebSocketError>

Send a JSON-RPC request

pub async fn send_message(&self, message: String) -> Result<(), WebSocketError>

Send a raw message

pub async fn receive_message(&self) -> Result<String, WebSocketError>

Receive a message

pub async fn get_subscriptions(&self) -> Vec<String>

Get active subscriptions

pub async fn test_connection(&self) -> Result<TestResponse, WebSocketError>

Test connection

Tests the WebSocket connection and returns API version information.

Returns

Returns TestResponse containing the API version string

Errors

Returns an error if the connection test fails

pub async fn get_time(&self) -> Result<u64, WebSocketError>

Get server time

Returns the current server timestamp in milliseconds since Unix epoch.

Returns

Returns u64 timestamp in milliseconds

Errors

Returns an error if the request fails

pub async fn set_heartbeat( &self, interval: u64, ) -> Result<String, WebSocketError>

Enable heartbeat with specified interval

The server will send a heartbeat message every interval seconds. If heartbeat is enabled, the server will also send test_request notifications which the client should respond to with public/test to keep the connection alive.

Arguments

• interval - Heartbeat interval in seconds (10-3600)

Returns

Returns "ok" on success

Errors

Returns an error if the request fails or the interval is invalid

pub async fn disable_heartbeat(&self) -> Result<String, WebSocketError>

Disable heartbeat

Stops the server from sending heartbeat messages and test_request notifications.

Returns

Returns "ok" on success

Errors

Returns an error if the request fails

pub async fn hello( &self, client_name: &str, client_version: &str, ) -> Result<HelloResponse, WebSocketError>

Send client identification to the server

This method identifies the client to the server with its name and version. It’s recommended to call this after connecting to provide debugging information.

Arguments

• client_name - Name of the client application
• client_version - Version of the client application

Returns

Returns HelloResponse containing the API version information

Errors

Returns an error if the request fails

pub async fn enable_cancel_on_disconnect( &self, ) -> Result<String, WebSocketError>

Enable automatic order cancellation on disconnect

When enabled, all open orders will be automatically cancelled if the WebSocket connection is lost. This is a safety feature to prevent unintended order execution when the client loses connectivity.

Returns

Returns "ok" on success

Errors

Returns an error if the request fails or requires authentication

pub async fn disable_cancel_on_disconnect( &self, ) -> Result<String, WebSocketError>

Disable automatic order cancellation on disconnect

When disabled, orders will remain active even if the WebSocket connection is lost.

Returns

Returns "ok" on success

Errors

Returns an error if the request fails or requires authentication

pub async fn get_cancel_on_disconnect(&self) -> Result<bool, WebSocketError>

Get current cancel-on-disconnect status

Returns whether automatic order cancellation on disconnect is currently enabled.

Returns

Returns true if cancel-on-disconnect is enabled, false otherwise

Errors

Returns an error if the request fails or requires authentication

pub async fn mass_quote( &self, request: MassQuoteRequest, ) -> Result<MassQuoteResult, WebSocketError>

Place mass quotes

pub async fn cancel_quotes( &self, request: CancelQuotesRequest, ) -> Result<CancelQuotesResponse, WebSocketError>

Cancel quotes

pub async fn set_mmp_config( &self, config: MmpGroupConfig, ) -> Result<(), WebSocketError>

Set MMP group configuration

pub async fn get_mmp_config( &self, mmp_group: Option<String>, ) -> Result<Vec<MmpGroupConfig>, WebSocketError>

Get MMP group configuration

pub async fn reset_mmp( &self, mmp_group: Option<String>, ) -> Result<(), WebSocketError>

Reset MMP group

pub async fn get_open_orders( &self, currency: Option<String>, kind: Option<String>, type_filter: Option<String>, ) -> Result<Vec<QuoteInfo>, WebSocketError>

Get open orders (including quotes)

pub async fn buy( &self, request: OrderRequest, ) -> Result<OrderResponse, WebSocketError>

Place a buy order

Arguments

• request - The order request parameters

Returns

Returns OrderResponse containing order info and any immediate trades

pub async fn sell( &self, request: OrderRequest, ) -> Result<OrderResponse, WebSocketError>

Place a sell order

Arguments

• request - The order request parameters

Returns

Returns OrderResponse containing order info and any immediate trades

pub async fn cancel(&self, order_id: &str) -> Result<OrderInfo, WebSocketError>

Cancel an order by ID

Arguments

• order_id - The order ID to cancel

Returns

Returns OrderInfo for the cancelled order

pub async fn cancel_all(&self) -> Result<u32, WebSocketError>

Cancel all orders

Returns

Returns the number of orders cancelled

pub async fn cancel_all_by_currency( &self, currency: &str, ) -> Result<u32, WebSocketError>

Cancel all orders by currency

Arguments

• currency - Currency to cancel orders for (e.g., “BTC”, “ETH”)

Returns

Returns the number of orders cancelled

pub async fn cancel_all_by_instrument( &self, instrument_name: &str, ) -> Result<u32, WebSocketError>

Cancel all orders by instrument

Arguments

• instrument_name - Instrument name to cancel orders for (e.g., “BTC-PERPETUAL”)

Returns

Returns the number of orders cancelled

pub async fn edit( &self, request: EditOrderRequest, ) -> Result<OrderResponse, WebSocketError>

Edit an existing order

Arguments

• request - The edit order request parameters

Returns

Returns OrderResponse containing updated order info and any trades

pub async fn get_positions( &self, currency: Option<&str>, kind: Option<&str>, ) -> Result<Vec<Position>, WebSocketError>

Get positions for the specified currency and kind

Retrieves user positions filtered by currency and/or instrument kind.

Arguments

• currency - Currency filter (BTC, ETH, USDC, etc.) - optional
• kind - Kind filter (future, option, spot, etc.) - optional

Returns

A vector of positions matching the filter criteria

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn get_account_summary( &self, currency: &str, extended: Option<bool>, ) -> Result<AccountSummary, WebSocketError>

Get account summary for the specified currency

Retrieves account summary information including balance, margin, and other account details.

Arguments

• currency - Currency to get summary for (BTC, ETH, USDC, etc.)
• extended - Whether to include extended information

Returns

Account summary for the specified currency

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn get_order_state( &self, order_id: &str, ) -> Result<OrderInfo, WebSocketError>

Get the state of an order

Retrieves detailed information about a specific order.

Arguments

• order_id - The order ID to get state for

Returns

Order information for the specified order

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn get_order_history_by_currency( &self, currency: &str, kind: Option<&str>, count: Option<u32>, ) -> Result<Vec<OrderInfo>, WebSocketError>

Get order history by currency

Retrieves historical orders for the specified currency.

Arguments

• currency - Currency to get order history for
• kind - Kind filter (future, option, spot, etc.) - optional
• count - Number of items to return - optional

Returns

A vector of historical orders matching the filter criteria

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn close_position( &self, instrument_name: &str, order_type: &str, price: Option<f64>, ) -> Result<ClosePositionResponse, WebSocketError>

Close an existing position

Places a reduce-only order to close an existing position.

Arguments

• instrument_name - The instrument to close position for
• order_type - Order type: “limit” or “market”
• price - Price for limit orders (required if order_type is “limit”)

Returns

Response containing the order and any trades executed

Errors

Returns an error if the request fails or the response cannot be parsed

pub async fn move_positions( &self, currency: &str, source_uid: u64, target_uid: u64, trades: &[MovePositionTrade], ) -> Result<Vec<MovePositionResult>, WebSocketError>

Move positions between subaccounts

Transfers positions from one subaccount to another within the same main account.

Arguments

• currency - Currency for the positions (BTC, ETH, etc.)
• source_uid - Source subaccount ID
• target_uid - Target subaccount ID
• trades - List of positions to move

Returns

A vector of results for each position moved

Errors

Returns an error if the request fails or the response cannot be parsed

pub fn set_message_handler<F, E>( &mut self, message_callback: F, error_callback: E, )

where F: Fn(&str) -> Result<(), WebSocketError> + Send + Sync + 'static, E: Fn(&str, &WebSocketError) + Send + Sync + 'static,

Set message handler with callbacks The message_callback processes each incoming message and returns Result<(), Error> The error_callback is called only when message_callback returns an error

pub fn set_message_handler_builder(&mut self, handler: MessageHandler)

Set message handler using builder pattern

pub fn clear_message_handler(&mut self)

Remove the current message handler

pub fn has_message_handler(&self) -> bool

Check if message handler is set

pub async fn receive_and_process_message(&self) -> Result<(), WebSocketError>

Receive and process a message using the registered callbacks This method will:

1. Receive a message from the WebSocket
2. Call the primary callback with the message
3. If primary callback returns error, call error callback with message and error

pub async fn start_message_processing_loop(&self) -> Result<(), WebSocketError>

Start message processing loop with callbacks This will continuously receive messages and process them using the registered callbacks The loop will continue until an error occurs or the connection is closed

Trait Implementations

impl Debug for DeribitWebSocketClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DeribitWebSocketClient

fn default() -> Self

Returns the “default value” for a type.