use std::any::type_name;
use log::debug;
use reqwest::Client;
use serde_json::json;
use crate::config::NetworkConfig;
use crate::errors::O2Error;
use crate::models::*;
#[derive(Debug, Clone)]
pub struct O2Api {
client: Client,
config: NetworkConfig,
}
impl O2Api {
pub fn new(config: NetworkConfig) -> Self {
Self {
client: Client::new(),
config,
}
}
async fn parse_response<T: serde::de::DeserializeOwned>(
&self,
response: reqwest::Response,
) -> Result<T, O2Error> {
let status = response.status();
let text = response.text().await?;
let target_type = type_name::<T>();
debug!(
"api.parse_response status={} target_type={} body_len={}",
status,
target_type,
text.len()
);
if !status.is_success() {
debug!(
"api.parse_response non_success status={} body={}",
status, text
);
if let Ok(err) = serde_json::from_str::<serde_json::Value>(&text) {
if let Some(code) = err.get("code").and_then(|c| c.as_u64()) {
let raw_message = err
.get("message")
.or_else(|| err.get("error"))
.and_then(|m| m.as_str())
.unwrap_or("Unknown error");
let message = if raw_message.contains("Revert")
|| raw_message.contains("revert")
|| raw_message.contains("Panic")
{
let reason = err.get("reason").and_then(|r| r.as_str()).unwrap_or("");
let receipts = err.get("receipts").cloned();
crate::onchain_revert::augment_revert_reason(
raw_message,
reason,
receipts.as_ref(),
)
} else {
raw_message.to_string()
};
return Err(O2Error::from_code(code as u32, message));
}
if let Some(message) = err
.get("message")
.or_else(|| err.get("error"))
.and_then(|m| m.as_str())
{
let raw_reason = err.get("reason").and_then(|r| r.as_str()).unwrap_or("");
let receipts = err.get("receipts").cloned();
let has_receipts = receipts.as_ref().is_some_and(|v| !v.is_null());
let has_revert_evidence = raw_reason.contains("Revert")
|| raw_reason.to_lowercase().contains("receipt")
|| message.to_lowercase().contains("transaction");
if has_receipts || has_revert_evidence {
let reason = crate::onchain_revert::augment_revert_reason(
message,
raw_reason,
receipts.as_ref(),
);
return Err(O2Error::OnChainRevert {
message: message.to_string(),
reason,
receipts,
});
}
return Err(O2Error::HttpError(format!("HTTP {}: {}", status, message)));
}
}
return Err(O2Error::HttpError(format!("HTTP {}: {}", status, text)));
}
match serde_json::from_str(&text) {
Ok(parsed) => {
debug!("api.parse_response decode_ok target_type={}", target_type);
Ok(parsed)
}
Err(e) => {
debug!(
"api.parse_response decode_failed target_type={} error={}",
target_type, e
);
Err(O2Error::JsonError(format!(
"Failed to parse response: {e}\nBody: {}",
&text[..text.len().min(500)]
)))
}
}
}
pub async fn get_markets(&self) -> Result<MarketsResponse, O2Error> {
debug!("api.get_markets");
let url = format!("{}/v1/markets", self.config.api_base);
let resp = self.client.get(&url).send().await?;
self.parse_response(resp).await
}
pub async fn get_market_summary(&self, market_id: &str) -> Result<Vec<MarketSummary>, O2Error> {
debug!("api.get_market_summary market_id={}", market_id);
let url = format!("{}/v1/markets/summary", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("market_id", market_id)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_market_ticker(&self, market_id: &str) -> Result<Vec<MarketTicker>, O2Error> {
debug!("api.get_market_ticker market_id={}", market_id);
let url = format!("{}/v1/markets/ticker", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("market_id", market_id)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_depth(
&self,
market_id: &str,
precision: u64,
limit: Option<usize>,
) -> Result<DepthSnapshot, O2Error> {
debug!(
"api.get_depth market_id={} precision={} limit={:?}",
market_id, precision, limit
);
let url = format!("{}/v1/depth", self.config.api_base);
let precision_str = precision.to_string();
let mut pairs: Vec<(&str, String)> = vec![
("market_id", market_id.to_string()),
("precision", precision_str),
];
if let Some(lim) = limit {
pairs.push(("limit", lim.to_string()));
}
let resp = self
.client
.get(&url)
.query(
&pairs
.iter()
.map(|(k, v)| (*k, v.as_str()))
.collect::<Vec<_>>(),
)
.send()
.await?;
let val: serde_json::Value = self.parse_response(resp).await?;
let depth = val
.get("orders")
.or_else(|| val.get("view"))
.unwrap_or(&val);
let mut snapshot: DepthSnapshot = serde_json::from_value(depth.clone())
.map_err(|e| O2Error::JsonError(format!("Failed to parse depth: {e}")))?;
if let Some(lim) = limit {
snapshot.bids.truncate(lim);
snapshot.asks.truncate(lim);
}
Ok(snapshot)
}
pub async fn get_trades(
&self,
market_id: &str,
direction: &str,
count: u32,
start_timestamp: Option<u64>,
start_trade_id: Option<&str>,
contract: Option<&str>,
) -> Result<TradesResponse, O2Error> {
debug!(
"api.get_trades market_id={} direction={} count={} contract={:?}",
market_id, direction, count, contract
);
let url = format!("{}/v1/trades", self.config.api_base);
let count_str = count.to_string();
let start_timestamp_str = start_timestamp.map(|ts| ts.to_string());
let mut query: Vec<(&str, &str)> = vec![
("market_id", market_id),
("direction", direction),
("count", count_str.as_str()),
];
if let Some(ts) = start_timestamp_str.as_deref() {
query.push(("start_timestamp", ts));
}
if let Some(tid) = start_trade_id {
query.push(("start_trade_id", tid));
}
if let Some(c) = contract {
query.push(("contract", c));
}
let resp = self.client.get(&url).query(&query).send().await?;
self.parse_response(resp).await
}
pub async fn get_trades_by_account(
&self,
market_id: &str,
contract: &str,
direction: &str,
count: u32,
start_timestamp: Option<u64>,
start_trade_id: Option<&str>,
) -> Result<TradesResponse, O2Error> {
debug!(
"api.get_trades_by_account market_id={} contract={} direction={} count={}",
market_id, contract, direction, count
);
let url = format!("{}/v1/trades_by_account", self.config.api_base);
let count_str = count.to_string();
let start_timestamp_str = start_timestamp.map(|ts| ts.to_string());
let mut query: Vec<(&str, &str)> = vec![
("market_id", market_id),
("contract", contract),
("direction", direction),
("count", count_str.as_str()),
];
if let Some(ts) = start_timestamp_str.as_deref() {
query.push(("start_timestamp", ts));
}
if let Some(tid) = start_trade_id {
query.push(("start_trade_id", tid));
}
let resp = self.client.get(&url).query(&query).send().await?;
self.parse_response(resp).await
}
const VALID_RESOLUTIONS: &'static [&'static str] = &[
"1s", "1m", "2m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "6h", "8h", "12h", "1d",
"3d", "1w", "1M", "3M",
];
pub async fn get_bars(
&self,
market_id: &str,
from_ts: u64,
to_ts: u64,
resolution: &str,
) -> Result<Vec<Bar>, O2Error> {
if !Self::VALID_RESOLUTIONS.contains(&resolution) {
return Err(O2Error::InvalidRequest(format!(
"Invalid bar resolution \"{resolution}\". Valid values: {:?}",
Self::VALID_RESOLUTIONS
)));
}
debug!(
"api.get_bars market_id={} from_ts={} to_ts={} resolution={}",
market_id, from_ts, to_ts, resolution
);
let url = format!("{}/v1/bars", self.config.api_base);
let from_ts_str = from_ts.to_string();
let to_ts_str = to_ts.to_string();
let resp = self
.client
.get(&url)
.query(&[
("market_id", market_id),
("from", from_ts_str.as_str()),
("to", to_ts_str.as_str()),
("resolution", resolution),
])
.send()
.await?;
let val: serde_json::Value = self.parse_response(resp).await?;
let bars_val = val.get("bars").unwrap_or(&val);
serde_json::from_value(bars_val.clone())
.map_err(|e| O2Error::JsonError(format!("Failed to parse bars: {e}")))
}
pub async fn create_account(
&self,
owner_address: &str,
) -> Result<CreateAccountResponse, O2Error> {
debug!("api.create_account owner_address={}", owner_address);
let url = format!("{}/v1/accounts", self.config.api_base);
let body = json!({
"identity": {
"Address": owner_address
}
});
let resp = self
.client
.post(&url)
.header("Content-Type", "application/json")
.json(&body)
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_account_by_owner(&self, owner: &str) -> Result<AccountResponse, O2Error> {
debug!("api.get_account_by_owner owner={}", owner);
let url = format!("{}/v1/accounts", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("owner", owner)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_account_by_id(
&self,
trade_account_id: &str,
) -> Result<AccountResponse, O2Error> {
debug!(
"api.get_account_by_id trade_account_id={}",
trade_account_id
);
let url = format!("{}/v1/accounts", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("trade_account_id", trade_account_id)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_balance(
&self,
asset_id: &str,
contract: Option<&str>,
address: Option<&str>,
) -> Result<BalanceResponse, O2Error> {
debug!(
"api.get_balance asset_id={} contract={:?} address={:?}",
asset_id, contract, address
);
let url = format!("{}/v1/balance", self.config.api_base);
let mut query: Vec<(&str, &str)> = vec![("asset_id", asset_id)];
if let Some(c) = contract {
query.push(("contract", c));
}
if let Some(a) = address {
query.push(("address", a));
}
let resp = self.client.get(&url).query(&query).send().await?;
self.parse_response(resp).await
}
#[allow(clippy::too_many_arguments)]
pub async fn get_orders(
&self,
market_id: &str,
contract: &str,
direction: &str,
count: u32,
is_open: Option<bool>,
start_timestamp: Option<u64>,
start_order_id: Option<&str>,
) -> Result<OrdersResponse, O2Error> {
debug!(
"api.get_orders market_id={} contract={} direction={} count={} is_open={:?} start_timestamp={:?} start_order_id={:?}",
market_id, contract, direction, count, is_open, start_timestamp, start_order_id
);
let url = format!("{}/v1/orders", self.config.api_base);
let count_str = count.to_string();
let is_open_str = is_open.map(|open| open.to_string());
let start_timestamp_str = start_timestamp.map(|ts| ts.to_string());
let mut query: Vec<(&str, &str)> = vec![
("market_id", market_id),
("contract", contract),
("direction", direction),
("count", count_str.as_str()),
];
if let Some(open) = is_open_str.as_deref() {
query.push(("is_open", open));
}
if let Some(ts) = start_timestamp_str.as_deref() {
query.push(("start_timestamp", ts));
}
if let Some(oid) = start_order_id {
query.push(("start_order_id", oid));
}
let resp = self.client.get(&url).query(&query).send().await?;
self.parse_response(resp).await
}
pub async fn get_order(&self, market_id: &str, order_id: &str) -> Result<Order, O2Error> {
debug!(
"api.get_order market_id={} order_id={}",
market_id, order_id
);
let url = format!("{}/v1/order", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("market_id", market_id), ("order_id", order_id)])
.send()
.await?;
let val: serde_json::Value = self.parse_response(resp).await?;
let order_val = val.get("order").unwrap_or(&val);
serde_json::from_value(order_val.clone())
.map_err(|e| O2Error::JsonError(format!("Failed to parse order: {e}")))
}
pub async fn create_session(
&self,
owner_id: &str,
request: &SessionRequest,
) -> Result<SessionResponse, O2Error> {
debug!(
"api.create_session owner_id={} contract_id={} nonce={} expiry={}",
owner_id, request.contract_id, request.nonce, request.expiry
);
let url = format!("{}/v1/session", self.config.api_base);
let resp = self
.client
.put(&url)
.header("Content-Type", "application/json")
.header("O2-Owner-Id", owner_id)
.json(request)
.send()
.await?;
self.parse_response(resp).await
}
pub(crate) async fn submit_actions(
&self,
owner_id: &str,
request: &SessionActionsRequest,
) -> Result<SessionActionsResponse, O2Error> {
debug!(
"api.submit_actions owner_id={} nonce={} markets={} collect_orders={:?}",
owner_id,
request.nonce,
request.actions.len(),
request.collect_orders
);
let url = format!("{}/v1/session/actions", self.config.api_base);
let resp = self
.client
.post(&url)
.header("Content-Type", "application/json")
.header("O2-Owner-Id", owner_id)
.json(request)
.send()
.await?;
let val: serde_json::Value = self.parse_response(resp).await?;
let tx_id = val.get("tx_id").and_then(|v| v.as_str()).map(TxId::from);
let code = val.get("code").and_then(|v| v.as_u64()).map(|v| v as u32);
let message = val
.get("message")
.and_then(|v| v.as_str())
.map(String::from);
let reason = val.get("reason").and_then(|v| v.as_str()).map(String::from);
let receipts = val.get("receipts").cloned();
let orders = val
.get("orders")
.and_then(|o| serde_json::from_value::<Vec<Order>>(o.clone()).ok());
let parsed = SessionActionsResponse {
tx_id,
orders,
code,
message,
reason,
receipts,
};
if parsed.is_success() {
debug!("api.submit_actions parsed=success tx_id={:?}", parsed.tx_id);
Ok(parsed)
} else if parsed.is_preflight_error() {
let code = parsed.code.unwrap_or(0);
let message = parsed.message.unwrap_or_default();
debug!(
"api.submit_actions parsed=preflight_error code={} message={}",
code, message
);
Err(O2Error::from_code(code, message))
} else if parsed.is_onchain_error() {
debug!(
"api.submit_actions parsed=onchain_error message={:?} reason={:?}",
parsed.message, parsed.reason
);
let message = parsed.message.unwrap_or_default();
let raw_reason = parsed.reason.unwrap_or_default();
let reason = crate::onchain_revert::augment_revert_reason(
&message,
&raw_reason,
parsed.receipts.as_ref(),
);
Err(O2Error::OnChainRevert {
message,
reason,
receipts: parsed.receipts,
})
} else {
debug!("api.submit_actions parsed=ambiguous returning_raw_response");
Ok(parsed)
}
}
pub async fn withdraw(
&self,
owner_id: &str,
request: &WithdrawRequest,
) -> Result<WithdrawResponse, O2Error> {
debug!(
"api.withdraw owner_id={} trade_account_id={} asset_id={} amount={} nonce={}",
owner_id, request.trade_account_id, request.asset_id, request.amount, request.nonce
);
let url = format!("{}/v1/accounts/withdraw", self.config.api_base);
let resp = self
.client
.post(&url)
.header("Content-Type", "application/json")
.header("O2-Owner-Id", owner_id)
.json(request)
.send()
.await?;
self.parse_response(resp).await
}
pub async fn whitelist_account(
&self,
trade_account_id: &str,
) -> Result<WhitelistResponse, O2Error> {
debug!(
"api.whitelist_account trade_account_id={}",
trade_account_id
);
let url = format!("{}/analytics/v1/whitelist", self.config.api_base);
let body = WhitelistRequest {
trade_account: trade_account_id.to_string(),
};
let resp = self
.client
.post(&url)
.header("Content-Type", "application/json")
.json(&body)
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_referral_info(&self, code: &str) -> Result<ReferralInfo, O2Error> {
debug!("api.get_referral_info code={}", code);
let url = format!("{}/analytics/v1/referral/code-info", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("code", code)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_assets(&self) -> Result<AggregatedAssets, O2Error> {
debug!("api.get_aggregated_assets");
let url = format!("{}/v1/aggregated/assets", self.config.api_base);
let resp = self.client.get(&url).send().await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_orderbook(
&self,
market_pair: &str,
depth: u32,
level: u32,
) -> Result<AggregatedOrderbook, O2Error> {
debug!(
"api.get_aggregated_orderbook market_pair={} depth={} level={}",
market_pair, depth, level
);
let url = format!("{}/v1/aggregated/orderbook", self.config.api_base);
let depth_str = depth.to_string();
let level_str = level.to_string();
let resp = self
.client
.get(&url)
.query(&[
("market_pair", market_pair),
("depth", depth_str.as_str()),
("level", level_str.as_str()),
])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_coingecko_orderbook(
&self,
ticker_id: &str,
depth: u32,
) -> Result<CoingeckoAggregatedOrderbook, O2Error> {
debug!(
"api.get_aggregated_coingecko_orderbook ticker_id={} depth={}",
ticker_id, depth
);
let url = format!("{}/v1/aggregated/coingecko/orderbook", self.config.api_base);
let depth_str = depth.to_string();
let resp = self
.client
.get(&url)
.query(&[("ticker_id", ticker_id), ("depth", depth_str.as_str())])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_summary(&self) -> Result<Vec<PairSummary>, O2Error> {
debug!("api.get_aggregated_summary");
let url = format!("{}/v1/aggregated/summary", self.config.api_base);
let resp = self.client.get(&url).send().await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_ticker(&self) -> Result<AggregatedTicker, O2Error> {
debug!("api.get_aggregated_ticker");
let url = format!("{}/v1/aggregated/ticker", self.config.api_base);
let resp = self.client.get(&url).send().await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_coingecko_tickers(&self) -> Result<Vec<PairTicker>, O2Error> {
debug!("api.get_aggregated_coingecko_tickers");
let url = format!("{}/v1/aggregated/coingecko/tickers", self.config.api_base);
let resp = self.client.get(&url).send().await?;
self.parse_response(resp).await
}
pub async fn get_aggregated_trades(
&self,
market_pair: &str,
) -> Result<Vec<AggregatedTrade>, O2Error> {
debug!("api.get_aggregated_trades market_pair={}", market_pair);
let url = format!("{}/v1/aggregated/trades", self.config.api_base);
let resp = self
.client
.get(&url)
.query(&[("market_pair", market_pair)])
.send()
.await?;
self.parse_response(resp).await
}
pub async fn mint_to_address(&self, address: &str) -> Result<FaucetResponse, O2Error> {
debug!("api.mint_to_address address={}", address);
let faucet_url = self
.config
.faucet_url
.as_ref()
.ok_or_else(|| O2Error::Other("Faucet not available on this network".into()))?;
let body = json!({ "address": address });
let resp = self
.client
.post(faucet_url)
.header("Content-Type", "application/json")
.json(&body)
.send()
.await?;
self.parse_response(resp).await
}
pub async fn mint_to_contract(&self, contract_id: &str) -> Result<FaucetResponse, O2Error> {
debug!("api.mint_to_contract contract_id={}", contract_id);
let faucet_url = self
.config
.faucet_url
.as_ref()
.ok_or_else(|| O2Error::Other("Faucet not available on this network".into()))?;
let body = json!({ "contract": contract_id });
let resp = self
.client
.post(faucet_url)
.header("Content-Type", "application/json")
.json(&body)
.send()
.await?;
self.parse_response(resp).await
}
}