Struct BulkHttpClient 

pub struct BulkHttpClient { /* private fields */ }

HTTP REST API client for Bulk Labs exchange.

Supports both public (unsigned) and private (signed) endpoints. Construct with None for read-only access or provide a private key for trading operations.

Implementations

impl BulkHttpClient

pub fn new(config: &HttpConfig) -> Result<Self>

Create bulk HTTP client

Arguments

• config: http client config

Examples found in repository

examples/account_query.rs (lines 39-43)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for account: {:?}", args.url, args.account);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    });

    let addr = Pubkey::from_str(args.account.as_str())?;
    let account = client?.get_account(addr).await;

    eprintln!("account: {:?}", account);
    process::exit(0);
}

examples/md_query.rs (lines 37-41)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for symbol: {:?}", args.url, args.symbol);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    })
    .unwrap();

    let book = client.get_orderbook(&args.symbol, None, None).await?;
    eprintln!("book: {:?}\n", book);

    let ticker = client.get_ticker(&args.symbol).await?;
    eprintln!("ticker: {:?}\n", ticker);

    let markets = client.get_exchange_info().await?;
    eprintln!("markets: {:?}\n", markets);

    process::exit(0);
}

examples/execute_cond.rs (lines 40-44)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    })
    .unwrap();

    let account = if false {
        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
    } else {
        signer.public_key()
    };
    let nonce = 1776682154418;

    let orders = vec![Action::TakeProfit(StopOrTP {
        symbol: Arc::from("BTC-USD"),
        is_above: false,
        size: 0.480894,
        threshold: 40000.0,
        limit: None,
        meta: ActionMeta {
            account,
            nonce,
            seqno: 0,
            hash: None,
        },
    })];

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

examples/execute_limit.rs (lines 40-44)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    })
    .unwrap();

    let account = signer.public_key();
    let nonce = make_nonce();

    let mut orders = vec![
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("BTC-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            builder_code: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            },
        }),
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("ETH-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            builder_code: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 1,
                hash: None,
            },
        }),
    ];

    let oids = orders
        .iter_mut()
        .map(|o| o.hash().to_string())
        .collect::<Vec<_>>();

    eprintln!("order IDs: {:?}", oids);

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

pub fn with_url(base_url: &str, private_key: Option<&str>) -> Result<Self>

Create bulk HTTP client with url, private key

Arguments

• base_url: http client url
• private_key: optional private key

pub fn with_signer(base_url: &str, signer: TransactionSigner) -> Result<Self>

Create bulk HTTP client with a pre-built signer (software key or Ledger).

Example

let signer = TransactionSigner::from_ledger("usb://ledger", None)?;
let client = BulkHttpClient::with_signer("https://exchange-api.bulk.trade/api/v1", signer)?;
let resp = client.request_faucet(None, None, None).await?;

pub fn config(&self) -> &HttpConfig

Channel configuration

pub fn public_key(&self) -> Option<Pubkey>

Pubkeyt associated with this channel

pub async fn get_exchange_info(&self) -> Result<Vec<MarketInfo>>

Get exchange information including all available markets.

Examples found in repository

examples/md_query.rs (line 50)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for symbol: {:?}", args.url, args.symbol);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    })
    .unwrap();

    let book = client.get_orderbook(&args.symbol, None, None).await?;
    eprintln!("book: {:?}\n", book);

    let ticker = client.get_ticker(&args.symbol).await?;
    eprintln!("ticker: {:?}\n", ticker);

    let markets = client.get_exchange_info().await?;
    eprintln!("markets: {:?}\n", markets);

    process::exit(0);
}

pub async fn get_ticker(&self, symbol: &str) -> Result<Ticker>

Get market ticker/statistics for a symbol.

Examples found in repository

examples/md_query.rs (line 47)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for symbol: {:?}", args.url, args.symbol);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    })
    .unwrap();

    let book = client.get_orderbook(&args.symbol, None, None).await?;
    eprintln!("book: {:?}\n", book);

    let ticker = client.get_ticker(&args.symbol).await?;
    eprintln!("ticker: {:?}\n", ticker);

    let markets = client.get_exchange_info().await?;
    eprintln!("markets: {:?}\n", markets);

    process::exit(0);
}

pub async fn get_klines( &self, symbol: &str, interval: &str, start_time: Option<u64>, end_time: Option<u64>, limit: Option<u32>, ) -> Result<Vec<Candle>>

Get historical candlestick/OHLCV data.

Arguments

• symbol: Market symbol (e.g. “BTC-USD”)
• interval: Candle interval (“1m”, “5m”, “15m”, “30m”, “1h”, “4h”, “1d”, “1w”)
• start_time: Optional start timestamp in milliseconds
• end_time: Optional end timestamp in milliseconds
• limit: Maximum candles to return (default 500, max 1000)

pub async fn get_orderbook( &self, symbol: &str, nlevels: Option<u32>, aggregation: Option<f64>, ) -> Result<L2Snapshot>

Get L2 order book snapshot.

Arguments

• symbol: Market symbol
• nlevels: Number of price levels per side (default 20, max 1000)
• aggregation: Optional price aggregation/grouping

Examples found in repository

examples/md_query.rs (line 44)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for symbol: {:?}", args.url, args.symbol);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    })
    .unwrap();

    let book = client.get_orderbook(&args.symbol, None, None).await?;
    eprintln!("book: {:?}\n", book);

    let ticker = client.get_ticker(&args.symbol).await?;
    eprintln!("ticker: {:?}\n", ticker);

    let markets = client.get_exchange_info().await?;
    eprintln!("markets: {:?}\n", markets);

    process::exit(0);
}

