ccxt-pro 4.5.84

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

#![allow(unused, non_snake_case, clippy::all)]
use crate::Value;
use crate::get_value;
use crate::runtime::*;
// Base methods are now trait methods (review #1: static dispatch). Bring the
// traits into scope so `self.market(...)`, `self.safe_market(...)`,
// `self.load_markets(...)`, … on this Core resolve to the base defaults.
use crate::exchange_generated::ExchangeBase;
use crate::exchange::ExchangeRuntime;
// Dynamic `this[method](...)` re-entries are emitted as
// `self.call_dynamic_checked(...)` (blanket-impl'd on every Core) so an
// unresolvable name raises NotSupported instead of yielding a silent Null.
use crate::exchange::CallDynamicChecked;
use crate::pro::*;


pub struct UpbitCore {
    pub parent: crate::exchanges::upbit::UpbitCore,
}

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

    pub fn init(&mut self) {
        let described = UpbitCore::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 UpbitCore {
    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 UpbitCore {
    fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
        -> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
    {
        Box::pin(async move {
            match method {
                "authenticate" => self.authenticate(&args[..]).await,
                "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 },
                "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
                "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
                "watch_balance" => self.watch_balance(&args[..]).await,
                "watch_my_trades" => self.watch_my_trades(&args[..]).await,
                "watch_ohlcv" => self.watch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_orders" => self.watch_orders(&args[..]).await,
                "watch_private" => self.watch_private(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), &args[3.min(args.len())..]).await,
                "watch_public_multiple" => self.watch_public_multiple(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]).await,
                "watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_tickers" => self.watch_tickers(&args[..]).await,
                "watch_trades" => self.watch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                "watch_trades_for_symbols" => self.watch_trades_for_symbols(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
                // Go-style inheritance: an un-overridden method dispatches to the parent core.
                _ => crate::exchange_generated::ExchangeBase::call_dynamic(&mut self.parent, method, args).await,
            }
        })
    }
}
impl UpbitCore {
    /// Synchronous WS handler dispatch — routes a handler-name string (from the
    /// venue's handle_message dispatch table) to the real handler method.
    #[allow(dead_code, unreachable_patterns, clippy::all)]
    pub fn dispatch_ws_handler(&mut self, __name: &crate::Value, args: &[crate::Value]) -> crate::Value {
        let __n = match __name { crate::Value::Str(s) => s.as_ref(), _ => return crate::Value::Null };
        match __n {
            "authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
            "handle_balance" => { self.handle_balance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_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_order" => { self.handle_my_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_my_trade" => { self.handle_my_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_ohlcv" => { self.handle_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order" => { self.handle_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_order_book" => { self.handle_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_ticker" => { self.handle_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "handle_trades" => { self.handle_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
            "parse_ws_order" => self.parse_ws_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "parse_ws_order_status" => self.parse_ws_order_status(args.get(0).cloned().unwrap_or(crate::Value::Null)),
            "parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
            "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_private" => { crate::exchange_stubs::enqueue_spawn("watch_private", args.to_vec()); crate::Value::Null },
            "watch_public_multiple" => { crate::exchange_stubs::enqueue_spawn("watch_public_multiple", args.to_vec()); crate::Value::Null },
            "watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
            "watch_tickers" => { crate::exchange_stubs::enqueue_spawn("watch_tickers", args.to_vec()); crate::Value::Null },
            "watch_trades" => { crate::exchange_stubs::enqueue_spawn("watch_trades", args.to_vec()); crate::Value::Null },
            "watch_trades_for_symbols" => { crate::exchange_stubs::enqueue_spawn("watch_trades_for_symbols", args.to_vec()); crate::Value::Null },
            _ => crate::Value::Null,
        }
    }
}

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

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

impl UpbitCore {
    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("watchOrderBook".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("watchOHLCV".to_string(), Value::Bool(true));
        m.insert("watchOrders".to_string(), Value::Bool(true));
        m.insert("watchMyTrades".to_string(), Value::Bool(true));
        m.insert("watchBalance".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://{hostname}/websocket/v1".into()));
    m
}));
    m
}));
        m.insert("options".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("tradesLimit".to_string(), Value::Int(1000));
    m
}));
    m
})]);

    Value::Null
}

    pub async fn watch_public_multiple(&mut self, mut symbols: Value, mut channel: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        if (symbols == Value::Null) {
            symbols = self.symbols.clone();
        }
        symbols = self.market_symbols(&[symbols.clone()]);
        if (symbols == Value::Null) {
            symbols = Value::from(vec![]);
        }
        let mut marketIds: Value = self.market_ids(&[symbols.clone()]);
        let mut url: Value = self.implode_params(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("hostname".to_string(), self.hostname.clone());
            m
        }));
        let mut client: Value = self.client(&[url.clone()]);
        let mut subscriptionsKey: Value = Value::Str("upbitPublicSubscriptions".into());
        if !(in_op(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey)) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey, self.create_safe_dictionary(&[Value::Bool(true)]));
        }
        let mut subscriptions: Value = get_value(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey);
        let mut messageHashes: Value = Value::from(vec![]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_608: bool = true;
            while { if !__for_first_608 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_608 = false; i.as_f64().unwrap_or(f64::NAN) < ((symbols.len() as i64) as f64) } {
            let mut marketId: Value = marketIds.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut symbol: Value = symbols.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", channel, Value::Str(":".into())).into()), symbol).into());
            append_to_array(&mut messageHashes, messageHash.clone());
            if !(in_op(&subscriptions, &messageHash)) {
                add_element_to_object(&mut subscriptions, &messageHash, Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("type".to_string(), channel.clone());
        m.insert("codes".to_string(), Value::from(vec![marketId]));
    m
}));
            }
        }
        }
        let mut finalMessage: Value = Value::from(vec![Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ticket".to_string(), self.uuid(&[]));
    m
})]);
        let mut channelKeys: Value = object_keys(&subscriptions);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_609: bool = true;
            while { if !__for_first_609 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_609 = false; i.as_f64().unwrap_or(f64::NAN) < ((channelKeys.len() as i64) as f64) } {
            let mut key: Value = channelKeys.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            append_to_array(&mut finalMessage, get_value(&subscriptions, &key));
        }
        }
        return self.watch_multiple(url, messageHashes.clone(), &[finalMessage, messageHashes.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name upbit#watchTicker
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://global-docs.upbit.com/reference/websocket-ticker
 * @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.watch_public_multiple(Value::from(vec![symbol]), Value::Str("ticker".into()), &[]).await;

    Value::Null
}

/*
 * @method
 * @name upbit#watchTickers
 * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
 * @see https://global-docs.upbit.com/reference/websocket-ticker
 * @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
}));
        let mut newTickers: Value = self.watch_public_multiple(symbols.clone(), Value::Str("ticker".into()), &[]).await;
        if is_true(&self.newUpdates) {
            let mut tickers: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                m
            });
            add_element_to_object(&mut tickers, &crate::value::get_value_k(&newTickers, "symbol"), newTickers.clone());
            return tickers;
        }
        return self.filter_by_array(self.tickers.clone(), Value::Str("symbol".into()), &[symbols]);

    Value::Null
}

/*
 * @method
 * @name upbit#watchTrades
 * @description get the list of most recent trades for a particular symbol
 * @see https://global-docs.upbit.com/reference/websocket-trade
 * @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
}));
        return self.watch_trades_for_symbols(Value::from(vec![symbol]), &[since, limit, params]).await;

    Value::Null
}

/*
 * @method
 * @name upbit#watchTradesForSymbols
 * @description get the list of most recent trades for a list of symbols
 * @see https://global-docs.upbit.com/reference/websocket-trade
 * @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
}));
        let mut trades: Value = self.watch_public_multiple(symbols, Value::Str("trade".into()), &[]).await;
        if is_true(&self.newUpdates) {
            let mut first: Value = self.safe_dict(trades.clone(), Value::Int(0), &[]);
            let mut tradeSymbol: Value = self.safe_string_k(first, "symbol", &[]);
            limit = trades.get_limit(tradeSymbol, limit.clone());
        }
        return self.filter_by_since_limit(trades, &[since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name upbit#watchOrderBook
 * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://global-docs.upbit.com/reference/websocket-orderbook
 * @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
}));
        let mut orderbook: Value = self.watch_public_multiple(Value::from(vec![symbol]), Value::Str("orderbook".into()), &[]).await;
        return orderbook.limit();

    Value::Null
}

/*
 * @method
 * @name upbit#watchOHLCV
 * @description watches information an OHLCV with timestamp, openingPrice, highPrice, lowPrice, tradePrice, baseVolume in 1s.
 * @see https://docs.upbit.com/kr/reference/websocket-candle for Upbit KR
 * @see https://global-docs.upbit.com/reference/websocket-candle for Upbit Global
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {string} timeframe specifies the OHLCV candle interval to watch. As of now, Upbit only supports 1s candles.
 * @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 {OHLCV[]} a list of [OHLCV structures]{@link https://docs.ccxt.com/?id=ohlcv-structure}
 */
    pub async fn watch_ohlcv(&mut self, mut symbol: Value, optional_args: &[Value]) -> Value {
        let mut timeframe = get_arg(optional_args, 0, Value::Str("1s".into()));
        let mut since = get_arg(optional_args, 1, Value::Null);
        let mut limit = get_arg(optional_args, 2, Value::Null);
        let mut params = get_arg(optional_args, 3, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        if (timeframe.as_str() != Some("1s")) {
            panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" watchOHLCV does not support".into())).into()), timeframe).into()), Value::Str(" candle.".into()))));
        }
        let mut timeFrameOHLCV: Value = Value::Str(format!("{}{}", Value::Str("candle.".into()), timeframe).into());
        return self.watch_public_multiple(Value::from(vec![symbol]), timeFrameOHLCV, &[]).await;

    Value::Null
}

    pub fn handle_ticker(&mut self, mut client: Value, mut message: Value) {
        // 2020-03-17T23:07:36.511Z "onMessage" <Buffer 7b 22 74 79 70 65 22 3a 22 74 69 63 6b 65 72 22 2c 22 63 6f 64 65 22 3a 22 42 54 43 2d 45 54 48 22 2c 22 6f 70 65 6e 69 6e 67 5f 70 72 69 63 65 22 3a ... >
        // { type: "ticker",
        //   "code": "BTC-ETH",
        //   "opening_price": 0.02295092,
        //   "high_price": 0.02295092,
        //   "low_price": 0.02161249,
        //   "trade_price": 0.02161249,
        //   "prev_closing_price": 0.02185802,
        //   "acc_trade_price": 2.32732482,
        //   "change": "FALL",
        //   "change_price": 0.00024553,
        //   "signed_change_price": -0.00024553,
        //   "change_rate": 0.0112329479,
        //   "signed_change_rate": -0.0112329479,
        //   "ask_bid": "ASK",
        //   "trade_volume": 2.12,
        //   "acc_trade_volume": 106.11798418,
        //   "trade_date": "20200317",
        //   "trade_time": "215843",
        //   "trade_timestamp": 1584482323000,
        //   "acc_ask_volume": 90.16935908,
        //   "acc_bid_volume": 15.9486251,
        //   "highest_52_week_price": 0.03537414,
        //   "highest_52_week_date": "2019-04-08",
        //   "lowest_52_week_price": 0.01614901,
        //   "lowest_52_week_date": "2019-09-06",
        //   "trade_status": null,
        //   "market_state": "ACTIVE",
        //   "market_state_for_ios": null,
        //   "is_trading_suspended": false,
        //   "delisting_date": null,
        //   "market_warning": "NONE",
        //   "timestamp": 1584482323378,
        //   "acc_trade_price_24h": 2.5955306323568927,
        //   "acc_trade_volume_24h": 118.38798416,
        //   "stream_type": "SNAPSHOT" }
        let mut ticker: Value = self.parse_ticker(message, &[]);
        let mut symbol: Value = ticker.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        if (symbol != Value::Null) {
            if let Value::Dict(__d) = &mut self.tickers { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), ticker.clone()); }
        }
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("ticker:".into()), symbol).into());
        client.resolve(&[ticker, messageHash]);
}

    pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        // { type: "orderbook",
        //   "code": "BTC-ETH",
        //   "timestamp": 1584486737444,
        //   "total_ask_size": 16.76384456,
        //   "total_bid_size": 168.9020623,
        //   "orderbook_units":
        //    [ { ask_price: 0.02295077,
        //        "bid_price": 0.02161249,
        //        "ask_size": 3.57100696,
        //        "bid_size": 22.5303265 },
        //      { ask_price: 0.02295078,
        //        "bid_price": 0.02152658,
        //        "ask_size": 0.52451651,
        //        "bid_size": 2.30355128 },
        //      { ask_price: 0.02295086,
        //        "bid_price": 0.02150802,
        //        "ask_size": 1.585,
        //        "bid_size": 5 }, ... ],
        //   "stream_type": "SNAPSHOT" }
        let mut marketId: Value = (match __pro_message.get("code").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut symbol: Value = self.safe_symbol(marketId, &[Value::Null, Value::Str("-".into())]);
        let mut type_var: Option<String> = (match __pro_message.get("stream_type").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }).as_str().map(str::to_owned);
        let mut options: Value = self.safe_dict_k(self.options.clone(), "watchOrderBook", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut limit: Value = self.safe_integer_k(options, "limit", &[Value::Int(15)]);
        if (type_var.as_deref() == Some("SNAPSHOT")) {
            { let __be_tmp = self.order_book(&[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}), limit]); if let Value::Dict(__d) = &mut self.orderbooks { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), __be_tmp); } }
        }
        let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
        // upbit always returns a snapshot of 15 topmost entries
        // the "REALTIME" deltas are not incremental
        // therefore we reset the orderbook on each update
        // and reinitialize it again with new bidasks
        orderbook.reset(Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        }));
        add_element_to_object(&mut orderbook, &Value::Str("symbol".into()), symbol.clone());
        let mut bids: Value = get_value(&orderbook, &Value::Str("bids".into()));
        let mut asks: Value = get_value(&orderbook, &Value::Str("asks".into()));
        let mut data: Value = (match __pro_message.get("orderbook_units").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_610: bool = true;
            while { if !__for_first_610 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_610 = false; i.as_f64().unwrap_or(f64::NAN) < ((data.len() as i64) as f64) } {
            let mut entry: Value = data.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut ask_price: Value = self.safe_float_k(entry.clone(), "ask_price", &[]);
            let mut ask_size: Value = self.safe_float_k(entry.clone(), "ask_size", &[]);
            let mut bid_price: Value = self.safe_float_k(entry.clone(), "bid_price", &[]);
            let mut bid_size: Value = self.safe_float_k(entry, "bid_size", &[]);
            asks.store(ask_price, ask_size);
            bids.store(bid_price, bid_size);
        }
        }
        let mut timestamp: Value = self.safe_integer_k(message, "timestamp", &[]);
        let mut datetime: Value = self.iso8601(timestamp.clone());
        add_element_to_object(&mut orderbook, &Value::Str("timestamp".into()), timestamp);
        add_element_to_object(&mut orderbook, &Value::Str("datetime".into()), datetime);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("orderbook:".into()), symbol).into());
        client.resolve(&[orderbook, messageHash]);
}

    pub fn handle_trades(&mut self, mut client: Value, mut message: Value) {
        // { type: "trade",
        //   "code": "KRW-BTC",
        //   "timestamp": 1584508285812,
        //   "trade_date": "2020-03-18",
        //   "trade_time": "05:11:25",
        //   "trade_timestamp": 1584508285000,
        //   "trade_price": 6747000,
        //   "trade_volume": 0.06499468,
        //   "ask_bid": "ASK",
        //   "prev_closing_price": 6774000,
        //   "change": "FALL",
        //   "change_price": 27000,
        //   "sequential_id": 1584508285000002,
        //   "stream_type": "REALTIME" }
        let mut trade: Value = self.parse_trade(message, &[]);
        let mut symbol: Value = trade.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
        if (symbol == Value::Null) {
            return;
        }
        let mut stored: Value = self.safe_value(self.trades.clone(), symbol.clone(), &[]);
        if (stored == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
            stored = ArrayCache::new(limit);
            if let Value::Dict(__d) = &mut self.trades { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&symbol), stored.clone()); }
        }
        stored.append(trade);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trade:".into()), symbol).into());
        client.resolve(&[stored, messageHash]);
}

    pub fn handle_ohlcv(&self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        // {
        //     type: 'candle.1s',
        //     code: 'KRW-USDT',
        //     candle_date_time_utc: '2025-04-22T09:50:34',
        //     candle_date_time_kst: '2025-04-22T18:50:34',
        //     opening_price: 1438,
        //     high_price: 1438,
        //     low_price: 1438,
        //     trade_price: 1438,
        //     candle_acc_trade_volume: 1145.8935,
        //     candle_acc_trade_price: 1647794.853,
        //     timestamp: 1745315434125,
        //     stream_type: 'REALTIME'
        //   }
        let mut marketId: Value = (match __pro_message.get("code").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut symbol: Value = self.safe_symbol(marketId, &[]);
        let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("candle.1s:".into()), symbol).into());
        let mut ohlcv: Value = self.parse_ohlcv(message, &[]);
        client.resolve(&[ohlcv, messageHash]);
}

    pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.check_required_credentials(&[]);
        let mut wsOptions: Value = self.safe_dict_k(self.options.clone(), "ws", &[Value::Map({
            let mut m = indexmap::IndexMap::new();
            m
        })]);
        let mut authenticated: Option<String> = self.safe_string_k(wsOptions.clone(), "token", &[]).as_str().map(str::to_owned);
        if (authenticated.is_none()) {
            let mut auth: Value = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("access_key".to_string(), self.apiKey.clone());
                    m.insert("nonce".to_string(), self.uuid(&[]));
                m
            });
            let mut token: Value = jwt(auth, self.encode(self.secret.clone()), Value::Str("sha256".into()), Value::Bool(false), Value::Null);
            if let Value::Dict(__d) = &mut wsOptions { std::sync::Arc::make_mut(__d).insert("token".into(), token.clone()); }
            if let Value::Dict(__d) = &mut wsOptions { std::sync::Arc::make_mut(__d).insert("options".into(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("headers".to_string(), Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("authorization".to_string(), Value::Str(format!("{}{}", Value::Str("Bearer ".into()), token).into()));
    m
}));
    m
})); }
            if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("ws".into(), wsOptions); }
        }
        let mut url: Value = add(&self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), &Value::Str("/private".into()));
        let mut client: Value = self.client(&[url]);
        return client;

    Value::Null
}

    pub async fn watch_private(&mut self, mut symbol: Value, mut channel: Value, mut messageHash: Value, optional_args: &[Value]) -> Value {
        let mut params = get_arg(optional_args, 0, Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}));
        self.authenticate(&[]).await;
        let mut request: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("type".to_string(), channel.clone());
            m
        });
        if (symbol != Value::Null) {
            self.load_markets(&[]).await;
            let mut market: Value = self.market(symbol.clone());
            symbol = market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null);
            let mut symbols: Value = Value::from(vec![symbol.clone()]);
            let mut marketIds: Value = self.market_ids(&[symbols]);
            if let Value::Dict(__d) = &mut request { std::sync::Arc::make_mut(__d).insert("codes".into(), marketIds); }
            messageHash = Value::Str(format!("{}{}", Value::Str(format!("{}{}", messageHash, Value::Str(":".into())).into()), symbol).into());
        }
        let mut url: Value = self.implode_params(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null).as_map().and_then(|__m| __m.get("ws")).cloned().unwrap_or(Value::Null), Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("hostname".to_string(), self.hostname.clone());
            m
        }));
        url = Value::Str(format!("{}{}", url, Value::Str("/private".into())).into());
        let mut client: Value = self.client(&[url.clone()]);
        // Track private channel subscriptions to support multiple concurrent watches
        let mut subscriptionsKey: Value = Value::Str("upbitPrivateSubscriptions".into());
        if !(in_op(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey)) {
            add_element_to_object(&mut get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey, self.create_safe_dictionary(&[Value::Bool(true)]));
        }
        let mut channelKey: Value = channel.clone();
        if (symbol != Value::Null) {
            channelKey = Value::Str(format!("{}{}", Value::Str(format!("{}{}", channel, Value::Str(":".into())).into()), symbol).into());
        }
        let mut subscriptions: Value = get_value(&get_value(&client, &Value::Str("subscriptions".into())), &subscriptionsKey);
        let mut isNewChannel: bool = !(in_op(&subscriptions, &channelKey));
        if isNewChannel {
            add_element_to_object(&mut subscriptions, &channelKey, request);
        }
        // Build subscription message with all requested private channels
        // Format: [{'ticket': uuid}, {'type': 'myOrder'}, {'type': 'myAsset'}, ...]
        let mut requests: Value = Value::from(vec![]);
        let mut channelKeys: Value = object_keys(&subscriptions);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_611: bool = true;
            while { if !__for_first_611 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_611 = false; i.as_f64().unwrap_or(f64::NAN) < ((channelKeys.len() as i64) as f64) } {
            append_to_array(&mut requests, get_value(&subscriptions, &channelKeys.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null)));
        }
        }
        let mut message: Value = Value::from(vec![Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("ticket".to_string(), self.uuid(&[]));
    m
})]);
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_612: bool = true;
            while { if !__for_first_612 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_612 = false; i.as_f64().unwrap_or(f64::NAN) < ((requests.len() as i64) as f64) } {
            append_to_array(&mut message, requests.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null));
        }
        }
        return self.watch(url, messageHash.clone(), &[message, messageHash.clone()]).await;

    Value::Null
}

