#![allow(unused, non_snake_case, clippy::all)]
use crate::Value;
use crate::get_value;
use crate::runtime::*;
use crate::exchange_generated::ExchangeBase;
use crate::exchange::ExchangeRuntime;
use crate::exchange::CallDynamicChecked;
use crate::pro::*;
use crate::prediction_exchange_generated::PredictionBase;
use crate::prediction_exchange::PredictionRuntime;
pub struct MyriadCore {
pub exchange: crate::prediction_exchange::PredictionExchange,
}
impl MyriadCore {
pub fn new(config: Option<crate::Value>) -> Self {
let mut s = Self { exchange: crate::prediction_exchange::PredictionExchange::new(config) };
s.init();
s
}
pub fn init(&mut self) {
let described = MyriadCore::describe(self);
self.initialize_properties(described);
let user_config = self.userConfig.clone();
<Self as crate::exchange_generated::ExchangeBase>::after_construct(self, &[user_config]);
}
#[inline]
pub fn bind(&mut self) {}
}
impl crate::exchange::DerivedExchange for MyriadCore {
fn parse_ohlcv(&self, ohlcv: crate::Value, market: crate::Value) -> crate::Value {
MyriadCore::parse_ohlcv(self, ohlcv, &[market])
}
fn parse_prediction_trade(&self, trade: crate::Value, market: crate::Value) -> crate::Value {
MyriadCore::parse_prediction_trade(self, trade, &[market])
}
fn parse_prediction_order(&self, order: crate::Value, market: crate::Value) -> crate::Value {
MyriadCore::parse_prediction_order(self, order, &[market])
}
fn parse_prediction_position(&self, position: crate::Value, market: crate::Value) -> crate::Value {
MyriadCore::parse_prediction_position(self, position, &[market])
}
fn sign(&self, path: crate::Value, api: crate::Value, method: crate::Value, params: crate::Value, headers: crate::Value, body: crate::Value) -> crate::Value {
MyriadCore::sign(self, 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 {
MyriadCore::handle_errors(self, code, reason, url, method, headers, body, response, request_headers, request_body)
}
}
impl crate::exchange_generated::ExchangeBase for MyriadCore {
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 {
"build_orderbook_order" => self.build_orderbook_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), &args[4.min(args.len())..]),
"cancel_all_orders" => self.cancel_all_orders(&args[..]).await,
"cancel_order" => self.cancel_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"cancel_orders" => self.cancel_orders(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"clob_order_message" => self.clob_order_message(args.get(0).cloned().unwrap_or(crate::Value::Null)),
"connect_centrifugo" => self.connect_centrifugo(args.get(0).cloned().unwrap_or(crate::Value::Null)).await,
"create_amm_order" => self.create_amm_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), &args[4.min(args.len())..]).await,
"create_market_buy_order_with_cost" => self.create_market_buy_order_with_cost(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]).await,
"create_order" => self.create_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), &args[4.min(args.len())..]).await,
"create_orderbook_order" => self.create_orderbook_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), &args[4.min(args.len())..]).await,
"create_orders" => self.create_orders(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"edit_order" => self.edit_order(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), &args[4.min(args.len())..]).await,
"ensure_erc20_allowance" => self.ensure_erc20_allowance(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null)).await,
"eth_rpc" => self.eth_rpc(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)).await,
"fetch_amm_orders" => self.fetch_amm_orders(&args[..]).await,
"fetch_balance" => self.fetch_balance(&args[..]).await,
"fetch_canceled_orders" => self.fetch_canceled_orders(&args[..]).await,
"fetch_closed_orders" => self.fetch_closed_orders(&args[..]).await,
"fetch_event" => self.fetch_event(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_events" => self.fetch_events(&args[..]).await,
"fetch_markets" => self.fetch_markets(&args[..]).await,
"fetch_my_trades" => self.fetch_my_trades(&args[..]).await,
"fetch_ohlcv" => self.fetch_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_open_orders" => self.fetch_open_orders(&args[..]).await,
"fetch_order" => self.fetch_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_order_book" => self.fetch_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_orders" => self.fetch_orders(&args[..]).await,
"fetch_positions" => self.fetch_positions(&args[..]).await,
"fetch_raw_market_by_id" => self.fetch_raw_market_by_id(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_raw_markets_by_search" => self.fetch_raw_markets_by_search(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_raw_markets_list" => self.fetch_raw_markets_list(&args[..]).await,
"fetch_raw_question_by_id" => self.fetch_raw_question_by_id(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_raw_questions_by_search" => self.fetch_raw_questions_by_search(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_raw_questions_list" => self.fetch_raw_questions_list(&args[..]).await,
"fetch_ticker" => self.fetch_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_tickers" => self.fetch_tickers(&args[..]).await,
"fetch_trade_quote" => self.fetch_trade_quote(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,
"fetch_trades" => self.fetch_trades(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"fetch_trading_fee" => self.fetch_trading_fee(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"from_wei" => self.from_wei(args.get(0).cloned().unwrap_or(crate::Value::Null)),
"get_order_response_from_params" => self.get_order_response_from_params(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"handle_errors" => self.handle_errors(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null), args.get(4).cloned().unwrap_or(crate::Value::Null),
args.get(5).cloned().unwrap_or(crate::Value::Null), args.get(6).cloned().unwrap_or(crate::Value::Null), args.get(7).cloned().unwrap_or(crate::Value::Null), args.get(8).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_text_message" => { self.handle_text_message(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)); crate::Value::Null },
"order_to_trade" => self.order_to_trade(args.get(0).cloned().unwrap_or(crate::Value::Null)),
"parse_amm_event_to_order" => self.parse_amm_event_to_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_event" => self.parse_event(args.get(0).cloned().unwrap_or(crate::Value::Null)),
"parse_market_to_event" => self.parse_market_to_event(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"parse_myriad_market" => self.parse_myriad_market(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_ohlcv" => self.parse_ohlcv(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_prediction_order" => self.parse_prediction_order(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_prediction_position" => self.parse_prediction_position(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_prediction_ticker" => self.parse_prediction_ticker(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_prediction_trade" => self.parse_prediction_trade(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_trade_quote" => self.parse_trade_quote(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"parse_trade_tx" => self.parse_trade_tx(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), args.get(2).cloned().unwrap_or(crate::Value::Null), args.get(3).cloned().unwrap_or(crate::Value::Null)),
"parse_wei_order_book" => self.parse_wei_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"pong" => self.pong(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]).await,
"request_id" => self.request_id(args.get(0).cloned().unwrap_or(crate::Value::Null)),
"seed_order_book" => self.seed_order_book(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null), &args[2.min(args.len())..]).await,
"seed_position_balances" => self.seed_position_balances(args.get(0).cloned().unwrap_or(crate::Value::Null)).await,
"sign" => self.sign(args.get(0).cloned().unwrap_or(crate::Value::Null), &args[1.min(args.len())..]),
"sign_evm_transaction" => self.sign_evm_transaction(args.get(0).cloned().unwrap_or(crate::Value::Null), args.get(1).cloned().unwrap_or(crate::Value::Null)),
"subscribe_myriad_channel" => self.subscribe_myriad_channel(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_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_positions" => self.watch_positions(&args[..]).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,
_ => self.call_dynamic_prediction_base(method, args).await,
}
})
}
}
impl crate::prediction_exchange_generated::PredictionBase for MyriadCore {
fn pred(&self) -> &crate::prediction_exchange::PredictionExchange { &self.exchange }
fn pred_mut(&mut self) -> &mut crate::prediction_exchange::PredictionExchange { &mut self.exchange }
}
impl std::ops::Deref for MyriadCore {
type Target = crate::exchange::Exchange;
fn deref(&self) -> &crate::exchange::Exchange { std::ops::Deref::deref(&self.exchange) }
}
impl std::ops::DerefMut for MyriadCore {
fn deref_mut(&mut self) -> &mut crate::exchange::Exchange { std::ops::DerefMut::deref_mut(&mut self.exchange) }
}
impl MyriadCore {
pub fn describe(&self) -> Value {
return self.deep_extend(self.super_describe(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), Value::Str("myriad".into()));
m.insert("name".to_string(), Value::Str("Myriad".into()));
m.insert("countries".to_string(), Value::from(vec![]));
m.insert("rateLimit".to_string(), Value::Int(200));
m.insert("certified".to_string(), Value::Bool(false));
m.insert("pro".to_string(), Value::Bool(true));
m.insert("has".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("CORS".to_string(), Value::Null);
m.insert("spot".to_string(), Value::Bool(false));
m.insert("margin".to_string(), Value::Bool(false));
m.insert("swap".to_string(), Value::Bool(false));
m.insert("future".to_string(), Value::Bool(false));
m.insert("option".to_string(), Value::Bool(false));
m.insert("cancelAllOrders".to_string(), Value::Bool(true));
m.insert("cancelOrder".to_string(), Value::Bool(true));
m.insert("cancelOrders".to_string(), Value::Bool(true));
m.insert("createMarketBuyOrderWithCost".to_string(), Value::Bool(true));
m.insert("createOrder".to_string(), Value::Bool(true));
m.insert("createOrders".to_string(), Value::Bool(true));
m.insert("editOrder".to_string(), Value::Bool(true));
m.insert("fetchBalance".to_string(), Value::Bool(true));
m.insert("fetchCanceledOrders".to_string(), Value::Bool(true));
m.insert("fetchClosedOrders".to_string(), Value::Bool(true));
m.insert("fetchCurrencies".to_string(), Value::Bool(false));
m.insert("fetchEvent".to_string(), Value::Bool(true));
m.insert("fetchEvents".to_string(), Value::Bool(true));
m.insert("fetchMarkets".to_string(), Value::Bool(true));
m.insert("fetchMyTrades".to_string(), Value::Bool(true));
m.insert("fetchOHLCV".to_string(), Value::Bool(true));
m.insert("fetchOpenOrders".to_string(), Value::Bool(true));
m.insert("fetchOrder".to_string(), Value::Bool(true));
m.insert("fetchOrderBook".to_string(), Value::Bool(true));
m.insert("fetchOrders".to_string(), Value::Bool(true));
m.insert("fetchPositions".to_string(), Value::Bool(true));
m.insert("fetchTicker".to_string(), Value::Bool(true));
m.insert("fetchTickers".to_string(), Value::Bool(true));
m.insert("fetchTrades".to_string(), Value::Bool(true));
m.insert("fetchTradingFee".to_string(), Value::Bool(true));
m.insert("prediction".to_string(), Value::Bool(true));
m.insert("watchMyTrades".to_string(), Value::Bool(true));
m.insert("watchOHLCV".to_string(), Value::Bool(true));
m.insert("watchOrderBook".to_string(), Value::Bool(true));
m.insert("watchOrders".to_string(), Value::Bool(true));
m.insert("watchPositions".to_string(), Value::Bool(true));
m.insert("watchTicker".to_string(), Value::Bool(true));
m.insert("watchTickers".to_string(), Value::Bool(true));
m.insert("watchTrades".to_string(), Value::Bool(true));
m
}));
m.insert("timeframes".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("1m".to_string(), Value::Str("24h".into()));
m.insert("5m".to_string(), Value::Str("24h".into()));
m.insert("15m".to_string(), Value::Str("7d".into()));
m.insert("1h".to_string(), Value::Str("7d".into()));
m.insert("6h".to_string(), Value::Str("30d".into()));
m.insert("1d".to_string(), Value::Str("30d".into()));
m
}));
m.insert("urls".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("logo".to_string(), Value::Str("https://github.com/user-attachments/assets/a393c885-99e8-4943-897d-ebc0555c3773".into()));
m.insert("api".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("myriad".to_string(), Value::Str("https://api-v2.myriadprotocol.com".into()));
m.insert("ws".to_string(), Value::Str("wss://ws.myriadprotocol.com/ws".into()));
m
}));
m.insert("test".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("myriad".to_string(), Value::Str("https://api-v2.staging.myriadprotocol.com".into()));
m.insert("ws".to_string(), Value::Str("wss://ws.staging.myriadprotocol.com/ws".into()));
m
}));
m.insert("www".to_string(), Value::Str("https://myriad.markets".into()));
m.insert("doc".to_string(), Value::from(vec![Value::Str("https://docs.myriad.markets".into())]));
m
}));
m.insert("api".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("myriad".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("public".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("get".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("questions".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("questions/{id}".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{networkId}/{id}".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}/events".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}/orderbook".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}/trades".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}/holders".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/{id}/referrals".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("events".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("orders".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("orders/{hash}".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("users/{address}/events".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("users/{address}/referrals".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("users/{address}/portfolio".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("users/{address}/markets".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("tags".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("topics".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m
}));
m.insert("post".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("markets/quote".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("markets/claim".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("orders".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("orders/cancel-batch".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("orders/cancel-all".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/split".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/merge".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/redeem".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/redeem-voided".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/neg-risk/split".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m.insert("positions/neg-risk/merge".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m
}));
m.insert("delete".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("orders/{hash}".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m
}));
m
}));
m.insert("private".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("post".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("markets/quote_with_fee".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), Value::Int(1));
m
}));
m
}));
m
}));
m
}));
m
}));
m.insert("requiredCredentials".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("apiKey".to_string(), Value::Bool(false));
m.insert("secret".to_string(), Value::Bool(false));
m.insert("walletAddress".to_string(), Value::Bool(false));
m.insert("privateKey".to_string(), Value::Bool(true));
m
}));
m.insert("fees".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("trading".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("tierBased".to_string(), Value::Bool(false));
m.insert("percentage".to_string(), Value::Bool(true));
m.insert("maker".to_string(), Value::Float(0.01));
m.insert("taker".to_string(), Value::Float(0.01));
m
}));
m
}));
m.insert("exceptions".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("exact".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("Order not found".to_string(), Value::Str("OrderNotFound".into()));
m.insert("Market not found".to_string(), Value::Str("BadSymbol".into()));
m.insert("Invalid order payload".to_string(), Value::Str("InvalidOrder".into()));
m
}));
m.insert("broad".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("Insufficient".to_string(), Value::Str("InsufficientFunds".into()));
m.insert("allowance".to_string(), Value::Str("InsufficientFunds".into()));
m.insert("not found".to_string(), Value::Str("OrderNotFound".into()));
m.insert("Unauthorized".to_string(), Value::Str("AuthenticationError".into()));
m.insert("Forbidden".to_string(), Value::Str("AuthenticationError".into()));
m.insert("rate limit".to_string(), Value::Str("RateLimitExceeded".into()));
m.insert("Too many requests".to_string(), Value::Str("RateLimitExceeded".into()));
m.insert("expired".to_string(), Value::Str("InvalidOrder".into()));
m.insert("closed".to_string(), Value::Str("InvalidOrder".into()));
m.insert("resolved".to_string(), Value::Str("InvalidOrder".into()));
m.insert("Invalid".to_string(), Value::Str("InvalidOrder".into()));
m
}));
m
}));
m.insert("options".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("defaultFetchMarketsLimit".to_string(), Value::Int(50));
m.insert("defaultFetchEventsLimit".to_string(), Value::Int(50));
m.insert("allowUnscopedFetchEvents".to_string(), Value::Bool(true));
m.insert("defaultMarketStatus".to_string(), Value::Str("open".into()));
m.insert("defaultTradingModel".to_string(), Value::Str("all".into()));
m.insert("defaultNetworkId".to_string(), Value::Str("56".into()));
m.insert("obDomainName".to_string(), Value::Str("MyriadCTFExchange".into()));
m.insert("obDomainVersion".to_string(), Value::Str("1".into()));
m.insert("networks".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("2741".to_string(), Value::Str("Abstract".into()));
m.insert("59144".to_string(), Value::Str("Linea".into()));
m.insert("56".to_string(), Value::Str("BNB Chain".into()));
m
}));
m.insert("chains".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("56".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("rpcUrl".to_string(), Value::Str("https://bsc-dataseed.binance.org/".into()));
m.insert("predictionMarket".to_string(), Value::Str("0x39E66eE6b2ddaf4DEfDEd3038E0162180dbeF340".into()));
m.insert("obExchangeAddress".to_string(), Value::Str("0xa0b6f8ef8EdB64f395018D1933f2273Ce9f0f16A".into()));
m.insert("obConditionalTokens".to_string(), Value::Str("0x6413734f92248D4B29ae35883290BD93212654Dc".into()));
m.insert("collateralToken".to_string(), Value::Str("0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d".into()));
m.insert("collateralCurrency".to_string(), Value::Str("USD1".into()));
m.insert("collateralDecimals".to_string(), Value::Int(18));
m
}));
m.insert("2741".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("rpcUrl".to_string(), Value::Str("https://api.mainnet.abs.xyz".into()));
m.insert("predictionMarket".to_string(), Value::Str("0x3e0F5F8F5Fb043aBFA475C0308417Bf72c463289".into()));
m
}));
m.insert("59144".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("rpcUrl".to_string(), Value::Str("https://rpc.linea.build".into()));
m.insert("predictionMarket".to_string(), Value::Str("0x39e66ee6b2ddaf4defded3038e0162180dbef340".into()));
m
}));
m
}));
m
}));
m
})]);
Value::Null
}
pub async fn fetch_markets(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut queries: Value = self.parse_search_queries(&[params.clone()]);
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("query".into()), Value::Str("queries".into())]), &[]);
let mut queriesLength: f64 = ((queries.len() as i64) as f64);
let mut rawMarkets: Value = Value::from(vec![]);
if queriesLength > ((0i64) as f64) {
rawMarkets = self.fetch_raw_markets_by_search(queries, &[rest.clone()]).await;
} else {
rawMarkets = self.fetch_raw_markets_list(&[rest]).await;
}
let mut flatMarkets: Vec<Value> = Vec::new();
let mut eventsDict: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
{
let mut i: i64 = 0;
let mut __for_first_1341: bool = true;
while { if !__for_first_1341 { i += 1; } __for_first_1341 = false; i < (rawMarkets.len() as i64) } {
let mut raw: Value = rawMarkets.as_array().map(Vec::as_slice).unwrap_or_default().get(i as usize).cloned().unwrap_or(Value::Null);
let mut m: Value = self.parse_myriad_market(raw.clone(), &[]);
flatMarkets.push(m.clone());
let mut ev: Value = self.parse_market_to_event(raw, m);
let mut evKey: Option<String> = self.safe_string_k_opt(ev.clone(), "event", &[]);
if (evKey.is_some()) {
if let Value::Dict(__d) = &mut eventsDict { std::sync::Arc::make_mut(__d).insert(evKey.as_deref().unwrap_or("null").to_string(), ev); }
}
}
}
self.exchange.events = eventsDict.clone();
return Value::from(flatMarkets);
Value::Null
}
pub async fn fetch_raw_markets_by_search(&mut self, mut queries: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let __queries_empty = Vec::new();
let queries = queries.as_array().unwrap_or(&__queries_empty);
let mut limit: Value = self.safe_integer_k(params.clone(), "limit", &[self.safe_integer(self.options.clone(), Value::Str("defaultFetchEventsLimit".into()), &[Value::Int(50)])]);
let mut state: Value = self.safe_string_k(params.clone(), "state", &[self.safe_string(self.options.clone(), Value::Str("defaultMarketStatus".into()), &[Value::Str("open".into())])]);
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("limit".into()), Value::Str("state".into())]), &[]);
let mut seen: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut rawMarkets: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1343: bool = true;
while { if !__for_first_1343 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1343 = false; i.as_f64().unwrap_or(f64::NAN) < ((queries.len() as i64) as f64) } {
let mut q: Value = queries.get((i).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let __ws_arg_0 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("keyword".to_string(), q);
m.insert("state".to_string(), state.clone());
m.insert("limit".to_string(), limit.clone());
m
}), &[rest.clone()]);
let mut response: Value = self.myriad_public_get_markets(&[__ws_arg_0]).await;
let mut responseIsArray: bool = matches!(&response, Value::Arr(_));
let mut found: Value = (if (responseIsArray) { response.clone() } else { self.safe_list_k(response, "data", &[Value::from(vec![])]) });
{
let mut j: i64 = 0;
let mut __for_first_1342: bool = true;
while { if !__for_first_1342 { j += 1; } __for_first_1342 = false; j < (found.len() as i64) } {
let mut raw: Value = found.as_array().map(Vec::as_slice).unwrap_or_default().get(j as usize).cloned().unwrap_or(Value::Null);
let networkId: String = self.safe_string_k_opt(raw.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(raw.clone(), "id", &[Value::Str("".into())]).unwrap_or_default();
let mut key: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId, Value::Str(":".into())).into()), marketId).into());
if !(matches!((&seen, &key), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
if let Value::Dict(__d) = &mut seen { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&key), Value::Bool(true)); }
rawMarkets.push(raw);
}
}
}
}
}
return Value::from(rawMarkets);
Value::Null
}
pub async fn fetch_raw_markets_list(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut limit: Value = self.safe_integer_k(self.options.clone(), "defaultFetchMarketsLimit", &[Value::Int(50)]);
let mut maxMarkets: Value = self.safe_integer_k(params.clone(), "limit", &[self.safe_integer(self.options.clone(), Value::Str("fetchMarketsLimit".into()), &[Value::Int(1000)])]);
let mut state: Value = self.safe_string2(params.clone(), Value::Str("state".into()), Value::Str("status".into()), &[self.safe_string_k(self.options.clone(), "defaultMarketStatus", &[Value::Str("open".into())])]);
let mut tradingModel: Value = self.safe_string2(params.clone(), Value::Str("tradingModel".into()), Value::Str("trading_model".into()), &[self.safe_string_k(self.options.clone(), "defaultTradingModel", &[Value::Str("all".into())])]);
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("state".into()), Value::Str("status".into()), Value::Str("limit".into()), Value::Str("tradingModel".into()), Value::Str("trading_model".into())]), &[]);
let mut allRawMarkets: Vec<Value> = Vec::new();
let mut collected: i64 = 0;
let mut page: Value = Value::Int(1);
loop {
let __ws_arg_1 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("state".to_string(), state.clone());
m.insert("limit".to_string(), limit.clone());
m.insert("page".to_string(), page.clone());
m.insert("trading_model".to_string(), tradingModel.clone());
m
}), &[rest.clone()]);
let mut response: Value = self.myriad_public_get_markets(&[__ws_arg_1]).await;
let mut responseIsArray: bool = matches!(&response, Value::Arr(_));
let mut rawMarkets: Value = (if (responseIsArray) { response.clone() } else { self.safe_list_k(response, "data", &[Value::from(vec![])]) });
let mut rawMarketsLength: f64 = ((rawMarkets.len() as i64) as f64);
if (rawMarketsLength == 0.0) {
break;
}
{
let mut i: Value = Value::Int(0);
let mut __for_first_1344: bool = true;
while { if !__for_first_1344 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1344 = false; i.as_f64().unwrap_or(f64::NAN) < rawMarketsLength } {
if (collected as f64) < maxMarkets.as_f64().unwrap_or(f64::NAN) {
allRawMarkets.push(rawMarkets.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));
collected = allRawMarkets.len() as i64;
}
}
}
page = self.sum(&[page.clone(), Value::Int(1)]);
if rawMarketsLength < limit.as_f64().unwrap_or(f64::NAN) || (collected as f64) >= maxMarkets.as_f64().unwrap_or(f64::NAN) {
break;
}
}
return Value::from(allRawMarkets);
Value::Null
}
pub async fn fetch_event(&mut self, mut id: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
if !id.as_str().unwrap_or("").contains(":") {
let mut rawQuestion: Value = self.fetch_raw_question_by_id(id.clone(), &[params.clone()]).await;
let mut orderBookEvent: Value = self.parse_event(rawQuestion);
self.index_event_outcomes(orderBookEvent.clone());
return orderBookEvent;
}
let mut response: Value = self.fetch_raw_market_by_id(id, &[params]).await;
let mut market: Value = self.parse_myriad_market(response.clone(), &[]);
let mut event: Value = self.parse_market_to_event(response, market);
self.index_event_outcomes(event.clone());
return event;
Value::Null
}
pub async fn fetch_raw_market_by_id(&mut self, mut id: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut parts: Value = Value::Array(if let Some(__s) = id.as_str() { __s.split(":").map(Value::from).collect() } else { Vec::new() });
let mut partsLength: f64 = ((parts.len() as i64) as f64);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
if partsLength > ((1i64) as f64) {
request.insert("network_id".into(), self.safe_string(parts.clone(), Value::Int(0), &[]));
request.insert("id".into(), self.safe_string(parts, Value::Int(1), &[]));
} else {
request.insert("id".into(), id);
}
let __ws_arg_2 = self.extend(Value::Map(request), &[params]);
return self.myriad_public_get_markets_id(&[__ws_arg_2]).await;
Value::Null
}
pub async fn fetch_raw_question_by_id(&mut self, mut id: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), id.clone());
m
});
let mut result: Value = Value::Null;
let _try_result = futures::FutureExt::catch_unwind(std::panic::AssertUnwindSafe(async {
let __ws_arg_3 = self.extend(Value::Map(request), &[params.clone()]);
result = self.myriad_public_get_questions_id(&[__ws_arg_3]).await;
#[allow(unreachable_code)] { Value::Null }})).await;
if let Err(_try_err) = _try_result { let e: Value = panic_to_value(_try_err);
if (matches!(&e, Value::Str(__s) if __s.contains("[RateLimitExceeded]"))) || (is_instance(&e, &Value::Str("AuthenticationError".into()))) {
panic!("{}", e);
}
let mut keywordRequest: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("keyword".to_string(), id.clone());
m.insert("limit".to_string(), Value::Int(50));
m
});
let __ws_arg_4 = self.extend(Value::Map(keywordRequest), &[params]);
let mut response: Value = self.myriad_public_get_questions(&[__ws_arg_4]).await;
let mut questions: Value = self.safe_list_k(response, "data", &[Value::from(vec![])]);
let mut questionsLength: f64 = ((questions.len() as i64) as f64);
let mut idLower: Value = (if let Some(__s) = id.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null });
{
let mut i: Value = Value::Int(0);
let mut __for_first_1345: bool = true;
while { if !__for_first_1345 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1345 = false; i.as_f64().unwrap_or(f64::NAN) < questionsLength } {
let mut q: Value = self.safe_dict(questions.clone(), i.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut qId: Value = self.safe_string_k(q.clone(), "id", &[Value::Str("".into())]);
let mut qSlug: Value = self.safe_string_k(q.clone(), "slug", &[Value::Str("".into())]);
let mut qTitle: Value = self.safe_string_k(q.clone(), "title", &[Value::Str("".into())]);
let mut qHandle: Value = self.shorten_slug(qSlug.clone());
if ((if let Some(__s) = qId.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str() == idLower.as_str()) || ((if let Some(__s) = qSlug.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str() == idLower.as_str()) || ((if let Some(__s) = qTitle.as_str() { Value::Str(__s.to_lowercase().into())
} else { Value::Null }).as_str() == idLower.as_str()) || ((qHandle != Value::Null) && ((if let Some(__s) = qHandle.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str() == idLower.as_str())) {
return q;
}
}
}
panic!("{}", e);
}
return result;
Value::Null
}
pub async fn fetch_raw_questions_by_search(&mut self, mut queries: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let __queries_empty = Vec::new();
let queries = queries.as_array().unwrap_or(&__queries_empty);
let mut limit: Value = self.safe_integer_k(params.clone(), "limit", &[self.safe_integer(self.options.clone(), Value::Str("defaultFetchEventsLimit".into()), &[Value::Int(50)])]);
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("limit".into())]), &[]);
let mut seen: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut rawQuestions: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1347: bool = true;
while { if !__for_first_1347 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1347 = false; i.as_f64().unwrap_or(f64::NAN) < ((queries.len() as i64) as f64) } {
let mut q: Value = queries.get((i).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let __ws_arg_5 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("keyword".to_string(), q);
m.insert("limit".to_string(), limit.clone());
m
}), &[rest.clone()]);
let mut response: Value = self.myriad_public_get_questions(&[__ws_arg_5]).await;
let mut responseIsArray: bool = matches!(&response, Value::Arr(_));
let mut found: Value = (if (responseIsArray) { response.clone() } else { self.safe_list_k(response, "data", &[Value::from(vec![])]) });
{
let mut j: i64 = 0;
let mut __for_first_1346: bool = true;
while { if !__for_first_1346 { j += 1; } __for_first_1346 = false; j < (found.len() as i64) } {
let mut raw: Value = found.as_array().map(Vec::as_slice).unwrap_or_default().get(j as usize).cloned().unwrap_or(Value::Null);
let mut questionId: Option<String> = self.safe_string_k_opt(raw.clone(), "id", &[]);
if (questionId.is_some()) && !(matches!((&seen, &questionId.clone().map(Value::from).unwrap_or(Value::Null)), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
if let Value::Dict(__d) = &mut seen { std::sync::Arc::make_mut(__d).insert(questionId.as_deref().unwrap_or("null").to_string(), Value::Bool(true)); }
rawQuestions.push(raw);
}
}
}
}
}
return Value::from(rawQuestions);
Value::Null
}
pub async fn fetch_raw_questions_list(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut limit: Value = self.safe_integer_k(self.options.clone(), "defaultFetchEventsLimit", &[Value::Int(50)]);
let mut maxQuestions: Value = self.safe_integer_k(params.clone(), "limit", &[self.safe_integer(self.options.clone(), Value::Str("fetchEventsLimit".into()), &[Value::Int(1000)])]);
let mut state: Value = self.safe_string2(params.clone(), Value::Str("state".into()), Value::Str("status".into()), &[self.safe_string_k(self.options.clone(), "defaultMarketStatus", &[Value::Str("open".into())])]);
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("state".into()), Value::Str("status".into()), Value::Str("limit".into()), Value::Str("tradingModel".into()), Value::Str("trading_model".into())]), &[]);
let mut allRawQuestions: Vec<Value> = Vec::new();
let mut seen: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut collected: i64 = 0;
let mut page: Value = Value::Int(1);
loop {
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("limit".to_string(), limit.clone());
m.insert("page".to_string(), page.clone());
m
});
if (state != Value::Null) {
request.insert("state".into(), state.clone());
}
let __ws_arg_6 = self.extend(Value::Map(request), &[rest.clone()]);
let mut response: Value = self.myriad_public_get_questions(&[__ws_arg_6]).await;
let mut responseIsArray: bool = matches!(&response, Value::Arr(_));
let mut rawQuestions: Value = (if (responseIsArray) { response.clone() } else { self.safe_list_k(response, "data", &[Value::from(vec![])]) });
let mut rawQuestionsLength: f64 = ((rawQuestions.len() as i64) as f64);
if (rawQuestionsLength == 0.0) {
break;
}
{
let mut i: Value = Value::Int(0);
let mut __for_first_1348: bool = true;
while { if !__for_first_1348 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1348 = false; i.as_f64().unwrap_or(f64::NAN) < rawQuestionsLength } {
let mut rawQuestion: Value = rawQuestions.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 questionId: Option<String> = self.safe_string_k_opt(rawQuestion.clone(), "id", &[]);
if (questionId.is_some()) && (matches!((&seen, &questionId.clone().map(Value::from).unwrap_or(Value::Null)), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
continue;
}
if (questionId.is_some()) {
if let Value::Dict(__d) = &mut seen { std::sync::Arc::make_mut(__d).insert(questionId.as_deref().unwrap_or("null").to_string(), Value::Bool(true)); }
}
if (collected as f64) < maxQuestions.as_f64().unwrap_or(f64::NAN) {
allRawQuestions.push(rawQuestion);
collected = allRawQuestions.len() as i64;
}
}
}
page = self.sum(&[page.clone(), Value::Int(1)]);
if (rawQuestionsLength < limit.as_f64().unwrap_or(f64::NAN)) || ((collected as f64) >= maxQuestions.as_f64().unwrap_or(f64::NAN)) {
break;
}
}
return Value::from(allRawQuestions);
Value::Null
}
pub async fn fetch_positions(&mut self, optional_args: &[Value]) -> Value {
let mut outcomes = 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 address: Value = self.safe_string2(params.clone(), Value::Str("address".into()), Value::Str("user".into()), &[self.wallet_address_or_undefined().map(Value::from).unwrap_or(Value::Null)]);
if (address == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" fetchPositions() requires a walletAddress or an address parameter".into()))));
}
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("address".into()), Value::Str("user".into())]), &[]);
let __ws_arg_7 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("address".to_string(), address);
m
}), &[rest]);
let mut response: Value = self.myriad_public_get_users_address_portfolio(&[__ws_arg_7]).await;
let mut data: Vec<Value> = self.safe_list_k(response, "data", &[Value::from(vec![])]).as_array().cloned().unwrap_or_default();
let mut result: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1349: bool = true;
while { if !__for_first_1349 { i += 1; } __for_first_1349 = false; i < (data.len() as i64) } {
let mut position: Value = self.parse_prediction_position(data.get(i as usize).cloned().unwrap_or(Value::Null), &[]);
if (outcomes == Value::Null) || self.in_array(position.as_map().and_then(|__m| __m.get("outcome")).cloned().unwrap_or(Value::Null), outcomes.clone()).as_bool() == Some(true) {
result.push(position);
}
}
}
return Value::from(result);
Value::Null
}
pub fn parse_prediction_position(&self, mut position: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut marketSlug: Value = self.safe_string_k(position.clone(), "marketSlug", &[Value::Str("".into())]);
let mut outcomeTitle: Value = self.safe_string_k(position.clone(), "outcomeTitle", &[Value::Str("".into())]);
let mut outcome: Value = self.slug_to_outcome_symbol(marketSlug.clone(), marketSlug.clone(), outcomeTitle.clone());
let mut marketSymbol: Value = self.slug_to_market_symbol(marketSlug.clone(), marketSlug.clone());
let mut outcomeId: Option<String> = self.safe_string_k_opt(position.clone(), "outcomeId", &[]);
let mut id: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.safe_string_k(position.clone(), "networkId", &[Value::Str("".into())]), Value::Str(":".into())).into()), self.safe_string_k(position.clone(), "marketId", &[Value::Str("".into())])).into()),
Value::Str("/".into())).into()), self.safe_string_k(position.clone(), "outcomeId", &[Value::Str("".into())])).into());
let mut shares: Value = self.safe_number_k(position.clone(), "shares", &[]);
let mut value: Value = self.safe_number_k(position.clone(), "value", &[]);
let mut profit: Value = self.safe_number_k(position.clone(), "profit", &[]);
let mut roi: Option<String> = self.safe_string_k_opt(position.clone(), "roi", &[]);
let mut percentage: Value = Value::Null;
if (roi.is_some()) {
percentage = crate::precise::Precise::stringMul(&roi.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("100".into()));
}
return self.safe_prediction_position(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), position.clone());
m.insert("id".to_string(), id);
m.insert("outcome".to_string(), outcome);
m.insert("outcomeId".to_string(), outcomeId.map(Value::from).unwrap_or(Value::Null));
m.insert("label".to_string(), outcomeTitle);
m.insert("market".to_string(), marketSymbol);
m.insert("contracts".to_string(), shares);
m.insert("side".to_string(), Value::Str("long".into()));
m.insert("notional".to_string(), value);
m.insert("markPrice".to_string(), self.safe_number_k(position, "price", &[]));
m.insert("unrealizedPnl".to_string(), profit);
m.insert("percentage".to_string(), self.parse_number(percentage, &[]));
m.insert("marginMode".to_string(), Value::Str("cash".into()));
m.insert("hedged".to_string(), Value::Bool(false));
m
}));
Value::Null
}
pub async fn fetch_trade_quote(&mut self, mut outcome: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
self.load_outcome(outcome.clone(), &[]).await;
let mut outcomeObj: Value = self.outcome(outcome.clone());
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut networkId: Option<String> = self.safe_string_k_opt(info.clone(), "networkId", &[]);
let mut marketId: Option<String> = self.safe_string_k_opt(info.clone(), "marketId", &[]);
let mut outcomeId: Option<i64> = self.safe_integer_k(info, "outcomeId", &[]).as_i64();
let mut sideStr: Value = (if let Some(__s) = side.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null });
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("market_id".to_string(), self.parse_to_int(marketId.map(Value::from).unwrap_or(Value::Null)));
m.insert("network_id".to_string(), self.parse_to_int(networkId.map(Value::from).unwrap_or(Value::Null)));
m.insert("outcome_id".to_string(), Value::from(outcomeId));
m.insert("action".to_string(), sideStr.clone());
m.insert("slippage".to_string(), self.safe_number_k(params.clone(), "slippage", &[Value::Float(0.005)]));
m
});
if (sideStr.as_str() == Some("buy")) {
request.insert("value".into(), amount.clone());
} else {
request.insert("shares".into(), amount);
}
let mut rest: Value = self.omit(params, Value::from(vec![Value::Str("slippage".into())]), &[]);
let __ws_arg_8 = self.extend(Value::Map(request), &[rest]);
let mut response: Value = self.myriad_public_post_markets_quote(&[__ws_arg_8]).await;
let __ws_arg_9 = self.extend(response, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("action".to_string(), sideStr);
m
})]);
return self.parse_trade_quote(__ws_arg_9, &[outcomeObj]);
Value::Null
}
pub fn parse_trade_quote(&self, mut quote: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let __market_empty = indexmap::IndexMap::new();
let market = market.as_map().unwrap_or(&__market_empty);
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("outcome".to_string(), (match market.get("outcome") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null }));
m.insert("side".to_string(), self.safe_string_lower_k(quote.clone(), "action", &[]));
m.insert("value".to_string(), self.safe_number_k(quote.clone(), "value", &[]));
m.insert("shares".to_string(), self.safe_number_k(quote.clone(), "shares", &[]));
m.insert("sharesThreshold".to_string(), self.safe_number_k(quote.clone(), "shares_threshold", &[]));
m.insert("priceAverage".to_string(), self.safe_number_k(quote.clone(), "price_average", &[]));
m.insert("priceBefore".to_string(), self.safe_number_k(quote.clone(), "price_before", &[]));
m.insert("priceAfter".to_string(), self.safe_number_k(quote.clone(), "price_after", &[]));
m.insert("netAmount".to_string(), self.safe_number_k(quote.clone(), "net_amount", &[]));
m.insert("fees".to_string(), self.safe_dict_k(quote.clone(), "fees", &[]));
m.insert("calldata".to_string(), self.safe_string_k(quote.clone(), "calldata", &[]));
m.insert("info".to_string(), quote);
m
});
Value::Null
}
pub fn sign_evm_transaction(&self, mut tx: Value, mut privateKey: Value) -> Value {
let mut accessList: Value = self.rlp_encode_list(Value::from(vec![]));
let mut fields: Value = Value::from(vec![self.rlp_encode_bytes(self.int_to_rlp_hex(self.safe_integer_k(tx.clone(), "chainId", &[]))), self.rlp_encode_bytes(self.hex_to_rlp_bytes(self.safe_string_k(tx.clone(), "nonce", &[]))), self.rlp_encode_bytes(self.hex_to_rlp_bytes(self.safe_string_k(tx.clone(), "maxPriorityFeePerGas", &[]))),
self.rlp_encode_bytes(self.hex_to_rlp_bytes(self.safe_string_k(tx.clone(), "maxFeePerGas", &[]))), self.rlp_encode_bytes(self.hex_to_rlp_bytes(self.safe_string_k(tx.clone(), "gasLimit", &[]))), self.rlp_encode_bytes(self.remove0x_prefix(self.safe_string_k(tx.clone(), "to", &[]))),
self.rlp_encode_bytes(self.hex_to_rlp_bytes(self.safe_string_k(tx.clone(), "value", &[Value::Str("0x0".into())]))), self.rlp_encode_bytes(self.remove0x_prefix(self.safe_string_k(tx, "data", &[Value::Str("0x".into())]))), accessList]);
let mut payload: Value = Value::Str(format!("{}{}", Value::Str("02".into()), self.rlp_encode_list(fields.clone())).into());
let mut hashHex: Value = self.hash(self.base16_to_binary(payload, &[]), Value::Str("keccak".into()), &[Value::Str("hex".into())]);
let mut signature: Value = ecdsa(hashHex, self.remove0x_prefix(privateKey), Value::Str("secp256k1".into()), Value::Null);
let mut rHex: Value = self.safe_string_k(signature.clone(), "r", &[]);
let mut sHex: Value = self.safe_string_k(signature.clone(), "s", &[]);
if (rHex == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" signEvmTransaction() missing rHex".into()))));
}
let mut rHexLength: Value = Value::Int(rHex.len() as i64);
if (((match (&(rHexLength), &(Value::Int(2))) { (Value::Int(x), Value::Int(y)) if *y != 0 => Value::Int(x % y), (Value::Int(x), Value::Float(y)) if *y != 0.0 => Value::Float(*x as f64 % *y), (Value::Float(x), Value::Int(y)) if *y != 0 => Value::Float(*x % *y as f64), (Value::Float(x), Value::Float(y)) if *y != 0.0 => Value::Float(x % y), _ => Value::Null })).as_f64() != Some(0.0)) {
rHex = Value::Str(format!("{}{}", Value::Str("0".into()), rHex).into());
}
if (sHex == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" signEvmTransaction() missing sHex".into()))));
}
let mut sHexLength: Value = Value::Int(sHex.len() as i64);
if (((match (&(sHexLength), &(Value::Int(2))) { (Value::Int(x), Value::Int(y)) if *y != 0 => Value::Int(x % y), (Value::Int(x), Value::Float(y)) if *y != 0.0 => Value::Float(*x as f64 % *y), (Value::Float(x), Value::Int(y)) if *y != 0 => Value::Float(*x % *y as f64), (Value::Float(x), Value::Float(y)) if *y != 0.0 => Value::Float(x % y), _ => Value::Null })).as_f64() != Some(0.0)) {
sHex = Value::Str(format!("{}{}", Value::Str("0".into()), sHex).into());
}
let mut yParity: Value = self.safe_integer_k(signature, "v", &[]);
let mut signedFields: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1350: bool = true;
while { if !__for_first_1350 { i += 1; } __for_first_1350 = false; i < (fields.len() as i64) } {
signedFields.push(fields.as_array().map(Vec::as_slice).unwrap_or_default().get(i as usize).cloned().unwrap_or(Value::Null));
}
}
signedFields.push(self.rlp_encode_bytes(self.int_to_rlp_hex(yParity)));
signedFields.push(self.rlp_encode_bytes(rHex));
signedFields.push(self.rlp_encode_bytes(sHex));
return Value::Str(format!("{}{}", Value::Str("0x02".into()), self.rlp_encode_list(Value::from(signedFields))).into());
Value::Null
}
pub async fn eth_rpc(&mut self, mut rpcUrl: Value, mut method: Value, mut rpcParams: Value) -> Value {
let mut payload: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("jsonrpc".to_string(), Value::Str("2.0".into()));
m.insert("id".to_string(), Value::Int(1));
m.insert("method".to_string(), method.clone());
m.insert("params".to_string(), rpcParams);
m
});
let mut headers: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("Content-Type".to_string(), Value::Str("application/json".into()));
m
});
let mut response: Value = self.fetch(rpcUrl, &[Value::Str("POST".into()), Value::Map(headers), json_stringify(&Value::Map(payload))]).await;
let mut rpcError: Value = self.safe_value_k(response.clone(), "error", &[]);
if (rpcError != Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" rpc ".into())).into()), method).into()), Value::Str(" error: ".into())).into()), json_stringify(&rpcError))));
}
return self.safe_value_k(response, "result", &[]);
Value::Null
}
pub async fn ensure_erc20_allowance(&mut self, mut rpcUrl: Value, mut networkId: Value, mut token: Value, mut owner: Value, mut spender: Value) -> Value {
let mut allowanceData: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("0xdd62ed3e".into()), self.pad_hex_address(owner.clone())).into()), self.pad_hex_address(spender.clone())).into());
let mut current: Value = self.eth_rpc(rpcUrl.clone(), Value::Str("eth_call".into()), Value::from(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("to".to_string(), token.clone());
m.insert("data".to_string(), allowanceData);
m
}), Value::Str("latest".into())])).await;
let mut trimmed: Value = self.hex_to_rlp_bytes(current);
if ((trimmed.len() as i64) as f64) >= ((50i64) as f64) {
return Value::Null;
}
let mut maxUint: String = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string();
let mut approveData: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("0x095ea7b3".into()), self.pad_hex_address(spender)).into()), maxUint).into());
let __ws_arg_10 = self.parse_to_int(networkId);
let mut approveHash: Value = self.send_evm_transaction(rpcUrl.clone(), __ws_arg_10, owner, token, Value::Str("0x0".into()), approveData, Value::Str("0x186a0".into())).await;
self.wait_for_transaction_receipt(rpcUrl, approveHash, &[]).await;
return Value::Null;
Value::Null
}
pub async fn create_order(&mut self, mut outcome: Value, mut type_var: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
let mut price = get_arg(optional_args, 0, Value::Null);
let mut params = get_arg(optional_args, 1, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj, "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut defaultModel: Value = self.safe_string_k(info, "tradingModel", &[Value::Str("amm".into())]);
let mut tradingModel: Option<String> = self.safe_string_lower_k(params.clone(), "tradingModel", &[defaultModel]).as_str().map(str::to_owned);
let mut rest: Value = self.omit(params.clone(), Value::from(vec![Value::Str("tradingModel".into())]), &[]);
if (tradingModel.as_deref() == Some("ob")) {
return self.create_orderbook_order(outcome.clone(), type_var.clone(), side.clone(), amount.clone(), &[price.clone(), rest.clone()]).await;
}
let mut enableAmm: Value = self.safe_bool2(params, Value::Str("enableAmm".into()), Value::Str("enableAmmOrders".into()), &[self.safe_bool_k(self.options.clone(), "enableAmmOrders", &[Value::Bool(false)])]);
if !(enableAmm.as_bool() == Some(true)) {
panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" createOrder() only supports the gasless order book; this market uses the on-chain AMM (needs native gas and is unverified) — pass params.enableAmm=true to opt in".into()))));
}
return self.create_amm_order(outcome, type_var, side, amount, &[price, self.omit(rest, Value::from(vec![Value::Str("enableAmm".into()), Value::Str("enableAmmOrders".into())]), &[])]).await;
Value::Null
}
pub async fn create_orderbook_order(&mut self, mut outcome: Value, mut type_var: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
let mut price = get_arg(optional_args, 0, Value::Null);
let mut params = get_arg(optional_args, 1, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut built: Value = self.build_orderbook_order(outcome.clone(), type_var.clone(), side.clone(), amount.clone(), &[price.clone(), params]);
let mut order: Value = self.safe_dict_k(built.clone(), "order", &[]);
let mut networkId: Option<String> = self.safe_string_k_opt(built.clone(), "networkId", &[]);
let mut timeInForce: Option<String> = self.safe_string_k_opt(built.clone(), "timeInForce", &[]);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("order".to_string(), order.clone());
m.insert("signature".to_string(), self.safe_string_k(built, "signature", &[]));
m.insert("network_id".to_string(), self.parse_to_int(networkId.clone().map(Value::from).unwrap_or(Value::Null)));
m.insert("time_in_force".to_string(), timeInForce.clone().map(Value::from).unwrap_or(Value::Null));
m
});
let mut response: Value = self.myriad_public_post_orders(&[Value::Map(request)]).await;
let mut orderForResponse: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("trader".to_string(), self.safe_string_k(order.clone(), "trader", &[]));
m.insert("marketId".to_string(), self.safe_string_k(order.clone(), "marketId", &[]));
m.insert("outcomeId".to_string(), self.safe_number_k(order.clone(), "outcomeId", &[]));
m.insert("side".to_string(), self.safe_number_k(order.clone(), "side", &[]));
m.insert("amount".to_string(), self.safe_string_k(order.clone(), "amount", &[]));
m.insert("price".to_string(), self.safe_string_k(order.clone(), "price", &[]));
m.insert("minFillAmount".to_string(), self.safe_string_k(order.clone(), "minFillAmount", &[]));
m.insert("nonce".to_string(), self.safe_string_k(order.clone(), "nonce", &[]));
m.insert("expiration".to_string(), self.safe_string_k(order, "expiration", &[]));
m
});
let mut wrapper: Value = self.extend(response, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("order".to_string(), Value::Map(orderForResponse));
m.insert("networkId".to_string(), networkId.map(Value::from).unwrap_or(Value::Null));
m.insert("timeInForce".to_string(), timeInForce.clone().map(Value::from).unwrap_or(Value::Null));
m
})]);
let mut outcomeObj: Value = self.outcome(outcome.clone());
let mut parsed: Value = self.parse_prediction_order(wrapper, &[outcomeObj]);
let mut sideStr: Value = (if (side == Value::Null) { Value::Null } else { (if let Some(__s) = side.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }) });
let mut typeStr: Value = (if (type_var == Value::Null) { Value::Str("limit".into()) } else { (if let Some(__s) = type_var.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }) });
if (self.safe_string_k(parsed.clone(), "side", &[]) == Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("side".to_string(), sideStr); }
}
if (self.safe_string_k(parsed.clone(), "type", &[]) == Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("type".to_string(), typeStr); }
}
if (self.safe_string_k(parsed.clone(), "timeInForce", &[]) == Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("timeInForce".to_string(), timeInForce.map(Value::from).unwrap_or(Value::Null)); }
}
if (self.safe_number_k(parsed.clone(), "price", &[]) == Value::Null) && (price != Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("price".to_string(), price); }
}
if (self.safe_number_k(parsed.clone(), "amount", &[]) == Value::Null) && (amount != Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("amount".to_string(), amount); }
}
if (self.safe_string_k(parsed.clone(), "status", &[]) == Value::Null) {
if let Value::Dict(__rda) = &mut parsed { std::sync::Arc::make_mut(__rda).insert("status".to_string(), Value::Str("open".into())); }
}
return parsed;
Value::Null
}
pub fn build_orderbook_order(&self, mut outcome: Value, mut type_var: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
let mut price = get_arg(optional_args, 0, Value::Null);
let mut params = get_arg(optional_args, 1, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
if (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" createOrder() requires a privateKey to sign the order".into()))));
}
let mut outcomeObj: Value = self.outcome(outcome.clone());
let mut info: Value = self.safe_dict_k(outcomeObj, "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut networkId: Value = self.safe_string_k(info.clone(), "networkId", &[self.safe_string(self.options.clone(), Value::Str("defaultNetworkId".into()), &[Value::Str("56".into())])]);
let mut marketId: Option<String> = self.safe_string_k_opt(info.clone(), "marketId", &[]);
let mut outcomeId: Value = self.safe_integer_k(info, "outcomeId", &[Value::Int(0)]);
let mut trader: Value = self.eth_get_address_from_private_key(self.privateKey.clone(), &[]);
let mut typeStr: Value = (if (type_var == Value::Null) { Value::Str("limit".into()) } else { (if let Some(__s) = type_var.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }) });
let mut sideStr: Value = (if let Some(__s) = side.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null });
let mut sideInt: Value = (if (sideStr.as_str() == Some("buy")) { Value::Int(0) } else { Value::Int(1) });
let mut isMarket: bool = typeStr.as_str() == Some("market");
let mut defaultTif: String = "GTC".to_string();
if isMarket {
defaultTif = "FOK".to_string();
}
let mut timeInForce: Value = self.safe_string_upper_k(params.clone(), "timeInForce", &[Value::from(defaultTif)]);
if (price == Value::Null) && !isMarket {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" createOrder() requires a price for limit orders".into()))));
}
let mut marketPrice: Value = (if (sideInt.as_f64() == Some(0.0)) { Value::Int(1) } else { Value::Int(0) });
let mut priceValue: Value = (if (price != Value::Null) { price } else { marketPrice });
let mut priceWei: Value = self.to_orderbook_wei(priceValue).map(Value::from).unwrap_or(Value::Null);
if crate::precise::Precise::stringLt(&priceWei, &Value::Str("1".into())).as_bool() == Some(true) {
priceWei = Value::Str("1".into());
}
if crate::precise::Precise::stringGt(&priceWei, &Value::Str("1000000000000000000".into())).as_bool() == Some(true) {
panic!("{}", crate::exchange_errors::invalid_order(format!("{}{}", self.id.clone(), Value::Str(" createOrder() price must be a fraction between 0 and 1".into()))));
}
let mut amountWei: Value = self.to_orderbook_wei(amount).map(Value::from).unwrap_or(Value::Null);
if crate::precise::Precise::stringLt(&amountWei, &Value::Str("1".into())).as_bool() == Some(true) {
panic!("{}", crate::exchange_errors::invalid_order(format!("{}{}", self.id.clone(), Value::Str(" createOrder() amount is too small (rounds to zero shares)".into()))));
}
let mut nonce: Value = self.safe_string_k(params.clone(), "nonce", &[self.number_to_string(self.milliseconds())]);
let mut expiration: Value = self.safe_string_k(params.clone(), "expiration", &[Value::Str("0".into())]);
let mut minFillAmount: Value = self.safe_string_k(params, "minFillAmount", &[Value::Str("0".into())]);
let mut order: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("trader".to_string(), trader);
m.insert("marketId".to_string(), marketId.map(Value::from).unwrap_or(Value::Null));
m.insert("outcomeId".to_string(), self.parse_to_numeric(outcomeId));
m.insert("side".to_string(), self.parse_to_numeric(sideInt));
m.insert("amount".to_string(), amountWei);
m.insert("price".to_string(), priceWei);
m.insert("minFillAmount".to_string(), minFillAmount);
m.insert("nonce".to_string(), nonce);
m.insert("expiration".to_string(), expiration);
m
});
let mut signature: Value = self.sign_clob_order(Value::Map(order.clone()), networkId.clone()).map(Value::from).unwrap_or(Value::Null);
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("order".to_string(), Value::Map(order));
m.insert("signature".to_string(), signature);
m.insert("timeInForce".to_string(), timeInForce);
m.insert("networkId".to_string(), networkId);
m
});
Value::Null
}
pub async fn create_orders(&mut self, mut orders: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut ordersLength: f64 = ((orders.len() as i64) as f64);
let mut orderOutcomes: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1351: bool = true;
while { if !__for_first_1351 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1351 = false; i.as_f64().unwrap_or(f64::NAN) < ordersLength } {
let mut __oc: Option<String> = self.safe_string_opt(orders.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), Value::Str("outcome".into()), &[]);
if (__oc.is_some()) {
orderOutcomes.push(__oc.map(Value::from).unwrap_or(Value::Null));
}
}
}
self.load_outcomes(&[Value::from(orderOutcomes)]).await;
let mut result: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1352: bool = true;
while { if !__for_first_1352 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1352 = false; i.as_f64().unwrap_or(f64::NAN) < ordersLength } {
let mut o: Value = self.safe_dict(orders.clone(), i.clone(), &[]);
let mut outcome: Option<String> = self.safe_string_k_opt(o.clone(), "outcome", &[]);
let mut type_var: Option<String> = self.safe_string_k_opt(o.clone(), "type", &[]);
let mut side: Option<String> = self.safe_string_k_opt(o.clone(), "side", &[]);
let mut amount: Value = self.safe_number_k(o.clone(), "amount", &[]);
let mut price: Value = self.safe_number_k(o.clone(), "price", &[]);
let mut orderParams: Value = self.safe_dict_k(o, "params", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let __ws_arg_11 = self.extend(orderParams, &[params.clone()]);
let mut placed: Value = self.create_orderbook_order(outcome.map(Value::from).unwrap_or(Value::Null), type_var.map(Value::from).unwrap_or(Value::Null), side.map(Value::from).unwrap_or(Value::Null), amount, &[price, __ws_arg_11]).await;
result.push(placed);
}
}
return Value::from(result);
Value::Null
}
pub async fn edit_order(&mut self, mut id: Value, mut outcome: Value, mut type_var: Value, mut side: Value, optional_args: &[Value]) -> Value {
let mut amount = get_arg(optional_args, 0, Value::Null);
let mut price = get_arg(optional_args, 1, Value::Null);
let mut params = get_arg(optional_args, 2, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
self.load_outcome(outcome.clone(), &[]).await;
self.cancel_order(id, &[outcome.clone(), params.clone()]).await;
return self.create_orderbook_order(outcome, type_var, side, amount, &[price, params]).await;
Value::Null
}
pub async fn create_amm_order(&mut self, mut outcome: Value, mut type_var: Value, mut side: Value, mut amount: Value, optional_args: &[Value]) -> Value {
let mut price = get_arg(optional_args, 0, Value::Null);
let mut params = get_arg(optional_args, 1, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut sideLower: Value = (if let Some(__s) = side.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null });
let mut isCostDenominated: bool = self.safe_bool_k_opt(params.clone(), "costDenominated", &[Value::Bool(false)]).unwrap_or(false);
if (sideLower.as_str() == Some("buy")) && (!(isCostDenominated)) {
panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", self.id.clone(), Value::Str(" createOrder() market buy on the AMM sizes by collateral, not shares — use createMarketBuyOrderWithCost(outcome, collateral) for a dollar buy, or the default order book (omit enableAmm) for a share-denominated order".into()))));
}
if (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" createOrder() requires a privateKey to sign the on-chain transaction".into()))));
}
self.load_outcome(outcome.clone(), &[]).await;
let mut outcomeObj: Value = self.outcome(outcome.clone());
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut networkId: Option<String> = self.safe_string_k_opt(info.clone(), "networkId", &[]);
let mut chains: Value = self.safe_dict_k(self.options.clone(), "chains", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut chainConfig: Value = self.safe_dict(chains, networkId.clone().map(Value::from).unwrap_or(Value::Null), &[]);
if (chainConfig == Value::Null) {
panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" createOrder() has no on-chain config for network ".into())).into()), networkId.clone().map(Value::from).unwrap_or(Value::Null))));
}
let mut rpcUrl: Value = self.safe_string2(params.clone(), Value::Str("rpcUrl".into()), Value::Str("rpc".into()), &[self.safe_string_k(chainConfig.clone(), "rpcUrl", &[])]);
let mut predictionMarket: Option<String> = self.safe_string_k_opt(chainConfig, "predictionMarket", &[]);
let mut tokenAddress: Value = self.safe_string2(params.clone(), Value::Str("token".into()), Value::Str("tokenAddress".into()), &[self.safe_string_k(info, "tokenAddress", &[])]);
let mut gasLimit: Value = self.safe_string_k(params.clone(), "gasLimit", &[Value::Str("0xaae60".into())]);
let mut sideStr: Value = sideLower;
let mut quoteParams: Value = self.omit(params.clone(), Value::from(vec![Value::Str("rpcUrl".into()), Value::Str("rpc".into()), Value::Str("token".into()), Value::Str("tokenAddress".into()), Value::Str("gasLimit".into()), Value::Str("costDenominated".into()), Value::Str("quote".into()), Value::Str("transactionHash".into()),
Value::Str("txHash".into()), Value::Str("skipAllowance".into()), Value::Str("skipWaitForReceipt".into())]), &[]);
let mut quote: Value = self.safe_dict_k(params.clone(), "quote", &[]);
if (quote == Value::Null) {
quote = self.fetch_trade_quote(outcome, sideStr.clone(), amount, &[quoteParams]).await;
}
let mut calldata: Option<String> = self.safe_string_opt(self.safe_dict_k(quote.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]), Value::Str("calldata".into()), &[]);
if (calldata.is_none()) {
panic!("{}", crate::exchange_errors::bad_request(format!("{}{}", self.id.clone(), Value::Str(" createAmmOrder is missing calldata from fetchTradeQuote".into()))));
}
let mut fromAddress: Value = self.eth_get_address_from_private_key(self.privateKey.clone(), &[]);
let mut txHashParam: Option<String> = self.safe_string2_opt(params.clone(), Value::Str("transactionHash".into()), Value::Str("txHash".into()), &[]);
let mut hasPreBroadcastTxHash: Value = (Value::Bool(txHashParam.is_some()));
let mut skipAllowance: Value = self.safe_bool_k(params.clone(), "skipAllowance", &[hasPreBroadcastTxHash.clone()]);
if (sideStr.as_str() == Some("buy")) && (tokenAddress != Value::Null) && (skipAllowance.as_bool() != Some(true)) {
self.ensure_erc20_allowance(rpcUrl.clone(), networkId.clone().map(Value::from).unwrap_or(Value::Null), tokenAddress, fromAddress.clone(), predictionMarket.clone().map(Value::from).unwrap_or(Value::Null)).await;
}
let mut skipWaitForReceipt: Value = self.safe_bool_k(params, "skipWaitForReceipt", &[hasPreBroadcastTxHash]);
let mut txHash: Value = txHashParam.map(Value::from).unwrap_or(Value::Null);
if (txHash == Value::Null) {
let __ws_arg_12 = self.parse_to_int(networkId.map(Value::from).unwrap_or(Value::Null));
txHash = self.send_evm_transaction(rpcUrl.clone(), __ws_arg_12, fromAddress, predictionMarket.map(Value::from).unwrap_or(Value::Null), Value::Str("0x0".into()), calldata.map(Value::from).unwrap_or(Value::Null), gasLimit).await;
}
if skipWaitForReceipt.as_bool() != Some(true) {
self.wait_for_transaction_receipt(rpcUrl, txHash.clone(), &[]).await;
}
return self.parse_trade_tx(txHash, quote, outcomeObj, sideStr);
Value::Null
}
pub async fn create_market_buy_order_with_cost(&mut self, mut outcome: Value, mut cost: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut request: Value = self.extend(params, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("enableAmm".to_string(), Value::Bool(true));
m.insert("costDenominated".to_string(), Value::Bool(true));
m
})]);
return self.create_order(outcome, Value::Str("market".into()), Value::Str("buy".into()), cost, &[Value::Null, request]).await;
Value::Null
}
pub fn sign_orderbook_typed_data(&self, mut types: Value, mut message: Value, mut networkId: Value) -> Option<String> {
let mut chains: Value = self.safe_dict_k(self.options.clone(), "chains", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut chainConfig: Value = self.safe_dict(chains, networkId.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut exchangeAddress: Option<String> = self.safe_string_k_opt(chainConfig, "obExchangeAddress", &[]);
if (exchangeAddress.is_none()) {
panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" order book trading is not configured for network ".into())).into()), networkId)));
}
let mut domainName: Value = self.safe_string_k(self.options.clone(), "obDomainName", &[Value::Str("MyriadCTFExchange".into())]);
let mut domainVersion: Value = self.safe_string_k(self.options.clone(), "obDomainVersion", &[Value::Str("1".into())]);
let mut domain: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), domainName);
m.insert("version".to_string(), domainVersion);
m.insert("chainId".to_string(), self.parse_to_int(networkId));
m.insert("verifyingContract".to_string(), exchangeAddress.map(Value::from).unwrap_or(Value::Null));
m
});
let mut encoded: Value = self.eth_encode_structured_data(Value::Map(domain), types, message);
let mut digest: Value = self.hash(encoded, Value::Str("keccak".into()), &[Value::Str("hex".into())]);
let mut signature: Value = ecdsa(digest, self.remove0x_prefix(self.privateKey.clone()), Value::Str("secp256k1".into()), Value::Null);
let mut rRaw: Value = signature.as_map().and_then(|__m| __m.get("r")).cloned().unwrap_or(Value::Null);
let mut sRaw: Value = signature.as_map().and_then(|__m| __m.get("s")).cloned().unwrap_or(Value::Null);
let mut r: Value = rRaw.as_str().map(|__s| Value::Str(format!("{:0>64}", __s).into())).unwrap_or(Value::Null);
let mut s: Value = sRaw.as_str().map(|__s| Value::Str(format!("{:0>64}", __s).into())).unwrap_or(Value::Null);
let mut v: Value = self.sum(&[Value::Int(27), signature.as_map().and_then(|__m| __m.get("v")).cloned().unwrap_or(Value::Null)]);
let mut sigHex: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("0x".into()), r).into()), s).into()), self.int_to_base16(v, &[])).into());
return (if let Some(__s) = sigHex.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str().map(str::to_owned);
}
pub fn sign_clob_order(&self, mut message: Value, mut networkId: Value) -> Option<String> {
let mut orderStruct: Value = Value::from(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("trader".into()));
m.insert("type".to_string(), Value::Str("address".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("marketId".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("outcomeId".into()));
m.insert("type".to_string(), Value::Str("uint8".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("side".into()));
m.insert("type".to_string(), Value::Str("uint8".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("amount".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("price".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("minFillAmount".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("nonce".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("expiration".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
})]);
return self.sign_orderbook_typed_data(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("Order".to_string(), orderStruct);
m
}), message, networkId);
}
pub fn sign_cancel_all(&self, mut message: Value, mut networkId: Value) -> Option<String> {
let mut cancelStruct: Value = Value::from(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("trader".into()));
m.insert("type".to_string(), Value::Str("address".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("marketId".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
}), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("timestamp".into()));
m.insert("type".to_string(), Value::Str("uint256".into()));
m
})]);
return self.sign_orderbook_typed_data(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("CancelAll".to_string(), cancelStruct);
m
}), message, networkId);
}
pub fn clob_order_message(&self, mut rawOrder: Value) -> Value {
let mut signer: Value = self.safe_string2(rawOrder.clone(), Value::Str("trader".into()), Value::Str("user".into()), &[]);
if (self.privateKey.clone() != Value::Null) {
signer = self.eth_get_address_from_private_key(self.privateKey.clone(), &[]);
} else {
signer = self.wallet_address_or_undefined().map(Value::from).unwrap_or(Value::Null);
}
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("trader".to_string(), signer);
m.insert("marketId".to_string(), self.safe_string_k(rawOrder.clone(), "marketId", &[]));
m.insert("outcomeId".to_string(), self.safe_integer_k(rawOrder.clone(), "outcomeId", &[Value::Int(0)]));
m.insert("side".to_string(), self.safe_integer_k(rawOrder.clone(), "side", &[Value::Int(0)]));
m.insert("amount".to_string(), self.safe_string_k(rawOrder.clone(), "amount", &[]));
m.insert("price".to_string(), self.safe_string_k(rawOrder.clone(), "price", &[]));
m.insert("minFillAmount".to_string(), self.safe_string_k(rawOrder.clone(), "minFillAmount", &[Value::Str("0".into())]));
m.insert("nonce".to_string(), self.safe_string_k(rawOrder.clone(), "nonce", &[]));
m.insert("expiration".to_string(), self.safe_string_k(rawOrder, "expiration", &[Value::Str("0".into())]));
m
});
Value::Null
}
pub fn get_order_response_from_params(&self, mut id: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut orderResponse: Value = self.safe_dict_k(params.clone(), "orderResponse", &[]);
if (orderResponse != Value::Null) {
return orderResponse;
}
let mut rawOrder: Value = self.safe_dict_k(params.clone(), "rawOrder", &[]);
if (rawOrder != Value::Null) {
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("orderHash".to_string(), id.clone());
m.insert("order".to_string(), rawOrder);
m.insert("networkId".to_string(), self.safe_string2(params.clone(), Value::Str("networkId".into()), Value::Str("network_id".into()), &[]));
m
});
}
let mut orderResponsesById: Value = self.safe_dict_k(params.clone(), "orderResponses", &[]);
if (orderResponsesById != Value::Null) {
let mut keyedResponse: Value = self.safe_dict(orderResponsesById, id.clone(), &[]);
if (keyedResponse != Value::Null) {
return keyedResponse;
}
}
let mut orderResponses: Value = self.safe_list_k(params, "orderResponses", &[]);
if (orderResponses != Value::Null) {
let mut responsesLength: f64 = ((orderResponses.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1353: bool = true;
while { if !__for_first_1353 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1353 = false; i.as_f64().unwrap_or(f64::NAN) < responsesLength } {
let mut current: Value = self.safe_dict(orderResponses.clone(), i.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut currentId: Option<String> = self.safe_string_n_opt(current.clone(), Value::from(vec![Value::Str("orderHash".into()), Value::Str("hash".into()), Value::Str("id".into())]), &[]);
if (currentId.is_some()) && (currentId.as_deref() == id.as_str()) {
return current;
}
}
}
}
return Value::Null;
Value::Null
}
pub fn to_orderbook_wei(&self, mut value: Value) -> Option<String> {
let mut valueStr: Value = self.number_to_string(value);
let mut scaled: Value = crate::precise::Precise::stringMul(&valueStr, &Value::Str("1000000000000000000".into()));
if (scaled == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" toOrderbookWei() missing scaled".into()))));
}
let mut dotIndex: Value = Value::Int(scaled.as_str().and_then(|__s| __s.find(".")).map(|__i| __i as i64).unwrap_or(-1));
if (scaled == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" toOrderbookWei() missing scaled".into()))));
}
if dotIndex.as_f64().unwrap_or(f64::NAN) > ((-1i64) as f64) {
return (match (&(scaled), 0i64, (match &(dotIndex) { Value::Int(__n) => Some(*__n), Value::Float(__f) => Some(*__f as i64), Value::Str(__s) => __s.parse::<i64>().ok(), Value::Bool(__b) => Some(if *__b { 1 } else { 0 }), _ => None })) { (Value::Str(__sv), __b,
__e) => match (__sv.chars().count() as i64) { __l => match (if __b < 0 { (__l + __b).max(0) } else { __b.min(__l) }, match __e { None => __l, Some(__k) => if __k < 0 { (__l + __k).max(0) } else { __k.min(__l) } }) { (__i,
__j) => if __i <= __j { Value::Str(__sv.chars().skip(__i as usize).take((__j - __i) as usize).collect::<String>().into()) } else { Value::Str(String::new().into()) } } }, (Value::Arr(__a), __b, __e) => match (__a.len() as i64) { __l => match (if __b < 0 { (__l + __b).max(0) } else { __b.min(__l) }, match __e { None => __l,
Some(__k) => if __k < 0 { (__l + __k).max(0) } else { __k.min(__l) } }) { (__i, __j) => if __i <= __j { Value::Array(__a[__i as usize..__j as usize].to_vec()) } else { Value::Array(vec![]) } } }, _ => Value::Null }).as_str().map(str::to_owned);
}
return scaled.as_str().map(str::to_owned);
}
pub fn parse_order_status(&self, mut status: Value) -> Option<String> {
let mut statuses: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("open".to_string(), Value::Str("open".into()));
m.insert("pending".to_string(), Value::Str("open".into()));
m.insert("partially_filled".to_string(), Value::Str("open".into()));
m.insert("filled".to_string(), Value::Str("closed".into()));
m.insert("cancelled".to_string(), Value::Str("canceled".into()));
m.insert("canceled".to_string(), Value::Str("canceled".into()));
m.insert("expired".to_string(), Value::Str("expired".into()));
m
});
return self.safe_string(Value::Map(statuses), status.clone(), &[status.clone()]).as_str().map(str::to_owned);
}
pub fn parse_prediction_order(&self, mut order: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut inner: Value = self.safe_dict_k(order.clone(), "order", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut orderHash: Option<String> = self.safe_string2_opt(order.clone(), Value::Str("orderHash".into()), Value::Str("hash".into()), &[]);
let mut sideInt: Option<i64> = self.safe_integer_k(inner.clone(), "side", &[]).as_i64();
let mut side: String = "buy".to_string();
if (sideInt == Some(1)) {
side = "sell".to_string();
}
let mut amountWei: Option<String> = self.safe_string_k_opt(inner.clone(), "amount", &[]);
let mut priceWei: Option<String> = self.safe_string_k_opt(inner.clone(), "price", &[]);
let mut filledWei: Option<String> = self.safe_string_k_opt(order.clone(), "filledAmount", &[]);
let mut amount: Value = (if (amountWei.is_none()) { Value::Null } else { self.parse_number(crate::precise::Precise::stringDiv(&amountWei.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("1000000000000000000".into())), &[]) });
let mut price: Value = (if (priceWei.is_none()) { Value::Null } else { self.parse_number(crate::precise::Precise::stringDiv(&priceWei.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("1000000000000000000".into())), &[]) });
let mut filled: Value = (if (filledWei.is_none()) { Value::Null } else { self.parse_number(crate::precise::Precise::stringDiv(&filledWei.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("1000000000000000000".into())), &[]) });
let mut statusRaw: Option<String> = self.safe_string_lower_k_opt(order.clone(), "status", &[]);
let mut status: Value = self.parse_order_status(statusRaw.map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
let mut timestamp: Value = self.parse8601(self.safe_string_k(order.clone(), "createdAt", &[]));
let mut tif: Option<String> = self.safe_string_upper_k_opt(order.clone(), "timeInForce", &[]);
let mut isMarketTif: bool = (tif.as_deref() == Some("FOK")) || (tif.as_deref() == Some("FAK"));
let mut outcome: Value = Value::Null;
if (market == Value::Null) {
outcome = Value::Null;
} else {
outcome = self.safe_string_k(market.clone(), "outcome", &[]);
}
let mut outcomeObj: Value = market.clone();
if (outcome == Value::Null) {
let mut networkId: Value = self.safe_string2(order.clone(), Value::Str("networkId".into()), Value::Str("network_id".into()), &[self.safe_string_k(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())])]);
let mut marketId: Option<String> = self.safe_string_k_opt(inner.clone(), "marketId", &[]);
let mut outcomeId: Option<String> = self.safe_string_k_opt(inner, "outcomeId", &[]);
let mut composite: Value = Value::Null;
if (networkId != Value::Null) && (marketId.is_some()) && (outcomeId.is_some()) {
composite = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId, Value::Str(":".into())).into()), marketId.map(Value::from).unwrap_or(Value::Null)).into()), Value::Str("/".into())).into()), outcomeId.map(Value::from).unwrap_or(Value::Null)).into());
}
outcomeObj = self.safe_outcome(composite, &[market.clone()]);
outcome = self.safe_string_k(outcomeObj.clone(), "outcome", &[]);
}
return self.safe_prediction_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), orderHash.map(Value::from).unwrap_or(Value::Null));
m.insert("clientOrderId".to_string(), Value::Null);
m.insert("info".to_string(), order);
m.insert("timestamp".to_string(), timestamp.clone());
m.insert("datetime".to_string(), self.iso8601(timestamp));
m.insert("lastTradeTimestamp".to_string(), Value::Null);
m.insert("outcome".to_string(), outcome);
m.insert("outcomeId".to_string(), self.safe_string2(outcomeObj.clone(), Value::Str("outcomeId".into()), Value::Str("id".into()), &[]));
m.insert("label".to_string(), self.safe_string_k(outcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(outcomeObj, "market", &[]));
m.insert("type".to_string(), (if isMarketTif { Value::Str("market".into()) } else { Value::Str("limit".into()) }));
m.insert("timeInForce".to_string(), tif.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("postOnly".to_string(), (Value::Bool(tif.as_deref() == Some("PO"))));
m.insert("side".to_string(), Value::from(side));
m.insert("price".to_string(), price);
m.insert("triggerPrice".to_string(), Value::Null);
m.insert("amount".to_string(), amount);
m.insert("filled".to_string(), filled);
m.insert("remaining".to_string(), Value::Null);
m.insert("cost".to_string(), Value::Null);
m.insert("average".to_string(), Value::Null);
m.insert("status".to_string(), status);
m.insert("fee".to_string(), Value::Null);
m.insert("trades".to_string(), Value::Null);
m
}), &[market]);
Value::Null
}
pub fn parse_amm_event_to_order(&self, mut trade: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut networkId: Option<String> = self.safe_string_k_opt(trade.clone(), "networkId", &[]);
let mut marketId: Option<String> = self.safe_string_k_opt(trade.clone(), "marketId", &[]);
let mut rawOutcomeId: Option<String> = self.safe_string_k_opt(trade.clone(), "outcomeId", &[]);
let mut composite: Value = Value::Null;
if (networkId.is_some()) && (marketId.is_some()) && (rawOutcomeId.is_some()) {
composite = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId.map(Value::from).unwrap_or(Value::Null), Value::Str(":".into())).into()), marketId.clone().map(Value::from).unwrap_or(Value::Null)).into()), Value::Str("/".into())).into()), rawOutcomeId.clone().map(Value::from).unwrap_or(Value::Null)).into());
}
let mut outcomeObj: Value = self.safe_outcome(composite.clone(), &[market.clone()]);
let mut marketSlug: Value = self.safe_string_k(trade.clone(), "marketSlug", &[marketId.map(Value::from).unwrap_or(Value::Null)]);
let mut outcomeTitle: Value = self.safe_string_k(trade.clone(), "outcomeTitle", &[rawOutcomeId.map(Value::from).unwrap_or(Value::Null)]);
let mut outcomeValue: Value = self.safe_string_k(outcomeObj.clone(), "outcome", &[]);
let mut outcome: Value = (if (outcomeValue != Value::Null) { outcomeValue } else { self.slug_to_outcome_symbol(marketSlug.clone(), marketSlug.clone(), outcomeTitle.clone()) });
let mut marketSymbolValue: Value = self.safe_string_k(outcomeObj.clone(), "market", &[]);
let mut marketSymbol: Value = (if (marketSymbolValue != Value::Null) { marketSymbolValue } else { self.slug_to_market_symbol(marketSlug.clone(), marketSlug.clone()) });
let mut label: Value = self.safe_string_k(outcomeObj, "label", &[]);
if (label == Value::Null) {
label = outcomeTitle;
}
let mut timestamp: Value = self.safe_timestamp_k(trade.clone(), "timestamp", &[]);
let mut amountStr: Option<String> = self.safe_string_k_opt(trade.clone(), "shares", &[]);
let mut costStr: Option<String> = self.safe_string_k_opt(trade.clone(), "value", &[]);
let mut priceStr: Value = Value::Null;
if (amountStr.is_some()) && (costStr.is_some()) && !(crate::precise::Precise::stringEq(&amountStr.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("0".into())).as_bool() == Some(true)) {
priceStr = crate::precise::Precise::stringDiv(&costStr.clone().map(Value::from).unwrap_or(Value::Null), &amountStr.clone().map(Value::from).unwrap_or(Value::Null));
}
return self.safe_prediction_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), self.safe_string2(trade.clone(), Value::Str("txId".into()), Value::Str("id".into()), &[]));
m.insert("clientOrderId".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("lastTradeTimestamp".to_string(), timestamp);
m.insert("lastUpdateTimestamp".to_string(), Value::Null);
m.insert("status".to_string(), Value::Str("closed".into()));
m.insert("outcome".to_string(), outcome);
m.insert("outcomeId".to_string(), composite);
m.insert("label".to_string(), label);
m.insert("market".to_string(), marketSymbol);
m.insert("type".to_string(), Value::Str("market".into()));
m.insert("timeInForce".to_string(), Value::Str("IOC".into()));
m.insert("postOnly".to_string(), Value::Bool(false));
m.insert("side".to_string(), self.safe_string_lower_k(trade, "action", &[]));
m.insert("price".to_string(), self.parse_number(priceStr.clone(), &[]));
m.insert("triggerPrice".to_string(), Value::Null);
m.insert("amount".to_string(), self.parse_number(amountStr.clone().map(Value::from).unwrap_or(Value::Null), &[]));
m.insert("filled".to_string(), self.parse_number(amountStr.map(Value::from).unwrap_or(Value::Null), &[]));
m.insert("remaining".to_string(), Value::Int(0));
m.insert("cost".to_string(), self.parse_number(costStr.map(Value::from).unwrap_or(Value::Null), &[]));
m.insert("average".to_string(), self.parse_number(priceStr, &[]));
m.insert("fee".to_string(), Value::Null);
m.insert("reduceOnly".to_string(), Value::Null);
m.insert("trades".to_string(), Value::from(vec![]));
m.insert("event".to_string(), Value::Null);
m
}), &[market]);
Value::Null
}
pub async fn fetch_amm_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut requestedStatus: Option<String> = self.safe_string_lower_k(params.clone(), "status", &[]).as_str().map(str::to_owned);
if (requestedStatus.as_deref() == Some("open")) || (requestedStatus.as_deref() == Some("cancelled")) || (requestedStatus.as_deref() == Some("canceled")) || (requestedStatus.as_deref() == Some("expired")) {
return Value::from(vec![]);
}
let mut traderParam: Value = self.safe_string2(params.clone(), Value::Str("trader".into()), Value::Str("address".into()), &[]);
let mut trader: Value = (if (traderParam != Value::Null) { traderParam } else { self.wallet_address_or_undefined().map(Value::from).unwrap_or(Value::Null) });
if (trader == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" fetchOrders() for AMM history requires a trader address or wallet/privateKey".into()))));
}
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("address".to_string(), trader);
m
});
let mut outcomeObj: Value = Value::Null;
let mut outcomeSymbol: Value = Value::Null;
let mut rowOutcomeId: Value = Value::Null;
if (outcome != Value::Null) {
outcomeObj = self.load_outcome(outcome.clone(), &[]).await;
outcomeSymbol = self.safe_string_k(outcomeObj.clone(), "outcome", &[outcome]);
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
request.insert("market_id".into(), self.safe_string_k(info.clone(), "marketId", &[]));
request.insert("network_id".into(), self.safe_string_k(info.clone(), "networkId", &[]));
rowOutcomeId = self.safe_string_k(info, "outcomeId", &[]);
}
if (since != Value::Null) {
request.insert("since".into(), self.parse_to_int((match ((since).as_f64(), (Value::Int(1000)).as_f64()) { (Some(x), Some(y)) if y != 0.0 => Value::Float(x / y), _ => Value::Null })));
}
if (limit != Value::Null) {
request.insert("limit".into(), limit.clone());
}
let mut paramsOmitted: Value = self.omit(params, Value::from(vec![Value::Str("trader".into()), Value::Str("address".into()), Value::Str("status".into())]), &[]);
let __ws_arg_13 = self.extend(Value::Map(request), &[paramsOmitted]);
let mut response: Value = self.myriad_public_get_users_address_events(&[__ws_arg_13]).await;
let mut rows: Vec<Value> = self.safe_list_k(response, "data", &[Value::from(vec![])]).as_array().cloned().unwrap_or_default();
let mut result: Vec<Value> = Vec::new();
let mut rowsLength: f64 = ((rows.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1354: bool = true;
while { if !__for_first_1354 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1354 = false; i.as_f64().unwrap_or(f64::NAN) < rowsLength } {
let mut row: Value = rows.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut action: Option<String> = self.safe_string_lower_k(row.clone(), "action", &[]).as_str().map(str::to_owned);
if (action.as_deref() != Some("buy")) && (action.as_deref() != Some("sell")) {
continue;
}
let mut currentOutcomeId: Option<String> = self.safe_string_k_opt(row.clone(), "outcomeId", &[]);
if (rowOutcomeId != Value::Null) && (currentOutcomeId.as_deref() != rowOutcomeId.as_str()) {
continue;
}
result.push(self.parse_amm_event_to_order(row, &[outcomeObj.clone()]));
}
}
let mut sorted: Value = self.sort_by(Value::from(result), Value::Str("timestamp".into()), &[Value::Bool(true)]);
return self.filter_by_outcome_since_limit(sorted, &[outcomeSymbol, since, limit]);
Value::Null
}
pub async fn cancel_order(&mut self, mut id: Value, optional_args: &[Value]) -> Value {
let mut outcome = 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 (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" cancelOrder() requires a privateKey to sign the cancellation".into()))));
}
let mut fetched: Value = self.get_order_response_from_params(id.clone(), &[params.clone()]);
let mut networkIdParam: Option<String> = self.safe_string2_opt(params.clone(), Value::Str("networkId".into()), Value::Str("network_id".into()), &[]);
let mut paramsOmitted: Value = self.omit(params, Value::from(vec![Value::Str("orderResponse".into()), Value::Str("orderResponses".into()), Value::Str("rawOrder".into()), Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
if (fetched == Value::Null) {
let __ws_arg_14 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("hash".to_string(), id.clone());
m
}), &[paramsOmitted.clone()]);
fetched = self.myriad_public_get_orders_hash(&[__ws_arg_14]).await;
}
let mut fetchedInfo: Value = self.safe_dict_k(fetched.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut rawOrder: Value = self.safe_dict_k(fetched.clone(), "order", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut rawOrderKeys: Vec<Value> = Value::Array(rawOrder.as_map().map(|__m| __m.keys().map(|__k| Value::Str(__k.clone().into())).collect()).unwrap_or_default()).as_array().cloned().unwrap_or_default();
let mut rawOrderKeysLength: f64 = ((rawOrderKeys.len() as i64) as f64);
if (rawOrderKeysLength == 0.0) {
rawOrder = self.safe_dict_k(fetchedInfo.clone(), "order", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
}
let mut networkId: Value = self.safe_string_n(fetched.clone(), Value::from(vec![Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
if (networkId == Value::Null) {
networkId = self.safe_string_n(fetchedInfo, Value::from(vec![Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
}
if (networkId == Value::Null) {
networkId = networkIdParam.map(Value::from).unwrap_or(Value::Null);
}
if (networkId == Value::Null) {
networkId = self.safe_string_k(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())]);
}
let mut message: Value = self.clob_order_message(rawOrder);
let mut signature: Value = self.sign_clob_order(message.clone(), networkId.clone()).map(Value::from).unwrap_or(Value::Null);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("hash".to_string(), id);
m.insert("order".to_string(), message);
m.insert("signature".to_string(), signature);
m.insert("network_id".to_string(), self.parse_to_int(networkId.clone()));
m
});
let __ws_arg_15 = self.extend(Value::Map(request), &[paramsOmitted]);
let mut response: Value = self.myriad_public_delete_orders_hash(&[__ws_arg_15]).await;
let mut status: Value = self.safe_string_k(response, "status", &[Value::Str("canceled".into())]);
let mut wrapper: Value = self.extend(fetched, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), status);
m.insert("networkId".to_string(), networkId);
m
})]);
let mut market: Value = Value::Null;
if (outcome != Value::Null) {
market = self.load_outcome(outcome, &[]).await;
}
return self.parse_prediction_order(wrapper, &[market]);
Value::Null
}
pub async fn cancel_all_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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 (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" cancelAllOrders() requires a privateKey to sign the cancellation".into()))));
}
let mut trader: Value = self.eth_get_address_from_private_key(self.privateKey.clone(), &[]);
let mut marketId: Value = self.safe_string_k(params.clone(), "market_id", &[Value::Str("0".into())]);
let mut networkId: Value = self.safe_string_k(params.clone(), "network_id", &[self.safe_string(self.options.clone(), Value::Str("defaultNetworkId".into()), &[Value::Str("56".into())])]);
if (outcome != Value::Null) {
let mut outcomeObj: Value = self.load_outcome(outcome, &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj, "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
marketId = self.safe_string_k(info.clone(), "marketId", &[marketId.clone()]);
networkId = self.safe_string_k(info, "networkId", &[networkId.clone()]);
}
let mut timestamp: Value = self.safe_string_k(params, "timestamp", &[self.number_to_string(self.seconds())]);
let mut message: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("trader".to_string(), trader.clone());
m.insert("marketId".to_string(), marketId.clone());
m.insert("timestamp".to_string(), timestamp.clone());
m
});
let mut signature: Value = self.sign_cancel_all(Value::Map(message), networkId.clone()).map(Value::from).unwrap_or(Value::Null);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("trader".to_string(), trader);
m.insert("market_id".to_string(), self.parse_to_int(marketId));
m.insert("timestamp".to_string(), timestamp);
m.insert("signature".to_string(), signature);
m.insert("network_id".to_string(), self.parse_to_int(networkId));
m
});
let mut response: Value = self.myriad_public_post_orders_cancel_all(&[Value::Map(request)]).await;
return Value::from(vec![self.safe_prediction_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), response);
m.insert("status".to_string(), Value::Str("canceled".into()));
m
}), &[])]);
Value::Null
}
pub async fn cancel_orders(&mut self, mut ids: Value, optional_args: &[Value]) -> Value {
let mut outcome = 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 __ids_empty = Vec::new();
let ids = ids.as_array().unwrap_or(&__ids_empty);
if (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" cancelOrders() requires a privateKey to sign the cancellations".into()))));
}
let mut paramsForLookup: Value = params.clone();
let mut networkIdParam: Option<String> = self.safe_string2_opt(params.clone(), Value::Str("networkId".into()), Value::Str("network_id".into()), &[]);
let mut paramsOmitted: Value = self.omit(params, Value::from(vec![Value::Str("orderResponse".into()), Value::Str("orderResponses".into()), Value::Str("rawOrder".into()), Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
let mut idsLength: f64 = ((ids.len() as i64) as f64);
let mut signedOrders: Vec<Value> = Vec::new();
let mut wrappers: Vec<Value> = Vec::new();
let mut networkId: Value = self.safe_string_k(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())]);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1355: bool = true;
while { if !__for_first_1355 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1355 = false; i.as_f64().unwrap_or(f64::NAN) < idsLength } {
let mut id: Value = ids.get((i).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut fetched: Value = self.get_order_response_from_params(id.clone(), &[paramsForLookup.clone()]);
if (fetched == Value::Null) {
fetched = self.myriad_public_get_orders_hash(&[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("hash".to_string(), id);
m
})]).await;
}
let mut fetchedInfo: Value = self.safe_dict_k(fetched.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut rawOrder: Value = self.safe_dict_k(fetched.clone(), "order", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut rawOrderKeys: Vec<Value> = Value::Array(rawOrder.as_map().map(|__m| __m.keys().map(|__k| Value::Str(__k.clone().into())).collect()).unwrap_or_default()).as_array().cloned().unwrap_or_default();
let mut rawOrderKeysLength: f64 = ((rawOrderKeys.len() as i64) as f64);
if (rawOrderKeysLength == 0.0) {
rawOrder = self.safe_dict_k(fetchedInfo.clone(), "order", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
}
let mut fetchedNetworkId: Value = self.safe_string_n(fetched.clone(), Value::from(vec![Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
if (fetchedNetworkId == Value::Null) {
fetchedNetworkId = self.safe_string_n(fetchedInfo, Value::from(vec![Value::Str("networkId".into()), Value::Str("network_id".into())]), &[]);
}
if (fetchedNetworkId == Value::Null) {
fetchedNetworkId = networkIdParam.clone().map(Value::from).unwrap_or(Value::Null);
}
if (fetchedNetworkId != Value::Null) {
networkId = fetchedNetworkId;
}
let mut message: Value = self.clob_order_message(rawOrder);
let mut signature: Value = self.sign_clob_order(message.clone(), networkId.clone()).map(Value::from).unwrap_or(Value::Null);
signedOrders.push(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("order".to_string(), message);
m.insert("signature".to_string(), signature);
m
}));
wrappers.push(self.extend(fetched, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), Value::Str("canceled".into()));
m.insert("networkId".to_string(), networkId.clone());
m
})]));
}
}
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("orders".to_string(), Value::from(signedOrders));
m.insert("network_id".to_string(), self.parse_to_int(networkId));
m
});
let __ws_arg_16 = self.extend(Value::Map(request), &[paramsOmitted]);
self.myriad_public_post_orders_cancel_batch(&[__ws_arg_16]).await;
return self.parse_prediction_orders(Value::from(wrappers), &[]);
Value::Null
}
pub async fn fetch_order(&mut self, mut id: Value, optional_args: &[Value]) -> Value {
let mut outcome = 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 __ws_arg_17 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("hash".to_string(), id);
m
}), &[params]);
let mut response: Value = self.myriad_public_get_orders_hash(&[__ws_arg_17]).await;
let mut market: Value = Value::Null;
if (outcome != Value::Null) {
market = self.load_outcome(outcome, &[]).await;
}
return self.parse_prediction_order(response, &[market]);
Value::Null
}
pub async fn fetch_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
let mut trader: Option<String> = self.safe_string_k(params.clone(), "trader", &[]).as_str().map(str::to_owned);
if (trader.is_none()) {
if (self.privateKey.clone() != Value::Null) {
request.insert("trader".into(), self.eth_get_address_from_private_key(self.privateKey.clone(), &[]));
} else if (self.walletAddress.clone() != Value::Null) {
request.insert("trader".into(), self.walletAddress.clone());
}
}
let mut requestedTradingModel: Value = self.safe_string_lower2(params.clone(), Value::Str("tradingModel".into()), Value::Str("trading_model".into()), &[]);
let mut paramsOmitted: Value = self.omit(params, Value::from(vec![Value::Str("tradingModel".into()), Value::Str("trading_model".into())]), &[]);
let mut outcomeObj: Value = Value::Null;
let mut outcomeSymbol: Value = Value::Null;
if (outcome != Value::Null) {
outcomeObj = self.load_outcome(outcome.clone(), &[]).await;
outcomeSymbol = self.safe_string_k(outcomeObj.clone(), "outcome", &[outcome.clone()]);
if (requestedTradingModel == Value::Null) {
let mut info: Value = self.safe_dict_k(outcomeObj, "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
requestedTradingModel = self.safe_string_lower_k(info, "tradingModel", &[]);
}
}
if (requestedTradingModel.as_str() == Some("amm")) {
return self.fetch_amm_orders(&[outcome, since.clone(), limit.clone(), paramsOmitted.clone()]).await;
}
let __ws_arg_18 = self.extend(Value::Map(request), &[paramsOmitted]);
let mut response: Value = self.myriad_public_get_orders(&[__ws_arg_18]).await;
let mut data: Value = self.safe_list_k(response, "data", &[Value::from(vec![])]);
let mut orders: Value = self.parse_prediction_orders(data, &[]);
return self.filter_by_outcome_since_limit(orders, &[outcomeSymbol, since, limit]);
Value::Null
}
pub async fn fetch_open_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), Value::Str("open".into()));
m
});
let __ws_arg_19 = self.extend(Value::Map(request), &[params]);
return self.fetch_orders(&[outcome, since, limit, __ws_arg_19]).await;
Value::Null
}
pub async fn fetch_closed_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), Value::Str("filled".into()));
m
});
let __ws_arg_20 = self.extend(Value::Map(request), &[params]);
return self.fetch_orders(&[outcome, since, limit, __ws_arg_20]).await;
Value::Null
}
pub async fn fetch_canceled_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), Value::Str("cancelled".into()));
m
});
let __ws_arg_21 = self.extend(Value::Map(request), &[params]);
return self.fetch_orders(&[outcome, since, limit, __ws_arg_21]).await;
Value::Null
}
pub async fn fetch_my_trades(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("status".to_string(), Value::Str("filled".into()));
m
});
let __ws_arg_22 = self.extend(Value::Map(request), &[params]);
let mut orders: Value = self.fetch_orders(&[outcome.clone(), since.clone(), limit.clone(), __ws_arg_22]).await;
let mut trades: Vec<Value> = Vec::new();
let mut ordersLength: f64 = ((orders.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1356: bool = true;
while { if !__for_first_1356 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1356 = false; i.as_f64().unwrap_or(f64::NAN) < ordersLength } {
let mut order: Value = orders.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);
trades.push(self.order_to_trade(order));
}
}
return self.filter_by_value_since_limit(Value::from(trades), Value::Str("outcome".into()), &[outcome, since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);
Value::Null
}
pub fn order_to_trade(&self, mut order: Value) -> Value {
let mut timestamp: Option<i64> = self.safe_integer_k(order.clone(), "timestamp", &[]).as_i64();
let mut orderType: Option<String> = self.safe_string_k_opt(order.clone(), "type", &[]);
let mut price: Value = Value::Null;
if (orderType.as_deref() != Some("market")) {
price = self.safe_number_k(order.clone(), "price", &[]);
}
return self.safe_prediction_trade(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), self.safe_string_k(order.clone(), "id", &[]));
m.insert("order".to_string(), self.safe_string_k(order.clone(), "id", &[]));
m.insert("info".to_string(), self.safe_dict_k(order.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]));
m.insert("timestamp".to_string(), Value::from(timestamp));
m.insert("datetime".to_string(), self.iso8601(Value::from(timestamp)));
m.insert("outcome".to_string(), self.safe_string_k(order.clone(), "outcome", &[]));
m.insert("outcomeId".to_string(), self.safe_string_k(order.clone(), "outcomeId", &[]));
m.insert("label".to_string(), self.safe_string_k(order.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(order.clone(), "market", &[]));
m.insert("type".to_string(), orderType.map(Value::from).unwrap_or(Value::Null));
m.insert("side".to_string(), self.safe_string_k(order.clone(), "side", &[]));
m.insert("takerOrMaker".to_string(), Value::Null);
m.insert("price".to_string(), price);
m.insert("amount".to_string(), self.safe_number_k(order, "filled", &[]));
m.insert("cost".to_string(), Value::Null);
m.insert("fee".to_string(), Value::Null);
m
}), &[]);
Value::Null
}
pub async fn fetch_balance(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut networkId: Value = self.safe_string2(params.clone(), Value::Str("network_id".into()), Value::Str("network".into()), &[self.safe_string_k(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())])]);
let mut chains: Value = self.safe_dict_k(self.options.clone(), "chains", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut chainConfig: Value = self.safe_dict(chains, networkId.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut rpcUrl: Value = self.safe_string2(params.clone(), Value::Str("rpcUrl".into()), Value::Str("rpc".into()), &[self.safe_string_k(chainConfig.clone(), "rpcUrl", &[])]);
let mut token: Value = self.safe_string2(params.clone(), Value::Str("token".into()), Value::Str("tokenAddress".into()), &[self.safe_string_k(chainConfig.clone(), "collateralToken", &[])]);
if (token == Value::Null) {
panic!("{}", crate::exchange_errors::not_supported(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" fetchBalance() has no collateral token configured for network ".into())).into()), networkId)));
}
let mut currency: Value = self.safe_string_k(params.clone(), "currency", &[self.safe_string(chainConfig.clone(), Value::Str("collateralCurrency".into()), &[Value::Str("USD1".into())])]);
let mut decimals: Value = self.safe_integer_k(params, "decimals", &[self.safe_integer(chainConfig, Value::Str("collateralDecimals".into()), &[Value::Int(18)])]);
let mut owner: Value = self.wallet_address_from_keys().map(Value::from).unwrap_or(Value::Null);
let mut callData: Value = Value::Str(format!("{}{}", Value::Str("0x70a08231".into()), self.pad_hex_address(owner)).into());
let mut callParams: Value = Value::from(vec![Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("to".to_string(), token.clone());
m.insert("data".to_string(), callData);
m
}), Value::Str("latest".into())]);
let mut raw: Value = self.eth_rpc(rpcUrl, Value::Str("eth_call".into()), callParams).await;
let mut balanceString: Value = self.from_wei_with_decimals(raw.clone(), decimals).map(Value::from).unwrap_or(Value::Null);
let mut result: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("balanceHex".to_string(), raw);
m.insert("token".to_string(), token);
m.insert("networkId".to_string(), networkId);
m
}));
m
});
let mut account: indexmap::IndexMap<String, Value> = self.account().as_map().cloned().unwrap_or_default();
account.insert("free".into(), balanceString.clone());
account.insert("total".into(), balanceString);
result.insert(crate::runtime::stringify_param(¤cy), Value::Map(account));
return self.safe_balance(Value::Map(result));
Value::Null
}
pub fn hex_to_decimal_string(&self, mut hexValue: Value) -> Option<String> {
let mut stripped: Value = self.remove0x_prefix(hexValue);
if (stripped.as_str() == Some("")) {
return None;
}
let mut chars: Vec<Value> = self.string_to_chars_array((if let Some(__s) = stripped.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null })).as_array().cloned().unwrap_or_default();
let mut n: f64 = ((chars.len() as i64) as f64);
let mut digits: String = "0123456789abcdef".to_string();
let mut result: Value = Value::Str("0".into());
{
let mut i: Value = Value::Int(0);
let mut __for_first_1357: bool = true;
while { if !__for_first_1357 { if let Value::Int(__n) = &mut i { *__n += 1; } } __for_first_1357 = false; i.as_f64().unwrap_or(f64::NAN) < n } {
let mut v: Value = (match (&(Value::from(digits.clone())), &(chars.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null))) { (Value::Arr(__a), __nd) => Value::Int(__a.iter().position(|__it| match (__it, __nd) { (Value::Null, Value::Null) => true, (Value::Bool(__x), Value::Bool(__y)) => __x == __y, (Value::Str(__x),
Value::Str(__y)) => __x == __y, (Value::Int(__x), Value::Int(__y)) => __x == __y, (Value::Float(__x), Value::Float(__y)) => __x == __y, (__p, __q) => match ((match __p { Value::Int(__n) => Some(*__n as f64), Value::Float(__f) => Some(*__f), Value::Str(__s) => __s.parse::<f64>().ok(), Value::Bool(__b) => Some(if *__b { 1.0 } else { 0.0 }),
_ => None }), (match __q { Value::Int(__n) => Some(*__n as f64), Value::Float(__f) => Some(*__f), Value::Str(__s) => __s.parse::<f64>().ok(), Value::Bool(__b) => Some(if *__b { 1.0 } else { 0.0 }), _ => None })) { (Some(__x), Some(__y)) => __x == __y, _ => false } }).map(|__i| __i as i64).unwrap_or(-1)), (Value::Str(__s),
Value::Str(__nd)) => Value::Int(__s.find(&**__nd).map(|__i| __i as i64).unwrap_or(-1)), _ => Value::Int(-1) });
if v.as_f64().unwrap_or(f64::NAN) > ((-1i64) as f64) {
let mut mul: Value = crate::precise::Precise::stringMul(&result, &Value::Str("16".into()));
let mut digit: Value = self.number_to_string(v);
result = crate::precise::Precise::stringAdd(&mul, &digit);
}
}
}
return result.as_str().map(str::to_owned);
}
pub fn from_wei_with_decimals(&self, mut hexValue: Value, mut decimals: Value) -> Option<String> {
let mut decimalString: Value = self.hex_to_decimal_string(hexValue).map(Value::from).unwrap_or(Value::Null);
if (decimalString == Value::Null) {
return None;
}
let mut scale: Value = Value::Str("1".into());
if (decimals == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" fromWeiWithDecimals() missing decimals".into()))));
}
let mut decimalsCount: Value = self.parse_to_int(decimals);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1358: bool = true;
while { if !__for_first_1358 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1358 = false; i.as_f64().unwrap_or(f64::NAN) < decimalsCount.as_f64().unwrap_or(f64::NAN) } {
scale = Value::Str(format!("{}{}", scale, Value::Str("0".into())).into());
}
}
return crate::precise::Precise::stringDiv(&decimalString, &scale).as_str().map(str::to_owned);
}
pub fn parse_trade_tx(&self, mut txHash: Value, mut quote: Value, mut market: Value, mut side: Value) -> Value {
let __quote_empty = indexmap::IndexMap::new();
let quote = quote.as_map().unwrap_or(&__quote_empty);
return self.safe_prediction_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), txHash.clone());
m.insert("clientOrderId".to_string(), Value::Null);
m.insert("info".to_string(), self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("transactionHash".to_string(), txHash);
m
}), &[(match quote.get("info") { Some(__v) if matches!(__v, Value::Dict(_)) => __v.clone(), _ => Value::Map({
let mut m = indexmap::IndexMap::new();
m
}) })]));
m.insert("outcome".to_string(), self.safe_string_k(market.clone(), "outcome", &[]));
m.insert("outcomeId".to_string(), self.safe_string_k(market.clone(), "id", &[]));
m.insert("label".to_string(), self.safe_string_k(market.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(market.clone(), "market", &[]));
m.insert("type".to_string(), Value::Str("market".into()));
m.insert("side".to_string(), side);
m.insert("price".to_string(), (match quote.get("priceAverage") { Some(Value::Float(__f)) => Value::Float(*__f), Some(Value::Int(__n)) => Value::Float(*__n as f64), Some(Value::Str(__s)) => match __s.parse::<f64>() { Ok(__n) => Value::Float(__n), Err(_) => Value::Null }, _ => Value::Null }));
m.insert("amount".to_string(), (match quote.get("shares") { Some(Value::Float(__f)) => Value::Float(*__f), Some(Value::Int(__n)) => Value::Float(*__n as f64), Some(Value::Str(__s)) => match __s.parse::<f64>() { Ok(__n) => Value::Float(__n), Err(_) => Value::Null }, _ => Value::Null }));
m.insert("cost".to_string(), (match quote.get("value") { Some(Value::Float(__f)) => Value::Float(*__f), Some(Value::Int(__n)) => Value::Float(*__n as f64), Some(Value::Str(__s)) => match __s.parse::<f64>() { Ok(__n) => Value::Float(__n), Err(_) => Value::Null }, _ => Value::Null }));
m.insert("status".to_string(), Value::Str("closed".into()));
m.insert("fee".to_string(), Value::Null);
m
}), &[market]);
Value::Null
}
pub fn parse_market_to_event(&self, mut raw: Value, mut market: Value) -> Value {
let mut slug: Value = self.safe_string_k(raw.clone(), "slug", &[self.safe_string(raw.clone(), Value::Str("id".into()), &[])]);
let mut state: Option<String> = self.safe_string_k(raw.clone(), "state", &[Value::Str("open".into())]).as_str().map(str::to_owned);
let mut endDate: Option<String> = self.safe_string_k_opt(raw.clone(), "expiresAt", &[]);
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), crate::value::get_value_k(&market, "id"));
m.insert("slug".to_string(), slug);
m.insert("event".to_string(), crate::value::get_value_k(&market, "market"));
m.insert("title".to_string(), self.safe_string2(raw.clone(), Value::Str("title".into()), Value::Str("shortName".into()), &[]));
m.insert("description".to_string(), self.safe_string_k(raw.clone(), "description", &[]));
m.insert("markets".to_string(), Value::from(vec![market]));
m.insert("volume".to_string(), self.safe_number2(raw.clone(), Value::Str("volumeNotional24h".into()), Value::Str("volume24h".into()), &[]));
m.insert("liquidity".to_string(), self.safe_number_k(raw.clone(), "liquidity", &[]));
m.insert("url".to_string(), Value::Null);
m.insert("image".to_string(), self.safe_string_k(raw.clone(), "imageUrl", &[]));
m.insert("active".to_string(), (Value::Bool(state.as_deref() == Some("open"))));
m.insert("resolved".to_string(), (Value::Bool(state.as_deref() == Some("resolved"))));
m.insert("category".to_string(), Value::Null);
m.insert("tags".to_string(), self.safe_list_k(raw.clone(), "topics", &[]));
m.insert("created".to_string(), self.parse8601(self.safe_string_k(raw.clone(), "publishedAt", &[])));
m.insert("createdDatetime".to_string(), self.safe_string_k(raw.clone(), "publishedAt", &[]));
m.insert("end".to_string(), (if (endDate.is_some()) { self.parse8601(endDate.clone().map(Value::from).unwrap_or(Value::Null)) } else { Value::Null }));
m.insert("endDatetime".to_string(), endDate.map(Value::from).unwrap_or(Value::Null));
m.insert("lastUpdatedAt".to_string(), Value::Null);
m.insert("resolutionSource".to_string(), self.safe_string_k(raw.clone(), "resolutionSource", &[]));
m.insert("info".to_string(), raw);
m
});
Value::Null
}
pub fn parse_myriad_market(&self, mut raw: Value, optional_args: &[Value]) -> Value {
let mut eventSlug = get_arg(optional_args, 0, Value::Null);
let mut networkId: Option<String> = self.safe_string_k_opt(raw.clone(), "networkId", &[]);
let mut marketId: Option<String> = self.safe_string_k_opt(raw.clone(), "id", &[]);
let mut slug: Value = self.safe_string_k(raw.clone(), "slug", &[marketId.clone().map(Value::from).unwrap_or(Value::Null)]);
let mut rawOutcomes: Value = self.safe_list_k(raw.clone(), "outcomes", &[Value::from(vec![])]);
let mut endDate: Option<String> = self.safe_string_k_opt(raw.clone(), "expiresAt", &[]);
let mut state: Value = self.safe_string_k(raw.clone(), "state", &[Value::Str("open".into())]);
let mut active: Value = Value::Bool(state.as_str() == Some("open"));
let mut resolvedOutcomeId: Value = self.safe_string_k(raw.clone(), "resolvedOutcomeId", &[Value::Str("-1".into())]);
let mut voided: bool = self.safe_bool_k_opt(raw.clone(), "voided", &[Value::Bool(false)]).unwrap_or(false);
let mut hasResolution: bool = (resolvedOutcomeId.as_str() != Some("-1")) && (resolvedOutcomeId != Value::Null) && (resolvedOutcomeId.as_str() != Some(""));
let mut marketResolved: Value = Value::Bool(hasResolution || voided);
let mut resolvedOutcome: Value = Value::Null;
let mut volume24h: Value = self.safe_number_k(raw.clone(), "volume24h", &[]);
let mut marketSymbol: Value = self.slug_to_market_symbol(eventSlug.clone(), slug.clone());
let mut tokenObj: Value = self.safe_dict_k(raw.clone(), "token", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut tokenAddress: Option<String> = self.safe_string_k_opt(tokenObj.clone(), "address", &[]);
let mut tokenDecimals: Option<i64> = self.safe_integer_k(tokenObj.clone(), "decimals", &[Value::Int(18)]).as_i64();
let mut quoteCurrency: Value = self.safe_string_k(tokenObj, "symbol", &[Value::Str("USDC".into())]);
let mut feesObj: Value = self.safe_dict_k(raw.clone(), "fees", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut buyFees: Value = self.safe_dict_k(feesObj.clone(), "buy", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut sellFees: Value = self.safe_dict_k(feesObj, "sell", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut takerFee: Value = self.safe_number_k(buyFees, "fee", &[Value::Float(0.01)]);
let mut makerFee: Value = self.safe_number_k(sellFees, "fee", &[Value::Int(0)]);
let mut outcomes: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1359: bool = true;
while { if !__for_first_1359 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1359 = false; i.as_f64().unwrap_or(f64::NAN) < ((rawOutcomes.len() as i64) as f64) } {
let mut outcome: Value = self.safe_dict(rawOutcomes.clone(), i.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut outcomeId: Value = self.safe_string_k(outcome.clone(), "outcomeId", &[self.safe_string(outcome.clone(), Value::Str("id".into()), &[Value::Str(format!("{}", i).into())])]);
let mut outcomeLabel: Value = self.safe_string_k(outcome.clone(), "label", &[self.safe_string(outcome.clone(), Value::Str("title".into()), &[outcomeId.clone()])]);
let mut price: Value = self.safe_number_k(outcome, "price", &[]);
let mut outcomeHandle: Value = self.slug_to_outcome_symbol(eventSlug.clone(), slug.clone(), outcomeLabel.clone());
let mut outcomeCompositeId: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId.clone().map(Value::from).unwrap_or(Value::Null), Value::Str(":".into())).into()), marketId.clone().map(Value::from).unwrap_or(Value::Null)).into()), Value::Str("/".into())).into()), outcomeId).into());
let mut winnerRaw: Value = Value::Null;
let mut settleFractionRaw: Value = Value::Null;
if hasResolution {
winnerRaw = (Value::Bool(outcomeId.as_str() == resolvedOutcomeId.as_str()));
settleFractionRaw = (if winnerRaw.as_bool() == Some(true) { Value::Int(1) } else { Value::Int(0) });
if winnerRaw.as_bool() == Some(true) {
resolvedOutcome = outcomeHandle.clone();
}
} else if voided {
winnerRaw = Value::Bool(false);
}
let mut winner: Value = winnerRaw;
let mut settleFraction: Value = settleFractionRaw;
outcomes.push(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), outcomeCompositeId.clone());
m.insert("outcomeId".to_string(), outcomeCompositeId);
m.insert("outcome".to_string(), outcomeHandle);
m.insert("market".to_string(), marketSymbol.clone());
m.insert("label".to_string(), outcomeLabel.clone());
m.insert("active".to_string(), active.clone());
m.insert("winner".to_string(), winner);
m.insert("settleFraction".to_string(), settleFraction);
m.insert("precision".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("amount".to_string(), Value::Float(0.01));
m.insert("price".to_string(), Value::Float(0.001));
m
}));
m.insert("info".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("networkId".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("marketId".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("slug".to_string(), slug.clone());
m.insert("outcomeId".to_string(), outcomeId);
m.insert("outcomeLabel".to_string(), outcomeLabel);
m.insert("outcomePrice".to_string(), price);
m.insert("volume24h".to_string(), volume24h.clone());
m.insert("state".to_string(), state.clone());
m.insert("tradingModel".to_string(), self.safe_string_k(raw.clone(), "tradingModel", &[Value::Str("amm".into())]));
m.insert("tokenAddress".to_string(), tokenAddress.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("tokenDecimals".to_string(), Value::from(tokenDecimals));
m
}));
m
}));
}
}
let mut marketTradingModel: Option<String> = self.safe_string_k(raw.clone(), "tradingModel", &[Value::Str("amm".into())]).as_str().map(str::to_owned);
let mut marketExecutionModel: String = "clob".to_string();
if (marketTradingModel.as_deref() == Some("amm")) {
marketExecutionModel = "amm".to_string();
}
let mut outcomesLength: f64 = ((outcomes.len() as i64) as f64);
let mut marketResolvedOutcome: Value = resolvedOutcome;
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId.clone().map(Value::from).unwrap_or(Value::Null), Value::Str(":".into())).into()), marketId.clone().map(Value::from).unwrap_or(Value::Null)).into()));
m.insert("market".to_string(), marketSymbol);
m.insert("marketType".to_string(), (if (outcomesLength > ((2i64) as f64)) { Value::Str("categorical".into()) } else { Value::Str("binary".into()) }));
m.insert("executionModel".to_string(), Value::from(marketExecutionModel));
m.insert("base".to_string(), slug.clone());
m.insert("quote".to_string(), quoteCurrency.clone());
m.insert("settle".to_string(), Value::Null);
m.insert("baseId".to_string(), Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId.clone().map(Value::from).unwrap_or(Value::Null), Value::Str(":".into())).into()), marketId.clone().map(Value::from).unwrap_or(Value::Null)).into()));
m.insert("quoteId".to_string(), quoteCurrency);
m.insert("settleId".to_string(), Value::Null);
m.insert("type".to_string(), Value::Str("prediction".into()));
m.insert("spot".to_string(), Value::Bool(false));
m.insert("margin".to_string(), Value::Bool(false));
m.insert("swap".to_string(), Value::Bool(false));
m.insert("future".to_string(), Value::Bool(false));
m.insert("option".to_string(), Value::Bool(false));
m.insert("prediction".to_string(), Value::Bool(true));
m.insert("active".to_string(), active);
m.insert("resolved".to_string(), marketResolved);
m.insert("resolvedOutcome".to_string(), marketResolvedOutcome);
m.insert("contract".to_string(), Value::Bool(false));
m.insert("linear".to_string(), Value::Null);
m.insert("inverse".to_string(), Value::Null);
m.insert("contractSize".to_string(), Value::Null);
m.insert("expiry".to_string(), (if ((endDate.is_some()) && (endDate.as_deref() != Some(""))) { self.parse8601(endDate.clone().map(Value::from).unwrap_or(Value::Null)) } else { Value::Null }));
m.insert("expiryDatetime".to_string(), endDate.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("strike".to_string(), Value::Null);
m.insert("optionType".to_string(), Value::Null);
m.insert("taker".to_string(), takerFee);
m.insert("maker".to_string(), makerFee);
m.insert("percentage".to_string(), Value::Bool(true));
m.insert("tierBased".to_string(), Value::Bool(false));
m.insert("feeSide".to_string(), Value::Str("get".into()));
m.insert("precision".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("amount".to_string(), Value::Float(0.01));
m.insert("price".to_string(), Value::Float(0.001));
m
}));
m.insert("limits".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("leverage".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("min".to_string(), Value::Int(1));
m.insert("max".to_string(), Value::Int(1));
m
}));
m.insert("amount".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("min".to_string(), Value::Int(0));
m.insert("max".to_string(), Value::Null);
m
}));
m.insert("price".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("min".to_string(), Value::Float(0.001));
m.insert("max".to_string(), Value::Float(0.999));
m
}));
m.insert("cost".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("min".to_string(), Value::Null);
m.insert("max".to_string(), Value::Null);
m
}));
m
}));
m.insert("outcomes".to_string(), Value::from(outcomes));
m.insert("info".to_string(), self.extend(raw, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("networkId".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("marketId".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("slug".to_string(), slug);
m.insert("volume24h".to_string(), volume24h);
m.insert("state".to_string(), state);
m
})]));
m.insert("created".to_string(), Value::Null);
m
});
Value::Null
}
pub async fn fetch_ticker(&mut self, mut outcome: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut outcomeObj: Value = self.load_outcome(outcome, &[]).await;
let mut networkId: Option<String> = self.safe_string_opt(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("networkId".into()), &[]);
let mut marketId: Option<String> = self.safe_string_opt(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("marketId".into()), &[]);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), marketId.map(Value::from).unwrap_or(Value::Null));
m.insert("network_id".to_string(), networkId.map(Value::from).unwrap_or(Value::Null));
m
});
let __ws_arg_23 = self.extend(Value::Map(request), &[params]);
let mut response: Value = self.myriad_public_get_markets_id(&[__ws_arg_23]).await;
return self.parse_prediction_ticker(response, &[outcomeObj]);
Value::Null
}
pub async fn fetch_trading_fee(&mut self, mut outcome: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut outcomeObj: Value = self.load_outcome(outcome, &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), self.safe_string_k(info.clone(), "marketId", &[]));
m.insert("network_id".to_string(), self.safe_string_k(info, "networkId", &[]));
m
});
let __ws_arg_24 = self.extend(Value::Map(request), &[params]);
let mut response: Value = self.myriad_public_get_markets_id(&[__ws_arg_24]).await;
let mut fees: Value = self.safe_dict_k(response.clone(), "fees", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut buy: Value = self.safe_dict_k(fees.clone(), "buy", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut sell: Value = self.safe_dict_k(fees, "sell", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), response);
m.insert("outcome".to_string(), self.safe_outcome_symbol(Value::Null, &[outcomeObj.clone()]));
m.insert("outcomeId".to_string(), self.safe_string_k(outcomeObj, "outcomeId", &[]));
m.insert("maker".to_string(), self.safe_number_k(sell, "fee", &[]));
m.insert("taker".to_string(), self.safe_number_k(buy, "fee", &[]));
m.insert("percentage".to_string(), Value::Bool(true));
m.insert("tierBased".to_string(), Value::Bool(false));
m
});
Value::Null
}
pub fn parse_prediction_ticker(&self, mut raw: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut outcomeId: Value = (if ((market != Value::Null) && (market != Value::Null)) { self.safe_string(market.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("outcomeId".into()), &[]) } else { Value::Null });
let mut outcomes: Value = self.safe_list_k(raw.clone(), "outcomes", &[Value::from(vec![])]);
let mut price: Value = Value::Null;
let mut change: Value = Value::Null;
let mut previousClose: Value = Value::Null;
let mut percentage: Value = Value::Null;
{
let mut i: i64 = 0;
let mut __for_first_1360: bool = true;
while { if !__for_first_1360 { i += 1; } __for_first_1360 = false; i < (outcomes.len() as i64) } {
let mut o: Value = self.safe_dict(outcomes.clone(), Value::Int(i), &[]);
if (self.safe_string_k(o.clone(), "outcomeId", &[self.safe_string(o.clone(), Value::Str("id".into()), &[])]).as_str() == outcomeId.as_str()) {
let mut priceValue: Value = self.safe_number_k(o.clone(), "price", &[]);
let mut changeValue: Value = self.safe_number_k(o, "priceChange24h", &[]);
price = priceValue.clone();
change = changeValue.clone();
if (priceValue != Value::Null) && (changeValue != Value::Null) {
let mut previousCloseValue: Value = (match (&(priceValue), &(changeValue)) { (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 });
previousClose = previousCloseValue.clone();
if (previousCloseValue.as_f64() != Some(0.0)) {
percentage = (match (&((match ((changeValue).as_f64(), (previousCloseValue).as_f64()) { (Some(x), Some(y)) if y != 0.0 => Value::Float(x / y), _ => Value::Null })), &(Value::Int(100))) { (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 });
}
}
break;
}
}
}
return self.safe_prediction_ticker(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("outcome".to_string(), self.safe_string_k(market.clone(), "outcome", &[]));
m.insert("outcomeId".to_string(), self.safe_string_k(market.clone(), "id", &[]));
m.insert("label".to_string(), self.safe_string_k(market.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(market.clone(), "market", &[]));
m.insert("timestamp".to_string(), Value::Null);
m.insert("datetime".to_string(), Value::Null);
m.insert("high".to_string(), Value::Null);
m.insert("low".to_string(), Value::Null);
m.insert("bid".to_string(), price.clone());
m.insert("bidVolume".to_string(), Value::Null);
m.insert("ask".to_string(), price.clone());
m.insert("askVolume".to_string(), Value::Null);
m.insert("vwap".to_string(), Value::Null);
m.insert("open".to_string(), previousClose.clone());
m.insert("close".to_string(), price.clone());
m.insert("last".to_string(), price.clone());
m.insert("previousClose".to_string(), previousClose);
m.insert("change".to_string(), change);
m.insert("percentage".to_string(), percentage);
m.insert("average".to_string(), price);
m.insert("baseVolume".to_string(), self.safe_number_k(raw.clone(), "volumeNotional24h", &[]));
m.insert("quoteVolume".to_string(), self.safe_number_k(raw.clone(), "volume24h", &[]));
m.insert("info".to_string(), raw);
m
}), &[market]);
Value::Null
}
pub async fn fetch_order_book(&mut self, mut outcome: 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 outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut networkId: Option<String> = self.safe_string_opt(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("networkId".into()), &[]);
let mut marketId: Option<String> = self.safe_string_opt(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("marketId".into()), &[]);
let mut outcomeId: Option<String> = self.safe_string_opt(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("outcomeId".into()), &[]);
let mut tradingModel: Option<String> = self.safe_string(outcomeObj.as_map().and_then(|__m| __m.get("info")).cloned().unwrap_or(Value::Null), Value::Str("tradingModel".into()), &[Value::Str("amm".into())]).as_str().map(str::to_owned);
if (tradingModel.as_deref() == Some("ob")) {
let mut obRequest: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("network_id".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("outcome".to_string(), outcomeId.clone().map(Value::from).unwrap_or(Value::Null));
m
});
let __ws_arg_25 = self.extend(Value::Map(obRequest), &[params.clone()]);
let mut obResponse: Value = self.myriad_public_get_markets_id_orderbook(&[__ws_arg_25]).await;
return self.safe_prediction_order_book(self.parse_wei_order_book(obResponse, self.safe_outcome_symbol(outcome.clone(), &[outcomeObj.clone()])), &[outcomeObj.clone()]);
}
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("network_id".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m
});
let __ws_arg_26 = self.extend(Value::Map(request), &[params]);
let mut response: Value = self.myriad_public_get_markets_id(&[__ws_arg_26]).await;
let mut outcomes: Value = self.safe_list_k(response, "outcomes", &[Value::from(vec![])]);
let mut bid: Value = Value::Null;
let mut ask: Value = Value::Null;
{
let mut i: i64 = 0;
let mut __for_first_1361: bool = true;
while { if !__for_first_1361 { i += 1; } __for_first_1361 = false; i < (outcomes.len() as i64) } {
let mut o: Value = self.safe_dict(outcomes.clone(), Value::Int(i), &[]);
if (self.safe_string_k(o.clone(), "outcomeId", &[self.safe_string(o.clone(), Value::Str("id".into()), &[])]).as_str() == outcomeId.as_deref()) {
let mut price: Value = self.safe_number_k(o, "price", &[]);
if (price != Value::Null) {
if price.as_f64().unwrap_or(f64::NAN) > (0.001) {
bid = self.parse_number(crate::precise::Precise::stringSub(&self.number_to_string(price.clone()), &Value::Str("0.001".into())), &[]);
}
if (0.999) > price.as_f64().unwrap_or(f64::NAN) {
ask = self.parse_number(crate::precise::Precise::stringAdd(&self.number_to_string(price), &Value::Str("0.001".into())), &[]);
}
}
break;
}
}
}
let mut synthSize: Value = self.parse_number(Value::Str("9999".into()), &[]);
let mut bids: Vec<Value> = Vec::new();
if (bid != Value::Null) {
bids.push(Value::from(vec![bid, synthSize.clone()]));
}
let mut asks: Vec<Value> = Vec::new();
if (ask != Value::Null) {
asks.push(Value::from(vec![ask, synthSize]));
}
let mut orderbook: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("outcome".to_string(), self.safe_outcome_symbol(outcome, &[outcomeObj.clone()]));
m.insert("bids".to_string(), Value::from(bids));
m.insert("asks".to_string(), Value::from(asks));
m.insert("timestamp".to_string(), Value::Null);
m.insert("datetime".to_string(), Value::Null);
m.insert("nonce".to_string(), Value::Null);
m
});
return self.safe_prediction_order_book(Value::Map(orderbook), &[outcomeObj]);
Value::Null
}
pub fn parse_wei_order_book(&self, mut response: Value, mut outcome: Value) -> Value {
let __response_empty = indexmap::IndexMap::new();
let response = response.as_map().unwrap_or(&__response_empty);
let mut rawBids: Value = (match response.get("bids") { Some(__v) if matches!(__v, Value::Arr(_)) => __v.clone(), _ => Value::from(vec![]) });
let mut rawAsks: Value = (match response.get("asks") { Some(__v) if matches!(__v, Value::Arr(_)) => __v.clone(), _ => Value::from(vec![]) });
let mut bids: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1362: bool = true;
while { if !__for_first_1362 { i += 1; } __for_first_1362 = false; i < (rawBids.len() as i64) } {
let mut row: Value = self.safe_list(rawBids.clone(), Value::Int(i), &[]);
let mut rowPrice: Value = crate::precise::Precise::stringDiv(&self.safe_string(row.clone(), Value::Int(0), &[]), &Value::Str("1000000000000000000".into()));
let mut rowAmount: Value = crate::precise::Precise::stringDiv(&self.safe_string(row.clone(), Value::Int(1), &[]), &Value::Str("1000000000000000000".into()));
bids.push(Value::from(vec![self.parse_number(rowPrice.clone(), &[]), self.parse_number(rowAmount.clone(), &[])]));
}
}
let mut asks: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1363: bool = true;
while { if !__for_first_1363 { i += 1; } __for_first_1363 = false; i < (rawAsks.len() as i64) } {
let mut row: Value = self.safe_list(rawAsks.clone(), Value::Int(i), &[]);
let mut rowPrice: Value = crate::precise::Precise::stringDiv(&self.safe_string(row.clone(), Value::Int(0), &[]), &Value::Str("1000000000000000000".into()));
let mut rowAmount: Value = crate::precise::Precise::stringDiv(&self.safe_string(row, Value::Int(1), &[]), &Value::Str("1000000000000000000".into()));
asks.push(Value::from(vec![self.parse_number(rowPrice, &[]), self.parse_number(rowAmount, &[])]));
}
}
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("outcome".to_string(), outcome);
m.insert("bids".to_string(), self.sort_by(Value::from(bids), Value::Int(0), &[Value::Bool(true)]));
m.insert("asks".to_string(), self.sort_by(Value::from(asks), Value::Int(0), &[]));
m.insert("timestamp".to_string(), Value::Null);
m.insert("datetime".to_string(), Value::Null);
m.insert("nonce".to_string(), Value::Null);
m
});
Value::Null
}
pub async fn fetch_ohlcv(&mut self, mut outcome: Value, optional_args: &[Value]) -> Value {
let mut timeframe = get_arg(optional_args, 0, Value::Str("1d".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
}));
let mut outcomeObj: Value = self.load_outcome(outcome, &[]).await;
let mut outcomeInfo: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut networkId: Option<String> = self.safe_string_k_opt(outcomeInfo.clone(), "networkId", &[]);
let mut marketId: Option<String> = self.safe_string_k_opt(outcomeInfo.clone(), "marketId", &[]);
let mut outcomeId: Value = self.safe_string_k(outcomeInfo.clone(), "outcomeId", &[self.safe_string(outcomeInfo.clone(), Value::Str("id".into()), &[])]);
let mut outcomeTitle: Value = self.safe_string_k(outcomeInfo.clone(), "outcomeLabel", &[self.safe_string(outcomeInfo.clone(), Value::Str("label".into()), &[self.safe_string(outcomeInfo, Value::Str("title".into()), &[])])]);
let mut bucketKey: Value = self.safe_string(self.timeframes.clone(), timeframe.clone(), &[Value::Str("30d".into())]);
let __ws_arg_27 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("network_id".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m
}), &[params]);
let mut response: Value = self.myriad_public_get_markets_id(&[__ws_arg_27]).await;
let mut outcomes: Vec<Value> = self.safe_list_k(response.clone(), "outcomes", &[Value::from(vec![])]).as_array().cloned().unwrap_or_default();
let mut selectedOutcome: Value = Value::Null;
{
let mut i: i64 = 0;
let mut __for_first_1364: bool = true;
while { if !__for_first_1364 { i += 1; } __for_first_1364 = false; i < (outcomes.len() as i64) } {
let mut oc: Value = outcomes.get(i as usize).cloned().unwrap_or(Value::Null);
let mut currentId: Value = self.safe_string_k(oc.clone(), "id", &[self.safe_string(oc.clone(), Value::Str("outcomeId".into()), &[])]);
let mut currentTitle: Value = self.safe_string_k(oc.clone(), "title", &[self.safe_string(oc.clone(), Value::Str("label".into()), &[])]);
if (outcomeId != Value::Null) && (currentId.as_str() == outcomeId.as_str()) {
selectedOutcome = oc.clone();
break;
}
if (selectedOutcome == Value::Null) && (outcomeTitle != Value::Null) && (currentTitle.as_str() == outcomeTitle.as_str()) {
selectedOutcome = oc;
}
}
}
let mut chart: Value = Value::Null;
let mut chartsList: Value = self.safe_list_k(selectedOutcome.clone(), "price_charts", &[]);
if (chartsList != Value::Null) {
{
let mut i: i64 = 0;
let mut __for_first_1365: bool = true;
while { if !__for_first_1365 { i += 1; } __for_first_1365 = false; i < (chartsList.len() as i64) } {
let mut chartObj: Value = chartsList.as_array().map(Vec::as_slice).unwrap_or_default().get(i as usize).cloned().unwrap_or(Value::Null);
if (self.safe_string_k(chartObj.clone(), "timeframe", &[]).as_str() == bucketKey.as_str()) {
chart = chartObj;
break;
}
}
}
} else {
let mut chartsDict: Value = self.safe_dict_k(selectedOutcome, "price_charts", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
chart = self.safe_dict(chartsDict, bucketKey.clone(), &[]);
}
let mut pointsList: Value = self.safe_list_k(chart.clone(), "prices", &[self.safe_list(chart.clone(), Value::Str("data".into()), &[chart])]);
let mut points: Value = (if (pointsList != Value::Null) { pointsList } else { Value::from(vec![]) });
let mut pointsLength: f64 = ((points.len() as i64) as f64);
if (pointsLength == 0.0) {
let mut priceCharts: Value = self.safe_dict_k(response, "price_charts", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut bucket: Value = self.safe_dict(priceCharts, bucketKey, &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
points = self.safe_list(bucket.clone(), outcomeId, &[self.safe_list_k(bucket, "data", &[Value::from(vec![])])]);
}
let mut usablePoints: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1366: bool = true;
while { if !__for_first_1366 { i += 1; } __for_first_1366 = false; i < (points.len() as i64) } {
let mut point: Value = points.as_array().map(Vec::as_slice).unwrap_or_default().get(i as usize).cloned().unwrap_or(Value::Null);
let mut pointOpen: Option<f64> = self.safe_number_k(point.clone(), "open", &[]).as_f64();
let mut pointPrice: Value = self.safe_number_k(point.clone(), "price", &[self.safe_number(point.clone(), Value::Str("value".into()), &[])]);
let mut pointTs: Option<i64> = self.safe_integer_k(point.clone(), "timestamp", &[]).as_i64();
if ((pointOpen.is_some()) || (pointPrice != Value::Null)) && (pointTs.is_some()) {
usablePoints.push(point);
}
}
}
return self.parse_ohlc_vs(Value::from(usablePoints), &[outcomeObj, timeframe, since, limit]);
Value::Null
}
pub fn parse_ohlcv(&self, mut ohlcv: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut open: Value = self.safe_number_k(ohlcv.clone(), "open", &[]);
let mut high: Value = self.safe_number_k(ohlcv.clone(), "high", &[]);
let mut low: Value = self.safe_number_k(ohlcv.clone(), "low", &[]);
let mut close: Value = self.safe_number_k(ohlcv.clone(), "close", &[]);
let mut price: Value = self.safe_number_k(ohlcv.clone(), "price", &[self.safe_number(ohlcv.clone(), Value::Str("value".into()), &[])]); return Value::from(vec![self.safe_timestamp_k(ohlcv, "timestamp", &[]), (if (open != Value::Null) { open } else { price.clone() }), (if (high != Value::Null) { high } else { price.clone() }), (if (low != Value::Null) { low } else { price.clone() }), (if (close != Value::Null) { close } else { price }), Value::Int(0)]);
Value::Null
}
pub async fn fetch_tickers(&mut self, optional_args: &[Value]) -> Value {
let mut outcomes = 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 (outcomes == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" fetchTickers() requires an outcomes argument — the venue has no all-tickers endpoint; pass the outcome handles to fetch (discover them via fetchEvents ())".into()))));
}
let mut result: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
self.load_outcomes(&[outcomes.clone()]).await;
let mut outcomesByMarket: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut marketKeys: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1367: bool = true;
while { if !__for_first_1367 { i += 1; } __for_first_1367 = false; i < (outcomes.len() as i64) } {
let mut outcomeObj: Value = self.outcome(outcomes.as_array().map(Vec::as_slice).unwrap_or_default().get(i as usize).cloned().unwrap_or(Value::Null));
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info.clone(), "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut key: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId, Value::Str(":".into())).into()), marketId).into());
if !(matches!((&outcomesByMarket, &key), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
if let Value::Dict(__d) = &mut outcomesByMarket { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&key), Value::from(vec![])); }
marketKeys.push(key.clone());
}
let mut grouped: Value = (if let (Some(__m), Some(__k)) = (outcomesByMarket.as_map(), key.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null });
if let Value::Arr(__a) = &mut grouped { std::sync::Arc::make_mut(__a).push(outcomeObj.clone()); };
crate::set_value(&mut outcomesByMarket, &key, grouped.clone());
if let Value::Dict(__d) = &mut outcomesByMarket { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&key), grouped.clone()); }
}
}
let mut promises: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1368: bool = true;
while { if !__for_first_1368 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1368 = false; i.as_f64().unwrap_or(f64::NAN) < ((marketKeys.len() as i64) as f64) } {
let mut key: Value = marketKeys.get((i).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut grouped: Value = (if let (Some(__m), Some(__k)) = (outcomesByMarket.as_map(), key.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null });
let mut firstOutcome: Value = self.safe_dict(grouped.clone(), Value::Int(0), &[]);
let mut info: Value = self.safe_dict_k(firstOutcome, "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let __ws_arg_28 = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), self.safe_string_k(info.clone(), "marketId", &[]));
m.insert("network_id".to_string(), self.safe_string_k(info, "networkId", &[]));
m
}), &[params.clone()]);
promises.push(self.myriad_public_get_markets_id(&[__ws_arg_28]).await);
}
}
let mut responses: Vec<Value> = promise_all(&Value::from(promises)).await.as_array().cloned().unwrap_or_default();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1370: bool = true;
while { if !__for_first_1370 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1370 = false; i.as_f64().unwrap_or(f64::NAN) < ((marketKeys.len() as i64) as f64) } {
let mut key: Value = marketKeys.get((i).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut response: Value = responses.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut grouped: Value = (if let (Some(__m), Some(__k)) = (outcomesByMarket.as_map(), key.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null });
{
let mut j: i64 = 0;
let mut __for_first_1369: bool = true;
while { if !__for_first_1369 { j += 1; } __for_first_1369 = false; j < (grouped.len() as i64) } {
let mut outcomeObj: Value = grouped.as_array().map(Vec::as_slice).unwrap_or_default().get(j as usize).cloned().unwrap_or(Value::Null);
let mut ticker: Value = self.parse_prediction_ticker(response.clone(), &[outcomeObj]);
let mut symbolKey: Option<String> = self.safe_string_k_opt(ticker.clone(), "outcome", &[]);
if (symbolKey.is_some()) {
result.insert(symbolKey.as_deref().unwrap_or("null").to_string(), ticker);
}
}
}
}
}
return Value::Map(result);
Value::Null
}
pub async fn fetch_trades(&mut self, mut outcome: 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 outcomeObj: Value = self.load_outcome(outcome, &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut networkId: Option<String> = self.safe_string_k_opt(info.clone(), "networkId", &[]);
let mut marketId: Option<String> = self.safe_string_k_opt(info.clone(), "marketId", &[]);
let mut outcomeId: Value = self.safe_string_k(info, "outcomeId", &[]);
let mut request: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), marketId.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("network_id".to_string(), networkId.clone().map(Value::from).unwrap_or(Value::Null));
m
});
if (limit != Value::Null) {
request.insert("limit".into(), limit.clone());
}
let __ws_arg_29 = self.extend(Value::Map(request), &[params]);
let mut response: Value = self.myriad_public_get_markets_id_events(&[__ws_arg_29]).await;
let mut responseIsArray: bool = matches!(&response, Value::Arr(_));
let mut rows: Value = (if (responseIsArray) { response.clone() } else { self.safe_list_k(response, "data", &[Value::from(vec![])]) });
let mut trades: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1371: bool = true;
while { if !__for_first_1371 { i += 1; } __for_first_1371 = false; i < (rows.len() as i64) } {
let mut row: Value = self.safe_dict(rows.clone(), Value::Int(i), &[]);
let mut action: Option<String> = self.safe_string_k(row.clone(), "action", &[]).as_str().map(str::to_owned);
if (action.as_deref() != Some("buy")) && (action.as_deref() != Some("sell")) {
continue;
}
let mut rowOutcomeId: Value = self.safe_string_k(row.clone(), "outcomeId", &[]);
if (outcomeId != Value::Null) && (rowOutcomeId != outcomeId) {
continue;
}
trades.push(row);
}
}
return self.parse_prediction_trades(Value::from(trades), &[outcomeObj, since, limit]);
Value::Null
}
pub fn parse_prediction_trade(&self, mut trade: Value, optional_args: &[Value]) -> Value {
let mut market = get_arg(optional_args, 0, Value::Null);
let mut timestamp: Value = self.safe_timestamp_k(trade.clone(), "timestamp", &[]);
let mut amountStr: Option<String> = self.safe_string_k_opt(trade.clone(), "shares", &[]);
let mut costStr: Option<String> = self.safe_string_k_opt(trade.clone(), "value", &[]);
let mut priceStr: Value = Value::Null;
if (amountStr.is_some()) && (costStr.is_some()) && !(crate::precise::Precise::stringEq(&amountStr.clone().map(Value::from).unwrap_or(Value::Null), &Value::Str("0".into())).as_bool() == Some(true)) {
priceStr = crate::precise::Precise::stringDiv(&costStr.clone().map(Value::from).unwrap_or(Value::Null), &amountStr.clone().map(Value::from).unwrap_or(Value::Null));
}
return self.safe_prediction_trade(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), self.safe_string_k(trade.clone(), "txId", &[]));
m.insert("info".to_string(), trade.clone());
m.insert("timestamp".to_string(), timestamp.clone());
m.insert("datetime".to_string(), self.iso8601(timestamp));
m.insert("outcome".to_string(), self.safe_string_k(market.clone(), "outcome", &[]));
m.insert("outcomeId".to_string(), self.safe_string_k(market.clone(), "id", &[]));
m.insert("label".to_string(), self.safe_string_k(market.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(market.clone(), "market", &[]));
m.insert("order".to_string(), Value::Null);
m.insert("type".to_string(), Value::Null);
m.insert("side".to_string(), self.safe_string_k(trade, "action", &[]));
m.insert("takerOrMaker".to_string(), Value::Str("taker".into()));
m.insert("price".to_string(), self.parse_number(priceStr, &[]));
m.insert("amount".to_string(), self.parse_number(amountStr.map(Value::from).unwrap_or(Value::Null), &[]));
m.insert("cost".to_string(), self.parse_number(costStr.map(Value::from).unwrap_or(Value::Null), &[]));
m.insert("fee".to_string(), Value::Null);
m
}), &[market]);
Value::Null
}
pub async fn fetch_events(&mut self, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut allowUnscopedFetchEvents: bool = self.safe_bool_k_opt(self.options.clone(), "allowUnscopedFetchEvents", &[Value::Bool(false)]).unwrap_or(false);
if !(allowUnscopedFetchEvents) {
self.require_event_query(&[params.clone()]);
}
let mut queries: Value = self.parse_search_queries(&[params.clone()]);
let mut rest: Value = self.omit(params.clone(), Value::from(vec![Value::Str("query".into()), Value::Str("queries".into()), Value::Str("sort".into()), Value::Str("searchIn".into()), Value::Str("eventId".into()), Value::Str("slug".into()), Value::Str("status".into()), Value::Str("tags".into())]), &[]);
if (queries == Value::Null) {
panic!("{}", crate::exchange_errors::exchange_error(format!("{}{}", self.id.clone(), Value::Str(" fetchEvents() missing queries".into()))));
}
let mut queriesLength: f64 = ((queries.len() as i64) as f64);
let mut eventId: Option<String> = self.safe_string_k_opt(params.clone(), "eventId", &[]);
let mut rawMarkets: Value = Value::from(vec![]);
let mut rawQuestions: Value = Value::from(vec![]);
if queriesLength > ((0i64) as f64) {
let mut responses: Value = promise_all(&Value::from(vec![self.fetch_raw_markets_by_search(queries.clone(), &[rest.clone()]).await, self.fetch_raw_questions_by_search(queries.clone(), &[rest.clone()]).await])).await;
rawMarkets = self.safe_list(responses.clone(), Value::Int(0), &[Value::from(vec![])]);
rawQuestions = self.safe_list(responses.clone(), Value::Int(1), &[Value::from(vec![])]);
} else if (eventId.is_some()) {
if eventId.as_deref().unwrap_or("").contains(":") {
let mut rawMarket: Value = self.fetch_raw_market_by_id(eventId.clone().map(Value::from).unwrap_or(Value::Null), &[rest.clone()]).await;
rawMarkets = Value::from(vec![rawMarket]);
} else {
let mut rawQuestion: Value = self.fetch_raw_question_by_id(eventId.clone().map(Value::from).unwrap_or(Value::Null), &[rest.clone()]).await;
rawQuestions = Value::from(vec![rawQuestion.clone()]);
}
} else {
let mut requestedTags: Vec<Value> = self.safe_list_k(params.clone(), "tags", &[Value::from(vec![])]).as_array().cloned().unwrap_or_default();
let mut requestedTagsLength: f64 = ((requestedTags.len() as i64) as f64);
if (requestedTagsLength == 0.0) {
let mut listResponses: Value = promise_all(&Value::from(vec![self.fetch_raw_markets_list(&[rest.clone()]).await, self.fetch_raw_questions_list(&[rest.clone()]).await])).await;
rawMarkets = self.safe_list(listResponses.clone(), Value::Int(0), &[Value::from(vec![])]);
rawQuestions = self.safe_list(listResponses, Value::Int(1), &[Value::from(vec![])]);
} else {
let mut tagQueries: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1372: bool = true;
while { if !__for_first_1372 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1372 = false; i.as_f64().unwrap_or(f64::NAN) < requestedTagsLength } {
let mut tagSlug: Value = requestedTags.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
tagQueries.push(replace_all_str(&tagSlug, &Value::Str("-".into()), &Value::Str(" ".into())));
}
}
let mut responses: Value = promise_all(&Value::from(vec![self.fetch_raw_markets_by_search(Value::from(tagQueries.clone()), &[rest.clone()]).await, self.fetch_raw_questions_by_search(Value::from(tagQueries), &[rest]).await])).await;
rawMarkets = self.safe_list(responses.clone(), Value::Int(0), &[Value::from(vec![])]);
rawQuestions = self.safe_list(responses, Value::Int(1), &[Value::from(vec![])]);
}
}
if (self.markets.clone() == Value::Null) {
{ let __t = self.create_safe_dictionary(&[]); self.markets = __t; }
}
let mut seenMarketHandles: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut result: Vec<Value> = Vec::new();
let mut rawQuestionsLength: f64 = ((rawQuestions.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1374: bool = true;
while { if !__for_first_1374 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1374 = false; i.as_f64().unwrap_or(f64::NAN) < rawQuestionsLength } {
let mut rawQuestion: Value = rawQuestions.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 ev: Value = self.parse_event(rawQuestion);
let mut evMarkets: Value = self.safe_list_k(ev.clone(), "markets", &[Value::from(vec![])]);
let mut evMarketsLength: f64 = ((evMarkets.len() as i64) as f64);
let mut filteredMarkets: Value = Value::from(vec![]);
{
let mut j: Value = Value::Int(0);
let mut __for_first_1373: bool = true;
while { if !__for_first_1373 { if let Value::Int(n) = &mut j { *n += 1; } } __for_first_1373 = false; j.as_f64().unwrap_or(f64::NAN) < evMarketsLength } {
let mut m: Value = self.safe_dict(evMarkets.clone(), j.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut marketHandle: Option<String> = self.safe_string_k_opt(m.clone(), "market", &[]);
if (marketHandle.is_some()) {
if (matches!((&seenMarketHandles, &marketHandle.clone().map(Value::from).unwrap_or(Value::Null)), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
continue;
}
if let Value::Dict(__d) = &mut seenMarketHandles { std::sync::Arc::make_mut(__d).insert(marketHandle.as_deref().unwrap_or("null").to_string(), Value::Bool(true)); }
if let Value::Dict(__d) = &mut self.markets { std::sync::Arc::make_mut(__d).insert(marketHandle.as_deref().unwrap_or("null").to_string(), m.clone()); }
}
if let Value::Arr(__a) = &mut filteredMarkets { std::sync::Arc::make_mut(__a).push(m.clone()); }
}
}
let mut filteredMarketsLength: f64 = ((filteredMarkets.len() as i64) as f64);
if (evMarketsLength > ((0i64) as f64)) && (filteredMarketsLength == 0.0) {
continue;
}
add_element_to_object(&mut ev, &Value::Str("markets".into()), filteredMarkets);
result.push(ev.clone());
}
}
let mut rawMarketsLength: f64 = ((rawMarkets.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1375: bool = true;
while { if !__for_first_1375 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1375 = false; i.as_f64().unwrap_or(f64::NAN) < rawMarketsLength } {
let mut raw: Value = rawMarkets.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 m: Value = self.parse_myriad_market(raw.clone(), &[]);
let mut marketHandle: Option<String> = self.safe_string_k_opt(m.clone(), "market", &[]);
if (marketHandle.is_some()) && (matches!((&seenMarketHandles, &marketHandle.clone().map(Value::from).unwrap_or(Value::Null)), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
if let Value::Dict(__d) = &mut self.markets { std::sync::Arc::make_mut(__d).insert(marketHandle.as_deref().unwrap_or("null").to_string(), m.clone()); }
continue;
}
if (marketHandle.is_some()) {
if let Value::Dict(__d) = &mut seenMarketHandles { std::sync::Arc::make_mut(__d).insert(marketHandle.as_deref().unwrap_or("null").to_string(), Value::Bool(true)); }
if let Value::Dict(__d) = &mut self.markets { std::sync::Arc::make_mut(__d).insert(marketHandle.as_deref().unwrap_or("null").to_string(), m.clone()); }
}
let mut ev: Value = self.parse_market_to_event(raw, m);
result.push(ev);
}
}
self.set_events(Value::from(result.clone()));
self.populate_outcomes();
let mut postParams: Value = self.omit(params, Value::from(vec![Value::Str("tags".into())]), &[]);
return self.apply_event_fetch_params(Value::from(result), &[postParams, queries]);
Value::Null
}
pub fn parse_event(&self, mut rawEvent: Value) -> Value {
let mut questionSlug: Value = self.safe_string_k(rawEvent.clone(), "slug", &[self.safe_string(rawEvent.clone(), Value::Str("id".into()), &[])]);
let mut rawMarkets: Vec<Value> = self.safe_list_k(rawEvent.clone(), "markets", &[Value::from(vec![])]).as_array().cloned().unwrap_or_default();
let mut marketsList: Vec<Value> = Vec::new();
{
let mut i: i64 = 0;
let mut __for_first_1376: bool = true;
while { if !__for_first_1376 { i += 1; } __for_first_1376 = false; i < (rawMarkets.len() as i64) } {
let mut rawMarket: Value = rawMarkets.get(i as usize).cloned().unwrap_or(Value::Null);
marketsList.push(self.parse_myriad_market(rawMarket, &[questionSlug.clone()]));
}
}
let mut endDate: Value = self.safe_string_k(rawEvent.clone(), "expiresAt", &[self.safe_string(rawEvent.clone(), Value::Str("endDate".into()), &[])]);
let __ws_arg_30 = self.safe_string_k(rawEvent.clone(), "id", &[]);
let __ws_arg_31 = self.shorten_slug(questionSlug.clone());
let __ws_arg_32 = self.safe_string_k(rawEvent.clone(), "title", &[]);
let __ws_arg_33 = self.safe_string_k(rawEvent.clone(), "description", &[]);
let __ws_arg_34 = self.safe_number2(rawEvent.clone(), Value::Str("volumeNotional24h".into()), Value::Str("volume24h".into()), &[]);
let __ws_arg_35 = self.safe_number_k(rawEvent.clone(), "liquidity", &[]);
let __ws_arg_36 = self.safe_string_k(rawEvent.clone(), "url", &[]);
let __ws_arg_37 = self.safe_string_k(rawEvent.clone(), "imageUrl", &[self.safe_string(rawEvent.clone(), Value::Str("image".into()), &[])]);
let __ws_arg_38 = self.safe_bool_k(rawEvent.clone(), "active", &[]);
let __ws_arg_39 = self.safe_bool_k(rawEvent.clone(), "resolved", &[Value::Bool(false)]);
let __ws_arg_40 = self.safe_string_k(rawEvent.clone(), "category", &[]);
let __ws_arg_41 = self.safe_list_k(rawEvent.clone(), "tags", &[]);
let __ws_arg_42 = self.parse8601(self.safe_string_k(rawEvent.clone(), "createdAt", &[]));
let __ws_arg_43 = self.safe_string_k(rawEvent.clone(), "createdAt", &[]);
let __ws_arg_44 = self.parse8601(endDate.clone());
let __ws_arg_45 = self.parse8601(self.safe_string_k(rawEvent.clone(), "updatedAt", &[]));
let __ws_arg_46 = self.safe_string_k(rawEvent.clone(), "resolutionSource", &[]);
return self.extend(rawEvent.clone(), &[Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), __ws_arg_30);
m.insert("slug".to_string(), questionSlug.clone());
m.insert("event".to_string(), (if ((questionSlug != Value::Null) && (questionSlug.as_str() != Some(""))) { __ws_arg_31 } else { Value::Null }));
m.insert("title".to_string(), __ws_arg_32);
m.insert("description".to_string(), __ws_arg_33);
m.insert("markets".to_string(), Value::from(marketsList));
m.insert("volume".to_string(), __ws_arg_34);
m.insert("liquidity".to_string(), __ws_arg_35);
m.insert("url".to_string(), __ws_arg_36);
m.insert("image".to_string(), __ws_arg_37);
m.insert("active".to_string(), __ws_arg_38);
m.insert("resolved".to_string(), __ws_arg_39);
m.insert("category".to_string(), __ws_arg_40);
m.insert("tags".to_string(), __ws_arg_41);
m.insert("created".to_string(), __ws_arg_42);
m.insert("createdDatetime".to_string(), __ws_arg_43);
m.insert("end".to_string(), (if ((endDate != Value::Null) && (endDate.as_str() != Some(""))) { __ws_arg_44 } else { Value::Null }));
m.insert("endDatetime".to_string(), endDate);
m.insert("lastUpdatedAt".to_string(), __ws_arg_45);
m.insert("resolutionSource".to_string(), __ws_arg_46);
m.insert("info".to_string(), rawEvent);
m
})]);
Value::Null
}
pub fn request_id(&self, mut url: Value) -> Value {
let mut existing: Value = self.safe_value_k(self.options.clone(), "requestId", &[]);
if (existing == Value::Null) {
{ let __be_tmp = self.create_safe_dictionary(&[]); if let Value::Dict(__d) = &mut self.options.clone() { std::sync::Arc::make_mut(__d).insert("requestId".into(), __be_tmp); } }
}
let mut options: Value = self.options.as_map().and_then(|__m| __m.get("requestId")).cloned().unwrap_or(Value::Null);
let mut previousValue: Value = self.safe_integer(options.clone(), url.clone(), &[Value::Int(0)]);
let mut newValue: Value = self.sum(&[previousValue, Value::Int(1)]);
if (url != Value::Null) {
if let Value::Dict(__bf03d0) = unsafe { crate::runtime::coerce_value_to_mut(&self.options) } { let __bf03e1 = std::sync::Arc::make_mut(__bf03d0).entry("requestId".to_string()).or_insert(Value::Null); if let Value::Dict(__r05d) = __bf03e1 { std::sync::Arc::make_mut(__r05d).insert(crate::runtime::stringify_param(&url), newValue.clone()); } }
}
return newValue;
Value::Null
}
pub fn from_wei(&self, mut wei: Value) -> Value {
if (wei == Value::Null) {
return Value::Null;
}
return self.parse_number(crate::precise::Precise::stringDiv(&wei, &Value::Str("1000000000000000000".into())), &[]);
Value::Null
}
pub fn market_outcome_to_symbol(&self, mut networkId: Value, mut marketId: Value, mut outcomeId: Value) -> Option<String> {
if (networkId == Value::Null) || (marketId == Value::Null) || (outcomeId == Value::Null) {
return None;
}
let mut ocId: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId, Value::Str(":".into())).into()), marketId).into()), Value::Str("/".into())).into()), outcomeId).into());
let mut outcomeObj: Value = self.safe_dict(self.exchange.outcomes_by_id.clone(), ocId, &[]);
return self.safe_string_k(outcomeObj, "outcome", &[]).as_str().map(str::to_owned);
}
pub async fn connect_centrifugo(&mut self, mut url: Value) -> Value {
let mut client: Value = self.client(&[url.clone()]);
let __ch = crate::pro::ws_client::ClientHandle::from_value(client.clone());
if !(matches!(&__ch.subscriptions.clone(), Value::Dict(__d) if __d.contains_key("connect"))) {
if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("wsConnected".into(), Value::Bool(false)); }
let mut requestId: Value = self.request_id(url.clone());
let mut connectMsg: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("connect".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("name".to_string(), Value::Str("ccxt".into()));
m
}));
m.insert("id".to_string(), requestId);
m
});
return self.watch(url, Value::Str("centrifugoConnected".into()), &[Value::Map(connectMsg), Value::Str("connect".into())]).await;
}
if matches!(self.safe_bool_k(self.options.clone(), "wsConnected", &[Value::Bool(false)]), Value::Bool(true)) {
return Value::Null;
}
return crate::exchange_stubs::ws_await_flight(&client.future(&[Value::Str("centrifugoConnected".into())])).await;
Value::Null
}
pub async fn pong(&mut self, mut client: Value, optional_args: &[Value]) -> Value {
let mut message = get_arg(optional_args, 0, Value::Null);
client.send(&[Value::Str("{}".into())]);
Value::Null
}
pub async fn subscribe_myriad_channel(&mut self, mut messageHash: 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
}));
let mut url: Option<String> = self.safe_string_opt(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null), Value::Str("ws".into()), &[]);
self.connect_centrifugo(url.clone().map(Value::from).unwrap_or(Value::Null)).await;
let mut requestId: Value = self.request_id(url.clone().map(Value::from).unwrap_or(Value::Null));
let mut subscribeMsg: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("subscribe".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("channel".to_string(), channel.clone());
m
}));
m.insert("id".to_string(), requestId);
m
});
return self.watch(url.map(Value::from).unwrap_or(Value::Null), messageHash, &[Value::Map(subscribeMsg), channel]).await;
Value::Null
}
pub fn handle_text_message(&mut self, mut client: Value, mut message: Value) {
let mut lines: Vec<Value> = Value::Array(if let Some(__s) = message.as_str() { __s.split("\n").map(Value::from).collect() } else { Vec::new() }).as_array().cloned().unwrap_or_default();
let mut linesLength: f64 = ((lines.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1377: bool = true;
while { if !__for_first_1377 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1377 = false; i.as_f64().unwrap_or(f64::NAN) < linesLength } {
let mut line: Value = lines.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
if ((line.len() as i64) as f64) > ((0i64) as f64) {
let mut parsed: Value = json_parse(&line);
self.handle_centrifugo_frame(client.clone(), parsed);
}
}
}
}
pub fn handle_message(&mut self, mut client: Value, mut message: Value) {
self.handle_centrifugo_frame(client, message);
}
pub fn handle_centrifugo_frame(&mut self, mut client: Value, mut msg: Value) {
let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (if let Value::Dict(__d) = &msg { __d.clone() } else { std::sync::Arc::new(indexmap::IndexMap::new()) });
let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
let mut keys: Vec<Value> = object_keys(&msg).as_array().cloned().unwrap_or_default();
let mut keysLength: f64 = ((keys.len() as i64) as f64);
if (keysLength == 0.0) {
self.spawn(&[Value::Null.clone(), client.clone(), msg]);
return;
}
let mut connectReply: Value = (match __pro_message.get("connect").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Null });
if (connectReply != Value::Null) {
if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("wsConnected".into(), Value::Bool(true)); }
client.resolve(&[Value::Bool(true), Value::Str("centrifugoConnected".into())]);
return;
}
let mut push: Value = (match __pro_message.get("push").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Null });
if (push == Value::Null) {
return;
}
let mut channel: Option<String> = self.safe_string_k_opt(push.clone(), "channel", &[]);
if (channel.is_none()) {
return;
}
let mut pub_val: Value = self.safe_dict_k(push, "pub", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut data: Value = self.safe_dict_k(pub_val, "data", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut parts: Value = Value::Array(if let Some(__s) = channel.as_deref() { __s.split(":").map(Value::from).collect() } else { Vec::new() });
let mut channelType: Option<String> = self.safe_string(parts, Value::Int(0), &[]).as_str().map(str::to_owned);
if (channelType.as_deref() == Some("orderbook")) {
self.handle_order_book(client.clone(), data.clone());
} else if (channelType.as_deref() == Some("trades")) {
self.handle_trades(client.clone(), data.clone());
} else if (channelType.as_deref() == Some("prices")) {
self.handle_ticker(client.clone(), data.clone());
} else if (channelType.as_deref() == Some("orders")) {
self.handle_order(client.clone(), data.clone());
} else if (channelType.as_deref() == Some("positions")) {
self.handle_position(client, data);
}
}
pub async fn watch_order_book(&mut self, mut outcome: 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 outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info, "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut sym: Value = self.safe_outcome_symbol(outcome.clone(), &[outcomeObj]);
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("orderbook:".into()), networkId).into()), Value::Str(":".into())).into()), marketId).into());
let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("orderbook::".into()), sym).into());
let mut url: Option<String> = self.safe_string_opt(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null), Value::Str("ws".into()), &[]);
self.connect_centrifugo(url.clone().map(Value::from).unwrap_or(Value::Null)).await;
let mut client: Value = self.client(&[url.clone().map(Value::from).unwrap_or(Value::Null)]);
let __ch = crate::pro::ws_client::ClientHandle::from_value(client.clone());
let mut isNewSubscription: bool = !(__ch.has_subscription(&channel));
if isNewSubscription {
self.seed_order_book(outcome, sym.clone(), &[limit.clone()]).await;
}
let mut requestId: Value = self.request_id(url.clone().map(Value::from).unwrap_or(Value::Null));
let mut subscribeMsg: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("subscribe".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("channel".to_string(), channel.clone());
m
}));
m.insert("id".to_string(), requestId);
m
});
let mut future: Value = self.watch(url.map(Value::from).unwrap_or(Value::Null), messageHash.clone(), &[Value::Map(subscribeMsg), channel]).await;
if isNewSubscription {
client.resolve(&[self.safe_value(self.orderbooks.clone(), sym, &[]), messageHash]);
}
let mut orderbook: Value = crate::exchange_stubs::ws_await_flight(&future).await;
return orderbook.limit();
Value::Null
}
pub async fn seed_order_book(&mut self, mut outcome: Value, mut sym: Value, optional_args: &[Value]) -> Value {
let mut limit = get_arg(optional_args, 0, Value::Null);
let mut snapshot: Value = self.fetch_order_book(outcome, &[limit]).await;
let mut orderbook: Value = self.order_book(&[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
orderbook.reset(snapshot);
if let Value::Dict(__d) = &mut self.orderbooks { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&sym), orderbook); }
Value::Null
}
pub fn handle_order_book(&self, mut client: Value, mut data: Value) {
let __data_empty = indexmap::IndexMap::new();
let data = data.as_map().unwrap_or(&__data_empty);
let mut networkId: Value = (match data.get("networkId") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
let mut marketId: Value = (match data.get("marketId") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
let mut ts: Value = (match data.get("ts") { Some(Value::Int(__n)) => Value::Int(*__n), Some(Value::Float(__f)) => Value::Int(*__f as i64), Some(Value::Str(__s)) => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
let mut changes: Value = (match data.get("changes") { Some(__v) if matches!(__v, Value::Arr(_)) => __v.clone(), _ => Value::from(vec![]) });
let mut changesLength: f64 = ((changes.len() as i64) as f64);
let mut updated: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
{
let mut i: Value = Value::Int(0);
let mut __for_first_1378: bool = true;
while { if !__for_first_1378 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1378 = false; i.as_f64().unwrap_or(f64::NAN) < changesLength } {
let mut change: Value = self.safe_dict(changes.clone(), i.clone(), &[]);
let mut outcomeId: Option<String> = self.safe_string_k_opt(change.clone(), "outcome", &[]);
let mut sym: Value = self.market_outcome_to_symbol(networkId.clone(), marketId.clone(), outcomeId.map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
if (sym == Value::Null) {
continue;
}
if (self.safe_value(self.orderbooks.clone(), sym.clone(), &[]) == Value::Null) {
continue;
}
let mut orderbook: Value = (if let (Some(__m), Some(__k)) = (self.orderbooks.as_map(), sym.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null });
let mut price: Value = self.from_wei(self.safe_string_k(change.clone(), "price", &[]));
let mut amount: Value = self.from_wei(self.safe_string_k(change.clone(), "amount", &[]));
let mut sideStr: Option<String> = self.safe_string_k(change, "side", &[]).as_str().map(str::to_owned);
let mut bookSide: Value = (if (sideStr.as_deref() == Some("bid")) { orderbook.book_field("bids") } else { orderbook.book_field("asks") });
bookSide.store_array(Value::from(vec![price, amount]));
orderbook.set_book_meta("timestamp", ts.clone());
orderbook.set_book_meta("datetime", self.iso8601(ts.clone()));
if let Value::Dict(__d) = &mut updated { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&sym), Value::Bool(true)); }
}
}
let mut updatedSymbols: Vec<Value> = Value::Array(updated.as_map().map(|__m| __m.keys().map(|__k| Value::Str(__k.clone().into())).collect()).unwrap_or_default()).as_array().cloned().unwrap_or_default();
let mut updatedLength: f64 = ((updatedSymbols.len() as i64) as f64);
{
let mut k: Value = Value::Int(0);
let mut __for_first_1379: bool = true;
while { if !__for_first_1379 { if let Value::Int(n) = &mut k { *n += 1; } } __for_first_1379 = false; k.as_f64().unwrap_or(f64::NAN) < updatedLength } {
let mut sym: Value = updatedSymbols.get(k.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
client.resolve(&[(if let (Some(__m), Some(__k)) = (self.orderbooks.as_map(), sym.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null }), Value::Str(format!("{}{}", Value::Str("orderbook::".into()), sym).into())]);
}
}
}
pub async fn watch_trades(&mut self, mut outcome: 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 outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info, "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut sym: Value = self.safe_outcome_symbol(outcome, &[outcomeObj]);
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("trades:".into()), networkId).into()), Value::Str(":".into())).into()), marketId).into());
let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("trades::".into()), sym).into());
let mut trades: Value = self.subscribe_myriad_channel(messageHash, channel, &[params]).await;
return self.filter_by_since_limit(trades, &[since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);
Value::Null
}
pub async fn watch_my_trades(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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 (outcome == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchMyTrades() requires a outcome (the trades channel is per-market)".into()))));
}
let mut outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info, "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut sym: Value = self.safe_outcome_symbol(outcome, &[outcomeObj]);
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("trades:".into()), networkId).into()), Value::Str(":".into())).into()), marketId).into());
let mut messageHash: String = "myTrades".to_string();
let mut trades: Value = self.subscribe_myriad_channel(Value::from(messageHash), channel, &[params]).await;
return self.filter_by_value_since_limit(trades, Value::Str("outcome".into()), &[sym, since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);
Value::Null
}
pub fn wallet_address_or_undefined(&self) -> Option<String> {
if (self.walletAddress.clone() != Value::Null) && (self.walletAddress.as_str() != Some("")) {
return (if let Some(__s) = self.walletAddress.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str().map(str::to_owned);
}
if (self.privateKey.clone() != Value::Null) {
return (self.eth_get_address_from_private_key(self.privateKey.clone(), &[])).as_str().map(|__s| Value::Str(__s.to_lowercase().into())).unwrap_or(Value::Null).as_str().map(str::to_owned);
}
return None;
}
pub fn handle_trades(&mut self, mut client: Value, mut data: Value) {
let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (if let Value::Dict(__d) = &data { __d.clone() } else { std::sync::Arc::new(indexmap::IndexMap::new()) });
let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
let mut networkId: Option<String> = match __pro_message.get("networkId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut marketId: Option<String> = match __pro_message.get("marketId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut ts: Value = (match __pro_message.get("ts").cloned() { Some(Value::Int(__n)) => Value::Int(__n), Some(Value::Float(__f)) => Value::Int(__f as i64), Some(Value::Str(__s)) if !__s.is_empty() => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
let mut txHash: Option<String> = match __pro_message.get("txHash").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut taker: Value = (match __pro_message.get("taker").cloned() { Some(__v) if matches!(__v, Value::Dict(_)) => __v, _ => Value::Map({
let mut m = indexmap::IndexMap::new();
m
}) });
let mut outcomeId: Option<String> = self.safe_string_k_opt(taker.clone(), "outcome", &[]);
let mut sym: Value = self.market_outcome_to_symbol(networkId.clone().map(Value::from).unwrap_or(Value::Null), marketId.clone().map(Value::from).unwrap_or(Value::Null), outcomeId.clone().map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
if (sym == Value::Null) {
return;
}
let mut market: Value = self.safe_market(&[sym.clone()]);
let mut outcomeObj: Value = self.safe_outcome(sym.clone(), &[]);
let mut fees: Value = self.safe_dict_k(taker.clone(), "totalFees", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut trade: Value = self.safe_prediction_trade(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), txHash.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("info".to_string(), data);
m.insert("timestamp".to_string(), ts.clone());
m.insert("datetime".to_string(), self.iso8601(ts.clone()));
m.insert("outcome".to_string(), sym.clone());
m.insert("outcomeId".to_string(), self.safe_string2(outcomeObj.clone(), Value::Str("outcomeId".into()), Value::Str("id".into()), &[]));
m.insert("label".to_string(), self.safe_string_k(outcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(outcomeObj, "market", &[]));
m.insert("order".to_string(), self.safe_string_k(taker.clone(), "orderHash", &[]));
m.insert("type".to_string(), Value::Null);
m.insert("side".to_string(), self.safe_string_lower_k(taker.clone(), "side", &[]));
m.insert("takerOrMaker".to_string(), Value::Str("taker".into()));
m.insert("price".to_string(), self.safe_number_k(taker.clone(), "averagePrice", &[]));
m.insert("amount".to_string(), self.safe_number_k(taker.clone(), "totalAmount", &[]));
m.insert("cost".to_string(), Value::Null);
m.insert("fee".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), self.safe_number_k(fees, "total", &[]));
m.insert("currency".to_string(), self.safe_string_k(market.clone(), "quote", &[]));
m
}));
m
}), &[market]);
if (self.trades.clone() == Value::Null) {
{ let __t = self.create_safe_dictionary(&[]); self.trades = __t; }
}
if (self.safe_value(self.trades.clone(), sym.clone(), &[]) == Value::Null) {
let mut tradesLimit: Value = self.safe_integer_k(self.options.clone(), "tradesLimit", &[Value::Int(1000)]);
if let Value::Dict(__d) = &mut self.trades { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&sym), ArrayCache::new(tradesLimit)); }
}
let mut stored: Value = (if let (Some(__m), Some(__k)) = (self.trades.as_map(), sym.as_str()) { __m.get(__k).cloned().unwrap_or(Value::Null) } else { Value::Null });
stored.append(trade.clone());
client.resolve(&[stored, Value::Str(format!("{}{}", Value::Str("trades::".into()), sym).into())]);
let mut myWallet: Value = self.wallet_address_or_undefined().map(Value::from).unwrap_or(Value::Null);
if (myWallet != Value::Null) {
let mut myLegs: Vec<Value> = Vec::new();
let mut takerTrader: Value = self.safe_string_lower_k(taker, "trader", &[]);
if (takerTrader == myWallet) {
myLegs.push(trade);
}
let mut makers: Vec<Value> = (match __pro_message.get("makers").cloned() { Some(__v) if matches!(__v, Value::Arr(_)) => __v, _ => Value::from(vec![]) }).as_array().cloned().unwrap_or_default();
let mut makersLength: f64 = ((makers.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1380: bool = true;
while { if !__for_first_1380 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1380 = false; i.as_f64().unwrap_or(f64::NAN) < makersLength } {
let mut maker: Value = makers.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut makerTrader: Value = self.safe_string_lower_k(maker.clone(), "trader", &[]);
if (makerTrader == myWallet) {
let mut makerSym: Value = self.market_outcome_to_symbol(networkId.clone().map(Value::from).unwrap_or(Value::Null), marketId.clone().map(Value::from).unwrap_or(Value::Null), self.safe_string_k(maker.clone(), "outcome", &[])).map(Value::from).unwrap_or(Value::Null);
let mut makerMarket: Value = self.safe_market(&[makerSym.clone()]);
let mut makerOutcomeObj: Value = self.safe_outcome(makerSym.clone(), &[]);
let mut makerFees: Value = self.safe_dict_k(maker.clone(), "fees", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let mut makerTrade: Value = self.safe_prediction_trade(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), txHash.clone().map(Value::from).unwrap_or(Value::Null));
m.insert("info".to_string(), maker.clone());
m.insert("timestamp".to_string(), ts.clone());
m.insert("datetime".to_string(), self.iso8601(ts.clone()));
m.insert("outcome".to_string(), makerSym);
m.insert("outcomeId".to_string(), self.safe_string_k(makerOutcomeObj.clone(), "id", &[]));
m.insert("label".to_string(), self.safe_string_k(makerOutcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(makerOutcomeObj, "market", &[]));
m.insert("order".to_string(), self.safe_string_k(maker.clone(), "orderHash", &[]));
m.insert("type".to_string(), Value::Null);
m.insert("side".to_string(), self.safe_string_lower_k(maker.clone(), "side", &[]));
m.insert("takerOrMaker".to_string(), Value::Str("maker".into()));
m.insert("price".to_string(), self.safe_number_k(maker.clone(), "price", &[]));
m.insert("amount".to_string(), self.safe_number_k(maker, "amount", &[]));
m.insert("cost".to_string(), Value::Null);
m.insert("fee".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("cost".to_string(), self.safe_number_k(makerFees, "total", &[]));
m.insert("currency".to_string(), self.safe_string_k(makerMarket.clone(), "quote", &[]));
m
}));
m
}), &[makerMarket]);
myLegs.push(makerTrade);
}
}
}
let mut myLegsLength: f64 = ((myLegs.len() as i64) as f64);
if myLegsLength > ((0i64) as f64) {
if (self.myTrades.clone() == Value::Null) {
let mut myTradesLimit: Value = self.safe_integer_k(self.options.clone(), "myTradesLimit", &[Value::Int(1000)]);
self.myTrades = ArrayCacheByOutcomeById::new(myTradesLimit);
}
let mut myStored: Value = self.myTrades.clone();
{
let mut k: Value = Value::Int(0);
let mut __for_first_1381: bool = true;
while { if !__for_first_1381 { if let Value::Int(n) = &mut k { *n += 1; } } __for_first_1381 = false; k.as_f64().unwrap_or(f64::NAN) < myLegsLength } {
myStored.append(myLegs.get((k).as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null));
}
}
client.resolve(&[myStored, Value::Str("myTrades".into())]);
}
}
}
pub async fn watch_ticker(&mut self, mut outcome: Value, optional_args: &[Value]) -> Value {
let mut params = get_arg(optional_args, 0, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut outcomeObj: Value = self.load_outcome(outcome.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info, "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut sym: Value = self.safe_outcome_symbol(outcome, &[outcomeObj]);
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("prices:".into()), networkId).into()), Value::Str(":".into())).into()), marketId).into());
let mut messageHash: Value = Value::Str(format!("{}{}", Value::Str("ticker::".into()), sym).into());
return self.subscribe_myriad_channel(messageHash, channel, &[params]).await;
Value::Null
}
pub async fn watch_tickers(&mut self, optional_args: &[Value]) -> Value {
let mut outcomes = 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 (outcomes == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" watchTickers() requires a list of outcomes (the prices channel is per-market)".into()))));
}
let mut symbolsLength: f64 = ((outcomes.len() as i64) as f64);
let mut url: Option<String> = self.safe_string_opt(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null), Value::Str("ws".into()), &[]);
self.connect_centrifugo(url.clone().map(Value::from).unwrap_or(Value::Null)).await;
self.load_outcomes(&[outcomes.clone()]).await;
let mut client: Value = self.client(&[url.clone().map(Value::from).unwrap_or(Value::Null)]);
let mut seenChannels: Value = Value::Map({
let mut m = indexmap::IndexMap::new();
m
});
let mut resolvedSymbols: Vec<Value> = Vec::new();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1382: bool = true;
while { if !__for_first_1382 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1382 = false; i.as_f64().unwrap_or(f64::NAN) < symbolsLength } {
let mut outcomeObj: Value = self.outcome(outcomes.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 info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
let networkId: String = self.safe_string_k_opt(info.clone(), "networkId", &[Value::Str("".into())]).unwrap_or_default();
let marketId: String = self.safe_string_k_opt(info, "marketId", &[Value::Str("".into())]).unwrap_or_default();
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("prices:".into()), networkId).into()), Value::Str(":".into())).into()), marketId).into());
resolvedSymbols.push(self.safe_outcome_symbol(outcomes.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), &[outcomeObj]));
if !(matches!((&seenChannels, &channel), (Value::Dict(__d), Value::Str(__k)) if __d.contains_key(__k.as_ref()))) {
if let Value::Dict(__d) = &mut seenChannels { std::sync::Arc::make_mut(__d).insert(crate::runtime::stringify_param(&channel), Value::Bool(true)); }
let mut requestId: Value = self.request_id(url.clone().map(Value::from).unwrap_or(Value::Null));
let mut subscribeMsg: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("subscribe".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("channel".to_string(), channel.clone());
m
}));
m.insert("id".to_string(), requestId);
m
});
self.watch(url.clone().map(Value::from).unwrap_or(Value::Null), Value::Str("tickers".into()), &[Value::Map(subscribeMsg), channel.clone()]).await;
}
}
}
let mut tickers: Value = crate::exchange_stubs::ws_await_flight(&client.future(&[Value::Str("tickers".into())])).await;
return self.filter_by_array(tickers, Value::Str("outcome".into()), &[Value::from(resolvedSymbols), Value::Bool(true)]);
Value::Null
}
pub async fn watch_ohlcv(&mut self, mut outcome: Value, optional_args: &[Value]) -> Value {
let mut timeframe = get_arg(optional_args, 0, Value::Str("1m".into()));
let mut since = get_arg(optional_args, 1, Value::Null);
let mut limit = get_arg(optional_args, 2, Value::Null);
let mut params = get_arg(optional_args, 3, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let mut trades: Value = self.watch_trades(outcome, &[since.clone(), limit.clone(), params]).await;
let mut ohlcvc: Vec<Value> = self.build_ohlcvc(trades, &[timeframe, Value::Int(0), Value::Int(2147483647)]).as_array().cloned().unwrap_or_default();
let mut result: Vec<Value> = Vec::new();
let mut ohlcvcLength: f64 = ((ohlcvc.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1383: bool = true;
while { if !__for_first_1383 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1383 = false; i.as_f64().unwrap_or(f64::NAN) < ohlcvcLength } {
let mut candle: Value = ohlcvc.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
result.push(Value::from(vec![candle.as_array().and_then(|__arr| __arr.get(0)).cloned().unwrap_or(Value::Null), candle.as_array().and_then(|__arr| __arr.get(1)).cloned().unwrap_or(Value::Null), candle.as_array().and_then(|__arr| __arr.get(2)).cloned().unwrap_or(Value::Null),
candle.as_array().and_then(|__arr| __arr.get(3)).cloned().unwrap_or(Value::Null), candle.as_array().and_then(|__arr| __arr.get(4)).cloned().unwrap_or(Value::Null), candle.as_array().and_then(|__arr| __arr.get(5)).cloned().unwrap_or(Value::Null)]));
}
}
return self.filter_by_since_limit(Value::from(result), &[since, limit, Value::Int(0), Value::Bool(true)]);
Value::Null
}
pub fn handle_ticker(&self, mut client: Value, mut data: Value) {
let __data_empty = indexmap::IndexMap::new();
let data = data.as_map().unwrap_or(&__data_empty);
let mut networkId: Value = (match data.get("networkId") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
let mut marketId: Value = (match data.get("marketId") { Some(Value::Str(__s)) if !__s.is_empty() => Value::Str(__s.clone()), Some(Value::Int(__n)) => Value::Str(__n.to_string().into()), Some(Value::Float(__f)) => Value::Str(__f.to_string().into()), _ => Value::Null });
let mut ts: Value = (match data.get("ts") { Some(Value::Int(__n)) => Value::Int(*__n), Some(Value::Float(__f)) => Value::Int(*__f as i64), Some(Value::Str(__s)) => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
let mut outcomes: Vec<Value> = (match data.get("outcomes") { Some(__v) if matches!(__v, Value::Arr(_)) => __v.clone(), _ => Value::from(vec![]) }).as_array().cloned().unwrap_or_default();
let mut outcomesLength: f64 = ((outcomes.len() as i64) as f64);
let mut cachedTickers: indexmap::IndexMap<String, Value> = self.safe_dict_k(self.options.clone(), "wsTickers", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]).as_map().cloned().unwrap_or_default();
{
let mut i: Value = Value::Int(0);
let mut __for_first_1384: bool = true;
while { if !__for_first_1384 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1384 = false; i.as_f64().unwrap_or(f64::NAN) < outcomesLength } {
let mut oc: Value = outcomes.get(i.as_i64().unwrap_or(-1) as usize).cloned().unwrap_or(Value::Null);
let mut outcomeId: Option<String> = self.safe_string_k_opt(oc.clone(), "outcome", &[]);
let mut sym: Value = self.market_outcome_to_symbol(networkId.clone(), marketId.clone(), outcomeId.map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
if (sym == Value::Null) {
continue;
}
let mut market: Value = self.safe_market(&[sym.clone()]);
let mut outcomeObj: Value = self.safe_outcome(sym.clone(), &[]);
let mut last: Value = self.from_wei(self.safe_string_k(oc.clone(), "last", &[]));
let mut ticker: Value = self.safe_prediction_ticker(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("outcome".to_string(), sym.clone());
m.insert("outcomeId".to_string(), self.safe_string2(outcomeObj.clone(), Value::Str("outcomeId".into()), Value::Str("id".into()), &[]));
m.insert("label".to_string(), self.safe_string_k(outcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(outcomeObj, "market", &[]));
m.insert("timestamp".to_string(), ts.clone());
m.insert("datetime".to_string(), self.iso8601(ts.clone()));
m.insert("high".to_string(), Value::Null);
m.insert("low".to_string(), Value::Null);
m.insert("bid".to_string(), self.from_wei(self.safe_string_k(oc.clone(), "bestBid", &[])));
m.insert("bidVolume".to_string(), Value::Null);
m.insert("ask".to_string(), self.from_wei(self.safe_string_k(oc.clone(), "bestAsk", &[])));
m.insert("askVolume".to_string(), Value::Null);
m.insert("vwap".to_string(), Value::Null);
m.insert("open".to_string(), Value::Null);
m.insert("close".to_string(), last.clone());
m.insert("last".to_string(), last);
m.insert("previousClose".to_string(), Value::Null);
m.insert("change".to_string(), Value::Null);
m.insert("percentage".to_string(), Value::Null);
m.insert("average".to_string(), Value::Null);
m.insert("baseVolume".to_string(), Value::Null);
m.insert("quoteVolume".to_string(), Value::Null);
m.insert("info".to_string(), oc);
m
}), &[market]);
cachedTickers.insert(crate::runtime::stringify_param(&sym), ticker.clone());
client.resolve(&[ticker, Value::Str(format!("{}{}", Value::Str("ticker::".into()), sym).into())]);
}
}
if let Value::Dict(__d) = &mut self.options.clone() { std::sync::Arc::make_mut(__d).insert("wsTickers".into(), Value::Map(cachedTickers.clone())); }
client.resolve(&[Value::Map(cachedTickers), Value::Str("tickers".into())]);
}
pub async fn watch_orders(&mut self, optional_args: &[Value]) -> Value {
let mut outcome = 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
}));
let mut trader: Value = self.wallet_address_from_keys().map(Value::from).unwrap_or(Value::Null);
let mut networkId: Value = self.safe_string_k(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())]);
let mut outcomeResolved: Value = outcome;
if (outcomeResolved != Value::Null) {
let mut outcomeObj: Value = self.load_outcome(outcomeResolved.clone(), &[]).await;
let mut info: Value = self.safe_dict_k(outcomeObj.clone(), "info", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]);
networkId = self.safe_string_k(info, "networkId", &[networkId.clone()]);
outcomeResolved = self.safe_outcome_symbol(outcomeResolved.clone(), &[outcomeObj]);
}
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("orders:".into()), networkId).into()), Value::Str(":".into())).into()), trader).into());
let mut messageHash: String = "orders".to_string();
let mut orders: Value = self.subscribe_myriad_channel(Value::from(messageHash), channel, &[params]).await;
return self.filter_by_value_since_limit(orders, Value::Str("outcome".into()), &[outcomeResolved, since, limit, Value::Str("timestamp".into()), Value::Bool(true)]);
Value::Null
}
pub fn handle_order(&mut self, mut client: Value, mut data: Value) {
let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (if let Value::Dict(__d) = &data { __d.clone() } else { std::sync::Arc::new(indexmap::IndexMap::new()) });
let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
if (self.orders.clone() == Value::Null) {
let mut limit: Value = self.safe_integer_k(self.options.clone(), "ordersLimit", &[Value::Int(1000)]);
self.orders = ArrayCacheByOutcomeById::new(limit);
}
let mut networkId: Option<String> = match __pro_message.get("networkId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut marketId: Option<String> = match __pro_message.get("marketId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut outcomeId: Option<String> = match __pro_message.get("outcome").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut sym: Value = self.market_outcome_to_symbol(networkId.map(Value::from).unwrap_or(Value::Null), marketId.map(Value::from).unwrap_or(Value::Null), outcomeId.map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
let mut outcomeObj: Value = self.safe_outcome(sym.clone(), &[]);
let mut price: Value = self.from_wei((match __pro_message.get("price").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 amount: Value = self.from_wei((match __pro_message.get("amount").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 filled: Value = self.from_wei((match __pro_message.get("filledAmount").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 status: Value = self.parse_order_status(self.safe_string_lower_k(data.clone(), "status", &[])).map(Value::from).unwrap_or(Value::Null);
let mut tif: Option<String> = self.safe_string_upper_k_opt(data.clone(), "timeInForce", &[]);
let mut isMarketTif: bool = (tif.as_deref() == Some("FOK")) || (tif.as_deref() == Some("FAK"));
let mut timestamp: Value = self.parse8601(self.safe_string2(data.clone(), Value::Str("updatedAt".into()), Value::Str("createdAt".into()), &[]));
let mut parsed: Value = self.safe_prediction_order(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("id".to_string(), (match __pro_message.get("orderHash").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 }));
m.insert("clientOrderId".to_string(), Value::Null);
m.insert("info".to_string(), data.clone());
m.insert("timestamp".to_string(), timestamp.clone());
m.insert("datetime".to_string(), self.iso8601(timestamp));
m.insert("outcome".to_string(), sym.clone());
m.insert("outcomeId".to_string(), self.safe_string2(outcomeObj.clone(), Value::Str("outcomeId".into()), Value::Str("id".into()), &[]));
m.insert("label".to_string(), self.safe_string_k(outcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(outcomeObj, "market", &[]));
m.insert("type".to_string(), (if isMarketTif { Value::Str("market".into()) } else { Value::Str("limit".into()) }));
m.insert("timeInForce".to_string(), tif.map(Value::from).unwrap_or(Value::Null));
m.insert("side".to_string(), self.safe_string_lower_k(data, "side", &[]));
m.insert("price".to_string(), price);
m.insert("amount".to_string(), amount);
m.insert("filled".to_string(), filled);
m.insert("remaining".to_string(), Value::Null);
m.insert("average".to_string(), Value::Null);
m.insert("cost".to_string(), Value::Null);
m.insert("status".to_string(), status);
m.insert("fee".to_string(), Value::Null);
m.insert("trades".to_string(), Value::Null);
m
}), &[]);
let mut stored: Value = self.orders.clone();
stored.append(parsed);
client.resolve(&[stored.clone(), Value::Str("orders".into())]);
if (sym != Value::Null) {
client.resolve(&[stored, Value::Str(format!("{}{}", Value::Str("orders::".into()), sym).into())]);
}
}
pub async fn watch_positions(&mut self, optional_args: &[Value]) -> Value {
let mut outcomes = 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 (outcomes != Value::Null) {
self.load_outcomes(&[outcomes.clone()]).await;
}
let mut trader: Value = self.wallet_address_from_keys().map(Value::from).unwrap_or(Value::Null);
let networkId: String = self.safe_string_k_opt(self.options.clone(), "defaultNetworkId", &[Value::Str("56".into())]).unwrap_or_default();
let mut channel: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str("positions:".into()), networkId).into()), Value::Str(":".into())).into()), trader).into());
let mut messageHash: String = "positions".to_string();
let mut url: Option<String> = self.safe_string_opt(self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null), Value::Str("ws".into()), &[]);
self.connect_centrifugo(url.clone().map(Value::from).unwrap_or(Value::Null)).await;
let mut client: Value = self.client(&[url.clone().map(Value::from).unwrap_or(Value::Null)]);
let __ch = crate::pro::ws_client::ClientHandle::from_value(client.clone());
let mut isNewSubscription: bool = !(__ch.has_subscription(&channel));
if isNewSubscription {
self.seed_position_balances(trader).await;
}
let mut requestId: Value = self.request_id(url.clone().map(Value::from).unwrap_or(Value::Null));
let mut subscribeMsg: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m.insert("subscribe".to_string(), Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("channel".to_string(), channel.clone());
m
}));
m.insert("id".to_string(), requestId);
m
});
let mut positions: Value = self.watch(url.map(Value::from).unwrap_or(Value::Null), Value::from(messageHash), &[Value::Map(subscribeMsg), channel]).await;
if self.newUpdates.as_bool() == Some(true) {
return positions;
}
return self.filter_by_outcomes_since_limit(positions, &[outcomes, since, limit, Value::Bool(true)]);
Value::Null
}
pub async fn seed_position_balances(&mut self, mut trader: Value) -> Value {
let mut positions: Value = self.fetch_positions(&[Value::Null, Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("address".to_string(), trader);
m
})]).await;
let mut balances: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
let mut positionsLength: f64 = ((positions.len() as i64) as f64);
{
let mut i: Value = Value::Int(0);
let mut __for_first_1385: bool = true;
while { if !__for_first_1385 { if let Value::Int(n) = &mut i { *n += 1; } } __for_first_1385 = false; i.as_f64().unwrap_or(f64::NAN) < positionsLength } {
let mut p: Value = self.safe_dict(positions.clone(), i.clone(), &[]);
let mut id: Option<String> = self.safe_string_k_opt(p.clone(), "id", &[]);
if (id.is_some()) {
balances.insert(id.as_deref().unwrap_or("null").to_string(), self.number_to_string(self.safe_number_k(p, "contracts", &[Value::Int(0)])));
}
}
}
if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("positionBalances".into(), Value::Map(balances)); }
Value::Null
}
pub fn handle_position(&mut self, mut client: Value, mut data: Value) {
let __pro_message_arc: std::sync::Arc<indexmap::IndexMap<String, Value>> = (if let Value::Dict(__d) = &data { __d.clone() } else { std::sync::Arc::new(indexmap::IndexMap::new()) });
let __pro_message: &indexmap::IndexMap<String, Value> = &__pro_message_arc;
if (self.positions.clone() == Value::Null) {
let mut limit: Value = self.safe_integer_k(self.options.clone(), "positionsLimit", &[Value::Int(1000)]);
self.positions = ArrayCacheByOutcomeById::new(limit);
}
let mut networkId: Option<String> = match __pro_message.get("networkId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut marketId: Option<String> = match __pro_message.get("marketId").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut outcomeId: Option<String> = match __pro_message.get("outcome").cloned() { Some(Value::Str(__s)) if !__s.is_empty() => Some(__s.to_string()), Some(Value::Int(__n)) => Some(__n.to_string()), Some(Value::Float(__f)) => Some(__f.to_string()), _ => None };
let mut sym: Value = self.market_outcome_to_symbol(networkId.clone().map(Value::from).unwrap_or(Value::Null), marketId.clone().map(Value::from).unwrap_or(Value::Null), outcomeId.clone().map(Value::from).unwrap_or(Value::Null)).map(Value::from).unwrap_or(Value::Null);
let mut outcomeObj: Value = self.safe_outcome(sym.clone(), &[]);
let mut ts: Value = (match __pro_message.get("ts").cloned() { Some(Value::Int(__n)) => Value::Int(__n), Some(Value::Float(__f)) => Value::Int(__f as i64), Some(Value::Str(__s)) if !__s.is_empty() => match __s.parse::<i64>() { Ok(__n) => Value::Int(__n), Err(_) => match __s.parse::<f64>() { Ok(__f) if __f.is_finite() => Value::Int(__f as i64), _ => Value::Null } }, _ => Value::Null });
let mut deltaStr: Value = (match __pro_message.get("delta").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::Str("0".into()) });
let mut firstChar: Value = deltaStr.as_str().map(|__s| { let __c: Vec<char> = __s.chars().collect(); let __l = __c.len() as i64; let __i = __l.min(0); let __j = __l.min(1); if __i <= __j { __c[__i as usize..__j as usize].iter().collect::<String>() } else { String::new() } }).map(Value::from).unwrap_or(Value::Null);
if (firstChar.as_str() == Some("+")) {
deltaStr = deltaStr.as_str().map(|__s| { let __c: Vec<char> = __s.chars().collect(); let __l = __c.len() as i64; let __i = __l.min(1); let __j = __l; if __i <= __j { __c[__i as usize..__j as usize].iter().collect::<String>() } else { String::new() } }).map(Value::from).unwrap_or(Value::Null);
}
let mut deltaShares: Value = crate::precise::Precise::stringDiv(&deltaStr, &Value::Str("1000000000000000000".into()));
let mut contracts: Value = Value::Null;
let mut posId: Value = Value::Null;
if (networkId.is_some()) && (marketId.is_some()) && (outcomeId.is_some()) {
posId = Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", Value::Str(format!("{}{}", networkId.map(Value::from).unwrap_or(Value::Null), Value::Str(":".into())).into()), marketId.map(Value::from).unwrap_or(Value::Null)).into()), Value::Str("/".into())).into()), outcomeId.map(Value::from).unwrap_or(Value::Null)).into());
let mut balances: indexmap::IndexMap<String, Value> = self.safe_dict_k(self.options.clone(), "positionBalances", &[Value::Map({
let mut m = indexmap::IndexMap::new();
m
})]).as_map().cloned().unwrap_or_default();
let mut prior: Value = self.safe_string(Value::Map(balances.clone()), posId.clone(), &[Value::Str("0".into())]);
let mut updated: Value = crate::precise::Precise::stringAdd(&prior, &deltaShares);
if (posId != Value::Null) {
balances.insert(crate::runtime::stringify_param(&posId), updated.clone());
}
if let Value::Dict(__d) = &mut self.options { std::sync::Arc::make_mut(__d).insert("positionBalances".into(), Value::Map(balances)); }
contracts = self.parse_number(updated, &[]);
}
let mut parsed: Value = self.safe_prediction_position(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("info".to_string(), data);
m.insert("id".to_string(), posId.clone());
m.insert("outcome".to_string(), sym);
m.insert("outcomeId".to_string(), posId);
m.insert("label".to_string(), self.safe_string_k(outcomeObj.clone(), "label", &[]));
m.insert("market".to_string(), self.safe_string_k(outcomeObj, "market", &[]));
m.insert("timestamp".to_string(), ts.clone());
m.insert("datetime".to_string(), self.iso8601(ts));
m.insert("side".to_string(), Value::Str("long".into()));
m.insert("contracts".to_string(), contracts);
m.insert("entryPrice".to_string(), Value::Null);
m.insert("markPrice".to_string(), Value::Null);
m.insert("notional".to_string(), Value::Null);
m.insert("collateral".to_string(), Value::Null);
m.insert("unrealizedPnl".to_string(), Value::Null);
m
}));
let mut stored: Value = self.positions.clone();
stored.append(parsed);
client.resolve(&[stored, Value::Str("positions".into())]);
}
pub fn wallet_address_from_keys(&self) -> Option<String> {
if (self.walletAddress.clone() != Value::Null) && (self.walletAddress.as_str() != Some("")) {
return (if let Some(__s) = self.walletAddress.as_str() { Value::Str(__s.to_lowercase().into()) } else { Value::Null }).as_str().map(str::to_owned);
}
if (self.privateKey.clone() == Value::Null) {
panic!("{}", crate::exchange_errors::arguments_required(format!("{}{}", self.id.clone(), Value::Str(" requires a walletAddress or privateKey to watch private channels".into()))));
}
return (self.eth_get_address_from_private_key(self.privateKey.clone(), &[])).as_str().map(|__s| Value::Str(__s.to_lowercase().into())).unwrap_or(Value::Null).as_str().map(str::to_owned);
}
pub fn handle_errors(&self, mut code: Value, mut reason: Value, mut url: Value, mut method: Value, mut headers: Value, mut body: Value, mut response: Value, mut requestHeaders: Value, mut requestBody: Value) -> Value {
if (response == Value::Null) {
return Value::Null;
}
let mut error: Option<String> = self.safe_string_k_opt(response, "error", &[]);
if (error.is_none()) || (error.as_deref() == Some("")) {
return Value::Null;
}
let mut feedback: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", self.id.clone(), Value::Str(" ".into())).into()), body).into());
self.throw_exactly_matched_exception(self.exceptions.as_map().and_then(|__m| __m.get("exact")).cloned().unwrap_or(Value::Null), error.clone().map(Value::from).unwrap_or(Value::Null), feedback.clone());
self.throw_broadly_matched_exception(self.exceptions.as_map().and_then(|__m| __m.get("broad")).cloned().unwrap_or(Value::Null), error.map(Value::from).unwrap_or(Value::Null), feedback.clone());
panic!("{}", crate::exchange_errors::exchange_error(feedback));
Value::Null
}
pub fn sign(&self, mut path: Value, optional_args: &[Value]) -> Value {
let mut api = get_arg(optional_args, 0, Value::from(vec![Value::Str("myriad".into())]));
let mut method = get_arg(optional_args, 1, Value::Str("GET".into()));
let mut params = get_arg(optional_args, 2, Value::Map({
let mut m = indexmap::IndexMap::new();
m
}));
let __api_empty = Vec::new();
let api = api.as_array().unwrap_or(&__api_empty);
let mut apiGroup: Value = api.get(0).cloned().unwrap_or(Value::Null);
let mut baseUrls: Value = self.urls.as_map().and_then(|__m| __m.get("api")).cloned().unwrap_or(Value::Null);
let mut baseUrl: Value = self.safe_string(baseUrls.clone(), apiGroup, &[baseUrls.as_map().and_then(|__m| __m.get("myriad")).cloned().unwrap_or(Value::Null)]);
let mut url: Value = Value::Str(format!("{}{}", Value::Str(format!("{}{}", baseUrl, Value::Str("/".into())).into()), self.implode_params(path.clone(), params.clone())).into());
let mut query: Value = self.omit(params, self.extract_params(path), &[]);
if (method.as_str() == Some("GET")) {
let mut querystring: Value = self.urlencode(query.clone(), &[]);
if (querystring.as_str() != Some("")) {
url = Value::Str(format!("{}{}", url, Value::Str(format!("{}{}", Value::Str("?".into()), querystring).into())).into());
}
}
let mut existingHeaders: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
let mut headersValue: Value = self.extend(Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("Accept".to_string(), Value::Str("application/json".into()));
m.insert("Content-Type".to_string(), Value::Str("application/json".into()));
m
}), &[Value::Map(existingHeaders)]);
let mut bodyValue: Value = Value::Null;
if (method.as_str() != Some("GET")) {
if ((object_keys(&query).len() as i64) as f64) > ((0i64) as f64) {
bodyValue = json_stringify(&query);
}
}
if (self.apiKey.clone() != Value::Null) && (self.apiKey.as_str() != Some("")) {
let mut headerKey: Value = Value::Str(format!("{}{}", Value::Str("x-api".into()), Value::Str("-key".into())).into());
let mut headersKey: indexmap::IndexMap<String, Value> = ({
let mut m = indexmap::IndexMap::new();
m
});
headersKey.insert(crate::runtime::stringify_param(&headerKey), self.apiKey.clone());
headersValue = self.extend(headersValue.clone(), &[Value::Map(headersKey)]);
}
return Value::Map({
let mut m = indexmap::IndexMap::new();
m.insert("url".to_string(), url);
m.insert("method".to_string(), method);
m.insert("body".to_string(), bodyValue);
m.insert("headers".to_string(), headersValue);
m
});
Value::Null
}
}