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

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

    pub fn init(&mut self) {
        let described = CoinbaseCore::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 CoinbaseCore {
    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 CoinbaseCore {
    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 {
                "create_ws_auth" => self.create_ws_auth(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_heartbeats" => self.handle_heartbeats(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
                "handle_subscription_status" => self.handle_subscription_status(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
                "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_ticker" => self.parse_ws_ticker(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_multiple" => self.subscribe_multiple(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args.get(2..).unwrap_or(&[]).to_vec()[..]).await,
                "un_subscribe" => self.un_subscribe(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), &args.get(3..).unwrap_or(&[]).to_vec()[..]).await,
                "un_subscribe_multiple" => self.un_subscribe_multiple(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), &args.get(3..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_order_book" => self.un_watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_orders" => self.un_watch_orders(&args.get(0..).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_tickers" => self.un_watch_tickers(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_trades" => self.un_watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "un_watch_trades_for_symbols" => self.un_watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_order_book_for_symbols" => self.watch_order_book_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_orders" => self.watch_orders(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_tickers" => self.watch_tickers(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                "watch_trades_for_symbols" => self.watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
                // 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 CoinbaseCore {
    /// 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 {
            "create_ws_auth" => self.create_ws_auth(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_heartbeats" => self.handle_heartbeats(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
            "handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order" => { self.handle_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order_book" => { self.handle_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order_book_helper" => { self.handle_order_book_helper(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_tickers" => { self.handle_tickers(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_trade" => { self.handle_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "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_ticker" => self.parse_ws_ticker(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_multiple" => { crate::exchange_stubs::enqueue_spawn("subscribe_multiple", args.to_vec()); crate::Value::Null },
            "try_resolve_usdc" => { self.try_resolve_usdc(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 },
            "un_subscribe" => { crate::exchange_stubs::enqueue_spawn("un_subscribe", args.to_vec()); crate::Value::Null },
            "un_subscribe_multiple" => { crate::exchange_stubs::enqueue_spawn("un_subscribe_multiple", args.to_vec()); crate::Value::Null },
            "un_watch_order_book" => { crate::exchange_stubs::enqueue_spawn("un_watch_order_book", args.to_vec()); crate::Value::Null },
            "un_watch_orders" => { crate::exchange_stubs::enqueue_spawn("un_watch_orders", args.to_vec()); crate::Value::Null },
            "un_watch_ticker" => { crate::exchange_stubs::enqueue_spawn("un_watch_ticker", args.to_vec()); crate::Value::Null },
            "un_watch_tickers" => { crate::exchange_stubs::enqueue_spawn("un_watch_tickers", args.to_vec()); crate::Value::Null },
            "un_watch_trades" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades", args.to_vec()); crate::Value::Null },
            "un_watch_trades_for_symbols" => { crate::exchange_stubs::enqueue_spawn("un_watch_trades_for_symbols", args.to_vec()); crate::Value::Null },
            "watch_order_book" => { crate::exchange_stubs::enqueue_spawn("watch_order_book", args.to_vec()); crate::Value::Null },
            "watch_order_book_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_order_book_for_symbols", args.to_vec()); crate::Value::Null },
            "watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
            "watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
            "watch_tickers" => { crate::exchange_stubs::enqueue_spawn("watch_tickers", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            "watch_trades_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_trades_for_symbols", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

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

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

impl CoinbaseCore {
    pub fn describe(&self) -> Value {
        return self.deep_extend(self.parent.describe(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("has".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Bool(true));
        m.insert("cancelAllOrdersWs".to_string(), Value::Bool(false));
        m.insert("cancelOrdersWs".to_string(), Value::Bool(false));
        m.insert("cancelOrderWs".to_string(), Value::Bool(false));
        m.insert("createOrderWs".to_string(), Value::Bool(false));
        m.insert("editOrderWs".to_string(), Value::Bool(false));
        m.insert("fetchBalanceWs".to_string(), Value::Bool(false));
        m.insert("fetchOpenOrdersWs".to_string(), Value::Bool(false));
        m.insert("fetchOrderWs".to_string(), Value::Bool(false));
        m.insert("fetchTradesWs".to_string(), Value::Bool(false));
        m.insert("watchBalance".to_string(), Value::Bool(false));
        m.insert("watchMyTrades".to_string(), Value::Bool(false));
        m.insert("watchOHLCV".to_string(), Value::Bool(false));
        m.insert("watchOrderBook".to_string(), Value::Bool(true));
        m.insert("watchOrderBookForSymbols".to_string(), Value::Bool(true));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchTicker".to_string(), Value::Bool(true));
        m.insert("watchTickers".to_string(), Value::Bool(true));
        m.insert("watchTrades".to_string(), Value::Bool(true));
        m.insert("watchTradesForSymbols".to_string(), Value::Bool(true));
        m.insert("unWatchTicker".to_string(), Value::Bool(true));
        m.insert("unWatchTickers".to_string(), Value::Bool(true));
        m.insert("unWatchTrades".to_string(), Value::Bool(true));
        m.insert("unWatchOrders".to_string(), Value::Bool(true));
        m.insert("unWatchTradesForSymbols".to_string(), Value::Bool(true));
    m
}));
        m.insert("urls".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("api".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ws".to_string(), Value::Str("wss://advanced-trade-ws.coinbase.com".to_string()));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("tradesLimit".to_string(), Value::Int(1000));
        m.insert("ordersLimit".to_string(), Value::Int(1000));
        m.insert("myTradesLimit".to_string(), Value::Int(1000));
        m.insert("sides".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("bid".to_string(), Value::Str("bids".to_string()));
        m.insert("offer".to_string(), Value::Str("asks".to_string()));
    m
}));
    m
}));
    m
})]);

    Value::Null
}

/*
 * @ignore
 * @method
 * @description subscribes to a websocket channel
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
 * @param {string} name the name of the channel
 * @param {boolean} isPrivate whether the channel is private or not
 * @param {string} [symbol] unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} subscription to a websocket channel
 */
    pub async fn subscribe(&mut self, mut name: Value, mut isPrivate: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut market: Value = Value::Null;
        let mut messageHash: Value = name.clone();
        let mut productIds: Value = Value::List(vec![]);
        if is_true(&Value::Bool(is_array(&symbol))) {
            let mut symbols: Value = self.market_symbols(&[symbol.clone()]);
            let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
            if is_equal(&marketIds, &Value::Null) {
                productIds = Value::List(vec![]);
            }  else {
                productIds = marketIds.clone();
            }
            messageHash = add(&add(&messageHash, &Value::Str("::".to_string())), &join(&symbols, &Value::Str(",".to_string())));
        }  else if !is_equal(&symbol, &Value::Null) {
            market = self.market(symbol.clone());
            messageHash = add(&add(&name, &Value::Str("::".to_string())), &symbol);
            productIds = Value::List(vec![get_value(&market, &Value::Str("id".to_string()))]);
        }
        let mut url: Value = get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string()));
        let mut subscribe: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                m.insert("product_ids".to_string(), productIds.clone());
                m.insert("channel".to_string(), name.clone());
            m
        });
        if is_true(&isPrivate) {
            let __ws_arg_0 = self.create_ws_auth(name.clone(), productIds.clone());
            subscribe = self.extend(subscribe.clone(), &[__ws_arg_0]);
        }
        return self.watch(url.clone(), messageHash.clone(), &[subscribe.clone(), messageHash.clone()]).await;

    Value::Null
}

/*
 * @ignore
 * @method
 * @description unSubscribes to a websocket channel
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
 * @param {string} topic unified topic
 * @param {string} name the name of the channel
 * @param {boolean} isPrivate whether the channel is private or not
 * @param {string} [symbol] unified market symbol
 * @returns {object} subscription to a websocket channel
 */
    pub async fn un_subscribe(&mut self, mut topic: Value, mut name: Value, mut isPrivate: Value, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        if is_true(&self.safe_bool_k(self.options.clone(), "unSubscriptionPending", &[Value::Bool(false)])) {
            panic!("{}", crate::exchange_errors::exchange_error(add(&self.id, &Value::Str(" another unSubscription is pending, coinbase does not support concurrent unSubscriptions".to_string()))));
        }
        add_element_to_object(&mut self.options, &Value::Str("unSubscriptionPending".to_string()), Value::Bool(true));
        let mut market: Value = Value::Null;
        let mut watchMessageHash: Value = name.clone();
        let mut unWatchMessageHash: Value = add(&Value::Str("unsubscribe:".to_string()), &name);
        let mut productIds: Value = Value::List(vec![]);
        if is_true(&Value::Bool(is_array(&symbol))) {
            let mut symbols: Value = self.market_symbols(&[symbol.clone()]);
            let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
            if is_equal(&marketIds, &Value::Null) {
                productIds = Value::List(vec![]);
            }  else {
                productIds = marketIds.clone();
            }
            watchMessageHash = add(&add(&watchMessageHash, &Value::Str("::".to_string())), &join(&symbols, &Value::Str(",".to_string())));
            unWatchMessageHash = add(&add(&unWatchMessageHash, &Value::Str("::".to_string())), &join(&symbols, &Value::Str(",".to_string())));
        }  else if !is_equal(&symbol, &Value::Null) {
            market = self.market(symbol.clone());
            watchMessageHash = add(&add(&name, &Value::Str("::".to_string())), &symbol);
            unWatchMessageHash = add(&add(&unWatchMessageHash, &Value::Str("::".to_string())), &symbol);
            productIds = Value::List(vec![get_value(&market, &Value::Str("id".to_string()))]);
        }
        let mut url: Value = get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string()));
        // '{"type": "unsubscribe", "product_ids": ["BTC-USD", "ETH-USD"], "channel": "ticker"}'
        let mut message: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("unsubscribe".to_string()));
                m.insert("product_ids".to_string(), productIds.clone());
                m.insert("channel".to_string(), name.clone());
            m
        });
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), Value::List(vec![unWatchMessageHash.clone()]));
                m.insert("subMessageHashes".to_string(), Value::List(vec![watchMessageHash.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
        });
        if is_true(&isPrivate) {
            let __ws_arg_1 = self.create_ws_auth(name.clone(), productIds.clone());
            message = self.extend(message.clone(), &[__ws_arg_1]);
        }
        add_element_to_object(&mut self.options, &Value::Str("unSubscription".to_string()), subscription.clone());
        let mut res: Value = self.watch(url.clone(), unWatchMessageHash.clone(), &[message.clone(), unWatchMessageHash.clone(), subscription.clone()]).await;
        add_element_to_object(&mut self.options, &Value::Str("unSubscriptionPending".to_string()), Value::Bool(false));
        add_element_to_object(&mut self.options, &Value::Str("unSubscription".to_string()), Value::Null);
        return res;

    Value::Null
}

