Struct BitgetConnector 

pub struct BitgetConnector { /* private fields */ }

Bitget коннектор

Implementations

impl BitgetConnector

pub async fn new( credentials: Option<Credentials>, testnet: bool, ) -> ExchangeResult<Self>

Создать новый коннектор

When testnet is true the connector operates in Bitget Demo Trading (paper trading) mode: WebSocket connects to wspap.bitget.com and the X-CHANNEL-API-CODE: paptrading header is added to every authenticated REST request. The REST base URL remains the same as mainnet.

pub async fn public() -> ExchangeResult<Self>

Создать коннектор только для публичных методов

Examples found in repository

examples/e2e_metadata.rs (line 450)

async fn test_bitget_rest() -> RestTally {
    println!("\n── Bitget REST ──────────────────────────────────────────────");
    let mut tally = RestTally { exchange: "Bitget".into(), tested: 0, passed: 0, failed: 0 };

    let conn = match BitgetConnector::public().await {
        Ok(c) => c,
        Err(e) => {
            println!("  FAIL: connector init -> {}", e);
            tally.failed += 1;
            tally.tested += 1;
            return tally;
        }
    };

    // get_futures_open_interest
    tally.tested += 1;
    match conn.get_futures_open_interest("BTCUSDT", "USDT-FUTURES").await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_open_interest(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_open_interest", e); tally.failed += 1; }
    }

    // NEW: get_futures_market_fills
    tally.tested += 1;
    match conn.get_futures_market_fills("BTCUSDT", "USDT-FUTURES", Some(10)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_market_fills(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_market_fills", e); tally.failed += 1; }
    }

    // NEW: get_futures_mark_candles
    tally.tested += 1;
    match conn.get_futures_mark_candles("BTCUSDT", "USDT-FUTURES", "1H", None, None, Some(5)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_mark_candles(BTCUSDT, USDT-FUTURES, 1H)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_mark_candles", e); tally.failed += 1; }
    }

    tally
}

pub async fn get_symbols( &self, account_type: AccountType, ) -> ExchangeResult<Value>

Получить информацию о символах

impl BitgetConnector

pub async fn get_spot_recent_fills( &self, symbol: &str, limit: Option<u32>, ) -> ExchangeResult<Value>

Get recent public spot fills (market trades).

GET /api/v2/spot/market/fills

Parameters

• symbol: Spot symbol e.g. BTCUSDT
• limit: Number of fills (optional, max 500)

pub async fn get_spot_history_candles( &self, symbol: &str, granularity: &str, end_time: Option<i64>, limit: Option<u32>, ) -> ExchangeResult<Value>

Get historical spot candles beyond the standard window.

GET /api/v2/spot/market/history-candles

Parameters

• symbol: Spot symbol e.g. BTCUSDT
• granularity: Candle interval e.g. 1min, 1h, 1day
• end_time: End timestamp in ms (optional)
• limit: Number of candles (optional, max 200)

pub async fn get_futures_fill_history( &self, product_type: &str, symbol: Option<&str>, start_time: Option<i64>, end_time: Option<i64>, id_less_than: Option<&str>, limit: Option<u32>, ) -> ExchangeResult<Value>

Get futures fill/trade history (requires auth).

GET /api/v2/mix/order/fill-history

Parameters

• product_type: e.g. USDT-FUTURES, COIN-FUTURES
• symbol: Futures symbol (optional)
• start_time: Start timestamp in ms (optional)
• end_time: End timestamp in ms (optional)
• id_less_than: Pagination — return records with ID less than this (optional)
• limit: Number of records (optional, max 100)

pub async fn get_futures_open_interest( &self, symbol: &str, product_type: &str, ) -> ExchangeResult<Value>

Get futures open interest.

GET /api/v2/mix/market/open-interest

Parameters

• symbol: Futures symbol e.g. BTCUSDT
• product_type: e.g. USDT-FUTURES

Examples found in repository

examples/e2e_metadata.rs (line 462)

async fn test_bitget_rest() -> RestTally {
    println!("\n── Bitget REST ──────────────────────────────────────────────");
    let mut tally = RestTally { exchange: "Bitget".into(), tested: 0, passed: 0, failed: 0 };

    let conn = match BitgetConnector::public().await {
        Ok(c) => c,
        Err(e) => {
            println!("  FAIL: connector init -> {}", e);
            tally.failed += 1;
            tally.tested += 1;
            return tally;
        }
    };

    // get_futures_open_interest
    tally.tested += 1;
    match conn.get_futures_open_interest("BTCUSDT", "USDT-FUTURES").await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_open_interest(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_open_interest", e); tally.failed += 1; }
    }

    // NEW: get_futures_market_fills
    tally.tested += 1;
    match conn.get_futures_market_fills("BTCUSDT", "USDT-FUTURES", Some(10)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_market_fills(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_market_fills", e); tally.failed += 1; }
    }

    // NEW: get_futures_mark_candles
    tally.tested += 1;
    match conn.get_futures_mark_candles("BTCUSDT", "USDT-FUTURES", "1H", None, None, Some(5)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_mark_candles(BTCUSDT, USDT-FUTURES, 1H)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_mark_candles", e); tally.failed += 1; }
    }

    tally
}

pub async fn get_futures_funding_rate_history( &self, symbol: &str, product_type: &str, page_size: Option<u32>, page_no: Option<u32>, ) -> ExchangeResult<Value>

Get futures historical funding rates.

GET /api/v2/mix/market/history-fund-rate

Parameters

• symbol: Futures symbol e.g. BTCUSDT
• product_type: e.g. USDT-FUTURES
• page_size: Number of records per page (optional, max 100)
• page_no: Page number (optional)

pub async fn get_futures_symbol_price( &self, symbol: &str, product_type: &str, ) -> ExchangeResult<Value>

Get futures mark price and index price.

GET /api/v2/mix/market/symbol-price

Parameters

• symbol: Futures symbol e.g. BTCUSDT
• product_type: e.g. USDT-FUTURES

impl BitgetConnector

pub async fn get_futures_market_fills( &self, symbol: &str, product_type: &str, limit: Option<u32>, ) -> ExchangeResult<Value>

Get recent public futures fills (market trades).

GET /api/v2/mix/market/fills-history

Verified: returns [{tradeId, price, size, side, ts, symbol}] directly as data array.

Parameters

• symbol: Futures symbol e.g. BTCUSDT
• product_type: e.g. USDT-FUTURES
• limit: Number of fills (optional, max 100)

Examples found in repository

examples/e2e_metadata.rs (line 469)

async fn test_bitget_rest() -> RestTally {
    println!("\n── Bitget REST ──────────────────────────────────────────────");
    let mut tally = RestTally { exchange: "Bitget".into(), tested: 0, passed: 0, failed: 0 };

    let conn = match BitgetConnector::public().await {
        Ok(c) => c,
        Err(e) => {
            println!("  FAIL: connector init -> {}", e);
            tally.failed += 1;
            tally.tested += 1;
            return tally;
        }
    };

    // get_futures_open_interest
    tally.tested += 1;
    match conn.get_futures_open_interest("BTCUSDT", "USDT-FUTURES").await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_open_interest(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_open_interest", e); tally.failed += 1; }
    }

    // NEW: get_futures_market_fills
    tally.tested += 1;
    match conn.get_futures_market_fills("BTCUSDT", "USDT-FUTURES", Some(10)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_market_fills(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_market_fills", e); tally.failed += 1; }
    }

    // NEW: get_futures_mark_candles
    tally.tested += 1;
    match conn.get_futures_mark_candles("BTCUSDT", "USDT-FUTURES", "1H", None, None, Some(5)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_mark_candles(BTCUSDT, USDT-FUTURES, 1H)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_mark_candles", e); tally.failed += 1; }
    }

    tally
}

pub async fn get_futures_mark_candles( &self, symbol: &str, product_type: &str, granularity: &str, start_time: Option<i64>, end_time: Option<i64>, limit: Option<u32>, ) -> ExchangeResult<Value>

Get mark price OHLCV history for a futures contract.

GET /api/v2/mix/market/history-mark-candles

Verified: returns array of [ts, open, high, low, close, vol, notional] candles.

Parameters

• symbol: Futures symbol e.g. BTCUSDT
• product_type: e.g. USDT-FUTURES
• granularity: Candle interval e.g. 1m, 1H, 1D
• start_time: Start timestamp in ms (optional)
• end_time: End timestamp in ms (optional)
• limit: Number of candles (optional, max 200)

Examples found in repository

examples/e2e_metadata.rs (line 476)

async fn test_bitget_rest() -> RestTally {
    println!("\n── Bitget REST ──────────────────────────────────────────────");
    let mut tally = RestTally { exchange: "Bitget".into(), tested: 0, passed: 0, failed: 0 };

    let conn = match BitgetConnector::public().await {
        Ok(c) => c,
        Err(e) => {
            println!("  FAIL: connector init -> {}", e);
            tally.failed += 1;
            tally.tested += 1;
            return tally;
        }
    };

    // get_futures_open_interest
    tally.tested += 1;
    match conn.get_futures_open_interest("BTCUSDT", "USDT-FUTURES").await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_open_interest(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_open_interest", e); tally.failed += 1; }
    }

    // NEW: get_futures_market_fills
    tally.tested += 1;
    match conn.get_futures_market_fills("BTCUSDT", "USDT-FUTURES", Some(10)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_market_fills(BTCUSDT, USDT-FUTURES)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_market_fills", e); tally.failed += 1; }
    }

    // NEW: get_futures_mark_candles
    tally.tested += 1;
    match conn.get_futures_mark_candles("BTCUSDT", "USDT-FUTURES", "1H", None, None, Some(5)).await {
        Ok(v) => { let (p, _) = ok_rest_single!("get_futures_mark_candles(BTCUSDT, USDT-FUTURES, 1H)", v); tally.passed += p as usize; }
        Err(e) => { fail_rest!("get_futures_mark_candles", e); tally.failed += 1; }
    }

    tally
}

Trait Implementations

impl Account for BitgetConnector

fn get_balance<'life0, 'async_trait>( &'life0 self, query: BalanceQuery, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Balance>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get asset balances, optionally filtered to a single asset and/or account type.

fn get_account_info<'life0, 'async_trait>( &'life0 self, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<AccountInfo>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get account metadata — permissions, commission rates, balance summary.

fn get_fees<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<FeeInfo>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the fee schedule (maker/taker rates) for this account.

fn account_capabilities(&self, account_type: AccountType) -> AccountCapabilities

Returns the connector’s account capabilities.

impl AccountLedger for BitgetConnector

fn get_ledger<'life0, 'async_trait>( &'life0 self, filter: LedgerFilter, _account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<LedgerEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get spot account bill/ledger records from GET /api/v2/spot/account/bills.

Params: coin (optional), groupType, businessType, startTime (ms), endTime (ms), limit (max 500), idLessThan (for pagination).

impl AccountTransfers for BitgetConnector

fn transfer<'life0, 'async_trait>( &'life0 self, req: TransferRequest, ) -> Pin<Box<dyn Future<Output = ExchangeResult<TransferResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Transfer between Spot, Futures, P2P, etc.

POST /api/v2/spot/wallet/transfer Body: { fromType, toType, amount, coin }

fn get_transfer_history<'life0, 'async_trait>( &'life0 self, filter: TransferHistoryFilter, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<TransferResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get internal transfer history.

GET /api/v2/spot/account/transferRecords

impl AmendOrder for BitgetConnector

fn amend_order<'life0, 'async_trait>( &'life0 self, req: AmendRequest, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Modify a live order’s price, quantity, and/or trigger price.

impl BatchOrders for BitgetConnector

fn max_batch_place_size(&self) -> usize

Maximum number of orders allowed in a single batch place request.

fn max_batch_cancel_size(&self) -> usize

Maximum number of orders allowed in a single batch cancel request.

fn place_orders_batch<'life0, 'async_trait>( &'life0 self, orders: Vec<OrderRequest>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<OrderResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Place multiple orders in a single native batch request.

fn cancel_orders_batch<'life0, 'life1, 'async_trait>( &'life0 self, order_ids: Vec<String>, symbol: Option<&'life1 str>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<OrderResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cancel multiple orders in a single native batch request.

impl CancelAll for BitgetConnector

fn cancel_all_orders<'life0, 'async_trait>( &'life0 self, scope: CancelScope, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<CancelAllResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancel orders matching the given scope.

impl CustodialFunds for BitgetConnector

fn get_deposit_address<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, asset: &'life1 str, network: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<DepositAddress>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get deposit address for an asset.

GET /api/v2/spot/wallet/deposit-address

fn withdraw<'life0, 'async_trait>( &'life0 self, req: WithdrawRequest, ) -> Pin<Box<dyn Future<Output = ExchangeResult<WithdrawResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Submit a withdrawal request.

POST /api/v2/spot/wallet/withdrawal

fn get_funds_history<'life0, 'async_trait>( &'life0 self, filter: FundsHistoryFilter, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<FundsRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get deposit and/or withdrawal history.

GET /api/v2/spot/wallet/deposit-records (deposits) GET /api/v2/spot/wallet/withdrawal-records (withdrawals)

impl ExchangeIdentity for BitgetConnector

fn exchange_id(&self) -> ExchangeId

Уникальный идентификатор биржи

fn metrics(&self) -> ConnectorStats

Runtime metrics snapshot for this connector.

fn rate_limit_capabilities(&self) -> RateLimitCapabilities

Static rate limit capabilities for this exchange.

fn is_testnet(&self) -> bool

Работаем ли с тестовой сетью

fn supported_account_types(&self) -> Vec<AccountType>

Список поддерживаемых типов аккаунтов

fn exchange_type(&self) -> ExchangeType

Тип биржи (централизованная, децентрализованная, гибрид)

fn orderbook_capabilities( &self, _account_type: AccountType, ) -> OrderbookCapabilities

Static L2 orderbook capabilities for the given account type.

fn exchange_name(&self) -> &'static str

Человекочитаемое имя биржи

impl FundingHistory for BitgetConnector

fn get_funding_payments<'life0, 'async_trait>( &'life0 self, filter: FundingFilter, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<FundingPayment>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get historical funding payments for the account.

impl HasCapabilities for BitgetConnector

fn capabilities(&self) -> ConnectorCapabilities

Return a declarative map of what this connector supports.

fn validation_status(&self) -> Option<&'static ValidationStamp>

Empirical validation results from the last e2e_smoke harness run.

impl MarketData for BitgetConnector

fn get_price<'life0, 'life1, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Price>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Получить текущую цену символа

fn get_orderbook<'life0, 'life1, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, depth: Option<u16>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<OrderBook>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Получить книгу ордеров

fn get_klines<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, interval: &'life2 str, limit: Option<u16>, account_type: AccountType, end_time: Option<i64>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Kline>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Получить свечи (klines)

fn get_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Ticker>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Получить 24h тикер

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ExchangeResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Проверить соединение (ping)

fn get_exchange_info<'life0, 'async_trait>( &'life0 self, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<SymbolInfo>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Получить информацию о всех торговых символах биржи

fn market_data_capabilities( &self, account_type: AccountType, ) -> MarketDataCapabilities

Returns the connector’s market data capabilities.

impl MarketDataPublic for BitgetConnector

fn get_recent_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, limit: Option<u32>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<PublicTrade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Recent public trades for a symbol.

fn get_liquidation_history<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<SymbolInput<'life1>>, start_time: Option<i64>, end_time: Option<i64>, limit: Option<u32>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Liquidation>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Historical liquidation events, optionally filtered by symbol and time range.

fn get_open_interest_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, period: &'life2 str, start_time: Option<i64>, end_time: Option<i64>, limit: Option<u32>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<OpenInterest>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Historical open interest snapshots.

fn get_premium_index<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<SymbolInput<'life1>>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<MarkPrice>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark price and index price snapshot(s) for a symbol.

fn get_long_short_ratio_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, period: &'life2 str, start_time: Option<i64>, end_time: Option<i64>, limit: Option<u32>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<LongShortRatio>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Historical long/short ratio snapshots.

fn get_mark_price_klines<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, interval: &'life2 str, limit: Option<u32>, account_type: AccountType, end_time: Option<i64>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Kline>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark price klines (OHLCV based on mark price).

fn get_index_price_klines<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, interval: &'life2 str, limit: Option<u32>, account_type: AccountType, end_time: Option<i64>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Kline>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Index price klines (OHLCV based on index/spot price).

fn get_funding_rate_history<'life0, 'life1, 'async_trait>( &'life0 self, symbol: SymbolInput<'life1>, start_time: Option<i64>, end_time: Option<i64>, limit: Option<u32>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<FundingRate>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Historical funding rate payments.

impl Positions for BitgetConnector

fn get_positions<'life0, 'async_trait>( &'life0 self, query: PositionQuery, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get open positions, optionally filtered to a single symbol.

fn get_funding_rate<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<FundingRate>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the current funding rate for a perpetual contract symbol.

fn get_open_interest<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<OpenInterest>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get open interest for a perpetual/futures symbol.

fn get_mark_price<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = ExchangeResult<MarkPrice>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the current mark price (and optionally index price + funding rate) for a perpetual/futures symbol.

fn modify_position<'life0, 'async_trait>( &'life0 self, req: PositionModification, ) -> Pin<Box<dyn Future<Output = ExchangeResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Modify a position — leverage, margin mode, add/remove margin, TP/SL, or close.

fn get_closed_pnl<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, start_time: Option<u64>, end_time: Option<u64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<ClosedPnlRecord>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the closed position P&L history.

fn get_long_short_ratio<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<LongShortRatio>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the long/short account ratio for a symbol.

impl SubAccounts for BitgetConnector

fn sub_account_operation<'life0, 'async_trait>( &'life0 self, op: SubAccountOperation, ) -> Pin<Box<dyn Future<Output = ExchangeResult<SubAccountResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform sub-account operations: Create, List, Transfer, GetBalance.

impl Trading for BitgetConnector

fn place_order<'life0, 'async_trait>( &'life0 self, req: OrderRequest, ) -> Pin<Box<dyn Future<Output = ExchangeResult<PlaceOrderResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Place an order of any type.

fn cancel_order<'life0, 'async_trait>( &'life0 self, req: CancelRequest, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancel one order, a batch, all orders, or all orders for a symbol.

fn get_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbol: &'life1 str, order_id: &'life2 str, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the current state of a single order by ID.

fn get_open_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all currently open orders, optionally filtered to a single symbol.

fn get_order_history<'life0, 'async_trait>( &'life0 self, filter: OrderHistoryFilter, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get closed / filled / cancelled order history with filtering.

fn get_user_trades<'life0, 'async_trait>( &'life0 self, filter: UserTradeFilter, account_type: AccountType, ) -> Pin<Box<dyn Future<Output = ExchangeResult<Vec<UserTrade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the user’s own trade fills (executions).

fn trading_capabilities(&self, account_type: AccountType) -> TradingCapabilities

Returns the connector’s trading capabilities.