ccxt-pro 4.5.83

// 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;
// Dynamic `this[method](...)` re-entries are emitted as
// `self.call_dynamic_checked(...)` (blanket-impl'd on every Core) so an
// unresolvable name raises NotSupported instead of yielding a silent Null.
use crate::exchange::CallDynamicChecked;
use crate::pro::*;


pub struct NadoCore {
    pub parent: crate::exchanges::nado::NadoCore,
}

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

    pub fn init(&mut self) {
        let described = NadoCore::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 NadoCore {
    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 NadoCore {
    fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
        -> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
    {
        Box::pin(async move {
            match method {
                "authenticate" => self.authenticate(&args[..]).await,
                "cancel_all_orders_ws" => self.cancel_all_orders_ws(&args[..]).await,
                "cancel_order_ws" => self.cancel_order_ws(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "cancel_orders_ws" => self.cancel_orders_ws(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "create_order_ws" => self.create_order_ws(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[4.min(args.len())..]).await,
                "create_public_subscription_request" => self.create_public_subscription_request(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]),
                "edit_order_ws" => self.edit_order_ws(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[4.min(args.len())..]).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_pong" => self.handle_pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_all_bids_asks" => self.parse_ws_all_bids_asks(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_bid_ask" => self.parse_ws_bid_ask(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_my_trade" => self.parse_ws_my_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_timestamp" => self.parse_ws_timestamp(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "ping" => self.ping(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "request_id" => self.request_id(),
                "un_watch_bids_asks" => self.un_watch_bids_asks(&args[..]).await,
                "un_watch_my_trades" => self.un_watch_my_trades(&args[..]).await,
                "un_watch_ohlcv" => self.un_watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_ohlcv_for_symbols" => self.un_watch_ohlcv_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_order_book" => self.un_watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_order_book_for_symbols" => self.un_watch_order_book_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_orders" => self.un_watch_orders(&args[..]).await,
                "un_watch_positions" => self.un_watch_positions(&args[..]).await,
                "un_watch_private" => self.un_watch_private(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]).await,
                "un_watch_public" => self.un_watch_public(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[3.min(args.len())..]).await,
                "un_watch_public_multiple" => self.un_watch_public_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[3.min(args.len())..]).await,
                "un_watch_ticker" => self.un_watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_tickers" => self.un_watch_tickers(&args[..]).await,
                "un_watch_trades" => self.un_watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "un_watch_trades_for_symbols" => self.un_watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_bids_asks" => self.watch_bids_asks(&args[..]).await,
                "watch_execute_request" => self.watch_execute_request(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)).await,
                "watch_my_trades" => self.watch_my_trades(&args[..]).await,
                "watch_ohlcv" => self.watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_ohlcv_for_symbols" => self.watch_ohlcv_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_order_book_for_symbols" => self.watch_order_book_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_orders" => self.watch_orders(&args[..]).await,
                "watch_positions" => self.watch_positions(&args[..]).await,
                "watch_private" => self.watch_private(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[3.min(args.len())..]).await,
                "watch_public" => self.watch_public(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[3.min(args.len())..]).await,
                "watch_public_multiple" => self.watch_public_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[3.min(args.len())..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_tickers" => self.watch_tickers(&args[..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_trades_for_symbols" => self.watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).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 NadoCore {
    /// 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_ref(), _ => return crate::Value::Null };
        match __n {
            "authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
            "cancel_all_orders_ws" => { crate::exchange_stubs::enqueue_spawn("cancel_all_orders_ws", args.to_vec()); crate::Value::Null },
            "cancel_order_ws" => { crate::exchange_stubs::enqueue_spawn("cancel_order_ws", args.to_vec()); crate::Value::Null },
            "cancel_orders_ws" => { crate::exchange_stubs::enqueue_spawn("cancel_orders_ws", args.to_vec()); crate::Value::Null },
            "create_order_ws" => { crate::exchange_stubs::enqueue_spawn("create_order_ws", args.to_vec()); crate::Value::Null },
            "create_public_subscription_request" => self.create_public_subscription_request(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]),
            "edit_order_ws" => { crate::exchange_stubs::enqueue_spawn("edit_order_ws", args.to_vec()); crate::Value::Null },
            "handle_all_bids_asks" => { self.handle_all_bids_asks(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_authentication" => { self.handle_authentication(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_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_execute_response" => { self.handle_execute_response(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); 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_pong" => self.handle_pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(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_subscription" => { self.handle_subscription(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_unsubscription" => { self.handle_unsubscription(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_unsubscription_cache" => { self.handle_unsubscription_cache(args.get(0).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "parse_ws_all_bids_asks" => self.parse_ws_all_bids_asks(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_bid_ask" => self.parse_ws_bid_ask(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_my_trade" => self.parse_ws_my_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_position" => self.parse_ws_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_timestamp" => self.parse_ws_timestamp(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "ping" => self.ping(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "request_id" => self.request_id(),
            "un_watch_bids_asks" => { crate::exchange_stubs::enqueue_spawn("un_watch_bids_asks", args.to_vec()); crate::Value::Null },
            "un_watch_my_trades" => { crate::exchange_stubs::enqueue_spawn("un_watch_my_trades", 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_ohlcv_for_symbols" => { crate::exchange_stubs::enqueue_spawn("un_watch_ohlcv_for_symbols", 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_orders" => { crate::exchange_stubs::enqueue_spawn("un_watch_orders", args.to_vec()); crate::Value::Null },
            "un_watch_positions" => { crate::exchange_stubs::enqueue_spawn("un_watch_positions", args.to_vec()); crate::Value::Null },
            "un_watch_private" => { crate::exchange_stubs::enqueue_spawn("un_watch_private", args.to_vec()); crate::Value::Null },
            "un_watch_public" => { crate::exchange_stubs::enqueue_spawn("un_watch_public", args.to_vec()); crate::Value::Null },
            "un_watch_public_multiple" => { crate::exchange_stubs::enqueue_spawn("un_watch_public_multiple", 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_tickers" => { crate::exchange_stubs::enqueue_spawn("un_watch_tickers", 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_bids_asks" => { crate::exchange_stubs::enqueue_spawn("watch_bids_asks", args.to_vec()); crate::Value::Null },
            "watch_execute_request" => { crate::exchange_stubs::enqueue_spawn("watch_execute_request", 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_ohlcv_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_ohlcv_for_symbols", 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_positions" => { crate::exchange_stubs::enqueue_spawn("watch_positions", args.to_vec()); crate::Value::Null },
            "watch_private" => { crate::exchange_stubs::enqueue_spawn("watch_private", args.to_vec()); crate::Value::Null },
            "watch_public" => { crate::exchange_stubs::enqueue_spawn("watch_public", args.to_vec()); crate::Value::Null },
            "watch_public_multiple" => { crate::exchange_stubs::enqueue_spawn("watch_public_multiple", 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 },
            _ => crate::Value::Null,
        }
    }
}

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

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

impl NadoCore {
    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("cancelAllOrdersWs".to_string(), Value::Bool(true));
        m.insert("cancelOrderWs".to_string(), Value::Bool(true));
        m.insert("cancelOrdersWs".to_string(), Value::Bool(true));
        m.insert("createOrderWs".to_string(), Value::Bool(true));
        m.insert("editOrderWs".to_string(), Value::Bool(true));
        m.insert("watchBalance".to_string(), Value::Bool(false));
        m.insert("watchBidsAsks".to_string(), Value::Bool(true));
        m.insert("watchFundingRate".to_string(), Value::Bool(false));
        m.insert("watchFundingRates".to_string(), Value::Bool(false));
        m.insert("watchLiquidations".to_string(), Value::Bool(false));
        m.insert("watchLiquidationsForSymbols".to_string(), Value::Bool(false));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("unWatchBidsAsks".to_string(), Value::Bool(true));
        m.insert("unWatchMyTrades".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCVForSymbols".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBook".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBookForSymbols".to_string(), Value::Bool(true));
        m.insert("unWatchOrders".to_string(), Value::Bool(true));
        m.insert("unWatchPositions".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchTickers".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
        m.insert("unWatchTradesForSymbols".to_string(), Value::Bool(true));
        m.insert("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("watchOHLCVForSymbols".to_string(), Value::Bool(true));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchOrderBookForSymbols".to_string(), Value::Bool(true));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchPositions".to_string(), Value::Bool(true));
        m.insert("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(true));
    m
}));
        m.insert("streaming".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ping".to_string(), Value::Str("ping".into()).clone());
        m.insert("keepAlive".to_string(), Value::Int(30000));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("tradesLimit".to_string(), Value::Int(1000));
        m.insert("requestId".to_string(), Value::Int(0));
    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("gateway".to_string(), Value::Str("wss://gateway.prod.nado.xyz/ws/v2".into()));
        m.insert("subscriptions".to_string(), Value::Str("wss://gateway.prod.nado.xyz/v1/subscribe".into()));
    m
}));
    m
}));
        m.insert("test".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("gateway".to_string(), Value::Str("wss://gateway.test.nado.xyz/ws/v2".into()));
        m.insert("subscriptions".to_string(), Value::Str("wss://gateway.test.nado.xyz/v1/subscribe".into()));
    m
}));
    m
}));
    m
}));
    m
})]);

    Value::Null
}

    pub fn request_id(&mut self) -> Value {
        let mut requestId: Value = self.sum(&[self.safe_integer_k(self.options.clone(), "requestId", &[Value::Int(0)]), Value::Int(1)]);
        if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("requestId".into(), requestId.clone()); }
        return requestId;

    Value::Null
}

/*
 * @method
 * @name nado#watchTrades
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches information on multiple trades made in a market
 * @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 number of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Trade[]} 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
}));
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trade:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
        let mut trades: Value = self.watch_public(Value::Str("trade".into()), market.clone(), messageHash, &[params]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), limit.clone());
        }
        return self.filter_by_since_limit(trades, &[since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchTrades
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on multiple trades made in a market
 * @param {string} symbol unified symbol of the market to unwatch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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
}));
        self.load_markets(&[]).await;
        return self.un_watch_trades_for_symbols(Value::from(vec![symbol]), &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchTradesForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description get the list of most recent trades for a list of symbols
 * @param {string[]} symbols unified symbols of the markets to fetch trades for
 * @param {int} [since] timestamp in ms of the earliest trade to fetch
 * @param {int} [limit] the maximum number of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Trade[]} 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
}));
        self.load_markets(&[]).await;
        let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
        if (symbolsLength == 0.0) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchTradesForSymbols() requires a non-empty array of symbols".into()))));
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_508: bool = true;
            while { if !__for_first_508 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_508 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut market: Value = self.market(symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, Value::Str(format!("{}{}", Value::Str("trade:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into()));
        }
        }
        let mut trades: Value = self.watch_public_multiple(Value::Str("trade".into()), markets, messageHashes, &[params]).await;
        if is_true(&self.newUpdates) {
            let mut first: Value = self.safe_dict(trades.clone(), Value::Int(0), &[]);
            let mut tradeSymbol: Value = self.safe_string_k(first, "symbol", &[]);
            limit = trades.get_limit(tradeSymbol, limit.clone());
        }
        return self.filter_by_since_limit(trades, &[since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchTradesForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on multiple trades made in a list of markets
 * @param {string[]} symbols unified symbols of the markets to unwatch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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
}));
        self.load_markets(&[]).await;
        let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
        if (symbolsLength == 0.0) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" unWatchTradesForSymbols() requires a non-empty array of symbols".into()))));
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_509: bool = true;
            while { if !__for_first_509 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_509 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut market: Value = self.market(symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, Value::Str(format!("{}{}", Value::Str("trade:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into()));
        }
        }
        return self.un_watch_public_multiple(Value::Str("trade".into()), markets, messageHashes, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchOrderBook
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @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
 * @returns {OrderBook} 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
}));
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol.clone());
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("orderbook:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
        if !(in_op(&self.orderbooks, &market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null))) {
            let mut snapshot: Value = self.fetch_order_book(symbol, &[limit.clone()]).await;
            { let __be_tmp = self.order_book(&[snapshot, limit.clone()]); add_element_to_object(&mut self.orderbooks, &market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), __be_tmp); };
        }
        let mut orderbook: Value = self.watch_public(Value::Str("book_depth".into()), market, messageHash, &[params]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name nado#unWatchOrderBook
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @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 unwatch the order book for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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
}));
        self.load_markets(&[]).await;
        return self.un_watch_order_book_for_symbols(Value::from(vec![symbol]), &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchOrderBookForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data for a list of symbols
 * @param {string[]} symbols unified symbols of the markets to fetch the order book for
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {OrderBook} 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
}));
        self.load_markets(&[]).await;
        let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
        if (symbolsLength == 0.0) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchOrderBookForSymbols() requires a non-empty array of symbols".into()))));
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_510: bool = true;
            while { if !__for_first_510 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_510 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut symbol: Value = symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut market: Value = self.market(symbol.clone());
            let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("orderbook:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, messageHash);
            if !(in_op(&self.orderbooks, &market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null))) {
                let mut snapshot: Value = self.fetch_order_book(symbol, &[limit.clone()]).await;
                { let __be_tmp = self.order_book(&[snapshot, limit.clone()]); add_element_to_object(&mut self.orderbooks, &market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), __be_tmp); };
            }
        }
        }
        let mut orderbook: Value = self.watch_public_multiple(Value::Str("book_depth".into()), markets, messageHashes, &[params]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name nado#unWatchOrderBookForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data for a list of symbols
 * @param {string[]} symbols unified symbols of the markets to unwatch the order book for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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
}));
        self.load_markets(&[]).await;
        let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
        if (symbolsLength == 0.0) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" unWatchOrderBookForSymbols() requires a non-empty array of symbols".into()))));
        }
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_511: bool = true;
            while { if !__for_first_511 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_511 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut market: Value = self.market(symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, Value::Str(format!("{}{}", Value::Str("orderbook:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into()));
        }
        }
        return self.un_watch_public_multiple(Value::Str("book_depth".into()), markets, messageHashes, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchOHLCV
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {int} [since] timestamp in ms of the earliest candle to fetch
 * @param {int} [limit] the maximum amount of candles to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
    pub async fn watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".into()));
        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
}));
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("ohlcv:".into()), timeframe).into()), Value::Str(":".into())).into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("granularity".to_string(), self.safe_integer(self.timeframes.clone(), timeframe.clone(), &[self.parse_timeframe(timeframe.clone())]));
            m
        });
        let __ws_arg_0 = self.extend(request, &[params]);
        let mut result: Value = self.watch_public(Value::Str("latest_candlestick".into()), market.clone(), messageHash, &[__ws_arg_0]).await;
        let mut stored: Value = get_value(&result, &Value::Int(2));
        if is_true(&self.newUpdates) {
            limit = stored.get_limit(market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null), limit.clone());
        }
        return self.filter_by_since_limit(stored, &[since, limit, Value::Int(0), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#watchOHLCVForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of multiple markets
 * @param {string[][]} symbolsAndTimeframes array of arrays containing unified symbols and timeframes to watch OHLCV data for, example [['BTC/USDT0:USDT0', '1m'], ['ETH/USDT0:USDT0', '5m']]
 * @param {int} [since] timestamp in ms of the earliest candle to fetch
 * @param {int} [limit] the maximum amount of candles to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} A dictionary of {@link https://docs.ccxt.com/#/?id=ohlcv-structure OHLCV} structures indexed by market symbols
 */
    pub async fn watch_ohlcv_for_symbols(&mut self, mut symbolsAndTimeframes: 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: f64 = ((symbolsAndTimeframes.len() as i64) as f64);
        if (symbolsLength == 0.0) || !(matches!(&symbolsAndTimeframes.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null), Value::Arr(_))) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT0:USDT0', '1m'], ['ETH/USDT0:USDT0', '5m']]".into()))));
        }
        self.load_markets(&[]).await;
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        let mut subscriptionParams: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_512: bool = true;
            while { if !__for_first_512 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_512 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbolsAndTimeframes.len() as i64) as f64) } {
            let mut symbolAndTimeframe: Value = symbolsAndTimeframes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut marketSymbol: Value = self.safe_string(symbolAndTimeframe.clone(), Value::Int(0), &[]);
            let mut timeframe: Value = self.safe_string(symbolAndTimeframe, Value::Int(1), &[Value::Str("1m".into())]);
            let mut market: Value = self.market(marketSymbol);
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("ohlcv:".into()), timeframe).into()), Value::Str(":".into())).into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into()));
            let __ws_arg_1 = self.safe_integer(self.timeframes.clone(), timeframe.clone(), &[self.parse_timeframe(timeframe.clone())]);
            append_to_array(&mut subscriptionParams, self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("granularity".to_string(), __ws_arg_1);
                m
            }), &[params.clone()]));
        }
        }
        let mut resultSymbolresultTimeframestoredVariable = self.watch_public_multiple(Value::Str("latest_candlestick".into()), markets, messageHashes, &[params, subscriptionParams]).await;
        let mut resultSymbol: Value = get_value(&resultSymbolresultTimeframestoredVariable, &Value::Int(0));
        let mut resultTimeframe: Value = get_value(&resultSymbolresultTimeframestoredVariable, &Value::Int(1));
        let mut stored: Value = get_value(&resultSymbolresultTimeframestoredVariable, &Value::Int(2));
        if is_true(&self.newUpdates) {
            limit = stored.get_limit(resultSymbol.clone(), limit.clone());
        }
        let mut filtered: Value = self.filter_by_since_limit(stored, &[since, limit, Value::Int(0), Value::Bool(true)]);
        return self.create_ohlcv_object(resultSymbol, resultTimeframe, filtered);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchOHLCV
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @param {string} symbol unified symbol of the market to unwatch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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".into()));
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.load_markets(&[]).await;
        return self.un_watch_ohlcv_for_symbols(Value::from(vec![Value::from(vec![symbol, timeframe])]), &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#unWatchOHLCVForSymbols
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches historical candlestick data containing the open, high, low, and close price, and the volume of multiple markets
 * @param {string[][]} symbolsAndTimeframes array of arrays containing unified symbols and timeframes to unwatch OHLCV data for, example [['BTC/USDT0:USDT0', '1m'], ['ETH/USDT0:USDT0', '5m']]
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_watch_ohlcv_for_symbols(&mut self, mut symbolsAndTimeframes: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut symbolsLength: f64 = ((symbolsAndTimeframes.len() as i64) as f64);
        if (symbolsLength == 0.0) || !(matches!(&symbolsAndTimeframes.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null), Value::Arr(_))) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" unWatchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT0:USDT0', '1m'], ['ETH/USDT0:USDT0', '5m']]".into()))));
        }
        self.load_markets(&[]).await;
        let mut markets: Value = Value::from(vec![]);
        let mut messageHashes: Value = Value::from(vec![]);
        let mut subscriptionParams: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_513: bool = true;
            while { if !__for_first_513 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_513 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbolsAndTimeframes.len() as i64) as f64) } {
            let mut symbolAndTimeframe: Value = symbolsAndTimeframes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut marketSymbol: Value = self.safe_string(symbolAndTimeframe.clone(), Value::Int(0), &[]);
            let mut timeframe: Value = self.safe_string(symbolAndTimeframe, Value::Int(1), &[Value::Str("1m".into())]);
            let mut market: Value = self.market(marketSymbol);
            append_to_array(&mut markets, market.clone());
            append_to_array(&mut messageHashes, Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("ohlcv:".into()), timeframe).into()), Value::Str(":".into())).into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into()));
            let __ws_arg_2 = self.safe_integer(self.timeframes.clone(), timeframe.clone(), &[self.parse_timeframe(timeframe.clone())]);
            append_to_array(&mut subscriptionParams, self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("granularity".to_string(), __ws_arg_2);
                m
            }), &[params.clone()]));
        }
        }
        return self.un_watch_public_multiple(Value::Str("latest_candlestick".into()), markets, messageHashes, &[params, subscriptionParams]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchTicker
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches a price ticker with the best bid and ask for a specific market
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
 */
    pub async fn watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.load_markets(&[]).await;
        symbol = self.symbol(symbol.clone());
        let mut tickers: Value = self.watch_tickers(&[Value::from(vec![symbol.clone()]), params]).await;
        return get_value(&tickers, &symbol);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchTicker
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches a price ticker with the best bid and ask for a specific market
 * @param {string} symbol unified symbol of the market to unwatch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    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
}));
        self.load_markets(&[]).await;
        return self.un_watch_tickers(&[Value::from(vec![symbol]), params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchTickers
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches price tickers with the best bid and ask for all markets of a specific list
 * @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a dictionary of [ticker structures]{@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
}));
        self.load_markets(&[]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(true), Value::Bool(true), Value::Bool(true)]);
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("ticker".into());
        let mut streamType: Value = Value::Str("all_bbo".into());
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                market = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", Value::Str("ticker:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
                streamType = Value::Str("best_bid_offer".into());
            }
        }
        let mut ticker: Value = self.watch_public(streamType, market, messageHash.clone(), &[params]).await;
        if is_true(&self.newUpdates) {
            if (messageHash.as_str() == Some("ticker")) {
                return self.filter_by_array(ticker.clone(), Value::Str("symbol".into()), &[symbols.clone()]);
            }
            let mut tickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            add_element_to_object(&mut tickers, &crate::value::get_value_k(&ticker, "symbol"), ticker.clone());
            return tickers;
        }
        return self.filter_by_array(self.tickers.clone(), Value::Str("symbol".into()), &[symbols]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchTickers
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches price tickers with the best bid and ask for all markets of a specific list
 * @param {string[]} [symbols] unified symbols of the markets to unwatch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_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
}));
        self.load_markets(&[]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(true), Value::Bool(true), Value::Bool(true)]);
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("ticker".into());
        let mut streamType: Value = Value::Str("all_bbo".into());
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                market = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", Value::Str("ticker:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
                streamType = Value::Str("best_bid_offer".into());
            }
        }
        return self.un_watch_public(streamType, market, messageHash, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchBidsAsks
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description watches best bid & ask for symbols
 * @param {string[]} symbols unified symbols of the markets to fetch the bids and asks 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
}));
        self.load_markets(&[]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(true), Value::Bool(true), Value::Bool(true)]);
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("bidask".into());
        let mut streamType: Value = Value::Str("all_bbo".into());
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                market = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", Value::Str("bidask:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
                streamType = Value::Str("best_bid_offer".into());
            }
        }
        let mut ticker: Value = self.watch_public(streamType, market, messageHash.clone(), &[params]).await;
        if is_true(&self.newUpdates) {
            if (messageHash.as_str() == Some("bidask")) {
                return self.filter_by_array(ticker.clone(), Value::Str("symbol".into()), &[symbols.clone()]);
            }
            let mut tickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            add_element_to_object(&mut tickers, &crate::value::get_value_k(&ticker, "symbol"), ticker.clone());
            return tickers;
        }
        return self.filter_by_array(self.bidsasks.clone(), Value::Str("symbol".into()), &[symbols]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchBidsAsks
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches best bid & ask for symbols
 * @param {string[]} symbols unified symbols of the markets to unwatch the bids and asks for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_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
}));
        self.load_markets(&[]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(true), Value::Bool(true), Value::Bool(true)]);
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("bidask".into());
        let mut streamType: Value = Value::Str("all_bbo".into());
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                market = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", Value::Str("bidask:".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into());
                streamType = Value::Str("best_bid_offer".into());
            }
        }
        return self.un_watch_public(streamType, market, messageHash, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchOrders
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/events
 * @description watches information on multiple orders made by the user
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {int} [since] the earliest time in ms to fetch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
    pub async fn watch_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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_3 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_3]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("orders".into());
        let mut productId: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
            productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrders".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("order_update".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        let mut orders: Value = self.watch_private(Value::Str("order_update".into()), stream, messageHash, &[params]).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(orders, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchOrders
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on multiple orders made by the user
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_watch_orders(&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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_4 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_4]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("orders".into());
        let mut productId: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
            productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchOrders".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("order_update".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        return self.un_watch_private(stream, messageHash, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchMyTrades
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/events
 * @description watches information on multiple trades made by the user
 * @param {string} symbol unified market symbol of the market orders 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
 * @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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_5 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_5]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("myTrades".into());
        let mut productId: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
            productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchMyTrades".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("fill".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        let mut trades: Value = self.watch_private(Value::Str("fill".into()), stream, messageHash, &[params]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(trades, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchMyTrades
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on multiple trades made by the user
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_watch_my_trades(&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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_6 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_6]).await;
        let mut market: Value = Value::Null;
        let mut messageHash: Value = Value::Str("myTrades".into());
        let mut productId: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
            messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), symbol).into())).into());
            productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchMyTrades".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("fill".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        return self.un_watch_private(stream, messageHash, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#watchPositions
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/events
 * @description watches information on user positions
 * @param {string[]} [symbols] unified market symbols
 * @param {int} [since] the earliest time in ms to fetch positions for
 * @param {int} [limit] the maximum number of position structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [position structures]{@link https://docs.ccxt.com/#/?id=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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_7 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_7]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut messageHash: Value = Value::Str("positions".into());
        let mut productId: Value = Value::Null;
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                let mut market: Value = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into())).into());
                productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
            }
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchPositions".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("position_change".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        let mut positions: Value = self.watch_private(Value::Str("position_change".into()), stream, messageHash, &[params]).await;
        if is_true(&self.newUpdates) {
            return positions;
        }
        return self.filter_by_symbols_since_limit(self.positions.clone(), &[symbols, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name nado#unWatchPositions
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/authentication
 * @see https://docs.nado.xyz/developer-resources/api/subscriptions/streams
 * @description unWatches information on user positions
 * @param {string[]} [symbols] unified market symbols
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} the exchange response
 */
    pub async fn un_watch_positions(&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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let __ws_arg_8 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), &[params.clone()]);
        self.authenticate(&[__ws_arg_8]).await;
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
        let mut messageHash: Value = Value::Str("positions".into());
        let mut productId: Value = Value::Null;
        if (symbols != Value::Null) {
            let mut symbolsLength: f64 = ((symbols.len() as i64) as f64);
            if (symbolsLength == 1.0) {
                let mut market: Value = self.market(symbols.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null));
                messageHash = Value::Str(format!("{}{}", messageHash, Value::Str(format!("{}{}", Value::Str(":".into()), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null)).into())).into());
                productId = self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null));
            }
        }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("unWatchPositions".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("position_change".into()));
                m.insert("subaccount".to_string(), sender);
                m.insert("product_id".to_string(), productId);
            m
        });
        return self.un_watch_private(stream, messageHash, &[params]).await;

    Value::Null
}

