ccxt-pro 4.5.78

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

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


pub struct BitfinexCore {
    pub parent: crate::exchanges::bitfinex::BitfinexCore,
}

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

    pub fn init(&mut self) {
        let described = BitfinexCore::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 BitfinexCore {
    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 BitfinexCore {
    fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
        -> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
    {
        Box::pin(async move {
            match method {
                "authenticate" => self.authenticate(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
                "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_system_status" => self.handle_system_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_unsubscription_status" => self.handle_unsubscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_balance" => self.parse_ws_balance(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
                "subscribe" => self.subscribe(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args.get(2..).unwrap_or(&[]).to_vec()[..]).await,
                "subscribe_private" => self.subscribe_private(args.get(0).cloned().unwrap_or(crate::Value::Null)).await,
                "un_subscribe" => self.un_subscribe(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), &args.get(3..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_ohlcv" => self.un_watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_ticker" => self.un_watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_trades" => self.un_watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_balance" => self.watch_balance(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_my_trades" => self.watch_my_trades(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_ohlcv" => self.watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_orders" => self.watch_orders(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                // Go-style inheritance: an un-overridden method dispatches to the parent core.
                _ => crate::exchange_generated::ExchangeBase::call_dynamic(&mut self.parent, method, args).await,
            }
        })
    }
}
impl BitfinexCore {
    /// Synchronous WS handler dispatch — routes a handler-name string (from the
    /// venue's handle_message dispatch table) to the real handler method.
    #[allow(dead_code, unreachable_patterns, clippy::all)]
    pub fn dispatch_ws_handler(&mut self, __name: &crate::Value, args: &[crate::Value]) -> crate::Value {
        let __n = match __name { crate::Value::Str(s) => s.as_str(), _ => return crate::Value::Null };
        match __n {
            "authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
            "handle_authentication_message" => { self.handle_authentication_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_balance" => { self.handle_balance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_checksum" => { self.handle_checksum(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_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), &args.get(2..).unwrap_or(&[]).to_vec()[..]); 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), args.get(2).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), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_orders" => { self.handle_orders(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_system_status" => self.handle_system_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_ticker" => { self.handle_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_trades" => { self.handle_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_unsubscription_status" => self.handle_unsubscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_balance" => self.parse_ws_balance(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_ticker" => self.parse_ws_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
            "subscribe" => { crate::exchange_stubs::enqueue_spawn("subscribe", args.to_vec()); crate::Value::Null },
            "subscribe_private" => { crate::exchange_stubs::enqueue_spawn("subscribe_private", args.to_vec()); crate::Value::Null },
            "un_subscribe" => { crate::exchange_stubs::enqueue_spawn("un_subscribe", 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_ticker" => { crate::exchange_stubs::enqueue_spawn("un_watch_ticker", args.to_vec()); crate::Value::Null },
            "un_watch_trades" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades", args.to_vec()); crate::Value::Null },
            "watch_balance" => { crate::exchange_stubs::enqueue_spawn("watch_balance", args.to_vec()); crate::Value::Null },
            "watch_my_trades" => { crate::exchange_stubs::enqueue_spawn("watch_my_trades", args.to_vec()); crate::Value::Null },
            "watch_ohlcv" => { crate::exchange_stubs::enqueue_spawn("watch_ohlcv", args.to_vec()); crate::Value::Null },
            "watch_order_book" => { crate::exchange_stubs::enqueue_spawn("watch_order_book", args.to_vec()); crate::Value::Null },
            "watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
            "watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

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

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

impl BitfinexCore {
    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("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(false));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(false));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("watchBalance".to_string(), Value::Bool(true));
        m.insert("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
        m.insert("unWatchOHLCV".to_string(), Value::Bool(true));
        m.insert("unWatchOrderBook".to_string(), Value::Bool(true));
    m
}));
        m.insert("urls".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("api".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("public".to_string(), Value::Str("wss://api-pub.bitfinex.com/ws/2".to_string()));
        m.insert("private".to_string(), Value::Str("wss://api.bitfinex.com/ws/2".to_string()));
    m
}));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("watchOrderBook".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("prec".to_string(), Value::Str("P0".to_string()));
        m.insert("freq".to_string(), Value::Str("F0".to_string()));
        m.insert("checksum".to_string(), Value::Bool(true));
    m
}));
        m.insert("ordersLimit".to_string(), Value::Int(1000));
    m
}));
    m
})]);

    Value::Null
}

    pub async fn subscribe(&mut self, mut channel: Value, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketId: Value = get_value(&market, &Value::Str("id".to_string()));
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut messageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("event".to_string(), Value::Str("subscribe".to_string()));
                m.insert("channel".to_string(), channel.clone());
                m.insert("symbol".to_string(), marketId.clone());
            m
        });
        let __ws_arg_0 = self.deep_extend(request.clone(), &[params.clone()]);
        let mut result: Value = self.watch(url.clone(), messageHash.clone(), &[__ws_arg_0, messageHash.clone(), Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("checksum".to_string(), Value::Bool(false));
            m
        })]).await;
        let mut checksum: Value = self.safe_bool_k(self.options.clone(), "checksum", &[Value::Bool(true)]);
        if is_true(&(is_equal(&checksum, &Value::Bool(true)))) && is_true(&(is_equal(&channel, &Value::Str("book".to_string())))) {
            let mut sub: Value = get_value(&get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash);
            if is_true(&(!is_equal(&sub, &Value::Null))) && is_true(&(!is_equal(&get_value(&sub, &Value::Str("checksum".to_string())), &Value::Bool(true)))) {
                add_element_to_object(get_value_mut(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash), &Value::Str("checksum".to_string()), Value::Bool(true));
                client.send(&[Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("event".to_string(), Value::Str("conf".to_string()));
                        m.insert("flags".to_string(), Value::Int(131072));
                    m
                })]);
            }
        }
        return result;

    Value::Null
}

    pub async fn un_subscribe(&mut self, mut channel: Value, mut topic: Value, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        let mut marketId: Value = get_value(&market, &Value::Str("id".to_string()));
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut subMessageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        let mut messageHash: Value = add(&add(&add(&Value::Str("unsubscribe:".to_string()), &channel), &Value::Str(":".to_string())), &marketId);
        let mut unSubTopic: Value = add(&add(&add(&add(&Value::Str("unsubscribe".to_string()), &Value::Str(":".to_string())), &topic), &Value::Str(":".to_string())), &symbol);
        let mut channelId: Value = self.safe_string(get_value(&client, &Value::Str("subscriptions".to_string())), unSubTopic.clone(), &[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("event".to_string(), Value::Str("unsubscribe".to_string()));
                m.insert("chanId".to_string(), channelId.clone());
            m
        });
        let mut unSubChanMsg: Value = add(&Value::Str("unsubscribe:".to_string()), &channelId);
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &unSubChanMsg, subMessageHash.clone());
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), Value::List(vec![messageHash.clone()]));
                m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                m.insert("topic".to_string(), topic.clone());
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
            m
        });
        let __ws_arg_1 = self.deep_extend(request.clone(), &[params.clone()]);
        return self.watch(url.clone(), messageHash.clone(), &[__ws_arg_1, messageHash.clone(), subscription.clone()]).await;

    Value::Null
}

    pub async fn subscribe_private(&mut self, mut messageHash: Value) -> Value {
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        self.authenticate(&[]).await;
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("private".to_string()));
        return self.watch(url.clone(), messageHash.clone(), &[Value::Null, Value::Int(1)]).await;

    Value::Null
}