/*
 * @ignore
 * @method
 * @description subscribes to a websocket channel
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
 * @param {string} name the name of the channel
 * @param {boolean} isPrivate whether the channel is private or not
 * @param {string[]} [symbols] unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} subscription to a websocket channel
 */
    pub async fn subscribe_multiple(&mut self, mut name: Value, mut isPrivate: Value, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut productIds: Value = Value::List(vec![]);
        let mut messageHashes: Value = Value::List(vec![]);
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false)]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_247: bool = true;
            while { if !__for_first_247 { i = add(&i, &Value::Int(1)); } __for_first_247 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            let mut market: Value = self.market(symbol.clone());
            let mut marketId: Value = get_value(&market, &Value::Str("id".to_string()));
            append_to_array(&mut productIds, marketId.clone());
            append_to_array(&mut messageHashes, add(&add(&name, &Value::Str("::".to_string())), &symbol));
        }
        }
        let mut url: Value = get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string()));
        let mut subscribe: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("subscribe".to_string()));
                m.insert("product_ids".to_string(), productIds.clone());
                m.insert("channel".to_string(), name.clone());
            m
        });
        if is_true(&isPrivate) {
            let __ws_arg_2 = self.create_ws_auth(name.clone(), productIds.clone());
            subscribe = self.extend(subscribe.clone(), &[__ws_arg_2]);
        }
        return self.watch_multiple(url.clone(), messageHashes.clone(), &[subscribe.clone(), messageHashes.clone()]).await;

    Value::Null
}