/*
 * @method
 * @name upbit#watchOrders
 * @description watches information on multiple orders made by the user
 * @see https://global-docs.upbit.com/reference/websocket-myorder
 * @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 (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut channel: Value = Value::Str("myOrder".into());
        let mut messageHash: Value = Value::Str("myOrder".into());
        let mut orders: Value = self.watch_private(symbol.clone(), channel, messageHash, &[]).await;
        if is_true(&self.newUpdates) {
            limit = orders.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(orders, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

/*
 * @method
 * @name upbit#watchMyTrades
 * @description watches information on multiple trades made by the user
 * @see https://global-docs.upbit.com/reference/websocket-myorder
 * @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 [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 (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut channel: Value = Value::Str("myOrder".into());
        let mut messageHash: Value = Value::Str("myTrades".into());
        let mut trades: Value = self.watch_private(symbol.clone(), channel, messageHash, &[]).await;
        if is_true(&self.newUpdates) {
            limit = trades.get_limit(symbol.clone(), limit.clone());
        }
        return self.filter_by_symbol_since_limit(trades, &[symbol, since, limit, Value::Bool(true)]);

    Value::Null
}

    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("wait".to_string(), Value::Str("open".into()));
                m.insert("done".to_string(), Value::Str("closed".into()));
                m.insert("cancel".to_string(), Value::Str("canceled".into()));
                m.insert("watch".to_string(), Value::Str("open".into()));
                m.insert("trade".to_string(), Value::Str("open".into()));
            m
        });
        if (status == Value::Null) {
            return Value::Null;
        }
        return self.safe_string(statuses, 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);
        //
        // {
        //     "type": "myOrder",
        //     "code": "SGD-XRP",
        //     "uuid": "ac2dc2a3-fce9-40a2-a4f6-5987c25c438f",
        //     "ask_bid": "BID",
        //     "order_type": "limit",
        //     "state": "trade",
        //     "price": 0.001453,
        //     "avg_price": 0.00145372,
        //     "volume": 30925891.29839369,
        //     "remaining_volume": 29968038.09235948,
        //     "executed_volume": 30925891.29839369,
        //     "trades_count": 1,
        //     "reserved_fee": 44.23943970238218,
        //     "remaining_fee": 21.77177967409916,
        //     "paid_fee": 22.467660028283017,
        //     "locked": 43565.33112787242,
        //     "executed_funds": 44935.32005656603,
        //     "order_timestamp": 1710751590000,
        //     "timestamp": 1710751597500,
        //     "stream_type": "REALTIME"
        // }
        //
        let mut id: Value = self.safe_string_k(order.clone(), "uuid", &[]);
        let mut side: Value = self.safe_string_lower_k(order.clone(), "ask_bid", &[]);
        if (side.as_str() == Some("bid")) {
            side = Value::Str("buy".into());
        }  else {
            side = Value::Str("sell".into());
        }
        let mut timestamp: Value = self.parse8601(self.safe_string_k(order.clone(), "order_timestamp", &[]));
        let mut status: Value = self.parse_ws_order_status(self.safe_string_k(order.clone(), "state", &[]));
        let mut marketId: Value = self.safe_string_k(order.clone(), "code", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut fee: Value = Value::Null;
        let mut feeCost: Value = self.safe_string_k(order.clone(), "paid_fee", &[]);
        if (feeCost != Value::Null) {
            fee = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("currency".to_string(), market.as_map().and_then(|__m| __m.get("quote")).cloned().unwrap_or(Value::Null));
                    m.insert("cost".to_string(), feeCost);
                m
            });
        }
        return self.safe_order(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("info".to_string(), order.clone());
        m.insert("id".to_string(), id);
        m.insert("clientOrderId".to_string(), Value::Null);
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("lastTradeTimestamp".to_string(), self.safe_string_k(order.clone(), "trade_timestamp", &[]));
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("type".to_string(), self.safe_string_k(order.clone(), "order_type", &[]));
        m.insert("timeInForce".to_string(), self.safe_string_k(order.clone(), "time_in_force", &[]));
        m.insert("postOnly".to_string(), Value::Null);
        m.insert("side".to_string(), side);
        m.insert("price".to_string(), self.safe_string_k(order.clone(), "price", &[]));
        m.insert("stopPrice".to_string(), Value::Null);
        m.insert("triggerPrice".to_string(), Value::Null);
        m.insert("cost".to_string(), self.safe_string_k(order.clone(), "executed_funds", &[]));
        m.insert("average".to_string(), self.safe_string_k(order.clone(), "avg_price", &[]));
        m.insert("amount".to_string(), self.safe_string_k(order.clone(), "volume", &[]));
        m.insert("filled".to_string(), self.safe_string_k(order.clone(), "executed_volume", &[]));
        m.insert("remaining".to_string(), self.safe_string_k(order, "remaining_volume", &[]));
        m.insert("status".to_string(), status);
        m.insert("fee".to_string(), fee);
        m.insert("trades".to_string(), Value::Null);
    m
}), &[]);

    Value::Null
}

    pub fn parse_ws_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
        let mut market = get_arg(optional_args, 0, Value::Null);
        // see: parseWsOrder
        let mut side: Value = self.safe_string_lower_k(trade.clone(), "ask_bid", &[]);
        if (side.as_str() == Some("bid")) {
            side = Value::Str("buy".into());
        }  else {
            side = Value::Str("sell".into());
        }
        let mut timestamp: Value = self.parse8601(self.safe_string_k(trade.clone(), "trade_timestamp", &[]));
        let mut marketId: Value = self.safe_string_k(trade.clone(), "code", &[]);
        market = self.safe_market(&[marketId, market.clone()]);
        let mut fee: Value = Value::Null;
        let mut feeCost: Value = self.safe_string_k(trade.clone(), "paid_fee", &[]);
        if (feeCost != Value::Null) {
            fee = Value::Map({
                let mut m = indexmap::IndexMap::new();
                    m.insert("currency".to_string(), market.as_map().and_then(|__m| __m.get("quote")).cloned().unwrap_or(Value::Null));
                    m.insert("cost".to_string(), feeCost);
                m
            });
        }
        return self.safe_trade(Value::Map({
    let mut m = indexmap::IndexMap::new();
        m.insert("id".to_string(), self.safe_string_k(trade.clone(), "trade_uuid", &[]));
        m.insert("timestamp".to_string(), timestamp.clone());
        m.insert("datetime".to_string(), self.iso8601(timestamp));
        m.insert("symbol".to_string(), market.as_map().and_then(|__m| __m.get("symbol")).cloned().unwrap_or(Value::Null));
        m.insert("side".to_string(), side);
        m.insert("price".to_string(), self.safe_string_k(trade.clone(), "price", &[]));
        m.insert("amount".to_string(), self.safe_string_k(trade.clone(), "volume", &[]));
        m.insert("cost".to_string(), self.safe_string_k(trade.clone(), "executed_funds", &[]));
        m.insert("order".to_string(), self.safe_string_k(trade.clone(), "uuid", &[]));
        m.insert("takerOrMaker".to_string(), Value::Null);
        m.insert("type".to_string(), self.safe_string_k(trade.clone(), "order_type", &[]));
        m.insert("fee".to_string(), fee);
        m.insert("info".to_string(), trade);
    m
}), &[market]);

    Value::Null
}

    pub fn handle_my_order(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        // see: parseWsOrder
        let mut tradeId: Option<String> = (match __pro_message.get("trade_uuid").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }).as_str().map(str::to_owned);
        if (tradeId.is_some()) {
            self.handle_my_trade(client.clone(), message.clone());
        }
        self.handle_order(client, message);
}

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

    pub fn handle_order(&mut self, mut client: Value, mut message: Value) {
        let mut parsed: Value = self.parse_ws_order(message, &[]);
        let mut symbol: Value = self.safe_string_k(parsed.clone(), "symbol", &[]);
        let mut orderId: Value = self.safe_string_k(parsed.clone(), "id", &[]);
        if (self.orders.clone() == Value::Null) {
            let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
            self.orders = ArrayCacheBySymbolById::new(limit);
        }
        let mut cachedOrders: Value = self.orders.clone();
        let mut orders: Value = (if (symbol == Value::Null) { Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
}) } else { self.safe_dict(cachedOrders.hashmap(), symbol.clone(), &[Value::Map({
    let mut m = indexmap::IndexMap::new();
    m
})]) });
        let mut order: Value = (if (orderId == Value::Null) { Value::Null } else { self.safe_dict(orders.clone(), orderId, &[]) });
        if (order != Value::Null) {
            let mut fee: Value = self.safe_value_k(order.clone(), "fee", &[]);
            if (fee != Value::Null) {
                add_element_to_object(&mut parsed, &Value::Str("fee".into()), fee);
            }
            let mut fees: Value = self.safe_value_k(order.clone(), "fees", &[]);
            if (fees != Value::Null) {
                add_element_to_object(&mut parsed, &Value::Str("fees".into()), fees);
            }
            add_element_to_object(&mut parsed, &Value::Str("trades".into()), self.safe_value_k(order.clone(), "trades", &[]));
            add_element_to_object(&mut parsed, &Value::Str("timestamp".into()), self.safe_integer_k(order.clone(), "timestamp", &[]));
            add_element_to_object(&mut parsed, &Value::Str("datetime".into()), self.safe_string_k(order, "datetime", &[]));
        }
        cachedOrders.append(parsed);
        let mut messageHash: Value = Value::Str("myOrder".into());
        client.resolve(&[self.orders.clone(), messageHash.clone()]);
        messageHash = Value::Str(format!("{}{}", Value::Str(format!("{}{}", messageHash, Value::Str(":".into())).into()), symbol).into());
        client.resolve(&[self.orders.clone(), messageHash]);
}

/*
 * @method
 * @name upbit#watchBalance
 * @see https://global-docs.upbit.com/reference/websocket-myasset
 * @description query for 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
 * @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 (self.markets.clone() == Value::Null) {
            self.load_markets(&[]).await;
        }
        let mut channel: Value = Value::Str("myAsset".into());
        let mut messageHash: Value = Value::Str("myAsset".into());
        return self.watch_private(Value::Null, channel, messageHash, &[]).await;

    Value::Null
}

    pub fn handle_balance(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        //
        // {
        //     "type": "myAsset",
        //     "asset_uuid": "e635f223-1609-4969-8fb6-4376937baad6",
        //     "assets": [
        //       {
        //         "currency": "SGD",
        //         "balance": 1386929.37231066771348207123,
        //         "locked": 10329.670127489597585685
        //       }
        //     ],
        //     "asset_timestamp": 1710146517259,
        //     "timestamp": 1710146517267,
        //     "stream_type": "REALTIME"
        // }
        //
        let mut data: Value = (match __pro_message.get("assets").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) });
        let mut timestamp: Value = self.safe_integer_k(message, "timestamp", &[]);
        if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert("timestamp".into(), timestamp.clone()); }
        { let __be_tmp = self.iso8601(timestamp); if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert("datetime".into(), __be_tmp); } }
        {
                        let mut i: Value = Value::Int(0);
            let mut __for_first_613: bool = true;
            while { if !__for_first_613 { i = (match (&(i), &(Value::Int(1))) { (Value::Int(x), Value::Int(y)) => Value::Int(x + y), (Value::Int(x), Value::Float(y)) => Value::Float(*x as f64 + *y), (Value::Float(x), Value::Int(y)) => Value::Float(*x + *y as f64), (Value::Float(x), Value::Float(y)) => Value::Float(x + y), _ => Value::Null }); } __for_first_613 = false; i.as_f64().unwrap_or(f64::NAN) < ((data.len() as i64) as f64) } {
            let mut balance: Value = data.as_array().and_then(|__arr| match &i { Value::Int(__n) => __arr.get(*__n as usize), Value::Str(__s) => __s.parse::<usize>().ok().and_then(|__n| __arr.get(__n)), _ => None }).cloned().unwrap_or(Value::Null);
            let mut currencyId: Value = self.safe_string_k(balance.clone(), "currency", &[]);
            let mut code: Value = self.safe_currency_code(currencyId, &[]);
            let mut available: Value = self.safe_string_k(balance.clone(), "balance", &[]);
            let mut frozen: Value = self.safe_string_k(balance.clone(), "locked", &[]);
            let mut account: Value = self.account();
            if let Value::Dict(__d) = &mut account { std::sync::Arc::make_mut(__d).insert("free".into(), available); }
            if let Value::Dict(__d) = &mut account { std::sync::Arc::make_mut(__d).insert("used".into(), frozen); }
            if (code != Value::Null) {
                if let Value::Dict(__d) = &mut self.balance { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&code), account); }
            }
            { let __t = self.safe_balance(self.balance.clone()); self.balance = __t; }
        }
        }
        let mut messageHash: Value = (match __pro_message.get("type").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        client.resolve(&[self.balance.clone(), messageHash]);
}

    pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
        let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (match &message { Value::Dict(__d) => __d.clone(), _ => std::sync::Arc::new(indexmap::IndexMap::new()) });
        let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
        let mut methods: Value = Value::Map({
            let mut m = indexmap::IndexMap::new();
                m.insert("ticker".to_string(), Value::Str("handle_ticker".into()).clone());
                m.insert("orderbook".to_string(), Value::Str("handle_order_book".into()).clone());
                m.insert("trade".to_string(), Value::Str("handle_trades".into()).clone());
                m.insert("myOrder".to_string(), Value::Str("handle_my_order".into()).clone());
                m.insert("myAsset".to_string(), Value::Str("handle_balance".into()).clone());
                m.insert("candle.1s".to_string(), Value::Str("handle_ohlcv".into()).clone());
            m
        });
        let mut methodName: Value = (match __pro_message.get("type").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
        let mut method: Value = (if (methodName == Value::Null) { Value::Null } else { self.safe_value(methods, methodName, &[]) });
        if (method != Value::Null) {
            self.dispatch_ws_handler(&method, &[client, message]);
        }
}
}