/*
 * @method
 * @name bitfinex#watchOHLCV
 * @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".to_string()));
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut interval: Value = self.safe_string(self.timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut channel: Value = Value::Str("candles".to_string());
        let mut key: Value = add(&add(&add(&Value::Str("trade:".to_string()), &interval), &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
        let mut messageHash: Value = add(&add(&add(&add(&channel, &Value::Str(":".to_string())), &interval), &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("event".to_string(), Value::Str("subscribe".to_string()));
                m.insert("channel".to_string(), channel.clone());
                m.insert("key".to_string(), key.clone());
            m
        });
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string()));
        // not using subscribe here because this message has a different format
        let __ws_arg_2 = self.deep_extend(request.clone(), &[params.clone()]);
        let mut ohlcv: Value = self.watch(url.clone(), messageHash.clone(), &[__ws_arg_2, messageHash.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = ohlcv.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(ohlcv.clone(), &[since.clone(), limit.clone(), Value::Int(0), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bitfinex#unWatchOHLCV
 * @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 fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {bool} true if successfully unsubscribed, false otherwise
 */
    pub async fn un_watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".to_string()));
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = self.market(symbol.clone());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut interval: Value = self.safe_string(self.timeframes.clone(), timeframe.clone(), &[timeframe.clone()]);
        let mut channel: Value = Value::Str("candles".to_string());
        let mut subMessageHash: Value = add(&add(&add(&add(&channel, &Value::Str(":".to_string())), &interval), &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
        let mut messageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &subMessageHash);
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut subId: Value = add(&add(&add(&Value::Str("unsubscribe:trade:".to_string()), &interval), &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string()))); // trade here because we use the key
        let mut channelId: Value = self.safe_string(get_value(&client, &Value::Str("subscriptions".to_string())), subId.clone(), &[]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("event".to_string(), Value::Str("unsubscribe".to_string()));
                m.insert("chanId".to_string(), channelId.clone());
            m
        });
        let mut unSubChanMsg: Value = add(&Value::Str("unsubscribe:".to_string()), &channelId);
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &unSubChanMsg, subMessageHash.clone());
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), Value::List(vec![messageHash.clone()]));
                m.insert("subMessageHashes".to_string(), Value::List(vec![subMessageHash.clone()]));
                m.insert("topic".to_string(), Value::Str("ohlcv".to_string()));
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("symbols".to_string(), Value::List(vec![symbol.clone()]));
            m
        });
        let __ws_arg_3 = self.deep_extend(request.clone(), &[params.clone()]);
        return self.watch(url.clone(), messageHash.clone(), &[__ws_arg_3, messageHash.clone(), subscription.clone()]).await;

    Value::Null
}

    pub fn handle_ohlcv(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // initial snapshot
        //   [
        //       341527, // channel id
        //       [
        //          [
        //             1654705860000, // timestamp
        //             1802.6, // open
        //             1800.3, // close
        //             1802.8, // high
        //             1800.3, // low
        //             86.49588236 // volume
        //          ],
        //          [
        //             1654705800000,
        //             1803.6,
        //             1802.6,
        //             1804.9,
        //             1802.3,
        //             74.6348086
        //          ],
        //          [
        //             1654705740000,
        //             1802.5,
        //             1803.2,
        //             1804.4,
        //             1802.4,
        //             23.61801085
        //          ]
        //       ]
        //   ]
        //
        // update
        //   [
        //       211171,
        //       [
        //          1654705680000,
        //          1801,
        //          1802.4,
        //          1802.9,
        //          1800.4,
        //          23.91911091
        //       ]
        //   ]
        //
        let mut data: Value = self.safe_value(message.clone(), Value::Int(1), &[Value::List(vec![])]);
        let mut ohlcvs: Value = Value::List(vec![]);
        let mut first: Value = self.safe_value(data.clone(), Value::Int(0), &[]);
        if is_true(&Value::Bool(is_array(&first))) {
            // snapshot
            ohlcvs = data.clone();
        }  else {
            // update
            ohlcvs = Value::List(vec![data.clone()]);
        }
        let mut channel: Value = self.safe_value_k(subscription.clone(), "channel", &[]);
        let mut key: Value = self.safe_string_k(subscription.clone(), "key", &[Value::Str("".to_string())]);
        let mut keyParts: Value = split(&key, &Value::Str(":".to_string()));
        let mut interval: Value = self.safe_string(keyParts.clone(), Value::Int(1), &[]);
        let mut marketId: Value = key.clone();
        marketId = replace_str(&marketId, &Value::Str("trade:".to_string()), &Value::Str("".to_string()));
        marketId = replace_str(&marketId, &add(&interval, &Value::Str(":".to_string())), &Value::Str("".to_string()));
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut timeframe: Value = self.find_timeframe(interval.clone(), &[]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut messageHash: Value = add(&add(&add(&add(&channel, &Value::Str(":".to_string())), &interval), &Value::Str(":".to_string())), &marketId);
        { let __be_tmp = self.safe_value(self.ohlcvs.clone(), symbol.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]); add_element_to_object(&mut self.ohlcvs, &symbol, __be_tmp); };
        let mut stored: Value = self.safe_value(get_value(&self.ohlcvs, &symbol), timeframe.clone(), &[]);
        if is_equal(&stored, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "OHLCVLimit", &[Value::Int(1000)]);
            stored = ArrayCacheByTimestamp::new(limit.clone());
            add_element_to_object(get_value_mut(unsafe { crate::runtime::coerce_value_to_mut(&self.ohlcvs) }, &symbol), &timeframe, stored.clone());
        }
        let mut ohlcvsLength: Value = get_array_length(&ohlcvs);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_100: bool = true;
            while { if !__for_first_100 { i = add(&i, &Value::Int(1)); } __for_first_100 = false; is_less_than(&i, &ohlcvsLength) } {
            let mut ohlcv: Value = get_value(&ohlcvs, &subtract(&subtract(&ohlcvsLength, &i), &Value::Int(1)));
            let mut parsed: Value = self.parse_ohlcv(ohlcv.clone(), &[market.clone()]);
            stored.append(parsed.clone());
        }
        }
        client.resolve(&[stored.clone(), messageHash.clone()]);
}

