use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::http::VenueError;
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ParsedOrder {
#[serde(default)]
pub order_id: String,
#[serde(default)]
pub status: String,
#[serde(default)]
pub filled: bool,
#[serde(default)]
pub base_qty: Option<f64>,
#[serde(default)]
pub quote: f64,
#[serde(default)]
pub avg_price: Option<f64>,
#[serde(default)]
pub price: Option<f64>,
#[serde(default)]
pub fee: f64,
#[serde(default)]
pub fee_asset: Option<String>,
#[serde(default)]
pub side: String,
#[serde(default)]
pub qty: f64,
#[serde(default)]
pub client_id: String,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Balance {
pub free: f64,
pub locked: f64,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Limits {
pub min_base: f64,
pub min_quote: f64,
}
pub trait Venue {
fn name(&self) -> &'static str;
fn parse_order(&self, raw: &serde_json::Value) -> Result<ParsedOrder, VenueError>;
fn order_status(&self, pair: &str, order_id: &str) -> Result<ParsedOrder, VenueError>;
fn open_orders(&self, pair: &str) -> Result<Vec<ParsedOrder>, VenueError>;
fn cancel(&self, pair: &str, order_id: &str) -> Result<ParsedOrder, VenueError>;
fn balances(&self) -> Result<BTreeMap<String, f64>, VenueError>;
fn balances_full(&self) -> Result<BTreeMap<String, Balance>, VenueError>;
fn price(&self, pair: &str) -> Result<f64, VenueError>;
fn limits(&self, pair: &str) -> Result<Limits, VenueError>;
fn round_amount(&self, pair: &str, amount: f64) -> Result<f64, VenueError>;
fn round_price(&self, pair: &str, price: f64) -> Result<f64, VenueError>;
fn market_buy(
&self,
pair: &str,
quote: f64,
client_id: Option<&str>,
) -> Result<serde_json::Value, VenueError>;
fn market_sell(
&self,
pair: &str,
base: f64,
client_id: Option<&str>,
) -> Result<serde_json::Value, VenueError>;
fn limit_buy(
&self,
pair: &str,
base: f64,
price: f64,
client_id: Option<&str>,
) -> Result<serde_json::Value, VenueError>;
fn limit_sell(
&self,
pair: &str,
base: f64,
price: f64,
client_id: Option<&str>,
) -> Result<serde_json::Value, VenueError>;
fn qty_step(&self, _pair: &str) -> Result<f64, VenueError> {
Ok(1e-8)
}
fn deposits(&self, _since: f64) -> Option<Result<Vec<crate::gate::Deposit>, VenueError>> {
None
}
fn id_matches(&self, venue_cid: &str, cid: &str) -> bool {
venue_id_matches(self.name(), venue_cid, cid)
}
}
pub fn step_from_precision(p: i64) -> f64 {
let p = if p == 0 { 8 } else { p };
10f64.powf(-(p as f64))
}
pub fn venue_id_matches(exch: &str, venue_cid: &str, cid: &str) -> bool {
if venue_cid.is_empty() || cid.is_empty() {
return false;
}
match exch {
"revx" => crate::ids::safe_revx_cid(cid).is_ok_and(|u| venue_cid.to_lowercase() == u),
"gate" => crate::ids::gate_cid(cid).is_ok_and(|g| venue_cid == g),
_ => venue_cid.starts_with(cid),
}
}
pub(crate) fn shape_err(venue: &'static str, what: impl core::fmt::Display) -> VenueError {
VenueError::new(venue, None, what.to_string())
}