/*
 * @method
 * @name nado#createOrderWs
 * @description create a trade order over the v2 gateway WebSocket
 * @see https://docs.nado.xyz/developer-resources/api/gateway/websocket-v2
 * @see https://docs.nado.xyz/developer-resources/api/gateway/executes/place-order
 * @param {string} symbol unified symbol of the market to create an order in
 * @param {string} type must be 'limit'
 * @param {string} side 'buy' or 'sell'
 * @param {float} amount how much of currency you want to trade in units of base currency
 * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.subaccount] the 12-byte subaccount identifier, defaults to 'default'
 * @param {string|int} [params.expiration] order expiration timestamp in seconds, defaults to 4294967295
 * @param {string|int} [params.appendix] pre-encoded order appendix
 * @param {boolean} [params.reduceOnly] true if the order should only reduce position
 * @param {boolean} [params.postOnly] true to create a post-only order
 * @param {string} [params.timeInForce] 'GTC', 'IOC', 'FOK', or 'PO'
 * @param {boolean} [params.spotLeverage] whether leverage should be used for spot, defaults to true, exchange-specific alias params.spot_leverage
 * @param {int} [params.id] client-provided request id used to correlate the out-of-order v2 response, autogenerated when omitted
 * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
    pub async fn create_order_ws(&mut self, mut symbol: Value, mut type_var: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
        let mut price = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol.clone());
        let __ws_arg_9 = self.request_id();
        params = self.extend(Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), __ws_arg_9);
            m
        }), &[params.clone()]);
        let mut requestIdString: Value = self.safe_string_k(params.clone(), "id", &[]);
        if (requestIdString == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" ws execute requires params.id".into()))));
        }
        let mut request: Value = self.parent.create_order_request(symbol, type_var, side, amount, &[price, params]).await;
        let mut placeOrder: Value = self.safe_dict_k(request.clone(), "place_order", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        if (matches!(&placeOrder, Value::Dict(__d) if __d.contains_key("trigger"))) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" createOrderWs() does not support trigger orders, use createOrder() instead".into()))));
        }
        let mut response: Value = self.watch_execute_request(requestIdString, request).await;
        let __ws_arg_10 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("place_order".to_string(), placeOrder);
    m
}), &[response]);
        return self.parse_order(__ws_arg_10, &[market]);

    Value::Null
}

/*
 * @method
 * @name nado#editOrderWs
 * @description edit a trade order over the v2 gateway WebSocket
 * @see https://docs.nado.xyz/developer-resources/api/gateway/websocket-v2
 * @see https://docs.nado.xyz/developer-resources/api/gateway/executes/cancel-and-place
 * @param {string} id order id
 * @param {string} symbol unified symbol of the market to edit an order in
 * @param {string} type must be 'limit'
 * @param {string} side 'buy' or 'sell'
 * @param {float} amount how much of currency you want to trade in units of base currency
 * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.subaccount] the 12-byte subaccount identifier, defaults to 'default'
 * @param {string|int} [params.expiration] order expiration timestamp in seconds, defaults to 4294967295
 * @param {string|int} [params.appendix] pre-encoded order appendix
 * @param {boolean} [params.reduceOnly] true if the order should only reduce position
 * @param {boolean} [params.postOnly] true to create a post-only order
 * @param {string} [params.timeInForce] 'GTC', 'IOC', 'FOK', or 'PO'
 * @param {boolean} [params.spotLeverage] whether leverage should be used for spot, defaults to true, exchange-specific alias params.spot_leverage
 * @param {boolean} [params.placeRequiresUnfilled] when true, aborts the new order if the canceled order had partial fills or the cancel failed, exchange-specific alias params.place_requires_unfilled, defaults to true
 * @param {int} [params.id] client-provided request id used to correlate the out-of-order v2 response, autogenerated when omitted
 * @param {float} [params.triggerPrice] not supported, editing trigger orders throws NotSupported, the same applies to params.stopPrice, params.stopLossPrice and params.takeProfitPrice
 * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
    pub async fn edit_order_ws(&mut self, mut id: Value, mut symbol: Value, mut type_var: Value, mut side: Value, optional_args: &[Value]) -> Value {
        let mut amount = get_arg(optional_args, 0, Value::Null);
        let mut price = get_arg(optional_args, 1, Value::Null);
        let mut params = get_arg(optional_args, 2, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol.clone());
        // for cancel_and_place the request id is echoed from the nested place_order object
        let __ws_arg_11 = self.request_id();
        params = self.extend(Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), __ws_arg_11);
            m
        }), &[params.clone()]);
        let mut requestIdString: Value = self.safe_string_k(params.clone(), "id", &[]);
        if (requestIdString == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" ws execute requires params.id".into()))));
        }
        let mut request: Value = self.parent.edit_order_request(id, symbol, type_var, side, &[amount, price, params]).await;
        let mut response: Value = self.watch_execute_request(requestIdString, request.clone()).await;
        //
        //     {
        //         "status": "success",
        //         "signature": "0x...",
        //         "data": {
        //             "digest": "0x..."
        //         },
        //         "request_type": "execute_cancel_and_place",
        //         "id": 100
        //     }
        //
        let mut cancelAndPlace: Value = self.safe_dict_k(request, "cancel_and_place", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut placeOrder: Value = self.safe_dict_k(cancelAndPlace, "place_order", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let __ws_arg_12 = self.extend(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("place_order".to_string(), placeOrder);
    m
}), &[response]);
        return self.parse_order(__ws_arg_12, &[market]);

    Value::Null
}

/*
 * @method
 * @name nado#cancelOrderWs
 * @description cancels an open order over the v2 gateway WebSocket
 * @see https://docs.nado.xyz/developer-resources/api/gateway/websocket-v2
 * @see https://docs.nado.xyz/developer-resources/api/gateway/executes/cancel-orders
 * @param {string} id order id
 * @param {string} symbol unified symbol of the market the order was made in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.subaccount] the 12-byte subaccount identifier, defaults to 'default'
 * @param {string} [params.requiredUnfilledAmount] cancel only if the order's absolute remaining unfilled amount matches this amount, exchange-specific raw x18 alias params.required_unfilled_amount
 * @param {int} [params.id] client-provided request id used to correlate the out-of-order v2 response, autogenerated when omitted
 * @returns {object} An [order structure]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn cancel_order_ws(&mut self, mut id: 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 orders: Value = self.cancel_orders_ws(Value::from(vec![id]), &[symbol, params]).await;
        return self.safe_dict(orders, Value::Int(0), &[]);

    Value::Null
}

/*
 * @method
 * @name nado#cancelOrdersWs
 * @description cancel multiple orders over the v2 gateway WebSocket
 * @see https://docs.nado.xyz/developer-resources/api/gateway/websocket-v2
 * @see https://docs.nado.xyz/developer-resources/api/gateway/executes/cancel-orders
 * @param {string[]} ids order ids
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.subaccount] the 12-byte subaccount identifier, defaults to 'default'
 * @param {string} [params.requiredUnfilledAmount] cancel only if the order's absolute remaining unfilled amount matches this amount, exchange-specific raw x18 alias params.required_unfilled_amount
 * @param {int} [params.id] client-provided request id used to correlate the out-of-order v2 response, autogenerated when omitted
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn cancel_orders_ws(&mut self, mut ids: 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
}));
        self.check_required_credentials(&[]);
        if (symbol == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" cancelOrdersWs() requires a symbol argument".into()))));
        }
        self.load_markets(&[]).await;
        let mut market: Value = self.market(symbol.clone());
        let mut trigger: Value = self.safe_bool2(params.clone(), Value::Str("stop".into()), Value::Str("trigger".into()), &[]);
        if (trigger.as_bool() == Some(true)) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" cancelOrdersWs() does not support trigger orders, use cancelOrders() instead".into()))));
        }
        let __ws_arg_13 = self.request_id();
        params = self.extend(Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), __ws_arg_13);
            m
        }), &[params.clone()]);
        let mut requestIdString: Value = self.safe_string_k(params.clone(), "id", &[]);
        if (requestIdString == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" ws execute requires params.id".into()))));
        }
        let mut request: Value = self.parent.cancel_orders_request(ids, &[symbol, params]).await;
        let mut response: Value = self.watch_execute_request(requestIdString, request).await;
        //
        //     {
        //         "status": "success",
        //         "signature": "0x...",
        //         "data": {
        //             "cancelled_orders": []
        //         },
        //         "request_type": "execute_cancel_orders",
        //         "id": 100
        //     }
        //
        let mut data: Value = self.safe_dict_k(response, "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut cancelledOrders: Value = self.safe_list_k(data, "cancelled_orders", &[Value::from(vec![])]);
        let mut result: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_514: bool = true;
            while { if !__for_first_514 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_514 = false; i.as_f64().unwrap_or(f64::NAN) < ((cancelledOrders.len() as i64) as f64) } {
            let __ws_arg_14 = self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("status".to_string(), Value::Str("canceled".into()));
                m
            }), &[cancelledOrders.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null)]);
            append_to_array(&mut result, self.parse_order(__ws_arg_14, &[market.clone()]));
        }
        }
        return result;

    Value::Null
}

/*
 * @method
 * @name nado#cancelAllOrdersWs
 * @description cancel all open orders over the v2 gateway WebSocket
 * @see https://docs.nado.xyz/developer-resources/api/gateway/websocket-v2
 * @see https://docs.nado.xyz/developer-resources/api/gateway/executes/cancel-product-orders
 * @param {string} [symbol] unified market symbol, when undefined all orders for all products are canceled
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.subaccount] the 12-byte subaccount identifier, defaults to 'default'
 * @param {int} [params.id] client-provided request id used to correlate the out-of-order v2 response, autogenerated when omitted
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn cancel_all_orders_ws(&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
}));
        self.check_required_credentials(&[]);
        self.load_markets(&[]).await;
        let mut market: Value = Value::Null;
        if (symbol != Value::Null) {
            market = self.market(symbol.clone());
        }
        let mut trigger: Value = self.safe_bool2(params.clone(), Value::Str("stop".into()), Value::Str("trigger".into()), &[]);
        if (trigger.as_bool() == Some(true)) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" cancelAllOrdersWs() does not support trigger orders, use cancelAllOrders() instead".into()))));
        }
        let __ws_arg_15 = self.request_id();
        params = self.extend(Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), __ws_arg_15);
            m
        }), &[params.clone()]);
        let mut requestIdString: Value = self.safe_string_k(params.clone(), "id", &[]);
        if (requestIdString == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" ws execute requires params.id".into()))));
        }
        let mut request: Value = self.parent.cancel_all_orders_request(&[symbol, params]).await;
        let mut response: Value = self.watch_execute_request(requestIdString, request).await;
        let mut data: Value = self.safe_dict_k(response, "data", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut cancelledOrders: Value = self.safe_list_k(data, "cancelled_orders", &[Value::from(vec![])]);
        let mut result: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_515: bool = true;
            while { if !__for_first_515 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_515 = false; i.as_f64().unwrap_or(f64::NAN) < ((cancelledOrders.len() as i64) as f64) } {
            let __ws_arg_16 = self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("status".to_string(), Value::Str("canceled".into()));
                m
            }), &[cancelledOrders.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null)]);
            append_to_array(&mut result, self.parse_order(__ws_arg_16, &[market.clone()]));
        }
        }
        return result;

    Value::Null
}

    pub async fn watch_execute_request(&mut self, mut requestIdString: Value, mut request: Value) -> Value {
        // the v2 gateway dispatches requests concurrently, so responses arrive
        // in completion order, not send order — every execute carries a unique
        // request id and its response is correlated by the echoed id
        if (requestIdString == Value::Null) {
            panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchExecuteRequest() requires requestIdString".into()))));
        }
        let mut url: Value = crate::value::get_value_k(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), "gateway");
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("execute:".into()), requestIdString).into());
        return self.watch(url, messageHash.clone(), &[request, messageHash.clone()]).await;

    Value::Null
}

    pub async fn watch_public(&mut self, mut streamType: Value, mut market: Value, mut messageHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), streamType.clone());
            m
        });
        if (market != Value::Null) {
            if let Value::Dict(__d) = &mut stream { std::sync::Arc::make_mut(__d).insert("product_id".into(), self.parse_to_int(crate::value::get_value_k(&market, "id"))); }
        }
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("method".to_string(), Value::Str("subscribe".into()));
                m.insert("stream".to_string(), self.deep_extend(stream, &[params]));
                m.insert("id".to_string(), self.request_id());
            m
        });
        let mut subscribeHash: Value = Value::Str(format!("{}{}", Value::Str("subscribe:".into()), json_stringify(&match &request { Value::Dict(__m15) => __m15.get("stream").cloned().unwrap_or(Value::Null), _ => Value::Null })).into());
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("streamType".to_string(), streamType);
                m.insert("symbol".to_string(), self.safe_string_k(market, "symbol", &[]));
            m
        });
        let mut client: Value = self.client(&[url.clone()]);
        let mut clientSubscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), subscribeHash.clone(), &[]);
        if (clientSubscription == Value::Null) {
            let mut id: Value = self.safe_string_k(request.clone(), "id", &[]);
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("subscribeHash".to_string(), subscribeHash.clone());
    m
}));
            self.watch_multiple(url.clone(), Value::from(vec![subscribeHash.clone()]), &[request, Value::from(vec![subscribeHash]), subscription]).await;
        }
        return self.watch(url, messageHash, &[]).await;

    Value::Null
}

    pub async fn watch_private(&mut self, mut streamType: Value, mut stream: Value, mut messageHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut clientSubscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), messageHash.clone(), &[]);
        if (clientSubscription != Value::Null) {
            return self.watch(url.clone(), messageHash.clone(), &[]).await;
        }
        let mut id: Value = self.request_id();
        let mut subscribeHash: Value = Value::Str(format!("{}{}", Value::Str("subscribe:".into()), messageHash).into());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("method".to_string(), Value::Str("subscribe".into()));
                m.insert("stream".to_string(), self.deep_extend(stream, &[params]));
                m.insert("id".to_string(), id.clone());
            m
        });
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("streamType".to_string(), streamType);
            m
        });
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("subscription:".into()), self.number_to_string(id)).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("subscribeHash".to_string(), subscribeHash.clone());
    m
}));
        self.watch_multiple(url.clone(), Value::from(vec![subscribeHash]), &[request, Value::from(vec![messageHash.clone()]), subscription]).await;
        return self.watch(url, messageHash, &[]).await;

    Value::Null
}

    pub async fn un_watch_private(&mut self, mut stream: Value, mut messageHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut id: Value = self.request_id();
        let mut unsubscribeHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe:".into()), messageHash).into());
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("method".to_string(), Value::Str("unsubscribe".into()));
                m.insert("stream".to_string(), self.deep_extend(stream, &[params]));
                m.insert("id".to_string(), id.clone());
            m
        });
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), id.clone());
                m.insert("messageHash".to_string(), messageHash.clone());
            m
        });
        let mut client: Value = self.client(&[url.clone()]);
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("unsubscription:".into()), self.number_to_string(id)).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("messageHash".to_string(), messageHash);
        m.insert("unsubscribeHash".to_string(), unsubscribeHash.clone());
    m
}));
        return self.watch(url, unsubscribeHash.clone(), &[request, unsubscribeHash.clone(), subscription]).await;

    Value::Null
}

    pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.check_required_credentials(&[]);
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut messageHash: Value = Value::Str("authenticated".into());
        let mut authenticated: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), messageHash.clone(), &[]);
        if (authenticated != Value::Null) {
            let mut future: Value = self.safe_value(get_value(&client, &Value::Str("futures".into())), messageHash.clone(), &[]);
            if (future != Value::Null) {
                return crate::exchange_stubs::ws_await_flight(&future).await;
            }
            return authenticated;
        }
        let mut recvWindow: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("authenticate".into()), Value::Str("recvWindow".into()), &[Value::Int(5000)]); recvWindow = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut subaccount: Value = Value::Null;
        { let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("authenticate".into()), Value::Str("subaccount".into()), &[Value::Str("default".into())]); subaccount = __destr_tmp.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null); params = __destr_tmp.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null); }
        let mut id: Value = self.request_id();
        let mut sender: Value = self.parent.create_subaccount(self.walletAddress.clone(), &[subaccount]);
        let mut expiration: Value = self.sum(&[self.milliseconds(), recvWindow]);
        let mut tx: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("sender".to_string(), sender);
                m.insert("expiration".to_string(), self.number_to_string(expiration));
            m
        });
        let mut contracts: Value = self.parent.query_contracts(&[]).await;
        let mut chainId: Value = self.safe_string_k(contracts.clone(), "chain_id", &[]);
        let mut endpointAddress: Value = self.safe_string_k(contracts, "endpoint_addr", &[]);
        if (endpointAddress == Value::Null) {
            panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" authenticate() requires endpoint_addr from contracts query".into()))));
        }
        let mut signature: Value = self.sign_stream_authentication(tx.clone(), chainId, endpointAddress).map(|__s| Value::Str(__s.into())).unwrap_or(Value::Null);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("method".to_string(), Value::Str("authenticate".into()));
                m.insert("id".to_string(), id.clone());
                m.insert("tx".to_string(), tx);
                m.insert("signature".to_string(), signature);
            m
        });
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("authentication:".into()), self.number_to_string(id)).into()), messageHash.clone());
        let __ws_arg_17 = self.extend(request, &[params]);
        return self.watch(url, messageHash.clone(), &[__ws_arg_17, messageHash.clone()]).await;

    Value::Null
}

    pub fn sign_stream_authentication(&self, mut tx: Value, mut chainId: Value, mut endpointAddress: Value) -> Option<String> {
        let mut domain: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("name".to_string(), Value::Str("Nado".into()));
                m.insert("version".to_string(), Value::Str("0.0.1".into()));
                m.insert("chainId".to_string(), chainId);
                m.insert("verifyingContract".to_string(), endpointAddress);
            m
        });
        let mut messageTypes: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("StreamAuthentication".to_string(), Value::from(vec![Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("name".to_string(), Value::Str("sender".into()));
        m.insert("type".to_string(), Value::Str("bytes32".into()));
    m
}), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("name".to_string(), Value::Str("expiration".into()));
        m.insert("type".to_string(), Value::Str("uint64".into()));
    m
})]));
            m
        });
        let mut encoded: Value = self.eth_encode_structured_data(domain, messageTypes, tx);
        let mut hash: Value = add(&Value::Str("0x".into()), &self.hash(encoded, Value::Str("keccak".into()), &[Value::Str("hex".into())]));
        return self.parent.sign_hash(hash, self.privateKey.clone()).as_str().map(str::to_owned);
}

    pub fn create_public_subscription_request(&self, mut method: Value, mut streamType: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        let mut id = 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 stream: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), streamType);
            m
        });
        if (market != Value::Null) {
            if let Value::Dict(__d) = &mut stream { std::sync::Arc::make_mut(__d).insert("product_id".into(), self.parse_to_int(market.as_map().and_then(|__m| __m.get("id")).cloned().unwrap_or(Value::Null))); }
        }
        return Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("method".to_string(), method);
        m.insert("stream".to_string(), self.deep_extend(stream, &[params]));
        m.insert("id".to_string(), id);
    m
});

    Value::Null
}

    pub async fn watch_public_multiple(&mut self, mut streamType: Value, mut markets: Value, mut messageHashes: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscriptionParams = get_arg(optional_args, 1, Value::Null);
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut client: Value = self.client(&[url.clone()]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_516: bool = true;
            while { if !__for_first_516 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_516 = false; i.as_f64().unwrap_or(f64::NAN) < ((messageHashes.len() as i64) as f64) } {
            let mut messageHash: Value = messageHashes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut clientSubscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), messageHash, &[]);
            if (clientSubscription == Value::Null) {
                let mut market: Value = markets.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
                let mut id: Value = self.request_id();
                let mut requestParams: Value = (if (subscriptionParams == Value::Null) { params.clone() } else { subscriptionParams.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null) });
                let mut request: Value = self.create_public_subscription_request(Value::Str("subscribe".into()), streamType.clone(), &[market.clone(), id.clone(), requestParams]);
                let mut subscribeHash: Value = Value::Str(format!("{}{}", Value::Str("subscribe:".into()), json_stringify(&request.as_map().and_then(|__m| __m.get("stream")).cloned().unwrap_or(Value::Null))).into());
                let mut streamSubscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), subscribeHash.clone(), &[]);
                if (streamSubscription == Value::Null) {
                    let mut subscription: Value = Value::Map({
                        let mut m = indexmap::IndexMap::new();
                            m.insert("streamType".to_string(), streamType.clone());
                            m.insert("symbol".to_string(), self.safe_string_k(market, "symbol", &[]));
                        m
                    });
                    add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("subscription:".into()), self.number_to_string(id)).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("subscribeHash".to_string(), subscribeHash.clone());
    m
}));
                    self.watch_multiple(url.clone(), Value::from(vec![subscribeHash.clone()]), &[request, Value::from(vec![subscribeHash]), subscription]).await;
                }
            }
        }
        }
        return self.watch_multiple(url, messageHashes.clone(), &[Value::Null, messageHashes.clone()]).await;

    Value::Null
}

    pub async fn un_watch_public(&mut self, mut streamType: Value, mut market: Value, mut messageHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut id: Value = self.request_id();
        let mut request: Value = self.create_public_subscription_request(Value::Str("unsubscribe".into()), streamType, &[market, id.clone(), params]);
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("id".to_string(), id.clone());
                m.insert("messageHash".to_string(), messageHash.clone());
            m
        });
        let mut unsubscribeHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe:".into()), messageHash).into());
        let mut client: Value = self.client(&[url.clone()]);
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("unsubscription:".into()), self.number_to_string(id)).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("messageHash".to_string(), messageHash);
        m.insert("unsubscribeHash".to_string(), unsubscribeHash.clone());
    m
}));
        return self.watch(url, unsubscribeHash.clone(), &[request, unsubscribeHash.clone(), subscription]).await;

    Value::Null
}

    pub async fn un_watch_public_multiple(&mut self, mut streamType: Value, mut markets: Value, mut messageHashes: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut subscriptionParams = get_arg(optional_args, 1, Value::Null);
        let mut url: Value = get_value(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("subscriptions".into()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut results: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_517: bool = true;
            while { if !__for_first_517 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_517 = false; i.as_f64().unwrap_or(f64::NAN) < ((messageHashes.len() as i64) as f64) } {
            let mut messageHash: Value = messageHashes.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut id: Value = self.request_id();
            let mut unsubscribeHash: Value = Value::Str(format!("{}{}", Value::Str("unsubscribe:".into()), messageHash).into());
            let mut requestParams: Value = (if (subscriptionParams == Value::Null) { params.clone() } else { subscriptionParams.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null) });
            let mut request: Value = self.create_public_subscription_request(Value::Str("unsubscribe".into()), streamType.clone(), &[markets.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null), id.clone(), requestParams]);
            let mut subscription: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("id".to_string(), id.clone());
                    m.insert("messageHash".to_string(), messageHash.clone());
                m
            });
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("unsubscription:".into()), self.number_to_string(id)).into()), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("messageHash".to_string(), messageHash);
        m.insert("unsubscribeHash".to_string(), unsubscribeHash.clone());
    m
}));
            append_to_array(&mut results, self.watch_multiple(url.clone(), Value::from(vec![unsubscribeHash.clone()]), &[request, Value::from(vec![unsubscribeHash]), subscription]).await);
        }
        }
        return results;

    Value::Null
}

    pub fn parse_ws_timestamp(&self, mut message: Value, mut key: Value) -> Value {
        let mut value: Value = self.safe_string(message.clone(), key.clone(), &[]);
        if (value == Value::Null) {
            return Value::Null;
        }
        // keep the string-size reads inline: assigning the size to a standalone
        // local is the regex transpiler's ARRAY hint and would emit php count()
        // on a string, breaking every ws parser with a TypeError
        if ((value.len() as i64) as f64) > ((13i64) as f64) {
            return self.parse_to_int(slice(&value, &Value::Int(0), &(match (&(Value::Int(value.len() as i64)), &(Value::Int(6))) { (Value::Int(x), Value::Int(y)) => Value::Int(x - y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 - *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x - *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x - y), _ => Value::Null })));
        }
        return self.safe_integer(message, key, &[]);

    Value::Null
}

    pub fn parse_ws_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "trade",
        //         "timestamp": "1676151190656903000",
        //         "product_id": 1,
        //         "price": "25000000000000000000000",
        //         "taker_qty": "1000000000000000000",
        //         "maker_qty": "1000000000000000000",
        //         "is_taker_buyer": true
        //     }
        //
        let mut marketId: Value = self.safe_string_k(trade.clone(), "product_id", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut timestamp: Value = self.parse_ws_timestamp(trade.clone(), Value::Str("timestamp".into()));
        let mut isTakerBuyer: Value = self.safe_bool_k(trade.clone(), "is_taker_buyer", &[]);
        let mut side: Value = Value::Null;
        if (isTakerBuyer != Value::Null) {
            side = (if isTakerBuyer.as_bool() == Some(true) { Value::Str("buy".into()) } else { Value::Str("sell".into()) });
        }
        return self.safe_trade(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), trade.clone());
        m.insert("id".to_string(), Value::Null);
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("order".to_string(), Value::Null);
        m.insert("type".to_string(), Value::Null);
        m.insert("side".to_string(), side);
        m.insert("takerOrMaker".to_string(), Value::Str("taker".into()));
        m.insert("price".to_string(), self.parent.parse_x18(self.safe_string_k(trade.clone(), "price", &[])));
        m.insert("amount".to_string(), self.parent.parse_x18(self.safe_string_k(trade, "taker_qty", &[])));
        m.insert("cost".to_string(), Value::Null);
        m.insert("fee".to_string(), Value::Null);
    m
}), &[market]);

    Value::Null
}

    pub fn parse_ws_my_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "fill",
        //         "timestamp": "1695081920633151000",
        //         "product_id": 1,
        //         "subaccount": "0x...",
        //         "order_digest": "0x...",
        //         "appendix": "1",
        //         "filled_qty": "18000000000000000",
        //         "remaining_qty": "82000000000000000",
        //         "original_qty": "100000000000000000",
        //         "price": "25000000000000000000000",
        //         "is_taker": true,
        //         "is_bid": true,
        //         "fee": "4500000000000000",
        //         "submission_idx": 1,
        //         "id": 100
        //     }
        //
        let mut marketId: Value = self.safe_string_k(trade.clone(), "product_id", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut timestamp: Value = self.parse_ws_timestamp(trade.clone(), Value::Str("timestamp".into()));
        let mut isBid: Value = self.safe_bool_k(trade.clone(), "is_bid", &[]);
        let mut side: Value = Value::Null;
        if (isBid != Value::Null) {
            side = (if isBid.as_bool() == Some(true) { Value::Str("buy".into()) } else { Value::Str("sell".into()) });
        }
        let mut isTaker: Value = self.safe_bool_k(trade.clone(), "is_taker", &[]);
        let mut takerOrMaker: Value = Value::Null;
        if (isTaker != Value::Null) {
            takerOrMaker = (if isTaker.as_bool() == Some(true) { Value::Str("taker".into()) } else { Value::Str("maker".into()) });
        }
        let mut feeCost: Value = self.parent.parse_x18(self.safe_string_k(trade.clone(), "fee", &[]));
        let mut fee: Value = Value::Null;
        if (feeCost != Value::Null) {
            fee = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("cost".to_string(), feeCost);
                    m.insert("currency".to_string(), market.as_map().and_then(|__m| __m.get("quote")).cloned().unwrap_or(Value::Null));
                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_string2(trade.clone(), Value::Str("id".into()), Value::Str("submission_idx".into()), &[]));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("order".to_string(), self.safe_string_k(trade.clone(), "order_digest", &[]));
        m.insert("type".to_string(), Value::Null);
        m.insert("side".to_string(), side);
        m.insert("takerOrMaker".to_string(), takerOrMaker);
        m.insert("price".to_string(), self.parent.parse_x18(self.safe_string_k(trade.clone(), "price", &[])));
        m.insert("amount".to_string(), self.parent.parse_x18(self.safe_string_k(trade, "filled_qty", &[])));
        m.insert("cost".to_string(), Value::Null);
        m.insert("fee".to_string(), fee);
    m
}), &[market]);

    Value::Null
}

    pub fn handle_trade(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut marketId: Value = (match __pro_message.get("product_id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut market: Value = self.safe_market(&[marketId]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trade:".into()), symbol).into());
        let mut trades: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if (trades == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            trades = ArrayCache::new(limit);
            if let Value::Dict(__d) = &mut self.trades { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), trades.clone()); }
        }
        let mut trade: Value = self.parse_ws_trade(message, &[market]);
        trades.append(trade);
        client.resolve(&[trades, messageHash]);
}

    pub fn handle_my_trade(&mut self, mut client: Value, mut message: Value) {
        let mut trade: Value = self.parse_ws_my_trade(message, &[]);
        if (self.myTrades.clone() == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            self.myTrades = ArrayCacheBySymbolById::new(limit);
        }
        let mut trades: Value = self.myTrades.clone();
        trades.append(trade.clone());
        let mut symbol: Value = trade.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        client.resolve(&[trades.clone(), Value::Str("myTrades".into())]);
        client.resolve(&[trades, Value::Str(format!("{}{}", Value::Str("myTrades:".into()), symbol).into())]);
}

    pub fn handle_ohlcv(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "type": "latest_candlestick",
        //         "timestamp": "1782179760",
        //         "product_id": 2,
        //         "granularity": 60,
        //         "open_x18": "64148000000000000000000",
        //         "high_x18": "64148000000000000000000",
        //         "low_x18": "64148000000000000000000",
        //         "close_x18": "64148000000000000000000",
        //         "volume": "24250000000000000"
        //     }
        //
        let mut marketId: Value = (match __pro_message.get("product_id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut market: Value = self.safe_market(&[marketId]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        let mut granularity: Value = (match __pro_message.get("granularity").cloned() { Some(Value::Int(__n)) => Value::Int(__n), Some(Value::Float(__f)) => Value::Int(__f as i64), Some(Value::Str(__s)) if !__s.is_empty() => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
        let mut timeframe: Value = self.find_timeframe(granularity, &[]);
        if (timeframe == Value::Null) {
            return;
        }
        if !(in_op(&self.ohlcvs, &symbol)) {
            if let Value::Dict(__d) = &mut self.ohlcvs { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})); }
        }
        let mut stored: Value = self.safe_value(get_value(&self.ohlcvs, &symbol), timeframe.clone(), &[]);
        if (stored == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "OHLCVLimit", &[Value::Int(1000)]);
            stored = ArrayCacheByTimestamp::new(limit);
            add_element_to_object(get_value_mut(&mut self.ohlcvs, &symbol), &timeframe, stored.clone());
        }
        let mut parsed: Value = self.parse_ohlcv(message, &[market]);
        stored.append(parsed);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("ohlcv:".into()), timeframe).into()), Value::Str(":".into())).into()), symbol).into());
        client.resolve(&[Value::from(vec![symbol, timeframe, stored]), messageHash]);
}

    pub fn parse_ws_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "order_update",
        //         "timestamp": "1695081920633151000",
        //         "product_id": 1,
        //         "digest": "0xf7712b63ccf70358db8f201e9bf33977423e7a63f6a16f6dab180bdd580f7c6c",
        //         "amount": "82000000000000000",
        //         "reason": "filled",
        //         "filled_qty": "18000000000000000",
        //         "filled_price": "25000000000000000000000",
        //         "id": 100
        //     }
        //
        let mut marketId: Value = self.safe_string_k(order.clone(), "product_id", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut timestamp: Value = self.parse_ws_timestamp(order.clone(), Value::Str("timestamp".into()));
        let mut id: Value = self.safe_string_k(order.clone(), "digest", &[]);
        let mut amountString: Value = self.safe_string_k(order.clone(), "amount", &[]);
        let mut remaining: Value = Value::Null;
        if (amountString != Value::Null) {
            remaining = self.parent.parse_x18(amountString.clone());
        }
        let mut filled: Value = self.parent.parse_x18(self.safe_string_k(order.clone(), "filled_qty", &[]));
        let mut average: Value = self.parent.parse_x18(self.safe_string_k(order.clone(), "filled_price", &[]));
        let mut reason: Option<String> = self.safe_string_k(order.clone(), "reason", &[]).as_str().map(str::to_owned);
        let mut status: Value = Value::Null;
        if (reason.as_deref() == Some("placed")) {
            status = Value::Str("open".into());
        }  else if (reason.as_deref() == Some("filled")) {
            status = Value::Str("open".into());
            if (amountString != Value::Null) && is_true(&crate::precise::Precise::stringEq(&amountString, &Value::Str("0".into()))) {
                status = Value::Str("closed".into());
            }
        }  else if (reason.as_deref() == Some("cancelled")) {
            status = Value::Str("canceled".into());
        }
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order);
        m.insert("id".to_string(), id);
        m.insert("clientOrderId".to_string(), Value::Null);
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("lastTradeTimestamp".to_string(), (if (filled == Value::Null) { Value::Null } else { timestamp.clone() }));
        m.insert("lastUpdateTimestamp".to_string(), timestamp);
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("type".to_string(), Value::Null);
        m.insert("timeInForce".to_string(), Value::Null);
        m.insert("postOnly".to_string(), Value::Null);
        m.insert("side".to_string(), Value::Null);
        m.insert("price".to_string(), Value::Null);
        m.insert("stopPrice".to_string(), Value::Null);
        m.insert("triggerPrice".to_string(), Value::Null);
        m.insert("amount".to_string(), Value::Null);
        m.insert("cost".to_string(), Value::Null);
        m.insert("average".to_string(), average);
        m.insert("filled".to_string(), filled);
        m.insert("remaining".to_string(), remaining);
        m.insert("status".to_string(), status);
        m.insert("fee".to_string(), Value::Null);
        m.insert("trades".to_string(), Value::Null);
    m
}), &[market]);

    Value::Null
}

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        let mut order: Value = self.parse_ws_order(message, &[]);
        if (self.orders.clone() == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
            self.orders = ArrayCacheBySymbolById::new(limit);
        }
        let mut orders: Value = self.orders.clone();
        orders.append(order.clone());
        let mut symbol: Value = order.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        client.resolve(&[orders.clone(), Value::Str("orders".into())]);
        client.resolve(&[orders, Value::Str(format!("{}{}", Value::Str("orders:".into()), symbol).into())]);
}

    pub fn parse_ws_position(&self, mut position: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "position_change",
        //         "timestamp": "1695081920633151000",
        //         "product_id": 2,
        //         "subaccount": "0x15f43d1f2dee81424afd891943262aa90f22cc2a64656661756c740000000000",
        //         "isolated": false,
        //         "amount": "100000000000000000",
        //         "v_quote_amount": "-3033500000000000000000",
        //         "reason": "match_orders"
        //     }
        //
        let mut marketId: Value = self.safe_string_k(position.clone(), "product_id", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut timestamp: Value = self.parse_ws_timestamp(position.clone(), Value::Str("timestamp".into()));
        let mut amountString: Value = self.safe_string_k(position.clone(), "amount", &[]);
        let mut vQuoteAmount: Value = self.safe_string_k(position.clone(), "v_quote_amount", &[]);
        let mut side: Value = Value::Null;
        let mut contracts: Value = Value::Null;
        let mut entryPrice: Value = Value::Null;
        if (amountString != Value::Null) {
            if is_true(&crate::precise::Precise::stringGt(&amountString, &Value::Str("0".into()))) {
                side = Value::Str("long".into());
            }  else if is_true(&crate::precise::Precise::stringLt(&amountString, &Value::Str("0".into()))) {
                side = Value::Str("short".into());
            }
            let mut absoluteAmount: Value = crate::precise::Precise::stringAbs(&amountString);
            contracts = self.parent.parse_x18(absoluteAmount.clone());
            if (vQuoteAmount != Value::Null) && !is_true(&crate::precise::Precise::stringEquals(&absoluteAmount, &Value::Str("0".into()))) {
                entryPrice = self.parse_number(crate::precise::Precise::stringDiv(&crate::precise::Precise::stringAbs(&vQuoteAmount), &absoluteAmount), &[]);
            }
        }
        return self.safe_position(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), position.clone());
        m.insert("id".to_string(), Value::Null);
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("isolated".to_string(), self.safe_bool_k(position, "isolated", &[]));
        m.insert("hedged".to_string(), Value::Bool(false));
        m.insert("side".to_string(), side);
        m.insert("contracts".to_string(), contracts);
        m.insert("contractSize".to_string(), self.safe_number_k(market, "contractSize", &[]));
        m.insert("entryPrice".to_string(), entryPrice);
        m.insert("markPrice".to_string(), Value::Null);
        m.insert("notional".to_string(), Value::Null);
        m.insert("leverage".to_string(), Value::Null);
        m.insert("collateral".to_string(), Value::Null);
        m.insert("initialMargin".to_string(), Value::Null);
        m.insert("initialMarginPercentage".to_string(), Value::Null);
        m.insert("maintenanceMargin".to_string(), Value::Null);
        m.insert("maintenanceMarginPercentage".to_string(), Value::Null);
        m.insert("unrealizedPnl".to_string(), Value::Null);
        m.insert("liquidationPrice".to_string(), Value::Null);
        m.insert("marginMode".to_string(), Value::Null);
        m.insert("marginRatio".to_string(), Value::Null);
        m.insert("percentage".to_string(), Value::Null);
    m
}));

    Value::Null
}

    pub fn handle_position(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut marketId: Value = (match __pro_message.get("product_id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut market: Value = self.safe_market(&[marketId]);
        if !matches!(self.safe_bool_k(market.clone(), "contract", &[Value::Bool(false)]), Value::Bool(true)) {
            return;
        }
        let mut position: Value = self.parse_ws_position(message, &[market]);
        if (self.positions.clone() == Value::Null) {
            self.positions = ArrayCacheBySymbolBySide::new(Value::Null);
        }
        let mut positions: Value = self.positions.clone();
        let mut side: Option<String> = self.safe_string_k(position.clone(), "side", &[]).as_str().map(str::to_owned);
        if (side.is_none()) {
            let mut longPosition: Value = self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            }), &[position.clone()]);
            add_element_to_object(&mut longPosition, &Value::Str("side".into()), Value::Str("long".into()));
            positions.append(longPosition);
            let mut shortPosition: Value = self.extend(Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            }), &[position.clone()]);
            add_element_to_object(&mut shortPosition, &Value::Str("side".into()), Value::Str("short".into()));
            positions.append(shortPosition);
        }  else {
            positions.append(position.clone());
        }
        let mut symbol: Value = position.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        client.resolve(&[positions.clone(), Value::Str("positions".into())]);
        client.resolve(&[positions, Value::Str(format!("{}{}", Value::Str("positions:".into()), symbol).into())]);
}

    pub fn parse_ws_bid_ask(&self, mut bidask: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "best_bid_offer",
        //         "timestamp": "1676151190656903000",
        //         "product_id": 1,
        //         "bid_price": "24990000000000000000000",
        //         "bid_qty": "5000000000000000000",
        //         "ask_price": "25010000000000000000000",
        //         "ask_qty": "3000000000000000000"
        //     }
        //
        let mut marketId: Value = self.safe_string_k(bidask.clone(), "product_id", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut timestamp: Value = self.parse_ws_timestamp(bidask.clone(), Value::Str("timestamp".into()));
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("ask".to_string(), self.parent.parse_x18(self.safe_string_k(bidask.clone(), "ask_price", &[])));
        m.insert("askVolume".to_string(), self.parent.parse_x18(self.safe_string_k(bidask.clone(), "ask_qty", &[])));
        m.insert("bid".to_string(), self.parent.parse_x18(self.safe_string_k(bidask.clone(), "bid_price", &[])));
        m.insert("bidVolume".to_string(), self.parent.parse_x18(self.safe_string_k(bidask.clone(), "bid_qty", &[])));
        m.insert("info".to_string(), bidask);
    m
}), &[market]);

    Value::Null
}

    pub fn handle_bid_ask(&mut self, mut client: Value, mut message: Value) {
        let mut ticker: Value = self.parse_ws_bid_ask(message, &[]);
        let mut symbol: Value = self.safe_string_k(ticker.clone(), "symbol", &[]);
        if (symbol == Value::Null) {
            return;
        }
        if let Value::Dict(__d) = &mut self.bidsasks { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
        if let Value::Dict(__d) = &mut self.tickers { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
        let mut tickers: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if let Value::Dict(__d) = &mut tickers { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
        client.resolve(&[ticker.clone(), Value::Str(format!("{}{}", Value::Str("bidask:".into()), symbol).into())]);
        client.resolve(&[ticker, Value::Str(format!("{}{}", Value::Str("ticker:".into()), symbol).into())]);
        client.resolve(&[tickers.clone(), Value::Str("bidask".into())]);
        client.resolve(&[tickers, Value::Str("ticker".into())]);
}

    pub fn parse_ws_all_bids_asks(&self, mut message: Value) -> Value {
        let __message_empty = indexmap::IndexMap::new();
        let message = message.as_map().unwrap_or(&__message_empty);
        //
        //     {
        //         "type": "all_bbo",
        //         "time": "1781750134714",
        //         "bbos": {
        //             "2": { "bid": "64924000000000000000000", "ask": "64935000000000000000000" }
        //         }
        //     }
        //
        let mut timestamp: Value = (match message.get("time") { Some(Value::Int(__n)) => Value::Int(*__n), Some(Value::Float(__f)) => Value::Int(*__f as i64), Some(Value::Str(__s)) => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
        let mut bbos: Value = (match message.get("bbos") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        let mut marketIds: Value = object_keys(&bbos);
        let mut result: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_518: bool = true;
            while { if !__for_first_518 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_518 = false; i.as_f64().unwrap_or(f64::NAN) < ((marketIds.len() as i64) as f64) } {
            let mut marketId: Value = marketIds.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut market: Value = self.safe_market(&[marketId.clone()]);
            let mut bbo: Value = self.safe_dict(bbos.clone(), marketId, &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut bid: Value = self.safe_string_k(bbo.clone(), "bid", &[]);
            let mut ask: Value = self.safe_string_k(bbo.clone(), "ask", &[]);
            let mut maxPrice: Value = Value::Str("170141183460469231731687303715884105727".into());
            if is_true(&crate::precise::Precise::stringGt(&bid, &Value::Str("0".into()))) && is_true(&crate::precise::Precise::stringGt(&ask, &Value::Str("0".into()))) && !is_true(&crate::precise::Precise::stringEquals(&bid, &maxPrice)) && !is_true(&crate::precise::Precise::stringEquals(&ask, &maxPrice)) {
                let mut ticker: Value = self.safe_ticker(Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
                        m.insert("timestamp".to_string(), timestamp.clone());
                        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
                        m.insert("ask".to_string(), self.parent.parse_x18(ask.clone()));
                        m.insert("bid".to_string(), self.parent.parse_x18(bid.clone()));
                        m.insert("info".to_string(), bbo);
                    m
                }), &[market.clone()]);
                let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
                if let Value::Dict(__d) = &mut result { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker); }
            }
        }
        }
        return result;

    Value::Null
}

    pub fn handle_all_bids_asks(&mut self, mut client: Value, mut message: Value) {
        let mut tickers: Value = self.parse_ws_all_bids_asks(message);
        let mut symbols: Value = object_keys(&tickers);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_519: bool = true;
            while { if !__for_first_519 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_519 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut symbol: Value = symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut ticker: Value = get_value(&tickers, &symbol);
            let mut ticker: Value = get_value(&tickers, &symbol);
            if let Value::Dict(__d) = &mut self.bidsasks { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
            if let Value::Dict(__d) = &mut self.tickers { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
            client.resolve(&[ticker.clone(), Value::Str(format!("{}{}", Value::Str("bidask:".into()), symbol).into())]);
            client.resolve(&[ticker, Value::Str(format!("{}{}", Value::Str("ticker:".into()), symbol).into())]);
        }
        }
        client.resolve(&[tickers.clone(), Value::Str("bidask".into())]);
        client.resolve(&[tickers, Value::Str("ticker".into())]);
}

    pub fn handle_delta(&self, mut bookside: Value, mut delta: Value) {
        let mut bidAsk: Value = Value::from(vec![self.parent.parse_x18(self.safe_string(delta.clone(), Value::Int(0), &[])), self.parent.parse_x18(self.safe_string(delta, Value::Int(1), &[]))]);
        bookside.store_array(bidAsk);
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "type": "book_depth",
        //         "min_timestamp": "1683805381879572835",
        //         "max_timestamp": "1683805381879572835",
        //         "last_max_timestamp": "1683805381771464799",
        //         "product_id": 1,
        //         "bids": [["21594490000000000000000", "51007390115411548"]],
        //         "asks": [["21694490000000000000000", "0"]]
        //     }
        //
        let mut marketId: Value = (match __pro_message.get("product_id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut market: Value = self.safe_market(&[marketId]);
        let mut symbol: Value = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        if !(in_op(&self.orderbooks, &symbol)) {
            return;
        }
        let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("orderbook:".into()), symbol).into());
        let mut maxTimestamp: Value = self.safe_string_k(orderbook.clone(), "maxTimestamp", &[]);
        let mut lastMaxTimestamp: Value = (match __pro_message.get("last_max_timestamp").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        if (maxTimestamp != Value::Null) && (lastMaxTimestamp != Value::Null) && (maxTimestamp.as_str() != lastMaxTimestamp.as_str()) {
            let mut subscriptions: Value = object_keys(&get_value(&client, &Value::Str("subscriptions".into())));
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_520: bool = true;
                while { if !__for_first_520 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_520 = false; i.as_f64().unwrap_or(f64::NAN) < ((subscriptions.len() as i64) as f64) } {
                let mut subscriptionHash: Value = subscriptions.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
                let mut subscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".into())), subscriptionHash.clone(), &[]);
                let mut streamType: Option<String> = self.safe_string_k(subscription.clone(), "streamType", &[]).as_str().map(str::to_owned);
                let mut subscriptionSymbol: Value = self.safe_string_k(subscription, "symbol", &[]);
                if (streamType.as_deref() == Some("book_depth")) && (subscriptionSymbol.as_str() == symbol.as_str()) {
                    remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &subscriptionHash);
                }
            }
            }
            let mut subscriptionMsg: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), messageHash.clone(), &[]);
            if (subscriptionMsg != Value::Null) {
                remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &messageHash);
            }
            remove(&mut self.orderbooks, &symbol);
            let mut error = Value::from(crate::exchange_errors::invalid_nonce(format!("{}{}", self.id.clone(), Value::Str(" watchOrderBook received invalid nonce".into()))));
            client.reject(&[Value::from(error), messageHash.clone()]);
            return;
        }
        let mut asks: Value = (match __pro_message.get("asks").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        let mut bids: Value = (match __pro_message.get("bids").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        self.handle_deltas(get_value(&orderbook, &Value::Str("asks".into())), asks);
        self.handle_deltas(get_value(&orderbook, &Value::Str("bids".into())), bids);
        let mut timestamp: Value = self.parse_ws_timestamp(message, Value::Str("max_timestamp".into()));
        add_element_to_object(&mut orderbook, &Value::Str("symbol".into()), symbol);
        add_element_to_object(&mut orderbook, &Value::Str("timestamp".into()), timestamp.clone());
        add_element_to_object(&mut orderbook, &Value::Str("datetime".into()), self.iso8601(timestamp));
        add_element_to_object(&mut orderbook, &Value::Str("maxTimestamp".into()), (match __pro_message.get("max_timestamp").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }));
        client.resolve(&[orderbook, messageHash]);
}

    pub fn handle_execute_response(&self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "status": "success",
        //         "signature": "0x...",
        //         "data": {
        //             "digest": "0x..."
        //         },
        //         "request_type": "execute_place_order",
        //         "id": 100
        //     }
        //
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        if (id == Value::Null) {
            return;
        }
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("execute:".into()), id).into());
        let mut subscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), messageHash.clone(), &[]);
        if (subscription != Value::Null) {
            remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &messageHash);
        }
        client.resolve(&[message, messageHash]);
}

    pub fn handle_subscription(&self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut subscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()), &[]);
        if (subscription != Value::Null) {
            let mut subscribeHash: Value = self.safe_string_k(subscription, "subscribeHash", &[]);
            remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()));
            client.resolve(&[message, subscribeHash]);
        }
}

    pub fn handle_authentication(&self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut messageHash: Value = self.safe_string(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("authentication:".into()), id).into()), &[]);
        if (messageHash != Value::Null) {
            remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("authentication:".into()), id).into()));
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &messageHash, Value::Bool(true));
            client.resolve(&[message, messageHash]);
        }
}

    pub fn handle_unsubscription(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut unsubscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("unsubscription:".into()), id).into()), &[]);
        if (unsubscription != Value::Null) {
            let mut messageHash: Value = self.safe_string_k(unsubscription.clone(), "messageHash", &[]);
            let mut unsubscribeHash: Value = self.safe_string_k(unsubscription, "unsubscribeHash", &[]);
            remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("unsubscription:".into()), id).into()));
            if (messageHash != Value::Null) {
                self.clean_unsubscription(client.clone(), messageHash.clone(), unsubscribeHash.clone(), &[]);
                self.handle_unsubscription_cache(messageHash.clone());
            }
            client.resolve(&[message.clone(), unsubscribeHash.clone()]);
            return;
        }
        let mut subscriptions: Value = object_keys(&get_value(&client, &Value::Str("subscriptions".into())));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_521: bool = true;
            while { if !__for_first_521 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_521 = false; i.as_f64().unwrap_or(f64::NAN) < ((subscriptions.len() as i64) as f64) } {
            let mut unsubscribeHash: Value = subscriptions.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut subscription: Value = get_value(&get_value(&client, &Value::Str("subscriptions".into())), &unsubscribeHash);
            let mut subscriptionId: Value = self.safe_string_k(subscription.clone(), "id", &[]);
            if (subscriptionId.as_str() != id.as_str()) {
                continue;
            }
            let mut messageHash: Value = self.safe_string_k(subscription, "messageHash", &[]);
            if (messageHash != Value::Null) {
                self.clean_unsubscription(client.clone(), messageHash.clone(), unsubscribeHash.clone(), &[]);
                self.handle_unsubscription_cache(messageHash);
            }
            client.resolve(&[message.clone(), unsubscribeHash]);
            return;
        }
        }
}

    pub fn handle_unsubscription_cache(&mut self, mut messageHash: Value) {
        if (messageHash == Value::Null) {
            return;
        }
        if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("trade:")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            let mut symbol: Value = replace_str(&messageHash, &Value::Str("trade:".into()), &Value::Str("".into()));
            if (in_op(&self.trades, &symbol)) {
                remove(&mut self.trades, &symbol);
            }
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("orderbook:")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            let mut symbol: Value = replace_str(&messageHash, &Value::Str("orderbook:".into()), &Value::Str("".into()));
            if (in_op(&self.orderbooks, &symbol)) {
                remove(&mut self.orderbooks, &symbol);
            }
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("ohlcv:")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            let mut parts: Value = split(&messageHash, &Value::Str(":".into()));
            let mut timeframe: Value = self.safe_string(parts.clone(), Value::Int(1), &[]);
            let mut symbol: Value = self.safe_string(parts, Value::Int(2), &[]);
            if (symbol != Value::Null) && (timeframe != Value::Null) && (in_op(&self.ohlcvs, &symbol)) && (in_op(&get_value(&self.ohlcvs, &symbol), &timeframe)) {
                remove(&mut get_value(&self.ohlcvs, &symbol), &timeframe);
            }
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("ticker:")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            let mut symbol: Value = replace_str(&messageHash, &Value::Str("ticker:".into()), &Value::Str("".into()));
            if (in_op(&self.tickers, &symbol)) {
                remove(&mut self.tickers, &symbol);
            }
        }  else if (messageHash.as_str() == Some("ticker")) {
            let mut symbols: Value = object_keys(&self.tickers);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_522: bool = true;
                while { if !__for_first_522 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_522 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
                remove(&mut self.tickers, &symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
            }
            }
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("bidask:")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            let mut symbol: Value = replace_str(&messageHash, &Value::Str("bidask:".into()), &Value::Str("".into()));
            if (in_op(&self.bidsasks, &symbol)) {
                remove(&mut self.bidsasks, &symbol);
            }
        }  else if (messageHash.as_str() == Some("bidask")) {
            let mut symbols: Value = object_keys(&self.bidsasks);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_523: bool = true;
                while { if !__for_first_523 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_523 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
                remove(&mut self.bidsasks, &symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
            }
            }
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("orders")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            self.orders = Value::Null;
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("myTrades")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            self.myTrades = Value::Null;
        }  else if (Value::Int(messageHash.as_str().and_then(|__s| __s.find("positions")).map(|__i| __i as i64).unwrap_or(-1)).as_f64() == Some(0.0)) {
            self.positions = Value::Null;
        }
}

    pub fn ping(&mut self, mut client: Value) -> Value {
        let mut gatewayUrl: Value = crate::value::get_value_k(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), "gateway");
        if is_equal(&client.as_map().and_then(|__m| __m.get("url")).cloned().unwrap_or(Value::Null), &gatewayUrl) {
            return Value::Null;
        }
        return Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("method".to_string(), Value::Str("ping".into()));
        m.insert("id".to_string(), self.request_id());
        m.insert("client_time".to_string(), self.number_to_string(self.milliseconds()));
    m
});

    Value::Null
}

    pub fn handle_pong(&self, mut client: Value, mut message: Value) -> Value {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        //     {
        //         "result": {
        //             "method": "pong",
        //             "server_time": "1780000000123",
        //             "client_time": "1780000000000"
        //         },
        //         "id": 10
        //     }
        //
        let mut result: Value = (match __pro_message.get("result").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) });
        let __ws_arg_18 = self.milliseconds();
        crate::set_value(&mut client, &Value::Str("lastPong".into()), self.safe_integer_k(result, "server_time", &[__ws_arg_18]));
        return message;

    Value::Null
}

    pub fn handle_error_message(&self, mut client: Value, mut message: Value) -> Value {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut error: Value = (match __pro_message.get("error").cloned() { Some(Value::Str(__s)) if __s.is_empty() => Value::Null, Some(__v) => __v, None => Value::Null });
        let mut status: Option<String> = (match __pro_message.get("status").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }).as_str().map(str::to_owned);
        if (error == Value::Null) && (status.as_deref() != Some("failure")) {
            return Value::Bool(false);
        }
        let mut feedback = Value::from(crate::exchange_errors::exchange_error(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" ".into())).into()), json_stringify(&message))));
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        if (id != Value::Null) {
            let mut executeHash: Value = Value::Str(format!("{}{}", Value::Str("execute:".into()), id).into());
            let mut executeSubscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".into())), executeHash.clone(), &[]);
            if (executeSubscription != Value::Null) {
                remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &executeHash);
                client.reject(&[feedback.clone(), executeHash]);
                return Value::Bool(true);
            }
        }
        let mut subscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()), &[]);
        if (subscription != Value::Null) {
            let mut subscribeHash: Value = self.safe_string_k(subscription, "subscribeHash", &[]);
            remove(&mut get_value(&client, &Value::Str("subscriptions".into())), &Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()));
            client.reject(&[feedback.clone(), subscribeHash]);
        }  else {
            client.reject(&[feedback]);
        }
        return Value::Bool(true);

    Value::Null
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        if (self.handle_error_message(client.clone(), message.clone()).as_bool() == Some(true)) {
            return;
        }
        let mut id: Value = (match __pro_message.get("id").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut hasResult: bool = matches!(&message, Value::Dict(__d) if __d.contains_key("result"));
        let mut result: Value = (match __pro_message.get("result").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Null });
        let mut method: Option<String> = self.safe_string_k(result.clone(), "method", &[]).as_str().map(str::to_owned);
        if (method.as_deref() == Some("pong")) {
            // pong replies carry both 'id' and 'result' so they must be routed
            // before the subscription-ack branch below swallows them
            self.handle_pong(client.clone(), message.clone());
            return;
        }
        let mut requestType: Option<String> = (match __pro_message.get("request_type").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }).as_str().map(str::to_owned);
        if (requestType.is_some()) {
            // v2 gateway execute responses carry 'request_type' and the echoed request id
            self.handle_execute_response(client.clone(), message.clone());
            return;
        }
        if (id != Value::Null) && hasResult {
            let mut authentication: Option<String> = self.safe_string(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("authentication:".into()), id).into()), &[]).as_str().map(str::to_owned);
            if (authentication.is_some()) {
                self.handle_authentication(client.clone(), message.clone());
                return;
            }
            let mut subscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".into())), Value::Str(format!("{}{}", Value::Str("subscription:".into()), id).into()), &[]);
            if (subscription != Value::Null) {
                self.handle_subscription(client.clone(), message.clone());
                return;
            }
            if (result == Value::Null) {
                self.handle_unsubscription(client.clone(), message.clone());
                return;
            }
            self.handle_subscription(client.clone(), message.clone());
            return;
        }
        let mut type_var: Value = (match __pro_message.get("type").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut methods: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("trade".to_string(), Value::Str("handle_trade".into()).clone());
                m.insert("all_bbo".to_string(), Value::Str("handle_all_bids_asks".into()).clone());
                m.insert("best_bid_offer".to_string(), Value::Str("handle_bid_ask".into()).clone());
                m.insert("book_depth".to_string(), Value::Str("handle_order_book".into()).clone());
                m.insert("fill".to_string(), Value::Str("handle_my_trade".into()).clone());
                m.insert("latest_candlestick".to_string(), Value::Str("handle_ohlcv".into()).clone());
                m.insert("order_update".to_string(), Value::Str("handle_order".into()).clone());
                m.insert("position_change".to_string(), Value::Str("handle_position".into()).clone());
            m
        });
        let mut handler: Value = self.safe_value(methods, type_var, &[]);
        if (handler != Value::Null) {
            self.dispatch_ws_handler(&handler, &[client, message]);
        }
}
}