/*
 * @ignore
 * @method
 * @description unsubscribes to a websocket channel
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
 * @param {string} topic unified topic
 * @param {string} name the name of the channel
 * @param {boolean} isPrivate whether the channel is private or not
 * @param {string[]} [symbols] unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} subscription to a websocket channel
 */
    pub async fn un_subscribe_multiple(&mut self, mut topic: Value, mut name: Value, mut isPrivate: Value, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_true(&self.safe_bool_k(self.options.clone(), "unSubscriptionPending", &[Value::Bool(false)])) {
            panic!("{}", crate::exchange_errors::exchange_error(add(&self.id, &Value::Str(" another unSubscription is pending, coinbase does not support concurrent unSubscriptions".to_string()))));
        }
        add_element_to_object(&mut self.options, &Value::Str("unSubscriptionPending".to_string()), Value::Bool(true));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut productIds: Value = Value::List(vec![]);
        let mut watchMessageHashes: Value = Value::List(vec![]);
        let mut unWatchMessageHashes: Value = Value::List(vec![]);
        symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false)]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_248: bool = true;
            while { if !__for_first_248 { i = add(&i, &Value::Int(1)); } __for_first_248 = false; is_less_than(&i, &get_array_length(&symbols)) } {
            let mut symbol: Value = get_value(&symbols, &i);
            let mut symbol: Value = get_value(&symbols, &i);
            let mut market: Value = self.market(symbol.clone());
            let mut marketId: Value = get_value(&market, &Value::Str("id".to_string()));
            append_to_array(&mut productIds, marketId.clone());
            append_to_array(&mut watchMessageHashes, add(&add(&name, &Value::Str("::".to_string())), &symbol));
            append_to_array(&mut unWatchMessageHashes, add(&add(&add(&Value::Str("unsubscribe:".to_string()), &name), &Value::Str("::".to_string())), &symbol));
        }
        }
        let mut url: Value = get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string()));
        let mut message: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), Value::Str("unsubscribe".to_string()));
                m.insert("product_ids".to_string(), productIds.clone());
                m.insert("channel".to_string(), name.clone());
            m
        });
        if is_true(&isPrivate) {
            let __ws_arg_3 = self.create_ws_auth(name.clone(), productIds.clone());
            message = self.extend(message.clone(), &[__ws_arg_3]);
        }
        let mut subscription: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("messageHashes".to_string(), unWatchMessageHashes.clone());
                m.insert("subMessageHashes".to_string(), watchMessageHashes.clone());
                m.insert("topic".to_string(), topic.clone());
                m.insert("unsubscribe".to_string(), Value::Bool(true));
                m.insert("symbols".to_string(), symbols.clone());
            m
        });
        add_element_to_object(&mut self.options, &Value::Str("unSubscription".to_string()), subscription.clone());
        let mut res: Value = self.watch_multiple(url.clone(), unWatchMessageHashes.clone(), &[message.clone(), unWatchMessageHashes.clone(), subscription.clone()]).await;
        add_element_to_object(&mut self.options, &Value::Str("unSubscriptionPending".to_string()), Value::Bool(false));
        add_element_to_object(&mut self.options, &Value::Str("unSubscription".to_string()), Value::Null);
        return res;

    Value::Null
}

    pub fn create_ws_auth(&mut self, mut name: Value, mut productIds: Value) -> Value {
        let mut subscribe: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        });
        let mut timestamp: Value = self.number_to_string(self.seconds());
        self.check_required_credentials(&[]);
        let mut isCloudAPiKey: bool = is_true(&(is_greater_than_or_equal(&get_index_of(&self.apiKey, &Value::Str("organizations/".to_string())), &Value::Int(0)))) || is_true(&(Value::Bool(starts_with(&self.secret, &Value::Str("-----BEGIN".to_string())))));
        let mut auth: Value = add(&add(&timestamp, &name), &join(&productIds, &Value::Str(",".to_string())));
        if !is_true(&isCloudAPiKey) {
            add_element_to_object(&mut subscribe, &Value::Str("api_key".to_string()), self.apiKey.clone());
            add_element_to_object(&mut subscribe, &Value::Str("timestamp".to_string()), timestamp.clone());
            add_element_to_object(&mut subscribe, &Value::Str("signature".to_string()), self.hmac(self.encode(auth.clone()), self.encode(self.secret.clone()), Value::Str("sha256".to_string()), &[]));
        }  else {
            if is_true(&Value::Bool(starts_with(&self.apiKey, &Value::Str("-----BEGIN".to_string())))) {
                panic!("{}", crate::exchange_errors::arguments_required(add(&self.id, &Value::Str(" apiKey should contain the name (eg: organizations/3b910e93....) and not the public key".to_string()))));
            }
            let mut currentToken: Value = self.safe_string_k(self.options.clone(), "wsToken", &[]);
            let mut tokenTimestamp: Value = self.safe_integer_k(self.options.clone(), "wsTokenTimestamp", &[Value::Int(0)]);
            let mut seconds: Value = self.seconds();
            if is_equal(&currentToken, &Value::Null) || is_less_than(&add(&tokenTimestamp, &Value::Int(120)), &seconds) {
                // we should generate new token
                let mut token: Value = self.parent.create_auth_token(seconds.clone(), &[]);
                add_element_to_object(&mut self.options, &Value::Str("wsToken".to_string()), token.clone());
                add_element_to_object(&mut self.options, &Value::Str("wsTokenTimestamp".to_string()), seconds.clone());
            }
            add_element_to_object(&mut subscribe, &Value::Str("jwt".to_string()), self.safe_string_k(self.options.clone(), "wsToken", &[]));
        }
        return subscribe;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-channel
 * @param {string} [symbol] unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("ticker".to_string());
        return self.subscribe(name.clone(), Value::Bool(false), &[symbol.clone(), params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#unWatchTicker
 * @description stops watching a price ticker
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-channel
 * @param {string} [symbol] unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn un_watch_ticker(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("ticker".to_string());
        return self.un_subscribe(Value::Str("ticker".to_string()), name.clone(), Value::Bool(false), &[symbol.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchTickers
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-batch-channel
 * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn watch_tickers(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        if is_equal(&symbols, &Value::Null) {
            symbols = self.symbols.clone();
        }
        let mut name: Value = Value::Str("ticker_batch".to_string());
        let mut ticker: Value = self.subscribe_multiple(name.clone(), Value::Bool(false), &[symbols.clone(), params.clone()]).await;
        if is_true(&self.newUpdates) {
            let mut tickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            let mut symbol: Value = get_value(&ticker, &Value::Str("symbol".to_string()));
            add_element_to_object(&mut tickers, &symbol, ticker.clone());
            return tickers;
        }
        return self.tickers.clone();

    Value::Null
}

/*
 * @method
 * @name coinbase#unWatchTickers
 * @description stop watching
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-batch-channel
 * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/?id=ticker-structure}
 */
    pub async fn un_watch_tickers(&mut self, optional_args: &[Value]) -> Value {
        let mut symbols = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        if is_equal(&symbols, &Value::Null) {
            symbols = self.symbols.clone();
        }
        return self.un_subscribe_multiple(Value::Str("ticker".to_string()), Value::Str("ticker_batch".to_string()), Value::Bool(false), &[symbols.clone()]).await;

    Value::Null
}

    pub fn handle_tickers(&mut self, mut client: Value, mut message: Value) {
        //
        //    {
        //        "channel": "ticker",
        //        "client_id": "",
        //        "timestamp": "2023-02-09T20:30:37.167359596Z",
        //        "sequence_num": 0,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "tickers": [
        //                    {
        //                        "type": "ticker",
        //                        "product_id": "BTC-USD",
        //                        "price": "21932.98",
        //                        "volume_24_h": "16038.28770938",
        //                        "low_24_h": "21835.29",
        //                        "high_24_h": "23011.18",
        //                        "low_52_w": "15460",
        //                        "high_52_w": "48240",
        //                        "price_percent_chg_24_h": "-4.15775596190603"
        // new as of 2024-04-12
        //                        "best_bid":"21835.29",
        //                        "best_bid_quantity": "0.02000000",
        //                        "best_ask":"23011.18",
        //                        "best_ask_quantity": "0.01500000"
        //                    }
        //                ]
        //            }
        //        ]
        //    }
        //
        //    {
        //        "channel": "ticker_batch",
        //        "client_id": "",
        //        "timestamp": "2023-03-01T12:15:18.382173051Z",
        //        "sequence_num": 0,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "tickers": [
        //                    {
        //                        "type": "ticker",
        //                        "product_id": "DOGE-USD",
        //                        "price": "0.08212",
        //                        "volume_24_h": "242556423.3",
        //                        "low_24_h": "0.07989",
        //                        "high_24_h": "0.08308",
        //                        "low_52_w": "0.04908",
        //                        "high_52_w": "0.1801",
        //                        "price_percent_chg_24_h": "0.50177456859626"
        // new as of 2024-04-12
        //                        "best_bid":"0.07989",
        //                        "best_bid_quantity": "500.0",
        //                        "best_ask":"0.08308",
        //                        "best_ask_quantity": "300.0"
        //                    }
        //                ]
        //            }
        //        ]
        //    }
        //
        // note! seems coinbase might also send empty data like:
        //
        //    {
        //        "channel": "ticker_batch",
        //        "client_id": "",
        //        "timestamp": "2024-05-24T18:22:24.546809523Z",
        //        "sequence_num": 1,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "tickers": [
        //                    {
        //                        "type": "ticker",
        //                        "product_id": "",
        //                        "price": "",
        //                        "volume_24_h": "",
        //                        "low_24_h": "",
        //                        "high_24_h": "",
        //                        "low_52_w": "",
        //                        "high_52_w": "",
        //                        "price_percent_chg_24_h": ""
        //                    }
        //                ]
        //            }
        //        ]
        //    }
        //
        //
        let mut channel: Value = self.safe_string_k(message.clone(), "channel", &[]);
        let mut events: Value = self.safe_list_k(message.clone(), "events", &[Value::List(vec![])]);
        let mut datetime: Value = self.safe_string_k(message.clone(), "timestamp", &[]);
        let mut timestamp: Value = self.parse8601(datetime.clone());
        let mut newTickers: Value = Value::List(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_250: bool = true;
            while { if !__for_first_250 { i = add(&i, &Value::Int(1)); } __for_first_250 = false; is_less_than(&i, &get_array_length(&events)) } {
            let mut tickersObj: Value = get_value(&events, &i);
            let mut tickersObj: Value = get_value(&events, &i);
            let mut tickers: Value = self.safe_list_k(tickersObj.clone(), "tickers", &[Value::List(vec![])]);
            {
                                let mut j: Value = Value::Int(0);
                let mut __for_first_249: bool = true;
                while { if !__for_first_249 { j = add(&j, &Value::Int(1)); } __for_first_249 = false; is_less_than(&j, &get_array_length(&tickers)) } {
                let mut ticker: Value = get_value(&tickers, &j);
                let mut ticker: Value = get_value(&tickers, &j);
                let mut wsMarketId: Value = self.safe_string_k(ticker.clone(), "product_id", &[]);
                if is_equal(&wsMarketId, &Value::Null) {
                    continue;
                }
                let mut result: Value = self.parse_ws_ticker(ticker.clone(), &[]);
                add_element_to_object(&mut result, &Value::Str("timestamp".to_string()), timestamp.clone());
                add_element_to_object(&mut result, &Value::Str("datetime".to_string()), datetime.clone());
                let mut symbol: Value = get_value(&result, &Value::Str("symbol".to_string()));
                if !is_equal(&symbol, &Value::Null) {
                    add_element_to_object(&mut self.tickers, &symbol, result.clone());
                }
                append_to_array(&mut newTickers, result.clone());
                let mut messageHash: Value = add(&add(&channel, &Value::Str("::".to_string())), &symbol);
                client.resolve(&[result.clone(), messageHash.clone()]);
                self.try_resolve_usdc(client.clone(), messageHash.clone(), result.clone());
            }
            }
        }
        }
}

    pub fn parse_ws_ticker(&self, mut ticker: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //     {
        //         "type": "ticker",
        //         "product_id": "DOGE-USD",
        //         "price": "0.08212",
        //         "volume_24_h": "242556423.3",
        //         "low_24_h": "0.07989",
        //         "high_24_h": "0.08308",
        //         "low_52_w": "0.04908",
        //         "high_52_w": "0.1801",
        //         "price_percent_chg_24_h": "0.50177456859626"
        // new as of 2024-04-12
        //         "best_bid":"0.07989",
        //         "best_bid_quantity": "500.0",
        //         "best_ask":"0.08308",
        //         "best_ask_quantity": "300.0"
        //     }
        //
        let mut marketId: Value = self.safe_string_k(ticker.clone(), "product_id", &[]);
        let mut timestamp: Value = Value::Null;
        let mut last: Value = self.safe_number_k(ticker.clone(), "price", &[]);
        return self.safe_ticker(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), ticker.clone());
        m.insert("symbol".to_string(), self.safe_symbol(marketId.clone(), &[market.clone(), Value::Str("-".to_string())]));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
        m.insert("high".to_string(), self.safe_string_k(ticker.clone(), "high_24_h", &[]));
        m.insert("low".to_string(), self.safe_string_k(ticker.clone(), "low_24_h", &[]));
        m.insert("bid".to_string(), self.safe_string_k(ticker.clone(), "best_bid", &[]));
        m.insert("bidVolume".to_string(), self.safe_string_k(ticker.clone(), "best_bid_quantity", &[]));
        m.insert("ask".to_string(), self.safe_string_k(ticker.clone(), "best_ask", &[]));
        m.insert("askVolume".to_string(), self.safe_string_k(ticker.clone(), "best_ask_quantity", &[]));
        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(), Value::Null);
        m.insert("percentage".to_string(), self.safe_string_k(ticker.clone(), "price_percent_chg_24_h", &[]));
        m.insert("average".to_string(), Value::Null);
        m.insert("baseVolume".to_string(), self.safe_string_k(ticker.clone(), "volume_24_h", &[]));
        m.insert("quoteVolume".to_string(), Value::Null);
    m
}), &[]);

    Value::Null
}

