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 KucoinCore {
    pub parent: crate::exchanges::kucoin::KucoinCore,
}

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

    pub fn init(&mut self) {
        let described = KucoinCore::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 KucoinCore {
    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 KucoinCore {
    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_uta" => self.authenticate_uta().await,
                "get_cache_index" => self.get_cache_index(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "get_current_position" => self.get_current_position(args.get(0).cloned().unwrap_or(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_my_trades_message_hash_suffix" => self.get_my_trades_message_hash_suffix(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "get_orders_message_hash_suffix" => self.get_orders_message_hash_suffix(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "get_uta_url" => self.get_uta_url().await,
                "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_system_status" => self.handle_system_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "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)).await,
                "load_position_snapshot" => self.load_position_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,
                "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,
                "negotiate" => self.negotiate(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "negotiate_helper" => self.negotiate_helper(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()[..]).await,
                "parse_ws_bid_ask" => self.parse_ws_bid_ask(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_funding_rate" => self.parse_ws_funding_rate(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_uta_order" => self.parse_ws_uta_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_uta_position" => self.parse_ws_uta_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_uta_ticker" => self.parse_ws_uta_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_uta_trade" => self.parse_ws_uta_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "ping" => self.ping(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "request_id" => self.request_id(),
                "subscribe" => self.subscribe(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..).unwrap_or(&[]).to_vec()[..]).await,
                "subscribe_multiple" => self.subscribe_multiple(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..).unwrap_or(&[]).to_vec()[..]).await,
                "subscribe_private_uta" => self.subscribe_private_uta(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..).unwrap_or(&[]).to_vec()[..]).await,
                "subscribe_public_multiple_uta" => self.subscribe_public_multiple_uta(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..).unwrap_or(&[]).to_vec()[..]).await,
                "subscribe_public_uta" => self.subscribe_public_uta(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..).unwrap_or(&[]).to_vec()[..]).await,
                "un_subscribe" => self.un_subscribe(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..).unwrap_or(&[]).to_vec()[..]).await,
                "un_subscribe_multiple" => self.un_subscribe_multiple(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..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_funding_rate" => self.un_watch_funding_rate(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_mark_price" => self.un_watch_mark_price(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).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_order_book_for_symbols" => self.un_watch_order_book_for_symbols(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,
                "un_watch_trades_for_symbols" => self.un_watch_trades_for_symbols(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_bids_asks" => self.watch_bids_asks(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_funding_rate" => self.watch_funding_rate(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_mark_price" => self.watch_mark_price(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_multi_helper" => self.watch_multi_helper(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..).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_order_book_for_symbols" => self.watch_order_book_for_symbols(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_position" => self.watch_position(&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_tickers" => self.watch_tickers(&args.get(0..).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,
                "watch_trades_for_symbols" => self.watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_uta_tickers" => self.watch_uta_tickers(&args.get(0..).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 KucoinCore {
    /// 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_uta" => { crate::exchange_stubs::enqueue_spawn("authenticate_uta", args.to_vec()); crate::Value::Null },
            "get_cache_index" => self.get_cache_index(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "get_current_position" => self.get_current_position(args.get(0).cloned().unwrap_or(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_my_trades_message_hash_suffix" => self.get_my_trades_message_hash_suffix(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "get_orders_message_hash_suffix" => self.get_orders_message_hash_suffix(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "get_uta_url" => { crate::exchange_stubs::enqueue_spawn("get_uta_url", args.to_vec()); crate::Value::Null },
            "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_bid_ask" => { self.handle_bid_ask(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_bid_asks" => { self.handle_bid_asks(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_contract_ticker" => { self.handle_contract_ticker(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_trade" => { self.handle_my_trade(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_order_book_subscription" => { self.handle_order_book_subscription(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)); crate::Value::Null },
            "handle_pong" => { self.handle_pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_position" => { self.handle_position(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_subject" => { self.handle_subject(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)); crate::Value::Null },
            "handle_system_status" => self.handle_system_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_trade" => { self.handle_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_balance" => { self.handle_uta_balance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_funding_rate" => { self.handle_uta_funding_rate(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_my_trade" => { self.handle_uta_my_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_ohlcv" => { self.handle_uta_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_order" => { self.handle_uta_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_order_book" => { self.handle_uta_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_position" => { self.handle_uta_position(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_ticker" => { self.handle_uta_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_uta_trade" => { self.handle_uta_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "load_balance_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_balance_snapshot", args.to_vec()); crate::Value::Null },
            "load_position_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_position_snapshot", args.to_vec()); crate::Value::Null },
            "load_positions_snapshot" => { crate::exchange_stubs::enqueue_spawn("load_positions_snapshot", args.to_vec()); crate::Value::Null },
            "negotiate" => { crate::exchange_stubs::enqueue_spawn("negotiate", args.to_vec()); crate::Value::Null },
            "negotiate_helper" => { crate::exchange_stubs::enqueue_spawn("negotiate_helper", args.to_vec()); crate::Value::Null },
            "parse_ws_bid_ask" => self.parse_ws_bid_ask(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_funding_rate" => self.parse_ws_funding_rate(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_uta_order" => self.parse_ws_uta_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_uta_position" => self.parse_ws_uta_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_uta_ticker" => self.parse_ws_uta_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_uta_trade" => self.parse_ws_uta_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "ping" => self.ping(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "request_id" => self.request_id(),
            "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)); crate::Value::Null },
            "set_position_cache" => { self.set_position_cache(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).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)); crate::Value::Null },
            "subscribe" => { crate::exchange_stubs::enqueue_spawn("subscribe", args.to_vec()); crate::Value::Null },
            "subscribe_multiple" => { crate::exchange_stubs::enqueue_spawn("subscribe_multiple", args.to_vec()); crate::Value::Null },
            "subscribe_private_uta" => { crate::exchange_stubs::enqueue_spawn("subscribe_private_uta", args.to_vec()); crate::Value::Null },
            "subscribe_public_multiple_uta" => { crate::exchange_stubs::enqueue_spawn("subscribe_public_multiple_uta", args.to_vec()); crate::Value::Null },
            "subscribe_public_uta" => { crate::exchange_stubs::enqueue_spawn("subscribe_public_uta", args.to_vec()); crate::Value::Null },
            "un_subscribe" => { crate::exchange_stubs::enqueue_spawn("un_subscribe", args.to_vec()); crate::Value::Null },
            "un_subscribe_multiple" => { crate::exchange_stubs::enqueue_spawn("un_subscribe_multiple", args.to_vec()); crate::Value::Null },
            "un_watch_funding_rate" => { crate::exchange_stubs::enqueue_spawn("un_watch_funding_rate", args.to_vec()); crate::Value::Null },
            "un_watch_mark_price" => { crate::exchange_stubs::enqueue_spawn("un_watch_mark_price", 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_order_book_for_symbols" => { crate::exchange_stubs::enqueue_spawn("un_watch_order_book_for_symbols", 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 },
            "un_watch_trades_for_symbols" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades_for_symbols", args.to_vec()); crate::Value::Null },
            "watch_balance" => { crate::exchange_stubs::enqueue_spawn("watch_balance", args.to_vec()); crate::Value::Null },
            "watch_bids_asks" => { crate::exchange_stubs::enqueue_spawn("watch_bids_asks", args.to_vec()); crate::Value::Null },
            "watch_funding_rate" => { crate::exchange_stubs::enqueue_spawn("watch_funding_rate", args.to_vec()); crate::Value::Null },
            "watch_mark_price" => { crate::exchange_stubs::enqueue_spawn("watch_mark_price", args.to_vec()); crate::Value::Null },
            "watch_multi_helper" => { crate::exchange_stubs::enqueue_spawn("watch_multi_helper", 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_order_book_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_order_book_for_symbols", args.to_vec()); crate::Value::Null },
            "watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
            "watch_position" => { crate::exchange_stubs::enqueue_spawn("watch_position", 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_tickers" => { crate::exchange_stubs::enqueue_spawn("watch_tickers", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            "watch_trades_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_trades_for_symbols", args.to_vec()); crate::Value::Null },
            "watch_uta_tickers" => { crate::exchange_stubs::enqueue_spawn("watch_uta_tickers", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

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

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

impl KucoinCore {
    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("createOrderWs".to_string(), Value::Bool(false));
        m.insert("editOrderWs".to_string(), Value::Bool(false));
        m.insert("fetchOpenOrdersWs".to_string(), Value::Bool(false));
        m.insert("fetchOrderWs".to_string(), Value::Bool(false));
        m.insert("cancelOrderWs".to_string(), Value::Bool(false));
        m.insert("cancelOrdersWs".to_string(), Value::Bool(false));
        m.insert("cancelAllOrdersWs".to_string(), Value::Bool(false));
        m.insert("watchBidsAsks".to_string(), Value::Bool(true));
        m.insert("watchFundingRate".to_string(), Value::Bool(true));
        m.insert("watchMarkPrice".to_string(), Value::Bool(true));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchPosition".to_string(), Value::Bool(true));
        m.insert("watchPositions".to_string(), Value::Bool(true));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(true));
        m.insert("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(true));
        m.insert("watchOrderBookForSymbols".to_string(), Value::Bool(true));
        m.insert("watchBalance".to_string(), Value::Bool(true));
        m.insert("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchFundingRate".to_string(), Value::Bool(true));
        m.insert("unWatchMarkPrice".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBook".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
        m.insert("unWatchTradesForSymbols".to_string(), Value::Bool(true));
    m
}));
        m.insert("urls".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        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://x-push-spot.kucoin.com".to_string()));
        m.insert("futures".to_string(), Value::Str("wss://x-push-futures.kucoin.com".to_string()));
        m.insert("private".to_string(), Value::Str("wss://wsapi-push.kucoin.com".to_string()));
    m
}));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("utaToken".to_string(), Value::Null);
        m.insert("utaTokenLastUpdate".to_string(), Value::Int(0));
        m.insert("utaTokenRefreshInterval".to_string(), multiply(&multiply(&multiply(&Value::Int(1000), &Value::Int(60)), &Value::Int(60)), &Value::Int(24)));
        m.insert("tradesLimit".to_string(), Value::Int(1000));
        m.insert("watchTicker".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("spotMethod".to_string(), Value::Str("/market/snapshot".to_string()));
    m
}));
        m.insert("watchOrderBook".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("snapshotDelay".to_string(), Value::Int(5));
        m.insert("snapshotMaxRetries".to_string(), Value::Int(3));
        m.insert("utaDepth".to_string(), Value::Str("increment".to_string()));
        m.insert("spotMethod".to_string(), Value::Str("/market/level2".to_string()));
        m.insert("contractMethod".to_string(), Value::Str("/contractMarket/level2".to_string()));
    m
}));
        m.insert("watchMyTrades".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("spotMethod".to_string(), Value::Str("/spotMarket/tradeOrders".to_string()));
    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("watchPosition".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("fetchPositionSnapshot".to_string(), Value::Bool(true));
        m.insert("awaitPositionSnapshot".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(true));
    m
}));
    m
}));
        m.insert("streaming".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ping".to_string(), Value::Str("ping".to_string()).clone());
    m
}));
    m
})]);

    Value::Null
}

    pub async fn negotiate(&mut self, mut privateChannel: Value, optional_args: &[Value]) -> Value {
        let mut isFuturesMethod = get_arg(optional_args, 0, Value::Bool(false));
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut connectId: Value = ternary(is_true(&(is_equal(&privateChannel, &Value::Bool(true)))), Value::Str("private".to_string()), Value::Str("public".to_string()));
        if is_true(&isFuturesMethod) {
            connectId = add(&connectId, &Value::Str("Futures".to_string()));
        }
        let mut urls: Value = self.safe_dict_k(self.options.clone(), "urls", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut future: Value = self.safe_value(urls.clone(), connectId.clone(), &[]);
        if !is_equal(&future, &Value::Null) {
            return future;
        }
        // we store an awaitable to the url
        // so that multiple calls don't asynchronously
        // fetch different urls and overwrite each other
        add_element_to_object(&mut urls, &connectId, self.call_dynamic("negotiate_helper", vec![privateChannel.clone(), connectId.clone(), params.clone()]).await);
        add_element_to_object(&mut self.options, &Value::Str("urls".to_string()), urls.clone());
        future = get_value(&urls, &connectId);
        return future;

    Value::Null
}

    pub async fn negotiate_helper(&mut self, mut privateChannel: Value, mut connectId: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut response: Value = Value::Null;
        let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
            if is_equal(&connectId, &Value::Str("private".to_string())) {
                response = self.parent.private_post_bullet_private(&[params.clone()]).await;
            }  else if is_equal(&connectId, &Value::Str("public".to_string())) {
                response = self.parent.public_post_bullet_public(&[params.clone()]).await;
            }  else if is_equal(&connectId, &Value::Str("privateFutures".to_string())) {
                response = self.parent.futures_private_post_bullet_private(&[params.clone()]).await;
            }  else {
                response = self.parent.futures_public_post_bullet_public(&[params.clone()]).await;
            }
            let mut data: Value = self.safe_dict_k(response.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut instanceServers: Value = self.safe_list_k(data.clone(), "instanceServers", &[Value::List(vec![])]);
            let mut firstInstanceServer: Value = self.safe_dict(instanceServers.clone(), Value::Int(0), &[]);
            let mut pingInterval: Value = self.safe_integer_k(firstInstanceServer.clone(), "pingInterval", &[]);
            let mut endpoint: Value = self.safe_string_k(firstInstanceServer.clone(), "endpoint", &[]);
            let mut token: Value = self.safe_string_k(data.clone(), "token", &[]);
            let mut result: Value = add(&add(&endpoint, &Value::Str("?".to_string())), &self.urlencode(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("token".to_string(), token.clone());
        m.insert("privateChannel".to_string(), privateChannel.clone());
        m.insert("connectId".to_string(), connectId.clone());
    m
}), &[]));
            let mut client: Value = self.client(&[result.clone()]);
            crate::set_value(&mut client, &Value::Str("keepAlive".to_string()), pingInterval.clone());
            return result.clone();
         #[allow(unreachable_code)] { Value::Null }})).await;
match _try_result { Ok(__try_ok) => { if !matches!(__try_ok, Value::Null) { return __try_ok; } return Value::Null; } Err(_try_err) => { let e: Value = panic_to_value(_try_err); 
            let mut future: Value = self.safe_value(get_value(&self.options, &Value::Str("urls".to_string())), connectId.clone(), &[]);
            future.reject(&[e.clone()]);
            remove(&mut get_value(&self.options, &Value::Str("urls".to_string())), &connectId);
         } }
        return Value::Null;

    Value::Null
}

    pub fn request_id(&mut self) -> Value {
        self.lock_id(&[]);
        let mut requestId: Value = self.sum(&[self.safe_integer_k(self.options.clone(), "requestId", &[Value::Int(0)]), Value::Int(1)]);
        add_element_to_object(&mut self.options, &Value::Str("requestId".to_string()), requestId.clone());
        self.unlock_id(&[]);
        return requestId;

    Value::Null
}

    pub async fn subscribe(&mut self, mut url: Value, mut messageHash: Value, mut subscriptionHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                m.insert("topic".to_string(), subscriptionHash.clone());
                m.insert("response".to_string(), Value::Bool(true));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        let mut client: Value = self.client(&[url.clone()]);
        if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash)))) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, subscriptionHash.clone());
        }
        return self.watch(url.clone(), messageHash.clone(), &[message.clone(), subscriptionHash.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn subscribe_public_uta(&mut self, mut messageHash: Value, mut channel: Value, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut market: Value = self.market(symbol.clone());
        let mut urlType: Value = ternary(is_true(&(is_equal(&get_value(&market, &Value::Str("contract".to_string())), &Value::Bool(true)))), Value::Str("futures".to_string()), Value::Str("spot".to_string()));
        let mut tradeType: Value = to_upper(&urlType);
        let mut action: Value = Value::Str("subscribe".to_string());
        if !is_equal(&subscription, &Value::Null) {
            let mut unsubscribe: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
            action = ternary(is_true(&(is_equal(&unsubscribe, &Value::Bool(true)))), Value::Str("unsubscribe".to_string()), action.clone());
        }
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("action".to_string(), action.clone());
                m.insert("channel".to_string(), channel.clone());
                m.insert("tradeType".to_string(), tradeType.clone());
                m.insert("symbol".to_string(), get_value(&market, &Value::Str("id".to_string())));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        let mut url: Value = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), urlType.clone(), &[]);
        let mut client: Value = self.client(&[url.clone()]);
        if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash)))) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, messageHash.clone());
        }
        return self.watch(url.clone(), messageHash.clone(), &[message.clone(), messageHash.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn subscribe_private_uta(&mut self, mut messageHashes: Value, mut subscribeHash: Value, mut channel: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 2, Value::Null);
        self.check_required_credentials(&[]);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut action: Value = Value::Str("subscribe".to_string());
        if !is_equal(&subscription, &Value::Null) {
            let mut unsubscribe: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
            action = ternary(is_true(&(is_equal(&unsubscribe, &Value::Bool(true)))), Value::Str("unsubscribe".to_string()), action.clone());
        }
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("action".to_string(), action.clone());
                m.insert("channel".to_string(), channel.clone());
            m
        });
        if !is_equal(&symbol, &Value::Null) {
            let mut market: Value = self.market(symbol.clone());
            add_element_to_object(&mut request, &Value::Str("symbol".to_string()), get_value(&market, &Value::Str("id".to_string())));
        }
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        let mut url: Value = self.get_uta_url().await;
        let mut client: Value = self.client(&[url.clone()]);
        if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscribeHash)))) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, subscribeHash.clone());
        }
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), Value::List(vec![subscribeHash.clone()]), subscription.clone()]).await;

    Value::Null
}

    pub async fn get_uta_url(&mut self) -> Value {
        let mut utaToken: Value = self.authenticate_uta().await;
        return add(&add(&get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("private".to_string())), &Value::Str("?token=".to_string())), &utaToken);

    Value::Null
}

    pub async fn authenticate_uta(&mut self) -> Value {
        self.check_required_credentials(&[]);
        let mut utaToken: Value = self.safe_value_k(self.options.clone(), "utaToken", &[]);
        let mut lastUpdate: Value = self.safe_integer_k(self.options.clone(), "utaTokenLastUpdate", &[Value::Int(0)]);
        let mut refreshInterval: Value = multiply(&multiply(&multiply(&Value::Int(1000), &Value::Int(60)), &Value::Int(60)), &Value::Int(24)); // 24 hours
        refreshInterval = self.safe_integer_k(self.options.clone(), "utaTokenRefreshInterval", &[refreshInterval.clone()]);
        let mut now: Value = self.milliseconds();
        let mut expired: bool = is_greater_than_or_equal(&(subtract(&now, &lastUpdate)), &refreshInterval);
        let mut messageHash: Value = Value::Str("utaToken".to_string());
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("private".to_string()));
        let mut client: Value = self.client(&[url.clone()]);
        if is_true(&(is_equal(&utaToken, &Value::Null))) || is_true(&expired) {
            if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("futures".to_string())), &messageHash))) {
                // wait the existing future if it's already being fetched by another call
                crate::exchange_stubs::ws_await_flight(&client.future(&[messageHash.clone()])).await;
            }  else {
                // fetch new token and store the future to the .futures to prevent concurrent fetches
                client.future(&[messageHash.clone()]);
                let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
                    let mut response: Value = self.parent.private_post_bullet_private(&[Value::Map({
                        let mut m = indexmap::IndexMap::new();
                            m.insert("version".to_string(), Value::Str("v2".to_string()));
                        m
                    })]).await;
                    let mut data: Value = self.safe_dict_k(response.clone(), "data", &[Value::Map({
                        let mut m = indexmap::IndexMap::new();
                        m
                    })]);
                    let mut utaTokenString: Value = self.safe_string_k(data.clone(), "token", &[]);
                    add_element_to_object(&mut self.options, &Value::Str("utaTokenLastUpdate".to_string()), now.clone());
                    add_element_to_object(&mut self.options, &Value::Str("utaToken".to_string()), utaTokenString.clone());
                    client.resolve(&[utaTokenString.clone(), messageHash.clone()]);
                 #[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
                    add_element_to_object(&mut self.options, &Value::Str("utaToken".to_string()), Value::Null);
                    client.reject(&[e.clone(), messageHash.clone()]);
                }
            }
        }
        return self.safe_string_k(self.options.clone(), "utaToken", &[]);

    Value::Null
}

    pub async fn un_subscribe(&mut self, mut url: Value, mut messageHash: Value, mut topic: Value, mut subscriptionHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        return self.un_subscribe_multiple(url.clone(), Value::List(vec![messageHash.clone()]), topic.clone(), Value::List(vec![subscriptionHash.clone()]), &[params.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn subscribe_multiple(&mut self, mut url: Value, mut messageHashes: Value, mut topic: Value, mut subscriptionHashes: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                m.insert("topic".to_string(), topic.clone());
                m.insert("response".to_string(), Value::Bool(true));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        let mut client: Value = self.client(&[url.clone()]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_449: bool = true;
            while { if !__for_first_449 { i = add(&i, &Value::Int(1)); } __for_first_449 = false; is_less_than(&i, &get_array_length(&subscriptionHashes)) } {
            let mut subscriptionHash: Value = get_value(&subscriptionHashes, &i);
            let mut subscriptionHash: Value = get_value(&subscriptionHashes, &i);
            if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash)))) {
                add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, subscriptionHash.clone());
            }
        }
        }
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), subscriptionHashes.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn un_subscribe_multiple(&mut self, mut url: Value, mut messageHashes: Value, mut topic: Value, mut subscriptionHashes: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("type".to_string(), Value::Str("unsubscribe".to_string()));
                m.insert("topic".to_string(), topic.clone());
                m.insert("response".to_string(), Value::Bool(true));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        if !is_equal(&subscription, &Value::Null) {
            add_element_to_object(&mut subscription, &requestId, requestId.clone());
        }
        let mut client: Value = self.client(&[url.clone()]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_450: bool = true;
            while { if !__for_first_450 { i = add(&i, &Value::Int(1)); } __for_first_450 = false; is_less_than(&i, &get_array_length(&subscriptionHashes)) } {
            let mut subscriptionHash: Value = get_value(&subscriptionHashes, &i);
            let mut subscriptionHash: Value = get_value(&subscriptionHashes, &i);
            if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash)))) {
                add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, subscriptionHash.clone());
            }
        }
        }
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), subscriptionHashes.clone(), subscription.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://www.kucoin.com/docs-new/3470063w0
 * @see https://www.kucoin.com/docs-new/3470081w0
 * @see https://www.kucoin.com/docs-new/3470222w0
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @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());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&Value::Str("ticker:".to_string()), &symbol);
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTicker".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&uta) {
            messageHash = add(&Value::Str("uta:".to_string()), &messageHash);
            let mut channel: Value = Value::Str("ticker".to_string());
            return self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone()]).await;
        }
        let mut isFuturesMethod: Value = get_value(&market, &Value::Str("contract".to_string()));
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut method: Value = Value::Str("/market/snapshot".to_string());
        if is_equal(&isFuturesMethod, &Value::Bool(true)) {
            method = Value::Str("/contractMarket/ticker".to_string());
        }  else {
            { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTicker".to_string()), Value::Str("spotMethod".to_string()), &[method.clone()]); method = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        }
        let mut topic: Value = add(&add(&method, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
        return self.subscribe(url.clone(), messageHash.clone(), topic.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchTicker
 * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://www.kucoin.com/docs-new/3470063w0
 * @see https://www.kucoin.com/docs-new/3470081w0
 * @see https://www.kucoin.com/docs-new/3470222w0
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @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());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut isFuturesMethod: Value = get_value(&market, &Value::Str("contract".to_string()));
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchTicker".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m.insert("topic".to_string(), Value::Str("ticker".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
            m
        });
        let mut subMessageHash: Value = add(&Value::Str("ticker:".to_string()), &symbol);
        if is_true(&uta) {
            subMessageHash = add(&Value::Str("uta:".to_string()), &subMessageHash);
            add_element_to_object(&mut subscription, &Value::Str("subMessageHashes".to_string()), Value::List(vec![subMessageHash.clone()]));
            let mut utaMessageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            add_element_to_object(&mut subscription, &Value::Str("messageHashes".to_string()), Value::List(vec![utaMessageHash.clone()]));
            return self.subscribe_public_uta(utaMessageHash.clone(), Value::Str("ticker".to_string()), symbol.clone(), &[params.clone(), subscription.clone()]).await;
        }  else {
            let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
            let mut method: Value = Value::Str("/market/snapshot".to_string());
            if is_equal(&isFuturesMethod, &Value::Bool(true)) {
                method = Value::Str("/contractMarket/ticker".to_string());
            }  else {
                { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTicker".to_string()), Value::Str("spotMethod".to_string()), &[method.clone()]); method = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
            }
            let mut topic: Value = add(&add(&method, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
            let mut messageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            // we have to add the topic to the messageHashes and subMessageHashes
            // because handleSubscriptionStatus needs them to remove the subscription from the client
            // without them subscription would never be removed and re-subscribe would fail because of duplicate subscriptionHash
            add_element_to_object(&mut subscription, &Value::Str("messageHashes".to_string()), Value::List(vec![messageHash.clone(), topic.clone()]));
            add_element_to_object(&mut subscription, &Value::Str("subMessageHashes".to_string()), Value::List(vec![subMessageHash.clone(), topic.clone()]));
            return self.un_subscribe(url.clone(), messageHash.clone(), topic.clone(), subMessageHash.clone(), &[params.clone(), subscription.clone()]).await;
        }

    Value::Null
}

/*
 * @method
 * @name kucoin#watchTickers
 * @see https://www.kucoin.com/docs-new/3470063w0
 * @see https://www.kucoin.com/docs-new/3470064w0
 * @see https://www.kucoin.com/docs-new/3470081w0
 * @see https://www.kucoin.com/docs-new/3470222w0
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
 * @param {string[]} symbols unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.method] *spot markets only* either '/market/snapshot' or '/market/ticker' default is '/market/ticker'
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn watch_tickers(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = 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;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(true), Value::Bool(true)]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut marketType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchTickers".to_string()), &[firstMarket.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTickers".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut isFuturesMethod: Value = Value::Bool(is_true(&(!is_equal(&marketType, &Value::Str("spot".to_string())))) && is_true(&(!is_equal(&marketType, &Value::Str("margin".to_string())))));
        if is_true(&(is_true(&isFuturesMethod) || is_true(&uta))) && is_equal(&symbols, &Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(add(&add(&add(&self.id, &Value::Str(" watchTickers() requires a list of symbols for ".to_string())), &marketType), &Value::Str(" markets and unified trading account (uta)".to_string()))));
        }
        let mut messageHash: Value = Value::Str("tickers".to_string());
        let mut method: Value = Value::Str("/market/ticker".to_string());
        if is_true(&isFuturesMethod) {
            method = Value::Str("/contractMarket/ticker".to_string());
        }  else {
            { let __destr_tmp = self.handle_option_and_params2(params.clone(), Value::Str("watchTickers".to_string()), Value::Str("method".to_string()), Value::Str("spotMethod".to_string()), &[method.clone()]); method = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        }
        let mut messageHashes: Value = Value::List(vec![]);
        let mut topics: Value = Value::List(vec![]);
        if !is_equal(&symbols, &Value::Null) {
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_451: bool = true;
                while { if !__for_first_451 { i = add(&i, &Value::Int(1)); } __for_first_451 = false; is_less_than(&i, &get_array_length(&symbols)) } {
                let mut symbol: Value = get_value(&symbols, &i);
                let mut symbol: Value = get_value(&symbols, &i);
                append_to_array(&mut messageHashes, add(&Value::Str("ticker:".to_string()), &symbol));
                let mut market: Value = self.market(symbol.clone());
                append_to_array(&mut topics, add(&add(&method, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string()))));
            }
            }
        }
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut tickers: Value = Value::Null;
        if is_equal(&symbols, &Value::Null) {
            let mut allTopic: Value = add(&method, &Value::Str(":all".to_string()));
            tickers = self.subscribe(url.clone(), messageHash.clone(), allTopic.clone(), &[params.clone()]).await;
            if is_true(&self.newUpdates) {
                return tickers;
            }
        }  else {
            let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
            let mut symbolsTopic: Value = add(&add(&method, &Value::Str(":".to_string())), &join(&marketIds, &Value::Str(",".to_string())));
            tickers = self.subscribe_multiple(url.clone(), messageHashes.clone(), symbolsTopic.clone(), topics.clone(), &[params.clone()]).await;
            if is_true(&self.newUpdates) {
                let mut newDict: Value = Value::Map({
                    let mut m = indexmap::IndexMap::new();
                    m
                });
                add_element_to_object(&mut newDict, &get_value(&tickers, &Value::Str("symbol".to_string())), tickers.clone());
                return newDict;
            }
        }
        return self.filter_by_array(self.tickers.clone(), Value::Str("symbol".to_string()), &[symbols.clone()]);

    Value::Null
}

    pub async fn subscribe_public_multiple_uta(&mut self, mut messageHashes: Value, mut channel: Value, mut symbols: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscription = get_arg(optional_args, 1, Value::Null);
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut market: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isContract: bool = is_equal(&get_value(&market, &Value::Str("contract".to_string())), &Value::Bool(true));
        let mut urlType: Value = ternary(is_true(&isContract), Value::Str("futures".to_string()), Value::Str("spot".to_string()));
        let mut tradeType: Value = to_upper(&urlType);
        let mut action: Value = Value::Str("subscribe".to_string());
        if !is_equal(&subscription, &Value::Null) {
            let mut unsubscribe: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
            action = ternary(is_true(&(is_equal(&unsubscribe, &Value::Bool(true)))), Value::Str("unsubscribe".to_string()), action.clone());
        }
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("action".to_string(), action.clone());
                m.insert("channel".to_string(), channel.clone());
                m.insert("tradeType".to_string(), tradeType.clone());
                m.insert("symbols".to_string(), self.market_ids(&[symbols.clone()]));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        let mut url: Value = self.safe_string(get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), urlType.clone(), &[]);
        let mut client: Value = self.client(&[url.clone()]);
        let mut messageHashWithSymbols: Value = add(&add(&channel, &Value::Str(":".to_string())), &join(&symbols, &Value::Str(",".to_string())));
        if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &messageHashWithSymbols)))) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, messageHashWithSymbols.clone());
        }
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), messageHashes.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn watch_uta_tickers(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = 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;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true)]);
        let mut messageHash: Value = Value::Str("uta:ticker".to_string());
        let mut messageHashes: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_452: bool = true;
            while { if !__for_first_452 { i = add(&i, &Value::Int(1)); } __for_first_452 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = self.safe_string(symbols.clone(), i.clone(), &[]);
            let mut market: Value = self.market(symbol.clone());
            let mut subMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("symbol".to_string())));
            append_to_array(&mut messageHashes, subMessageHash.clone());
        }
        }
        let mut tickers: Value = self.subscribe_public_multiple_uta(messageHashes.clone(), Value::Str("ticker".to_string()), symbols.clone(), &[params.clone()]).await;
        if is_true(&self.newUpdates) {
            return tickers;
        }
        return self.filter_by_array(self.tickers.clone(), Value::Str("symbol".to_string()), &[symbols.clone()]);

    Value::Null
}

    pub fn handle_ticker(&mut self, mut client: Value, mut message: Value) {
        //
        // market/snapshot
        //
        // updates come in every 2 sec unless there
        // were no changes since the previous update
        //
        //     {
        //         "data": {
        //             "sequence": "1545896669291",
        //             "data": {
        //                 "trading": true,
        //                 "symbol": "KCS-BTC",
        //                 "buy": 0.00011,
        //                 "sell": 0.00012,
        //                 "sort": 100,
        //                 "volValue": 3.13851792584, // total
        //                 "baseCurrency": "KCS",
        //                 "market": "BTC",
        //                 "quoteCurrency": "BTC",
        //                 "symbolCode": "KCS-BTC",
        //                 "datetime": 1548388122031,
        //                 "high": 0.00013,
        //                 "vol": 27514.34842,
        //                 "low": 0.0001,
        //                 "changePrice": -1.0e-5,
        //                 "changeRate": -0.0769,
        //                 "lastTradedPrice": 0.00012,
        //                 "board": 0,
        //                 "mark": 0
        //             }
        //         },
        //         "subject": "trade.snapshot",
        //         "topic": "/market/snapshot:KCS-BTC",
        //         "type": "message"
        //     }
        //
        // market/ticker
        //
        //     {
        //         "type": "message",
        //         "topic": "/market/ticker:BTC-USDT",
        //         "subject": "trade.ticker",
        //         "data": {
        //             "bestAsk": "62163",
        //             "bestAskSize": "0.99011388",
        //             "bestBid": "62162.9",
        //             "bestBidSize": "0.04794181",
        //             "price": "62162.9",
        //             "sequence": "1621383371852",
        //             "size": "0.00832274",
        //             "time": 1634641987564
        //         }
        //     }
        //
        // futures
        //    {
        //     "subject": "ticker",
        //     "topic": "/contractMarket/ticker:XBTUSDM",
        //     "data": {
        //         "symbol": "XBTUSDM", //Market of the symbol
        //         "sequence": 45, //Sequence number which is used to judge the continuity of the pushed messages
        //         "side": "sell", //Transaction side of the last traded taker order
        //         "price": "3600.0", //Filled price
        //         "size": 16, //Filled quantity
        //         "tradeId": "5c9dcf4170744d6f5a3d32fb", //Order ID
        //         "bestBidSize": 795, //Best bid size
        //         "bestBidPrice": "3200.0", //Best bid
        //         "bestAskPrice": "3600.0", //Best ask size
        //         "bestAskSize": 284, //Best ask
        //         "ts": 1553846081210004941 //Filled time - nanosecond
        //     }
        //    }
        //
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        if is_less_than(&get_index_of(&topic, &Value::Str("contractMarket".to_string())), &Value::Int(0)) {
            let mut market: Value = Value::Null;
            if !is_equal(&topic, &Value::Null) {
                let mut parts: Value = split(&topic, &Value::Str(":".to_string()));
                let mut first: Value = self.safe_string(parts.clone(), Value::Int(1), &[]);
                let mut marketId: Value = Value::Null;
                if is_equal(&first, &Value::Str("all".to_string())) {
                    marketId = self.safe_string_k(message.clone(), "subject", &[]);
                }  else {
                    marketId = first.clone();
                }
                market = self.safe_market(&[marketId.clone(), market.clone(), Value::Str("-".to_string())]);
            }
            let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut rawTicker: Value = self.safe_dict_k(data.clone(), "data", &[data.clone()]);
            let mut ticker: Value = self.parent.parse_spot_or_uta_ticker(rawTicker.clone(), &[market.clone()]);
            let mut symbol: Value = get_value(&ticker, &Value::Str("symbol".to_string()));
            add_element_to_object(&mut self.tickers, &symbol, ticker.clone());
            let mut messageHash: Value = add(&Value::Str("ticker:".to_string()), &symbol);
            client.resolve(&[ticker.clone(), messageHash.clone()]);
            // watchTickers
            let mut allTickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            add_element_to_object(&mut allTickers, &symbol, ticker.clone());
            client.resolve(&[allTickers.clone(), Value::Str("tickers".to_string())]);
        }  else {
            self.handle_contract_ticker(client.clone(), message.clone());
        }
}

    pub fn handle_contract_ticker(&mut self, mut client: Value, mut message: Value) {
        //
        // ticker (v1)
        //
        //    {
        //     "subject": "ticker",
        //     "topic": "/contractMarket/ticker:XBTUSDM",
        //     "data": {
        //         "symbol": "XBTUSDM", //Market of the symbol
        //         "sequence": 45, //Sequence number which is used to judge the continuity of the pushed messages
        //         "side": "sell", //Transaction side of the last traded taker order
        //         "price": "3600.0", //Filled price
        //         "size": 16, //Filled quantity
        //         "tradeId": "5c9dcf4170744d6f5a3d32fb", //Order ID
        //         "bestBidSize": 795, //Best bid size
        //         "bestBidPrice": "3200.0", //Best bid
        //         "bestAskPrice": "3600.0", //Best ask size
        //         "bestAskSize": 284, //Best ask
        //         "ts": 1553846081210004941 //Filled time - nanosecond
        //     }
        //    }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone(), Value::Null, Value::Str("-".to_string())]);
        let mut ticker: Value = self.parse_ticker(data.clone(), &[market.clone()]);
        add_element_to_object(&mut self.tickers, &get_value(&market, &Value::Str("symbol".to_string())), ticker.clone());
        let mut messageHash: Value = add(&Value::Str("ticker:".to_string()), &get_value(&market, &Value::Str("symbol".to_string())));
        client.resolve(&[ticker.clone(), messageHash.clone()]);
}

    pub fn handle_uta_ticker(&mut self, mut client: Value, mut message: Value) {
        //
        // watchTicker
        //     {
        //         "T": "ticker.SPOT",
        //         "P": "1774100940787520626",
        //         "d": {
        //             "A": "0.5972689",
        //             "B": "23.3114947",
        //             "E": 20310552932,
        //             "M": "1774100940780000000",
        //             "S": "SELL",
        //             "a": "2155.55",
        //             "b": "2155.54",
        //             "l": "2155.54",
        //             "q": "0.0001529",
        //             "s": "ETH-USDT"
        //         }
        //     }
        //
        // watchMarkPrice
        //     {
        //         "T": "mark-price",
        //         "P": "1782834987171570181",
        //         "d": {
        //             "s": "ETHUSDTM",
        //             "mp": "1569.15",
        //             "ip": "1569.87",
        //             "oi": "50541824",
        //             "ts": 1782834987000
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut ticker: Value = self.parse_ws_uta_ticker(data.clone(), &[market.clone()]);
        add_element_to_object(&mut self.tickers, &get_value(&market, &Value::Str("symbol".to_string())), ticker.clone());
        let mut messageHash: Value = add(&Value::Str("uta:ticker:".to_string()), &get_value(&market, &Value::Str("symbol".to_string())));
        client.resolve(&[ticker.clone(), messageHash.clone()]);
}

    pub fn parse_ws_uta_ticker(&self, mut ticker: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        let mut symbol: Value = self.safe_string_k(market.clone(), "symbol", &[]);
        market = self.safe_market(&[symbol.clone(), market.clone()]);
        let mut timestamp: Value = self.safe_integer_k(ticker.clone(), "ts", &[]);
        if is_equal(&timestamp, &Value::Null) {
            timestamp = self.safe_integer_product(ticker.clone(), Value::Str("M".to_string()), Value::Float(0.000001), &[]);
        }
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("high".to_string(), Value::Null);
        m.insert("low".to_string(), Value::Null);
        m.insert("bid".to_string(), self.safe_string_k(ticker.clone(), "a", &[]));
        m.insert("bidVolume".to_string(), self.safe_string_k(ticker.clone(), "A", &[]));
        m.insert("ask".to_string(), self.safe_string_k(ticker.clone(), "b", &[]));
        m.insert("askVolume".to_string(), self.safe_string_k(ticker.clone(), "B", &[]));
        m.insert("vwap".to_string(), Value::Null);
        m.insert("open".to_string(), Value::Null);
        m.insert("close".to_string(), Value::Null);
        m.insert("last".to_string(), self.safe_string_k(ticker.clone(), "l", &[]));
        m.insert("previousClose".to_string(), Value::Null);
        m.insert("change".to_string(), Value::Null);
        m.insert("percentage".to_string(), Value::Null);
        m.insert("average".to_string(), Value::Null);
        m.insert("baseVolume".to_string(), Value::Null);
        m.insert("quoteVolume".to_string(), Value::Null);
        m.insert("markPrice".to_string(), self.safe_string_k(ticker.clone(), "mp", &[]));
        m.insert("indexPrice".to_string(), self.safe_string_k(ticker.clone(), "ip", &[]));
        m.insert("info".to_string(), ticker.clone());
    m
}), &[market.clone()]);

    Value::Null
}

/*
 * @method
 * @name kucoin#watchBidsAsks
 * @see https://www.kucoin.com/docs-new/3470067w0
 * @see https://www.kucoin.com/docs-new/3470080w0
 * @description watches best bid & ask for symbols
 * @param {string[]} symbols 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_bids_asks(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = 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;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(false)]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isFuturesMethod: Value = Value::Bool(is_equal(&get_value(&firstMarket, &Value::Str("contract".to_string())), &Value::Bool(true)));
        let mut channelName: Value = Value::Str("/spotMarket/level1:".to_string());
        if is_true(&isFuturesMethod) {
            channelName = Value::Str("/contractMarket/tickerV2:".to_string());
        }
        let mut ticker: Value = self.watch_multi_helper(Value::Str("watchBidsAsks".to_string()), channelName.clone(), isFuturesMethod.clone(), &[symbols.clone(), params.clone()]).await;
        if is_true(&self.newUpdates) {
            let mut tickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            add_element_to_object(&mut tickers, &get_value(&ticker, &Value::Str("symbol".to_string())), ticker.clone());
            return tickers;
        }
        return self.filter_by_array(self.bidsasks.clone(), Value::Str("symbol".to_string()), &[symbols.clone()]);

    Value::Null
}

    pub async fn watch_multi_helper(&mut self, mut methodName: Value, mut channelName: Value, mut isFuturesChannel: Value, optional_args: &[Value]) -> Value {
        let mut symbols = 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;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(false)]);
        let mut length: Value = get_array_length(&symbols);
        if is_greater_than(&length, &Value::Int(100)) {
            panic!("{}", crate::exchange_errors::arguments_required(add(&add(&add(&self.id, &Value::Str(" ".to_string())), &methodName), &Value::Str("() accepts a maximum of 100 symbols".to_string()))));
        }
        let mut messageHashes: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_453: bool = true;
            while { if !__for_first_453 { i = add(&i, &Value::Int(1)); } __for_first_453 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            let mut market: Value = self.market(symbol.clone());
            append_to_array(&mut messageHashes, add(&Value::Str("bidask@".to_string()), &get_value(&market, &Value::Str("symbol".to_string()))));
        }
        }
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesChannel.clone()]).await;
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut joined: Value = join(&marketIds, &Value::Str(",".to_string()));
        let mut requestId: Value = to_string_val(&self.request_id());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), requestId.clone());
                m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                m.insert("topic".to_string(), add(&channelName, &joined));
                m.insert("response".to_string(), Value::Bool(true));
            m
        });
        let mut message: Value = self.extend(request.clone(), &[params.clone()]);
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), messageHashes.clone()]).await;

    Value::Null
}

    pub fn handle_bid_ask(&mut self, mut client: Value, mut message: Value) {
        //
        // arrives one symbol dict
        //
        //     {
        //         topic: '/spotMarket/level1:ETH-USDT',
        //         type: 'message',
        //         data: {
        //             asks: [ '3347.42', '2.0778387' ],
        //             bids: [ '3347.41', '6.0411697' ],
        //             timestamp: 1712231142085
        //         },
        //         subject: 'level1'
        //     }
        //
        // futures
        // {
        //   "subject": "tickerV2",
        //   "topic": "/contractMarket/tickerV2:XBTUSDM",
        //   "data": {
        //     "symbol": "XBTUSDM", //Market of the symbol
        //     "bestBidSize": 795, // Best bid size
        //     "bestBidPrice": 3200.0, // Best bid
        //     "bestAskPrice": 3600.0, // Best ask
        //     "bestAskSize": 284, // Best ask size
        //     "ts": 1553846081210004941 // Filled time - nanosecond
        //   }
        // }
        //
        let mut parsedTicker: Value = self.parse_ws_bid_ask(message.clone(), &[]);
        let mut symbol: Value = get_value(&parsedTicker, &Value::Str("symbol".to_string()));
        add_element_to_object(&mut self.bidsasks, &symbol, parsedTicker.clone());
        let mut messageHash: Value = add(&Value::Str("bidask@".to_string()), &symbol);
        client.resolve(&[parsedTicker.clone(), messageHash.clone()]);
}

    pub fn parse_ws_bid_ask(&self, mut ticker: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        let mut topic: Value = self.safe_string_k(ticker.clone(), "topic", &[]);
        if is_less_than(&get_index_of(&topic, &Value::Str("contractMarket".to_string())), &Value::Int(0)) {
            let mut parts: Value = split(&topic, &Value::Str(":".to_string()));
            let mut marketId: Value = get_value(&parts, &Value::Int(1));
            market = self.safe_market(&[marketId.clone(), market.clone()]);
            let mut symbol: Value = self.safe_string_k(market.clone(), "symbol", &[]);
            let mut data: Value = self.safe_dict_k(ticker.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut ask: Value = self.safe_list_k(data.clone(), "asks", &[Value::List(vec![])]);
            let mut bid: Value = self.safe_list_k(data.clone(), "bids", &[Value::List(vec![])]);
            let mut timestamp: Value = self.safe_integer_k(data.clone(), "timestamp", &[]);
            return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("ask".to_string(), self.safe_number(ask.clone(), Value::Int(0), &[]));
        m.insert("askVolume".to_string(), self.safe_number(ask.clone(), Value::Int(1), &[]));
        m.insert("bid".to_string(), self.safe_number(bid.clone(), Value::Int(0), &[]));
        m.insert("bidVolume".to_string(), self.safe_number(bid.clone(), Value::Int(1), &[]));
        m.insert("info".to_string(), ticker.clone());
    m
}), &[market.clone()]);
        }  else {
            // futures
            let mut data: Value = self.safe_dict_k(ticker.clone(), "data", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[]);
            market = self.safe_market(&[marketId.clone(), market.clone()]);
            let mut symbol: Value = self.safe_string_k(market.clone(), "symbol", &[]);
            let mut timestamp: Value = self.safe_integer_product(data.clone(), Value::Str("ts".to_string()), Value::Float(0.000001), &[]);
            return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("ask".to_string(), self.safe_number_k(data.clone(), "bestAskPrice", &[]));
        m.insert("askVolume".to_string(), self.safe_number_k(data.clone(), "bestAskSize", &[]));
        m.insert("bid".to_string(), self.safe_number_k(data.clone(), "bestBidPrice", &[]));
        m.insert("bidVolume".to_string(), self.safe_number_k(data.clone(), "bestBidSize", &[]));
        m.insert("info".to_string(), ticker.clone());
    m
}), &[market.clone()]);
        }

    Value::Null
}

/*
 * @method
 * @name kucoin#watchOHLCV
 * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://www.kucoin.com/docs-new/3470071w0
 * @see https://www.kucoin.com/docs-new/3470086w0
 * @see https://www.kucoin.com/docs-new/3470223w0
 * @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
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @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());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut period: Value = self.safe_string(self.timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut messageHash: Value = add(&add(&add(&Value::Str("candles:".to_string()), &symbol), &Value::Str(":".to_string())), &timeframe);
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOHLCV".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut ohlcv: Value = Value::Null;
        if is_true(&uta) {
            let mut channel: Value = Value::Str("kline".to_string());
            messageHash = add(&Value::Str("uta:".to_string()), &messageHash);
            let mut extendedParams: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("interval".to_string(), period.clone());
                m
            });
            params = self.extend(extendedParams.clone(), &[params.clone()]);
            let __ws_arg_0 = self.extend(extendedParams.clone(), &[params.clone()]);
            ohlcv = self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[__ws_arg_0]).await;
        }  else {
            let mut isFuturesMethod: Value = get_value(&market, &Value::Str("contract".to_string()));
            let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
            let mut channelName: Value = Value::Str("/market/candles:".to_string());
            if is_equal(&isFuturesMethod, &Value::Bool(true)) {
                channelName = Value::Str("/contractMarket/limitCandle:".to_string());
            }
            let mut topic: Value = add(&add(&add(&channelName, &get_value(&market, &Value::Str("id".to_string()))), &Value::Str("_".to_string())), &period);
            ohlcv = self.subscribe(url.clone(), messageHash.clone(), topic.clone(), &[params.clone()]).await;
        }
        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 kucoin#unWatchOHLCV
 * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://www.kucoin.com/docs-new/3470071w0
 * @see https://www.kucoin.com/docs-new/3470086w0
 * @see https://www.kucoin.com/docs-new/3470223w0
 * @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
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @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());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchOHLCV".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut period: Value = self.safe_string(self.timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut symbolAndTimeframe: Value = Value::List(vec![symbol.clone(), timeframe.clone()]);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m.insert("symbolsAndTimeframes".to_string(), Value::List(vec![symbolAndTimeframe.clone()]));
                m.insert("topic".to_string(), Value::Str("ohlcv".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
            m
        });
        let mut subMessageHash: Value = add(&add(&add(&Value::Str("candles:".to_string()), &symbol), &Value::Str(":".to_string())), &timeframe);
        if is_true(&uta) {
            subMessageHash = add(&Value::Str("uta:".to_string()), &subMessageHash);
            add_element_to_object(&mut subscription, &Value::Str("subMessageHashes".to_string()), Value::List(vec![subMessageHash.clone()]));
            let mut utaMessageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            add_element_to_object(&mut subscription, &Value::Str("messageHashes".to_string()), Value::List(vec![utaMessageHash.clone()]));
            let mut extendedParams: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("interval".to_string(), period.clone());
                m
            });
            let __ws_arg_1 = self.extend(extendedParams.clone(), &[params.clone()]);
            return self.subscribe_public_uta(utaMessageHash.clone(), Value::Str("kline".to_string()), symbol.clone(), &[__ws_arg_1, subscription.clone()]).await;
        }  else {
            let mut isFuturesMethod: Value = get_value(&market, &Value::Str("contract".to_string()));
            let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
            let mut channelName: Value = Value::Str("/market/candles:".to_string());
            if is_equal(&isFuturesMethod, &Value::Bool(true)) {
                channelName = Value::Str("/contractMarket/limitCandle:".to_string());
            }
            let mut messageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            let mut topic: Value = add(&add(&add(&channelName, &get_value(&market, &Value::Str("id".to_string()))), &Value::Str("_".to_string())), &period);
            // we have to add the topic to the messageHashes and subMessageHashes
            // because handleSubscriptionStatus needs them to remove the subscription from the client
            // without them subscription would never be removed and re-subscribe would fail because of duplicate subscriptionHash
            add_element_to_object(&mut subscription, &Value::Str("messageHashes".to_string()), Value::List(vec![messageHash.clone(), topic.clone()]));
            add_element_to_object(&mut subscription, &Value::Str("subMessageHashes".to_string()), Value::List(vec![subMessageHash.clone(), topic.clone()]));
            return self.un_subscribe(url.clone(), messageHash.clone(), topic.clone(), messageHash.clone(), &[params.clone(), subscription.clone()]).await;
        }

    Value::Null
}

    pub fn handle_ohlcv(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "data": {
        //             "symbol": "BTC-USDT",
        //             "candles": [
        //                 "1624881240",
        //                 "34138.8",
        //                 "34121.6",
        //                 "34138.8",
        //                 "34097.9",
        //                 "3.06097133",
        //                 "104430.955068564"
        //             ],
        //             "time": 1624881284466023700
        //         },
        //         "subject": "trade.candles.update",
        //         "topic": "/market/candles:BTC-USDT_1min",
        //         "type": "message"
        //     }
        //
        // futures
        //    {
        //        "topic":"/contractMarket/limitCandle:LTCUSDTM_1min",
        //        "type":"message",
        //        "data":{
        //            "symbol":"LTCUSDTM",
        //            "candles":[
        //                "1715470980",
        //                "81.38",
        //                "81.38",
        //                "81.38",
        //                "81.38",
        //                "61.0", - Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
        //                "61"
        //            ],
        //            "time":1715470994801
        //        },
        //        "subject":"candle.stick"
        //    }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[]);
        let mut candles: Value = self.safe_list_k(data.clone(), "candles", &[Value::List(vec![])]);
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        let mut parts: Value = split(&topic, &Value::Str("_".to_string()));
        let mut interval: Value = self.safe_string(parts.clone(), Value::Int(1), &[]);
        // use a reverse lookup in a static map instead
        let mut timeframe: Value = self.find_timeframe(interval.clone(), &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&add(&add(&Value::Str("candles:".to_string()), &symbol), &Value::Str(":".to_string())), &timeframe);
        { 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 stored: Value = self.safe_value(get_value(&self.ohlcvs, &symbol), timeframe.clone(), &[]);
        if is_equal(&stored, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "OHLCVLimit", &[Value::Int(1000)]);
            stored = ArrayCacheByTimestamp::new(limit.clone());
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.ohlcvs) }, &symbol), &timeframe, stored.clone());
        }
        let mut isContractMarket: bool = is_greater_than_or_equal(&get_index_of(&topic, &Value::Str("contractMarket".to_string())), &Value::Int(0));
        let mut baseVolumeIndex: Value = ternary(is_true(&isContractMarket), Value::Int(6), Value::Int(5)); // Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
        let mut parsed: Value = Value::List(vec![self.safe_timestamp(candles.clone(), Value::Int(0), &[]), self.safe_number(candles.clone(), Value::Int(1), &[]), self.safe_number(candles.clone(), Value::Int(3), &[]), self.safe_number(candles.clone(), Value::Int(4), &[]), self.safe_number(candles.clone(), Value::Int(2), &[]), self.safe_number(candles.clone(), baseVolumeIndex.clone(), &[])]);
        stored.append(parsed.clone());
        client.resolve(&[stored.clone(), messageHash.clone()]);
}

    pub fn handle_uta_ohlcv(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "kline.SPOT",
        //         "P": "1774621652314890314",
        //         "d": {
        //             "a": "195333.419819132",
        //             "s": "ETH-USDT",
        //             "C": 1774621680,
        //             "c": "1973.4",
        //             "S": false,
        //             "v": "98.941095",
        //             "h": "1974.97",
        //             "i": "1min",
        //             "l": "1973.4",
        //             "O": 1774621620,
        //             "o": "1974.34"
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut interval: Value = self.safe_string_k(data.clone(), "i", &[]);
        let mut timeframe: Value = self.find_timeframe(interval.clone(), &[]);
        let mut messageHash: Value = add(&add(&add(&Value::Str("uta:candles:".to_string()), &symbol), &Value::Str(":".to_string())), &timeframe);
        { 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 stored: Value = self.safe_value(get_value(&self.ohlcvs, &symbol), timeframe.clone(), &[]);
        if is_equal(&stored, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "OHLCVLimit", &[Value::Int(1000)]);
            stored = ArrayCacheByTimestamp::new(limit.clone());
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.ohlcvs) }, &symbol), &timeframe, stored.clone());
        }
        let mut parsed: Value = Value::List(vec![self.safe_integer_product(data.clone(), Value::Str("O".to_string()), Value::Int(1000), &[]), self.safe_number_k(data.clone(), "o", &[]), self.safe_number_k(data.clone(), "h", &[]), self.safe_number_k(data.clone(), "l", &[]), self.safe_number_k(data.clone(), "c", &[]), self.safe_number_k(data.clone(), "v", &[])]);
        stored.append(parsed.clone());
        client.resolve(&[stored.clone(), messageHash.clone()]);
}

/*
 * @method
 * @name kucoin#watchTrades
 * @description get the list of most recent trades for a particular symbol
 * @see https://www.kucoin.com/docs-new/3470072w0
 * @see https://www.kucoin.com/docs-new/3470084w0
 * @see https://www.kucoin.com/docs-new/3470224w0
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {int} [since] timestamp in ms of the earliest trade to fetch
 * @param {int} [limit] the maximum amount of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    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
}));
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTrades".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&uta) {
            self.load_markets(&[]).await;
            let mut market: Value = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
            let mut messageHash: Value = add(&Value::Str("uta:trades:".to_string()), &symbol);
            let mut channel: Value = Value::Str("trade".to_string());
            let mut trades: Value = self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone()]).await;
            if is_true(&self.newUpdates) {
                let mut first: Value = self.safe_value(trades.clone(), Value::Int(0), &[]);
                let mut tradeSymbol: Value = self.safe_string_k(first.clone(), "symbol", &[]);
                limit = trades.get_limit(tradeSymbol.clone(), limit.clone());
            }
            return self.filter_by_since_limit(trades.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);
        }
        return self.watch_trades_for_symbols(Value::List(vec![symbol.clone()]), &[since.clone(), limit.clone(), params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#watchTradesForSymbols
 * @description get the list of most recent trades for a particular symbol
 * @see https://www.kucoin.com/docs-new/3470072w0
 * @see https://www.kucoin.com/docs-new/3470084w0
 * @param {string[]} symbols
 * @param {int} [since] timestamp in ms of the earliest trade to fetch
 * @param {int} [limit] the maximum amount of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn watch_trades_for_symbols(&mut self, mut symbols: 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
}));
        let mut symbolsLength: Value = get_array_length(&symbols);
        if is_equal(&symbolsLength, &Value::Int(0)) {
            panic!("{}", crate::exchange_errors::arguments_required(add(&self.id, &Value::Str(" watchTradesForSymbols() requires a non-empty array of symbols".to_string()))));
        }
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true)]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isFuturesMethod: Value = Value::Bool(is_equal(&get_value(&firstMarket, &Value::Str("contract".to_string())), &Value::Bool(true)));
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut messageHashes: Value = Value::List(vec![]);
        let mut subscriptionHashes: Value = Value::List(vec![]);
        let mut channelName: Value = Value::Str("/market/match:".to_string());
        if is_true(&isFuturesMethod) {
            channelName = Value::Str("/contractMarket/execution:".to_string());
        }
        let mut topic: Value = add(&channelName, &join(&marketIds, &Value::Str(",".to_string())));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_454: bool = true;
            while { if !__for_first_454 { i = add(&i, &Value::Int(1)); } __for_first_454 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            append_to_array(&mut messageHashes, add(&Value::Str("trades:".to_string()), &symbol));
            let mut marketId: Value = get_value(&marketIds, &i);
            let mut marketId: Value = get_value(&marketIds, &i);
            append_to_array(&mut subscriptionHashes, add(&channelName, &marketId));
        }
        }
        let mut trades: Value = self.subscribe_multiple(url.clone(), messageHashes.clone(), topic.clone(), subscriptionHashes.clone(), &[params.clone()]).await;
        if is_true(&self.newUpdates) {
            let mut first: Value = self.safe_value(trades.clone(), Value::Int(0), &[]);
            let mut tradeSymbol: Value = self.safe_string_k(first.clone(), "symbol", &[]);
            limit = trades.get_limit(tradeSymbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(trades.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchTradesForSymbols
 * @description unWatches trades stream
 * @see https://www.kucoin.com/docs-new/3470072w0
 * @see https://www.kucoin.com/docs-new/3470084w0
 * @param {string} symbols
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn un_watch_trades_for_symbols(&mut self, mut symbols: 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;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true)]);
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isFuturesMethod: Value = Value::Bool(is_equal(&get_value(&firstMarket, &Value::Str("contract".to_string())), &Value::Bool(true)));
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut messageHashes: Value = Value::List(vec![]);
        let mut subscriptionHashes: Value = Value::List(vec![]);
        let mut channelName: Value = Value::Str("/market/match:".to_string());
        if is_true(&isFuturesMethod) {
            channelName = Value::Str("/contractMarket/execution:".to_string());
        }
        let mut topic: Value = add(&channelName, &join(&marketIds, &Value::Str(",".to_string())));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_455: bool = true;
            while { if !__for_first_455 { i = add(&i, &Value::Int(1)); } __for_first_455 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            append_to_array(&mut messageHashes, add(&Value::Str("unsubscribe:trades:".to_string()), &symbol));
            append_to_array(&mut subscriptionHashes, add(&Value::Str("trades:".to_string()), &symbol));
        }
        }
        // we have to add the topic to the messageHashes and subMessageHashes
        // because handleSubscriptionStatus needs them to remove the subscription from the client
        // without them subscription would never be removed and re-subscribe would fail because of duplicate subscriptionHash
        append_to_array(&mut messageHashes, topic.clone());
        append_to_array(&mut subscriptionHashes, topic.clone());
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), messageHashes.clone());
                m.insert("subMessageHashes".to_string(), subscriptionHashes.clone());
                m.insert("topic".to_string(), Value::Str("trades".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("symbols".to_string(), symbols.clone());
            m
        });
        return self.un_subscribe_multiple(url.clone(), messageHashes.clone(), topic.clone(), messageHashes.clone(), &[params.clone(), subscription.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchTrades
 * @description unWatches trades stream
 * @see https://www.kucoin.com/docs-new/3470072w0
 * @see https://www.kucoin.com/docs-new/3470084w0
 * @see https://www.kucoin.com/docs-new/3470224w0
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @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
}));
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTrades".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&uta) {
            self.load_markets(&[]).await;
            let mut market: Value = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
            let mut subMessageHash: Value = add(&Value::Str("uta:trades:".to_string()), &symbol);
            let mut messageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            let mut channel: Value = Value::Str("trade".to_string());
            let mut subscription: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("messageHashes".to_string(), Value::List(vec![messageHash.clone()]));
                    m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                    m.insert("topic".to_string(), Value::Str("trades".to_string()));
                    m.insert("unsubscribe".to_string(), Value::Bool(true));
                    m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m
            });
            return self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone(), subscription.clone()]).await;
        }
        return self.un_watch_trades_for_symbols(Value::List(vec![symbol.clone()]), &[params.clone()]).await;

    Value::Null
}

    pub fn handle_trade(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "data": {
        //             "sequence": "1568787654360",
        //             "symbol": "BTC-USDT",
        //             "side": "buy",
        //             "size": "0.00536577",
        //             "price": "9345",
        //             "takerOrderId": "5e356c4a9f1a790008f8d921",
        //             "time": "1580559434436443257",
        //             "type": "match",
        //             "makerOrderId": "5e356bffedf0010008fa5d7f",
        //             "tradeId": "5e356c4aeefabd62c62a1ece"
        //         },
        //         "subject": "trade.l3match",
        //         "topic": "/market/match:BTC-USDT",
        //         "type": "message"
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut trade: Value = self.parse_trade(data.clone(), &[market.clone()]);
        let mut symbol: Value = get_value(&trade, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&Value::Str("trades:".to_string()), &symbol);
        if !is_true(&(Value::Bool(in_op(&self.trades, &symbol)))) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            let mut stored = ArrayCache::new(limit.clone());
            add_element_to_object(&mut self.trades, &symbol, stored.clone());
        }
        let mut cache: Value = get_value(&self.trades, &symbol);
        cache.append(trade.clone());
        client.resolve(&[cache.clone(), messageHash.clone()]);
}

    pub fn handle_uta_trade(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "trade.SPOT",
        //         "P": "1774618231151398133",
        //         "d": {
        //             "E": "20745928670070784",
        //             "M": "1774618231141000000",
        //             "S": "buy",
        //             "p": "1995.49",
        //             "q": "0.3142324",
        //             "s": "ETH-USDT",
        //             "ti": "20745928670070784"
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut trade: Value = self.parse_ws_uta_trade(data.clone(), &[market.clone()]);
        let mut symbol: Value = get_value(&trade, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&Value::Str("uta:trades:".to_string()), &symbol);
        if !is_true(&(Value::Bool(in_op(&self.trades, &symbol)))) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            let mut stored = ArrayCache::new(limit.clone());
            add_element_to_object(&mut self.trades, &symbol, stored.clone());
        }
        let mut cache: Value = get_value(&self.trades, &symbol);
        cache.append(trade.clone());
        client.resolve(&[cache.clone(), messageHash.clone()]);
}

    pub fn parse_ws_uta_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        // trades
        //     {
        //         "E": "20745928670070784",
        //         "M": "1774618231141000000",
        //         "S": "buy",
        //         "p": "1995.49",
        //         "q": "0.3142324",
        //         "s": "ETH-USDT",
        //         "ti": "20745928670070784"
        //     }
        //
        // myTrades
        //     {
        //         "E": "1774977429843000000",
        //         "S": "SELL",
        //         "p": "0.09211",
        //         "q": "10",
        //         "s": "DOGE-USDT",
        //         "lR": "TAKER",
        //         "oT": "MARKET",
        //         "oi": "428507829452754944",
        //         "ti": 20801647764195330
        //     }
        //
        let mut marketId: Value = self.safe_string_k(trade.clone(), "s", &[]);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut timestamp: Value = self.safe_integer_product2(trade.clone(), Value::Str("M".to_string()), Value::Str("E".to_string()), Value::Float(0.000001), &[]);
        let mut fee: Value = Value::Null;
        let mut feeCost: Value = self.safe_string_k(trade.clone(), "f", &[]);
        if !is_equal(&feeCost, &Value::Null) {
            let mut feeCurrencyId: Value = self.safe_string_k(trade.clone(), "fC", &[]);
            let mut feeCurrencyCode: Value = self.safe_currency_code(feeCurrencyId.clone(), &[]);
            fee = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("cost".to_string(), feeCost.clone());
                    m.insert("currency".to_string(), feeCurrencyCode.clone());
                m
            });
        }
        return self.safe_trade(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), trade.clone());
        m.insert("id".to_string(), self.safe_string_k(trade.clone(), "ti", &[]));
        m.insert("order".to_string(), self.safe_string_k(trade.clone(), "oi", &[]));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("symbol".to_string(), get_value(&market, &Value::Str("symbol".to_string())));
        m.insert("type".to_string(), self.safe_string_lower(trade.clone(), Value::Str("oT".to_string()), &[]));
        m.insert("side".to_string(), self.safe_string_lower(trade.clone(), Value::Str("S".to_string()), &[]));
        m.insert("takerOrMaker".to_string(), self.safe_string_lower(trade.clone(), Value::Str("lR".to_string()), &[]));
        m.insert("price".to_string(), self.safe_string_k(trade.clone(), "p", &[]));
        m.insert("amount".to_string(), self.safe_string_k(trade.clone(), "q", &[]));
        m.insert("cost".to_string(), Value::Null);
        m.insert("fee".to_string(), fee.clone());
    m
}), &[market.clone()]);

    Value::Null
}

/*
 * @method
 * @name kucoin#watchOrderBook
 * @see https://www.kucoin.com/docs-new/3470069w0 // spot level 5
 * @see https://www.kucoin.com/docs-new/3470070w0 // spot level 50
 * @see https://www.kucoin.com/docs-new/3470068w0 // spot incremental
 * @see https://www.kucoin.com/docs-new/3470083w0 // futures level 5
 * @see https://www.kucoin.com/docs-new/3470097w0 // futures level 50
 * @see https://www.kucoin.com/docs-new/3470082w0 // futures incremental
 * @see https://www.kucoin.com/docs-new/3470221w0 // uta
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @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
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
 * @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
}));
        //
        // https://docs.kucoin.com/#level-2-market-data
        //
        // 1. After receiving the websocket Level 2 data flow, cache the data.
        // 2. Initiate a REST request to get the snapshot data of Level 2 order book.
        // 3. Playback the cached Level 2 data flow.
        // 4. Apply the new Level 2 data flow to the local snapshot to ensure that
        // the sequence of the new Level 2 update lines up with the sequence of
        // the previous Level 2 data. Discard all the message prior to that
        // sequence, and then playback the change to snapshot.
        // 5. Update the level2 full data based on sequence according to the
        // size. If the price is 0, ignore the messages and update the sequence.
        // If the size=0, update the sequence and remove the price of which the
        // size is 0 out of level 2. Fr other cases, please update the price.
        //
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrderBook".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&uta) {
            self.load_markets(&[]).await;
            let mut market: Value = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
            let mut depth: Value = Value::Str("increment".to_string()); // '1', '5', '50' or 'increment'
            { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrderBook".to_string()), Value::Str("utaDepth".to_string()), &[depth.clone()]); depth = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
            let mut messageHash: Value = add(&add(&add(&Value::Str("uta:orderbook:".to_string()), &symbol), &Value::Str(":depth:".to_string())), &depth);
            let mut channel: Value = Value::Str("obu".to_string());
            let mut subscription: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            if is_true(&(is_equal(&depth, &Value::Str("increment".to_string())))) {
                subscription = Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("method".to_string(), Value::Str("handle_order_book_subscription".to_string()).clone());
                        m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                        m.insert("limit".to_string(), limit.clone());
                    m
                });
            }
            params = self.extend(params.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("depth".to_string(), depth.clone());
                m
            })]);
            let mut orderbook: Value = self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone(), subscription.clone()]).await;
            return orderbook.limit();
        }
        return self.watch_order_book_for_symbols(Value::List(vec![symbol.clone()]), &[limit.clone(), params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchOrderBook
 * @see https://www.kucoin.com/docs-new/3470069w0 // spot level 5
 * @see https://www.kucoin.com/docs-new/3470070w0 // spot level 50
 * @see https://www.kucoin.com/docs-new/3470068w0 // spot incremental
 * @see https://www.kucoin.com/docs-new/3470083w0 // futures level 5
 * @see https://www.kucoin.com/docs-new/3470097w0 // futures level 50
 * @see https://www.kucoin.com/docs-new/3470082w0 // futures incremental
 * @see https://www.kucoin.com/docs-new/3470221w0 // uta
 * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta), default is false
 * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
 * @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
}));
        let mut uta: Value = Value::Bool(false);
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchOrderBook".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_true(&uta) {
            self.load_markets(&[]).await;
            let mut market: Value = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
            let mut depth: Value = Value::Str("increment".to_string()); // '1', '5', '50' or 'increment'
            { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrderBook".to_string()), Value::Str("utaDepth".to_string()), &[depth.clone()]); depth = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
            params = self.extend(params.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("depth".to_string(), depth.clone());
                m
            })]);
            let mut subMessageHash: Value = add(&add(&add(&Value::Str("uta:orderbook:".to_string()), &symbol), &Value::Str(":depth:".to_string())), &depth);
            let mut messageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
            let mut channel: Value = Value::Str("obu".to_string());
            let mut subscription: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("messageHashes".to_string(), Value::List(vec![messageHash.clone()]));
                    m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                    m.insert("topic".to_string(), Value::Str("orderbook".to_string()));
                    m.insert("unsubscribe".to_string(), Value::Bool(true));
                    m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m
            });
            return self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone(), subscription.clone()]).await;
        }
        return self.un_watch_order_book_for_symbols(Value::List(vec![symbol.clone()]), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#watchOrderBookForSymbols
 * @see https://www.kucoin.com/docs-new/3470069w0 // spot level 5
 * @see https://www.kucoin.com/docs-new/3470070w0 // spot level 50
 * @see https://www.kucoin.com/docs-new/3470068w0 // spot incremental
 * @see https://www.kucoin.com/docs-new/3470083w0 // futures level 5
 * @see https://www.kucoin.com/docs-new/3470097w0 // futures level 50
 * @see https://www.kucoin.com/docs-new/3470082w0 // futures incremental
 * @see https://www.kucoin.com/docs-new/3470221w0 // uta
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @param {string[]} symbols unified array of symbols
 * @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_for_symbols(&mut self, mut symbols: 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
}));
        let mut symbolsLength: Value = get_array_length(&symbols);
        if is_equal(&symbolsLength, &Value::Int(0)) {
            panic!("{}", crate::exchange_errors::arguments_required(add(&self.id, &Value::Str(" watchOrderBookForSymbols() requires a non-empty array of symbols".to_string()))));
        }
        if !is_equal(&limit, &Value::Null) {
            if is_true(&(!is_equal(&limit, &Value::Int(20)))) && is_true(&(!is_equal(&limit, &Value::Int(100)))) && is_true(&(!is_equal(&limit, &Value::Int(50)))) && is_true(&(!is_equal(&limit, &Value::Int(5)))) {
                panic!("{}", crate::exchange_errors::exchange_error(add(&self.id, &Value::Str(" watchOrderBook 'limit' argument must be undefined, 5, 20, 50 or 100".to_string()))));
            }
        }
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        symbols = self.market_symbols(&[symbols.clone()]);
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isFuturesMethod: Value = Value::Bool(is_equal(&get_value(&firstMarket, &Value::Str("contract".to_string())), &Value::Bool(true)));
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut method: Value = ternary(is_true(&isFuturesMethod), Value::Str("/contractMarket/level2".to_string()), Value::Str("/market/level2".to_string()));
        let mut optionName: Value = ternary(is_true(&isFuturesMethod), Value::Str("contractMethod".to_string()), Value::Str("spotMethod".to_string()));
        { let __destr_tmp = self.handle_option_and_params2(params.clone(), Value::Str("watchOrderBook".to_string()), optionName.clone(), Value::Str("method".to_string()), &[method.clone()]); method = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_less_than(&get_index_of(&method, &Value::Str("Depth".to_string())), &Value::Int(0)) {
            if is_true(&(is_equal(&limit, &Value::Int(5)))) || is_true(&(is_equal(&limit, &Value::Int(50)))) {
                if !is_true(&isFuturesMethod) {
                    method = Value::Str("/spotMarket/level2".to_string());
                }
                method = add(&method, &add(&Value::Str("Depth".to_string()), &to_string_val(&limit)));
            }
        }
        let mut topic: Value = add(&add(&method, &Value::Str(":".to_string())), &join(&marketIds, &Value::Str(",".to_string())));
        let mut messageHashes: Value = Value::List(vec![]);
        let mut subscriptionHashes: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_456: bool = true;
            while { if !__for_first_456 { i = add(&i, &Value::Int(1)); } __for_first_456 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            append_to_array(&mut messageHashes, add(&Value::Str("orderbook:".to_string()), &symbol));
            let mut marketId: Value = get_value(&marketIds, &i);
            let mut marketId: Value = get_value(&marketIds, &i);
            append_to_array(&mut subscriptionHashes, add(&add(&method, &Value::Str(":".to_string())), &marketId));
        }
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if is_true(&(is_equal(&method, &Value::Str("/market/level2".to_string())))) || is_true(&(is_equal(&method, &Value::Str("/contractMarket/level2".to_string())))) {
            subscription = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("method".to_string(), Value::Str("handle_order_book_subscription".to_string()).clone());
                    m.insert("symbols".to_string(), symbols.clone());
                    m.insert("limit".to_string(), limit.clone());
                m
            });
        }
        let mut orderbook: Value = self.subscribe_multiple(url.clone(), messageHashes.clone(), topic.clone(), subscriptionHashes.clone(), &[params.clone(), subscription.clone()]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchOrderBookForSymbols
 * @see https://www.kucoin.com/docs-new/3470069w0 // spot level 5
 * @see https://www.kucoin.com/docs-new/3470070w0 // spot level 50
 * @see https://www.kucoin.com/docs-new/3470068w0 // spot incremental
 * @see https://www.kucoin.com/docs-new/3470083w0 // futures level 5
 * @see https://www.kucoin.com/docs-new/3470097w0 // futures level 50
 * @see https://www.kucoin.com/docs-new/3470082w0 // futures incremental
 * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @param {string[]} symbols unified array of symbols
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' or '/contractMarket/level2' or '/contractMarket/level2Depth5' or '/contractMarket/level2Depth50' default is '/market/level2' for spot and '/contractMarket/level2' for futures
 * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn un_watch_order_book_for_symbols(&mut self, mut symbols: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut limit: Value = self.safe_integer_k(params.clone(), "limit", &[]);
        params = self.omit(params.clone(), Value::Str("limit".to_string()), &[]);
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true)]);
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut firstMarket: Value = self.get_market_from_symbols(&[symbols.clone()]);
        let mut isFuturesMethod: Value = Value::Bool(is_equal(&get_value(&firstMarket, &Value::Str("contract".to_string())), &Value::Bool(true)));
        let mut url: Value = self.negotiate(Value::Bool(false), &[isFuturesMethod.clone()]).await;
        let mut method: Value = ternary(is_true(&isFuturesMethod), Value::Str("/contractMarket/level2".to_string()), Value::Str("/market/level2".to_string()));
        let mut optionName: Value = ternary(is_true(&isFuturesMethod), Value::Str("contractMethod".to_string()), Value::Str("spotMethod".to_string()));
        { let __destr_tmp = self.handle_option_and_params2(params.clone(), Value::Str("watchOrderBook".to_string()), optionName.clone(), Value::Str("method".to_string()), &[method.clone()]); method = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        if is_less_than(&get_index_of(&method, &Value::Str("Depth".to_string())), &Value::Int(0)) {
            if is_true(&(is_equal(&limit, &Value::Int(5)))) || is_true(&(is_equal(&limit, &Value::Int(50)))) {
                if !is_true(&isFuturesMethod) {
                    method = Value::Str("/spotMarket/level2".to_string());
                }
                method = add(&method, &add(&Value::Str("Depth".to_string()), &to_string_val(&limit)));
            }
        }
        let mut topic: Value = add(&add(&method, &Value::Str(":".to_string())), &join(&marketIds, &Value::Str(",".to_string())));
        let mut messageHashes: Value = Value::List(vec![]);
        let mut subscriptionHashes: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_457: bool = true;
            while { if !__for_first_457 { i = add(&i, &Value::Int(1)); } __for_first_457 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            append_to_array(&mut messageHashes, add(&Value::Str("unsubscribe:orderbook:".to_string()), &symbol));
            append_to_array(&mut subscriptionHashes, add(&Value::Str("orderbook:".to_string()), &symbol));
        }
        }
        // we have to add the topic to the messageHashes and subMessageHashes
        // because handleSubscriptionStatus needs them to remove the subscription from the client
        // without them subscription would never be removed and re-subscribe would fail because of duplicate subscriptionHash
        append_to_array(&mut messageHashes, topic.clone());
        append_to_array(&mut subscriptionHashes, topic.clone());
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), messageHashes.clone());
                m.insert("symbols".to_string(), symbols.clone());
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("topic".to_string(), Value::Str("orderbook".to_string()));
                m.insert("subMessageHashes".to_string(), subscriptionHashes.clone());
            m
        });
        return self.un_subscribe_multiple(url.clone(), messageHashes.clone(), topic.clone(), messageHashes.clone(), &[params.clone(), subscription.clone()]).await;

    Value::Null
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        //
        // initial snapshot is fetched with ccxt's fetchOrderBook
        // the feed does not include a snapshot, just the deltas
        //
        //     {
        //         "type":"message",
        //         "topic":"/market/level2:BTC-USDT",
        //         "subject":"trade.l2update",
        //         "data":{
        //             "sequenceStart":1545896669105,
        //             "sequenceEnd":1545896669106,
        //             "symbol":"BTC-USDT",
        //             "changes": {
        //                 "asks": [["6","1","1545896669105"]], // price, size, sequence
        //                 "bids": [["4","1","1545896669106"]]
        //             }
        //         }
        //     }
        //
        //     {
        //         "topic": "/spotMarket/level2Depth5:BTC-USDT",
        //         "type": "message",
        //         "data": {
        //             "asks": [
        //                 [
        //                     "42815.6",
        //                     "1.24016245"
        //                 ]
        //             ],
        //             "bids": [
        //                 [
        //                     "42815.5",
        //                     "0.08652716"
        //                 ]
        //             ],
        //             "timestamp": 1707204474018
        //         },
        //         "subject": "level2"
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[]);
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        let mut topicParts: Value = split(&topic, &Value::Str(":".to_string()));
        let mut topicSymbol: Value = self.safe_string(topicParts.clone(), Value::Int(1), &[]);
        let mut topicChannel: Value = self.safe_string(topicParts.clone(), Value::Int(0), &[]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "symbol", &[topicSymbol.clone()]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("-".to_string())]);
        let mut messageHash: Value = add(&Value::Str("orderbook:".to_string()), &symbol);
        // let orderbook = this.safeDict (this.orderbooks, symbol);
        if is_greater_than_or_equal(&get_index_of(&topic, &Value::Str("Depth".to_string())), &Value::Int(0)) {
            if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) {
                { let __be_tmp = self.order_book(&[]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
            }  else {
                let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
                orderbook.reset0();
            }
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.orderbooks) }, &symbol), &Value::Str("symbol".to_string()), symbol.clone());
        }  else {
            if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) {
                { let __be_tmp = self.order_book(&[]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
            }
            let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
            let mut nonce: Value = self.safe_integer_k(orderbook.clone(), "nonce", &[]);
            let mut deltaEnd: Value = self.safe_integer2(data.clone(), Value::Str("sequenceEnd".to_string()), Value::Str("timestamp".to_string()), &[]);
            if is_equal(&nonce, &Value::Null) {
                let mut cacheLength: Value = get_array_length(&get_value(&orderbook, &Value::Str("cache".to_string())));
                let mut subscriptions: Value = object_keys(&get_value(&client, &Value::Str("subscriptions".to_string())));
                let mut subscription: Value = Value::Null;
                {
                                        let mut i: Value = Value::Int(0);
                    let mut __for_first_458: bool = true;
                    while { if !__for_first_458 { i = add(&i, &Value::Int(1)); } __for_first_458 = false; is_less_than(&i, &get_array_length(&subscriptions)) } {
                    let mut key: Value = get_value(&subscriptions, &i);
                    let mut key: Value = get_value(&subscriptions, &i);
                    if is_true(&(is_greater_than_or_equal(&get_index_of(&key, &topicSymbol), &Value::Int(0)))) && is_true(&(is_greater_than_or_equal(&get_index_of(&key, &topicChannel), &Value::Int(0)))) {
                        subscription = get_value(&get_value(&client, &Value::Str("subscriptions".to_string())), &key);
                        break;
                    }
                }
                }
                let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[]);
                let mut snapshotDelay: Value = self.handle_option(Value::Str("watchOrderBook".to_string()), Value::Str("snapshotDelay".to_string()), &[Value::Int(5)]);
                if is_equal(&cacheLength, &snapshotDelay) {
                    self.spawn(&[Value::Str("load_order_book".to_string()).clone(), client.clone(), messageHash.clone(), symbol.clone(), limit.clone(), Value::Map({
                        let mut m = indexmap::IndexMap::new();
                        m
                    })]);
                }
                crate::runtime::append_to_object_array(&mut orderbook, &Value::Str("cache".to_string()), data.clone());
                return;
            }  else if is_greater_than_or_equal(&nonce, &deltaEnd) {
                return;
            }
        }
        self.handle_delta(get_value(&self.orderbooks, &symbol), data.clone());
        client.resolve(&[get_value(&self.orderbooks, &symbol), messageHash.clone()]);
}

    pub fn handle_uta_order_book(&mut self, mut client: Value, mut message: Value) {
        //
        // snapshot
        //     {
        //         "T": "obu.SPOT",
        //         "dp": "50",
        //         "t": "snapshot",
        //         "P": "1774624848680504909",
        //         "d": {
        //             "C": 20452522782,
        //             "M": "1774624848673000000",
        //             "O": 20452522782,
        //             "a": [ [ "66532.5", "0.46243848" ] ],
        //             "b": [ [ "66532.4", "0.09489" ] ],
        //             "s": "ETH-USDT"
        //         }
        //     }
        //
        let mut type_var: Value = self.safe_string_k(message.clone(), "t", &[]);
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut timestamp: Value = self.safe_integer_product(data.clone(), Value::Str("M".to_string()), Value::Float(0.000001), &[]);
        if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) {
            { let __be_tmp = self.order_book(&[]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
        }
        let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
        let mut depth: Value = self.safe_string_k(message.clone(), "dp", &[]);
        let mut messageHash: Value = add(&add(&add(&Value::Str("uta:orderbook:".to_string()), &symbol), &Value::Str(":depth:".to_string())), &depth);
        if is_equal(&type_var, &Value::Str("snapshot".to_string())) {
            let mut parsed: Value = self.parse_order_book(data.clone(), symbol.clone(), &[timestamp.clone(), Value::Str("b".to_string()), Value::Str("a".to_string()), Value::Int(0), Value::Int(1)]);
            add_element_to_object(&mut parsed, &Value::Str("nonce".to_string()), self.safe_integer_k(data.clone(), "O", &[]));
            orderbook.reset(parsed.clone());
            add_element_to_object(&mut self.orderbooks, &symbol, orderbook.clone());
        }  else {
            let mut nonce: Value = self.safe_integer_k(orderbook.clone(), "nonce", &[]);
            let mut deltaEnd: Value = self.safe_integer_k(data.clone(), "C", &[]);
            if is_equal(&nonce, &Value::Null) {
                let mut cacheLength: Value = get_array_length(&get_value(&orderbook, &Value::Str("cache".to_string())));
                let mut subscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".to_string())), messageHash.clone(), &[Value::Map({
                    let mut m = indexmap::IndexMap::new();
                    m
                })]);
                let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[]);
                let mut snapshotDelay: Value = self.handle_option(Value::Str("watchOrderBook".to_string()), Value::Str("snapshotDelay".to_string()), &[Value::Int(5)]);
                let mut utaParams: Value = Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("uta".to_string(), Value::Bool(true));
                    m
                });
                if is_equal(&cacheLength, &snapshotDelay) {
                    self.spawn(&[Value::Str("load_order_book".to_string()).clone(), client.clone(), messageHash.clone(), symbol.clone(), limit.clone(), utaParams.clone()]);
                }
                crate::runtime::append_to_object_array(&mut orderbook, &Value::Str("cache".to_string()), data.clone());
                return;
            }  else if is_greater_than_or_equal(&nonce, &deltaEnd) {
                return;
            }
        }
        self.handle_delta(get_value(&self.orderbooks, &symbol), data.clone());
        client.resolve(&[get_value(&self.orderbooks, &symbol), messageHash.clone()]);
}

    pub fn get_cache_index(&self, mut orderbook: Value, mut cache: Value) -> Value {
        let mut firstDelta: Value = self.safe_value(cache.clone(), Value::Int(0), &[]);
        let mut nonce: Value = self.safe_integer_k(orderbook.clone(), "nonce", &[]);
        let mut firstDeltaStart: Value = self.safe_integer_n(firstDelta.clone(), Value::List(vec![Value::Str("sequenceStart".to_string()), Value::Str("sequence".to_string()), Value::Str("O".to_string())]), &[]);
        if is_less_than(&nonce, &subtract(&firstDeltaStart, &Value::Int(1))) {
            return negate(&Value::Int(1));
        }
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_459: bool = true;
            while { if !__for_first_459 { i = add(&i, &Value::Int(1)); } __for_first_459 = false; is_less_than(&i, &get_array_length(&cache)) } {
            let mut delta: Value = get_value(&cache, &i);
            let mut delta: Value = get_value(&cache, &i);
            let mut deltaStart: Value = self.safe_integer_n(delta.clone(), Value::List(vec![Value::Str("sequenceStart".to_string()), Value::Str("sequence".to_string()), Value::Str("O".to_string())]), &[]);
            let mut deltaEnd: Value = self.safe_integer_n(delta.clone(), Value::List(vec![Value::Str("sequenceEnd".to_string()), Value::Str("sequence".to_string()), Value::Str("C".to_string())]), &[]); // todo check
            if is_true(&(is_greater_than_or_equal(&nonce, &subtract(&deltaStart, &Value::Int(1))))) && is_true(&(is_less_than(&nonce, &deltaEnd))) {
                return i;
            }
        }
        }
        return get_array_length(&cache);

    Value::Null
}

    pub fn handle_delta(&self, mut orderbook: Value, mut delta: Value) {
        let mut timestamp: Value = self.safe_integer_product(delta.clone(), Value::Str("M".to_string()), Value::Float(0.000001), &[]);
        if is_equal(&timestamp, &Value::Null) {
            timestamp = self.safe_integer2(delta.clone(), Value::Str("time".to_string()), Value::Str("timestamp".to_string()), &[]);
        }
        add_element_to_object(&mut orderbook, &Value::Str("nonce".to_string()), self.safe_integer_n(delta.clone(), Value::List(vec![Value::Str("sequenceEnd".to_string()), Value::Str("sequence".to_string()), Value::Str("C".to_string())]), &[timestamp.clone()]));
        add_element_to_object(&mut orderbook, &Value::Str("timestamp".to_string()), timestamp.clone());
        add_element_to_object(&mut orderbook, &Value::Str("datetime".to_string()), self.iso8601(timestamp.clone()));
        let mut change: Value = self.safe_string_k(delta.clone(), "change", &[]);
        let mut changes: Value = self.safe_dict_k(delta.clone(), "changes", &[delta.clone()]);
        let mut storedBids: Value = get_value(&orderbook, &Value::Str("bids".to_string()));
        let mut storedAsks: Value = get_value(&orderbook, &Value::Str("asks".to_string()));
        if !is_equal(&change, &Value::Null) {
            // handling futures orderbook update
            let mut splitChange: Value = split(&change, &Value::Str(",".to_string()));
            let mut price: Value = self.safe_number(splitChange.clone(), Value::Int(0), &[]);
            let mut side: Value = self.safe_string(splitChange.clone(), Value::Int(1), &[]);
            let mut quantity: Value = self.safe_number(splitChange.clone(), Value::Int(2), &[]);
            let mut type_var: Value = ternary(is_true(&(is_equal(&side, &Value::Str("buy".to_string())))), Value::Str("bids".to_string()), Value::Str("asks".to_string()));
            let mut value: Value = Value::List(vec![price.clone(), quantity.clone()]);
            if is_equal(&type_var, &Value::Str("bids".to_string())) {
                storedBids.store_array(value.clone());
            }  else {
                storedAsks.store_array(value.clone());
            }
        }  else if !is_equal(&changes, &Value::Null) {
            let mut bids: Value = self.safe_list_k(changes.clone(), "bids", &[Value::List(vec![])]);
            let mut asks: Value = self.safe_list_k(changes.clone(), "asks", &[Value::List(vec![])]);
            self.handle_bid_asks(storedBids.clone(), bids.clone());
            self.handle_bid_asks(storedAsks.clone(), asks.clone());
        }  else {
            let mut bids: Value = self.safe_list2(delta.clone(), Value::Str("bids".to_string()), Value::Str("b".to_string()), &[Value::List(vec![])]);
            let mut asks: Value = self.safe_list2(delta.clone(), Value::Str("asks".to_string()), Value::Str("a".to_string()), &[Value::List(vec![])]);
            self.handle_bid_asks(storedBids.clone(), bids.clone());
            self.handle_bid_asks(storedAsks.clone(), asks.clone());
        }
}

    pub fn handle_bid_asks(&self, mut bookSide: Value, mut bidAsks: Value) {
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_460: bool = true;
            while { if !__for_first_460 { i = add(&i, &Value::Int(1)); } __for_first_460 = false; is_less_than(&i, &get_array_length(&bidAsks)) } {
            let mut bidAsk: Value = self.parse_order_book_bid_ask(get_value(&bidAsks, &i), &[]);
            bookSide.store_array(bidAsk.clone());
        }
        }
}

    pub fn handle_order_book_subscription(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[]);
        let mut symbols: Value = self.safe_list_k(subscription.clone(), "symbols", &[]);
        if is_equal(&symbols, &Value::Null) {
            let mut symbol: Value = self.safe_string_k(subscription.clone(), "symbol", &[]);
            { 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); };
        }  else {
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_461: bool = true;
                while { if !__for_first_461 { i = add(&i, &Value::Int(1)); } __for_first_461 = false; is_less_than(&i, &get_array_length(&symbols)) } {
                let mut symbol: Value = get_value(&symbols, &i);
                let mut symbol: Value = get_value(&symbols, &i);
                { 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); };
            }
            }
        }
}

    pub fn handle_subscription_status(&mut self, mut client: Value, mut message: Value) {
        //
        // classic
        //     {
        //         "id": "1578090438322",
        //         "type": "ack"
        //     }
        //
        // uta
        //     {
        //         "id": "1",
        //         "result": true
        //     }
        //
        let mut id: Value = self.safe_string_k(message.clone(), "id", &[]);
        if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &id)))) {
            return;
        }
        let mut subscriptionHash: Value = self.safe_string(get_value(&client, &Value::Str("subscriptions".to_string())), id.clone(), &[]);
        let mut subscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".to_string())), subscriptionHash.clone(), &[]);
        remove(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &id);
        let mut method: Value = self.safe_value_k(subscription.clone(), "method", &[]);
        if !is_equal(&method, &Value::Null) {
            self.dispatch_ws_handler(&method, &[client.clone(), message.clone(), subscription.clone()]);
        }
        let mut isUnSub: Value = self.safe_bool_k(subscription.clone(), "unsubscribe", &[Value::Bool(false)]);
        if is_equal(&isUnSub, &Value::Bool(true)) {
            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_462: bool = true;
                while { if !__for_first_462 { i = add(&i, &Value::Int(1)); } __for_first_462 = 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 subHash: Value = get_value(&subMessageHashes, &i);
                let mut subHash: Value = get_value(&subMessageHashes, &i);
                self.clean_unsubscription(client.clone(), subHash.clone(), messageHash.clone(), &[]);
            }
            }
            let mut topic: Value = self.safe_string_k(subscription.clone(), "topic", &[]);
            if is_equal(&topic, &Value::Str("fundingRate".to_string())) {
                // todo: add fundingRate topic to cleanCache
                let mut symbols: Value = self.safe_list_k(subscription.clone(), "symbols", &[Value::List(vec![])]);
                {
                                        let mut i: Value = Value::Int(0);
                    let mut __for_first_463: bool = true;
                    while { if !__for_first_463 { i = add(&i, &Value::Int(1)); } __for_first_463 = false; is_less_than(&i, &get_array_length(&symbols)) } {
                    let mut symbol: Value = get_value(&symbols, &i);
                    let mut symbol: Value = get_value(&symbols, &i);
                    if is_true(&Value::Bool(in_op(&self.fundingRates, &symbol))) {
                        remove(&mut self.fundingRates, &symbol);
                    }
                }
                }
            }  else {
                self.clean_cache(subscription.clone());
            }
        }
}

    pub fn handle_system_status(&self, mut client: Value, mut message: Value) -> Value {
        //
        // todo: answer the question whether handleSystemStatus should be renamed
        // and unified as handleStatus for any usage pattern that
        // involves system status and maintenance updates
        //
        //     {
        //         "id": "1578090234088", // connectId
        //         "type": "welcome",
        //     }
        //
        // uta
        //     {
        //         "sessionId": "ddfb0cbd-f7a7-40c2-9129-445bbb830c54",
        //         "message": "welcome",
        //         "pingInterval": 18000
        //     }
        //
        let mut pingInterval: Value = self.safe_integer_k(message.clone(), "pingInterval", &[]);
        if !is_equal(&pingInterval, &Value::Null) {
            crate::set_value(&mut client, &Value::Str("keepAlive".to_string()), pingInterval.clone());
        }
        return message;

    Value::Null
}

/*
 * @method
 * @name kucoin#watchOrders
 * @description watches information on multiple orders made by the user
 * @see https://www.kucoin.com/docs-new/3470074w0 // spot regular orders
 * @see https://www.kucoin.com/docs-new/3470139w0 // spot trigger orders
 * @see https://www.kucoin.com/docs-new/3470090w0 // contract regular orders
 * @see https://www.kucoin.com/docs-new/3470091w0 // contract trigger orders
 * @see https://www.kucoin.com/docs-new/3470228w0 // uta orders
 * @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
 * @param {boolean} [params.uta] set to true for the unified trading account (uta)
 * @param {boolean} [params.trigger] trigger orders are watched if true
 * @param {string} [params.type] 'spot' or 'swap' (default is 'spot' if symbol is not provided)
 * @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;
        }
        let mut uta: Value = self.is_uta_enabled(&[]).await;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrders".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("orders".to_string());
        if !is_equal(&symbol, &Value::Null) {
            market = self.market(symbol.clone());
            symbol = get_value(&market, &Value::Str("symbol".to_string()));
            messageHash = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
        }
        let mut orders: Value = Value::Null;
        if is_true(&uta) {
            params = self.extend(params.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("tradeType".to_string(), Value::Str("UNIFIED".to_string()));
                m
            })]);
            messageHash = add(&Value::Str("uta:".to_string()), &messageHash);
            let mut channel: Value = Value::Str("order".to_string());
            if is_equal(&symbol, &Value::Null) {
                channel = add(&channel, &Value::Str("All".to_string()));
            }
            orders = self.subscribe_private_uta(Value::List(vec![messageHash.clone()]), messageHash.clone(), channel.clone(), &[symbol.clone(), params.clone()]).await;
        }  else {
            let mut trigger: Value = self.safe_bool2(params.clone(), Value::Str("stop".to_string()), Value::Str("trigger".to_string()), &[]);
            params = self.omit(params.clone(), Value::List(vec![Value::Str("stop".to_string()), Value::Str("trigger".to_string())]), &[]);
            let mut marketType: Value = Value::Null;
            { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchOrders".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
            let mut isFuturesMethod: Value = Value::Bool(is_true(&(!is_equal(&marketType, &Value::Str("spot".to_string())))) && is_true(&(!is_equal(&marketType, &Value::Str("margin".to_string())))));
            let mut url: Value = self.negotiate(Value::Bool(true), &[isFuturesMethod.clone()]).await;
            let mut topic: Value = ternary(is_true(&(is_equal(&trigger, &Value::Bool(true)))), Value::Str("/spotMarket/advancedOrders".to_string()), Value::Str("/spotMarket/tradeOrders".to_string()));
            if is_true(&isFuturesMethod) {
                topic = ternary(is_true(&(is_equal(&trigger, &Value::Bool(true)))), Value::Str("/contractMarket/advancedOrders".to_string()), Value::Str("/contractMarket/tradeOrders".to_string()));
            }
            if is_equal(&symbol, &Value::Null) {
                let mut suffix: Value = self.get_orders_message_hash_suffix(topic.clone());
                messageHash = add(&messageHash, &suffix);
            }
            let mut request: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("privateChannel".to_string(), Value::Bool(true));
                m
            });
            let __ws_arg_2 = self.extend(request.clone(), &[params.clone()]);
            orders = self.subscribe(url.clone(), messageHash.clone(), topic.clone(), &[__ws_arg_2]).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
}

    pub fn get_orders_message_hash_suffix(&self, mut topic: Value) -> Value {
        let mut suffix: Value = Value::Str("-spot".to_string());
        if is_equal(&topic, &Value::Str("/spotMarket/advancedOrders".to_string())) {
            suffix = add(&suffix, &Value::Str("-trigger".to_string()));
        }  else if is_equal(&topic, &Value::Str("/contractMarket/tradeOrders".to_string())) {
            suffix = Value::Str("-contract".to_string());
        }  else if is_equal(&topic, &Value::Str("/contractMarket/advancedOrders".to_string())) {
            suffix = Value::Str("-contract-trigger".to_string());
        }
        return suffix;

    Value::Null
}

    pub fn parse_ws_order_status(&self, mut status: Value) -> Value {
        let mut statuses: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("open".to_string(), Value::Str("open".to_string()));
                m.insert("filled".to_string(), Value::Str("closed".to_string()));
                m.insert("match".to_string(), Value::Str("open".to_string()));
                m.insert("update".to_string(), Value::Str("open".to_string()));
                m.insert("canceled".to_string(), Value::Str("canceled".to_string()));
                m.insert("cancel".to_string(), Value::Str("canceled".to_string()));
                m.insert("TRIGGERED".to_string(), Value::Str("triggered".to_string()));
            m
        });
        return self.safe_string(statuses.clone(), status.clone(), &[status.clone()]);

    Value::Null
}

    pub fn parse_ws_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        // /spotMarket/tradeOrders
        //
        //    {
        //        "symbol": "XCAD-USDT",
        //        "orderType": "limit",
        //        "side": "buy",
        //        "orderId": "6249167327218b000135e749",
        //        "type": "canceled",
        //        "orderTime": 1648957043065280224,
        //        "size": "100.452",
        //        "filledSize": "0",
        //        "price": "2.9635",
        //        "clientOid": "buy-XCAD-USDT-1648957043010159",
        //        "remainSize": "0",
        //        "status": "done",
        //        "ts": 1648957054031001037
        //    }
        //
        // /spotMarket/advancedOrders
        //
        //    {
        //        "createdAt": 1589789942337,
        //        "orderId": "5ec244f6a8a75e0009958237",
        //        "orderPrice": "0.00062",
        //        "orderType": "stop",
        //        "side": "sell",
        //        "size": "1",
        //        "stop": "entry",
        //        "stopPrice": "0.00062",
        //        "symbol": "KCS-BTC",
        //        "tradeType": "TRADE",
        //        "triggerSuccess": true,
        //        "ts": 1589790121382281286,
        //        "type": "triggered"
        //    }
        //
        // futures
        //     {
        //         "symbol": "ETHUSDTM",
        //         "orderType": "market",
        //         "side": "buy",
        //         "canceledSize": "0",
        //         "orderId": "416204113500479490",
        //         "positionSide": "LONG",
        //         "liquidity": "taker",
        //         "marginMode": "ISOLATED",
        //         "type": "match",
        //         "feeType": "takerFee",
        //         "orderTime": "1772043995356345762",
        //         "size": "1",
        //         "filledSize": "1",
        //         "price": "0",
        //         "matchPrice": "2068.55",
        //         "matchSize": "1",
        //         "remainSize": "0",
        //         "tradeId": "1815302608109",
        //         "clientOid": "9f7a2be0-effe-45bd-bdc8-1614715a583a",
        //         "tradeType": "trade",
        //         "status": "match",
        //         "ts": 1772043995362000000
        //     }
        //
        let mut rawType: Value = self.safe_string_k(order.clone(), "type", &[]);
        let mut status: Value = self.parse_ws_order_status(rawType.clone());
        let mut timestamp: Value = self.safe_integer2(order.clone(), Value::Str("orderTime".to_string()), Value::Str("createdAt".to_string()), &[]);
        let mut marketId: Value = self.safe_string_k(order.clone(), "symbol", &[]);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        if is_equal(&get_value(&market, &Value::Str("contract".to_string())), &Value::Bool(true)) {
            timestamp = self.safe_integer_product(order.clone(), Value::Str("orderTime".to_string()), Value::Float(0.000001), &[]);
        }
        let mut triggerPrice: Value = self.safe_string_k(order.clone(), "stopPrice", &[]);
        let mut triggerSuccess: Value = self.safe_bool_k(order.clone(), "triggerSuccess", &[]);
        let mut triggerFail: bool = is_true(&(!is_equal(&triggerSuccess, &Value::Bool(true)))) && is_true(&(!is_equal(&triggerSuccess, &Value::Null))); // TODO: updated to triggerSuccess === False once transpiler transpiles it correctly
        if is_true(&(is_equal(&status, &Value::Str("triggered".to_string())))) && is_true(&triggerFail) {
            status = Value::Str("canceled".to_string());
        }
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order.clone());
        m.insert("symbol".to_string(), get_value(&market, &Value::Str("symbol".to_string())));
        m.insert("id".to_string(), self.safe_string_k(order.clone(), "orderId", &[]));
        m.insert("clientOrderId".to_string(), self.safe_string_k(order.clone(), "clientOid", &[]));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("lastTradeTimestamp".to_string(), Value::Null);
        m.insert("type".to_string(), self.safe_string_lower(order.clone(), Value::Str("orderType".to_string()), &[]));
        m.insert("timeInForce".to_string(), Value::Null);
        m.insert("postOnly".to_string(), Value::Null);
        m.insert("side".to_string(), self.safe_string_lower(order.clone(), Value::Str("side".to_string()), &[]));
        m.insert("price".to_string(), self.safe_string2(order.clone(), Value::Str("price".to_string()), Value::Str("orderPrice".to_string()), &[]));
        m.insert("stopPrice".to_string(), triggerPrice.clone());
        m.insert("triggerPrice".to_string(), triggerPrice.clone());
        m.insert("amount".to_string(), self.safe_string_k(order.clone(), "size", &[]));
        m.insert("cost".to_string(), Value::Null);
        m.insert("average".to_string(), Value::Null);
        m.insert("filled".to_string(), self.safe_string_k(order.clone(), "filledSize", &[]));
        m.insert("remaining".to_string(), Value::Null);
        m.insert("status".to_string(), status.clone());
        m.insert("fee".to_string(), Value::Null);
        m.insert("trades".to_string(), Value::Null);
    m
}), &[market.clone()]);

    Value::Null
}

    pub fn parse_ws_uta_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "tT": "FUTURES",
        //         "oi": "427737326394129559",
        //         "ci": "",
        //         "os": 5,
        //         "eT": "CANCEL",
        //         "s": "DOGEUSDTM",
        //         "S": "SELL",
        //         "oT": "MARKET",
        //         "lR": "",
        //         "oS": "USER",
        //         "p": "",
        //         "ti": "",
        //         "q": "1",
        //         "qU": "UNIT",
        //         "fS": "0",
        //         "lS": "0",
        //         "ls": "0",
        //         "aP": "0",
        //         "f": "0",
        //         "fC": "USDT",
        //         "t": "0",
        //         "cR": "USER",
        //         "cS": "1",
        //         "rS": "0",
        //         "tD": "DOWN",
        //         "tP": "0.01",
        //         "tPT": "MP",
        //         "pP": "",
        //         "pPT": "",
        //         "lP": "",
        //         "lPT": "",
        //         "toi": "427737326102335488",
        //         "stp": "",
        //         "rO": true,
        //         "tIF": "GTC",
        //         "pO": false,
        //         "O": "1774793727626043888",
        //         "U": 1774794309608959200
        //     }
        //
        let mut timestamp: Value = self.safe_integer_product(order.clone(), Value::Str("O".to_string()), Value::Float(0.000001), &[]);
        let mut rawStatus: Value = self.safe_string_k(order.clone(), "os", &[]);
        let mut marketId: Value = self.safe_string_k(order.clone(), "s", &[]);
        let mut rawTimeInForce: Value = self.safe_string_k(order.clone(), "tIF", &[]);
        let mut remainSize: Value = self.safe_string_k(order.clone(), "rS", &[]);
        let mut canceledSize: Value = self.safe_string_k(order.clone(), "cS", &[]);
        let mut remaining: Value = crate::precise::Precise::stringAdd(&remainSize, &canceledSize);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut fee: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("cost".to_string(), self.safe_string_k(order.clone(), "f", &[]));
                m.insert("currency".to_string(), self.safe_currency_code(self.safe_string_k(order.clone(), "fC", &[]), &[]));
            m
        });
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order.clone());
        m.insert("id".to_string(), self.safe_string_k(order.clone(), "oi", &[]));
        m.insert("clientOrderId".to_string(), self.safe_string_k(order.clone(), "ci", &[]));
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("lastTradeTimestamp".to_string(), Value::Null);
        m.insert("lastUpdateTimestamp".to_string(), self.safe_integer_product(order.clone(), Value::Str("U".to_string()), Value::Float(0.000001), &[]));
        m.insert("status".to_string(), self.parent.parse_order_status(rawStatus.clone()));
        m.insert("symbol".to_string(), get_value(&market, &Value::Str("symbol".to_string())));
        m.insert("type".to_string(), self.safe_string_lower(order.clone(), Value::Str("oT".to_string()), &[]));
        m.insert("timeInForce".to_string(), self.parent.parse_order_time_in_force(rawTimeInForce.clone()));
        m.insert("side".to_string(), self.safe_string_lower(order.clone(), Value::Str("S".to_string()), &[]));
        m.insert("price".to_string(), self.safe_string_k(order.clone(), "p", &[]));
        m.insert("average".to_string(), self.safe_string_k(order.clone(), "aP", &[]));
        m.insert("amount".to_string(), self.safe_string_k(order.clone(), "q", &[]));
        m.insert("filled".to_string(), self.safe_string_k(order.clone(), "fS", &[]));
        m.insert("remaining".to_string(), remaining.clone());
        m.insert("triggerPrice".to_string(), self.safe_string_k(order.clone(), "tP", &[]));
        m.insert("takeProfitPrice".to_string(), self.safe_string_k(order.clone(), "pP", &[]));
        m.insert("stopLossPrice".to_string(), self.safe_string_k(order.clone(), "lP", &[]));
        m.insert("cost".to_string(), self.safe_string_k(order.clone(), "c", &[]));
        m.insert("trades".to_string(), Value::Null);
        m.insert("fee".to_string(), fee.clone());
        m.insert("reduceOnly".to_string(), self.safe_bool_k(order.clone(), "rO", &[]));
        m.insert("postOnly".to_string(), self.safe_bool_k(order.clone(), "pO", &[]));
    m
}), &[market.clone()]);

    Value::Null
}

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        //
        // Trigger Orders
        //
        //    {
        //        "createdAt": 1692745706437,
        //        "error": "Balance insufficient!",       // not always there
        //        "orderId": "vs86kp757vlda6ni003qs70v",
        //        "orderPrice": "0.26",
        //        "orderType": "stop",
        //        "side": "sell",
        //        "size": "5",
        //        "stop": "loss",
        //        "stopPrice": "0.26",
        //        "symbol": "ADA-USDT",
        //        "tradeType": "TRADE",
        //        "triggerSuccess": false,                // not always there
        //        "ts": "1692745706442929298",
        //        "type": "open"
        //    }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[]);
        let mut tradeId: Value = self.safe_string_k(data.clone(), "tradeId", &[]);
        if !is_equal(&tradeId, &Value::Null) {
            self.handle_my_trade(client.clone(), message.clone());
        }
        let mut parsed: Value = self.parse_ws_order(data.clone(), &[]);
        let mut symbol: Value = self.safe_string_k(parsed.clone(), "symbol", &[]);
        let mut orderId: Value = self.safe_string_k(parsed.clone(), "id", &[]);
        let mut triggerPrice: Value = self.safe_string_k(parsed.clone(), "triggerPrice", &[]);
        let mut isTriggerOrder: bool = !is_equal(&triggerPrice, &Value::Null);
        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());
            self.triggerOrders = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut cachedOrders: Value = ternary(is_true(&isTriggerOrder), self.triggerOrders.clone(), self.orders.clone());
        let mut orders: Value = self.safe_value(cachedOrders.hashmap(), symbol.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut order: Value = self.safe_value(orders.clone(), orderId.clone(), &[]);
        if !is_equal(&order, &Value::Null) {
            if is_equal(&get_value(&order, &Value::Str("status".to_string())), &Value::Str("closed".to_string())) {
                add_element_to_object(&mut parsed, &Value::Str("status".to_string()), Value::Str("closed".to_string()));
            }
            // carry the accumulated fill state forward, the raw feed only
            // carries the match prices on the match messages, and safeOrder
            // derives cost from the order price otherwise, which is wrong for
            // orders filled at better prices, so the accumulated values win on
            // the non match messages, see https://github.com/ccxt/ccxt/issues/19083
            if !is_equal(&get_value(&order, &Value::Str("average".to_string())), &Value::Null) {
                add_element_to_object(&mut parsed, &Value::Str("average".to_string()), get_value(&order, &Value::Str("average".to_string())));
                add_element_to_object(&mut parsed, &Value::Str("cost".to_string()), get_value(&order, &Value::Str("cost".to_string())));
            }
            if is_equal(&get_value(&parsed, &Value::Str("filled".to_string())), &Value::Null) {
                add_element_to_object(&mut parsed, &Value::Str("filled".to_string()), get_value(&order, &Value::Str("filled".to_string())));
            }
        }
        // accumulate the average fill price and cost from the match messages,
        // which carry matchPrice and matchSize, the terminal filled message
        // does not repeat them, see https://github.com/ccxt/ccxt/issues/19083
        let mut rawType: Value = self.safe_string_k(data.clone(), "type", &[]);
        let mut matchPrice: Value = self.safe_string_k(data.clone(), "matchPrice", &[]);
        let mut matchSize: Value = self.safe_string_k(data.clone(), "matchSize", &[]);
        if is_true(&(is_equal(&rawType, &Value::Str("match".to_string())))) && is_true(&(!is_equal(&matchPrice, &Value::Null))) && is_true(&(!is_equal(&matchSize, &Value::Null))) {
            let mut matchCost: Value = crate::precise::Precise::stringMul(&matchPrice, &matchSize);
            let mut previousCost: Value = ternary(is_true(&(is_equal(&order, &Value::Null))), Value::Str("0".to_string()), self.number_to_string(self.safe_number_k(order.clone(), "cost", &[Value::Int(0)])));
            let mut costString: Value = crate::precise::Precise::stringAdd(&previousCost, &matchCost);
            add_element_to_object(&mut parsed, &Value::Str("cost".to_string()), self.parse_number(costString.clone(), &[]));
            let mut filledString: Value = self.number_to_string(get_value(&parsed, &Value::Str("filled".to_string())));
            if is_true(&(!is_equal(&filledString, &Value::Null))) && is_true(&(crate::precise::Precise::stringGt(&filledString, &Value::Str("0".to_string())))) {
                add_element_to_object(&mut parsed, &Value::Str("average".to_string()), self.parse_number(crate::precise::Precise::stringDiv(&costString, &filledString), &[]));
            }
        }
        cachedOrders.append(parsed.clone());
        let mut messageHash: Value = Value::Str("orders".to_string());
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        let mut suffix: Value = self.get_orders_message_hash_suffix(topic.clone());
        let mut typeSpecificMessageHash: Value = add(&messageHash, &suffix);
        client.resolve(&[cachedOrders.clone(), typeSpecificMessageHash.clone()]);
        let mut symbolSpecificMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
        client.resolve(&[cachedOrders.clone(), symbolSpecificMessageHash.clone()]);
}

    pub fn handle_uta_order(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "orderAll.UNIFIED",
        //         "P": "1774794309609274499",
        //         "d": {
        //             "tT": "FUTURES",
        //             "oi": "427737326394129559",
        //             "ci": "",
        //             "os": 5,
        //             "eT": "CANCEL",
        //             "s": "DOGEUSDTM",
        //             "S": "SELL",
        //             "oT": "MARKET",
        //             "lR": "",
        //             "oS": "USER",
        //             "p": "",
        //             "ti": "",
        //             "q": "1",
        //             "qU": "UNIT",
        //             "fS": "0",
        //             "lS": "0",
        //             "ls": "0",
        //             "aP": "0",
        //             "f": "0",
        //             "fC": "USDT",
        //             "t": "0",
        //             "cR": "USER",
        //             "cS": "1",
        //             "rS": "0",
        //             "tD": "DOWN",
        //             "tP": "0.01",
        //             "tPT": "MP",
        //             "pP": "",
        //             "pPT": "",
        //             "lP": "",
        //             "lPT": "",
        //             "toi": "427737326102335488",
        //             "stp": "",
        //             "rO": true,
        //             "tIF": "GTC",
        //             "pO": false,
        //             "O": "1774793727626043888",
        //             "U": 1774794309608959200
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut parsed: Value = self.parse_ws_uta_order(data.clone(), &[]);
        let mut symbol: Value = self.safe_string_k(parsed.clone(), "symbol", &[]);
        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 cachedOrders: Value = self.orders.clone();
        cachedOrders.append(parsed.clone());
        let mut messageHash: Value = Value::Str("uta:orders".to_string());
        let mut symbolSpecificMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
        client.resolve(&[cachedOrders.clone(), symbolSpecificMessageHash.clone()]);
        client.resolve(&[cachedOrders.clone(), messageHash.clone()]);
}

/*
 * @method
 * @name kucoin#watchMyTrades
 * @description watches information on multiple trades made by the user on spot
 * @see https://www.kucoin.com/docs-new/3470074w0
 * @see https://www.kucoin.com/docs-new/3470090w0
 * @see https://www.kucoin.com/docs-new/3470264w0
 * @param {string} symbol unified market symbol of the market trades were made in
 * @param {int} [since] the earliest time in ms to fetch trades for
 * @param {int} [limit] the maximum number of trade structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta)
 * @param {string} [params.method] *classic (non-uta) account only* '/spotMarket/tradeOrders' or '/spot/tradeFills' or '/contractMarket/tradeOrders', default is '/spotMarket/tradeOrders'
 * @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;
        }
        let mut messageHash: Value = Value::Str("myTrades".to_string());
        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()));
            messageHash = add(&add(&messageHash, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("symbol".to_string())));
        }
        let mut marketType: Value = Value::Null;
        { let __destr_tmp = self.handle_market_type_and_params(Value::Str("watchMyTrades".to_string()), &[market.clone(), params.clone()]); marketType = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut isFuturesMethod: Value = Value::Bool(is_true(&(!is_equal(&marketType, &Value::Str("spot".to_string())))) && is_true(&(!is_equal(&marketType, &Value::Str("margin".to_string())))));
        let mut uta: Value = self.is_uta_enabled(&[]).await;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchMyTrades".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut trades: Value = Value::Null;
        if is_true(&uta) {
            params = self.extend(params.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("tradeType".to_string(), Value::Str("UNIFIED".to_string()));
                m
            })]);
            messageHash = add(&Value::Str("uta:".to_string()), &messageHash);
            let mut channel: Value = Value::Str("execution.lite".to_string());
            trades = self.subscribe_private_uta(Value::List(vec![messageHash.clone()]), channel.clone(), channel.clone(), &[Value::Null, params.clone()]).await;
        }  else {
            let mut url: Value = self.negotiate(Value::Bool(true), &[isFuturesMethod.clone()]).await;
            let mut topic: Value = ternary(is_true(&isFuturesMethod), Value::Str("/contractMarket/tradeOrders".to_string()), Value::Str("/spotMarket/tradeOrders".to_string()));
            let mut optionName: Value = ternary(is_true(&isFuturesMethod), Value::Str("contractMethod".to_string()), Value::Str("spotMethod".to_string()));
            { let __destr_tmp = self.handle_option_and_params2(params.clone(), Value::Str("watchMyTrades".to_string()), optionName.clone(), Value::Str("method".to_string()), &[topic.clone()]); topic = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
            let mut request: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("privateChannel".to_string(), Value::Bool(true));
                m
            });
            if is_equal(&symbol, &Value::Null) {
                let mut suffix: Value = self.get_my_trades_message_hash_suffix(topic.clone());
                messageHash = add(&messageHash, &suffix);
            }
            let __ws_arg_3 = self.extend(request.clone(), &[params.clone()]);
            trades = self.subscribe(url.clone(), messageHash.clone(), topic.clone(), &[__ws_arg_3]).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
}

    pub fn get_my_trades_message_hash_suffix(&self, mut topic: Value) -> Value {
        let mut suffix: Value = Value::Str("-spot".to_string());
        if is_greater_than_or_equal(&get_index_of(&topic, &Value::Str("contractMarket".to_string())), &Value::Int(0)) {
            suffix = Value::Str("-contract".to_string());
        }
        return suffix;

    Value::Null
}

    pub fn handle_my_trade(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "type": "message",
        //         "topic": "/spotMarket/tradeOrders",
        //         "subject": "orderChange",
        //         "channelType": "private",
        //         "data": {
        //             "symbol": "KCS-USDT",
        //             "orderType": "limit",
        //             "side": "sell",
        //             "orderId": "5efab07953bdea00089965fa",
        //             "liquidity": "taker",
        //             "type": "match",
        //             "feeType": "takerFee",
        //             "orderTime": 1670329987026,
        //             "size": "0.1",
        //             "filledSize": "0.1",
        //             "price": "0.938",
        //             "matchPrice": "0.96738",
        //             "matchSize": "0.1",
        //             "tradeId": "5efab07a4ee4c7000a82d6d9",
        //             "clientOid": "1593487481000313",
        //             "remainSize": "0",
        //             "status": "match",
        //             "ts": 1670329987311000000
        //         }
        //     }
        //
        if is_equal(&self.myTrades, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            self.myTrades = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[]);
        let mut parsed: Value = self.parse_ws_trade(data.clone(), &[]);
        let mut myTrades: Value = self.myTrades.clone();
        myTrades.append(parsed.clone());
        let mut messageHash: Value = Value::Str("myTrades".to_string());
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        let mut suffix: Value = self.get_my_trades_message_hash_suffix(topic.clone());
        let mut typeSpecificMessageHash: Value = add(&messageHash, &suffix);
        client.resolve(&[self.myTrades.clone(), typeSpecificMessageHash.clone()]);
        let mut symbolSpecificMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &get_value(&parsed, &Value::Str("symbol".to_string())));
        client.resolve(&[self.myTrades.clone(), symbolSpecificMessageHash.clone()]);
}

    pub fn handle_uta_my_trade(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "execution.lite.UNIFIED",
        //         "P": "1774977429844510434",
        //         "d": {
        //             "E": "1774977429843000000",
        //             "S": "SELL",
        //             "p": "0.09211",
        //             "q": "10",
        //             "s": "DOGE-USDT",
        //             "lR": "TAKER",
        //             "oT": "MARKET",
        //             "oi": "428507829452754944",
        //             "ti": 20801647764195330
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut trade: Value = self.parse_ws_uta_trade(data.clone(), &[market.clone()]);
        let mut symbol: Value = get_value(&trade, &Value::Str("symbol".to_string()));
        if is_equal(&self.myTrades, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            self.myTrades = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut cache: Value = self.myTrades.clone();
        cache.append(trade.clone());
        let mut messageHash: Value = Value::Str("uta:myTrades".to_string());
        let mut symbolMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
        client.resolve(&[self.myTrades.clone(), messageHash.clone()]);
        client.resolve(&[cache.clone(), symbolMessageHash.clone()]);
}

    pub fn parse_ws_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        // /spotMarket/tradeOrders
        //
        //     {
        //         "symbol": "KCS-USDT",
        //         "orderType": "limit",
        //         "side": "sell",
        //         "orderId": "5efab07953bdea00089965fa",
        //         "liquidity": "taker",
        //         "type": "match",
        //         "feeType": "takerFee",
        //         "orderTime": 1670329987026,
        //         "size": "0.1",
        //         "filledSize": "0.1",
        //         "price": "0.938",
        //         "matchPrice": "0.96738",
        //         "matchSize": "0.1",
        //         "tradeId": "5efab07a4ee4c7000a82d6d9",
        //         "clientOid": "1593487481000313",
        //         "remainSize": "0",
        //         "status": "match",
        //         "ts": 1670329987311000000
        //     }
        //
        // /spot/tradeFills
        //
        //    {
        //        "fee": 0.00262148,
        //        "feeCurrency": "USDT",
        //        "feeRate": 0.001,
        //        "orderId": "62417436b29df8000183df2f",
        //        "orderType": "market",
        //        "price": 131.074,
        //        "side": "sell",
        //        "size": 0.02,
        //        "symbol": "LTC-USDT",
        //        "time": "1648456758734571745",
        //        "tradeId": "624174362e113d2f467b3043"
        //    }
        //
        let mut marketId: Value = self.safe_string_k(trade.clone(), "symbol", &[]);
        market = self.safe_market(&[marketId.clone(), market.clone(), Value::Str("-".to_string())]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut type_var: Value = self.safe_string_k(trade.clone(), "orderType", &[]);
        let mut side: Value = self.safe_string_k(trade.clone(), "side", &[]);
        let mut tradeId: Value = self.safe_string_k(trade.clone(), "tradeId", &[]);
        let mut price: Value = self.safe_string_k(trade.clone(), "matchPrice", &[]);
        let mut amount: Value = self.safe_string_k(trade.clone(), "matchSize", &[]);
        if is_equal(&price, &Value::Null) {
            // /spot/tradeFills
            price = self.safe_string_k(trade.clone(), "price", &[]);
            amount = self.safe_string_k(trade.clone(), "size", &[]);
        }
        let mut order: Value = self.safe_string_k(trade.clone(), "orderId", &[]);
        let mut timestamp: Value = self.safe_integer_product2(trade.clone(), Value::Str("ts".to_string()), Value::Str("time".to_string()), Value::Float(0.000001), &[]);
        let mut feeCurrency: Value = get_value(&market, &Value::Str("quote".to_string()));
        let mut feeRate: Value = self.safe_string_k(trade.clone(), "feeRate", &[]);
        let mut feeCost: Value = self.safe_string_k(trade.clone(), "fee", &[]);
        return self.safe_trade(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), trade.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("id".to_string(), tradeId.clone());
        m.insert("order".to_string(), order.clone());
        m.insert("type".to_string(), type_var.clone());
        m.insert("takerOrMaker".to_string(), self.safe_string_k(trade.clone(), "liquidity", &[]));
        m.insert("side".to_string(), side.clone());
        m.insert("price".to_string(), price.clone());
        m.insert("amount".to_string(), amount.clone());
        m.insert("cost".to_string(), Value::Null);
        m.insert("fee".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("cost".to_string(), feeCost.clone());
        m.insert("rate".to_string(), feeRate.clone());
        m.insert("currency".to_string(), feeCurrency.clone());
    m
}));
    m
}), &[market.clone()]);

    Value::Null
}

/*
 * @method
 * @name kucoin#watchBalance
 * @description watch balance and get the amount of funds available for trading or funds locked in orders
 * @see https://www.kucoin.com/docs-new/3470075w0 // spot balance
 * @see https://www.kucoin.com/docs-new/3470092w0 // contract balance
 * @see https://www.kucoin.com/docs-new/3470231w0 // uta balance
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta)
 * @param {string} [params.type] *classic (non-uta) account only* 'spot' or 'swap' (default is 'spot')
 * @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;
        }
        let mut uta: Value = self.is_uta_enabled(&[]).await;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut defaultType: Value = ternary(is_true(&uta), Value::Str("unified".to_string()), Value::Str("spot".to_string()));
        let mut type_var: Value = defaultType.clone();
        if !is_true(&uta) {
            defaultType = self.safe_string_k(self.options.clone(), "defaultType", &[defaultType.clone()]);
            type_var = self.safe_string_k(params.clone(), "type", &[defaultType.clone()]);
        }
        params = self.omit(params.clone(), Value::Str("type".to_string()), &[]);
        let mut accountsByType: Value = self.safe_dict_k(self.options.clone(), "accountsByType", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut uniformType: Value = self.safe_string(accountsByType.clone(), type_var.clone(), &[type_var.clone()]);
        let mut isClassicFuturesMethod: Value = Value::Bool(is_equal(&uniformType, &Value::Str("contract".to_string())));
        let mut subscriptionHash: Value = ternary(is_true(&isClassicFuturesMethod), Value::Str("/contractAccount/wallet".to_string()), Value::Str("/account/balance".to_string()));
        let mut url: Value = Value::Null;
        if is_true(&uta) {
            url = self.get_uta_url().await;
            subscriptionHash = uniformType.clone();
        }  else {
            url = self.negotiate(Value::Bool(true), &[isClassicFuturesMethod.clone()]).await;
        }
        let mut client: Value = self.client(&[url.clone()]);
        self.set_balance_cache(client.clone(), uniformType.clone());
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchBalance", &[]);
        let mut fetchBalanceSnapshot: Value = self.safe_bool_k(options.clone(), "fetchBalanceSnapshot", &[Value::Bool(false)]);
        let mut awaitBalanceSnapshot: Value = self.safe_bool_k(options.clone(), "awaitBalanceSnapshot", &[Value::Bool(true)]);
        if is_true(&(is_equal(&fetchBalanceSnapshot, &Value::Bool(true)))) && is_true(&(is_equal(&awaitBalanceSnapshot, &Value::Bool(true)))) {
            crate::exchange_stubs::ws_await_flight(&client.future(&[add(&uniformType, &Value::Str(":fetchBalanceSnapshot".to_string()))])).await;
        }
        let mut messageHash: Value = add(&uniformType, &Value::Str(":balance".to_string()));
        if is_true(&uta) {
            let mut extendedParams: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("accountType".to_string(), uniformType.clone());
                m
            });
            let mut channel: Value = Value::Str("balance".to_string());
            let __ws_arg_4 = self.extend(extendedParams.clone(), &[params.clone()]);
            return self.subscribe_private_uta(Value::List(vec![messageHash.clone()]), subscriptionHash.clone(), channel.clone(), &[Value::Null, __ws_arg_4]).await;
        }  else {
            let mut requestId: Value = to_string_val(&self.request_id());
            let mut request: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), requestId.clone());
                    m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                    m.insert("topic".to_string(), subscriptionHash.clone());
                    m.insert("response".to_string(), Value::Bool(true));
                    m.insert("privateChannel".to_string(), Value::Bool(true));
                m
            });
            let mut message: Value = self.extend(request.clone(), &[params.clone()]);
            if !is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &subscriptionHash)))) {
                add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &requestId, subscriptionHash.clone());
            }
            return self.watch(url.clone(), messageHash.clone(), &[message.clone(), uniformType.clone()]).await;
        }

    Value::Null
}

    pub fn set_balance_cache(&mut self, mut client: Value, mut type_var: Value) {
        if is_true(&(Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &type_var)))) && is_true(&(Value::Bool(in_op(&self.balance, &type_var)))) {
            return;
        }
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchBalance", &[]);
        let mut fetchBalanceSnapshot: Value = self.safe_bool_k(options.clone(), "fetchBalanceSnapshot", &[Value::Bool(false)]);
        if is_equal(&fetchBalanceSnapshot, &Value::Bool(true)) {
            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()]);
            }
        }  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) -> Value {
        let mut uta: Value = Value::Bool(is_equal(&type_var, &Value::Str("unified".to_string())));
        let mut params: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), type_var.clone());
                m.insert("uta".to_string(), uta.clone());
            m
        });
        let mut response: Value = self.fetch_balance(&[params.clone()]).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
}

    pub fn handle_balance(&mut self, mut client: Value, mut message: Value) {
        //
        // {
        //     "id":"6217a451294b030001e3a26a",
        //     "type":"message",
        //     "topic":"/account/balance",
        //     "userId":"6217707c52f97f00012a67db",
        //     "channelType":"private",
        //     "subject":"account.balance",
        //     "data":{
        //        "accountId":"62177fe67810720001db2f18",
        //        "available":"89",
        //        "availableChange":"-30",
        //        "currency":"USDT",
        //        "hold":"0",
        //        "holdChange":"0",
        //        "relationContext":{
        //        },
        //        "relationEvent":"main.transfer",
        //        "relationEventId":"6217a451294b030001e3a26a",
        //        "time":"1645716561816",
        //        "total":"89"
        //     }
        //
        // futures
        //    {
        //        "id": "6375553193027a0001f6566f",
        //        "type": "message",
        //        "topic": "/contractAccount/wallet",
        //        "userId": "613a896885d8660006151f01",
        //        "channelType": "private",
        //        "subject": "availableBalance.change",
        //        "data": {
        //            "currency": "USDT",
        //            "holdBalance": "0.0000000000",
        //            "availableBalance": "14.0350281903",
        //            "timestamp": "1668633905657"
        //        }
        //    }
        //
        //     {
        //         "topic": "/contractAccount/wallet",
        //         "type": "message",
        //         "subject": "walletBalance.change",
        //         "id": "699f586d4416a80001df3804",
        //         "userId": "64f99aced178640001306e6e",
        //         "channelType": "private",
        //         "data": {
        //             "crossPosMargin": "0",
        //             "isolatedOrderMargin": "0",
        //             "holdBalance": "0",
        //             "equity": "49.50050236",
        //             "version": "2874",
        //             "availableBalance": "28.67180236",
        //             "isolatedPosMargin": "20.7308",
        //             "maxWithdrawAmount": "28.67180236",
        //             "walletBalance": "49.40260236",
        //             "isolatedFundingFeeMargin": "0",
        //             "crossUnPnl": "0",
        //             "totalCrossMargin": "28.67180236",
        //             "currency": "USDT",
        //             "isolatedUnPnl": "0.0979",
        //             "availableMargin": "28.67180236",
        //             "crossOrderMargin": "0",
        //             "timestamp": "1772050541214"
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut currencyId: Value = self.safe_string_k(data.clone(), "currency", &[]);
        let mut relationEvent: Value = self.safe_string_k(data.clone(), "relationEvent", &[]);
        let mut requestAccountType: Value = Value::Null;
        if !is_equal(&relationEvent, &Value::Null) {
            let mut relationEventParts: Value = split(&relationEvent, &Value::Str(".".to_string()));
            requestAccountType = self.safe_string(relationEventParts.clone(), Value::Int(0), &[]);
        }
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        if is_equal(&topic, &Value::Str("/contractAccount/wallet".to_string())) {
            requestAccountType = Value::Str("contract".to_string());
        }
        let mut accountsByType: Value = self.safe_dict_k(self.options.clone(), "accountsByType", &[]);
        let mut uniformType: Value = self.safe_string(accountsByType.clone(), requestAccountType.clone(), &[Value::Str("trade".to_string())]);
        if !is_true(&(Value::Bool(in_op(&self.balance, &uniformType)))) {
            add_element_to_object(&mut self.balance, &uniformType, 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) }, &uniformType), &Value::Str("info".to_string()), data.clone());
        let mut timestamp: Value = self.safe_integer2(data.clone(), Value::Str("time".to_string()), Value::Str("timestamp".to_string()), &[]);
        add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.balance) }, &uniformType), &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) }, &uniformType), &Value::Str("datetime".to_string()), __be_tmp); };
        let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
        let mut account: Value = self.account();
        let mut used: Value = self.safe_string2(data.clone(), Value::Str("hold".to_string()), Value::Str("holdBalance".to_string()), &[]);
        let mut isolatedPosMargin: Value = self.omit_zero(self.safe_string_k(data.clone(), "isolatedPosMargin", &[]));
        if !is_equal(&isolatedPosMargin, &Value::Null) {
            used = crate::precise::Precise::stringAdd(&used, &isolatedPosMargin);
        }
        add_element_to_object(&mut account, &Value::Str("free".to_string()), self.safe_string2(data.clone(), Value::Str("available".to_string()), Value::Str("availableBalance".to_string()), &[]));
        add_element_to_object(&mut account, &Value::Str("used".to_string()), used.clone());
        add_element_to_object(&mut account, &Value::Str("total".to_string()), self.safe_string_k(data.clone(), "total", &[]));
        if is_true(&(!is_equal(&uniformType, &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) }, &uniformType), &code, account.clone());
        }
        { let __be_tmp = self.safe_balance(get_value(&self.balance, &uniformType)); add_element_to_object(&mut self.balance, &uniformType, __be_tmp); };
        let mut messageHash: Value = add(&uniformType, &Value::Str(":balance".to_string()));
        client.resolve(&[get_value(&self.balance, &uniformType), messageHash.clone()]);
}

    pub fn handle_uta_balance(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "balance.UNIFIED",
        //         "P": "1774982552507478380",
        //         "d": {
        //             "c": "USDT",
        //             "e": "100.0030439507",
        //             "b": "100.0030439507",
        //             "a": "89.9930439507",
        //             "h": "10.0100000000",
        //             "U": "1774982552505000000",
        //             "l": "0.0000000000"
        //         }
        //     }
        //
        let mut type_var: Value = Value::Str("unified".to_string());
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut currencyId: Value = self.safe_string_k(data.clone(), "c", &[]);
        let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
        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());
        let mut timestamp: Value = self.safe_integer_product(data.clone(), Value::Str("U".to_string()), Value::Float(0.000001), &[]);
        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 account: Value = self.account();
        add_element_to_object(&mut account, &Value::Str("free".to_string()), self.safe_string_k(data.clone(), "a", &[]));
        add_element_to_object(&mut account, &Value::Str("used".to_string()), self.safe_string_k(data.clone(), "h", &[]));
        add_element_to_object(&mut account, &Value::Str("total".to_string()), self.safe_string_k(data.clone(), "b", &[]));
        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); };
        let mut messageHash: Value = add(&type_var, &Value::Str(":balance".to_string()));
        client.resolve(&[get_value(&self.balance, &type_var), messageHash.clone()]);
}

/*
 * @method
 * @name kucoin#watchPosition
 * @description watch open positions for a specific symbol
 * @see https://www.kucoin.com/docs-new/3470093w0
 * @param {string|undefined} symbol unified market symbol
 * @param {object} params extra parameters specific to the exchange API endpoint
 * @returns {object} a [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
 */
    pub async fn watch_position(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = 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(&symbol, &Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(add(&self.id, &Value::Str(" watchPosition() requires a symbol argument".to_string()))));
        }
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut url: Value = self.negotiate(Value::Bool(true), &[]).await;
        let mut market: Value = self.market(symbol.clone());
        let mut topic: Value = add(&Value::Str("/contract/position:".to_string()), &get_value(&market, &Value::Str("id".to_string())));
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("privateChannel".to_string(), Value::Bool(true));
            m
        });
        let mut messageHash: Value = add(&Value::Str("position:".to_string()), &get_value(&market, &Value::Str("symbol".to_string())));
        let mut client: Value = self.client(&[url.clone()]);
        self.set_position_cache(client.clone(), symbol.clone());
        let mut fetchPositionSnapshot: Value = self.handle_option(Value::Str("watchPosition".to_string()), Value::Str("fetchPositionSnapshot".to_string()), &[Value::Bool(true)]);
        let mut awaitPositionSnapshot: Value = self.handle_option(Value::Str("watchPosition".to_string()), Value::Str("awaitPositionSnapshot".to_string()), &[Value::Bool(true)]);
        let mut currentPosition: Value = self.get_current_position(symbol.clone());
        if is_true(&(is_equal(&fetchPositionSnapshot, &Value::Bool(true)))) && is_true(&(is_equal(&awaitPositionSnapshot, &Value::Bool(true)))) && is_true(&(is_equal(&currentPosition, &Value::Null))) {
            let mut snapshot: Value = crate::exchange_stubs::ws_await_flight(&client.future(&[add(&Value::Str("fetchPositionSnapshot:".to_string()), &symbol)])).await;
            return snapshot;
        }
        let __ws_arg_6 = self.extend(request.clone(), &[params.clone()]);
        return self.subscribe(url.clone(), messageHash.clone(), topic.clone(), &[__ws_arg_6]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#watchPositions
 * @see https://www.kucoin.com/docs-new/3470233w0
 * @description watch all open positions
 * @param {string[]} [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 positions to retrieve
 * @param {object} params extra parameters specific to the exchange API endpoint
 * @param {boolean} [params.uta] set to true for the unified trading account (uta)
 * @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;
        }
        let mut uta: Value = self.is_uta_enabled(&[]).await;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".to_string()), Value::Str("uta".to_string()), &[uta.clone()]); uta = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
        let mut tradeType: Value = ternary(is_true(&uta), Value::Str("UNIFIED".to_string()), Value::Str("TRADE".to_string()));
        let mut messageHash: Value = Value::Str("positions".to_string());
        let mut messageHashes: Value = Value::List(vec![]);
        symbols = self.market_symbols(&[symbols.clone()]);
        if is_equal(&symbols, &Value::Null) {
            append_to_array(&mut messageHashes, messageHash.clone());
        }  else {
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_464: bool = true;
                while { if !__for_first_464 { i = add(&i, &Value::Int(1)); } __for_first_464 = false; is_less_than(&i, &get_array_length(&symbols)) } {
                let mut symbol: Value = get_value(&symbols, &i);
                let mut symbol: Value = get_value(&symbols, &i);
                append_to_array(&mut messageHashes, add(&add(&messageHash, &Value::Str(":".to_string())), &symbol));
            }
            }
        }
        let mut url: Value = self.get_uta_url().await;
        let mut client: Value = self.client(&[url.clone()]);
        self.set_positions_cache(client.clone(), uta.clone());
        let mut fetchPositionSnapshot: Value = self.handle_option(Value::Str("watchPositions".to_string()), Value::Str("fetchPositionsSnapshot".to_string()), &[Value::Bool(true)]);
        let mut awaitPositionSnapshot: Value = self.handle_option(Value::Str("watchPositions".to_string()), Value::Str("awaitPositionsSnapshot".to_string()), &[Value::Bool(true)]);
        let mut cache: Value = self.positions.clone();
        if is_true(&(is_equal(&fetchPositionSnapshot, &Value::Bool(true)))) && is_true(&(is_equal(&awaitPositionSnapshot, &Value::Bool(true)))) && is_true(&(is_equal(&cache, &Value::Null))) {
            let mut snapshot: Value = crate::exchange_stubs::ws_await_flight(&client.future(&[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 channel: Value = Value::Str("positionAll".to_string());
        params = self.extend(params.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("tradeType".to_string(), tradeType.clone());
            m
        })]);
        let mut newPositions: Value = self.subscribe_private_uta(messageHashes.clone(), channel.clone(), channel.clone(), &[Value::Null, params.clone()]).await;
        if is_true(&self.newUpdates) {
            return newPositions;
        }
        return self.filter_by_symbols_since_limit(cache.clone(), &[symbols.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

    pub fn get_current_position(&self, mut symbol: Value) -> Value {
        if is_equal(&self.positions, &Value::Null) {
            return Value::Null;
        }
        let mut cache: Value = self.positions.hashmap();
        let mut symbolCache: Value = self.safe_value(cache.clone(), symbol.clone(), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut values: Value = object_values(&symbolCache);
        return self.safe_value(values.clone(), Value::Int(0), &[]);

    Value::Null
}

    pub fn set_positions_cache(&mut self, mut client: Value, mut uta: Value) {
        if !is_true(&(self.is_empty(self.positions.clone()))) {
            return;
        }
        let mut fetchPositionsSnapshot: Value = self.handle_option(Value::Str("watchPositions".to_string()), Value::Str("fetchPositionsSnapshot".to_string()), &[Value::Bool(false)]);
        if is_equal(&fetchPositionsSnapshot, &Value::Bool(true)) {
            let mut messageHash: Value = 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(), uta.clone()]);
            }
        }  else {
            self.positions = ArrayCacheBySymbolById::new(Value::Null);
        }
}

    pub async fn load_positions_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut uta: Value) -> Value {
        let mut positions: Value = self.fetch_positions(&[Value::Null, Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("uta".to_string(), uta.clone());
            m
        })]).await;
        self.positions = ArrayCacheBySymbolById::new(Value::Null);
        let mut cache: Value = self.positions.clone();
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_465: bool = true;
            while { if !__for_first_465 { i = add(&i, &Value::Int(1)); } __for_first_465 = 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("positions".to_string())]);
        }

    Value::Null
}

    pub fn set_position_cache(&mut self, mut client: Value, mut symbol: Value) {
        let mut fetchPositionSnapshot: Value = self.handle_option(Value::Str("watchPosition".to_string()), Value::Str("fetchPositionSnapshot".to_string()), &[Value::Bool(false)]);
        if is_equal(&fetchPositionSnapshot, &Value::Bool(true)) {
            let mut messageHash: Value = add(&Value::Str("fetchPositionSnapshot:".to_string()), &symbol);
            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_position_snapshot".to_string()).clone(), client.clone(), messageHash.clone(), symbol.clone()]);
            }
        }
}

    pub async fn load_position_snapshot(&mut self, mut client: Value, mut messageHash: Value, mut symbol: Value) -> Value {
        let mut position: Value = self.fetch_position(symbol.clone(), &[]).await;
        self.positions = ArrayCacheBySymbolById::new(Value::Null);
        let mut cache: Value = self.positions.clone();
        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(&[position.clone(), add(&Value::Str("position:".to_string()), &symbol)]);
        }

    Value::Null
}

    pub fn handle_position(&self, mut client: Value, mut message: Value) {
        //
        // Position Changes Caused Operations
        //    {
        //        "type": "message",
        //        "userId": "5c32d69203aa676ce4b543c7", // Deprecated, will detele later
        //        "channelType": "private",
        //        "topic": "/contract/position:XBTUSDM",
        //        "subject": "position.change",
        //        "data": {
        //            "realisedGrossPnl": 0E-8, //Accumulated realised profit and loss
        //            "symbol": "XBTUSDM", //Symbol
        //            "crossMode": false, //Cross mode or not
        //            "liquidationPrice": 1000000.0, //Liquidation price
        //            "posLoss": 0E-8, //Manually added margin amount
        //            "avgEntryPrice": 7508.22, //Average entry price
        //            "unrealisedPnl": -0.00014735, //Unrealised profit and loss
        //            "markPrice": 7947.83, //Mark price
        //            "posMargin": 0.00266779, //Position margin
        //            "autoDeposit": false, //Auto deposit margin or not
        //            "riskLimit": 100000, //Risk limit
        //            "unrealisedCost": 0.00266375, //Unrealised value
        //            "posComm": 0.00000392, //Bankruptcy cost
        //            "posMaint": 0.00001724, //Maintenance margin
        //            "posCost": 0.00266375, //Position value
        //            "maintMarginReq": 0.005, //Maintenance margin rate
        //            "bankruptPrice": 1000000.0, //Bankruptcy price
        //            "realisedCost": 0.00000271, //Currently accumulated realised position value
        //            "markValue": 0.00251640, //Mark value
        //            "posInit": 0.00266375, //Position margin
        //            "realisedPnl": -0.00000253, //Realised profit and losts
        //            "maintMargin": 0.00252044, //Position margin
        //            "realLeverage": 1.06, //Leverage of the order
        //            "changeReason": "positionChange", //changeReason:marginChange、positionChange、liquidation、autoAppendMarginStatusChange、adl
        //            "currentCost": 0.00266375, //Current position value
        //            "openingTimestamp": 1558433191000, //Open time
        //            "currentQty": -20, //Current position
        //            "delevPercentage": 0.52, //ADL ranking percentile
        //            "currentComm": 0.00000271, //Current commission
        //            "realisedGrossCost": 0E-8, //Accumulated reliased gross profit value
        //            "isOpen": true, //Opened position or not
        //            "posCross": 1.2E-7, //Manually added margin
        //            "currentTimestamp": 1558506060394, //Current timestamp
        //            "unrealisedRoePcnt": -0.0553, //Rate of return on investment
        //            "unrealisedPnlPcnt": -0.0553, //Position profit and loss ratio
        //            "settleCurrency": "XBT" //Currency used to clear and settle the trades
        //        }
        //    }
        // Position Changes Caused by Mark Price
        //    {
        //        "userId": "5cd3f1a7b7ebc19ae9558591", // Deprecated, will detele later
        //        "topic": "/contract/position:XBTUSDM",
        //        "subject": "position.change",
        //          "data": {
        //              "markPrice": 7947.83,                   //Mark price
        //              "markValue": 0.00251640,                 //Mark value
        //              "maintMargin": 0.00252044,              //Position margin
        //              "realLeverage": 10.06,                   //Leverage of the order
        //              "unrealisedPnl": -0.00014735,           //Unrealised profit and lost
        //              "unrealisedRoePcnt": -0.0553,           //Rate of return on investment
        //              "unrealisedPnlPcnt": -0.0553,            //Position profit and loss ratio
        //              "delevPercentage": 0.52,             //ADL ranking percentile
        //              "currentTimestamp": 1558087175068,      //Current timestamp
        //              "settleCurrency": "XBT"                 //Currency used to clear and settle the trades
        //          }
        //    }
        //  Funding Settlement
        //    {
        //        "userId": "xbc453tg732eba53a88ggyt8c", // Deprecated, will detele later
        //        "topic": "/contract/position:XBTUSDM",
        //        "subject": "position.settlement",
        //        "data": {
        //            "fundingTime": 1551770400000,          //Funding time
        //            "qty": 100,                            //Position siz
        //            "markPrice": 3610.85,                 //Settlement price
        //            "fundingRate": -0.002966,             //Funding rate
        //            "fundingFee": -296,                   //Funding fees
        //            "ts": 1547697294838004923,             //Current time (nanosecond)
        //            "settleCurrency": "XBT"                //Currency used to clear and settle the trades
        //        }
        //    }
        // Adjustmet result of risk limit level
        //     {
        //         "userId": "xbc453tg732eba53a88ggyt8c",
        //         "topic": "/contract/position:ADAUSDTM",
        //         "subject": "position.adjustRiskLimit",
        //         "data": {
        //           "success": true, // Successful or not
        //           "riskLimitLevel": 1, // Current risk limit level
        //           "msg": "" // Failure reason
        //         }
        //     }
        //
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[Value::Str("".to_string())]);
        let mut parts: Value = split(&topic, &Value::Str(":".to_string()));
        let mut marketId: Value = self.safe_string(parts.clone(), Value::Int(1), &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("".to_string())]);
        let mut cache: Value = self.positions.clone();
        let mut currentPosition: Value = self.get_current_position(symbol.clone());
        let mut messageHash: Value = add(&Value::Str("position:".to_string()), &symbol);
        let mut data: Value = self.safe_dict_k(message.clone(), "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut newPosition: Value = self.parse_position(data.clone(), &[]);
        let mut keys: Value = object_keys(&newPosition);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_466: bool = true;
            while { if !__for_first_466 { i = add(&i, &Value::Int(1)); } __for_first_466 = false; is_less_than(&i, &get_array_length(&keys)) } {
            let mut key: Value = get_value(&keys, &i);
            let mut key: Value = get_value(&keys, &i);
            if is_equal(&get_value(&newPosition, &key), &Value::Null) {
                remove(&mut newPosition, &key);
            }
        }
        }
        let mut position: Value = self.extend(currentPosition.clone(), &[newPosition.clone()]);
        cache.append(position.clone());
        client.resolve(&[position.clone(), messageHash.clone()]);
}

    pub fn handle_uta_position(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "positionAll.UNIFIED",
        //         "P": "1774805155993190995",
        //         "d": {
        //             "pi": "30000000000084845",
        //             "s": "DOGEUSDTM",
        //             "mM": "CROSS",
        //             "q": "3",
        //             "eP": "0.09038666666666666666",
        //             "pV": "27.021",
        //             "mP": "0.09007",
        //             "lP": "0.00001",
        //             "bP": "0.00001",
        //             "l": "4.5",
        //             "uPL": "-0.095",
        //             "rPL": "-0.01473705",
        //             "iM": "6.0046666666666666666",
        //             "mmr": "0.007",
        //             "mtM": "0.189147",
        //             "U": "1774805155988000000",
        //             "O": 1774793727585000000
        //         }
        //     }
        //
        if is_equal(&self.positions, &Value::Null) {
            self.positions = ArrayCacheBySymbolById::new(Value::Null);
        }
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        let mut cache: Value = self.positions.clone();
        let mut currentPosition: Value = self.get_current_position(symbol.clone());
        let mut newPosition: Value = self.parse_ws_uta_position(data.clone(), &[]);
        let mut keys: Value = object_keys(&newPosition);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_467: bool = true;
            while { if !__for_first_467 { i = add(&i, &Value::Int(1)); } __for_first_467 = false; is_less_than(&i, &get_array_length(&keys)) } {
            let mut key: Value = get_value(&keys, &i);
            let mut key: Value = get_value(&keys, &i);
            if is_equal(&get_value(&newPosition, &key), &Value::Null) {
                remove(&mut newPosition, &key);
            }
        }
        }
        let mut position: Value = self.extend(currentPosition.clone(), &[newPosition.clone()]);
        cache.append(position.clone());
        let mut messageHash: Value = Value::Str("positions".to_string());
        let mut symbolMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
        client.resolve(&[self.positions.clone(), messageHash.clone()]);
        client.resolve(&[self.positions.clone(), symbolMessageHash.clone()]);
}

    pub fn parse_ws_uta_position(&self, mut position: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "pi": "30000000000084845",
        //         "s": "DOGEUSDTM",
        //         "mM": "CROSS",
        //         "q": "3",
        //         "eP": "0.09038666666666666666",
        //         "pV": "27.021",
        //         "mP": "0.09007",
        //         "lP": "0.00001",
        //         "bP": "0.00001",
        //         "l": "4.5",
        //         "uPL": "-0.095",
        //         "rPL": "-0.01473705",
        //         "iM": "6.0046666666666666666",
        //         "mmr": "0.007",
        //         "mtM": "0.189147",
        //         "U": "1774805155988000000",
        //         "O": 1774793727585000000
        //     }
        //
        let mut marketId: Value = self.safe_string_k(position.clone(), "s", &[]);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut timestamp: Value = self.safe_integer_product(position.clone(), Value::Str("O".to_string()), Value::Float(0.000001), &[]);
        let mut amountString: Value = self.safe_string_k(position.clone(), "q", &[]);
        let mut size: Value = crate::precise::Precise::stringAbs(&amountString);
        let mut side: Value = ternary(is_true(&crate::precise::Precise::stringGt(&amountString, &Value::Str("0".to_string()))), Value::Str("long".to_string()), Value::Str("short".to_string()));
        return self.safe_position(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), position.clone());
        m.insert("id".to_string(), self.safe_string_k(position.clone(), "pi", &[]));
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("lastUpdateTimestamp".to_string(), self.safe_integer_product(position.clone(), Value::Str("U".to_string()), Value::Float(0.000001), &[]));
        m.insert("initialMargin".to_string(), self.safe_number_k(position.clone(), "iM", &[]));
        m.insert("initialMarginPercentage".to_string(), Value::Null);
        m.insert("maintenanceMargin".to_string(), self.safe_number_k(position.clone(), "mtM", &[]));
        m.insert("maintenanceMarginPercentage".to_string(), self.safe_number_k(position.clone(), "mmr", &[]));
        m.insert("entryPrice".to_string(), self.safe_number_k(position.clone(), "eP", &[]));
        m.insert("notional".to_string(), self.safe_number_k(position.clone(), "pV", &[]));
        m.insert("leverage".to_string(), self.safe_number_k(position.clone(), "l", &[]));
        m.insert("unrealizedPnl".to_string(), self.safe_number_k(position.clone(), "uPL", &[]));
        m.insert("contracts".to_string(), self.parse_number(size.clone(), &[]));
        m.insert("contractSize".to_string(), self.safe_number_k(market.clone(), "contractSize", &[]));
        m.insert("realizedPnl".to_string(), self.safe_number_k(position.clone(), "rPL", &[]));
        m.insert("marginRatio".to_string(), Value::Null);
        m.insert("liquidationPrice".to_string(), self.safe_number_k(position.clone(), "lP", &[]));
        m.insert("markPrice".to_string(), self.safe_number_k(position.clone(), "mP", &[]));
        m.insert("lastPrice".to_string(), Value::Null);
        m.insert("collateral".to_string(), Value::Null);
        m.insert("marginMode".to_string(), self.safe_string_lower(position.clone(), Value::Str("mM".to_string()), &[]));
        m.insert("side".to_string(), side.clone());
        m.insert("percentage".to_string(), Value::Null);
        m.insert("stopLossPrice".to_string(), Value::Null);
        m.insert("takeProfitPrice".to_string(), Value::Null);
    m
}));

    Value::Null
}

