ticker_viewer/src/gate_swap/gate_swap_standard.rs

use std::fmt::Debug;
use std::io::{Error, ErrorKind};
use rust_decimal::Decimal;
use rust_decimal::prelude::FromPrimitive;
use serde::{Deserialize, Serialize};
use crate::gate_swap::gate_swap_rest::{get_market, get_trades};
use crate::struct_standard::{Market, Trades};
use crate::utils::utils::format_symbol;

#[derive(Debug, Deserialize, Serialize)]
struct SwapTrades {
    id: i64,
    contract: String,
    create_time: f64,
    create_time_ms: f64,
    size: Decimal,
    price: String,
}

pub(crate) async fn standard_trades(symbol: &str, start_at: &str, end_at: &str, ct_val: Option<Decimal>) -> Result<Vec<Trades>, Error> {
    let symbol_fmt = format_symbol(symbol, "_");
    let res_data = get_trades(&symbol_fmt, start_at, end_at).await;
    if res_data.code == "200" {
        let res_data_str = res_data.data;
        let mut trades_list: Vec<SwapTrades> = serde_json::from_str(&res_data_str).unwrap();
        trades_list.sort_by(|a, b| (a.id).cmp(&b.id));
        let result = trades_list.iter().map(|item| {
            Trades {
                id: item.id.to_string(),
                symbol: item.contract.clone(),
                create_time: (item.create_time_ms * 1000.0).to_string(),
                size: (item.size * ct_val.unwrap_or(Decimal::ONE)).to_string(),
                price: item.price.clone(),
            }
        }).collect();
        Ok(result)
    } else {
        Err(Error::new(ErrorKind::Other, res_data.to_string()))
    }
}

#[derive(Debug, Deserialize, Serialize)]
struct SwapMarket {
    name: String,
    order_price_round: Decimal,
    order_size_min: Decimal,
    order_size_max: Decimal,
    quanto_multiplier: Decimal,
}

pub(crate) async fn standard_market(symbol: &str) -> Result<Market, Error> {
    let symbol_fmt = format_symbol(symbol, "_");
    let res_data = get_market().await;
    if res_data.code == "200" {
        let res_data_str = res_data.data;
        let market_list: Vec<SwapMarket> = serde_json::from_str(&res_data_str).unwrap();
        let market = market_list.iter().find(|item| item.name == symbol_fmt).unwrap();

        let name_array: Vec<&str> = market.name.split("_").collect();
        let tick_size = market.order_price_round;
        let amount_size = market.order_size_min * market.quanto_multiplier;
        let min_notional = market.order_size_min * market.quanto_multiplier;
        let max_notional = market.order_size_max * market.quanto_multiplier;

        let result = Market {
            symbol: market.name.clone(),
            base_asset: name_array[0].to_string(),
            quote_asset: name_array[1].to_string(),
            tick_size,
            amount_size,
            price_precision: Decimal::from_u32(tick_size.scale()).unwrap(),
            amount_precision: Decimal::from_u32(amount_size.scale()).unwrap(),
            min_qty: market.order_size_min,
            max_qty: market.order_size_max,
            min_notional,
            max_notional,
            ct_val: market.quanto_multiplier,
        };
        Ok(result)
    } else {
        Err(Error::new(ErrorKind::Other, res_data.to_string()))
    }
}