pub async fn get_account(&self, user: Pubkey) -> Result<AccountData>

Get complete account state including positions, orders, and margin.

Arguments

• user: user pubkey to query

Examples found in repository

examples/account_query.rs (line 46)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for account: {:?}", args.url, args.account);
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: None,
        ..Default::default()
    });

    let addr = Pubkey::from_str(args.account.as_str())?;
    let account = client?.get_account(addr).await;

    eprintln!("account: {:?}", account);
    process::exit(0);
}

pub async fn get_open_orders(&self, user: &str) -> Result<Vec<OrderState>>

Get resting orders for an account.

Arguments

• user: user pubkey to query

pub async fn get_fills(&self, user: &str) -> Result<Vec<Fill>>

Get trade history (up to 5000 recent fills).

Arguments

• user: user pubkey to query

pub async fn get_position_history( &self, user: &str, ) -> Result<Vec<PositionInfo>>

Get closed position history (up to 5000 positions).

Arguments

• user: user pubkey to query

pub async fn place_tx( &self, actions: Vec<Action>, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Vec<Response>>

Place multiple order actions in a single signed transaction.

Accepts any mix of limit orders, market orders, cancels, and cancel-alls.

Example

let resp = client.place_tx(vec![
    Action::LimitOrder(LimitOrder { .. }),
    Action::CancelAll(CancelAll { .. }),
], None, None).await?;

Examples found in repository

examples/execute_cond.rs (line 68)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    })
    .unwrap();

    let account = if false {
        Pubkey::from_str("8oqBACkDvyJjBoiWNbZPXrnjZvFjzUjMThbi9oahAVvH")?
    } else {
        signer.public_key()
    };
    let nonce = 1776682154418;

    let orders = vec![Action::TakeProfit(StopOrTP {
        symbol: Arc::from("BTC-USD"),
        is_above: false,
        size: 0.480894,
        threshold: 40000.0,
        limit: None,
        meta: ActionMeta {
            account,
            nonce,
            seqno: 0,
            hash: None,
        },
    })];

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

examples/execute_limit.rs (line 92)

async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
        .init();

    let args = Args::parse();

    info!("Connecting to {} for execution", args.url);
    let key = env::var("BULK_PRIVATE_KEY")?;
    let signer = TransactionSigner::from_private_key(key.as_str())?;
    let client = BulkHttpClient::new(&HttpConfig {
        base_url: args.url,
        signer: Some(signer.clone()),
        ..Default::default()
    })
    .unwrap();

    let account = signer.public_key();
    let nonce = make_nonce();

    let mut orders = vec![
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("BTC-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            builder_code: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 0,
                hash: None,
            },
        }),
        Action::LimitOrder(LimitOrder {
            symbol: Arc::from("ETH-USD"),
            is_buy: true,
            price: 1000.0,
            size: 0.0001,
            tif: TimeInForce::IOC,
            reduce_only: false,
            iso: false,
            builder_code: None,
            meta: ActionMeta {
                account,
                nonce,
                seqno: 1,
                hash: None,
            },
        }),
    ];

    let oids = orders
        .iter_mut()
        .map(|o| o.hash().to_string())
        .collect::<Vec<_>>();

    eprintln!("order IDs: {:?}", oids);

    let results = client.place_tx(orders, Some(account), Some(nonce)).await?;
    eprintln!("results: {:?}\n", results);

    process::exit(0);
}

pub async fn place_limit_order( &self, symbol: &str, side: Side, price: f64, size: f64, tif: TimeInForce, reduce_only: bool, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Place a single limit order.

pub async fn place_market_order( &self, symbol: &str, side: Side, size: f64, reduce_only: bool, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Place a single market order.

pub async fn cancel_order( &self, symbol: &str, order_id: &str, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Cancel a single order by ID.

pub async fn cancel_all( &self, symbols: Vec<String>, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Cancel all orders, optionally filtered by symbols.

pub async fn update_leverage( &self, settings: HashMap<String, f64>, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Update maximum leverage settings for markets.

Arguments

• settings: Map of (symbol, max_leverage) pairs

pub async fn manage_agent_wallet( &self, agent_pubkey: Pubkey, delete: bool, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Create or delete an agent wallet authorization.

Arguments

• agent_pubkey: Agent’s public key (base58)
• delete: true to remove the agent, false to add

pub async fn approve_builder_code( &self, to: Pubkey, fee: u8, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Approve a builder-code recipient for routed orders.

Builder codes are encoded as builder-code fees on the wire.

pub async fn revoke_builder_code( &self, to: Pubkey, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Revoke a builder-code recipient approval.

pub async fn whitelist_faucet( &self, target_account: Pubkey, whitelist: bool, account: Option<Pubkey>, nonce: Option<u64>, ) -> Result<Response>

Whitelist or unwhitelist an account for testnet faucet access.

Testnet admin only.

Arguments

• target_account: account to be whitelisted
• whitelist: if true is added whitelisted, if false removed
• nonce: tx nonce

pub async fn request_faucet( &self, user: Option<Pubkey>, amount: Option<f64>, nonce: Option<u64>, ) -> Result<Response>

Request testnet faucet funds.

Testnet only.

Arguments

• user: Optional target user public key (defaults to signer’s key)
• amount: Optional specific amount (only for whitelisted accounts)
• nonce: Optional nonce

Trait Implementations

impl Clone for BulkHttpClient

fn clone(&self) -> BulkHttpClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.