use num_bigint::BigUint;
use num_traits::{ToPrimitive, Zero};
use serde::{Deserialize, Serialize};
use serde_with::{serde_as, DefaultOnNull, DisplayFromStr};
use tycho_common::Bytes;
use crate::{serde_helpers::evm_address, snapshot_feed::errors::FeedError};
const Q64_FLOAT: f64 = 18_446_744_073_709_551_616.0;
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct MetricApiError {
pub error: String,
}
impl MetricApiError {
pub fn refuses_the_chain(&self) -> bool {
self.error
.starts_with("Unknown chainId")
}
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaginatedMetadataResponse {
pub data: Vec<MetricMetadata>,
pub next_offset: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MetricMetadata {
#[serde(deserialize_with = "evm_address::deserialize")]
pub pool_address: Bytes,
#[serde(deserialize_with = "evm_address::deserialize")]
pub token0: Bytes,
#[serde(deserialize_with = "evm_address::deserialize")]
pub token1: Bytes,
pub tvl_fiat: Option<f64>,
#[serde(default)]
pub pause_level: Option<u8>,
}
impl MetricMetadata {
pub fn is_unpaused(&self) -> bool {
self.pause_level.unwrap_or(0) == 0
}
}
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct MetricBatchBidAskRequest {
pub pools: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct MetricBatchBidAskResponse {
pub results: Vec<MetricBatchBidAskResult>,
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MetricBatchBidAskResult {
#[serde(deserialize_with = "evm_address::deserialize")]
pub pool_address: Bytes,
#[serde(default)]
pub quote: Option<MetricBidAskResponse>,
#[serde(default)]
pub error: Option<MetricBatchBidAskError>,
}
impl MetricBatchBidAskResult {
pub fn into_quote(self) -> Result<MetricBidAskResponse, FeedError> {
match (self.quote, self.error) {
(Some(quote), _) => Ok(quote),
(None, Some(error)) => Err(error.into()),
(None, None) => Err(FeedError::Parsing(format!(
"Metric batch bid/ask answered neither a quote nor an error for pool {}",
self.pool_address
))),
}
}
}
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct MetricBatchBidAskError {
pub status: u16,
pub error: String,
}
impl From<MetricBatchBidAskError> for FeedError {
fn from(error: MetricBatchBidAskError) -> Self {
let message = format!("Metric bid/ask HTTP error {}: {}", error.status, error.error);
if (MetricApiError { error: error.error }).refuses_the_chain() {
FeedError::Fatal(message)
} else {
FeedError::Connection(message)
}
}
}
#[serde_as]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MetricBidAskResponse {
#[serde_as(as = "DisplayFromStr")]
pub bid_adj: BigUint,
#[serde_as(as = "DisplayFromStr")]
pub ask_adj: BigUint,
#[serde_as(as = "Option<DisplayFromStr>")]
pub total_token0_available: Option<BigUint>,
#[serde_as(as = "Option<DisplayFromStr>")]
pub total_token1_available: Option<BigUint>,
pub server_ts: u64,
pub price_provider_status: Option<String>,
#[serde_as(as = "DefaultOnNull")]
#[serde(default)]
pub depth: MetricDepth,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MetricDepth {
#[serde(default)]
pub asks: Vec<MetricDepthBin>,
#[serde(default)]
pub bids: Vec<MetricDepthBin>,
}
#[serde_as]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MetricDepthBin {
pub bin_idx: i64,
#[serde_as(as = "DisplayFromStr")]
pub price: BigUint,
#[serde_as(as = "DisplayFromStr")]
pub cumulative_volume: BigUint,
#[serde_as(as = "DisplayFromStr")]
pub cumulative_input_volume: BigUint,
}
impl MetricBidAskResponse {
pub fn bid_price(&self) -> Result<Option<f64>, FeedError> {
if self.bid_adj.is_zero() {
return Ok(None);
}
q64_to_f64(&self.bid_adj).map(Some)
}
pub fn ask_price(&self) -> Result<Option<f64>, FeedError> {
if self.ask_adj == BigUint::from(u128::MAX) {
return Ok(None);
}
q64_to_f64(&self.ask_adj).map(Some)
}
pub fn total_token0_available(&self) -> Result<BigUint, FeedError> {
self.total_token0_available
.clone()
.ok_or_else(|| FeedError::Parsing("totalToken0Available is null".to_string()))
}
pub fn total_token1_available(&self) -> Result<BigUint, FeedError> {
self.total_token1_available
.clone()
.ok_or_else(|| FeedError::Parsing("totalToken1Available is null".to_string()))
}
pub fn is_quotable(&self) -> bool {
if let Some(status) = self.price_provider_status.as_deref() {
if status != "healthy" {
return false;
}
}
self.total_token0_available.is_some() &&
self.total_token1_available.is_some() &&
!(self.depth.bids.is_empty() && self.depth.asks.is_empty())
}
}
fn q64_to_f64(value: &BigUint) -> Result<f64, FeedError> {
let raw = value
.to_f64()
.ok_or_else(|| FeedError::Parsing(format!("Q64 price does not fit in f64: {value}")))?;
Ok(raw / Q64_FLOAT)
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricPrices {
pub pools: Vec<MetricPoolPrice>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricPoolPrice {
pub metadata: MetricMetadata,
pub bid_ask: MetricBidAskResponse,
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use rstest::rstest;
use super::*;
#[test]
fn sentinel_sides_have_no_price() {
let quote = |bid: String, ask: String| MetricBidAskResponse {
bid_adj: bid.parse().unwrap(),
ask_adj: ask.parse().unwrap(),
total_token0_available: None,
total_token1_available: None,
server_ts: 0,
price_provider_status: None,
depth: MetricDepth::default(),
};
let unquoted = quote("0".to_string(), u128::MAX.to_string());
assert_eq!(unquoted.bid_price().unwrap(), None);
assert_eq!(unquoted.ask_price().unwrap(), None);
let quoted = quote("1".to_string(), (u128::MAX - 1).to_string());
assert!(quoted.bid_price().unwrap().is_some());
assert!(quoted.ask_price().unwrap().is_some());
}
#[test]
fn bid_ask_deserializes_depth_bins() {
let response: MetricBidAskResponse = serde_json::from_value(serde_json::json!({
"bidAdj": "55340232221128654848000",
"askAdj": "55524699661865750400000",
"totalToken0Available": "1000000000000000000",
"totalToken1Available": "3000000000",
"serverTs": 0,
"depth": {
"asks": [{
"binIdx": 0,
"price": "57184906628499610009600",
"cumulativeVolume": "1000000000000000000",
"cumulativeInputVolume": "3100000000",
"priceImpactE6": "33333"
}],
"bids": [{
"binIdx": -1,
"price": "53495557813757699686400",
"cumulativeVolume": "3000000000",
"cumulativeInputVolume": "1000000000000000000",
"priceImpactE6": "33333"
}]
}
}))
.unwrap();
assert_eq!(response.depth.asks.len(), 1);
assert_eq!(response.depth.bids[0].bin_idx, -1);
assert_eq!(q64_to_f64(&response.depth.asks[0].price).unwrap(), 3100.0);
assert_eq!(response.depth.bids[0].cumulative_volume, BigUint::from(3_000_000_000u64));
assert_eq!(
response.depth.bids[0].cumulative_input_volume,
BigUint::from(1_000_000_000_000_000_000u64)
);
let serialized = serde_json::to_value(&response).unwrap();
assert_eq!(serialized["bidAdj"], "55340232221128654848000");
assert_eq!(serialized["totalToken1Available"], "3000000000");
assert_eq!(serialized["depth"]["asks"][0]["cumulativeInputVolume"], "3100000000");
}
#[test]
fn bid_ask_null_totals_are_not_quotable() {
let response: MetricBidAskResponse = serde_json::from_value(serde_json::json!({
"bidAdj": "55340232221128654848000",
"askAdj": "55524699661865750400000",
"totalToken0Available": null,
"totalToken1Available": null,
"serverTs": 1_770_053_095u64,
}))
.unwrap();
assert_eq!(response.total_token0_available, None);
assert!(!response.is_quotable());
}
#[test]
fn bid_ask_absent_totals_decode_as_none() {
let response: MetricBidAskResponse = serde_json::from_value(serde_json::json!({
"bidAdj": "55340232221128654848000",
"askAdj": "55524699661865750400000",
"serverTs": 1_770_053_095u64,
}))
.unwrap();
assert_eq!(response.total_token0_available, None);
assert_eq!(response.total_token1_available, None);
assert_eq!(response.price_provider_status, None);
}
#[test]
fn bid_ask_null_depth_decodes_as_empty() {
let response: MetricBidAskResponse = serde_json::from_value(serde_json::json!({
"bidAdj": "55340232221128654848000",
"askAdj": "55524699661865750400000",
"totalToken0Available": "1000000000000000000",
"totalToken1Available": "3000000000",
"serverTs": 0,
"depth": null,
}))
.unwrap();
assert_eq!(response.depth, MetricDepth::default());
assert!(!response.is_quotable());
}
#[test]
fn bid_ask_empty_depth_is_not_quotable() {
let response: MetricBidAskResponse = serde_json::from_value(serde_json::json!({
"bidAdj": "0",
"askAdj": "340282366920938463463374607431768211455",
"totalToken0Available": "11419581536531814910",
"totalToken1Available": "12935676138",
"serverTs": 1_784_611_959u64,
}))
.unwrap();
assert!(response.depth.bids.is_empty() && response.depth.asks.is_empty());
assert!(!response.is_quotable());
}
#[test]
fn bid_ask_unhealthy_provider_status_is_not_quotable() {
let quotable = serde_json::json!({
"bidAdj": "55340232221128654848000",
"askAdj": "55524699661865750400000",
"totalToken0Available": "1000000000000000000",
"totalToken1Available": "3000000000",
"serverTs": 1_787_710_476u64,
"depth": {
"asks": [{
"binIdx": 0,
"price": "57184906628499610009600",
"cumulativeVolume": "1000000000000000000",
"cumulativeInputVolume": "3100000000"
}],
"bids": []
}
});
for (status, expected) in
[("healthy", true), ("feed_down", false), ("internal_error", false)]
{
let mut payload = quotable.clone();
payload["priceProviderStatus"] = serde_json::json!(status);
let response: MetricBidAskResponse = serde_json::from_value(payload).unwrap();
assert_eq!(response.is_quotable(), expected, "status {status}");
}
let response: MetricBidAskResponse = serde_json::from_value(quotable).unwrap();
assert_eq!(response.price_provider_status, None);
assert!(response.is_quotable());
}
#[test]
fn paginated_metadata_deserializes_tvl_fiat() {
let response: PaginatedMetadataResponse = serde_json::from_value(serde_json::json!({
"data": [{
"pair": "ethusdc",
"poolAddress": "0xbF48bCf474d57fF82A3215319229e0DE1476A557",
"token0": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"token1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
"tvlFiat": 1234.56
}],
"total": 1,
"nextOffset": null
}))
.unwrap();
assert_eq!(response.next_offset, None);
assert_eq!(response.data[0].tvl_fiat, Some(1234.56));
}
fn metadata_with_pause_level(pause_level: Option<u8>) -> MetricMetadata {
let mut pool = serde_json::json!({
"poolAddress": "0xbF48bCf474d57fF82A3215319229e0DE1476A557",
"token0": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"token1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
});
if let Some(level) = pause_level {
pool["pauseLevel"] = serde_json::json!(level);
}
serde_json::from_value(pool).unwrap()
}
#[rstest]
#[case::trading(Some(0), true)]
#[case::partly_paused(Some(1), false)]
#[case::fully_paused(Some(2), false)]
#[case::no_pause_level(None, true)]
fn only_pause_level_zero_is_unpaused(#[case] pause_level: Option<u8>, #[case] unpaused: bool) {
let pool = metadata_with_pause_level(pause_level);
assert_eq!(pool.pause_level, pause_level);
assert_eq!(pool.is_unpaused(), unpaused);
}
#[test]
fn batch_bid_ask_carries_quotes_and_per_pool_errors() {
let response: MetricBatchBidAskResponse = serde_json::from_value(serde_json::json!({
"results": [
{
"poolAddress": "0xf85afbadecc7f23dd173ed706f07d9c7e2473e24",
"quote": {
"pair": "WETH/USDC",
"poolAddress": "0xF85AfbADeCC7F23Dd173ed706f07d9C7e2473e24",
"priceProviderStatus": "healthy",
"bidAdj": "49940417631045696435290",
"askAdj": "49945012360825322506424",
"totalToken0Available": "24503618827789131821",
"totalToken1Available": "49785157539",
"serverTs": 1790508850,
"depth": null
}
},
{
"poolAddress": "0x0000000000000000000000000000000000000001",
"error": { "status": 404, "error": "Pair metadata not found" }
},
{ "poolAddress": "0x0000000000000000000000000000000000000002" }
]
}))
.unwrap();
let [quoted, failed, empty] = <[_; 3]>::try_from(response.results).unwrap();
assert_eq!(
quoted.pool_address,
Bytes::from_str("0xF85AfbADeCC7F23Dd173ed706f07d9C7e2473e24").unwrap()
);
assert_eq!(quoted.into_quote().unwrap().server_ts, 1790508850);
let error = failed.into_quote().unwrap_err();
assert!(matches!(error, FeedError::Connection(_)), "{error}");
assert!(
error
.to_string()
.contains("Pair metadata not found"),
"{error}"
);
assert!(matches!(empty.into_quote(), Err(FeedError::Parsing(_))));
}
#[rstest]
#[case::an_unknown_pool("Pair metadata not found", false)]
#[case::an_unserved_chain("Unknown chainId: 130", true)]
fn only_a_batch_entry_refusing_the_chain_is_fatal(#[case] message: &str, #[case] fatal: bool) {
let error: FeedError =
MetricBatchBidAskError { status: 404, error: message.to_string() }.into();
assert_eq!(error.is_fatal(), fatal, "{error}");
}
}