Real-Time Push

Push uses Protobuf over TCP/TLS. Market subscriptions require the corresponding license; account subscriptions require account permission. subscribe/unsubscribe only report whether the frame entered the local channel, not server acceptance. Auto-reconnect defaults on, backs off to 60 seconds, and restores subscriptions recorded through state methods.

`PushClient::new`

pub fn new(config: ClientConfig, options: Option<PushClientOptions>) -> PushClient

All PushClientOptions fields are optional: push_url defaults to openapi.tigerfintech.com:9883; heartbeat 10 seconds; initial reconnect 5 seconds; auto reconnect true; connection timeout 30 seconds.

`set_callbacks`

pub fn set_callbacks(&self, cb: Callbacks)

Replaces all callbacks. Market callbacks: on_quote(QuoteData), on_tick(TradeTickData), on_depth(QuoteDepthData), on_option(QuoteData), on_future(QuoteData), on_kline(KlineData), on_stock_top(StockTopData), on_option_top(OptionTopData), on_full_tick(TickData), on_quote_bbo(QuoteData). Account callbacks: asset, position, order status, transaction. Connection callbacks: connect, disconnect, error String, kickout String. Types are in tigeropen::push::pb.

Connection and state

Method and exact signature	Behavior and errors
`connect(client: &Arc<PushClient>) -> Result<(), String>`	Async free function; TCP/TLS, RSA auth, waits for CONNECTED; rejects duplicate connection; default timeout 30 seconds.
`disconnect(&self)`	Best-effort DISCONNECT, stops tasks, clears channels, invokes callback.
`state(&self) -> ConnectionState`	Disconnected/Connecting/Connected.
`send_heartbeat(&self) -> bool`	Queues heartbeat; false when unavailable.

pub fn subscribe(&self, subject: &SubjectType, symbols: Option<&str>, account: Option<&str>, market: Option<&str>) -> bool
pub fn unsubscribe(&self, subject: &SubjectType, symbols: Option<&str>, account: Option<&str>, market: Option<&str>) -> bool

Symbols are comma-separated. Market data uses symbols, account subjects use account, and market/ranking subjects use market. Subjects: Quote/Tick/Depth/Option/Future/Kline/StockTop/OptionTop/FullTick/QuoteBbo/Asset/Position/Order/Transaction/Cc/Market.

Subscription state

Exact signature	Purpose
`add_subscription(&self, subject: SubjectType, symbols: &[String])`	Record market data for query/reconnect.
`remove_subscription(&self, subject: SubjectType, symbols: Option<&[String]>)`	Remove symbols or whole subject.
`get_subscriptions(&self) -> HashMap<SubjectType, Vec<String>>`	Recorded market subscriptions.
`add_account_sub(&self, subject: SubjectType)`	Record account subject.
`remove_account_sub(&self, subject: &SubjectType)`	Remove account subject.
`get_account_subscriptions(&self) -> Vec<SubjectType>`	Recorded account subjects.

Base subscribe does not update state. Record it too for reconnect restoration, or use convenience methods.

Convenience methods

pub fn subscribe_cc(&self, symbols: &[&str]) -> Result<(), TigerError>
pub fn unsubscribe_cc(&self, symbols: Option<&[&str]>) -> Result<(), TigerError>
pub fn subscribe_market(&self, market: &str) -> Result<(), TigerError>
pub fn unsubscribe_market(&self, market: &str) -> Result<(), TigerError>

subscribe_cc requires a nonempty slice; unsubscribe_cc(None) clears all crypto records. These methods currently ignore the underlying bool and update local state, so Ok(()) does not prove server acceptance.

Public protocol methods

handle_message(&self, data: &[u8]) decodes a varint32 frame and dispatches callbacks, mainly for tests/custom transports. push::varint::{encode_varint32, decode_varint32} and the public push::proto_message builders/mapping are also public; normal applications should use connect and subscriptions.

Example

use std::sync::Arc;
use tigeropen::config::ClientConfig;
use tigeropen::push::{connect, Callbacks, PushClient, SubjectType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Arc::new(PushClient::new(ClientConfig::builder().build()?, None));
    client.set_callbacks(Callbacks {
        on_quote: Some(Arc::new(|q| println!("{} {:?}", q.symbol, q.latest_price))),
        on_error: Some(Arc::new(|message| eprintln!("{message}"))),
        ..Default::default()
    });
    connect(&client).await.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
    let symbols = vec!["AAPL".to_string()];
    if client.subscribe(&SubjectType::Quote, Some("AAPL"), None, None) {
        client.add_subscription(SubjectType::Quote, &symbols);
    }
    client.disconnect();
    Ok(())
}

Redacted event shape generated from the model:

{"symbol":"AAPL","latestPrice":150.5,"volume":1000000}

Push has no HTTP pagination; event rate is server-controlled. Slow callbacks block dispatch, so hand expensive work to another task. Source: PushClient, Callbacks, SubjectType.