ccxt-pro 4.5.78

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

#![allow(unused, non_snake_case, clippy::all)]
use crate::Value;
use crate::get_value;
use crate::runtime::*;
// Base methods are now trait methods (review #1: static dispatch). Bring the
// traits into scope so `self.market(...)`, `self.safe_market(...)`,
// `self.load_markets(...)`, … on this Core resolve to the base defaults.
use crate::exchange_generated::ExchangeBase;
use crate::exchange::ExchangeRuntime;
use crate::pro::*;


pub struct BingxCore {
    pub parent: crate::exchanges::bingx::BingxCore,
}

impl BingxCore {
    pub fn new(config: Option<crate::Value>) -> Self {
        let mut s = Self { parent: crate::exchanges::bingx::BingxCore::new(config) };
        s.init();
        s
    }

    pub fn init(&mut self) {
        let described = BingxCore::describe(self);
        self.initialize_properties(described);
        <Self as crate::exchange_generated::ExchangeBase>::after_construct(self);
    }

    /// Compatibility no-op. The old pointer-based dispatch needed a post-move
    /// `bind()`; static trait dispatch (review #1) needs no binding, so this
    /// just exists so callers that still call it keep compiling.
    #[inline]
    pub fn bind(&mut self) {}
}

impl crate::exchange::DerivedExchange for BingxCore {
    fn nonce(&self, ) -> crate::Value {
        crate::exchange::DerivedExchange::nonce(&self.parent)
    }
    fn parse_ticker(&self, ticker: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ticker(&self.parent, ticker, market)
    }
    fn parse_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_trade(&self.parent, trade, market)
    }
    fn parse_order(&self, order: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_order(&self.parent, order, market)
    }
    fn parse_market(&self, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_market(&self.parent, market)
    }
    fn parse_ohlcv(&self, ohlcv: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ohlcv(&self.parent, ohlcv, market)
    }
    fn parse_order_book(&self, ob: crate::Value, symbol: crate::Value, ts: crate::Value, bk: crate::Value, ak: crate::Value, pk: crate::Value, ak2: crate::Value, ck: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_order_book(&self.parent, ob, symbol, ts, bk, ak, pk, ak2, ck)
    }
    fn parse_balance(&self, response: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_balance(&self.parent, response)
    }
    fn parse_position(&self, position: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_position(&self.parent, position, market)
    }
    fn parse_funding_rate(&self, rate: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_funding_rate(&self.parent, rate, market)
    }
    fn parse_deposit(&self, tx: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit(&self.parent, tx, currency)
    }
    fn parse_deposit_address(&self, depositAddress: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit_address(&self.parent, depositAddress, currency)
    }
    fn parse_last_price(&self, entry: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_last_price(&self.parent, entry, market)
    }
    fn parse_withdrawal(&self, tx: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_withdrawal(&self.parent, tx, currency)
    }
    fn parse_ledger_entry(&self, entry: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_ledger_entry(&self.parent, entry, currency)
    }
    fn parse_transfer(&self, transfer: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_transfer(&self.parent, transfer, currency)
    }
    fn parse_currency(&self, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_currency(&self.parent, currency)
    }
    fn parse_bid_ask(&self, bidask: crate::Value, price_key: crate::Value, amount_key: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_bid_ask(&self.parent, bidask, price_key, amount_key, market)
    }
    fn parse_open_interest(&self, interest: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_open_interest(&self.parent, interest, market)
    }
    fn parse_liquidation(&self, liquidation: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_liquidation(&self.parent, liquidation, market)
    }
    fn parse_funding_rate_history(&self, entry: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_funding_rate_history(&self.parent, entry, market)
    }
    fn parse_margin_modification(&self, data: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_margin_modification(&self.parent, data, market)
    }
    fn parse_account(&self, account: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_account(&self.parent, account)
    }
    fn parse_my_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_my_trade(&self.parent, trade, market)
    }
    fn parse_transaction(&self, transaction: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_transaction(&self.parent, transaction, currency)
    }
    fn parse_borrow_interest(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_borrow_interest(&self.parent, info, market)
    }
    fn parse_adl_rank(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_adl_rank(&self.parent, info, market)
    }
    fn parse_income(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_income(&self.parent, info, market)
    }
    fn parse_greeks(&self, greeks: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_greeks(&self.parent, greeks, market)
    }
    fn parse_margin_mode(&self, margin_mode: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_margin_mode(&self.parent, margin_mode, market)
    }
    fn parse_conversion(&self, conversion: crate::Value, from_currency: crate::Value, to_currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_conversion(&self.parent, conversion, from_currency, to_currency)
    }
    fn parse_borrow_rate(&self, info: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_borrow_rate(&self.parent, info, currency)
    }
    fn parse_leverage(&self, leverage: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_leverage(&self.parent, leverage, market)
    }
    fn parse_market_leverage_tiers(&self, info: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_market_leverage_tiers(&self.parent, info, market)
    }
    fn parse_deposit_withdraw_fee(&self, fee: crate::Value, currency: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_deposit_withdraw_fee(&self.parent, fee, currency)
    }
    fn parse_prediction_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_trade(&self.parent, trade, market)
    }
    fn parse_prediction_order(&self, order: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_order(&self.parent, order, market)
    }
    fn parse_prediction_position(&self, position: crate::Value, market: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::parse_prediction_position(&self.parent, position, market)
    }
    fn create_expired_option_market(&self, symbol: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::create_expired_option_market(&self.parent, symbol)
    }
    fn sign(&self, path: crate::Value, api: crate::Value, method: crate::Value, params: crate::Value, headers: crate::Value, body: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::sign(&self.parent, path, api, method, params, headers, body)
    }
    fn handle_errors(&self, code: crate::Value, reason: crate::Value, url: crate::Value, method: crate::Value, headers: crate::Value, body: crate::Value, response: crate::Value, request_headers: crate::Value, request_body: crate::Value) -> crate::Value {
        crate::exchange::DerivedExchange::handle_errors(&self.parent, code, reason, url, method, headers, body, response, request_headers, request_body)
    }
}