/*
 * @method
 * @name bitfinex#watchTrades
 * @description get the list of most recent trades for a particular symbol
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {int} [since] timestamp in ms of the earliest trade to fetch
 * @param {int} [limit] the maximum amount of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn watch_trades(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut since = get_arg(optional_args, 0, Value::Null);
        let mut limit = get_arg(optional_args, 1, Value::Null);
        let mut params = get_arg(optional_args, 2, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut trades: Value = self.subscribe(Value::Str("trades".to_string()), symbol.clone(), &[params.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(trades.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bitfinex#unWatchTrades
 * @description unWatches the list of most recent trades for a particular symbol
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
 */
    pub async fn un_watch_trades(&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
}));
        return self.un_subscribe(Value::Str("trades".to_string()), Value::Str("trades".to_string()), symbol.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name bitfinex#watchMyTrades
 * @description watches information on multiple trades made by the user
 * @param {string} symbol unified market symbol of the market trades were made in
 * @param {int} [since] the earliest time in ms to fetch trades for
 * @param {int} [limit] the maximum number of trade structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
 */
    pub async fn watch_my_trades(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut messageHash: Value = Value::Str("myTrade".to_string());
        if !is_equal(&symbol, &Value::Null) {
            let mut market: Value = self.market(symbol.clone());
            messageHash = add(&messageHash, &add(&Value::Str(":".to_string()), &get_value(&market, &Value::Str("id".to_string()))));
        }
        let mut trades: Value = self.subscribe_private(messageHash.clone()).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(trades.clone(), &[symbol.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name bitfinex#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours 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
}));
        return self.subscribe(Value::Str("ticker".to_string()), symbol.clone(), &[params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name bitfinex#unWatchTicker
 * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours 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 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
}));
        return self.un_subscribe(Value::Str("ticker".to_string()), Value::Str("ticker".to_string()), symbol.clone(), &[params.clone()]).await;

    Value::Null
}

    pub fn handle_my_trade(&mut self, mut client: Value, mut message: Value, optional_args: &[Value]) {
        let mut subscription = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        //
        // trade execution
        // [
        //     0,
        //     "te", // or tu
        //     [
        //        1133411090,
        //        "tLTCUST",
        //        1655110144598,
        //        97084883506,
        //        0.1,
        //        42.821,
        //        "EXCHANGE MARKET",
        //        42.799,
        //        -1,
        //        null,
        //        null,
        //        1655110144596
        //     ]
        // ]
        //
        let mut name: Value = Value::Str("myTrade".to_string());
        let mut data: Value = self.safe_value(message.clone(), Value::Int(2), &[]);
        let mut trade: Value = self.parse_ws_trade(data.clone(), &[]);
        let mut symbol: Value = get_value(&trade, &Value::Str("symbol".to_string()));
        let mut market: Value = self.market(symbol.clone());
        let mut messageHash: Value = add(&add(&name, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
        if is_equal(&self.myTrades, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            self.myTrades = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut tradesArray: Value = self.myTrades.clone();
        tradesArray.append(trade.clone());
        self.myTrades = tradesArray.clone();
        // generic subscription
        client.resolve(&[tradesArray.clone(), name.clone()]);
        // specific subscription
        client.resolve(&[tradesArray.clone(), messageHash.clone()]);
}

    pub fn handle_trades(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // initial snapshot
        //
        //    [
        //        188687, // channel id
        //        [
        //          [ 1128060675, 1654701572690, 0.00217533, 1815.3 ], // id, mts, amount, price
        //          [ 1128060665, 1654701551231, -0.00280472, 1814.1 ],
        //          [ 1128060664, 1654701550996, -0.00364444, 1814.1 ],
        //          [ 1128060656, 1654701527730, -0.00265203, 1814.2 ],
        //          [ 1128060647, 1654701505193, 0.00262395, 1815.2 ],
        //          [ 1128060642, 1654701484656, -0.13411443, 1816 ],
        //          [ 1128060641, 1654701484656, -0.00088557, 1816 ],
        //          [ 1128060639, 1654701478326, -0.002, 1816 ],
        //        ]
        //    ]
        // update
        //
        //    [
        //        360141,
        //        "te",
        //        [
        //            1128060969, // id
        //            1654702500098, // mts
        //            0.00325131, // amount positive buy, negative sell
        //            1818.5, // price
        //        ],
        //    ]
        //
        //
        let mut channel: Value = self.safe_value_k(subscription.clone(), "channel", &[]);
        let mut marketId: Value = self.safe_string_k(subscription.clone(), "symbol", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut messageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        let mut tradesLimit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut stored: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if is_equal(&stored, &Value::Null) {
            stored = ArrayCache::new(tradesLimit.clone());
            add_element_to_object(&mut self.trades, &symbol, stored.clone());
        }
        let mut messageLength: Value = get_array_length(&message);
        if is_equal(&messageLength, &Value::Int(2)) {
            // initial snapshot
            let mut trades: Value = self.safe_list(message.clone(), Value::Int(1), &[Value::List(vec![])]);
            // needs to be reversed to make chronological order
            let mut length: Value = get_array_length(&trades);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_101: bool = true;
                while { if !__for_first_101 { i = add(&i, &Value::Int(1)); } __for_first_101 = false; is_less_than(&i, &length) } {
                let mut index: Value = subtract(&subtract(&length, &i), &Value::Int(1));
                let mut parsed: Value = self.parse_ws_trade(get_value(&trades, &index), &[market.clone()]);
                stored.append(parsed.clone());
            }
            }
        }  else {
            // update
            let mut type_var: Value = self.safe_string(message.clone(), Value::Int(1), &[]);
            if is_equal(&type_var, &Value::Str("tu".to_string())) {
                return;
            }
            let mut trade: Value = self.safe_value(message.clone(), Value::Int(2), &[Value::List(vec![])]);
            let mut parsed: Value = self.parse_ws_trade(trade.clone(), &[market.clone()]);
            stored.append(parsed.clone());
        }
        client.resolve(&[stored.clone(), messageHash.clone()]);
}

    pub fn parse_ws_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //    [
        //        1128060969, // id
        //        1654702500098, // mts
        //        0.00325131, // amount positive buy, negative sell
        //        1818.5, // price
        //    ]
        //
        // trade execution
        //
        //    [
        //        1133411090, // id
        //        "tLTCUST", // symbol
        //        1655110144598, // create ms
        //        97084883506, // order id
        //        0.1, // amount
        //        42.821, // price
        //        "EXCHANGE MARKET", // order type
        //        42.799, // order price
        //        -1, // maker
        //        null, // fee
        //        null, // fee currency
        //        1655110144596 // cid
        //    ]
        //
        // trade update
        //
        //    [
        //       1133411090,
        //       "tLTCUST",
        //       1655110144598,
        //       97084883506,
        //       0.1,
        //       42.821,
        //       "EXCHANGE MARKET",
        //       42.799,
        //       -1,
        //       -0.0002,
        //       "LTC",
        //       1655110144596
        //    ]
        //
        let mut numFields: Value = get_array_length(&trade);
        let mut isPublic: bool = is_less_than_or_equal(&numFields, &Value::Int(8));
        let mut marketId: Value = ternary(is_true(&(!is_true(&isPublic))), self.safe_string(trade.clone(), Value::Int(1), &[]), Value::Null);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut createdKey: Value = ternary(is_true(&isPublic), Value::Int(1), Value::Int(2));
        let mut priceKey: Value = ternary(is_true(&isPublic), Value::Int(3), Value::Int(5));
        let mut amountKey: Value = ternary(is_true(&isPublic), Value::Int(2), Value::Int(4));
        marketId = get_value(&market, &Value::Str("id".to_string()));
        let mut type_var: Value = self.safe_string(trade.clone(), Value::Int(6), &[]);
        if !is_equal(&type_var, &Value::Null) {
            if is_greater_than(&get_index_of(&type_var, &Value::Str("LIMIT".to_string())), &negate(&Value::Int(1))) {
                type_var = Value::Str("limit".to_string());
            }  else if is_greater_than(&get_index_of(&type_var, &Value::Str("MARKET".to_string())), &negate(&Value::Int(1))) {
                type_var = Value::Str("market".to_string());
            }
        }
        let mut orderId: Value = ternary(is_true(&(!is_true(&isPublic))), self.safe_string(trade.clone(), Value::Int(3), &[]), Value::Null);
        let mut id: Value = self.safe_string(trade.clone(), Value::Int(0), &[]);
        let mut timestamp: Value = self.safe_integer(trade.clone(), createdKey.clone(), &[]);
        let mut price: Value = self.safe_string(trade.clone(), priceKey.clone(), &[]);
        let mut amountString: Value = self.safe_string(trade.clone(), amountKey.clone(), &[]);
        let mut amount: Value = self.parse_number(crate::precise::Precise::stringAbs(&amountString), &[]);
        let mut side: Value = Value::Null;
        if !is_equal(&amount, &Value::Null) {
            side = ternary(is_true(&crate::precise::Precise::stringGt(&amountString, &Value::Str("0".to_string()))), Value::Str("buy".to_string()), Value::Str("sell".to_string()));
        }
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[market.clone()]);
        let mut feeValue: Value = self.safe_string(trade.clone(), Value::Int(9), &[]);
        let mut fee: Value = Value::Null;
        if !is_equal(&feeValue, &Value::Null) {
            let mut currencyId: Value = self.safe_string(trade.clone(), Value::Int(10), &[]);
            let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
            fee = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("cost".to_string(), feeValue.clone());
                    m.insert("currency".to_string(), code.clone());
                m
            });
        }
        let mut maker: Value = self.safe_integer(trade.clone(), Value::Int(8), &[]);
        let mut takerOrMaker: Value = Value::Null;
        if !is_equal(&maker, &Value::Null) {
            takerOrMaker = ternary(is_true(&(is_equal(&maker, &negate(&Value::Int(1))))), Value::Str("taker".to_string()), Value::Str("maker".to_string()));
        }
        return self.safe_trade(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), trade.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("id".to_string(), id.clone());
        m.insert("order".to_string(), orderId.clone());
        m.insert("type".to_string(), type_var.clone());
        m.insert("takerOrMaker".to_string(), takerOrMaker.clone());
        m.insert("side".to_string(), side.clone());
        m.insert("price".to_string(), price.clone());
        m.insert("amount".to_string(), amount.clone());
        m.insert("cost".to_string(), Value::Null);
        m.insert("fee".to_string(), fee.clone());
    m
}), &[market.clone()]);

    Value::Null
}

    pub fn handle_ticker(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // [
        //    340432, // channel ID
        //     [
        //         236.62,        // 1 BID float Price of last highest bid
        //         9.0029,        // 2 BID_SIZE float Size of the last highest bid
        //         236.88,        // 3 ASK float Price of last lowest ask
        //         7.1138,        // 4 ASK_SIZE float Size of the last lowest ask
        //         -1.02,         // 5 DAILY_CHANGE float Amount that the last price has changed since yesterday
        //         0,             // 6 DAILY_CHANGE_PERC float Amount that the price has changed expressed in percentage terms
        //         236.52,        // 7 LAST_PRICE float Price of the last trade.
        //         5191.36754297, // 8 VOLUME float Daily volume
        //         250.01,        // 9 HIGH float Daily high
        //         220.05,        // 10 LOW float Daily low
        //     ]
        //  ]
        //
        let mut ticker: Value = self.safe_value(message.clone(), Value::Int(1), &[]);
        let mut marketId: Value = self.safe_string_k(subscription.clone(), "symbol", &[]);
        let mut market: Value = self.safe_market(&[marketId.clone()]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        let mut parsed: Value = self.parse_ws_ticker(ticker.clone(), &[market.clone()]);
        let mut channel: Value = Value::Str("ticker".to_string());
        let mut messageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        add_element_to_object(&mut self.tickers, &symbol, parsed.clone());
        client.resolve(&[parsed.clone(), messageHash.clone()]);
}

    pub fn parse_ws_ticker(&self, mut ticker: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     [
        //         236.62,        // 1 BID float Price of last highest bid
        //         9.0029,        // 2 BID_SIZE float Size of the last highest bid
        //         236.88,        // 3 ASK float Price of last lowest ask
        //         7.1138,        // 4 ASK_SIZE float Size of the last lowest ask
        //         -1.02,         // 5 DAILY_CHANGE float Amount that the last price has changed since yesterday
        //         0,             // 6 DAILY_CHANGE_PERC float Amount that the price has changed expressed in percentage terms
        //         236.52,        // 7 LAST_PRICE float Price of the last trade.
        //         5191.36754297, // 8 VOLUME float Daily volume
        //         250.01,        // 9 HIGH float Daily high
        //         220.05,        // 10 LOW float Daily low
        //     ]
        //
        market = self.safe_market(&[Value::Null, market.clone()]);
        let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
        let mut last: Value = self.safe_string(ticker.clone(), Value::Int(6), &[]);
        let mut change: Value = self.safe_string(ticker.clone(), Value::Int(4), &[]);
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("timestamp".to_string(), Value::Null);
        m.insert("datetime".to_string(), Value::Null);
        m.insert("high".to_string(), self.safe_string(ticker.clone(), Value::Int(8), &[]));
        m.insert("low".to_string(), self.safe_string(ticker.clone(), Value::Int(9), &[]));
        m.insert("bid".to_string(), self.safe_string(ticker.clone(), Value::Int(0), &[]));
        m.insert("bidVolume".to_string(), self.safe_string(ticker.clone(), Value::Int(1), &[]));
        m.insert("ask".to_string(), self.safe_string(ticker.clone(), Value::Int(2), &[]));
        m.insert("askVolume".to_string(), self.safe_string(ticker.clone(), Value::Int(3), &[]));
        m.insert("vwap".to_string(), Value::Null);
        m.insert("open".to_string(), Value::Null);
        m.insert("close".to_string(), last.clone());
        m.insert("last".to_string(), last.clone());
        m.insert("previousClose".to_string(), Value::Null);
        m.insert("change".to_string(), change.clone());
        m.insert("percentage".to_string(), self.safe_string(ticker.clone(), Value::Int(5), &[]));
        m.insert("average".to_string(), Value::Null);
        m.insert("baseVolume".to_string(), self.safe_string(ticker.clone(), Value::Int(7), &[]));
        m.insert("quoteVolume".to_string(), Value::Null);
        m.insert("info".to_string(), ticker.clone());
    m
}), &[market.clone()]);

    Value::Null
}

