use std::mem;
use chrono::DateTime;
use tracing::{debug, warn};
use crate::{
book::{component::pair_book, BookFeedConfig, BookSnapshot, Books, ReceivedAt},
pamm::protocols::metric::{
client::MetricClient, models::MetricMetadata, state::MetricState, PROTOCOL_TYPE,
},
snapshot_feed::{errors::FeedError, http::HttpSource},
};
#[derive(derive_more::Debug, Clone)]
pub struct MetricBookSource {
pub protocol_system: &'static str,
pub book_config: BookFeedConfig,
pub client: MetricClient,
}
impl HttpSource for MetricBookSource {
type Snapshot = BookSnapshot<ReceivedAt>;
async fn fetch(&self) -> Result<BookSnapshot<ReceivedAt>, FeedError> {
let metadata = self.client.fetch_metadata().await?;
let quotable: Vec<MetricMetadata> = metadata
.into_iter()
.filter(|pool| {
self.book_config
.pair_tokens(&pool.token0, &pool.token1)
.is_some() &&
self.book_config
.clears_min_tvl(pool.tvl_fiat.unwrap_or(0.0), &pool.pool_address)
})
.collect();
let polled = self
.client
.fetch_bid_ask_each(quotable)
.await;
let requested = polled.len();
let mut failures: Vec<FeedError> = Vec::new();
let mut books = Books::new();
for (pool, bid_ask) in polled {
let bid_ask = match bid_ask {
Ok(bid_ask) => bid_ask,
Err(e) => {
warn!(pool = %pool.pool_address, error = %e, "skipping pool, bid/ask fetch failed");
failures.push(e);
continue;
}
};
let Some((token0, token1)) = self
.book_config
.pair_tokens(&pool.token0, &pool.token1)
else {
continue;
};
if !bid_ask.is_quotable() {
debug!(pool = %pool.pool_address, "skipping pool, not quotable");
continue;
}
let component_id = pool.pool_address.clone();
let updated_at = DateTime::from_timestamp(bid_ask.server_ts as i64, 0);
let state = MetricState {
base_token: token0.clone(),
quote_token: token1.clone(),
metadata: pool,
bid_ask,
};
books.insert(pair_book(
self.protocol_system,
PROTOCOL_TYPE,
self.book_config.chain,
component_id,
state,
updated_at,
));
}
if requested > 0 && failures.len() == requested {
return Err(every_pool_failed(failures));
}
Ok(BookSnapshot::received_now(books))
}
}
fn every_pool_failed(failures: Vec<FeedError>) -> FeedError {
let summary =
format!("none of Metric's {} quotable pools answered its bid/ask request", failures.len());
let mut failures = failures.into_iter();
let Some(first) = failures.next() else {
return FeedError::Connection(summary);
};
if failures.all(|other| mem::discriminant(&other) == mem::discriminant(&first)) {
first.in_context(summary)
} else {
FeedError::Connection(summary)
}
}
#[cfg(test)]
mod tests {
use std::{collections::HashMap, str::FromStr, sync::Arc};
use num_bigint::BigUint;
use rstest::rstest;
use tycho_common::{
models::{token::Token, Chain},
Bytes,
};
use super::*;
use crate::{
book::test_token_map,
evm::protocol::utils::bytes_to_address,
pamm::protocols::metric::{
client::DEFAULT_BID_ASK_CONCURRENCY, feed::MetricFeedBuilder, FALLBACK_PROTOCOL_SYSTEM,
PROTOCOL_SYSTEM,
},
snapshot_feed::http::test_support::spawn_http_server,
};
const FIRST_POOL: &str = "0x1111111111111111111111111111111111111111";
const SECOND_POOL: &str = "0x2222222222222222222222222222222222222222";
const REFUSED_KEY: (&str, &str) = ("401 Unauthorized", r#"{"message":"invalid api key"}"#);
const UNSERVED_CHAIN: (&str, &str) = ("404 Not Found", r#"{"error": "Unknown chainId: 1"}"#);
fn pool_json(pool: &str, tvl_fiat: Option<f64>) -> serde_json::Value {
serde_json::json!({
"poolAddress": pool,
"token0": weth().address.to_string(),
"token1": usdc().address.to_string(),
"tvlFiat": tvl_fiat,
})
}
fn metadata_page(pools: &[serde_json::Value], next_offset: Option<u64>) -> String {
serde_json::json!({ "data": pools, "nextOffset": next_offset }).to_string()
}
fn bid_ask_json(server_ts: u64, unhealthy: bool) -> String {
let mut body = serde_json::json!({
"bidAdj": q64(3000).to_string(),
"askAdj": q64(3010).to_string(),
"totalToken0Available": "1000000000000000000",
"totalToken1Available": "3000000000",
"serverTs": server_ts,
"depth": {
"asks": [{
"binIdx": 0,
"price": q64(3010).to_string(),
"cumulativeVolume": "3000000000",
"cumulativeInputVolume": "1000000000000000000"
}],
"bids": []
}
});
if unhealthy {
body["priceProviderStatus"] = serde_json::json!("degraded");
}
body.to_string()
}
fn bid_ask_target(pool: &str) -> String {
let checksummed = bytes_to_address(&Bytes::from_str(pool).unwrap())
.unwrap()
.to_checksum(None);
format!("/public/v1/evm/1/{checksummed}/bid_ask")
}
fn source(chain: Chain, base_url: &str, api_key: &str) -> MetricBookSource {
MetricBookSource {
protocol_system: PROTOCOL_SYSTEM,
book_config: BookFeedConfig {
chain,
tokens: Arc::new(HashMap::new()),
min_tvl_usd: 0.0,
},
client: MetricClient::new(
Some(base_url),
chain.try_id().unwrap(),
api_key.to_string(),
DEFAULT_BID_ASK_CONCURRENCY,
),
}
}
fn weth() -> Token {
let address = Bytes::from_str("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap();
Token::new(&address, "WETH", 18, 0, &[], Chain::Ethereum, 100)
}
fn usdc() -> Token {
let address = Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap();
Token::new(&address, "USDC", 6, 0, &[], Chain::Ethereum, 100)
}
fn q64(price: u64) -> BigUint {
BigUint::from(price) << 64usize
}
#[tokio::test]
async fn a_fallback_source_labels_its_components_for_the_fallback_router() {
const POOL: &str = "0x1111111111111111111111111111111111111111";
const SERVER_TS: u64 = 1_700_000_000;
let page = metadata_page(&[pool_json(POOL, Some(1_000.0))], None);
let server = spawn_http_server(move |request| {
if request
.target
.starts_with("/public/v1/evm/1/metadata?")
{
return Some(("200 OK", page.clone()));
}
Some(("200 OK", bid_ask_json(SERVER_TS, false)))
})
.await;
let mut source = MetricBookSource {
protocol_system: FALLBACK_PROTOCOL_SYSTEM,
..source(Chain::Ethereum, &server.url(), "test_key")
};
source.book_config.tokens = Arc::new(test_token_map(&[
(&weth().address, "WETH", 18),
(&usdc().address, "USDC", 6),
]));
let books = source.fetch().await.unwrap().books;
let book = books.values().next().expect("one book");
assert_eq!(book.component.protocol_system, "fallback:rfq:metric");
assert_eq!(book.component.id.to_string(), POOL);
}
#[tokio::test]
async fn fetch_books_drops_failed_and_unquotable_pools_but_keeps_the_rest() {
const HEALTHY: &str = "0x1111111111111111111111111111111111111111";
const FAILING: &str = "0x2222222222222222222222222222222222222222";
const UNQUOTABLE: &str = "0x3333333333333333333333333333333333333333";
const BELOW_FLOOR: &str = "0x4444444444444444444444444444444444444444";
const UNPRICED: &str = "0x5555555555555555555555555555555555555555";
const SERVER_TS: u64 = 1_700_000_000;
let page = metadata_page(
&[
pool_json(HEALTHY, Some(1_000.0)),
pool_json(FAILING, Some(1_000.0)),
pool_json(UNQUOTABLE, Some(1_000.0)),
pool_json(BELOW_FLOOR, Some(99.0)),
pool_json(UNPRICED, None),
],
None,
);
let server = spawn_http_server(move |request| {
if request
.target
.starts_with("/public/v1/evm/1/metadata?")
{
return Some(("200 OK", page.clone()));
}
if request.target == bid_ask_target(HEALTHY) {
return Some(("200 OK", bid_ask_json(SERVER_TS, false)));
}
if request.target == bid_ask_target(FAILING) {
return Some(("500 Internal Server Error", "boom".to_string()));
}
if request.target == bid_ask_target(UNQUOTABLE) {
return Some(("200 OK", bid_ask_json(SERVER_TS, true)));
}
Some(("200 OK", bid_ask_json(SERVER_TS, false)))
})
.await;
let endpoint = server.url();
let mut source = source(Chain::Ethereum, &endpoint, "key");
source.book_config.tokens = Arc::new(test_token_map(&[
(&weth().address, "WETH", 18),
(&usdc().address, "USDC", 6),
]));
source.book_config.min_tvl_usd = 100.0;
let books = source.fetch().await.unwrap().books;
let healthy_id = Bytes::from_str(HEALTHY)
.unwrap()
.to_string();
assert_eq!(books.keys().collect::<Vec<_>>(), vec![&healthy_id]);
let book = &books[&healthy_id];
assert_eq!(book.component.id, Bytes::from(healthy_id.as_str()));
assert_eq!(book.updated_at, DateTime::from_timestamp(SERVER_TS as i64, 0));
}
#[tokio::test]
async fn metadata_failure_fails_the_poll() {
let server =
spawn_http_server(|_| Some(("500 Internal Server Error", "boom".to_string()))).await;
let endpoint = server.url();
let source = source(Chain::Ethereum, &endpoint, "key");
let result = source.fetch().await;
assert!(matches!(result, Err(FeedError::Connection(_))), "got {result:?}");
}
#[rstest]
#[case::every_pool_on_a_refused_key(REFUSED_KEY, REFUSED_KEY, false)]
#[case::every_pool_on_an_unserved_chain(UNSERVED_CHAIN, UNSERVED_CHAIN, true)]
#[case::one_pool_of_two_refusing_the_chain(UNSERVED_CHAIN, REFUSED_KEY, false)]
#[tokio::test]
async fn losing_every_pool_fails_the_poll(
#[case] first_answer: (&'static str, &'static str),
#[case] second_answer: (&'static str, &'static str),
#[case] fatal: bool,
) {
let page = metadata_page(
&[pool_json(FIRST_POOL, Some(1_000.0)), pool_json(SECOND_POOL, Some(1_000.0))],
None,
);
let server = spawn_http_server(move |request| {
if request
.target
.starts_with("/public/v1/evm/1/metadata?")
{
return Some(("200 OK", page.clone()));
}
let (status, body) = if request.target == bid_ask_target(FIRST_POOL) {
first_answer
} else {
second_answer
};
Some((status, body.to_string()))
})
.await;
let endpoint = server.url();
let mut source = source(Chain::Ethereum, &endpoint, "revoked");
source.book_config.tokens = Arc::new(test_token_map(&[
(&weth().address, "WETH", 18),
(&usdc().address, "USDC", 6),
]));
let result = source.fetch().await;
let error = result.expect_err("a poll that lost every pool must fail");
assert_eq!(error.is_fatal(), fatal, "{error}");
assert!(
error
.to_string()
.contains("none of Metric's 2 quotable pools"),
"{error}"
);
}
#[tokio::test]
#[ignore = "hits Metric's public API; requires METRIC_API_KEY"]
async fn live_metric_poll_fits_the_request_timeout_at_the_default_concurrency() {
let api_key = std::env::var("METRIC_API_KEY").expect("METRIC_API_KEY not set");
let mut source = source(Chain::Base, "https://api.metric.xyz", &api_key);
let metadata = source
.client
.fetch_metadata()
.await
.unwrap();
assert!(!metadata.is_empty(), "Metric serves no Base pools");
let tokens = metadata
.iter()
.flat_map(|pool| [pool.token0.clone(), pool.token1.clone()])
.map(|address| {
let token = Token::new(&address, "TKN", 18, 0, &[], Chain::Base, 100);
(address, token)
})
.collect();
source.book_config =
BookFeedConfig { chain: Chain::Base, tokens: Arc::new(tokens), min_tvl_usd: 0.0 };
let budget = MetricFeedBuilder::default_feed_config().request_timeout;
let started = std::time::Instant::now();
let books = source.fetch().await.unwrap().books;
let elapsed = started.elapsed();
assert!(!books.is_empty(), "no quotable pool among the {} on Base", metadata.len());
println!(
"{} pools, {} books, {elapsed:?} of a {budget:?} budget",
metadata.len(),
books.len()
);
assert!(elapsed < budget, "a poll of {} pools took {elapsed:?}", metadata.len());
}
}