impl crate::exchange_generated::ExchangeBase for BingxCore {
    fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
        -> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
    {
        Box::pin(async move {
            match method {
                "authenticate" => self.authenticate(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "get_message_hash" => self.get_message_hash(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "get_order_book_limit_by_market_type" => self.get_order_book_limit_by_market_type(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
                "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "keep_alive_listen_key" => self.keep_alive_listen_key(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "load_balance_snapshot" => self.load_balance_snapshot(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null)).await,
                "load_positions_snapshot" => self.load_positions_snapshot(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)).await,
                "parse_ws_ohlcv" => self.parse_ws_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "pong" => self.pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)).await,
                "un_watch" => self.un_watch(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null), args.get(5).cloned().unwrap_or(crate::Value::Null), args.get(6).cloned().unwrap_or(crate::Value::Null), &args.get(7..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_ohlcv" => self.un_watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_order_book" => self.un_watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_ticker" => self.un_watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_trades" => self.un_watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_balance" => self.watch_balance(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_my_trades" => self.watch_my_trades(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_ohlcv" => self.watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_orders" => self.watch_orders(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_positions" => self.watch_positions(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                // Go-style inheritance: an un-overridden method dispatches to the parent core.
                _ => crate::exchange_generated::ExchangeBase::call_dynamic(&mut self.parent, method, args).await,
            }
        })
    }
}
impl BingxCore {
    /// Synchronous WS handler dispatch — routes a handler-name string (from the
    /// venue's handle_message dispatch table) to the real handler method.
    #[allow(dead_code, unreachable_patterns, clippy::all)]
    pub fn dispatch_ws_handler(&mut self, __name: &crate::Value, args: &[crate::Value]) -> crate::Value {
        let __n = match __name { crate::Value::Str(s) => s.as_str(), _ => return crate::Value::Null };
        match __n {
            "authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
            "get_message_hash" => self.get_message_hash(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "get_order_book_limit_by_market_type" => self.get_order_book_limit_by_market_type(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "handle_balance" => { self.handle_balance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_delta" => { self.handle_delta(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_my_trades" => { self.handle_my_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_ohlcv" => { self.handle_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order" => { self.handle_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order_book" => { self.handle_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_positions" => { self.handle_positions(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_ticker" => { self.handle_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_trades" => { self.handle_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_un_subscription" => { self.handle_un_subscription(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "keep_alive_listen_key" => { crate::exchange_stubs::enqueue_spawn("keep_alive_listen_key", args.to_vec()); crate::Value::Null },
            "load_balance_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_balance_snapshot", args.to_vec()); crate::Value::Null },
            "load_positions_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_positions_snapshot", args.to_vec()); crate::Value::Null },
            "parse_ws_ohlcv" => self.parse_ws_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "pong" => { crate::exchange_stubs::enqueue_spawn("pong", args.to_vec()); crate::Value::Null },
            "set_balance_cache" => { self.set_balance_cache(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "set_positions_cache" => { self.set_positions_cache(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args.get(2..).unwrap_or(&[]).to_vec()[..]); crate::Value::Null },
            "un_watch" => { crate::exchange_stubs::enqueue_spawn("un_watch", args.to_vec()); crate::Value::Null },
            "un_watch_ohlcv" => { crate::exchange_stubs::enqueue_spawn("un_watch_ohlcv", args.to_vec()); crate::Value::Null },
            "un_watch_order_book" => { crate::exchange_stubs::enqueue_spawn("un_watch_order_book", args.to_vec()); crate::Value::Null },
            "un_watch_ticker" => { crate::exchange_stubs::enqueue_spawn("un_watch_ticker", args.to_vec()); crate::Value::Null },
            "un_watch_trades" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades", args.to_vec()); crate::Value::Null },
            "watch_balance" => { crate::exchange_stubs::enqueue_spawn("watch_balance", args.to_vec()); crate::Value::Null },
            "watch_my_trades" => { crate::exchange_stubs::enqueue_spawn("watch_my_trades", args.to_vec()); crate::Value::Null },
            "watch_ohlcv" => { crate::exchange_stubs::enqueue_spawn("watch_ohlcv", args.to_vec()); crate::Value::Null },
            "watch_order_book" => { crate::exchange_stubs::enqueue_spawn("watch_order_book", args.to_vec()); crate::Value::Null },
            "watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
            "watch_positions" => { crate::exchange_stubs::enqueue_spawn("watch_positions", args.to_vec()); crate::Value::Null },
            "watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

impl std::ops::Deref for BingxCore {
    type Target = crate::exchange::Exchange;
    fn deref(&self) -> &crate::exchange::Exchange { std::ops::Deref::deref(&self.parent) }
}

impl std::ops::DerefMut for BingxCore {
    fn deref_mut(&mut self) -> &mut crate::exchange::Exchange { std::ops::DerefMut::deref_mut(&mut self.parent) }
}

impl BingxCore {
    pub fn describe(&self) -> Value {
        return self.deep_extend(self.parent.describe(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("has".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchOrderBookForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("watchOHLCVForSymbols".to_string(), Value::Bool(false));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(false));
        m.insert("watchBalance".to_string(), Value::Bool(true));
        m.insert("watchPositions".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBook".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
    m
}));
        m.insert("urls".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("test".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("linear".to_string(), Value::Str("wss://vst-open-api-ws.bingx.com/swap-market".to_string()));
    m
}));
    m
}));
        m.insert("api".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("spot".to_string(), Value::Str("wss://open-api-ws.bingx.com/market".to_string()));
        m.insert("linear".to_string(), Value::Str("wss://open-api-swap.bingx.com/swap-market".to_string()));
        m.insert("inverse".to_string(), Value::Str("wss://open-api-cswap-ws.bingx.com/market".to_string()));
    m
}));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("listenKeyRefreshRate".to_string(), Value::Int(3540000));
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("gunzip".to_string(), Value::Bool(true));
    m
}));
        m.insert("swap".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("timeframes".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("1m".to_string(), Value::Str("1m".to_string()));
        m.insert("3m".to_string(), Value::Str("3m".to_string()));
        m.insert("5m".to_string(), Value::Str("5m".to_string()));
        m.insert("15m".to_string(), Value::Str("15m".to_string()));
        m.insert("30m".to_string(), Value::Str("30m".to_string()));
        m.insert("1h".to_string(), Value::Str("1h".to_string()));
        m.insert("2h".to_string(), Value::Str("2h".to_string()));
        m.insert("4h".to_string(), Value::Str("4h".to_string()));
        m.insert("6h".to_string(), Value::Str("6h".to_string()));
        m.insert("12h".to_string(), Value::Str("12h".to_string()));
        m.insert("1d".to_string(), Value::Str("1d".to_string()));
        m.insert("3d".to_string(), Value::Str("3d".to_string()));
        m.insert("1w".to_string(), Value::Str("1w".to_string()));
        m.insert("1M".to_string(), Value::Str("1M".to_string()));
    m
}));
    m
}));
        m.insert("spot".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("timeframes".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("1m".to_string(), Value::Str("1min".to_string()));
        m.insert("5m".to_string(), Value::Str("5min".to_string()));
        m.insert("15m".to_string(), Value::Str("15min".to_string()));
        m.insert("30m".to_string(), Value::Str("30min".to_string()));
        m.insert("1h".to_string(), Value::Str("60min".to_string()));
        m.insert("1d".to_string(), Value::Str("1day".to_string()));
    m
}));
    m
}));
        m.insert("watchBalance".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("fetchBalanceSnapshot".to_string(), Value::Bool(true));
        m.insert("awaitBalanceSnapshot".to_string(), Value::Bool(true));
    m
}));
        m.insert("watchPositions".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("fetchPositionsSnapshot".to_string(), Value::Bool(true));
        m.insert("awaitPositionsSnapshot".to_string(), Value::Bool(false));
    m
}));
        m.insert("watchOrderBook".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("depth".to_string(), Value::Int(100));
    m
}));
        m.insert("watchTrades".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ignoreDuplicates".to_string(), Value::Bool(true));
    m
}));
    m
}));
        m.insert("streaming".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("keepAlive".to_string(), Value::Int(1800000));
    m
}));
    m
})]);

    Value::Null
}

    pub async fn un_watch(&mut self, mut messageHash: Value, mut subMessageHash: Value, mut subscribeHash: Value, mut dataType: Value, mut topic: Value, mut market: Value, mut methodName: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(methodName.clone(), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(methodName.clone(), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), marketType.clone(), &[]);
        }
        let mut id: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), id.clone());
                m.insert("dataType".to_string(), dataType.clone());
                m.insert("reqType".to_string(), Value::Str("unsub".to_string()));
            m
        });
        let mut symbols: Value = Value::List(vec![]);
        if !is_equal(&market, &Value::Null) {
            append_to_array(&mut symbols, get_value(&market, &Value::Str("symbol".to_string())));
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("id".to_string(), id.clone());
                m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                m.insert("messageHashes".to_string(), Value::List(vec![messageHash.clone()]));
                m.insert("symbols".to_string(), symbols.clone());
                m.insert("topic".to_string(), topic.clone());
            m
        });
        let mut symbolsAndTimeframes: Value = self.safe_list_k(params.clone(), "symbolsAndTimeframes", &[]);
        if !is_equal(&symbolsAndTimeframes, &Value::Null) {
            add_element_to_object(&mut subscription, &Value::Str("symbolsAndTimeframes".to_string()), symbolsAndTimeframes.clone());
            params = self.omit(params.clone(), Value::Str("symbolsAndTimeframes".to_string()), &[]);
        }
        let __ws_arg_0 = self.extend(request.clone(), &[params.clone()]);
        return self.watch(url.clone(), messageHash.clone(), &[__ws_arg_0, subscribeHash.clone(), subscription.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20Price%20Change
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20price%20changes
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%2024-Hour%20Price%20Change
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchTicker".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchTicker".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), marketType.clone(), &[]);
        }
        let mut dataType: Value = add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@ticker".to_string()));
        let mut messageHash: Value = self.get_message_hash(Value::Str("ticker".to_string()), &[get_value(&market, &Value::Str("symbol".to_string()))]);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), dataType.clone());
            m
        });
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            add_element_to_object(&mut request, &Value::Str("reqType".to_string()), Value::Str("sub".to_string()));
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        let __ws_arg_1 = self.extend(request.clone(), &[params.clone()]);
        return self.watch(url.clone(), messageHash.clone(), &[__ws_arg_1, messageHash.clone(), subscription.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchTicker
 * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20Price%20Change
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20to%2024-hour%20price%20changes
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%2024-Hour%20Price%20Change
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn un_watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut dataType: Value = add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@ticker".to_string()));
        let mut subMessageHash: Value = self.get_message_hash(Value::Str("ticker".to_string()), &[get_value(&market, &Value::Str("symbol".to_string()))]);
        let mut messageHash: Value = add(&Value::Str("unsubscribe::".to_string()), &subMessageHash);
        let mut topic: Value = Value::Str("ticker".to_string());
        let mut methodName: Value = Value::Str("unWatchTicker".to_string());
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), dataType.clone(), topic.clone(), market.clone(), methodName.clone(), &[params.clone()]).await;

    Value::Null
}

    pub fn handle_ticker(&mut self, mut client: Value, mut message: Value) {
        //
        // swap
        //
        //     {
        //         "code": 0,
        //         "dataType": "BTC-USDT@ticker",
        //         "data": {
        //             "e": "24hTicker",
        //             "E": 1706498923556,
        //             "s": "BTC-USDT",
        //             "p": "346.4",
        //             "P": "0.82",
        //             "c": "42432.5",
        //             "L": "0.0529",
        //             "h": "42855.4",
        //             "l": "41578.3",
        //             "v": "64310.9754",
        //             "q": "2728360284.15",
        //             "o": "42086.1",
        //             "O": 1706498922655,
        //             "C": 1706498883023,
        //             "A": "42437.8",
        //             "a": "1.4160",
        //             "B": "42437.1",
        //             "b": "2.5747"
        //         }
        //     }
        //
        // spot
        //
        //     {
        //         "code": 0,
        //         "timestamp": 1706506795473,
        //         "data": {
        //             "e": "24hTicker",
        //             "E": 1706506795472,
        //             "s": "BTC-USDT",
        //             "p": -372.12,
        //             "P": "-0.87%",
        //             "o": 42548.95,
        //             "h": 42696.1,
        //             "l": 41621.29,
        //             "c": 42176.83,
        //             "v": 4943.33,
        //             "q": 208842236.5,
        //             "O": 1706420395472,
        //             "C": 1706506795472,
        //             "A": 42177.23,
        //             "a": 5.14484,
        //             "B": 42176.38,
        //             "b": 5.36117
        //         }
        //     }
        //
        let mut data: Value = self.safe_value_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        // const marketId = messageHash.split('@')[0];
        let mut isSwap: bool = is_greater_than_or_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &Value::Str("swap".to_string())), &Value::Int(0));
        let mut marketType: Value = ternary(is_true(&isSwap), Value::Str("swap".to_string()), Value::Str("spot".to_string()));
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Null, marketType.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut ticker: Value = self.parse_ws_ticker(data.clone(), &[market.clone()]);
        add_element_to_object(&mut self.tickers, &symbol, ticker.clone());
        client.resolve(&[ticker.clone(), self.get_message_hash(Value::Str("ticker".to_string()), &[symbol.clone()])]);
        if is_equal(&self.safe_string_k(message.clone(), "dataType", &[]), &Value::Str("all@ticker".to_string())) {
            client.resolve(&[ticker.clone(), self.get_message_hash(Value::Str("ticker".to_string()), &[])]);
        }
}

    pub fn parse_ws_ticker(&self, mut message: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "e": "24hTicker",
        //         "E": 1706498923556,
        //         "s": "BTC-USDT",
        //         "p": "346.4",
        //         "P": "0.82",
        //         "c": "42432.5",
        //         "L": "0.0529",
        //         "h": "42855.4",
        //         "l": "41578.3",
        //         "v": "64310.9754",
        //         "q": "2728360284.15",
        //         "o": "42086.1",
        //         "O": 1706498922655,
        //         "C": 1706498883023,
        //         "A": "42437.8",
        //         "a": "1.4160",
        //         "B": "42437.1",
        //         "b": "2.5747"
        //     }
        //
        let mut timestamp: Value = self.safe_integer_k(message.clone(), "C", &[]);
        let mut marketId: Value = self.safe_string_k(message.clone(), "s", &[]);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut close: Value = self.safe_string_k(message.clone(), "c", &[]);
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), get_value(&market, &Value::Str("symbol".to_string())));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("high".to_string(), self.safe_string_k(message.clone(), "h", &[]));
        m.insert("low".to_string(), self.safe_string_k(message.clone(), "l", &[]));
        m.insert("bid".to_string(), self.safe_string_k(message.clone(), "B", &[]));
        m.insert("bidVolume".to_string(), self.safe_string_k(message.clone(), "b", &[]));
        m.insert("ask".to_string(), self.safe_string_k(message.clone(), "A", &[]));
        m.insert("askVolume".to_string(), self.safe_string_k(message.clone(), "a", &[]));
        m.insert("vwap".to_string(), Value::Null);
        m.insert("open".to_string(), self.safe_string_k(message.clone(), "o", &[]));
        m.insert("close".to_string(), close.clone());
        m.insert("last".to_string(), close.clone());
        m.insert("previousClose".to_string(), Value::Null);
        m.insert("change".to_string(), self.safe_string_k(message.clone(), "p", &[]));
        m.insert("percentage".to_string(), Value::Null);
        m.insert("average".to_string(), Value::Null);
        m.insert("baseVolume".to_string(), self.safe_string_k(message.clone(), "v", &[]));
        m.insert("quoteVolume".to_string(), self.safe_string_k(message.clone(), "q", &[]));
        m.insert("info".to_string(), message.clone());
    m
}), &[market.clone()]);

    Value::Null
}

    pub fn get_order_book_limit_by_market_type(&self, mut marketType: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        if is_equal(&limit, &Value::Null) {
            limit = Value::Int(100);
        }  else {
            if is_equal(&marketType, &Value::Str("swap".to_string())) || is_equal(&marketType, &Value::Str("future".to_string())) {
                limit = self.find_nearest_ceiling(Value::List(vec![Value::Int(5), Value::Int(10), Value::Int(20), Value::Int(50), Value::Int(100)]), limit.clone());
            }  else if is_equal(&marketType, &Value::Str("spot".to_string())) {
                limit = self.find_nearest_ceiling(Value::List(vec![Value::Int(20), Value::Int(100)]), limit.clone());
            }
        }
        return limit;

    Value::Null
}

    pub fn get_message_hash(&self, mut unifiedChannel: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut extra = get_arg(optional_args, 1, Value::Null);
        let mut hash: Value = unifiedChannel.clone();
        if !is_equal(&symbol, &Value::Null) {
            hash = add(&hash, &add(&Value::Str("::".to_string()), &symbol));
        }  else {
            hash = add(&hash, &Value::Str("s".to_string())); // tickers, orderbooks, ohlcvs, etc ...
        }
        if !is_equal(&extra, &Value::Null) {
            hash = add(&hash, &add(&Value::Str("::".to_string()), &extra));
        }
        return hash;

    Value::Null
}