/*
 * @method
 * @name kucoin#watchFundingRate
 * @description watch the current funding rate
 * @see https://www.kucoin.com/docs-new/3470270w0
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/?id=funding-rate-structure}
 */
    pub async fn watch_funding_rate(&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;
        }
        symbol = self.safe_symbol(symbol.clone(), &[]);
        let mut channel: Value = Value::Str("funding-fee".to_string());
        let mut messageHash: Value = add(&Value::Str("fundingRate:".to_string()), &symbol);
        return self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchFundingRate
 * @description unWatches the current funding rate for a symbol
 * @see https://www.kucoin.com/docs-new/3470270w0
 * @param {string} symbol unified symbol of the market
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/?id=funding-rate-structure}
 */
    pub async fn un_watch_funding_rate(&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;
        }
        symbol = self.safe_symbol(symbol.clone(), &[]);
        let mut channel: Value = Value::Str("funding-fee".to_string());
        let mut subMessageHash: Value = add(&Value::Str("fundingRate:".to_string()), &symbol);
        let mut unSubMessageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m.insert("topic".to_string(), Value::Str("fundingRate".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                m.insert("messageHashes".to_string(), Value::List(vec![unSubMessageHash.clone()]));
            m
        });
        return self.subscribe_public_uta(unSubMessageHash.clone(), channel.clone(), symbol.clone(), &[params.clone(), subscription.clone()]).await;

    Value::Null
}

    pub fn handle_uta_funding_rate(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "T": "funding-fee",
        //         "P": "1782831961172694254",
        //         "d": {
        //             "s": "ETHUSDTM",
        //             "fr": "0.000035",
        //             "ft": 1782806400000,
        //             "nt": 1782835200000,
        //             "gl": 28800000,
        //             "fc": "0.00375",
        //             "ff": "-0.00375"
        //         }
        //     }
        //
        let mut data: Value = self.safe_dict_k(message.clone(), "d", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut fundingRate: Value = self.parse_ws_funding_rate(data.clone(), &[]);
        let mut symbol: Value = get_value(&fundingRate, &Value::Str("symbol".to_string()));
        if !is_equal(&symbol, &Value::Null) {
            add_element_to_object(&mut self.fundingRates, &symbol, fundingRate.clone());
        }
        let mut messageHash: Value = add(&Value::Str("fundingRate:".to_string()), &symbol);
        client.resolve(&[fundingRate.clone(), messageHash.clone()]);
}

    pub fn parse_ws_funding_rate(&self, mut data: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "s": "ETHUSDTM",
        //         "fr": "0.000035",
        //         "ft": 1782806400000,
        //         "nt": 1782835200000,
        //         "gl": 28800000,
        //         "fc": "0.00375",
        //         "ff": "-0.00375"
        //     }
        //
        let mut fundingTimestamp: Value = self.safe_integer_k(data.clone(), "ft", &[]);
        let mut nextFundingTimestamp: Value = self.safe_integer_k(data.clone(), "nt", &[]);
        let mut marketId: Value = self.safe_string_k(data.clone(), "s", &[]);
        let mut granularity: Value = self.safe_string_k(data.clone(), "gl", &[]);
        return Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), data.clone());
        m.insert("symbol".to_string(), self.safe_symbol(marketId.clone(), &[market.clone(), Value::Null, Value::Str("contract".to_string())]));
        m.insert("markPrice".to_string(), Value::Null);
        m.insert("indexPrice".to_string(), Value::Null);
        m.insert("interestRate".to_string(), Value::Null);
        m.insert("estimatedSettlePrice".to_string(), Value::Null);
        m.insert("timestamp".to_string(), Value::Null);
        m.insert("datetime".to_string(), Value::Null);
        m.insert("fundingRate".to_string(), self.safe_number_k(data.clone(), "fr", &[]));
        m.insert("fundingTimestamp".to_string(), fundingTimestamp.clone());
        m.insert("fundingDatetime".to_string(), self.iso8601(fundingTimestamp.clone()));
        m.insert("nextFundingRate".to_string(), Value::Null);
        m.insert("nextFundingTimestamp".to_string(), nextFundingTimestamp.clone());
        m.insert("nextFundingDatetime".to_string(), self.iso8601(nextFundingTimestamp.clone()));
        m.insert("previousFundingRate".to_string(), Value::Null);
        m.insert("previousFundingTimestamp".to_string(), Value::Null);
        m.insert("previousFundingDatetime".to_string(), Value::Null);
        m.insert("interval".to_string(), self.parent.parse_funding_interval(granularity.clone()));
    m
});

    Value::Null
}