/*
 * @method
 * @name bitfinex#watchOrderBook
 * @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 {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if !is_equal(&limit, &Value::Null) {
            if is_true(&(!is_equal(&limit, &Value::Int(25)))) && is_true(&(!is_equal(&limit, &Value::Int(100)))) {
                panic!("{}", crate::exchange_errors::exchange_error(add(&self.id, &Value::Str(" watchOrderBook limit argument must be undefined, 25 or 100".to_string()))));
            }
        }
        let mut options: Value = self.safe_value_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut prec: Value = self.safe_string_k(options.clone(), "prec", &[Value::Str("P0".to_string())]);
        let mut freq: Value = self.safe_string_k(options.clone(), "freq", &[Value::Str("F0".to_string())]);
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("prec".to_string(), prec.clone());
                m.insert("freq".to_string(), freq.clone());
            m
        });
        if !is_equal(&limit, &Value::Null) {
            add_element_to_object(&mut request, &Value::Str("len".to_string()), limit.clone()); // string, number of price points, '25', '100', default = '25'
        }
        let mut orderbook: Value = self.subscribe(Value::Str("book".to_string()), symbol.clone(), &[self.deep_extend(request.clone(), &[params.clone()])]).await;
        return orderbook.limit();

    Value::Null
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // first message (snapshot)
        //
        //     [
        //         18691, // channel id
        //         [
        //             [ 7364.8, 10, 4.354802 ], // price, count, size > 0 = bid
        //             [ 7364.7, 1, 0.00288831 ],
        //             [ 7364.3, 12, 0.048 ],
        //             [ 7364.9, 3, -0.42028976 ], // price, count, size < 0 = ask
        //             [ 7365, 1, -0.25 ],
        //             [ 7365.5, 1, -0.00371937 ],
        //         ]
        //     ]
        //
        // subsequent updates
        //
        //     [
        //         358169, // channel id
        //         [
        //            1807.1, // price
        //            0, // count
        //            1 // size
        //         ]
        //     ]
        //
        let mut marketId: Value = self.safe_string_k(subscription.clone(), "symbol", &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        let mut channel: Value = Value::Str("book".to_string());
        let mut messageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        let mut prec: Value = self.safe_string_k(subscription.clone(), "prec", &[Value::Str("P0".to_string())]);
        let mut isRaw: bool = is_equal(&prec, &Value::Str("R0".to_string()));
        // if it is an initial snapshot
        if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) {
            let mut limit: Value = self.safe_integer_k(subscription.clone(), "len", &[]);
            if is_true(&isRaw) {
                // raw order books
                { let __be_tmp = self.indexed_order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit.clone()]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
            }  else {
                // P0, P1, P2, P3, P4
                { let __be_tmp = self.counted_order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit.clone()]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
            }
            let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
            if is_true(&isRaw) {
                let mut deltas: Value = get_value(&message, &Value::Int(1));
                {
                                        let mut i: Value = Value::Int(0);
                    let mut __for_first_102: bool = true;
                    while { if !__for_first_102 { i = add(&i, &Value::Int(1)); } __for_first_102 = false; is_less_than(&i, &get_array_length(&deltas)) } {
                    let mut delta: Value = get_value(&deltas, &i);
                    let mut delta: Value = get_value(&deltas, &i);
                    let mut delta2: Value = get_value(&delta, &Value::Int(2));
                    let mut size: Value = ternary(is_true(&(is_less_than(&delta2, &Value::Int(0)))), negate(&delta2), delta2.clone());
                    let mut side: Value = ternary(is_true(&(is_less_than(&delta2, &Value::Int(0)))), Value::Str("asks".to_string()), Value::Str("bids".to_string()));
                    let mut bookside: Value = get_value(&orderbook, &side);
                    let mut bookside: Value = get_value(&orderbook, &side);
                    let mut idString: Value = self.safe_string(delta.clone(), Value::Int(0), &[]);
                    let mut price: Value = self.safe_float(delta.clone(), Value::Int(1), &[]);
                    bookside.store_array(Value::List(vec![price.clone(), size.clone(), idString.clone()]));
                }
                }
            }  else {
                let mut deltas: Value = get_value(&message, &Value::Int(1));
                {
                                        let mut i: Value = Value::Int(0);
                    let mut __for_first_103: bool = true;
                    while { if !__for_first_103 { i = add(&i, &Value::Int(1)); } __for_first_103 = false; is_less_than(&i, &get_array_length(&deltas)) } {
                    let mut delta: Value = get_value(&deltas, &i);
                    let mut delta: Value = get_value(&deltas, &i);
                    let mut amount: Value = self.safe_number(delta.clone(), Value::Int(2), &[]);
                    if is_equal(&amount, &Value::Null) {
                        continue;
                    }
                    let mut counter: Value = self.safe_number(delta.clone(), Value::Int(1), &[]);
                    let mut price: Value = self.safe_number(delta.clone(), Value::Int(0), &[]);
                    let mut size: Value = ternary(is_true(&(is_less_than(&amount, &Value::Int(0)))), negate(&amount), amount.clone());
                    let mut side: Value = ternary(is_true(&(is_less_than(&amount, &Value::Int(0)))), Value::Str("asks".to_string()), Value::Str("bids".to_string()));
                    let mut bookside: Value = get_value(&orderbook, &side);
                    let mut bookside: Value = get_value(&orderbook, &side);
                    bookside.store_array(Value::List(vec![price.clone(), size.clone(), counter.clone()]));
                }
                }
            }
            add_element_to_object(&mut orderbook, &Value::Str("symbol".to_string()), symbol.clone());
            client.resolve(&[orderbook.clone(), messageHash.clone()]);
        }  else {
            let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
            let mut deltas: Value = get_value(&message, &Value::Int(1));
            let mut orderbookItem: Value = get_value(&self.orderbooks, &symbol);
            if is_true(&isRaw) {
                let mut price: Value = self.safe_string(deltas.clone(), Value::Int(1), &[]);
                let mut deltas2: Value = get_value(&deltas, &Value::Int(2));
                let mut size: Value = ternary(is_true(&(is_less_than(&deltas2, &Value::Int(0)))), negate(&deltas2), deltas2.clone());
                let mut side: Value = ternary(is_true(&(is_less_than(&deltas2, &Value::Int(0)))), Value::Str("asks".to_string()), Value::Str("bids".to_string()));
                let mut bookside: Value = get_value(&orderbookItem, &side);
                let mut bookside: Value = get_value(&orderbookItem, &side);
                // price = 0 means that you have to remove the order from your book
                let mut amount: Value = ternary(is_true(&crate::precise::Precise::stringGt(&price, &Value::Str("0".to_string()))), size.clone(), Value::Str("0".to_string()));
                let mut idString: Value = self.safe_string(deltas.clone(), Value::Int(0), &[]);
                bookside.store_array(Value::List(vec![self.parse_number(price.clone(), &[]), self.parse_number(amount.clone(), &[]), idString.clone()]));
            }  else {
                let mut amount: Value = self.safe_string(deltas.clone(), Value::Int(2), &[]);
                let mut counter: Value = self.safe_string(deltas.clone(), Value::Int(1), &[]);
                let mut price: Value = self.safe_string(deltas.clone(), Value::Int(0), &[]);
                let mut size: Value = ternary(is_true(&crate::precise::Precise::stringLt(&amount, &Value::Str("0".to_string()))), crate::precise::Precise::stringNeg(&amount), amount.clone());
                let mut side: Value = ternary(is_true(&crate::precise::Precise::stringLt(&amount, &Value::Str("0".to_string()))), Value::Str("asks".to_string()), Value::Str("bids".to_string()));
                let mut bookside: Value = get_value(&orderbookItem, &side);
                let mut bookside: Value = get_value(&orderbookItem, &side);
                bookside.store_array(Value::List(vec![self.parse_number(price.clone(), &[]), self.parse_number(size.clone(), &[]), self.parse_number(counter.clone(), &[])]));
            }
            client.resolve(&[orderbook.clone(), messageHash.clone()]);
        }
}

    pub fn handle_checksum(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // [ 173904, "cs", -890884919 ]
        //
        let mut marketId: Value = self.safe_string_k(subscription.clone(), "symbol", &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        let mut channel: Value = Value::Str("book".to_string());
        let mut messageHash: Value = add(&add(&channel, &Value::Str(":".to_string())), &marketId);
        let mut book: Value = self.safe_value(self.orderbooks.clone(), symbol.clone(), &[]);
        if is_equal(&book, &Value::Null) {
            return;
        }
        let mut depth: Value = Value::Int(25); // covers the first 25 bids and asks
        let mut stringArray: Value = Value::List(vec![]);
        let mut bids: Value = get_value(&book, &Value::Str("bids".to_string()));
        let mut asks: Value = get_value(&book, &Value::Str("asks".to_string()));
        let mut prec: Value = self.safe_string_k(subscription.clone(), "prec", &[Value::Str("P0".to_string())]);
        let mut isRaw: bool = is_equal(&prec, &Value::Str("R0".to_string()));
        let mut idToCheck: Value = ternary(is_true(&isRaw), Value::Int(2), Value::Int(0));
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_104: bool = true;
            while { if !__for_first_104 { i = add(&i, &Value::Int(1)); } __for_first_104 = false; is_less_than(&i, &depth) } {
            let mut bid: Value = self.safe_value(bids.clone(), i.clone(), &[]);
            let mut ask: Value = self.safe_value(asks.clone(), i.clone(), &[]);
            if !is_equal(&bid, &Value::Null) {
                append_to_array(&mut stringArray, self.number_to_string(get_value(&get_value(&bids, &i), &idToCheck)));
                append_to_array(&mut stringArray, self.number_to_string(get_value(&get_value(&bids, &i), &Value::Int(1))));
            }
            if !is_equal(&ask, &Value::Null) {
                append_to_array(&mut stringArray, self.number_to_string(get_value(&get_value(&asks, &i), &idToCheck)));
                let mut aski1: Value = get_value(&get_value(&asks, &i), &Value::Int(1));
                append_to_array(&mut stringArray, self.number_to_string(negate(&aski1)));
            }
        }
        }
        let mut payload: Value = join(&stringArray, &Value::Str(":".to_string()));
        let mut localChecksum: Value = self.crc32(&[payload.clone(), Value::Bool(true)]);
        let mut responseChecksum: Value = self.safe_integer(message.clone(), Value::Int(2), &[]);
        if !is_equal(&responseChecksum, &localChecksum) {
            remove(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash);
            remove(&mut self.orderbooks, &symbol);
            let mut checksum: Value = self.handle_option(Value::Str("watchOrderBook".to_string()), Value::Str("checksum".to_string()), &[Value::Bool(true)]);
            if is_equal(&checksum, &Value::Bool(true)) {
                let mut error = Value::from(crate::exchange_errors::checksum_error(add(&add(&self.id, &Value::Str(" ".to_string())), &self.orderbook_checksum_message(symbol.clone()))));
                client.reject(&[Value::from(error.clone()), messageHash.clone()]);
            }
        }
}

/*
 * @method
 * @name bitfinex#watchBalance
 * @description watch balance and get the amount of funds available for trading or funds locked in orders
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {str} [params.type] spot or contract if not provided this.options['defaultType'] is used
 * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
 */
    pub async fn watch_balance(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut balanceType: Value = self.safe_string_k(params.clone(), "wallet", &[Value::Str("exchange".to_string())]); // exchange, margin
        params = self.omit(params.clone(), Value::Str("wallet".to_string()), &[]);
        let mut messageHash: Value = add(&Value::Str("balance:".to_string()), &balanceType);
        return self.subscribe_private(messageHash.clone()).await;

    Value::Null
}

    pub fn handle_balance(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // snapshot (exchange + margin together)
        //   [
        //       0,
        //       "ws",
        //       [
        //           [
        //               "exchange",
        //               "LTC",
        //               0.05479727,
        //               0,
        //               null,
        //               "Trading fees for 0.05 LTC (LTCUST) @ 51.872 on BFX (0.2%)",
        //               null,
        //           ]
        //           [
        //               "margin",
        //               "USTF0",
        //               11.960650700086292,
        //               0,
        //               null,
        //               "Trading fees for 0.1 LTCF0 (LTCF0:USTF0) @ 51.844 on BFX (0.065%)",
        //               null,
        //           ],
        //       ],
        //   ]
        //
        // spot
        //   [
        //       0,
        //       "wu",
        //       [
        //         "exchange",
        //         "LTC", // currency
        //         0.06729727, // wallet balance
        //         0, // unsettled balance
        //         0.06729727, // available balance might be null
        //         "Exchange 0.4 LTC for UST @ 65.075",
        //         {
        //           "reason": "TRADE",
        //           "order_id": 96596397973,
        //           "order_id_oppo": 96596632735,
        //           "trade_price": "65.075",
        //           "trade_amount": "-0.4",
        //           "order_cid": 1654636218766,
        //           "order_gid": null
        //         }
        //       ]
        //   ]
        //
        // margin
        //
        //   [
        //       "margin",
        //       "USTF0",
        //       11.960650700086292, // total
        //       0,
        //       6.776250700086292, // available
        //       "Trading fees for 0.1 LTCF0 (LTCF0:USTF0) @ 51.844 on BFX (0.065%)",
        //       null
        //   ]
        //
        let mut updateType: Value = self.safe_value(message.clone(), Value::Int(1), &[]);
        let mut data: Value = Value::List(vec![]);
        if is_equal(&updateType, &Value::Str("ws".to_string())) {
            data = self.safe_value(message.clone(), Value::Int(2), &[]);
        }  else {
            data = Value::List(vec![self.safe_value(message.clone(), Value::Int(2), &[])]);
        }
        let mut updatedTypes: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_105: bool = true;
            while { if !__for_first_105 { i = add(&i, &Value::Int(1)); } __for_first_105 = false; is_less_than(&i, &get_array_length(&data)) } {
            let mut rawBalance: Value = get_value(&data, &i);
            let mut rawBalance: Value = get_value(&data, &i);
            let mut currencyId: Value = self.safe_string(rawBalance.clone(), Value::Int(1), &[]);
            let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
            let mut balance: Value = self.parse_ws_balance(rawBalance.clone());
            let mut balanceType: Value = self.safe_string(rawBalance.clone(), Value::Int(0), &[]);
            let mut oldBalance: Value = self.safe_value(self.balance.clone(), balanceType.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            if !is_equal(&code, &Value::Null) {
                add_element_to_object(&mut oldBalance, &code, balance.clone());
            }
            add_element_to_object(&mut oldBalance, &Value::Str("info".to_string()), message.clone());
            { let __be_tmp = self.safe_balance(oldBalance.clone()); add_element_to_object(&mut self.balance, &balanceType, __be_tmp); };
            add_element_to_object(&mut updatedTypes, &balanceType, Value::Bool(true));
        }
        }
        let mut updatesKeys: Value = object_keys(&updatedTypes);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_106: bool = true;
            while { if !__for_first_106 { i = add(&i, &Value::Int(1)); } __for_first_106 = false; is_less_than(&i, &get_array_length(&updatesKeys)) } {
            let mut type_var: Value = get_value(&updatesKeys, &i);
            let mut type_var: Value = get_value(&updatesKeys, &i);
            let mut messageHash: Value = add(&Value::Str("balance:".to_string()), &type_var);
            client.resolve(&[get_value(&self.balance, &type_var), messageHash.clone()]);
        }
        }
}

    pub fn parse_ws_balance(&self, mut balance: Value) -> Value {
        //
        //     [
        //         "exchange",
        //         "LTC",
        //         0.05479727, // balance
        //         0,
        //         null, // available null if not calculated yet
        //         "Trading fees for 0.05 LTC (LTCUST) @ 51.872 on BFX (0.2%)",
        //         null,
        //     ]
        //
        let mut totalBalance: Value = self.safe_string(balance.clone(), Value::Int(2), &[]);
        let mut availableBalance: Value = self.safe_string(balance.clone(), Value::Int(4), &[]);
        let mut account: Value = self.account();
        if !is_equal(&availableBalance, &Value::Null) {
            add_element_to_object(&mut account, &Value::Str("free".to_string()), availableBalance.clone());
        }
        add_element_to_object(&mut account, &Value::Str("total".to_string()), totalBalance.clone());
        return account;

    Value::Null
}

    pub fn handle_system_status(&self, mut client: Value, mut message: Value) -> Value {
        return message;

    Value::Null
}

    pub fn handle_unsubscription_status(&mut self, mut client: Value, mut message: Value) -> Value {
        //
        // {
        //     "event": "unsubscribed",
        //     "status": "OK",
        //     "chanId": CHANNEL_ID
        // }
        //
        let mut channelId: Value = self.safe_string_k(message.clone(), "chanId", &[]);
        let mut unSubChannel: Value = add(&Value::Str("unsubscribe:".to_string()), &channelId);
        let mut subMessageHash: Value = self.safe_string(get_value(&client, &Value::Str("subscriptions".to_string())), unSubChannel.clone(), &[]);
        let mut subscription: Value = self.safe_dict(get_value(&client, &Value::Str("subscriptions".to_string())), add(&Value::Str("unsubscribe:".to_string()), &subMessageHash), &[]);
        remove(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &unSubChannel);
        let mut messageHashes: Value = self.safe_list_k(subscription.clone(), "messageHashes", &[Value::List(vec![])]);
        let mut subMessageHashes: Value = self.safe_list_k(subscription.clone(), "subMessageHashes", &[Value::List(vec![])]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_107: bool = true;
            while { if !__for_first_107 { i = add(&i, &Value::Int(1)); } __for_first_107 = false; is_less_than(&i, &get_array_length(&messageHashes)) } {
            let mut messageHash: Value = get_value(&messageHashes, &i);
            let mut messageHash: Value = get_value(&messageHashes, &i);
            let mut subHash: Value = get_value(&subMessageHashes, &i);
            let mut subHash: Value = get_value(&subMessageHashes, &i);
            self.clean_unsubscription(client.clone(), subHash.clone(), messageHash.clone(), &[]);
        }
        }
        self.clean_cache(subscription.clone());
        return Value::Bool(true);

    Value::Null
}

    pub fn handle_subscription_status(&self, mut client: Value, mut message: Value) -> Value {
        //
        //     {
        //         "event": "subscribed",
        //         "channel": "book",
        //         "chanId": 67473,
        //         "symbol": "tBTCUSD",
        //         "prec": "P0",
        //         "freq": "F0",
        //         "len": "25",
        //         "pair": "BTCUSD"
        //     }
        //
        //   {
        //       event: 'subscribed',
        //       channel: 'candles',
        //       chanId: 128306,
        //       key: 'trade:1m:tBTCUST'
        //  }
        //
        let mut channelId: Value = self.safe_string_k(message.clone(), "chanId", &[]);
        add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &channelId, message.clone());
        // store the opposite direction too for unWatch
        let mut mappings: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("book".to_string(), Value::Str("orderbook".to_string()));
                m.insert("candles".to_string(), Value::Str("ohlcv".to_string()));
                m.insert("ticker".to_string(), Value::Str("ticker".to_string()));
                m.insert("trades".to_string(), Value::Str("trades".to_string()));
            m
        });
        let mut unifiedChannel: Value = self.safe_string(mappings.clone(), self.safe_string_k(message.clone(), "channel", &[]), &[]);
        if is_true(&Value::Bool(in_op(&message, &Value::Str("key".to_string())))) {
            // handle ohlcv differently because the message is different
            let mut key: Value = self.safe_string_k(message.clone(), "key", &[]);
            let mut subKeyId: Value = add(&Value::Str("unsubscribe:".to_string()), &key);
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &subKeyId, channelId.clone());
        }  else {
            let mut marketId: Value = self.safe_string_k(message.clone(), "symbol", &[]);
            let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
            if !is_equal(&unifiedChannel, &Value::Null) {
                let mut subId: Value = add(&add(&add(&Value::Str("unsubscribe:".to_string()), &unifiedChannel), &Value::Str(":".to_string())), &symbol);
                add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &subId, channelId.clone());
            }
        }
        return message;

    Value::Null
}

    pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("private".to_string()));
        let mut client: Value = self.client(&[url.clone()]);
        let mut messageHash: Value = Value::Str("authenticated".to_string());
        let mut future: Value = client.reusable_future(messageHash.clone());
        let mut authenticated: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".to_string())), messageHash.clone(), &[]);
        if is_equal(&authenticated, &Value::Null) {
            let mut nonce: Value = self.milliseconds();
            let mut payload: Value = add(&Value::Str("AUTH".to_string()), &to_string_val(&nonce));
            let mut signature: Value = self.hmac(self.encode(payload.clone()), self.encode(self.secret.clone()), Value::Str("sha384".to_string()), &[Value::Str("hex".to_string())]);
            let mut event: Value = Value::Str("auth".to_string());
            let mut request: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("apiKey".to_string(), self.apiKey.clone());
                    m.insert("authSig".to_string(), signature.clone());
                    m.insert("authNonce".to_string(), nonce.clone());
                    m.insert("authPayload".to_string(), payload.clone());
                    m.insert("event".to_string(), event.clone());
                m
            });
            let mut message: Value = self.extend(request.clone(), &[params.clone()]);
            self.watch(url.clone(), messageHash.clone(), &[message.clone(), messageHash.clone()]).await;
        }
        return crate::exchange_stubs::ws_await_flight(&future).await;

    Value::Null
}

    pub fn handle_authentication_message(&self, mut client: Value, mut message: Value) {
        let mut messageHash: Value = Value::Str("authenticated".to_string());
        let mut status: Value = self.safe_string_k(message.clone(), "status", &[]);
        if is_equal(&status, &Value::Str("OK".to_string())) {
            // we resolve the future here permanently so authentication only happens once
            let mut future: Value = self.safe_value(get_value(&client, &Value::Str("futures".to_string())), messageHash.clone(), &[]);
            future.resolve(&[Value::Bool(true)]);
        }  else {
            let mut error = Value::from(crate::exchange_errors::authentication_error(self.json(message.clone())));
            client.reject(&[Value::from(error.clone()), messageHash.clone()]);
            // allows further authentication attempts
            if is_true(&Value::Bool(in_op(&get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash))) {
                remove(&mut get_value(&client, &Value::Str("subscriptions".to_string())), &messageHash);
            }
        }
}