/*
 * @method
 * @name bingx#watchTrades
 * @description watches information on multiple trades made in a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20the%20Latest%20Trade%20Detail
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {int} [since] the earliest time in ms to fetch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn watch_trades(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut since = get_arg(optional_args, 0, Value::Null);
        let mut limit = get_arg(optional_args, 1, Value::Null);
        let mut params = get_arg(optional_args, 2, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchTrades".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchTrades".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), marketType.clone(), &[]);
        }
        let mut rawHash: Value = add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@trade".to_string()));
        let mut messageHash: Value = add(&Value::Str("trade::".to_string()), &symbol);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), rawHash.clone());
            m
        });
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            add_element_to_object(&mut request, &Value::Str("reqType".to_string()), Value::Str("sub".to_string()));
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        let __ws_arg_2 = self.extend(request.clone(), &[params.clone()]);
        let mut trades: Value = self.watch(url.clone(), messageHash.clone(), &[__ws_arg_2, messageHash.clone(), subscription.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        let mut result: Value = self.filter_by_since_limit(trades.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);
        if is_equal(&self.handle_option(Value::Str("watchTrades".to_string()), Value::Str("ignoreDuplicates".to_string()), &[Value::Bool(true)]), &Value::Bool(true)) {
            let mut filtered: Value = self.remove_repeated_trades_from_array(result.clone());
            filtered = self.sort_by(filtered.clone(), Value::Str("timestamp".to_string()), &[]);
            return filtered;
        }
        return result;

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchTrades
 * @description unsubscribes from the trades channel
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20the%20Latest%20Trade%20Detail
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscription%20transaction%20by%20transaction
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.name] the name of the method to call, 'trade' or 'aggTrade', default is 'trade'
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn un_watch_trades(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut dataType: Value = add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@trade".to_string()));
        let mut subMessageHash: Value = self.get_message_hash(Value::Str("trade".to_string()), &[get_value(&market, &Value::Str("symbol".to_string()))]);
        let mut messageHash: Value = add(&Value::Str("unsubscribe::".to_string()), &subMessageHash);
        let mut topic: Value = Value::Str("trades".to_string());
        let mut methodName: Value = Value::Str("unWatchTrades".to_string());
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), dataType.clone(), topic.clone(), market.clone(), methodName.clone(), &[params.clone()]).await;

    Value::Null
}

    pub fn handle_trades(&mut self, mut client: Value, mut message: Value) {
        //
        // spot: first snapshot
        //
        //    {
        //      "id": "d83b78ce-98be-4dc2-b847-12fe471b5bc5",
        //      "code": 0,
        //      "msg": "SUCCESS",
        //      "timestamp": 1690214699854
        //    }
        //
        // spot: subsequent updates
        //
        //     {
        //         "code": 0,
        //         "data": {
        //           "E": 1690214529432,
        //           "T": 1690214529386,
        //           "e": "trade",
        //           "m": true,
        //           "p": "29110.19",
        //           "q": "0.1868",
        //           "s": "BTC-USDT",
        //           "t": "57903921"
        //         },
        //         "dataType": "BTC-USDT@trade",
        //         "success": true
        //     }
        //
        // linear swap: first snapshot
        //
        //    {
        //        "id": "2aed93b1-6e1e-4038-aeba-f5eeaec2ca48",
        //        "code": 0,
        //        "msg": '',
        //        "dataType": '',
        //        "data": null
        //    }
        //
        // linear swap: subsequent updates
        //
        //    {
        //        "code": 0,
        //        "dataType": "BTC-USDT@trade",
        //        "data": [
        //            {
        //                "q": "0.0421",
        //                "p": "29023.5",
        //                "T": 1690221401344,
        //                "m": false,
        //                "s": "BTC-USDT"
        //            },
        //            ...
        //        ]
        //    }
        //
        // inverse swap: first snapshot
        //
        //     {
        //         "code": 0,
        //         "id": "a2e482ca-f71b-42f8-a83a-8ff85a713e64",
        //         "msg": "SUCCESS",
        //         "timestamp": 1722920589426
        //     }
        //
        // inverse swap: subsequent updates
        //
        //     {
        //         "code": 0,
        //         "dataType": "BTC-USD@trade",
        //         "data": {
        //             "e": "trade",
        //             "E": 1722920589665,
        //             "s": "BTC-USD",
        //             "t": "39125001",
        //             "p": "55360.0",
        //             "q": "1",
        //             "T": 1722920589582,
        //             "m": false
        //         }
        //     }
        //
        let mut data: Value = self.safe_value_k(message.clone(), "data", &[Value::List(vec![])]);
        let mut rawHash: Value = self.safe_string_k(message.clone(), "dataType", &[Value::Str("".to_string())]);
        let mut marketId: Value = get_value(&split(&rawHash, &Value::Str("@".to_string())), &Value::Int(0));
        let mut isSwap: bool = is_greater_than_or_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &Value::Str("swap".to_string())), &Value::Int(0));
        let mut marketType: Value = ternary(is_true(&isSwap), Value::Str("swap".to_string()), Value::Str("spot".to_string()));
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Null, marketType.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&Value::Str("trade::".to_string()), &symbol);
        let mut trades: Value = Value::Null;
        if is_true(&Value::Bool(is_array(&data))) {
            trades = self.parse_trades(data.clone(), &[market.clone()]);
        }  else {
            trades = Value::List(vec![self.parse_trade(data.clone(), &[market.clone()])]);
        }
        let mut stored: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if is_equal(&stored, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            stored = ArrayCache::new(limit.clone());
            add_element_to_object(&mut self.trades, &symbol, stored.clone());
        }
        {
                        let mut j: Value = Value::Int(0);
            let mut __for_first_91: bool = true;
            while { if !__for_first_91 { j = add(&j, &Value::Int(1)); } __for_first_91 = false; is_less_than(&j, &get_array_length(&trades)) } {
            stored.append(get_value(&trades, &j));
        }
        }
        client.resolve(&[stored.clone(), messageHash.clone()]);
}

/*
 * @method
 * @name bingx#watchOrderBook
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20Market%20Depth%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Partial%20Order%20Book%20Depth
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Limited%20Depth
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOrderBook".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOrderBook".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), marketType.clone(), &[]);
        }
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut depth: Value = self.safe_integer_k(options.clone(), "depth", &[Value::Int(100)]);
        let mut subscriptionHash: Value = add(&add(&add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@".to_string())), &Value::Str("depth".to_string())), &self.number_to_string(depth.clone()));
        let mut messageHash: Value = self.get_message_hash(Value::Str("orderbook".to_string()), &[get_value(&market, &Value::Str("symbol".to_string()))]);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), subscriptionHash.clone());
            m
        });
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            add_element_to_object(&mut request, &Value::Str("reqType".to_string()), Value::Str("sub".to_string()));
        }
        let mut subscriptionArgs: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if is_equal(&get_value(&market, &Value::Str("inverse".to_string())), &Value::Bool(true)) {
            subscriptionArgs = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("unsubscribe".to_string(), Value::Bool(false));
                    m.insert("count".to_string(), limit.clone());
                    m.insert("params".to_string(), params.clone());
                m
            });
        }  else {
            subscriptionArgs = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("unsubscribe".to_string(), Value::Bool(false));
                    m.insert("level".to_string(), limit.clone());
                    m.insert("params".to_string(), params.clone());
                m
            });
        }
        let __ws_arg_3 = self.deep_extend(request.clone(), &[params.clone()]);
        let mut orderbook: Value = self.watch(url.clone(), messageHash.clone(), &[__ws_arg_3, subscriptionHash.clone(), subscriptionArgs.clone()]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchOrderBook
 * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/Subscribe%20Market%20Depth%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Partial%20Order%20Book%20Depth
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Limited%20Depth
 * @param {string} symbol unified symbol of the market
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn un_watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut depth: Value = self.safe_integer_k(options.clone(), "depth", &[Value::Int(100)]);
        let mut subMessageHash: Value = add(&add(&add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@".to_string())), &Value::Str("depth".to_string())), &self.number_to_string(depth.clone()));
        let mut messageHash: Value = add(&Value::Str("unsubscribe::".to_string()), &subMessageHash);
        let mut topic: Value = Value::Str("orderbook".to_string());
        let mut methodName: Value = Value::Str("unWatchOrderBook".to_string());
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), subMessageHash.clone(), topic.clone(), market.clone(), methodName.clone(), &[params.clone()]).await;

    Value::Null
}

    pub fn handle_delta(&self, mut bookside: Value, mut delta: Value) {
        let mut price: Value = self.safe_float2(delta.clone(), Value::Int(0), Value::Str("p".to_string()), &[]);
        let mut amount: Value = self.safe_float2(delta.clone(), Value::Int(1), Value::Str("a".to_string()), &[]);
        bookside.store(price.clone(), amount.clone());
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        //
        // spot
        //
        //     {
        //         "code":0,
        //         "data":
        //         {
        //             "asks":[
        //                 ["84119.73","0.000011"],
        //                 ["84116.52","0.000014"],
        //                 ["84116.40","0.000039"]
        //             ],
        //             "bids":[
        //                 ["83656.98","2.570805"],
        //                 ["83655.51","0.000347"],
        //                 ["83654.59","0.000082"]
        //             ],
        //             "lastUpdateId":13565694850
        //         },
        //         "dataType":"BTC-USDT@depth100",
        //         "success":true,
        //         "timestamp":1743241379958
        //     }
        //
        // linear swap
        //
        //     {
        //         "code":0,
        //         "dataType":"BTC-USDT@depth100@500ms",
        //         "ts":1743241563651,
        //         "data":
        //         {
        //             "bids":[
        //                 ["83363.2","0.1908"],
        //                 ["83360.0","0.0003"],
        //                 ["83356.5","0.0245"],
        //             ],
        //             "asks":[
        //                 ["83495.0","0.0024"],
        //                 ["83490.0","0.0001"],
        //                 ["83488.0","0.0004"],
        //             ]
        //         }
        //     }
        //
        // inverse swap
        //
        //     {
        //         "code":0,
        //         "dataType":"BTC-USD@depth100",
        //         "data":{
        //             "symbol":"BTC-USD",
        //             "bids":[
        //                 {"p":"83411.2","a":"2.979216","v":"2485.0"},
        //                 {"p":"83411.1","a":"1.592114","v":"1328.0"},
        //                 {"p":"83410.8","a":"2.656730","v":"2216.0"},
        //             ],
        //             "asks":[
        //                 {"p":"88200.0","a":"0.344671","v":"304.0"},
        //                 {"p":"88023.8","a":"0.045442","v":"40.0"},
        //                 {"p":"88001.0","a":"0.003409","v":"3.0"},
        //             ],
        //             "aggPrecision":"0.1",
        //             "timestamp":1743242290710
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut dataType: Value = self.safe_string_k(message.clone(), "dataType", &[Value::Str("".to_string())]);
        let mut parts: Value = split(&dataType, &Value::Str("@".to_string()));
        let mut firstPart: Value = get_value(&parts, &Value::Int(0));
        let mut isAllEndpoint: bool = is_equal(&firstPart, &Value::Str("all".to_string()));
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[firstPart.clone()]);
        let mut isSwap: bool = is_greater_than_or_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &Value::Str("swap".to_string())), &Value::Int(0));
        let mut marketType: Value = ternary(is_true(&isSwap), Value::Str("swap".to_string()), Value::Str("spot".to_string()));
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Null, marketType.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut orderbook: Value = self.safe_value(self.orderbooks.clone(), symbol.clone(), &[]);
        if is_equal(&orderbook, &Value::Null) {
            // const limit = [ 5, 10, 20, 50, 100 ]
            let mut subscriptionHash: Value = dataType.clone();
            let mut subscription: Value = get_value(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash);
            // see handleOHLCV — subscription.limit may be missing for non-orderbook callers;
            // default to a reasonable depth instead of throwing NPE in the Java port.
            let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[Value::Int(100)]);
            { let __be_tmp = self.order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit.clone()]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
        }
        orderbook = get_value(&self.orderbooks, &symbol);
        let mut snapshot: Value = Value::Null;
        let mut timestamp: Value = self.safe_integer2(message.clone(), Value::Str("timestamp".to_string()), Value::Str("ts".to_string()), &[]);
        timestamp = self.safe_integer2(data.clone(), Value::Str("timestamp".to_string()), Value::Str("ts".to_string()), &[timestamp.clone()]);
        if is_equal(&get_value(&market, &Value::Str("inverse".to_string())), &Value::Bool(true)) {
            snapshot = self.parse_order_book(data.clone(), symbol.clone(), &[timestamp.clone(), Value::Str("bids".to_string()), Value::Str("asks".to_string()), Value::Str("p".to_string()), Value::Str("a".to_string())]);
        }  else {
            snapshot = self.parse_order_book(data.clone(), symbol.clone(), &[timestamp.clone(), Value::Str("bids".to_string()), Value::Str("asks".to_string()), Value::Int(0), Value::Int(1)]);
        }
        let mut nonce: Value = self.safe_integer_k(data.clone(), "lastUpdateId", &[]);
        add_element_to_object(&mut snapshot, &Value::Str("nonce".to_string()), nonce.clone());
        orderbook.reset(snapshot.clone());
        let mut messageHash: Value = self.get_message_hash(Value::Str("orderbook".to_string()), &[symbol.clone()]);
        client.resolve(&[orderbook.clone(), messageHash.clone()]);
        // resolve for "all"
        if is_true(&isAllEndpoint) {
            let mut messageHashForAll: Value = self.get_message_hash(Value::Str("orderbook".to_string()), &[]);
            client.resolve(&[orderbook.clone(), messageHashForAll.clone()]);
        }
}

    pub fn parse_ws_ohlcv(&self, mut ohlcv: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //    {
        //        "c": "28909.0",
        //        "o": "28915.4",
        //        "h": "28915.4",
        //        "l": "28896.1",
        //        "v": "27.6919",
        //        "T": 1696687499999,
        //        "t": 1696687440000
        //    }
        //
        // for spot, opening-time (t) is used instead of closing-time (T), to be compatible with fetchOHLCV
        // for linear swap, (T) is the opening time
        let mut isSpot: bool = is_equal(&self.safe_bool_k(market.clone(), "spot", &[]), &Value::Bool(true));
        let mut isInverse: bool = is_equal(&self.safe_bool_k(market.clone(), "inverse", &[]), &Value::Bool(true));
        let mut timestamp: Value = ternary(is_true(&isSpot), Value::Str("t".to_string()), Value::Str("T".to_string()));
        if is_equal(&self.safe_bool_k(market.clone(), "swap", &[]), &Value::Bool(true)) {
            timestamp = ternary(is_true(&isInverse), Value::Str("t".to_string()), Value::Str("T".to_string()));
        }
        return Value::List(vec![self.safe_integer(ohlcv.clone(), timestamp.clone(), &[]), self.safe_number_k(ohlcv.clone(), "o", &[]), self.safe_number_k(ohlcv.clone(), "h", &[]), self.safe_number_k(ohlcv.clone(), "l", &[]), self.safe_number_k(ohlcv.clone(), "c", &[]), self.safe_number_k(ohlcv.clone(), "v", &[])]);

    Value::Null
}

    pub fn handle_ohlcv(&mut self, mut client: Value, mut message: Value) {
        //
        // spot:
        //
        //   {
        //       "code": 0,
        //       "data": {
        //         "E": 1696687498608,
        //         "K": {
        //           "T": 1696687499999,
        //           "c": "27917.829",
        //           "h": "27918.427",
        //           "i": "1min",
        //           "l": "27917.7",
        //           "n": 262,
        //           "o": "27917.91",
        //           "q": "25715.359197",
        //           "s": "BTC-USDT",
        //           "t": 1696687440000,
        //           "v": "0.921100"
        //         },
        //         "e": "kline",
        //         "s": "BTC-USDT"
        //       },
        //       "dataType": "BTC-USDT@kline_1min",
        //       "success": true
        //   }
        //
        // linear swap:
        //
        //    {
        //        "code": 0,
        //        "dataType": "BTC-USDT@kline_1m",
        //        "s": "BTC-USDT",
        //        "data": [
        //            {
        //            "c": "28909.0",
        //            "o": "28915.4",
        //            "h": "28915.4",
        //            "l": "28896.1",
        //            "v": "27.6919",
        //            "T": 1690907580000
        //            }
        //        ]
        //    }
        //
        // inverse swap:
        //
        //     {
        //         "code": 0,
        //         "timestamp": 1723769354547,
        //         "dataType": "BTC-USD@kline_1m",
        //         "data": {
        //             "t": 1723769340000,
        //             "o": 57485.1,
        //             "c": 57468,
        //             "l": 57464.9,
        //             "h": 57485.1,
        //             "a": 0.189663,
        //             "v": 109,
        //             "u": 92,
        //             "s": "BTC-USD"
        //         }
        //     }
        //
        let mut isSwap: bool = is_greater_than_or_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &Value::Str("swap".to_string())), &Value::Int(0));
        let mut dataType: Value = self.safe_string_k(message.clone(), "dataType", &[Value::Str("".to_string())]);
        let mut parts: Value = split(&dataType, &Value::Str("@".to_string()));
        let mut firstPart: Value = get_value(&parts, &Value::Int(0));
        let mut isAllEndpoint: bool = is_equal(&firstPart, &Value::Str("all".to_string()));
        let mut marketId: Value = self.safe_string_k(message.clone(), "s", &[firstPart.clone()]);
        let mut marketType: Value = ternary(is_true(&isSwap), Value::Str("swap".to_string()), Value::Str("spot".to_string()));
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Null, marketType.clone()]);
        let mut candles: Value = Value::Null;
        if is_true(&isSwap) {
            if is_equal(&get_value(&market, &Value::Str("inverse".to_string())), &Value::Bool(true)) {
                candles = Value::List(vec![self.safe_dict_k(message.clone(), "data", &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})])]);
            }  else {
                candles = self.safe_list_k(message.clone(), "data", &[Value::List(vec![])]);
            }
        }  else {
            let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            candles = Value::List(vec![self.safe_dict_k(data.clone(), "K", &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})])]);
        }
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        { let __be_tmp = self.safe_value(self.ohlcvs.clone(), symbol.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]); add_element_to_object(&mut self.ohlcvs, &symbol, __be_tmp); };
        let mut rawTimeframe: Value = get_value(&split(&dataType, &Value::Str("_".to_string())), &Value::Int(1));
        let mut marketOptions: Value = self.safe_dict(self.options.clone(), marketType.clone(), &[]);
        let mut timeframes: Value = self.safe_dict_k(marketOptions.clone(), "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut unifiedTimeframe: Value = self.find_timeframe(rawTimeframe.clone(), &[timeframes.clone()]);
        if is_equal(&self.safe_value(get_value(&self.ohlcvs, &symbol), rawTimeframe.clone(), &[]), &Value::Null) {
            let mut subscriptionHash: Value = dataType.clone();
            let mut subscription: Value = get_value(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash);
            // subscription.limit is only set when watchOHLCV registers the subscription;
            // when handleMessage routes a non-OHLCV-originated subscription here (or the
            // subscription dict was reset on reconnect), fall back to the OHLCVLimit option.
            let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[self.safe_integer(self.options.clone(), Value::Str("OHLCVLimit".to_string()), &[Value::Int(1000)])]);
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.ohlcvs) }, &symbol), &unifiedTimeframe, ArrayCacheByTimestamp::new(limit.clone()));
        }
        let mut stored: Value = get_value(&get_value(&self.ohlcvs, &symbol), &unifiedTimeframe);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_92: bool = true;
            while { if !__for_first_92 { i = add(&i, &Value::Int(1)); } __for_first_92 = false; is_less_than(&i, &get_array_length(&candles)) } {
            let mut candle: Value = get_value(&candles, &i);
            let mut candle: Value = get_value(&candles, &i);
            let mut parsed: Value = self.parse_ws_ohlcv(candle.clone(), &[market.clone()]);
            stored.append(parsed.clone());
        }
        }
        let mut resolveData: Value = Value::List(vec![symbol.clone(), unifiedTimeframe.clone(), stored.clone()]);
        let mut messageHash: Value = self.get_message_hash(Value::Str("ohlcv".to_string()), &[symbol.clone(), unifiedTimeframe.clone()]);
        client.resolve(&[resolveData.clone(), messageHash.clone()]);
        // resolve for "all"
        if is_true(&isAllEndpoint) {
            let mut messageHashForAll: Value = self.get_message_hash(Value::Str("ohlcv".to_string()), &[Value::Null, unifiedTimeframe.clone()]);
            client.resolve(&[resolveData.clone(), messageHashForAll.clone()]);
        }
}

/*
 * @method
 * @name bingx#watchOHLCV
 * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/K-line%20Streamst
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20K-Line%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Latest%20Trading%20Pair%20K-Line
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {int} [since] timestamp in ms of the earliest candle to fetch
 * @param {int} [limit] the maximum amount of candles to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
    pub async fn watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".to_string()));
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketType: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut url: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOHLCV".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOHLCV".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            url = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), marketType.clone(), &[]);
        }
        if is_equal(&url, &Value::Null) {
            panic!("{}", crate::exchange_errors::bad_request(add(&add(&add(&self.id, &Value::Str(" watchOHLCV is not supported for ".to_string())), &marketType), &Value::Str(" markets.".to_string()))));
        }
        let mut options: Value = self.safe_value(self.options.clone(), marketType.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut timeframes: Value = self.safe_value_k(options.clone(), "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut rawTimeframe: Value = self.safe_string(timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut messageHash: Value = self.get_message_hash(Value::Str("ohlcv".to_string()), &[get_value(&market, &Value::Str("symbol".to_string())), timeframe.clone()]);
        let mut subscriptionHash: Value = add(&add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@kline_".to_string())), &rawTimeframe);
        let mut uuid: Value = self.uuid(&[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("dataType".to_string(), subscriptionHash.clone());
            m
        });
        if is_equal(&marketType, &Value::Str("swap".to_string())) {
            add_element_to_object(&mut request, &Value::Str("reqType".to_string()), Value::Str("sub".to_string()));
        }
        let mut subscriptionArgs: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), uuid.clone());
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("interval".to_string(), rawTimeframe.clone());
                m.insert("params".to_string(), params.clone());
            m
        });
        let __ws_arg_4 = self.extend(request.clone(), &[params.clone()]);
        let mut result: Value = self.watch(url.clone(), messageHash.clone(), &[__ws_arg_4, subscriptionHash.clone(), subscriptionArgs.clone()]).await;
        let mut ohlcv: Value = get_value(&result, &Value::Int(2));
        if is_true(&self.newUpdates) {
            limit = ohlcv.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(ohlcv.clone(), &[since.clone(), limit.clone(), Value::Int(0), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#unWatchOHLCV
 * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Market%20Data/K-line%20Streamst
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Market%20Data/Subscribe%20K-Line%20Data
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Market%20Data/Subscribe%20to%20Latest%20Trading%20Pair%20K-Line
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
    pub async fn un_watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".to_string()));
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut options: Value = self.safe_value(self.options.clone(), get_value(&market, &Value::Str("type".to_string())), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut timeframes: Value = self.safe_value_k(options.clone(), "timeframes", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut rawTimeframe: Value = self.safe_string(timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut subMessageHash: Value = add(&add(&get_value(&market, &Value::Str("id".to_string())), &Value::Str("@kline_".to_string())), &rawTimeframe);
        let mut messageHash: Value = add(&Value::Str("unsubscribe::".to_string()), &subMessageHash);
        let mut topic: Value = Value::Str("ohlcv".to_string());
        let mut methodName: Value = Value::Str("unWatchOHLCV".to_string());
        let mut symbolsAndTimeframes: Value = Value::List(vec![Value::List(vec![get_value(&market, &Value::Str("symbol".to_string())), timeframe.clone()])]);
        add_element_to_object(&mut params, &Value::Str("symbolsAndTimeframes".to_string()), symbolsAndTimeframes.clone());
        return self.un_watch(messageHash.clone(), subMessageHash.clone(), messageHash.clone(), subMessageHash.clone(), topic.clone(), market.clone(), methodName.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name bingx#watchOrders
 * @description watches information on multiple orders made by the user
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/order%20update%20event
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Order%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Order%20update%20push
 * @param {string} [symbol] unified market symbol of the market orders are made in
 * @param {int} [since] the earliest time in ms to watch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn watch_orders(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut market: Value = Value::Null;
        if !is_equal(&symbol, &Value::Null) {
            market = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
        }
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOrders".to_string()), &[market.clone(), params.clone()]); type_var = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchOrders".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut isSpot: bool = is_equal(&type_var, &Value::Str("spot".to_string()));
        let mut spotHash: Value = Value::Str("spot:private".to_string());
        let mut swapHash: Value = Value::Str("swap:private".to_string());
        let mut subscriptionHash: Value = ternary(is_true(&isSpot), spotHash.clone(), swapHash.clone());
        let mut spotMessageHash: Value = Value::Str("spot:order".to_string());
        let mut swapMessageHash: Value = Value::Str("swap:order".to_string());
        let mut messageHash: Value = ternary(is_true(&isSpot), spotMessageHash.clone(), swapMessageHash.clone());
        if !is_equal(&market, &Value::Null) {
            messageHash = add(&messageHash, &add(&Value::Str(":".to_string()), &symbol));
        }
        let mut uuid: Value = self.uuid(&[]);
        let mut baseUrl: Value = Value::Null;
        let mut request: Value = Value::Null;
        if is_equal(&type_var, &Value::Str("swap".to_string())) {
            if is_equal(&subType, &Value::Str("inverse".to_string())) {
                panic!("{}", crate::exchange_errors::not_supported(add(&self.id, &Value::Str(" watchOrders is not supported for inverse swap markets yet".to_string()))));
            }
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), type_var.clone(), &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("reqType".to_string(), Value::Str("sub".to_string()));
                    m.insert("dataType".to_string(), Value::Str("spot.executionReport".to_string()));
                m
            });
        }
        let mut url: Value = add(&add(&baseUrl, &Value::Str("?listenKey=".to_string())), &get_value(&self.options, &Value::Str("listenKey".to_string())));
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        let mut orders: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), subscriptionHash.clone(), subscription.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(orders.clone(), &[symbol.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#watchMyTrades
 * @description watches information on multiple trades made by the user
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/order%20update%20event
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Order%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Order%20update%20push
 * @param {string} [symbol] unified market symbol of the market the trades are made in
 * @param {int} [since] the earliest time in ms to watch trades for
 * @param {int} [limit] the maximum number of trade structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
 */
    pub async fn watch_my_trades(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        let mut market: Value = Value::Null;
        if !is_equal(&symbol, &Value::Null) {
            market = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
        }
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchMyTrades".to_string()), &[market.clone(), params.clone()]); type_var = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchMyTrades".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut isSpot: bool = is_equal(&type_var, &Value::Str("spot".to_string()));
        let mut spotHash: Value = Value::Str("spot:private".to_string());
        let mut swapHash: Value = Value::Str("swap:private".to_string());
        let mut subscriptionHash: Value = ternary(is_true(&isSpot), spotHash.clone(), swapHash.clone());
        let mut spotMessageHash: Value = Value::Str("spot:mytrades".to_string());
        let mut swapMessageHash: Value = Value::Str("swap:mytrades".to_string());
        let mut messageHash: Value = ternary(is_true(&isSpot), spotMessageHash.clone(), swapMessageHash.clone());
        if !is_equal(&market, &Value::Null) {
            messageHash = add(&messageHash, &add(&Value::Str(":".to_string()), &symbol));
        }
        let mut uuid: Value = self.uuid(&[]);
        let mut baseUrl: Value = Value::Null;
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if is_equal(&type_var, &Value::Str("swap".to_string())) {
            if is_equal(&subType, &Value::Str("inverse".to_string())) {
                panic!("{}", crate::exchange_errors::not_supported(add(&self.id, &Value::Str(" watchMyTrades is not supported for inverse swap markets yet".to_string()))));
            }
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), type_var.clone(), &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("reqType".to_string(), Value::Str("sub".to_string()));
                    m.insert("dataType".to_string(), Value::Str("spot.executionReport".to_string()));
                m
            });
        }
        let mut url: Value = add(&add(&baseUrl, &Value::Str("?listenKey=".to_string())), &get_value(&self.options, &Value::Str("listenKey".to_string())));
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        let mut trades: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), subscriptionHash.clone(), subscription.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(trades.clone(), &[symbol.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bingx#watchBalance
 * @description query for balance and get the amount of funds available for trading or funds locked in orders
 * @see https://bingx-api.github.io/docs-v3/#/en/Spot/Websocket%20Account%20Data/Subscription%20account%20balance%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Swap/Websocket%20Account%20Data/Account%20balance%20and%20position%20update%20push
 * @see https://bingx-api.github.io/docs-v3/#/en/Coin-M%20Futures/Websocket%20Account%20Data/Account%20balance%20and%20position%20update%20push
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
 */
    pub async fn watch_balance(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchBalance".to_string()), &[Value::Null, params.clone()]); type_var = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchBalance".to_string()), &[Value::Null, params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut isSpot: bool = is_equal(&type_var, &Value::Str("spot".to_string()));
        let mut spotSubHash: Value = Value::Str("spot:balance".to_string());
        let mut swapSubHash: Value = Value::Str("swap:private".to_string());
        let mut spotMessageHash: Value = Value::Str("spot:balance".to_string());
        let mut swapMessageHash: Value = Value::Str("swap:balance".to_string());
        let mut messageHash: Value = ternary(is_true(&isSpot), spotMessageHash.clone(), swapMessageHash.clone());
        let mut subscriptionHash: Value = ternary(is_true(&isSpot), spotSubHash.clone(), swapSubHash.clone());
        let mut request: Value = Value::Null;
        let mut baseUrl: Value = Value::Null;
        let mut uuid: Value = self.uuid(&[]);
        if is_equal(&type_var, &Value::Str("swap".to_string())) {
            if is_equal(&subType, &Value::Str("inverse".to_string())) {
                panic!("{}", crate::exchange_errors::not_supported(add(&self.id, &Value::Str(" watchBalance is not supported for inverse swap markets yet".to_string()))));
            }
            // swap balance updates are pushed automatically over the listenKey connection,
            // so we must not send a subscription message (an empty one is rejected with 80014)
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        }  else {
            baseUrl = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), type_var.clone(), &[]);
            request = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), uuid.clone());
                    m.insert("dataType".to_string(), Value::Str("ACCOUNT_UPDATE".to_string()));
                m
            });
        }
        let mut url: Value = add(&add(&baseUrl, &Value::Str("?listenKey=".to_string())), &get_value(&self.options, &Value::Str("listenKey".to_string())));
        let mut client: Value = self.client(&[url.clone()]);
        self.set_balance_cache(client.clone(), type_var.clone(), subType.clone(), subscriptionHash.clone(), params.clone());
        let mut fetchBalanceSnapshot: Value = Value::Null;
        let mut awaitBalanceSnapshot: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".to_string()), Value::Str("fetchBalanceSnapshot".to_string()), &[Value::Bool(true)]); fetchBalanceSnapshot = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".to_string()), Value::Str("awaitBalanceSnapshot".to_string()), &[Value::Bool(false)]); awaitBalanceSnapshot = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&fetchBalanceSnapshot) && is_true(&awaitBalanceSnapshot) {
            crate::exchange_stubs::ws_await_flight(&client.future(&[add(&type_var, &Value::Str(":fetchBalanceSnapshot".to_string()))])).await;
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        return self.watch(url.clone(), messageHash.clone(), &[request.clone(), subscriptionHash.clone(), subscription.clone()]).await;

    Value::Null
}

    pub fn set_balance_cache(&mut self, mut client: Value, mut type_var: Value, mut subType: Value, mut subscriptionHash: Value, mut params: Value) {
        if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash))) {
            return;
        }
        let mut fetchBalanceSnapshot: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".to_string()), Value::Str("fetchBalanceSnapshot".to_string()), &[Value::Bool(true)]); fetchBalanceSnapshot = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&fetchBalanceSnapshot) {
            let mut messageHash: Value = add(&type_var, &Value::Str(":fetchBalanceSnapshot".to_string()));
            if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash)))) {
                client.future(&[messageHash.clone()]);
                self.spawn(&[Value::Str("load_balance_snapshot".to_string()).clone(), client.clone(), messageHash.clone(), type_var.clone(), subType.clone()]);
            }
        }  else {
            add_element_to_object(&mut self.balance, &type_var, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        }
}

    pub async fn load_balance_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut type_var: Value, mut subType: Value) -> Value {
        let mut response: Value = self.fetch_balance(&[Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), type_var.clone());
                m.insert("subType".to_string(), subType.clone());
            m
        })]).await;
        let __ws_arg_5 = self.safe_value(self.balance.clone(), type_var.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]);
        { let __be_tmp = self.extend(response.clone(), &[__ws_arg_5]); add_element_to_object(&mut self.balance, &type_var, __be_tmp); };
        // don't remove the future from the .futures cache
        if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash))) {
            let mut future: Value = get_value(&get_value(&client, &Value::Str("futures".to_string())), &messageHash);
            future.resolve(&[]);
            client.resolve(&[get_value(&self.balance, &type_var), add(&type_var, &Value::Str(":balance".to_string()))]);
        }

    Value::Null
}