/*
 * @method
 * @name coinbase#watchTrades
 * @description get the list of most recent trades for a particular symbol
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
 * @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
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        symbol = self.symbol(symbol.clone());
        let mut name: Value = Value::Str("market_trades".to_string());
        let mut trades: Value = self.subscribe(name.clone(), Value::Bool(false), &[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 coinbase#unWatchTrades
 * @description stops watching the list of most recent trades for a particular symbol
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
 * @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
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("market_trades".to_string());
        return self.un_subscribe(Value::Str("trades".to_string()), name.clone(), Value::Bool(false), &[symbol.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchTradesForSymbols
 * @description get the list of most recent trades for a particular symbol
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
 * @param {string[]} symbols 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_for_symbols(&mut self, mut symbols: Value, optional_args: &[Value]) -> Value {
        let mut since = get_arg(optional_args, 0, Value::Null);
        let mut limit = get_arg(optional_args, 1, Value::Null);
        let mut params = get_arg(optional_args, 2, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("market_trades".to_string());
        let mut trades: Value = self.subscribe_multiple(name.clone(), Value::Bool(false), &[symbols.clone(), params.clone()]).await;
        if is_true(&self.newUpdates) {
            let mut first: Value = self.safe_dict(trades.clone(), Value::Int(0), &[]);
            let mut tradeSymbol: Value = self.safe_string_k(first.clone(), "symbol", &[]);
            limit = trades.get_limit(tradeSymbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(trades.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name coinbase#unWatchTradesForSymbols
 * @description get the list of most recent trades for a particular symbol
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
 * @param {string[]} symbols 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_for_symbols(&mut self, mut symbols: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("market_trades".to_string());
        return self.un_subscribe_multiple(Value::Str("trades".to_string()), name.clone(), Value::Bool(false), &[symbols.clone(), params.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchOrders
 * @description watches information on multiple orders made by the user
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#user-channel
 * @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 name: Value = Value::Str("user".to_string());
        let mut orders: Value = self.subscribe(name.clone(), Value::Bool(true), &[symbol.clone(), params.clone()]).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_since_limit(orders.clone(), &[since.clone(), limit.clone(), Value::Str("timestamp".to_string()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name coinbase#unWatchOrders
 * @description stops watching information on multiple orders made by the user
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#user-channel
 * @param {string} [symbol] unified market symbol of the market orders were made in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
 */
    pub async fn un_watch_orders(&mut self, optional_args: &[Value]) -> Value {
        let mut symbol = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("user".to_string());
        return self.un_subscribe(Value::Str("orders".to_string()), name.clone(), Value::Bool(true), &[self.symbol(symbol.clone())]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchOrderBook
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("level2".to_string());
        let mut market: Value = self.market(symbol.clone());
        symbol = get_value(&market, &Value::Str("symbol".to_string()));
        let mut orderbook: Value = self.subscribe(name.clone(), Value::Bool(false), &[symbol.clone(), params.clone()]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name coinbase#unWatchOrderBook
 * @description stops watching information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn un_watch_order_book(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        symbol = self.symbol(symbol.clone());
        let mut name: Value = Value::Str("level2".to_string());
        return self.un_subscribe(Value::Str("orderbook".to_string()), name.clone(), Value::Bool(false), &[symbol.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name coinbase#watchOrderBookForSymbols
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
 * @param {string[]} symbols unified array of symbols
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [order book structure]{@link https://docs.ccxt.com/?id=order-book-structure}
 */
    pub async fn watch_order_book_for_symbols(&mut self, mut symbols: Value, optional_args: &[Value]) -> Value {
        let mut limit = get_arg(optional_args, 0, Value::Null);
        let mut params = get_arg(optional_args, 1, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if is_equal(&self.markets, &Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut name: Value = Value::Str("level2".to_string());
        let mut orderbook: Value = self.subscribe_multiple(name.clone(), Value::Bool(false), &[symbols.clone(), params.clone()]).await;
        return orderbook.limit();

    Value::Null
}

    pub fn handle_trade(&mut self, mut client: Value, mut message: Value) {
        //
        //    {
        //        "channel": "market_trades",
        //        "client_id": "",
        //        "timestamp": "2023-02-09T20:19:35.39625135Z",
        //        "sequence_num": 0,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "trades": [
        //                    {
        //                        "trade_id": "000000000",
        //                        "product_id": "ETH-USD",
        //                        "price": "1260.01",
        //                        "size": "0.3",
        //                        "side": "BUY",
        //                        "time": "2019-08-14T20:42:27.265Z",
        //                    }
        //                ]
        //            }
        //        ]
        //    }
        //
        let mut events: Value = self.safe_list_k(message.clone(), "events", &[]);
        if is_equal(&events, &Value::Null) {
            return;
        }
        let mut event: Value = self.safe_value(events.clone(), Value::Int(0), &[]);
        let mut trades: Value = self.safe_list_k(event.clone(), "trades", &[]);
        let mut trade: Value = self.safe_dict(trades.clone(), Value::Int(0), &[]);
        let mut marketId: Value = self.safe_string_k(trade.clone(), "product_id", &[]);
        let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
        let mut messageHash: Value = add(&Value::Str("market_trades::".to_string()), &symbol);
        let mut tradesArray: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if is_equal(&tradesArray, &Value::Null) {
            let mut tradesLimit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            tradesArray = ArrayCacheBySymbolById::new(tradesLimit.clone());
            add_element_to_object(&mut self.trades, &symbol, tradesArray.clone());
        }
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_252: bool = true;
            while { if !__for_first_252 { i = add(&i, &Value::Int(1)); } __for_first_252 = false; is_less_than(&i, &get_array_length(&events)) } {
            let mut currentEvent: Value = get_value(&events, &i);
            let mut currentEvent: Value = get_value(&events, &i);
            let mut currentTrades: Value = self.safe_list_k(currentEvent.clone(), "trades", &[]);
            if is_equal(&currentTrades, &Value::Null) {
                continue;
            }
            // coinbase sends trades newest-first, append them in reverse so the cache stays sorted by ascending timestamp
            let mut tradesLength: Value = get_array_length(&currentTrades);
            {
                                let mut j: Value = Value::Int(0);
                let mut __for_first_251: bool = true;
                while { if !__for_first_251 { j = add(&j, &Value::Int(1)); } __for_first_251 = false; is_less_than(&j, &tradesLength) } {
                let mut item: Value = get_value(&currentTrades, &subtract(&subtract(&tradesLength, &j), &Value::Int(1)));
                tradesArray.append(self.parse_trade(item.clone(), &[]));
            }
            }
        }
        }
        client.resolve(&[tradesArray.clone(), messageHash.clone()]);
        self.try_resolve_usdc(client.clone(), messageHash.clone(), tradesArray.clone());
}

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        //
        //    {
        //        "channel": "user",
        //        "client_id": "",
        //        "timestamp": "2023-02-09T20:33:57.609931463Z",
        //        "sequence_num": 0,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "orders": [
        //                    {
        //                        "order_id": "XXX",
        //                        "client_order_id": "YYY",
        //                        "cumulative_quantity": "0",
        //                        "leaves_quantity": "0.000994",
        //                        "avg_price": "0",
        //                        "total_fees": "0",
        //                        "status": "OPEN",
        //                        "product_id": "BTC-USD",
        //                        "creation_time": "2022-12-07T19:42:18.719312Z",
        //                        "order_side": "BUY",
        //                        "order_type": "Limit"
        //                    },
        //                ]
        //            }
        //        ]
        //    }
        //
        let mut events: Value = self.safe_list_k(message.clone(), "events", &[]);
        if is_equal(&events, &Value::Null) {
            return;
        }
        let mut marketIds: Value = Value::List(vec![]);
        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 i: Value = Value::Int(0);
            let mut __for_first_254: bool = true;
            while { if !__for_first_254 { i = add(&i, &Value::Int(1)); } __for_first_254 = false; is_less_than(&i, &get_array_length(&events)) } {
            let mut event: Value = get_value(&events, &i);
            let mut event: Value = get_value(&events, &i);
            let mut responseOrders: Value = self.safe_list_k(event.clone(), "orders", &[]);
            if is_equal(&responseOrders, &Value::Null) {
                continue;
            }
            {
                                let mut j: Value = Value::Int(0);
                let mut __for_first_253: bool = true;
                while { if !__for_first_253 { j = add(&j, &Value::Int(1)); } __for_first_253 = false; is_less_than(&j, &get_array_length(&responseOrders)) } {
                let mut responseOrder: Value = get_value(&responseOrders, &j);
                let mut responseOrder: Value = get_value(&responseOrders, &j);
                let mut parsed: Value = self.parse_ws_order(responseOrder.clone(), &[]);
                let mut cachedOrders: Value = self.orders.clone();
                let mut marketId: Value = self.safe_string_k(responseOrder.clone(), "product_id", &[]);
                if !is_equal(&marketId, &Value::Null) {
                    if !is_true(&(Value::Bool(in_op(&marketIds, &marketId)))) {
                        append_to_array(&mut marketIds, marketId.clone());
                    }
                }
                cachedOrders.append(parsed.clone());
            }
            }
        }
        }
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_255: bool = true;
            while { if !__for_first_255 { i = add(&i, &Value::Int(1)); } __for_first_255 = false; is_less_than(&i, &get_array_length(&marketIds)) } {
            let mut marketId: Value = get_value(&marketIds, &i);
            let mut marketId: Value = get_value(&marketIds, &i);
            let mut symbol: Value = self.safe_symbol(marketId.clone(), &[]);
            let mut messageHash: Value = add(&Value::Str("user::".to_string()), &symbol);
            client.resolve(&[self.orders.clone(), messageHash.clone()]);
            self.try_resolve_usdc(client.clone(), messageHash.clone(), self.orders.clone());
        }
        }
        client.resolve(&[self.orders.clone(), Value::Str("user".to_string())]);
}

    pub fn parse_ws_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        //
        //    {
        //        "order_id": "XXX",
        //        "client_order_id": "YYY",
        //        "cumulative_quantity": "0",
        //        "leaves_quantity": "0.000994",
        //        "avg_price": "0",
        //        "total_fees": "0",
        //        "status": "OPEN",
        //        "product_id": "BTC-USD",
        //        "creation_time": "2022-12-07T19:42:18.719312Z",
        //        "order_side": "BUY",
        //        "order_type": "Limit"
        //    }
        //
        let mut id: Value = self.safe_string_k(order.clone(), "order_id", &[]);
        let mut clientOrderId: Value = self.safe_string_k(order.clone(), "client_order_id", &[]);
        let mut marketId: Value = self.safe_string_k(order.clone(), "product_id", &[]);
        let mut datetime: Value = self.safe_string2(order.clone(), Value::Str("time".to_string()), Value::Str("creation_time".to_string()), &[]);
        market = self.safe_market(&[marketId.clone(), market.clone()]);
        let mut stopPrice: Value = self.safe_string_k(order.clone(), "stop_price", &[]);
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order.clone());
        m.insert("symbol".to_string(), self.safe_string_k(market.clone(), "symbol", &[]));
        m.insert("id".to_string(), id.clone());
        m.insert("clientOrderId".to_string(), clientOrderId.clone());
        m.insert("timestamp".to_string(), self.parse8601(datetime.clone()));
        m.insert("datetime".to_string(), datetime.clone());
        m.insert("lastTradeTimestamp".to_string(), Value::Null);
        m.insert("type".to_string(), self.safe_string_k(order.clone(), "order_type", &[]));
        m.insert("timeInForce".to_string(), Value::Null);
        m.insert("postOnly".to_string(), Value::Null);
        m.insert("side".to_string(), self.safe_string_lower2(order.clone(), Value::Str("side".to_string()), Value::Str("order_side".to_string()), &[]));
        m.insert("price".to_string(), self.safe_string_k(order.clone(), "limit_price", &[]));
        m.insert("stopPrice".to_string(), stopPrice.clone());
        m.insert("triggerPrice".to_string(), stopPrice.clone());
        m.insert("amount".to_string(), self.safe_string_k(order.clone(), "cumulative_quantity", &[]));
        m.insert("cost".to_string(), self.omit_zero(self.safe_string_k(order.clone(), "filled_value", &[])));
        m.insert("average".to_string(), self.safe_string_k(order.clone(), "avg_price", &[]));
        m.insert("filled".to_string(), self.safe_string_k(order.clone(), "cumulative_quantity", &[]));
        m.insert("remaining".to_string(), self.safe_string_k(order.clone(), "leaves_quantity", &[]));
        m.insert("status".to_string(), self.parent.parse_order_status(self.safe_string_k(order.clone(), "status", &[])));
        m.insert("fee".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("amount".to_string(), self.safe_string_k(order.clone(), "total_fees", &[]));
        m.insert("currency".to_string(), self.safe_string_k(market.clone(), "quote", &[]));
    m
}));
        m.insert("trades".to_string(), Value::Null);
    m
}), &[]);

    Value::Null
}

    pub fn handle_order_book_helper(&self, mut orderbook: Value, mut updates: Value) {
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_256: bool = true;
            while { if !__for_first_256 { i = add(&i, &Value::Int(1)); } __for_first_256 = false; is_less_than(&i, &get_array_length(&updates)) } {
            let mut trade: Value = get_value(&updates, &i);
            let mut trade: Value = get_value(&updates, &i);
            let mut sideId: Value = self.safe_string_k(trade.clone(), "side", &[]);
            let mut side: Value = self.safe_string(get_value(&self.options, &Value::Str("sides".to_string())), sideId.clone(), &[]);
            let mut price: Value = self.safe_number_k(trade.clone(), "price_level", &[]);
            let mut amount: Value = self.safe_number_k(trade.clone(), "new_quantity", &[]);
            let mut orderbookSide: Value = self.safe_value(orderbook.clone(), side.clone(), &[]);
            orderbookSide.store(price.clone(), amount.clone());
        }
        }
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        //
        //    {
        //        "channel": "l2_data",
        //        "client_id": "",
        //        "timestamp": "2023-02-09T20:32:50.714964855Z",
        //        "sequence_num": 0,
        //        "events": [
        //            {
        //                "type": "snapshot",
        //                "product_id": "BTC-USD",
        //                "updates": [
        //                    {
        //                        "side": "bid",
        //                        "event_time": "1970-01-01T00:00:00Z",
        //                        "price_level": "21921.74",
        //                        "new_quantity": "0.06317902"
        //                    },
        //                    {
        //                        "side": "bid",
        //                        "event_time": "1970-01-01T00:00:00Z",
        //                        "price_level": "21921.3",
        //                        "new_quantity": "0.02"
        //                    },
        //                ]
        //            }
        //        ]
        //    }
        //
        let mut events: Value = self.safe_list_k(message.clone(), "events", &[]);
        if is_equal(&events, &Value::Null) {
            return;
        }
        let mut datetime: Value = self.safe_string_k(message.clone(), "timestamp", &[]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_257: bool = true;
            while { if !__for_first_257 { i = add(&i, &Value::Int(1)); } __for_first_257 = false; is_less_than(&i, &get_array_length(&events)) } {
            let mut event: Value = get_value(&events, &i);
            let mut event: Value = get_value(&events, &i);
            let mut updates: Value = self.safe_list_k(event.clone(), "updates", &[Value::List(vec![])]);
            let mut marketId: Value = self.safe_string_k(event.clone(), "product_id", &[]);
            // sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, as they are aliases
            let mut market: Value = self.safe_market(&[marketId.clone()]);
            let mut symbol: Value = get_value(&market, &Value::Str("symbol".to_string()));
            let mut messageHash: Value = add(&Value::Str("level2::".to_string()), &symbol);
            let mut subscription: Value = self.safe_value(get_value(&client, &Value::Str("subscriptions".to_string())), messageHash.clone(), &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut limit: Value = self.safe_integer_k(subscription.clone(), "limit", &[]);
            let mut type_var: Value = self.safe_string_k(event.clone(), "type", &[]);
            if is_equal(&type_var, &Value::Str("snapshot".to_string())) {
                { let __be_tmp = self.order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit.clone()]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
            }
            // unknown bug, can't reproduce, but sometimes orderbook is undefined
            if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) && is_equal(&get_value(&self.orderbooks, &symbol), &Value::Null) {
                continue;
            }
            let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
            self.handle_order_book_helper(orderbook.clone(), updates.clone());
            add_element_to_object(&mut orderbook, &Value::Str("timestamp".to_string()), self.parse8601(datetime.clone()));
            add_element_to_object(&mut orderbook, &Value::Str("datetime".to_string()), datetime.clone());
            add_element_to_object(&mut orderbook, &Value::Str("symbol".to_string()), symbol.clone());
            client.resolve(&[orderbook.clone(), messageHash.clone()]);
            self.try_resolve_usdc(client.clone(), messageHash.clone(), orderbook.clone());
        }
        }
}

    pub fn try_resolve_usdc(&self, mut client: Value, mut messageHash: Value, mut result: Value) {
        if is_true(&Value::Bool(ends_with(&messageHash, &Value::Str("/USD".to_string())))) || is_true(&Value::Bool(ends_with(&messageHash, &Value::Str("-USD".to_string())))) {
            client.resolve(&[result.clone(), add(&messageHash, &Value::Str("C".to_string()))]); // when subscribing to BTC/USDC and coinbase returns BTC/USD, so resolve USDC too
        }
}

    pub fn handle_subscription_status(&mut self, mut client: Value, mut message: Value) -> Value {
        //
        //     {
        //         "type": "subscriptions",
        //         "channels": [
        //             {
        //                 "name": "level2",
        //                 "product_ids": [ "ETH-BTC" ]
        //             }
        //         ]
        //     }
        //
        //
        //      {
        //        channel: 'subscriptions',
        //        client_id: '',
        //        timestamp: '2025-09-15T17:02:49.90120868Z',
        //        sequence_num: 3,
        //        events: [ { subscriptions: {} } ]
        //      }
        //
        let mut events: Value = self.safe_list_k(message.clone(), "events", &[Value::List(vec![])]);
        let mut firstEvent: Value = self.safe_value(events.clone(), Value::Int(0), &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut isUnsub: Value = (Value::Bool(in_op(&firstEvent, &Value::Str("subscriptions".to_string()))));
        let mut subKeys: Value = object_keys(&get_value(&firstEvent, &Value::Str("subscriptions".to_string())));
        let mut subKeysLength: Value = get_array_length(&subKeys);
        if is_true(&isUnsub) && is_equal(&subKeysLength, &Value::Int(0)) {
            let mut unSubObject: Value = self.safe_dict_k(self.options.clone(), "unSubscription", &[Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            })]);
            let mut messageHashes: Value = self.safe_list_k(unSubObject.clone(), "messageHashes", &[Value::List(vec![])]);
            let mut subMessageHashes: Value = self.safe_list_k(unSubObject.clone(), "subMessageHashes", &[Value::List(vec![])]);
            {
                                let mut i: Value = Value::Int(0);
                let mut __for_first_258: bool = true;
                while { if !__for_first_258 { i = add(&i, &Value::Int(1)); } __for_first_258 = 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(unSubObject.clone());
        }
        return message;

    Value::Null
}

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

    Value::Null
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        let mut channel: Value = self.safe_string_k(message.clone(), "channel", &[]);
        let mut methods: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("subscriptions".to_string(), Value::Str("handle_subscription_status".to_string()).clone());
                m.insert("ticker".to_string(), Value::Str("handle_tickers".to_string()).clone());
                m.insert("ticker_batch".to_string(), Value::Str("handle_tickers".to_string()).clone());
                m.insert("market_trades".to_string(), Value::Str("handle_trade".to_string()).clone());
                m.insert("user".to_string(), Value::Str("handle_order".to_string()).clone());
                m.insert("l2_data".to_string(), Value::Str("handle_order_book".to_string()).clone());
                m.insert("heartbeats".to_string(), Value::Str("handle_heartbeats".to_string()).clone());
            m
        });
        let mut type_var: Value = self.safe_string_k(message.clone(), "type", &[]);
        if is_equal(&type_var, &Value::Str("error".to_string())) {
            let mut errorMessage: Value = self.safe_string_k(message.clone(), "message", &[]);
            // ternary (not ||) so the ast-transpiler emits a value-typed conditional, not a boolean
            let mut errorMessageValue: Value = ternary(is_true(&(!is_equal(&errorMessage, &Value::Null))), errorMessage.clone(), Value::Str("unknown error".to_string()));
            panic!("{}", crate::exchange_errors::exchange_error(errorMessageValue));
        }
        let mut method: Value = self.safe_value(methods.clone(), channel.clone(), &[]);
        if !is_equal(&method, &Value::Null) {
            self.dispatch_ws_handler(&method, &[client.clone(), message.clone()]);
        }
}
}