Struct LightconeWebSocketClient 

pub struct LightconeWebSocketClient { /* private fields */ }

Main WebSocket client for Lightcone

Example

use lightcone_sdk::websocket::*;
use futures_util::StreamExt;

#[tokio::main]
async fn main() -> Result<(), WebSocketError> {
    let mut client = LightconeWebSocketClient::connect("ws://api.lightcone.xyz:8081/ws").await?;

    client.subscribe_book_updates(vec!["market1:ob1".to_string()]).await?;

    while let Some(event) = client.next().await {
        match event {
            WsEvent::BookUpdate { orderbook_id, is_snapshot } => {
                if let Some(book) = client.get_orderbook(&orderbook_id) {
                    println!("Best bid: {:?}", book.best_bid());
                }
            }
            _ => {}
        }
    }
    Ok(())
}

Implementations

impl LightconeWebSocketClient

pub async fn connect_default() -> WsResult<Self>

Connect to the default Lightcone WebSocket server.

Uses the URL wss://ws.lightcone.xyz/ws.

Example

let client = LightconeWebSocketClient::connect_default().await?;
client.subscribe_book_updates(vec!["ob1".to_string()]).await?;

pub async fn connect(url: &str) -> WsResult<Self>

Connect to a WebSocket server with default configuration

pub async fn connect_authenticated(signing_key: &SigningKey) -> WsResult<Self>

Connect to the default Lightcone WebSocket server with authentication.

This method:

1. Authenticates with the Lightcone API using the provided signing key
2. Obtains an auth token
3. Connects to the WebSocket server with the auth token

Arguments

• signing_key - The Ed25519 signing key for authentication

Example

use ed25519_dalek::SigningKey;

let signing_key = SigningKey::from_bytes(&secret_key_bytes);
let client = LightconeWebSocketClient::connect_authenticated(&signing_key).await?;
client.subscribe_user(pubkey.to_string()).await?;

pub async fn connect_authenticated_with_config( signing_key: &SigningKey, config: WebSocketConfig, ) -> WsResult<Self>

Connect to the default Lightcone WebSocket server with authentication and custom config.

pub async fn connect_with_auth(url: &str, auth_token: String) -> WsResult<Self>

Connect to a WebSocket server with a pre-obtained auth token.

Use this if you already have an auth token from a previous authentication.

Arguments

• url - The WebSocket URL to connect to
• auth_token - The auth token obtained from authentication

pub async fn connect_with_config( url: &str, config: WebSocketConfig, ) -> WsResult<Self>

Connect to a WebSocket server with custom configuration

pub async fn subscribe_book_updates( &mut self, orderbook_ids: Vec<String>, ) -> WsResult<()>

Subscribe to orderbook updates

pub async fn subscribe_trades( &mut self, orderbook_ids: Vec<String>, ) -> WsResult<()>

Subscribe to trade executions

pub async fn subscribe_user(&mut self, user: String) -> WsResult<()>

Subscribe to user events

pub async fn subscribe_price_history( &mut self, orderbook_id: String, resolution: String, include_ohlcv: bool, ) -> WsResult<()>

Subscribe to price history

pub async fn subscribe_market(&mut self, market_pubkey: String) -> WsResult<()>

Subscribe to market events

pub async fn unsubscribe_book_updates( &mut self, orderbook_ids: Vec<String>, ) -> WsResult<()>

Unsubscribe from orderbook updates

pub async fn unsubscribe_trades( &mut self, orderbook_ids: Vec<String>, ) -> WsResult<()>

Unsubscribe from trades

pub async fn unsubscribe_user(&mut self, user: String) -> WsResult<()>

Unsubscribe from user events

pub async fn unsubscribe_price_history( &mut self, orderbook_id: String, resolution: String, ) -> WsResult<()>

Unsubscribe from price history

pub async fn unsubscribe_market( &mut self, market_pubkey: String, ) -> WsResult<()>

Unsubscribe from market events

pub async fn ping(&mut self) -> WsResult<()>

Send a ping request

pub async fn disconnect(&mut self) -> WsResult<()>

Disconnect from the server

pub fn is_task_running(&self) -> bool

Check if the connection task is still running

pub fn connection_state(&self) -> ConnectionState

Get the current connection state

pub fn is_connected(&self) -> bool

Check if connected

pub fn is_authenticated(&self) -> bool

Check if the connection is authenticated

pub fn auth_credentials(&self) -> Option<&AuthCredentials>

Get the authentication credentials if available

pub fn user_pubkey(&self) -> Option<&str>

Get the user’s public key if authenticated

pub async fn get_orderbook(&self, orderbook_id: &str) -> Option<LocalOrderbook>

Get a reference to the local orderbook state.

pub async fn get_user_state(&self, user: &str) -> Option<UserState>

Get a reference to the local user state.

pub async fn get_price_history( &self, orderbook_id: &str, resolution: &str, ) -> Option<PriceHistory>

Get a reference to the price history state.

pub fn url(&self) -> &str

Get the WebSocket URL

pub fn config(&self) -> &WebSocketConfig

Get the configuration

Trait Implementations

impl Stream for LightconeWebSocketClient

type Item = WsEvent

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin> Unpin for LightconeWebSocketClient

where PinnedFieldsOf<__Origin<'__pin>>: Unpin,