/*
 * @method
 * @name kucoin#watchMarkPrice
 * @description watches a mark price for a specific market
 * @see https://www.kucoin.com/docs-new/3470272w0
 * @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_mark_price(&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;
        }
        symbol = self.safe_symbol(symbol.clone(), &[]);
        let mut channel: Value = Value::Str("mark-price".to_string());
        let mut messageHash: Value = add(&Value::Str("uta:ticker:".to_string()), &symbol);
        return self.subscribe_public_uta(messageHash.clone(), channel.clone(), symbol.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name kucoin#unWatchMarkPrice
 * @description unWatches a mark price for a specific market
 * @see https://www.kucoin.com/docs-new/3470272w0
 * @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_mark_price(&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;
        }
        symbol = self.safe_symbol(symbol.clone(), &[]);
        let mut channel: Value = Value::Str("mark-price".to_string());
        let mut subMessageHash: Value = add(&Value::Str("uta:ticker:".to_string()), &symbol);
        let mut unSubMessageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
                m.insert("topic".to_string(), Value::Str("ticker".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                m.insert("messageHashes".to_string(), Value::List(vec![unSubMessageHash.clone()]));
            m
        });
        return self.subscribe_public_uta(unSubMessageHash.clone(), channel.clone(), symbol.clone(), &[params.clone(), subscription.clone()]).await;

    Value::Null
}

    pub fn handle_subject(&mut self, mut client: Value, mut message: Value) {
        //
        //     {
        //         "type":"message",
        //         "topic":"/market/level2:BTC-USDT",
        //         "subject":"trade.l2update",
        //         "data":{
        //             "sequenceStart":1545896669105,
        //             "sequenceEnd":1545896669106,
        //             "symbol":"BTC-USDT",
        //             "changes": {
        //                 "asks": [["6","1","1545896669105"]], // price, size, sequence
        //                 "bids": [["4","1","1545896669106"]]
        //             }
        //         }
        //     }
        //
        let mut topic: Value = self.safe_string_k(message.clone(), "topic", &[]);
        if is_equal(&topic, &Value::Str("/market/ticker:all".to_string())) {
            self.handle_ticker(client.clone(), message.clone());
            return;
        }
        let mut subject: Value = self.safe_string2(message.clone(), Value::Str("subject".to_string()), Value::Str("T".to_string()), &[]);
        let mut methods: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("level1".to_string(), Value::Str("handle_bid_ask".to_string()).clone());
                m.insert("level2".to_string(), Value::Str("handle_order_book".to_string()).clone());
                m.insert("trade.l2update".to_string(), Value::Str("handle_order_book".to_string()).clone());
                m.insert("trade.ticker".to_string(), Value::Str("handle_ticker".to_string()).clone());
                m.insert("trade.snapshot".to_string(), Value::Str("handle_ticker".to_string()).clone());
                m.insert("trade.l3match".to_string(), Value::Str("handle_trade".to_string()).clone());
                m.insert("trade.candles.update".to_string(), Value::Str("handle_ohlcv".to_string()).clone());
                m.insert("account.balance".to_string(), Value::Str("handle_balance".to_string()).clone());
                m.insert("orderChange".to_string(), Value::Str("handle_order".to_string()).clone());
                m.insert("stopOrder".to_string(), Value::Str("handle_order".to_string()).clone());
                m.insert("/spot/tradeFills".to_string(), Value::Str("handle_my_trade".to_string()).clone());
                m.insert("ticker".to_string(), Value::Str("handle_ticker".to_string()).clone());
                m.insert("tickerV2".to_string(), Value::Str("handle_bid_ask".to_string()).clone());
                m.insert("candle.stick".to_string(), Value::Str("handle_ohlcv".to_string()).clone());
                m.insert("match".to_string(), Value::Str("handle_trade".to_string()).clone());
                m.insert("orderUpdated".to_string(), Value::Str("handle_order".to_string()).clone());
                m.insert("symbolOrderChange".to_string(), Value::Str("handle_order".to_string()).clone());
                m.insert("availableBalance.change".to_string(), Value::Str("handle_balance".to_string()).clone());
                m.insert("walletBalance.change".to_string(), Value::Str("handle_balance".to_string()).clone());
                m.insert("position.change".to_string(), Value::Str("handle_position".to_string()).clone());
                m.insert("position.settlement".to_string(), Value::Str("handle_position".to_string()).clone());
                m.insert("position.adjustRiskLimit".to_string(), Value::Str("handle_position".to_string()).clone());
                m.insert("ticker.SPOT".to_string(), Value::Str("handle_uta_ticker".to_string()).clone());
                m.insert("ticker.FUTURES".to_string(), Value::Str("handle_uta_ticker".to_string()).clone());
                m.insert("trade.SPOT".to_string(), Value::Str("handle_uta_trade".to_string()).clone());
                m.insert("trade.FUTURES".to_string(), Value::Str("handle_uta_trade".to_string()).clone());
                m.insert("kline.SPOT".to_string(), Value::Str("handle_uta_ohlcv".to_string()).clone());
                m.insert("kline.FUTURES".to_string(), Value::Str("handle_uta_ohlcv".to_string()).clone());
                m.insert("obu.SPOT".to_string(), Value::Str("handle_uta_order_book".to_string()).clone());
                m.insert("obu.FUTURES".to_string(), Value::Str("handle_uta_order_book".to_string()).clone());
                m.insert("order.UNIFIED".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("order.SPOT".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("order.FUTURES".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("order.CROSS".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("order.ISOLATED".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("orderAll.UNIFIED".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("orderAll.SPOT".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("orderAll.FUTURES".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("orderAll.CROSS".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("orderAll.ISOLATED".to_string(), Value::Str("handle_uta_order".to_string()).clone());
                m.insert("execution.UNIFIED".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.SPOT".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.FUTURES".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.CROSS".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.ISOLATED".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.lite.UNIFIED".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.lite.SPOT".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.lite.FUTURES".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.lite.CROSS".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("execution.lite.ISOLATED".to_string(), Value::Str("handle_uta_my_trade".to_string()).clone());
                m.insert("position.UNIFIED".to_string(), Value::Str("handle_uta_position".to_string()).clone());
                m.insert("position.FUTURES".to_string(), Value::Str("handle_uta_position".to_string()).clone());
                m.insert("positionAll.UNIFIED".to_string(), Value::Str("handle_uta_position".to_string()).clone());
                m.insert("positionAll.FUTURES".to_string(), Value::Str("handle_uta_position".to_string()).clone());
                m.insert("balance.UNIFIED".to_string(), Value::Str("handle_uta_balance".to_string()).clone());
                m.insert("funding-fee".to_string(), Value::Str("handle_uta_funding_rate".to_string()).clone());
                m.insert("mark-price".to_string(), Value::Str("handle_uta_ticker".to_string()).clone());
            m
        });
        let mut method: Value = self.safe_value(methods.clone(), subject.clone(), &[]);
        if !is_equal(&method, &Value::Null) {
            self.dispatch_ws_handler(&method, &[client.clone(), message.clone()]);
        }
}

    pub fn ping(&mut self, mut client: Value) -> Value {
        // kucoin does not support built-in ws protocol-level ping-pong
        // instead it requires a custom json-based text ping-pong
        // https://docs.kucoin.com/#ping
        let mut id: Value = to_string_val(&self.request_id());
        return Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("id".to_string(), id.clone());
        m.insert("type".to_string(), Value::Str("ping".to_string()));
    m
});

    Value::Null
}

    pub fn handle_pong(&self, mut client: Value, mut message: Value) {
        crate::set_value(&mut client, &Value::Str("lastPong".to_string()), self.milliseconds());
}

    pub fn handle_error_message(&self, mut client: Value, mut message: Value) -> Value {
        //
        //    {
        //        "id": "1",
        //        "type": "error",
        //        "code": 415,
        //        "data": "type is not supported"
        //    }
        //
        // uta
        //     {
        //         "id": "1",
        //         "result": false,
        //         "reason": "missing `symbol` for topic: Position"
        //     }
        //
        let mut data: Value = self.safe_string2(message.clone(), Value::Str("data".to_string()), Value::Str("reason".to_string()), &[Value::Str("".to_string())]);
        if is_equal(&data, &Value::Str("token is expired".to_string())) {
            let mut type_var: Value = Value::Str("public".to_string());
            if is_greater_than_or_equal(&get_index_of(&get_value(&client, &Value::Str("url".to_string())), &Value::Str("connectId=private".to_string())), &Value::Int(0)) {
                type_var = Value::Str("private".to_string());
            }
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.options) }, &Value::Str("urls".to_string())), &type_var, Value::Null);
        }
        self.handle_errors(Value::Int(1), Value::Str("".to_string()), get_value(&client, &Value::Str("url".to_string())), Value::Str("".to_string()), Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        }), data.clone(), message.clone(), Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        }), Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        }));
        return Value::Bool(false);

    Value::Null
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        let mut type_var: Value = self.safe_string2(message.clone(), Value::Str("type".to_string()), Value::Str("message".to_string()), &[]);
        let mut methods: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("welcome".to_string(), Value::Str("handle_system_status".to_string()).clone());
                m.insert("ack".to_string(), Value::Str("handle_subscription_status".to_string()).clone());
                m.insert("message".to_string(), Value::Str("handle_subject".to_string()).clone());
                m.insert("pong".to_string(), Value::Str("handle_pong".to_string()).clone());
                m.insert("error".to_string(), Value::Str("handle_error_message".to_string()).clone());
            m
        });
        let mut method: Value = self.safe_value(methods.clone(), type_var.clone(), &[]);
        if !is_equal(&method, &Value::Null) {
            self.dispatch_ws_handler(&method, &[client.clone(), message.clone()]);
        }  else if is_true(&Value::Bool(in_op(&message, &Value::Str("T".to_string())))) {
            self.handle_subject(client.clone(), message.clone());
        }  else if is_true(&Value::Bool(in_op(&message, &Value::Str("result".to_string())))) {
            let mut result: Value = self.safe_bool_k(message.clone(), "result", &[Value::Bool(true)]);
            if !is_equal(&result, &Value::Bool(true)) {
                self.handle_error_message(client.clone(), message.clone());
            }
            self.handle_subscription_status(client.clone(), message.clone());
        }
}

    pub fn get_message_hash(&self, mut elementName: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        // method from kucoinfutures
        // elementName can be 'ticker', 'bidask', ...
        if !is_equal(&symbol, &Value::Null) {
            return add(&add(&elementName, &Value::Str(":".to_string())), &symbol);
        }  else {
            return add(&elementName, &Value::Str("s@all".to_string()));
        }

    Value::Null
}
}