// 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 BithumbCore {
pub parent: crate::exchanges::bithumb::BithumbCore,
}
impl BithumbCore {
pub fn new(config: Option<crate::Value>) -> Self {
let mut s = Self { parent: crate::exchanges::bithumb::BithumbCore::new(config) };
s.init();
s
}
pub fn init(&mut self) {
let described = BithumbCore::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 BithumbCore {
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 BithumbCore {
fn call_dynamic<'a>(&'a mut self, method: &'a str, args: Vec<crate::Value>)
-> std::pin::Pin<Box<dyn std::future::Future<Output = crate::Value> + Send + 'a>>
{
Box::pin(async move {
match method {
"authenticate" => self.authenticate(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
"build_gen2_subscription_request" => self.build_gen2_subscription_request(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"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()[..]),
"parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
"pong" => self.pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)).await,
"watch_balance" => self.watch_balance(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
"watch_order_book" => self.watch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
"watch_orders" => self.watch_orders(&args.get(0..).unwrap_or(&[]).to_vec()[..]).await,
"watch_ticker" => self.watch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]).await,
"watch_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,
// 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 BithumbCore {
/// Synchronous WS handler dispatch — routes a handler-name string (from the
/// venue's handle_message dispatch table) to the real handler method.
#[allow(dead_code, unreachable_patterns, clippy::all)]
pub fn dispatch_ws_handler(&mut self, __name: &crate::Value, args: &[crate::Value]) -> crate::Value {
let __n = match __name { crate::Value::Str(s) => s.as_str(), _ => return crate::Value::Null };
match __n {
"authenticate" => { crate::exchange_stubs::enqueue_spawn("authenticate", args.to_vec()); crate::Value::Null },
"build_gen2_subscription_request" => self.build_gen2_subscription_request(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(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_delta" => { self.handle_delta(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"handle_deltas" => { self.handle_deltas(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"handle_error_message" => self.handle_error_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"handle_message" => { self.handle_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"handle_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_orders" => { self.handle_orders(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"handle_ping" => { self.handle_ping(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"handle_pong" => { self.handle_pong(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); 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.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()[..]),
"parse_ws_trade" => self.parse_ws_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args.get(1..).unwrap_or(&[]).to_vec()[..]),
"pong" => { crate::exchange_stubs::enqueue_spawn("pong", args.to_vec()); crate::Value::Null },
"watch_balance" => { crate::exchange_stubs::enqueue_spawn("watch_balance", args.to_vec()); crate::Value::Null },
"watch_order_book" => { crate::exchange_stubs::enqueue_spawn("watch_order_book", args.to_vec()); crate::Value::Null },
"watch_orders" => { crate::exchange_stubs::enqueue_spawn("watch_orders", args.to_vec()); crate::Value::Null },
"watch_ticker" => { crate::exchange_stubs::enqueue_spawn("watch_ticker", args.to_vec()); crate::Value::Null },
"watch_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 },
_ => crate::Value::Null,
}
}
}
impl std::ops::Deref for BithumbCore {
type Target = crate::exchange::Exchange;
fn deref(&self) -> &crate::exchange::Exchange { std::ops::Deref::deref(&self.parent) }
}
impl std::ops::DerefMut for BithumbCore {
fn deref_mut(&mut self) -> &mut crate::exchange::Exchange { std::ops::DerefMut::deref_mut(&mut self.parent) }
}
impl BithumbCore {
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("watchBalance".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("watchOrderBook".to_string(), Value::Bool(true));
m.insert("watchOHLCV".to_string(), Value::Bool(false));
m
}));
m.insert("urls".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("api".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ws".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("public".to_string(), Value::Str("wss://pubwss.bithumb.com/pub/ws".to_string()));
m.insert("publicV2".to_string(), Value::Str("wss://ws-api.bithumb.com/websocket/v1".to_string()));
m.insert("privateV2".to_string(), Value::Str("wss://ws-api.bithumb.com/websocket/v2/private".to_string()));
m.insert("publicGen2".to_string(), Value::Str("wss://ws-api.bithumb.com/websocket/v1".to_string()));
m.insert("privateGen2".to_string(), Value::Str("wss://ws-api.bithumb.com/websocket/v2/private".to_string()));
m
}));
m
}));
m
}));
m.insert("options".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
m.insert("streaming".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("keepAlive".to_string(), Value::Int(30000));
m.insert("maxPingPongMisses".to_string(), Value::Int(2));
m
}));
m.insert("exceptions".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
m
})]);
Value::Null
}
pub async fn pong(&mut self, mut client: Value, mut message: Value) -> Value {
let mut ping: Value = self.safe_integer_k(message.clone(), "ping", &[]);
if !is_equal(&ping, &Value::Null) {
client.send(&[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("pong".to_string(), ping.clone());
m
})]);
} else {
client.send(&[Value::Str("PONG".to_string())]);
}
Value::Null
}
pub fn handle_ping(&mut self, mut client: Value, mut message: Value) {
self.spawn(&[Value::Str("pong".to_string()).clone(), client.clone(), message.clone()]);
}
pub fn handle_pong(&self, mut client: Value, mut message: Value) {
crate::set_value(&mut client, &Value::Str("lastPong".to_string()), self.milliseconds());
}
/*
* @method
* @name bithumb#watchTicker
* @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
* @see https://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
* @see https://apidocs.bithumb.com/reference/%ED%98%84%EC%9E%AC%EA%B0%80-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
* @param {string} [params.tickTypes] generation 1 only, the tick type to subscribe to, '24H' by default (30M, 1H, 12H, 24H, MID)
* @param {int} [params.generation] if you want to use the API generation 1 or 2, default is 2
* @returns {object} a [ticker structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#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 generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTicker".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
let mut isGenerationTwo: bool = is_equal(&generation, &Value::Int(2));
let mut url: Value = ternary(is_true(&isGenerationTwo), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("publicGen2".to_string())), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string())));
let mut market: Value = self.market(symbol.clone());
let mut messageHash: Value = add(&Value::Str("ticker:".to_string()), &get_value(&market, &Value::Str("symbol".to_string())));
let mut tickTypes: Value = self.safe_string_k(params.clone(), "tickTypes", &[Value::Str("24H".to_string())]);
params = self.omit(params.clone(), Value::Str("tickTypes".to_string()), &[]);
let mut request: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("ticker".to_string()));
m.insert("symbols".to_string(), Value::List(vec![add(&add(&get_value(&market, &Value::Str("base".to_string())), &Value::Str("_".to_string())), &get_value(&market, &Value::Str("quote".to_string())))]));
m.insert("tickTypes".to_string(), Value::List(vec![tickTypes.clone()]));
m
});
if is_true(&isGenerationTwo) {
let mut marketIdRequest: Value = self.parent.get_gen2_market_id(market.clone());
request = Value::List(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticket".to_string(), self.uuid(&[]));
m
}), self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("ticker".to_string()));
m.insert("codes".to_string(), Value::List(vec![marketIdRequest.clone()]));
m
}), &[params.clone()])]);
return self.watch(url.clone(), messageHash.clone(), &[request.clone(), messageHash.clone()]).await;
}
let __ws_arg_0 = self.extend(request.clone(), &[params.clone()]);
return self.watch(url.clone(), messageHash.clone(), &[__ws_arg_0, messageHash.clone()]).await;
Value::Null
}
/*
* @method
* @name bithumb#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://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
* @see https://apidocs.bithumb.com/reference/%ED%98%84%EC%9E%AC%EA%B0%80-ticker
* @param {string[]} symbols unified symbols of the markets to fetch tickers for
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {string} [params.tickTypes] generation 1 only, the tick type to subscribe to, '24H' by default (30M, 1H, 12H, 24H, MID)
* @param {int} [params.generation] if you want to use the API generation 1 or 2, default is 2
* @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/?id=ticker-structure} indexed by market symbols
*/
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;
}
let mut generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTickers".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
let mut isGenerationTwo: bool = is_equal(&generation, &Value::Int(2));
symbols = self.market_symbols(&[symbols.clone(), Value::Null, Value::Bool(false), Value::Bool(true), Value::Bool(true)]);
let mut symbolsLength: Value = ternary(is_true(&(is_equal(&symbols, &Value::Null))), Value::Int(0), get_array_length(&symbols));
if is_true(&isGenerationTwo) && is_true(&(is_equal(&symbolsLength, &Value::Int(0)))) {
panic!("{}", crate::exchange_errors::arguments_required(add(&self.id, &Value::Str(" watchTickers() requires symbols for the generation 2 API".to_string()))));
}
if is_equal(&symbols, &Value::Null) {
symbols = self.symbols.clone();
}
let mut symbolsLengthDefined: Value = get_array_length(&symbols);
let mut url: Value = ternary(is_true(&isGenerationTwo), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("publicGen2".to_string())), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string())));
let mut streamMarketIds: Value = Value::List(vec![]);
let mut messageHashes: Value = Value::List(vec![]);
{
let mut i: Value = Value::Int(0);
let mut __for_first_126: bool = true;
while { if !__for_first_126 { i = add(&i, &Value::Int(1)); } __for_first_126 = false; is_less_than(&i, &symbolsLengthDefined) } {
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 streamMarketId: Value = Value::Null;
if is_true(&isGenerationTwo) {
streamMarketId = self.parent.get_gen2_market_id(market.clone());
} else {
streamMarketId = (add(&add(&get_value(&market, &Value::Str("base".to_string())), &Value::Str("_".to_string())), &get_value(&market, &Value::Str("quote".to_string()))));
}
append_to_array(&mut streamMarketIds, streamMarketId.clone());
append_to_array(&mut messageHashes, add(&Value::Str("ticker:".to_string()), &get_value(&market, &Value::Str("symbol".to_string()))));
}
}
let mut tickTypes: Value = self.safe_string_k(params.clone(), "tickTypes", &[Value::Str("24H".to_string())]);
params = self.omit(params.clone(), Value::Str("tickTypes".to_string()), &[]);
let mut message: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("ticker".to_string()));
m.insert("symbols".to_string(), streamMarketIds.clone());
m.insert("tickTypes".to_string(), Value::List(vec![tickTypes.clone()]));
m
});
if is_true(&isGenerationTwo) {
message = Value::List(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticket".to_string(), self.uuid(&[]));
m
}), self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("ticker".to_string()));
m.insert("codes".to_string(), streamMarketIds.clone());
m
}), &[params.clone()])]);
} else {
message = self.extend(message.clone(), &[params.clone()]);
}
let mut newTicker: Value = self.watch_multiple(url.clone(), messageHashes.clone(), &[message.clone(), messageHashes.clone()]).await;
if is_true(&self.newUpdates) {
let mut result: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
add_element_to_object(&mut result, &get_value(&newTicker, &Value::Str("symbol".to_string())), newTicker.clone());
return result;
}
return self.filter_by_array(self.tickers.clone(), Value::Str("symbol".to_string()), &[symbols.clone()]);
Value::Null
}
pub fn handle_ticker(&mut self, mut client: Value, mut message: Value) {
//
// generation 1
//
// {
// "type" : "ticker",
// "content" : {
// "symbol" : "BTC_KRW", // 통화코드
// "tickType" : "24H", // 변동 기준시간- 30M, 1H, 12H, 24H, MID
// "date" : "20200129", // 일자
// "time" : "121844", // 시간
// "openPrice" : "2302", // 시가
// "closePrice" : "2317", // 종가
// "lowPrice" : "2272", // 저가
// "highPrice" : "2344", // 고가
// "value" : "2831915078.07065789", // 누적거래금액
// "volume" : "1222314.51355788", // 누적거래량
// "sellVolume" : "760129.34079004", // 매도누적거래량
// "buyVolume" : "462185.17276784", // 매수누적거래량
// "prevClosePrice" : "2326", // 전일종가
// "chgRate" : "0.65", // 변동률
// "chgAmt" : "15", // 변동금액
// "volumePower" : "60.80" // 체결강도
// }
// }
//
// generation 2
//
// {
// "type": "ticker",
// "code": "KRW-BTC",
// "opening_price": 94223000,
// "high_price": 95465000,
// "low_price": 93601000,
// "trade_price": 95299000,
// "prev_closing_price": 94201000,
// "change": "RISE",
// "change_price": 1098000,
// "signed_change_price": 1098000,
// "change_rate": 0.01165593,
// "signed_change_rate": 0.01165593,
// "trade_volume": 0.0094,
// "acc_trade_volume": 151.44914647,
// "acc_trade_volume_24h": 310.44065227,
// "acc_trade_price": 14330306973.41015,
// "acc_trade_price_24h": 29226371799.56915,
// "trade_date": "20260710",
// "trade_time": "124548",
// "trade_timestamp": 1783655148303,
// "ask_bid": "BID",
// "acc_ask_volume": 52.30413928,
// "acc_bid_volume": 99.14500719,
// "highest_52_week_price": 179734000,
// "highest_52_week_date": "2025-10-09",
// "lowest_52_week_price": 81110000,
// "lowest_52_week_date": "2026-02-06",
// "market_state": "ACTIVE",
// "is_trading_suspended": false,
// "delisting_date": "",
// "market_warning": "NONE",
// "timestamp": 1783655148485,
// "stream_type": "REALTIME"
// }
//
let mut content: Value = self.safe_dict_k(message.clone(), "content", &[]);
let mut isGenerationTwo: bool = is_equal(&content, &Value::Null);
let mut tickerMessage: Value = Value::Null;
if is_true(&isGenerationTwo) {
tickerMessage = message.clone();
} else {
tickerMessage = content.clone();
}
let mut marketId: Value = self.safe_string2(tickerMessage.clone(), Value::Str("symbol".to_string()), Value::Str("code".to_string()), &[]);
if is_equal(&marketId, &Value::Null) {
return;
}
let mut symbol: Value = Value::Null;
if is_true(&isGenerationTwo) {
symbol = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("-".to_string())]);
} else {
symbol = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("_".to_string())]);
}
if is_equal(&symbol, &Value::Null) {
return;
}
let mut ticker: Value = self.parse_ws_ticker(tickerMessage.clone(), &[]);
let mut messageHash: Value = add(&Value::Str("ticker:".to_string()), &symbol);
add_element_to_object(&mut self.tickers, &symbol, ticker.clone());
client.resolve(&[get_value(&self.tickers, &symbol), messageHash.clone()]);
}
pub fn parse_ws_ticker(&self, mut ticker: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
//
// {
// "symbol" : "BTC_KRW", // 통화코드
// "tickType" : "24H", // 변동 기준시간- 30M, 1H, 12H, 24H, MID
// "date" : "20200129", // 일자
// "time" : "121844", // 시간
// "openPrice" : "2302", // 시가
// "closePrice" : "2317", // 종가
// "lowPrice" : "2272", // 저가
// "highPrice" : "2344", // 고가
// "value" : "2831915078.07065789", // 누적거래금액
// "volume" : "1222314.51355788", // 누적거래량
// "sellVolume" : "760129.34079004", // 매도누적거래량
// "buyVolume" : "462185.17276784", // 매수누적거래량
// "prevClosePrice" : "2326", // 전일종가
// "chgRate" : "0.65", // 변동률
// "chgAmt" : "15", // 변동금액
// "volumePower" : "60.80" // 체결강도
// }
//
// generation 2
//
// {
// "type": "ticker",
// "code": "KRW-BTC",
// "opening_price": 94223000,
// "high_price": 95465000,
// "low_price": 93601000,
// "trade_price": 95299000,
// "prev_closing_price": 94201000,
// "change": "RISE",
// "change_price": 1098000,
// "signed_change_price": 1098000,
// "change_rate": 0.01165593,
// "signed_change_rate": 0.01165593,
// "trade_volume": 0.0094,
// "acc_trade_volume": 151.44914647,
// "acc_trade_volume_24h": 310.44065227,
// "acc_trade_price": 14330306973.41015,
// "acc_trade_price_24h": 29226371799.56915,
// "trade_date": "20260710",
// "trade_time": "124548",
// "trade_timestamp": 1783655148303,
// "ask_bid": "BID",
// "acc_ask_volume": 52.30413928,
// "acc_bid_volume": 99.14500719,
// "highest_52_week_price": 179734000,
// "highest_52_week_date": "2025-10-09",
// "lowest_52_week_price": 81110000,
// "lowest_52_week_date": "2026-02-06",
// "market_state": "ACTIVE",
// "is_trading_suspended": false,
// "delisting_date": "",
// "market_warning": "NONE",
// "timestamp": 1783655148485,
// "stream_type": "REALTIME"
// }
//
let mut code: Value = self.safe_string_k(ticker.clone(), "code", &[]);
if !is_equal(&code, &Value::Null) {
{ let __be_tmp = self.safe_string_k(ticker.clone(), "market", &[code.clone()]); add_element_to_object(&mut ticker, &Value::Str("market".to_string()), __be_tmp); };
return self.parse_ticker(ticker.clone(), &[market.clone()]);
}
let mut date: Value = self.safe_string_k(ticker.clone(), "date", &[Value::Str("".to_string())]);
let mut time: Value = self.safe_string_k(ticker.clone(), "time", &[Value::Str("".to_string())]);
let mut kstDatetime: Value = add(&add(&add(&add(&add(&add(&add(&add(&add(&add(&slice(&date, &Value::Int(0), &Value::Int(4)), &Value::Str("-".to_string())), &slice(&date, &Value::Int(4), &Value::Int(6))), &Value::Str("-".to_string())), &slice(&date, &Value::Int(6), &Value::Int(8))), &Value::Str("T".to_string())), &slice(&time, &Value::Int(0), &Value::Int(2))), &Value::Str(":".to_string())), &slice(&time, &Value::Int(2), &Value::Int(4))), &Value::Str(":".to_string())), &slice(&time, &Value::Int(4), &Value::Int(6)));
// date/time are the exchange's local KST wall-clock, not UTC — shift -9h like parseWsTrade
let mut timestamp: Value = self.parse8601(kstDatetime.clone());
if !is_equal(×tamp, &Value::Null) {
timestamp = (subtract(×tamp, &Value::Int(32400000)));
}
let mut marketId: Value = self.safe_string_k(ticker.clone(), "symbol", &[]);
return self.safe_ticker(Value::Map({
let mut m = indexmap::IndexMap::new();
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(), "highPrice", &[]));
m.insert("low".to_string(), self.safe_string_k(ticker.clone(), "lowPrice", &[]));
m.insert("bid".to_string(), Value::Null);
m.insert("bidVolume".to_string(), self.safe_string_k(ticker.clone(), "buyVolume", &[]));
m.insert("ask".to_string(), Value::Null);
m.insert("askVolume".to_string(), self.safe_string_k(ticker.clone(), "sellVolume", &[]));
m.insert("vwap".to_string(), Value::Null);
m.insert("open".to_string(), self.safe_string_k(ticker.clone(), "openPrice", &[]));
m.insert("close".to_string(), self.safe_string_k(ticker.clone(), "closePrice", &[]));
m.insert("last".to_string(), Value::Null);
m.insert("previousClose".to_string(), self.safe_string_k(ticker.clone(), "prevClosePrice", &[]));
m.insert("change".to_string(), self.safe_string_k(ticker.clone(), "chgAmt", &[]));
m.insert("percentage".to_string(), self.safe_string_k(ticker.clone(), "chgRate", &[]));
m.insert("average".to_string(), Value::Null);
m.insert("baseVolume".to_string(), self.safe_string_k(ticker.clone(), "volume", &[]));
m.insert("quoteVolume".to_string(), self.safe_string_k(ticker.clone(), "value", &[]));
m.insert("info".to_string(), ticker.clone());
m
}), &[market.clone()]);
Value::Null
}
/*
* @method
* @name bithumb#watchOrderBook
* @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
* @see https://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
* @see https://apidocs.bithumb.com/reference/%ED%98%B8%EA%B0%80-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
* @param {int} [params.generation] if you want to use the API generation 1 or 2, default is 2
* @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 generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrderBook".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
let mut isGenerationTwo: bool = is_equal(&generation, &Value::Int(2));
let mut url: Value = ternary(is_true(&isGenerationTwo), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("publicGen2".to_string())), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string())));
let mut market: Value = self.market(symbol.clone());
symbol = get_value(&market, &Value::Str("symbol".to_string()));
let mut messageHash: Value = add(&add(&Value::Str("orderbook".to_string()), &Value::Str(":".to_string())), &symbol);
let mut request: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("orderbookdepth".to_string()));
m.insert("symbols".to_string(), Value::List(vec![add(&add(&get_value(&market, &Value::Str("base".to_string())), &Value::Str("_".to_string())), &get_value(&market, &Value::Str("quote".to_string())))]));
m
});
if is_true(&isGenerationTwo) {
let mut marketIdRequest: Value = self.parent.get_gen2_market_id(market.clone());
request = Value::List(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticket".to_string(), self.uuid(&[]));
m
}), self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("orderbook".to_string()));
m.insert("codes".to_string(), Value::List(vec![marketIdRequest.clone()]));
m
}), &[params.clone()])]);
} else {
request = self.extend(request.clone(), &[params.clone()]);
}
let mut orderbook: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), messageHash.clone()]).await;
return orderbook.limit();
Value::Null
}
pub fn handle_order_book(&mut self, mut client: Value, mut message: Value) {
//
// generation 1
//
// {
// "type" : "orderbookdepth",
// "content" : {
// "list" : [
// {
// "symbol" : "BTC_KRW",
// "orderType" : "ask", // 주문타입 – bid / ask
// "price" : "10593000", // 호가
// "quantity" : "1.11223318", // 잔량
// "total" : "3" // 건수
// },
// {"symbol" : "BTC_KRW", "orderType" : "ask", "price" : "10596000", "quantity" : "0.5495", "total" : "8"},
// {"symbol" : "BTC_KRW", "orderType" : "ask", "price" : "10598000", "quantity" : "18.2085", "total" : "10"},
// {"symbol" : "BTC_KRW", "orderType" : "bid", "price" : "10532000", "quantity" : "0", "total" : "0"},
// {"symbol" : "BTC_KRW", "orderType" : "bid", "price" : "10572000", "quantity" : "2.3324", "total" : "4"},
// {"symbol" : "BTC_KRW", "orderType" : "bid", "price" : "10571000", "quantity" : "1.469", "total" : "3"},
// {"symbol" : "BTC_KRW", "orderType" : "bid", "price" : "10569000", "quantity" : "0.5152", "total" : "2"}
// ],
// "datetime":1580268255864325 // 일시
// }
// }
//
// generation 2
//
// {
// "type": "orderbook",
// "code": "KRW-BTC",
// "total_ask_size": 4.7398,
// "total_bid_size": 0.2889,
// "orderbook_units": [
// {
// "ask_price": 95340000,
// "bid_price": 95339000,
// "ask_size": 0.0007,
// "bid_size": 0.0024
// },
// ],
// "level": 1,
// "timestamp": "1783657882348968",
// "stream_type": "SNAPSHOT"
// }
//
let mut content: Value = self.safe_dict_k(message.clone(), "content", &[]);
if !is_equal(&content, &Value::Null) {
let mut list: Value = self.safe_list_k(content.clone(), "list", &[Value::List(vec![])]);
let mut first: Value = self.safe_dict(list.clone(), Value::Int(0), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut legacyMarketId: Value = self.safe_string_k(first.clone(), "symbol", &[]);
if is_equal(&legacyMarketId, &Value::Null) {
return;
}
let mut legacySymbol: Value = self.safe_symbol(legacyMarketId.clone(), &[Value::Null, Value::Str("_".to_string())]);
let mut timestampStr: Value = self.safe_string_k(content.clone(), "datetime", &[]);
if is_equal(×tampStr, &Value::Null) {
return;
}
let mut legacyTimestamp: Value = self.parse_to_int(slice(×tampStr, &Value::Int(0), &Value::Int(13)));
if !is_true(&(Value::Bool(in_op(&self.orderbooks, &legacySymbol)))) {
let mut ob: Value = self.order_book(&[]);
add_element_to_object(&mut ob, &Value::Str("symbol".to_string()), legacySymbol.clone());
add_element_to_object(&mut self.orderbooks, &legacySymbol, ob.clone());
}
let mut legacyOrderbook: Value = get_value(&self.orderbooks, &legacySymbol);
self.handle_deltas(legacyOrderbook.clone(), list.clone());
add_element_to_object(&mut legacyOrderbook, &Value::Str("timestamp".to_string()), legacyTimestamp.clone());
add_element_to_object(&mut legacyOrderbook, &Value::Str("datetime".to_string()), self.iso8601(legacyTimestamp.clone()));
let mut legacyMessageHash: Value = add(&add(&Value::Str("orderbook".to_string()), &Value::Str(":".to_string())), &legacySymbol);
client.resolve(&[legacyOrderbook.clone(), legacyMessageHash.clone()]);
return;
}
let mut marketId: Value = self.safe_string_k(message.clone(), "code", &[]);
let mut symbol: Value = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("-".to_string())]);
if is_equal(&symbol, &Value::Null) {
return;
}
let mut streamType: Value = self.safe_string_k(message.clone(), "stream_type", &[]);
let mut options: Value = self.safe_value_k(self.options.clone(), "watchOrderBook", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut obLimit: Value = self.safe_integer_k(options.clone(), "limit", &[Value::Int(1000)]);
if !is_true(&(Value::Bool(in_op(&self.orderbooks, &symbol)))) || is_true(&(is_equal(&streamType, &Value::Str("SNAPSHOT".to_string())))) {
{ let __be_tmp = self.order_book(&[Value::Map({
let mut m = indexmap::IndexMap::new();
m
}), obLimit.clone()]); add_element_to_object(&mut self.orderbooks, &symbol, __be_tmp); };
}
let mut orderbook: Value = get_value(&self.orderbooks, &symbol);
orderbook.reset(Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
add_element_to_object(&mut orderbook, &Value::Str("symbol".to_string()), symbol.clone());
let mut bids: Value = get_value(&orderbook, &Value::Str("bids".to_string()));
let mut asks: Value = get_value(&orderbook, &Value::Str("asks".to_string()));
let mut units: Value = self.safe_list_k(message.clone(), "orderbook_units", &[Value::List(vec![])]);
{
let mut i: Value = Value::Int(0);
let mut __for_first_127: bool = true;
while { if !__for_first_127 { i = add(&i, &Value::Int(1)); } __for_first_127 = false; is_less_than(&i, &get_array_length(&units)) } {
let mut entry: Value = get_value(&units, &i);
let mut entry: Value = get_value(&units, &i);
let mut bidPrice: Value = self.safe_number_k(entry.clone(), "bid_price", &[]);
let mut bidSize: Value = self.safe_number_k(entry.clone(), "bid_size", &[]);
let mut askPrice: Value = self.safe_number_k(entry.clone(), "ask_price", &[]);
let mut askSize: Value = self.safe_number_k(entry.clone(), "ask_size", &[]);
if is_true(&(!is_equal(&bidPrice, &Value::Null))) && is_true(&(!is_equal(&bidSize, &Value::Null))) {
bids.store(bidPrice.clone(), bidSize.clone());
}
if is_true(&(!is_equal(&askPrice, &Value::Null))) && is_true(&(!is_equal(&askSize, &Value::Null))) {
asks.store(askPrice.clone(), askSize.clone());
}
}
}
let mut gen2TimestampStr: Value = self.safe_string2(message.clone(), Value::Str("timestamp".to_string()), Value::Str("datetime".to_string()), &[]);
let mut timestamp: Value = Value::Null;
if !is_equal(&gen2TimestampStr, &Value::Null) {
timestamp = self.parse_to_int(slice(&gen2TimestampStr, &Value::Int(0), &Value::Int(13)));
}
if is_equal(×tamp, &Value::Null) {
timestamp = self.milliseconds();
}
add_element_to_object(&mut orderbook, &Value::Str("timestamp".to_string()), timestamp.clone());
add_element_to_object(&mut orderbook, &Value::Str("datetime".to_string()), self.iso8601(timestamp.clone()));
let mut messageHash: Value = add(&add(&Value::Str("orderbook".to_string()), &Value::Str(":".to_string())), &symbol);
client.resolve(&[orderbook.clone(), messageHash.clone()]);
}
pub fn handle_delta(&self, mut orderbook: Value, mut delta: Value) {
//
// {
// symbol: "ETH_BTC",
// orderType: "bid",
// price: "0.07349517",
// quantity: "0",
// total: "0",
// }
//
let mut sideId: Value = self.safe_string_k(delta.clone(), "orderType", &[]);
let mut side: Value = ternary(is_true(&(is_equal(&sideId, &Value::Str("bid".to_string())))), Value::Str("bids".to_string()), Value::Str("asks".to_string()));
let mut bidAsk: Value = self.parse_order_book_bid_ask(delta.clone(), &[Value::Str("price".to_string()), Value::Str("quantity".to_string())]);
let mut orderbookSide: Value = get_value(&orderbook, &side);
let mut orderbookSide: Value = get_value(&orderbook, &side);
orderbookSide.store_array(bidAsk.clone());
}
pub fn handle_deltas(&self, mut orderbook: Value, mut deltas: Value) {
{
let mut i: Value = Value::Int(0);
let mut __for_first_128: bool = true;
while { if !__for_first_128 { i = add(&i, &Value::Int(1)); } __for_first_128 = false; is_less_than(&i, &get_array_length(&deltas)) } {
self.handle_delta(orderbook.clone(), get_value(&deltas, &i));
}
}
}
/*
* @method
* @name bithumb#watchTrades
* @description get the list of most recent trades for a particular symbol
* @see https://apidocs.bithumb.com/v1.2.0/reference/%EB%B9%97%EC%8D%B8-%EA%B1%B0%EB%9E%98%EC%86%8C-%EC%A0%95%EB%B3%B4-%EC%88%98%EC%8B%A0
* @see https://apidocs.bithumb.com/reference/%EC%B2%B4%EA%B2%B0-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
* @param {int} [params.generation] if you want to use the API generation 1 or 2, default is 2
* @returns {object[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#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;
}
let mut generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchTrades".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
let mut isGenerationTwo: bool = is_equal(&generation, &Value::Int(2));
let mut url: Value = ternary(is_true(&isGenerationTwo), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("publicGen2".to_string())), get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("public".to_string())));
let mut market: Value = self.market(symbol.clone());
symbol = get_value(&market, &Value::Str("symbol".to_string()));
let mut messageHash: Value = add(&Value::Str("trade:".to_string()), &symbol);
let mut request: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("transaction".to_string()));
m.insert("symbols".to_string(), Value::List(vec![add(&add(&get_value(&market, &Value::Str("base".to_string())), &Value::Str("_".to_string())), &get_value(&market, &Value::Str("quote".to_string())))]));
m
});
if is_true(&isGenerationTwo) {
let mut marketIdRequest: Value = self.parent.get_gen2_market_id(market.clone());
request = Value::List(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticket".to_string(), self.uuid(&[]));
m
}), self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), Value::Str("trade".to_string()));
m.insert("codes".to_string(), Value::List(vec![marketIdRequest.clone()]));
m
}), &[params.clone()])]);
} else {
request = self.extend(request.clone(), &[params.clone()]);
}
let mut trades: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), messageHash.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
}
pub fn handle_trades(&mut self, mut client: Value, mut message: Value) {
//
// generation 1
//
// {
// "type" : "transaction",
// "content" : {
// "list" : [
// {
// "symbol" : "BTC_KRW",
// "buySellGb" : "1",
// "contPrice" : "10579000",
// "contQty" : "0.01",
// "contAmt" : "105790.00",
// "contDtm" : "2020-01-29 12:24:18.830039",
// "updn" : "dn"
// }
// ]
// }
// }
//
// generation 2
//
// {
// "type": "trade",
// "code": "KRW-BTC",
// "trade_price": 95539000,
// "trade_volume": 0.00022664,
// "ask_bid": "ASK",
// "prev_closing_price": 94201000,
// "change": "RISE",
// "change_price": 1338000,
// "trade_date": "2026-07-10",
// "trade_time": "13:39:41",
// "trade_timestamp": 1783658381138,
// "sequential_id": "862683813820523888",
// "timestamp": 1783658381398,
// "stream_type": "REALTIME"
// }
//
let mut content: Value = self.safe_dict_k(message.clone(), "content", &[]);
let mut rawTrades: Value = self.safe_list_k(content.clone(), "list", &[]);
if is_equal(&rawTrades, &Value::Null) {
rawTrades = Value::List(vec![message.clone()]);
}
{
let mut i: Value = Value::Int(0);
let mut __for_first_129: bool = true;
while { if !__for_first_129 { i = add(&i, &Value::Int(1)); } __for_first_129 = false; is_less_than(&i, &get_array_length(&rawTrades)) } {
let mut rawTrade: Value = get_value(&rawTrades, &i);
let mut rawTrade: Value = get_value(&rawTrades, &i);
let mut marketId: Value = self.safe_string2(rawTrade.clone(), Value::Str("symbol".to_string()), Value::Str("code".to_string()), &[]);
if is_equal(&marketId, &Value::Null) {
continue;
}
let mut code: Value = self.safe_string_k(rawTrade.clone(), "code", &[]);
let mut isGenerationTwo: bool = !is_equal(&code, &Value::Null);
let mut fallbackSymbol: Value = Value::Null;
if is_true(&isGenerationTwo) {
fallbackSymbol = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("-".to_string())]);
} else {
fallbackSymbol = self.safe_symbol(marketId.clone(), &[Value::Null, Value::Str("_".to_string())]);
}
let mut parsed: Value = self.parse_ws_trade(rawTrade.clone(), &[]);
let mut symbol: Value = self.safe_string_k(parsed.clone(), "symbol", &[fallbackSymbol.clone()]);
if !is_true(&(Value::Bool(in_op(&self.trades, &symbol)))) {
let mut limit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
let mut stored = ArrayCache::new(limit.clone());
add_element_to_object(&mut self.trades, &symbol, stored.clone());
}
let mut trades: Value = get_value(&self.trades, &symbol);
trades.append(parsed.clone());
let mut messageHash: Value = add(&add(&Value::Str("trade".to_string()), &Value::Str(":".to_string())), &symbol);
client.resolve(&[trades.clone(), messageHash.clone()]);
}
}
}
pub fn parse_ws_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
//
// generation 1
//
// {
// "symbol" : "BTC_KRW",
// "buySellGb" : "1",
// "contPrice" : "10579000",
// "contQty" : "0.01",
// "contAmt" : "105790.00",
// "contDtm" : "2020-01-29 12:24:18.830038",
// "updn" : "dn"
// }
//
// generation 2
//
// {
// "type": "trade",
// "code": "KRW-BTC",
// "trade_price": 95539000,
// "trade_volume": 0.00022664,
// "ask_bid": "ASK",
// "prev_closing_price": 94201000,
// "change": "RISE",
// "change_price": 1338000,
// "trade_date": "2026-07-10",
// "trade_time": "13:39:41",
// "trade_timestamp": 1783658381138,
// "sequential_id": "862683813820523888",
// "timestamp": 1783658381398,
// "stream_type": "REALTIME"
// }
//
let mut marketCode: Value = self.safe_string_k(trade.clone(), "code", &[]);
if !is_equal(&marketCode, &Value::Null) {
let mut tradeTimestamp: Value = self.safe_integer_k(trade.clone(), "trade_timestamp", &[]);
let mut normalized: Value = self.extend(trade.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("market".to_string(), marketCode.clone());
m.insert("timestamp".to_string(), tradeTimestamp.clone());
m
})]);
return self.parse_trade(normalized.clone(), &[market.clone()]);
}
let mut marketId: Value = self.safe_string_k(trade.clone(), "symbol", &[]);
let mut datetime: Value = self.safe_string_k(trade.clone(), "contDtm", &[]);
// that date is not UTC iso8601, but exchange's local time, -9hr difference
let mut timestamp: Value = subtract(&self.parse_to_int(self.parse8601(datetime.clone())), &Value::Int(32400000));
let mut sideId: Value = self.safe_string_k(trade.clone(), "buySellGb", &[]);
return self.safe_trade(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), Value::Null);
m.insert("info".to_string(), trade.clone());
m.insert("timestamp".to_string(), timestamp.clone());
m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
m.insert("symbol".to_string(), self.safe_symbol(marketId.clone(), &[market.clone(), Value::Str("_".to_string())]));
m.insert("order".to_string(), Value::Null);
m.insert("type".to_string(), Value::Null);
m.insert("side".to_string(), ternary(is_true(&(is_equal(&sideId, &Value::Str("1".to_string())))), Value::Str("buy".to_string()), Value::Str("sell".to_string())));
m.insert("takerOrMaker".to_string(), Value::Null);
m.insert("price".to_string(), self.safe_string_k(trade.clone(), "contPrice", &[]));
m.insert("amount".to_string(), self.safe_string_k(trade.clone(), "contQty", &[]));
m.insert("cost".to_string(), self.safe_string_k(trade.clone(), "contAmt", &[]));
m.insert("fee".to_string(), Value::Null);
m
}), &[market.clone()]);
Value::Null
}
pub fn handle_error_message(&self, mut client: Value, mut message: Value) -> Value {
//
// {
// "status" : "5100",
// "resmsg" : "Invalid Filter Syntax"
// }
//
let mut error: Value = self.safe_dict_k(message.clone(), "error", &[]);
if !is_equal(&error, &Value::Null) {
let mut errorName: Value = self.safe_string_k(error.clone(), "name", &[Value::Str("Error".to_string())]);
let mut errorMessage: Value = self.safe_string_k(error.clone(), "message", &[Value::Str("".to_string())]);
let mut addedMessage: Value = Value::Null;
if is_true(&(is_greater_than(&get_array_length(&errorMessage), &Value::Int(0)))) {
addedMessage = (add(&Value::Str(" ".to_string()), &errorMessage));
} else {
addedMessage = Value::Str("".to_string());
}
client.reject(&[Value::from(crate::exchange_errors::exchange_error(add(&add(&add(&self.id, &Value::Str(" websocket error ".to_string())), &errorName), &addedMessage)))]);
return Value::Bool(false);
}
if !is_true(&(Value::Bool(in_op(&message, &Value::Str("status".to_string()))))) {
return Value::Bool(true);
}
let mut errorCode: Value = self.safe_string_k(message.clone(), "status", &[]);
let _try_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
if is_true(&(is_equal(&errorCode, &Value::Str("UP".to_string())))) || is_true(&(is_equal(&errorCode, &Value::Str("0000".to_string())))) {
return Value::Bool(true);
}
if !is_equal(&errorCode, &Value::Str("0000".to_string())) {
let mut msg: Value = self.safe_string_k(message.clone(), "resmsg", &[]);
panic!("{}", crate::exchange_errors::exchange_error(add(&add(&self.id, &Value::Str(" ".to_string())), &msg)));
}
return Value::Bool(true);
#[allow(unreachable_code)] { Value::Null }}));
match _try_result { Ok(__try_ok) => { if !matches!(__try_ok, Value::Null) { return __try_ok; } return Value::Null; } Err(_try_err) => { let e: Value = panic_to_value(_try_err);
client.reject(&[e.clone()]);
return Value::Bool(false);
} }
Value::Null
}
/*
* @method
* @name bithumb#watchBalance
* @description watch balance and get the amount of funds available for trading or funds locked in orders
* @see https://apidocs.bithumb.com/v2.1.5/reference/%EB%82%B4-%EC%9E%90%EC%82%B0-myasset
* @param {object} [params] extra parameters specific to the exchange API endpoint
* @param {int} [params.generation] *only generation 2 is supported* if you want to use the API generation 1 or 2, default is 2
* @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
*/
pub async fn watch_balance(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
if is_equal(&self.markets, &Value::Null) {
self.load_markets(&[]).await;
}
let mut generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchBalance".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
if !is_equal(&generation, &Value::Int(2)) {
panic!("{}", crate::exchange_errors::bad_request(add(&self.id, &Value::Str(" watchBalance() is only supported for the generation 2 API".to_string()))));
}
self.authenticate(&[]).await;
let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("privateGen2".to_string()));
let mut messageHash: Value = Value::Str("myAsset".to_string());
let mut request: Value = self.build_gen2_subscription_request(messageHash.clone(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), messageHash.clone());
m
}));
let mut balance: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), messageHash.clone()]).await;
return balance;
Value::Null
}
pub fn handle_balance(&mut self, mut client: Value, mut message: Value) {
//
// {
// "type": "myAsset",
// "assets": [
// {
// "currency": "KRW",
// "balance": "2061832.35",
// "locked": "3824127.3"
// }
// ],
// "asset_timestamp": 1727052537592,
// "timestamp": 1727052537687,
// "stream_type": "REALTIME"
// }
//
let mut messageHash: Value = Value::Str("myAsset".to_string());
let mut assets: Value = self.safe_list_k(message.clone(), "assets", &[Value::List(vec![])]);
if is_equal(&self.balance, &Value::Null) {
self.balance = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
}
{
let mut i: Value = Value::Int(0);
let mut __for_first_130: bool = true;
while { if !__for_first_130 { i = add(&i, &Value::Int(1)); } __for_first_130 = false; is_less_than(&i, &get_array_length(&assets)) } {
let mut asset: Value = get_value(&assets, &i);
let mut asset: Value = get_value(&assets, &i);
let mut currencyId: Value = self.safe_string_k(asset.clone(), "currency", &[]);
let mut code: Value = self.safe_currency_code(currencyId.clone(), &[]);
let mut account: Value = self.account();
add_element_to_object(&mut account, &Value::Str("free".to_string()), self.safe_string_k(asset.clone(), "balance", &[]));
add_element_to_object(&mut account, &Value::Str("used".to_string()), self.safe_string_k(asset.clone(), "locked", &[]));
if !is_equal(&code, &Value::Null) {
add_element_to_object(&mut self.balance, &code, account.clone());
}
}
}
add_element_to_object(&mut self.balance, &Value::Str("info".to_string()), message.clone());
let mut timestamp: Value = self.safe_integer_k(message.clone(), "timestamp", &[]);
add_element_to_object(&mut self.balance, &Value::Str("timestamp".to_string()), timestamp.clone());
{ let __be_tmp = self.iso8601(timestamp.clone()); add_element_to_object(&mut self.balance, &Value::Str("datetime".to_string()), __be_tmp); };
{ let __t = self.safe_balance(self.balance.clone()); self.balance = __t; }
client.resolve(&[self.balance.clone(), messageHash.clone()]);
}
/*
* @ignore
* @method
* @name bithumb#buildGen2SubscriptionRequest
* @description builds the SUBSCRIBE frame for the generation 2 private socket - the venue replaces
* the socket's whole subscription list with every SUBSCRIBE frame, so the frame always carries the
* union of everything subscribed so far, otherwise a second stream (e.g. watchOrders after
* watchBalance) would silently cancel the first one
* @param {string} subscriptionType the venue subscription type ('myAsset' / 'myOrder')
* @param {object} subscription the subscription entry for that type
* @returns {object[]} the SUBSCRIBE frame to send
*/
pub fn build_gen2_subscription_request(&mut self, mut subscriptionType: Value, mut subscription: Value) -> Value {
let mut wsOptions: Value = self.safe_dict_k(self.options.clone(), "ws", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut subscriptions: Value = self.safe_dict_k(wsOptions.clone(), "gen2Subscriptions", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
add_element_to_object(&mut subscriptions, &subscriptionType, subscription.clone());
add_element_to_object(&mut wsOptions, &Value::Str("gen2Subscriptions".to_string()), subscriptions.clone());
add_element_to_object(&mut self.options, &Value::Str("ws".to_string()), wsOptions.clone());
let mut request: Value = Value::List(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticket".to_string(), Value::Str("ccxt".to_string()));
m
})]);
let mut keys: Value = object_keys(&subscriptions);
{
let mut i: Value = Value::Int(0);
let mut __for_first_131: bool = true;
while { if !__for_first_131 { i = add(&i, &Value::Int(1)); } __for_first_131 = false; is_less_than(&i, &get_array_length(&keys)) } {
append_to_array(&mut request, get_value(&subscriptions, &get_value(&keys, &i)));
}
}
return request;
Value::Null
}
pub async fn authenticate(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
self.check_required_credentials(&[]);
let mut wsOptions: Value = self.safe_dict_k(self.options.clone(), "ws", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut authenticated: Value = self.safe_string_k(wsOptions.clone(), "token", &[]);
if is_equal(&authenticated, &Value::Null) {
let mut payload: 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.insert("timestamp".to_string(), self.milliseconds());
m
});
let mut jwtToken: Value = jwt(payload.clone(), self.encode(self.secret.clone()), Value::Str("sha256".to_string()), Value::Bool(false), Value::Null);
add_element_to_object(&mut wsOptions, &Value::Str("token".to_string()), jwtToken.clone());
add_element_to_object(&mut wsOptions, &Value::Str("options".to_string()), 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(), add(&Value::Str("Bearer ".to_string()), &jwtToken));
m
}));
m
}));
add_element_to_object(&mut self.options, &Value::Str("ws".to_string()), wsOptions.clone());
}
let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("privateGen2".to_string()));
let mut client: Value = self.client(&[url.clone()]);
return client;
Value::Null
}
/*
* @method
* @name bithumb#watchOrders
* @description watches information on multiple orders made by the user
* @see https://apidocs.bithumb.com/v2.1.5/reference/%EB%82%B4-%EC%A3%BC%EB%AC%B8-%EB%B0%8F-%EC%B2%B4%EA%B2%B0-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
* @param {string[]} [params.codes] market codes to filter orders
* @param {int} [params.generation] *only generation 2 is supported* if you want to use the API generation 1 or 2, default is 2
* @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 generation: Value = Value::Null;
{ let __destr_tmp = self.handle_option_and_params(params.clone(), Value::Str("watchOrders".to_string()), Value::Str("generation".to_string()), &[Value::Int(2)]); generation = get_value(&__destr_tmp, &Value::Int(0)); params = get_value(&__destr_tmp, &Value::Int(1)); }
if !is_equal(&generation, &Value::Int(2)) {
panic!("{}", crate::exchange_errors::bad_request(add(&self.id, &Value::Str(" watchOrders() is only supported for the generation 2 API".to_string()))));
}
self.authenticate(&[]).await;
let mut url: Value = get_value(&get_value(&get_value(&self.urls, &Value::Str("api".to_string())), &Value::Str("ws".to_string())), &Value::Str("privateGen2".to_string()));
let mut messageHash: Value = Value::Str("myOrder".to_string());
let mut codes: Value = self.safe_list_k(params.clone(), "codes", &[Value::List(vec![])]);
let mut request: Value = self.build_gen2_subscription_request(messageHash.clone(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("type".to_string(), messageHash.clone());
m.insert("codes".to_string(), codes.clone());
m
}));
if !is_equal(&symbol, &Value::Null) {
let mut market: Value = self.market(symbol.clone());
symbol = get_value(&market, &Value::Str("symbol".to_string()));
messageHash = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
}
let mut orders: Value = self.watch(url.clone(), messageHash.clone(), &[request.clone(), messageHash.clone()]).await;
if is_true(&self.newUpdates) {
limit = orders.get_limit(symbol.clone(), limit.clone());
}
return self.filter_by_symbol_since_limit(orders.clone(), &[symbol.clone(), since.clone(), limit.clone(), Value::Bool(true)]);
Value::Null
}
pub fn handle_orders(&mut self, mut client: Value, mut message: Value) {
//
// {
// "type": "myOrder",
// "code": "KRW-BTC",
// "uuid": "C0101000000001818113",
// "ask_bid": "BID",
// "order_type": "limit",
// "state": "trade",
// "trade_uuid": "C0101000000001744207",
// "price": 1927000,
// "volume": 0.4697,
// "remaining_volume": 0.0803,
// "executed_volume": 0.4697,
// "trades_count": 1,
// "reserved_fee": 0,
// "remaining_fee": 0,
// "paid_fee": 0,
// "executed_funds": 905111.9000,
// "trade_timestamp": 1727052318148,
// "order_timestamp": 1727052318074,
// "timestamp": 1727052318369,
// "stream_type": "REALTIME"
// }
//
let mut messageHash: Value = Value::Str("myOrder".to_string());
let mut parsed: Value = self.parse_ws_order(message.clone(), &[]);
let mut symbol: Value = self.safe_string_k(parsed.clone(), "symbol", &[]);
// const orderId = this.safeString (parsed, 'id');
if is_equal(&self.orders, &Value::Null) {
let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
self.orders = ArrayCacheBySymbolById::new(limit.clone());
}
let mut cachedOrders: Value = self.orders.clone();
cachedOrders.append(parsed.clone());
client.resolve(&[cachedOrders.clone(), messageHash.clone()]);
let mut symbolSpecificMessageHash: Value = add(&add(&messageHash, &Value::Str(":".to_string())), &symbol);
client.resolve(&[cachedOrders.clone(), symbolSpecificMessageHash.clone()]);
}
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": "KRW-BTC",
// "uuid": "C0101000000001818113",
// "ask_bid": "BID",
// "order_type": "limit",
// "state": "trade",
// "trade_uuid": "C0101000000001744207",
// "price": 1927000,
// "volume": 0.4697,
// "remaining_volume": 0.0803,
// "executed_volume": 0.4697,
// "trades_count": 1,
// "reserved_fee": 0,
// "remaining_fee": 0,
// "paid_fee": 0,
// "executed_funds": 905111.9000,
// "trade_timestamp": 1727052318148,
// "order_timestamp": 1727052318074,
// "timestamp": 1727052318369,
// "stream_type": "REALTIME"
// }
//
let mut marketId: Value = self.safe_string_k(order.clone(), "code", &[]);
let mut symbol: Value = self.safe_symbol(marketId.clone(), &[market.clone(), Value::Str("-".to_string())]);
let mut timestamp: Value = self.safe_integer_k(order.clone(), "order_timestamp", &[]);
let mut sideId: Value = self.safe_string_k(order.clone(), "ask_bid", &[]);
let mut side: Value = self.safe_string_lower(order.clone(), Value::Str("side".to_string()), &[]);
if !is_equal(&sideId, &Value::Null) {
side = ternary(is_true(&(is_equal(&sideId, &Value::Str("BID".to_string())))), (Value::Str("buy".to_string())), (Value::Str("sell".to_string())));
}
let mut typeId: Value = self.safe_string_k(order.clone(), "order_type", &[]);
let mut type_var: Value = Value::Null;
if is_equal(&typeId, &Value::Str("limit".to_string())) {
type_var = Value::Str("limit".to_string());
} else if is_equal(&typeId, &Value::Str("price".to_string())) {
type_var = Value::Str("market".to_string());
} else if is_equal(&typeId, &Value::Str("market".to_string())) {
type_var = Value::Str("market".to_string());
}
let mut stateId: Value = self.safe_string_k(order.clone(), "state", &[]);
let mut status: Value = Value::Null;
if is_equal(&stateId, &Value::Str("wait".to_string())) {
status = Value::Str("open".to_string());
} else if is_equal(&stateId, &Value::Str("trade".to_string())) {
status = Value::Str("open".to_string());
} else if is_equal(&stateId, &Value::Str("done".to_string())) {
status = Value::Str("closed".to_string());
} else if is_equal(&stateId, &Value::Str("cancel".to_string())) {
status = Value::Str("canceled".to_string());
}
let mut price: Value = self.safe_string2(order.clone(), Value::Str("price".to_string()), Value::Str("order_price".to_string()), &[]);
let mut amount: Value = self.safe_string2(order.clone(), Value::Str("volume".to_string()), Value::Str("order_quantity".to_string()), &[]);
let mut remaining: Value = self.safe_string_k(order.clone(), "remaining_volume", &[]);
let mut filled: Value = self.safe_string_k(order.clone(), "executed_volume", &[]);
let mut cost: Value = self.safe_string_k(order.clone(), "executed_funds", &[]);
let mut feeCost: Value = self.safe_string_k(order.clone(), "paid_fee", &[]);
let mut fee: Value = Value::Null;
if !is_equal(&feeCost, &Value::Null) {
let mut marketForFee: Value = self.safe_market(&[marketId.clone(), market.clone()]);
let mut feeCurrency: Value = self.safe_string_k(marketForFee.clone(), "quote", &[]);
fee = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), feeCost.clone());
m.insert("currency".to_string(), feeCurrency.clone());
m
});
}
return self.safe_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), order.clone());
m.insert("id".to_string(), self.safe_string2(order.clone(), Value::Str("uuid".to_string()), Value::Str("order_id".to_string()), &[]));
m.insert("clientOrderId".to_string(), Value::Null);
m.insert("timestamp".to_string(), timestamp.clone());
m.insert("datetime".to_string(), self.iso8601(timestamp.clone()));
m.insert("lastTradeTimestamp".to_string(), self.safe_integer_k(order.clone(), "trade_timestamp", &[]));
m.insert("symbol".to_string(), symbol.clone());
m.insert("type".to_string(), type_var.clone());
m.insert("timeInForce".to_string(), Value::Null);
m.insert("postOnly".to_string(), Value::Null);
m.insert("side".to_string(), side.clone());
m.insert("price".to_string(), price.clone());
m.insert("stopPrice".to_string(), Value::Null);
m.insert("triggerPrice".to_string(), Value::Null);
m.insert("amount".to_string(), amount.clone());
m.insert("cost".to_string(), cost.clone());
m.insert("average".to_string(), Value::Null);
m.insert("filled".to_string(), filled.clone());
m.insert("remaining".to_string(), remaining.clone());
m.insert("status".to_string(), status.clone());
m.insert("fee".to_string(), fee.clone());
m.insert("trades".to_string(), Value::Null);
m
}), &[market.clone()]);
Value::Null
}
pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
if is_string(&message) {
let mut content: Value = to_lower(&message);
if is_equal(&content, &Value::Str("pong".to_string())) {
self.handle_pong(client.clone(), message.clone());
return;
}
if is_equal(&content, &Value::Str("ping".to_string())) {
self.handle_ping(client.clone(), message.clone());
return;
}
return;
}
let mut status: Value = self.safe_string_k(message.clone(), "status", &[]);
if is_equal(&status, &Value::Str("UP".to_string())) {
self.handle_pong(client.clone(), message.clone());
return;
}
if is_true(&(Value::Bool(in_op(&message, &Value::Str("pong".to_string()))))) || is_true(&(Value::Bool(in_op(&message, &Value::Str("PINGPONG".to_string()))))) {
self.handle_pong(client.clone(), message.clone());
return;
}
if is_true(&Value::Bool(in_op(&message, &Value::Str("ping".to_string())))) {
self.handle_ping(client.clone(), message.clone());
return;
}
if !is_equal(&self.handle_error_message(client.clone(), message.clone()), &Value::Bool(true)) {
return;
}
let mut topic: Value = self.safe_string_k(message.clone(), "type", &[]);
if !is_equal(&topic, &Value::Null) {
let mut methods: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("ticker".to_string(), Value::Str("handle_ticker".to_string()).clone());
m.insert("orderbookdepth".to_string(), Value::Str("handle_order_book".to_string()).clone());
m.insert("orderbook".to_string(), Value::Str("handle_order_book".to_string()).clone());
m.insert("transaction".to_string(), Value::Str("handle_trades".to_string()).clone());
m.insert("trade".to_string(), Value::Str("handle_trades".to_string()).clone());
m.insert("myAsset".to_string(), Value::Str("handle_balance".to_string()).clone());
m.insert("myOrder".to_string(), Value::Str("handle_orders".to_string()).clone());
m
});
let mut method: Value = self.safe_value(methods.clone(), topic.clone(), &[]);
if !is_equal(&method, &Value::Null) {
self.dispatch_ws_handler(&method, &[client.clone(), message.clone()]);
}
}
}
}