/*
 * @method
 * @name bitfinex#watchOrders
 * @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
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut messageHash: Value = Value::Str("orders".to_string());
        if !is_equal(&symbol, &Value::Null) {
            let mut market: Value = self.market(symbol.clone());
            messageHash = add(&messageHash, &add(&Value::Str(":".to_string()), &get_value(&market, &Value::Str("id".to_string()))));
        }
        let mut orders: Value = self.subscribe_private(messageHash.clone()).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(orders.clone(), &[symbol.clone(), since.clone(), limit.clone(), Value::Bool(true)]);

    Value::Null
}

    pub fn handle_orders(&mut self, mut client: Value, mut message: Value, mut subscription: Value) {
        //
        // limit order
        //    [
        //        0,
        //        "on", // ou or oc
        //        [
        //           96923856256, // order id
        //           null, // gid
        //           1655029337026, // cid
        //           "tLTCUST", // symbol
        //           1655029337027, // created timestamp
        //           1655029337029, // updated timestamp
        //           0.1, // amount
        //           0.1, // amount_orig
        //           "EXCHANGE LIMIT", // order type
        //           null, // type_prev
        //           null, // mts_tif
        //           null, // placeholder
        //           0, // flags
        //           "ACTIVE", // status
        //           null,
        //           null,
        //           30, // price
        //           0, // price average
        //           0, // price_trailing
        //           0, // price_aux_limit
        //           null,
        //           null,
        //           null,
        //           0, // notify
        //           0,
        //           null,
        //           null,
        //           null,
        //           "BFX",
        //           null,
        //           null,
        //        ]
        //    ]
        //
        let mut data: Value = self.safe_value(message.clone(), Value::Int(2), &[Value::List(vec![])]);
        let mut messageType: Value = self.safe_string(message.clone(), Value::Int(1), &[]);
        if is_equal(&self.orders, &Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
            self.orders = ArrayCacheBySymbolById::new(limit.clone());
        }
        let mut orders: Value = self.orders.clone();
        let mut symbolIds: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        if is_equal(&messageType, &Value::Str("os".to_string())) {
            let mut snapshotLength: Value = get_array_length(&data);
            if is_equal(&snapshotLength, &Value::Int(0)) {
                return;
            }
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_108: bool = true;
                while { if !__for_first_108 { i = add(&i, &Value::Int(1)); } __for_first_108 = false; is_less_than(&i, &get_array_length(&data)) } {
                let mut value: Value = get_value(&data, &i);
                let mut value: Value = get_value(&data, &i);
                let mut parsed: Value = self.parse_ws_order(value.clone(), &[]);
                let mut symbol: Value = get_value(&parsed, &Value::Str("symbol".to_string()));
                add_element_to_object(&mut symbolIds, &symbol, Value::Bool(true));
                orders.append(parsed.clone());
            }
            }
        }  else {
            let mut parsed: Value = self.parse_ws_order(data.clone(), &[]);
            orders.append(parsed.clone());
            let mut symbol: Value = get_value(&parsed, &Value::Str("symbol".to_string()));
            add_element_to_object(&mut symbolIds, &symbol, Value::Bool(true));
        }
        let mut name: Value = Value::Str("orders".to_string());
        client.resolve(&[self.orders.clone(), name.clone()]);
        let mut keys: Value = object_keys(&symbolIds);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_109: bool = true;
            while { if !__for_first_109 { i = add(&i, &Value::Int(1)); } __for_first_109 = false; is_less_than(&i, &get_array_length(&keys)) } {
            let mut symbol: Value = get_value(&keys, &i);
            let mut symbol: Value = get_value(&keys, &i);
            let mut market: Value = self.market(symbol.clone());
            let mut messageHash: Value = add(&add(&name, &Value::Str(":".to_string())), &get_value(&market, &Value::Str("id".to_string())));
            client.resolve(&[self.orders.clone(), messageHash.clone()]);
        }
        }
}

    pub fn parse_ws_order_status(&self, mut status: Value) -> Value {
        let mut statuses: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("ACTIVE".to_string(), Value::Str("open".to_string()));
                m.insert("CANCELED".to_string(), Value::Str("canceled".to_string()));
                m.insert("EXECUTED".to_string(), Value::Str("closed".to_string()));
                m.insert("PARTIALLY".to_string(), Value::Str("open".to_string()));
            m
        });
        return self.safe_string(statuses.clone(), status.clone(), &[status.clone()]);

    Value::Null
}

    pub fn parse_ws_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //   [
        //       97084883506, // order id
        //       null,
        //       1655110144596, // clientOrderId
        //       "tLTCUST", // symbol
        //       1655110144596, // created timestamp
        //       1655110144598, // updated timestamp
        //       0, // amount
        //       0.1, // amount_orig negative if sell order
        //       "EXCHANGE MARKET", // type
        //       null,
        //       null,
        //       null,
        //       0,
        //       "EXECUTED @ 42.821(0.1)", // status
        //       null,
        //       null,
        //       42.799, // price
        //       42.821, // price average
        //       0, // price trailing
        //       0, // price_aux_limit
        //       null,
        //       null,
        //       null,
        //       0,
        //       0,
        //       null,
        //       null,
        //       null,
        //       "BFX",
        //       null,
        //       null,
        //       {}
        //   ]
        //
        let mut id: Value = self.safe_string(order.clone(), Value::Int(0), &[]);
        let mut clientOrderId: Value = self.safe_string(order.clone(), Value::Int(1), &[]);
        let mut marketId: Value = self.safe_string(order.clone(), Value::Int(3), &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        market = self.safe_market(&[symbol.clone()]);
        let mut amount: Value = self.safe_string(order.clone(), Value::Int(7), &[]);
        let mut side: Value = Value::Str("buy".to_string());
        if is_true(&crate::precise::Precise::stringLt(&amount, &Value::Str("0".to_string()))) {
            amount = crate::precise::Precise::stringAbs(&amount);
            side = Value::Str("sell".to_string());
        }
        let mut remaining: Value = crate::precise::Precise::stringAbs(&self.safe_string(order.clone(), Value::Int(6), &[]));
        let mut type_var: Value = self.safe_string(order.clone(), Value::Int(8), &[Value::Str("".to_string())]);
        if is_greater_than(&get_index_of(&type_var, &Value::Str("LIMIT".to_string())), &negate(&Value::Int(1))) {
            type_var = Value::Str("limit".to_string());
        }  else if is_greater_than(&get_index_of(&type_var, &Value::Str("MARKET".to_string())), &negate(&Value::Int(1))) {
            type_var = Value::Str("market".to_string());
        }
        let mut rawState: Value = self.safe_string(order.clone(), Value::Int(13), &[Value::Str("".to_string())]);
        let mut stateParts: Value = split(&rawState, &Value::Str(" ".to_string()));
        let mut trimmedStatus: Value = self.safe_string(stateParts.clone(), Value::Int(0), &[]);
        let mut status: Value = self.parse_ws_order_status(trimmedStatus.clone());
        let mut price: Value = self.safe_string(order.clone(), Value::Int(16), &[]);
        let mut timestamp: Value = self.safe_integer2(order.clone(), Value::Int(5), Value::Int(4), &[]);
        let mut average: Value = self.safe_string(order.clone(), Value::Int(17), &[]);
        let mut stopPrice: Value = self.omit_zero(self.safe_string(order.clone(), Value::Int(18), &[]));
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order.clone());
        m.insert("id".to_string(), id.clone());
        m.insert("clientOrderId".to_string(), clientOrderId.clone());
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("lastTradeTimestamp".to_string(), Value::Null);
        m.insert("symbol".to_string(), symbol.clone());
        m.insert("type".to_string(), type_var.clone());
        m.insert("side".to_string(), side.clone());
        m.insert("price".to_string(), price.clone());
        m.insert("stopPrice".to_string(), stopPrice.clone());
        m.insert("triggerPrice".to_string(), stopPrice.clone());
        m.insert("average".to_string(), average.clone());
        m.insert("amount".to_string(), amount.clone());
        m.insert("remaining".to_string(), remaining.clone());
        m.insert("filled".to_string(), Value::Null);
        m.insert("status".to_string(), status.clone());
        m.insert("fee".to_string(), Value::Null);
        m.insert("cost".to_string(), Value::Null);
        m.insert("trades".to_string(), Value::Null);
    m
}), &[market.clone()]);

    Value::Null
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        let mut channelId: Value = self.safe_string(message.clone(), Value::Int(0), &[]);
        //
        //     [
        //         1231,
        //         "hb",
        //     ]
        //
        // auth message
        //    {
        //        "event": "auth",
        //        "status": "OK",
        //        "chanId": 0,
        //        "userId": 3159883,
        //        "auth_id": "ac7108e7-2f26-424d-9982-c24700dc02ca",
        //        "caps": {
        //          "orders": { read: 1, write: 1 },
        //          "account": { read: 1, write: 1 },
        //          "funding": { read: 1, write: 1 },
        //          "history": { read: 1, write: 0 },
        //          "wallets": { read: 1, write: 1 },
        //          "withdraw": { read: 0, write: 1 },
        //          "positions": { read: 1, write: 1 },
        //          "ui_withdraw": { read: 0, write: 0 }
        //        }
        //    }
        //
        if is_true(&Value::Bool(is_array(&message))) {
            if is_equal(&get_value(&message, &Value::Int(1)), &Value::Str("hb".to_string())) {
                return;
            }
            let mut subscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".to_string())), channelId.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut channel: Value = self.safe_string_k(subscription.clone(), "channel", &[]);
            let mut name: Value = self.safe_string(message.clone(), Value::Int(1), &[]);
            let mut publicMethods: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("book".to_string(), Value::Str("handle_order_book".to_string()).clone());
                    m.insert("cs".to_string(), Value::Str("handle_checksum".to_string()).clone());
                    m.insert("candles".to_string(), Value::Str("handle_ohlcv".to_string()).clone());
                    m.insert("ticker".to_string(), Value::Str("handle_ticker".to_string()).clone());
                    m.insert("trades".to_string(), Value::Str("handle_trades".to_string()).clone());
                m
            });
            let mut privateMethods: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("os".to_string(), Value::Str("handle_orders".to_string()).clone());
                    m.insert("ou".to_string(), Value::Str("handle_orders".to_string()).clone());
                    m.insert("on".to_string(), Value::Str("handle_orders".to_string()).clone());
                    m.insert("oc".to_string(), Value::Str("handle_orders".to_string()).clone());
                    m.insert("wu".to_string(), Value::Str("handle_balance".to_string()).clone());
                    m.insert("ws".to_string(), Value::Str("handle_balance".to_string()).clone());
                    m.insert("tu".to_string(), Value::Str("handle_my_trade".to_string()).clone());
                m
            });
            let mut method: Value = Value::Null;
            if is_equal(&channelId, &Value::Str("0".to_string())) {
                method = self.safe_value(privateMethods.clone(), name.clone(), &[]);
            }  else {
                method = self.safe_value2(publicMethods.clone(), name.clone(), channel.clone(), &[]);
            }
            if !is_equal(&method, &Value::Null) {
                self.dispatch_ws_handler(&method, &[client.clone(), message.clone(), subscription.clone()]);
            }
        }  else {
            let mut event: Value = self.safe_string_k(message.clone(), "event", &[]);
            if !is_equal(&event, &Value::Null) {
                let mut methods: Value = Value::Map({
                    let mut m = indexmap::IndexMap::new();
                        m.insert("info".to_string(), Value::Str("handle_system_status".to_string()).clone());
                        m.insert("subscribed".to_string(), Value::Str("handle_subscription_status".to_string()).clone());
                        m.insert("unsubscribed".to_string(), Value::Str("handle_unsubscription_status".to_string()).clone());
                        m.insert("auth".to_string(), Value::Str("handle_authentication_message".to_string()).clone());
                    m
                });
                let mut method: Value = self.safe_value(methods.clone(), event.clone(), &[]);
                if !is_equal(&method, &Value::Null) {
                    self.dispatch_ws_handler(&method, &[client.clone(), message.clone()]);
                }
            }
        }
}
}