/*
 * @method
 * @name bingx#watchPositions
 * @description watch all open positions
 * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
 * @param {string[]|undefined} [symbols] list of unified market symbols
 * @param {int} [since] the earliest time in ms to fetch positions for
 * @param {int} [limit] the maximum number of position structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
 */
    pub async fn watch_positions(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("".to_string());
        symbols = self.market_symbols(&[symbols.clone()]);
        if is_true(&(!is_equal(&symbols, &Value::Null))) && !is_true(&self.is_empty(symbols.clone())) {
            market = self.get_market_from_symbols(&[symbols.clone()]);
            messageHash = add(&Value::Str("::".to_string()), &join(&symbols, &Value::Str(",".to_string())));
        }
        let mut type_var: Value = Value::Null;
        let mut subType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchPositions".to_string()), &[market.clone(), params.clone(), Value::Str("swap".to_string())]); type_var = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_sub_type_and_params(Value::Str("watchPositions".to_string()), &[market.clone(), params.clone(), Value::Str("linear".to_string())]); subType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_equal(&type_var, &Value::Str("spot".to_string())) {
            panic!("{}", crate::exchange_errors::not_supported(add(&self.id, &Value::Str(" watchPositions is not supported for spot markets".to_string()))));
        }
        if is_equal(&subType, &Value::Str("inverse".to_string())) {
            panic!("{}", crate::exchange_errors::not_supported(add(&self.id, &Value::Str(" watchPositions is not supported for inverse swap markets yet".to_string()))));
        }
        let mut subscriptionHash: Value = Value::Str("swap:private".to_string());
        messageHash = add(&Value::Str("swap:positions".to_string()), &messageHash);
        let mut baseUrl: Value = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), subType.clone(), &[]);
        let mut url: Value = add(&add(&baseUrl, &Value::Str("?listenKey=".to_string())), &get_value(&self.options, &Value::Str("listenKey".to_string())));
        let mut client: Value = self.client(&[url.clone()]);
        self.set_positions_cache(client.clone(), type_var.clone(), &[symbols.clone()]);
        let mut fetchPositionsSnapshot: Value = Value::Null;
        let mut awaitPositionsSnapshot: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".to_string()), Value::Str("fetchPositionsSnapshot".to_string()), &[Value::Bool(true)]); fetchPositionsSnapshot = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".to_string()), Value::Str("awaitPositionsSnapshot".to_string()), &[Value::Bool(false)]); awaitPositionsSnapshot = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut uuid: Value = self.uuid(&[]);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("unsubscribe".to_string(), Value::Bool(false));
                m.insert("id".to_string(), uuid.clone());
            m
        });
        if is_true(&fetchPositionsSnapshot) && is_true(&awaitPositionsSnapshot) && is_equal(&self.positions, &Value::Null) {
            let mut snapshot: Value = crate::exchange_stubs::ws_await_flight(&client.future(&[add(&type_var, &Value::Str(":fetchPositionsSnapshot".to_string()))])).await;
            return self.filter_by_symbols_since_limit(snapshot.clone(), &[symbols.clone(), since.clone(), limit.clone(), Value::Bool(true)]);
        }
        let mut newPositions: Value = self.watch(url.clone(), messageHash.clone(), &[Value::Null, subscriptionHash.clone(), subscription.clone()]).await;
        if is_true(&self.newUpdates) {
            return newPositions;
        }
        return self.filter_by_symbols_since_limit(self.positions.clone(), &[symbols.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

    pub fn set_positions_cache(&mut self, mut client: Value, mut type_var: Value, optional_args: &[Value]) {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        if !is_equal(&self.positions, &Value::Null) {
            return;
        }
        let mut fetchPositionsSnapshot: Value = self.handle_option(Value::Str("watchPositions".to_string()), Value::Str("fetchPositionsSnapshot".to_string()), &[Value::Bool(true)]);
        if is_equal(&fetchPositionsSnapshot, &Value::Bool(true)) {
            let mut messageHash: Value = add(&type_var, &Value::Str(":fetchPositionsSnapshot".to_string()));
            if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash)))) {
                client.future(&[messageHash.clone()]);
                self.spawn(&[Value::Str("load_positions_snapshot".to_string()).clone(), client.clone(), messageHash.clone(), type_var.clone()]);
            }
        }  else {
            self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        }
}

    pub async fn load_positions_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut type_var: Value) -> Value {
        let mut positions: Value = self.fetch_positions(&[Value::Null, Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), type_var.clone());
                m.insert("subType".to_string(), Value::Str("linear".to_string()));
            m
        })]).await;
        self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        let mut cache: Value = self.positions.clone();
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_93: bool = true;
            while { if !__for_first_93 { i = add(&i, &Value::Int(1)); } __for_first_93 = false; is_less_than(&i, &get_array_length(&positions)) } {
            let mut position: Value = get_value(&positions, &i);
            let mut position: Value = get_value(&positions, &i);
            let mut contracts: Value = self.safe_number_k(position.clone(), "contracts", &[Value::Int(0)]);
            if is_greater_than(&contracts, &Value::Int(0)) {
                cache.append(position.clone());
            }
        }
        }
        // don't remove the future from the .futures cache
        if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash))) {
            let mut future: Value = get_value(&get_value(&client, &Value::Str("futures".to_string())), &messageHash);
            future.resolve(&[cache.clone()]);
            client.resolve(&[cache.clone(), Value::Str("swap:positions".to_string())]);
        }

    Value::Null
}

    pub fn parse_ws_position(&self, mut position: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "s": "LINK-USDT",     // Symbol
        //         "pa": "5.000",        // Position Amount
        //         "ep": "11.2345",      // Entry Price
        //         "up": "0.5000",       // Unrealized PnL
        //         "mt": "isolated",     // Margin Type
        //         "iw": "50.00000000",  // Isolated Wallet
        //         "ps": "LONG"          // Position Side
        //     }
        //
        let mut marketId: Value = self.safe_string_k(position.clone(), "s", &[]);
        let mut contracts: Value = self.safe_string_k(position.clone(), "pa", &[]);
        let mut contractsAbs: Value = crate::precise::Precise::stringAbs(&contracts);
        let mut positionSide: Value = self.safe_string_lower(position.clone(), Value::Str("ps".to_string()), &[]);
        let mut hedged: Value = Value::Bool(true);
        if is_equal(&positionSide, &Value::Str("both".to_string())) {
            hedged = Value::Bool(false);
            if !is_true(&crate::precise::Precise::stringEq(&contracts, &Value::Str("0".to_string()))) {
                if is_true(&crate::precise::Precise::stringLt(&contracts, &Value::Str("0".to_string()))) {
                    positionSide = Value::Str("short".to_string());
                }  else {
                    positionSide = Value::Str("long".to_string());
                }
            }
        }
        let mut marginMode: Value = self.safe_string_k(position.clone(), "mt", &[]);
        let mut collateral: Value = ternary(is_true(&(is_equal(&marginMode, &Value::Str("isolated".to_string())))), self.safe_number_k(position.clone(), "iw", &[]), Value::Null);
        return self.safe_position(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), position.clone());
        m.insert("id".to_string(), Value::Null);
        m.insert("symbol".to_string(), self.safe_symbol(marketId.clone(), &[Value::Null, Value::Null, Value::Str("swap".to_string())]));
        m.insert("notional".to_string(), Value::Null);
        m.insert("marginMode".to_string(), marginMode.clone());
        m.insert("liquidationPrice".to_string(), Value::Null);
        m.insert("entryPrice".to_string(), self.safe_number_k(position.clone(), "ep", &[]));
        m.insert("unrealizedPnl".to_string(), self.safe_number_k(position.clone(), "up", &[]));
        m.insert("percentage".to_string(), Value::Null);
        m.insert("contracts".to_string(), self.parse_number(contractsAbs.clone(), &[]));
        m.insert("contractSize".to_string(), Value::Null);
        m.insert("markPrice".to_string(), Value::Null);
        m.insert("side".to_string(), positionSide.clone());
        m.insert("hedged".to_string(), hedged.clone());
        m.insert("timestamp".to_string(), Value::Null);
        m.insert("datetime".to_string(), Value::Null);
        m.insert("maintenanceMargin".to_string(), Value::Null);
        m.insert("maintenanceMarginPercentage".to_string(), Value::Null);
        m.insert("collateral".to_string(), collateral.clone());
        m.insert("initialMargin".to_string(), Value::Null);
        m.insert("initialMarginPercentage".to_string(), Value::Null);
        m.insert("leverage".to_string(), Value::Null);
        m.insert("marginRatio".to_string(), Value::Null);
    m
}));

    Value::Null
}

    pub fn handle_positions(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "e": "ACCOUNT_UPDATE",
        //         "E": 1696244249320,
        //         "a": {
        //             "m": "ORDER",
        //             "B": [...],
        //             "P": [
        //                 {
        //                     "s": "LINK-USDT",
        //                     "pa": "5.000",
        //                     "ep": "11.2345",
        //                     "up": "0.5000",
        //                     "mt": "isolated",
        //                     "iw": "50.00000000",
        //                     "ps": "LONG"
        //                 }
        //             ]
        //         }
        //     }
        //
        if is_equal(&self.positions, &Value::Null) {
            self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        }
        let mut cache: Value = self.positions.clone();
        let mut data: Value = self.safe_dict_k(message.clone(), "a", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        if !is_true(&(Value::Bool(in_op(&data, &Value::Str("P".to_string()))))) {
            return;
        }
        let mut rawPositions: Value = self.safe_list_k(data.clone(), "P", &[Value::List(vec![])]);
        let mut newPositions: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_94: bool = true;
            while { if !__for_first_94 { i = add(&i, &Value::Int(1)); } __for_first_94 = false; is_less_than(&i, &get_array_length(&rawPositions)) } {
            let mut rawPosition: Value = get_value(&rawPositions, &i);
            let mut rawPosition: Value = get_value(&rawPositions, &i);
            let mut position: Value = self.parse_ws_position(rawPosition.clone(), &[]);
            let mut symbol: Value = self.safe_string_k(position.clone(), "symbol", &[]);
            if is_equal(&symbol, &Value::Null) {
                continue;
            }
            let mut timestamp: Value = self.safe_integer_k(message.clone(), "E", &[]);
            add_element_to_object(&mut position, &Value::Str("timestamp".to_string()), timestamp.clone());
            add_element_to_object(&mut position, &Value::Str("datetime".to_string()), self.iso8601(timestamp.clone()));
            append_to_array(&mut newPositions, position.clone());
            cache.append(position.clone());
        }
        }
        let mut messageHashes: Value = self.find_message_hashes(client.clone(), Value::Str("swap:positions::".to_string()));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_95: bool = true;
            while { if !__for_first_95 { i = add(&i, &Value::Int(1)); } __for_first_95 = false; is_less_than(&i, &get_array_length(&messageHashes)) } {
            let mut messageHash: Value = get_value(&messageHashes, &i);
            let mut messageHash: Value = get_value(&messageHashes, &i);
            let mut parts: Value = split(&messageHash, &Value::Str("::".to_string()));
            let mut symbolsString: Value = get_value(&parts, &Value::Int(1));
            let mut filteredSymbols: Value = split(&symbolsString, &Value::Str(",".to_string()));
            let mut positions: Value = self.filter_by_array(newPositions.clone(), Value::Str("symbol".to_string()), &[filteredSymbols.clone(), Value::Bool(false)]);
            if !is_true(&self.is_empty(positions.clone())) {
                client.resolve(&[positions.clone(), messageHash.clone()]);
            }
        }
        }
        client.resolve(&[newPositions.clone(), Value::Str("swap:positions".to_string())]);
}

    pub fn handle_error_message(&self, mut client: Value, mut message: Value) -> Value {
        //
        // { code: 100400, msg: '', timestamp: 1696245808833 }
        //
        // {
        //     "code": 100500,
        //     "id": "9cd37d32-da98-440b-bd04-37e7dbcf51ad",
        //     "msg": '',
        //     "timestamp": 1696245842307
        // }
        let mut code: Value = self.safe_string_k(message.clone(), "code", &[]);
        let _try_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            if !is_equal(&code, &Value::Null) {
                let mut feedback: Value = add(&add(&self.id, &Value::Str(" ".to_string())), &self.json(message.clone()));
                self.throw_exactly_matched_exception(get_value(&self.exceptions, &Value::Str("exact".to_string())), code.clone(), feedback.clone());
            }
         #[allow(unreachable_code)] { Value::Null }}));
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
            client.reject(&[e.clone()]);
        }
        return Value::Bool(true);

    Value::Null
}

    pub async fn keep_alive_listen_key(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut listenKey: Value = self.safe_string_k(self.options.clone(), "listenKey", &[]);
        if is_equal(&listenKey, &Value::Null) {
            return Value::Null;
        }
        let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
            self.parent.user_auth_private_put_user_data_stream(&[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("listenKey".to_string(), listenKey.clone());
                m
            })]).await; // extend the expiry
         #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let error: Value = panic_to_value(_try_err);
            let mut types: Value = Value::List(vec![Value::Str("spot".to_string()), Value::Str("linear".to_string()), Value::Str("inverse".to_string())]);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_97: bool = true;
                while { if !__for_first_97 { i = add(&i, &Value::Int(1)); } __for_first_97 = false; is_less_than(&i, &get_array_length(&types)) } {
                let mut type_var: Value = get_value(&types, &i);
                let mut type_var: Value = get_value(&types, &i);
                let mut baseUrl: Value = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), type_var.clone(), &[]);
                if is_equal(&baseUrl, &Value::Null) {
                    continue;
                }
                let mut url: Value = add(&add(&baseUrl, &Value::Str("?listenKey=".to_string())), &listenKey);
                let mut client: Value = self.client(&[url.clone()]);
                let mut messageHashes: Value = object_keys(&get_value(&client, &Value::Str("futures".to_string())));
                {
                                        let mut j: Value = Value::Int(0);
                    let mut __for_first_96: bool = true;
                    while { if !__for_first_96 { j = add(&j, &Value::Int(1)); } __for_first_96 = false; is_less_than(&j, &get_array_length(&messageHashes)) } {
                    let mut messageHash: Value = get_value(&messageHashes, &j);
                    let mut messageHash: Value = get_value(&messageHashes, &j);
                    client.reject(&[Value::from(error.clone()), messageHash.clone()]);
                }
                }
            }
            }
            add_element_to_object(&mut self.options, &Value::Str("listenKey".to_string()), Value::Null);
            add_element_to_object(&mut self.options, &Value::Str("lastAuthenticatedTime".to_string()), Value::Int(0));
            return Value::Null;
        }
        // whether or not to schedule another listenKey keepAlive request
        let mut listenKeyRefreshRate: Value = self.safe_integer_k(self.options.clone(), "listenKeyRefreshRate", &[Value::Int(3600000)]);
        self.delay(listenKeyRefreshRate.clone(), &[Value::Str("keep_alive_listen_key".to_string()).clone(), params.clone()]).await;

    Value::Null
}

    pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut time: Value = self.milliseconds();
        let mut lastAuthenticatedTime: Value = self.safe_integer_k(self.options.clone(), "lastAuthenticatedTime", &[Value::Int(0)]);
        let mut listenKeyRefreshRate: Value = self.safe_integer_k(self.options.clone(), "listenKeyRefreshRate", &[Value::Int(3600000)]); // 1 hour
        if is_greater_than(&subtract(&time, &lastAuthenticatedTime), &listenKeyRefreshRate) {
            // single-flight leader election on a never-dialed client, see
            // https://github.com/ccxt/ccxt/issues/29393: racing fetches mint
            // different keys and the key rides the private url, so losers
            // connect their watchers to an orphaned stream. client.futures is
            // the registry: client.future () is the atomic check-and-insert
            // and client.resolve () / client.reject () settle and remove the
            // entry under the same lock in every port
            let mut messageHash: Value = Value::Str("authenticate".to_string());
            let mut client: Value = self.client(&[Value::Str("authenticationFlights".to_string())]);
            if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash))) {
                // a flight is already in progress - wake when the leader
                // settles it: the listenKey is then in the bucket
                crate::exchange_stubs::ws_await_flight(&client.future(&[messageHash.clone()])).await;
                return Value::Null;
            }
            // reusableFuture (), not future () - the two match in
            // js/py/php/cs/java, but go's Client.Future () yields a channel
            // that the trailing suspension point below would panic on
            let mut future: Value = client.reusable_future(messageHash.clone());
            let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
                let mut response: Value = self.parent.user_auth_private_post_user_data_stream(&[]).await;
                let mut listenKey: Value = self.safe_string_k(response.clone(), "listenKey", &[]);
                if is_equal(&listenKey, &Value::Null) {
                    panic!("{}", crate::exchange_errors::authentication_error(add(&self.id, &Value::Str(" authenticate() received an empty listenKey".to_string()))));
                }
                add_element_to_object(&mut self.options, &Value::Str("listenKey".to_string()), listenKey.clone());
                add_element_to_object(&mut self.options, &Value::Str("lastAuthenticatedTime".to_string()), time.clone());
                self.delay(listenKeyRefreshRate.clone(), &[Value::Str("keep_alive_listen_key".to_string()).clone(), params.clone()]).await;
                // settle the flight: client.resolve () removes the future from
                // client.futures and wakes every waiter
                client.resolve(&[listenKey.clone(), messageHash.clone()]);
             #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
                // reject the flight - waiters throw and the next caller re-leads.
                // no rethrow here, the trailing suspension point rethrows to this
                // caller AND attaches the handler an alone leader needs
                client.reject(&[e.clone(), messageHash.clone()]);
            }
            crate::exchange_stubs::ws_await_flight(&future).await;
        }

    Value::Null
}

    pub async fn pong(&mut self, mut client: Value, mut message: Value) -> Value {
        let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
            if is_equal(&message, &Value::Str("Ping".to_string())) {
                client.send(&[Value::Str("Pong".to_string())]);
            }  else {
                let mut ping: Value = self.safe_string_k(message.clone(), "ping", &[]);
                let mut time: Value = self.safe_string_k(message.clone(), "time", &[]);
                client.send(&[Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("pong".to_string(), ping.clone());
                        m.insert("time".to_string(), time.clone());
                    m
                })]);
            }
         #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
            let mut error = Value::from(crate::exchange_errors::network_error(add(&add(&self.id, &Value::Str(" pong failed with error ".to_string())), &self.exception_message(e.clone(), &[]))));
            client.reset(error.clone());
        }

    Value::Null
}

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //            "e": "executionReport",
        //            "E": 1694680212947,
        //            "s": "LTC-USDT",
        //            "S": "BUY",
        //            "o": "LIMIT",
        //            "q": 0.1,
        //            "p": 50,
        //            "x": "NEW",
        //            "X": "PENDING",
        //            "i": 1702238305204043800,
        //            "l": 0,
        //            "z": 0,
        //            "L": 0,
        //            "n": 0,
        //            "N": "",
        //            "T": 0,
        //            "t": 0,
        //            "O": 1694680212676,
        //            "Z": 0,
        //            "Y": 0,
        //            "Q": 0,
        //            "m": false
        //         }
        //      }
        //
        //      {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //           "e": "executionReport",
        //           "E": 1694681809302,
        //           "s": "LTC-USDT",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": 0,
        //           "p": 62.29,
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "i": "1702245001712369664",
        //           "l": 0.0802,
        //           "z": 0.0802,
        //           "L": 62.308,
        //           "n": -0.0000802,
        //           "N": "LTC",
        //           "T": 1694681809256,
        //           "t": 38259147,
        //           "O": 1694681809248,
        //           "Z": 4.9971016,
        //           "Y": 4.9971016,
        //           "Q": 5,
        //           "m": false
        //         }
        //       }
        // swap
        //    {
        //        "e": "ORDER_TRADE_UPDATE",
        //        "E": 1696843635475,
        //        "o": {
        //           "s": "LTC-USDT",
        //           "c": "",
        //           "i": "1711312357852147712",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": "0.10000000",
        //           "p": "64.35010000",
        //           "ap": "64.36000000",
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "N": "USDT",
        //           "n": "-0.00321800",
        //           "T": 0,
        //           "wt": "MARK_PRICE",
        //           "ps": "LONG",
        //           "rp": "0.00000000",
        //           "z": "0.10000000"
        //        }
        //    }
        //
        let mut isSpot: Value = (Value::Bool(in_op(&message, &Value::Str("dataType".to_string()))));
        let mut data: Value = self.safe_value2(message.clone(), Value::Str("data".to_string()), Value::Str("o".to_string()), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        if is_equal(&self.orders, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
            self.orders = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut stored: Value = self.orders.clone();
        let mut parsedOrder: Value = self.parse_order(data.clone(), &[]);
        stored.append(parsedOrder.clone());
        let mut symbol: Value = get_value(&parsedOrder, &Value::Str("symbol".to_string()));
        let mut spotHash: Value = Value::Str("spot:order".to_string());
        let mut swapHash: Value = Value::Str("swap:order".to_string());
        let mut messageHash: Value = ternary(is_true(&(isSpot)), spotHash.clone(), swapHash.clone());
        client.resolve(&[stored.clone(), messageHash.clone()]);
        client.resolve(&[stored.clone(), add(&add(&messageHash, &Value::Str(":".to_string())), &symbol)]);
}

    pub fn handle_my_trades(&mut self, mut client: Value, mut message: Value) {
        //
        //
        //      {
        //         "code": 0,
        //         "dataType": "spot.executionReport",
        //         "data": {
        //           "e": "executionReport",
        //           "E": 1694681809302,
        //           "s": "LTC-USDT",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": 0,
        //           "p": 62.29,
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "i": "1702245001712369664",
        //           "l": 0.0802,
        //           "z": 0.0802,
        //           "L": 62.308,
        //           "n": -0.0000802,
        //           "N": "LTC",
        //           "T": 1694681809256,
        //           "t": 38259147,
        //           "O": 1694681809248,
        //           "Z": 4.9971016,
        //           "Y": 4.9971016,
        //           "Q": 5,
        //           "m": false
        //         }
        //       }
        //
        //  swap
        //    {
        //        "e": "ORDER_TRADE_UPDATE",
        //        "E": 1696843635475,
        //        "o": {
        //           "s": "LTC-USDT",
        //           "c": "",
        //           "i": "1711312357852147712",
        //           "S": "BUY",
        //           "o": "MARKET",
        //           "q": "0.10000000",
        //           "p": "64.35010000",
        //           "ap": "64.36000000",
        //           "x": "TRADE",
        //           "X": "FILLED",
        //           "N": "USDT",
        //           "n": "-0.00321800",
        //           "T": 0,
        //           "wt": "MARK_PRICE",
        //           "ps": "LONG",
        //           "rp": "0.00000000",
        //           "z": "0.10000000"
        //        }
        //    }
        //
        let mut isSpot: Value = (Value::Bool(in_op(&message, &Value::Str("dataType".to_string()))));
        let mut result: Value = self.safe_dict2(message.clone(), Value::Str("data".to_string()), Value::Str("o".to_string()), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut cachedTrades: Value = self.myTrades.clone();
        if is_equal(&cachedTrades, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            cachedTrades = ArrayCacheBySymbolById::new(limit.clone());
            self.myTrades = cachedTrades.clone();
        }
        let mut type_var: Value = ternary(is_true(&isSpot), Value::Str("spot".to_string()), Value::Str("swap".to_string()));
        let mut marketId: Value = self.safe_string_k(result.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Str("-".to_string()), type_var.clone()]);
        let mut parsed: Value = self.parse_trade(result.clone(), &[market.clone()]);
        let mut symbol: Value = get_value(&parsed, &Value::Str("symbol".to_string()));
        let mut spotHash: Value = Value::Str("spot:mytrades".to_string());
        let mut swapHash: Value = Value::Str("swap:mytrades".to_string());
        let mut messageHash: Value = ternary(is_true(&isSpot), spotHash.clone(), swapHash.clone());
        cachedTrades.append(parsed.clone());
        client.resolve(&[cachedTrades.clone(), messageHash.clone()]);
        client.resolve(&[cachedTrades.clone(), add(&add(&messageHash, &Value::Str(":".to_string())), &symbol)]);
}

    pub fn handle_balance(&mut self, mut client: Value, mut message: Value) {
        // spot
        //     {
        //         "e":"ACCOUNT_UPDATE",
        //         "E":1696242817000,
        //         "T":1696242817142,
        //         "a":{
        //            "B":[
        //               {
        //                  "a":"USDT",
        //                  "bc":"-1.00000000000000000000",
        //                  "cw":"86.59497382000000050000",
        //                  "wb":"86.59497382000000050000"
        //               }
        //            ],
        //            "m":"ASSET_TRANSFER"
        //         }
        //     }
        // swap
        //     {
        //         "e":"ACCOUNT_UPDATE",
        //         "E":1696244249320,
        //         "a":{
        //            "m":"WITHDRAW",
        //            "B":[
        //               {
        //                  "a":"USDT",
        //                  "wb":"49.81083984",
        //                  "cw":"49.81083984",
        //                  "bc":"-1.00000000"
        //               }
        //            ],
        //            "P":[
        //            ]
        //         }
        //     }
        //
        let mut a: Value = self.safe_dict_k(message.clone(), "a", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut data: Value = self.safe_list_k(a.clone(), "B", &[Value::List(vec![])]);
        let mut timestamp: Value = self.safe_integer2(message.clone(), Value::Str("T".to_string()), Value::Str("E".to_string()), &[]);
        let mut spotUrl: Value = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), Value::Str("spot".to_string()), &[]);
        let mut isSpot: bool = is_true(&(!is_equal(&spotUrl, &Value::Null))) && is_true(&(is_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &spotUrl), &Value::Int(0))));
        let mut type_var: Value = ternary(is_true(&isSpot), Value::Str("spot".to_string()), Value::Str("swap".to_string()));
        if !is_true(&(Value::Bool(in_op(&self.balance, &type_var)))) {
            add_element_to_object(&mut self.balance, &type_var, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        }
        add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.balance) }, &type_var), &Value::Str("info".to_string()), data.clone());
        add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.balance) }, &type_var), &Value::Str("timestamp".to_string()), timestamp.clone());
        { let __be_tmp = self.iso8601(timestamp.clone()); add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.balance) }, &type_var), &Value::Str("datetime".to_string()), __be_tmp); };
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_98: bool = true;
            while { if !__for_first_98 { i = add(&i, &Value::Int(1)); } __for_first_98 = false; is_less_than(&i, &get_array_length(&data)) } {
            let mut balance: Value = get_value(&data, &i);
            let mut balance: Value = get_value(&data, &i);
            let mut currencyId: Value = self.safe_string_k(balance.clone(), "a", &[]);
            let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
            let mut account: Value = self.account();
            add_element_to_object(&mut account, &Value::Str("info".to_string()), balance.clone());
            add_element_to_object(&mut account, &Value::Str("used".to_string()), self.safe_string_k(balance.clone(), "lk", &[]));
            add_element_to_object(&mut account, &Value::Str("free".to_string()), self.safe_string_k(balance.clone(), "wb", &[]));
            if is_true(&(!is_equal(&type_var, &Value::Null))) && is_true(&(!is_equal(&code, &Value::Null))) {
                add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.balance) }, &type_var), &code, account.clone());
            }
        }
        }
        { let __be_tmp = self.safe_balance(get_value(&self.balance, &type_var)); add_element_to_object(&mut self.balance, &type_var, __be_tmp); };
        client.resolve(&[get_value(&self.balance, &type_var), add(&type_var, &Value::Str(":balance".to_string()))]);
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        if !is_true(&self.handle_error_message(client.clone(), message.clone())) {
            return;
        }
        // public subscriptions
        if is_true(&(is_equal(&message, &Value::Str("Ping".to_string())))) || is_true(&(Value::Bool(in_op(&message, &Value::Str("ping".to_string()))))) {
            self.spawn(&[Value::Str("pong".to_string()).clone(), client.clone(), message.clone()]);
            return;
        }
        let mut dataType: Value = self.safe_string_k(message.clone(), "dataType", &[Value::Str("".to_string())]);
        if is_greater_than_or_equal(&get_index_of(&dataType, &Value::Str("@depth".to_string())), &Value::Int(0)) {
            self.handle_order_book(client.clone(), message.clone());
            return;
        }
        if is_greater_than_or_equal(&get_index_of(&dataType, &Value::Str("@ticker".to_string())), &Value::Int(0)) {
            self.handle_ticker(client.clone(), message.clone());
            return;
        }
        if is_greater_than_or_equal(&get_index_of(&dataType, &Value::Str("@trade".to_string())), &Value::Int(0)) {
            self.handle_trades(client.clone(), message.clone());
            return;
        }
        if is_greater_than_or_equal(&get_index_of(&dataType, &Value::Str("@kline".to_string())), &Value::Int(0)) {
            self.handle_ohlcv(client.clone(), message.clone());
            return;
        }
        if is_greater_than_or_equal(&get_index_of(&dataType, &Value::Str("executionReport".to_string())), &Value::Int(0)) {
            let mut data: Value = self.safe_value_k(message.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut type_var: Value = self.safe_string_k(data.clone(), "x", &[]);
            if is_equal(&type_var, &Value::Str("TRADE".to_string())) {
                self.handle_my_trades(client.clone(), message.clone());
            }
            self.handle_order(client.clone(), message.clone());
            return;
        }
        let mut e: Value = self.safe_string_k(message.clone(), "e", &[]);
        if is_equal(&e, &Value::Str("ACCOUNT_UPDATE".to_string())) {
            self.handle_balance(client.clone(), message.clone());
            self.handle_positions(client.clone(), message.clone());
        }
        if is_equal(&e, &Value::Str("ORDER_TRADE_UPDATE".to_string())) {
            self.handle_order(client.clone(), message.clone());
            let mut data: Value = self.safe_value_k(message.clone(), "o", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut type_var: Value = self.safe_string_k(data.clone(), "x", &[]);
            let mut status: Value = self.safe_string_k(data.clone(), "X", &[]);
            if is_true(&(is_equal(&type_var, &Value::Str("TRADE".to_string())))) && is_true(&(is_equal(&status, &Value::Str("FILLED".to_string())))) {
                self.handle_my_trades(client.clone(), message.clone());
            }
        }
        let mut msgData: Value = self.safe_value_k(message.clone(), "data", &[]);
        let mut msgEvent: Value = self.safe_string_k(msgData.clone(), "e", &[]);
        if is_equal(&msgEvent, &Value::Str("24hTicker".to_string())) {
            self.handle_ticker(client.clone(), message.clone());
        }
        if is_equal(&dataType, &Value::Str("".to_string())) && is_equal(&msgEvent, &Value::Null) && is_equal(&e, &Value::Null) {
            self.handle_subscription_status(client.clone(), message.clone());
        }
}

    pub fn handle_subscription_status(&mut self, mut client: Value, mut message: Value) -> Value {
        //
        //     {
        //         "code": 0,
        //         "id": "b6ed9cb4-f3d0-4641-ac3f-f59eb47a3abd",
        //         "msg": "SUCCESS",
        //         "timestamp": 1759225965363
        //     }
        //
        let mut id: Value = self.safe_string_k(message.clone(), "id", &[]);
        let mut subscriptionsById: Value = self.index_by(get_value(&client, &Value::Str("subscriptions".to_string())), Value::Str("id".to_string()));
        let mut subscription: Value = self.safe_dict(subscriptionsById.clone(), id.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut isUnSubMessage: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
        if is_equal(&isUnSubMessage, &Value::Bool(true)) {
            self.handle_un_subscription(client.clone(), subscription.clone());
        }
        return message;

    Value::Null
}

    pub fn handle_un_subscription(&mut self, mut client: Value, mut subscription: Value) {
        let mut messageHashes: Value = self.safe_list_k(subscription.clone(), "messageHashes", &[Value::List(vec![])]);
        let mut subMessageHashes: Value = self.safe_list_k(subscription.clone(), "subMessageHashes", &[Value::List(vec![])]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_99: bool = true;
            while { if !__for_first_99 { i = add(&i, &Value::Int(1)); } __for_first_99 = false; is_less_than(&i, &get_array_length(&messageHashes)) } {
            let mut unsubHash: Value = get_value(&messageHashes, &i);
            let mut unsubHash: Value = get_value(&messageHashes, &i);
            let mut subHash: Value = get_value(&subMessageHashes, &i);
            let mut subHash: Value = get_value(&subMessageHashes, &i);
            self.clean_unsubscription(client.clone(), subHash.clone(), unsubHash.clone(), &[]);
        }
        }
        self.clean_cache(subscription.clone());
}
}