use std::{
collections::{BTreeSet, HashMap, HashSet},
time::{Duration, Instant},
};
use chrono::Utc;
use num_bigint::BigUint;
use tycho_common::{
models::{token::Token, Chain},
simulation::protocol_sim::ProtocolSim,
Bytes,
};
use super::{
config::{canonical_pamm_address, PriceLevelStreamConfig},
convert::{quotes_for_book, resolve_book_tokens, SideQuotes, SideRejection, UnresolvedToken},
overrides::{slot_of, BufferEvents, OverrideBuffer, PammSimulationOverrides},
state::{PriceLevelStreamQuote, PriceLevelStreamState, QUOTE_TTL},
stream::PAMM_ADDRESS_ATTRIBUTE,
telemetry::{self, MatchOutcome, MissingField, RejectReason, SideRejectReason, SkipReason},
titan::{
self, EntryRejection, QuoteSequence, TitanBook, TitanMessage, TitanPriceLevelMessage,
TitanQuoteStreamMessage, VenueOverrides,
},
NANOS_PER_SECOND, SLOT,
};
use crate::protocol::models::{ProtocolComponent, Update};
pub(super) const DEFAULT_STALE_AFTER: Duration = Duration::from_secs(2 * SLOT.as_secs());
const MAX_FUTURE_SKEW_NANOS: u64 = SLOT.as_secs() * NANOS_PER_SECOND;
const BLOCK_JUMP_SLACK: u64 = 2;
const MAX_UNREGISTERED_LOGGED: usize = 64;
const MAX_AUTO_DETECTED: usize = 64;
#[derive(Clone, Copy, Debug)]
pub(super) struct Now {
pub wall_nanos: u64,
pub monotonic: Instant,
}
#[derive(Clone, Copy)]
struct MessageTiming {
block: u64,
slot: Option<u64>,
ts: u64,
stale_at: Instant,
quotable_until: Option<Instant>,
}
impl MessageTiming {
fn new(
message: &TitanPriceLevelMessage,
now: Now,
message_age: Duration,
stale_after: Duration,
quote_guard: bool,
) -> Self {
let quotable_for = QUOTE_TTL.saturating_sub(message_age);
Self {
block: message.block,
slot: message.slot,
ts: message.ts,
stale_at: now.monotonic + stale_after.saturating_sub(message_age),
quotable_until: quote_guard.then(|| now.monotonic + quotable_for),
}
}
}
struct ServedComponent {
component: ProtocolComponent,
venue_name: String,
stale_at: Instant,
}
#[derive(Clone, Copy, Debug)]
struct Frontier {
block: u64,
accepted_at: Instant,
}
#[derive(Clone, Copy)]
enum ServingState {
Unserved,
Serving { deadline: Instant, frontier: Frontier },
}
impl ServingState {
fn telemetry_state(self) -> telemetry::ServingState {
match self {
ServingState::Unserved => telemetry::ServingState::Unserved,
ServingState::Serving { deadline: _, frontier: _ } => telemetry::ServingState::Serving,
}
}
}
pub(super) struct TrackerSettings {
pub registry: HashMap<Bytes, PriceLevelStreamConfig>,
pub denied: HashSet<Bytes>,
pub tokens: HashMap<Bytes, Token>,
pub auto_detect: bool,
pub auto_detected_gas_cost: BigUint,
pub stale_after: Duration,
pub via_fallback_router: bool,
pub quote_guard: bool,
pub simulation_overrides: bool,
}
pub(super) struct FreshnessTracker {
registry: HashMap<Bytes, PriceLevelStreamConfig>,
denied: HashSet<Bytes>,
tokens: HashMap<Bytes, Token>,
auto_detect: bool,
auto_detected_gas_cost: BigUint,
stale_after: Duration,
via_fallback_router: bool,
quote_guard: bool,
served: HashMap<String, ServedComponent>,
serving_state: ServingState,
newest_timestamp_nanos: u64,
rejecting: bool,
logged_unregistered: HashSet<Bytes>,
auto_detected: usize,
overrides: Option<OverrideBuffer>,
}
impl FreshnessTracker {
pub(super) fn new(settings: TrackerSettings) -> Self {
let TrackerSettings {
registry,
denied,
tokens,
auto_detect,
auto_detected_gas_cost,
stale_after,
via_fallback_router,
quote_guard,
simulation_overrides,
} = settings;
telemetry::record_serving_state(telemetry::ServingState::Unserved);
for config in registry.values() {
init_venue_series(&config.protocol, simulation_overrides);
}
telemetry::init_book_counters();
telemetry::init_socket_counters(simulation_overrides);
if simulation_overrides {
telemetry::init_override_counters();
}
Self {
registry,
denied,
tokens,
auto_detect,
auto_detected_gas_cost,
stale_after,
via_fallback_router,
quote_guard,
served: HashMap::new(),
serving_state: ServingState::Unserved,
newest_timestamp_nanos: 0,
rejecting: false,
logged_unregistered: HashSet::new(),
auto_detected: 0,
overrides: simulation_overrides.then(OverrideBuffer::default),
}
}
fn check_message(
&self,
message: &TitanPriceLevelMessage,
now: Now,
) -> Result<Duration, RejectReason> {
let message_age = Duration::from_nanos(
now.wall_nanos
.saturating_sub(message.ts),
);
if message_age >= self.stale_after {
return Err(RejectReason::TooOld);
}
if message.ts >
now.wall_nanos
.saturating_add(MAX_FUTURE_SKEW_NANOS)
{
return Err(RejectReason::InFuture);
}
if message.ts < self.newest_timestamp_nanos {
return Err(RejectReason::OutOfOrder);
}
let ServingState::Serving { deadline: _, frontier } = self.serving_state else {
return Ok(message_age);
};
if message.block < frontier.block {
return Err(RejectReason::BlockRegression);
}
let elapsed_slots = now
.monotonic
.saturating_duration_since(frontier.accepted_at)
.as_secs() /
SLOT.as_secs();
let allowed = frontier
.block
.saturating_add(elapsed_slots)
.saturating_add(BLOCK_JUMP_SLACK);
if message.block > allowed {
return Err(RejectReason::BlockJump);
}
Ok(message_age)
}
pub(super) fn on_price_level_message(
&mut self,
message: TitanPriceLevelMessage,
now: Now,
) -> Option<Update> {
let message_age = match self.check_message(&message, now) {
Ok(message_age) => message_age,
Err(reason) => {
self.log_rejection(reason, &message);
telemetry::record_frame_rejected(TitanPriceLevelMessage::SOCKET, reason);
return None;
}
};
self.rejecting = false;
telemetry::record_frame_accepted();
let age_nanos = i128::from(now.wall_nanos) - i128::from(message.ts);
telemetry::record_frame_age(age_nanos as f64 / NANOS_PER_SECOND as f64);
self.newest_timestamp_nanos = message.ts;
if message.slot.is_none() {
telemetry::record_message_without_slot();
}
let timing =
MessageTiming::new(&message, now, message_age, self.stale_after, self.quote_guard);
self.advance_override_window(&message);
let (states, new_pairs) = self.serve_books(message.books, timing);
self.settle(Frontier { block: message.block, accepted_at: now.monotonic });
if states.is_empty() {
return None;
}
Some(Update::new(message.block, states, new_pairs).set_is_partial(true))
}
fn serve_books(
&mut self,
books: Vec<TitanBook>,
timing: MessageTiming,
) -> (HashMap<String, Box<dyn ProtocolSim>>, HashMap<String, ProtocolComponent>) {
let mut states: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
let mut new_pairs = HashMap::new();
for (pamm, books) in group_by_venue(books) {
self.admit(&pamm);
let Some(config) = self.registry.get(&pamm) else {
continue;
};
telemetry::record_last_seen(&config.protocol, timing.ts / NANOS_PER_SECOND);
for pair in served_pairs(&books, &self.tokens, timing.slot) {
let id = component_id(&config.address, &pair.quotes.token0, &pair.quotes.token1);
let id_string = id.to_string();
match self.served.get_mut(&id_string) {
Some(served) => served.stale_at = timing.stale_at,
None => {
let component = build_component(
&self.tokens,
config,
id,
&pair.quotes.token0,
&pair.quotes.token1,
self.via_fallback_router,
);
new_pairs.insert(id_string.clone(), component.clone());
self.served.insert(
id_string.clone(),
ServedComponent {
component,
venue_name: config.protocol.clone(),
stale_at: timing.stale_at,
},
);
}
}
let overrides = self
.overrides
.as_ref()
.and_then(|buffer| {
find_overrides(
buffer,
&config.protocol,
&pamm,
&pair,
&id_string,
timing.block,
)
});
let PairQuotes { token0, token1, quotes_0_to_1, quotes_1_to_0 } = pair.quotes;
let mut state = PriceLevelStreamState::new(
token0,
token1,
quotes_0_to_1,
quotes_1_to_0,
config.gas_cost.clone(),
);
if let Some(until) = timing.quotable_until {
state = state.with_quotable_until(until);
}
if let Some(overrides) = overrides {
state = state.with_simulation_overrides(overrides);
}
states.insert(id_string, Box::new(state));
}
}
(states, new_pairs)
}
fn admit(&mut self, pamm: &Bytes) {
if self.registry.contains_key(pamm) {
return;
}
if self.denied.contains(pamm) {
tracing::debug!(%pamm, "Skipping denied pAMM");
return;
}
if self.auto_detect && self.auto_detected < MAX_AUTO_DETECTED {
tracing::info!(%pamm, "Serving auto-detected pAMM");
let config = PriceLevelStreamConfig::auto_detected(
pamm.clone(),
self.auto_detected_gas_cost.clone(),
);
init_venue_series(&config.protocol, self.overrides.is_some());
self.registry
.insert(pamm.clone(), config);
self.auto_detected += 1;
return;
}
telemetry::record_unregistered_pamm();
if self.logged_unregistered.len() < MAX_UNREGISTERED_LOGGED &&
self.logged_unregistered
.insert(pamm.clone())
{
if self.auto_detect {
tracing::warn!(
%pamm,
cap = MAX_AUTO_DETECTED,
"Skipping unknown pAMM: the auto-detection cap is reached; register it via \
add_pamm to serve it"
);
} else {
tracing::info!(
%pamm,
"Skipping unregistered pAMM; register it via add_pamm to serve it"
);
}
}
}
fn advance_override_window(&mut self, message: &TitanPriceLevelMessage) {
let Some(buffer) = self.overrides.as_mut() else {
return;
};
let newest_book_slot = || {
message
.books
.iter()
.filter_map(|book| match book.calculated_from {
QuoteSequence::Valid(sequence) => Some(slot_of(sequence)),
QuoteSequence::Absent | QuoteSequence::Unreadable => None,
})
.max()
};
let Some(slot) = message.slot.or_else(newest_book_slot) else {
return;
};
let mut events = BufferEvents::new();
buffer.advance(slot, &mut events);
record_buffer_events(&events);
}
pub(super) fn on_quote_stream_message(&mut self, message: TitanQuoteStreamMessage) {
let Some(buffer) = self.overrides.as_mut() else {
return;
};
let mut events = BufferEvents::new();
for outcome in titan::validate(message) {
let entry = match outcome {
Ok(entry) => entry,
Err(reason) => {
record_refused_entry(reason);
continue;
}
};
record_entry_shape(&entry);
if !self
.registry
.contains_key(&canonical_pamm_address(&entry.quote_address))
{
telemetry::record_unserved_venue_entry();
}
buffer.store(entry, |venue| self.registry.contains_key(venue), &mut events);
}
record_buffer_events(&events);
}
pub(super) fn on_stale_deadline(&mut self, now: Instant) -> Option<Update> {
let ServingState::Serving { deadline: _, frontier } = self.serving_state else {
return None;
};
let mut removed = HashMap::new();
let mut venues = BTreeSet::new();
for (id, served) in self
.served
.extract_if(|_, served| served.stale_at <= now)
{
telemetry::record_stale_removal(&served.venue_name);
venues.insert(served.venue_name);
removed.insert(id, served.component);
}
if removed.is_empty() {
return None;
}
let component_ids: Vec<&String> = removed.keys().collect();
tracing::warn!(
removed = removed.len(),
venues = ?venues,
components = ?component_ids,
stale_after_secs = self.stale_after.as_secs(),
"Removing price level components: no accepted message carried them within stale_after"
);
let update = Update::new(frontier.block, HashMap::new(), HashMap::new())
.set_is_partial(true)
.set_removed_pairs(removed);
self.settle(frontier);
Some(update)
}
pub(super) fn stale_deadline(&self) -> Option<Instant> {
match self.serving_state {
ServingState::Serving { deadline, frontier: _ } => Some(deadline),
ServingState::Unserved => None,
}
}
fn settle(&mut self, frontier: Frontier) {
let deadline = self
.served
.values()
.map(|served| served.stale_at)
.min();
self.serving_state = match deadline {
Some(deadline) => ServingState::Serving { deadline, frontier },
None => ServingState::Unserved,
};
telemetry::record_serving_state(self.serving_state.telemetry_state());
let mut per_venue: HashMap<&str, usize> = self
.registry
.values()
.map(|config| (config.protocol.as_str(), 0))
.collect();
for served in self.served.values() {
*per_venue
.entry(served.venue_name.as_str())
.or_default() += 1;
}
for (venue, count) in per_venue {
telemetry::record_served_components(venue, count);
}
}
fn log_rejection(&mut self, reason: RejectReason, message: &TitanPriceLevelMessage) {
let reason: &'static str = reason.into();
if self.rejecting {
tracing::debug!(
reason,
block = message.block,
slot = ?message.slot,
ts = message.ts,
"Rejecting price level message"
);
return;
}
self.rejecting = true;
let newest_block = match self.serving_state {
ServingState::Serving { deadline: _, frontier } => Some(frontier.block),
ServingState::Unserved => None,
};
tracing::warn!(
reason,
block = message.block,
slot = ?message.slot,
ts = message.ts,
newest_block = ?newest_block,
newest_timestamp_nanos = self.newest_timestamp_nanos,
"Rejecting price level message; further rejections logged at debug until a message is \
accepted"
);
}
}
fn group_by_venue(books: Vec<TitanBook>) -> Vec<(Bytes, Vec<TitanBook>)> {
let mut venues: Vec<(Bytes, Vec<TitanBook>)> = Vec::new();
let mut positions: HashMap<Bytes, usize> = HashMap::new();
for book in books {
let venue = canonical_pamm_address(&book.quote_address);
match positions.get(&venue) {
Some(&position) => venues[position].1.push(book),
None => {
positions.insert(venue.clone(), venues.len());
venues.push((venue, vec![book]));
}
}
}
venues
}
struct ServedPair {
quotes: PairQuotes,
quote_sequence: Option<u128>,
}
fn quote_sequence_of(book: &TitanBook, slot: Option<u64>) -> Option<u128> {
match book.calculated_from {
QuoteSequence::Valid(sequence) => {
if slot.is_some_and(|slot| slot_of(sequence) != slot) {
telemetry::record_sequence_slot_mismatch(TitanPriceLevelMessage::SOCKET);
tracing::debug!(
quote_address = %book.quote_address,
?slot,
sequence,
"A book's quote sequence does not carry the message's beacon slot"
);
}
Some(sequence)
}
QuoteSequence::Unreadable => {
telemetry::record_unreadable_quote_sequence();
tracing::debug!(
quote_address = %book.quote_address,
token1 = book.token1,
token2 = book.token2,
"Serving a book whose calculated_from this parser cannot read"
);
None
}
QuoteSequence::Absent => None,
}
}
fn served_pairs(
books: &[TitanBook],
tokens: &HashMap<Bytes, Token>,
slot: Option<u64>,
) -> Vec<ServedPair> {
let mut pairs: Vec<ServedPair> = Vec::new();
let mut positions: HashMap<(Bytes, Bytes), usize> = HashMap::new();
for book in books {
let Some(quotes) = quotes_for_pair(book, tokens) else {
continue;
};
let quote_sequence = quote_sequence_of(book, slot);
let key = (quotes.token0.clone(), quotes.token1.clone());
let pair = ServedPair { quotes, quote_sequence };
match positions.get(&key) {
Some(&position) => {
telemetry::record_duplicate_books();
pairs[position] = pair;
}
None => {
positions.insert(key, pairs.len());
pairs.push(pair);
}
}
}
pairs
}
fn find_overrides(
buffer: &OverrideBuffer,
venue_name: &str,
venue: &Bytes,
pair: &ServedPair,
component: &str,
block: u64,
) -> Option<std::sync::Arc<PammSimulationOverrides>> {
let Some(sequence) = pair.quote_sequence else {
telemetry::record_override_match(venue_name, MatchOutcome::NoQuoteSequence);
return None;
};
let Some(found) = buffer.find(venue, &pair.quotes.token0, &pair.quotes.token1, sequence) else {
telemetry::record_override_match(venue_name, MatchOutcome::NoneInSlot);
tracing::debug!(
venue = venue_name,
component,
sequence,
"Serving pAMM quotes without simulation overrides: no entry in the book's slot at or \
below its quote sequence"
);
return None;
};
let outcome = if found.same_sequence {
MatchOutcome::SameSequence
} else {
MatchOutcome::EarlierSequence
};
telemetry::record_override_match(venue_name, outcome);
if found.overrides.block_number != Some(block) {
telemetry::record_override_block_mismatch();
tracing::debug!(
venue = venue_name,
component,
sequence,
block,
overrides_block = ?found.overrides.block_number,
"Attaching pAMM simulation overrides that name another block than the message's"
);
}
if found.merged_sources > 0 {
telemetry::record_override_merged_sources(venue_name, found.merged_sources);
}
if found.skipped_sources > 0 {
telemetry::record_override_skipped_sources(venue_name, found.skipped_sources);
}
Some(found.overrides)
}
struct PairQuotes {
token0: Bytes,
token1: Bytes,
quotes_0_to_1: Vec<PriceLevelStreamQuote>,
quotes_1_to_0: Vec<PriceLevelStreamQuote>,
}
fn quotes_for_pair(book: &TitanBook, tokens: &HashMap<Bytes, Token>) -> Option<PairQuotes> {
let (base, quote) = match resolve_book_tokens(book, tokens) {
Ok(resolved) => resolved,
Err(unresolved) => {
let (reason, address) = match unresolved {
UnresolvedToken::Malformed(address) => (SkipReason::MalformedAddress, address),
UnresolvedToken::Unadmitted(address) => (SkipReason::UnadmittedToken, address),
};
telemetry::record_skipped_book(reason);
tracing::debug!(
quote_address = %book.quote_address,
token1 = book.token1,
token2 = book.token2,
reason = <&'static str>::from(reason),
%address,
"Skipping book: it names no pair of admitted tokens"
);
return None;
}
};
if base.address == quote.address {
telemetry::record_skipped_book(SkipReason::OneAssetPair);
tracing::debug!(
quote_address = %book.quote_address,
token1 = book.token1,
token2 = book.token2,
address = %base.address,
"Skipping book: both of its addresses name one asset"
);
return None;
}
let (sell_base, sell_quote) = quotes_for_book(book, base, quote);
let sell_base = accepted_side(sell_base, book, "bids");
let sell_quote = accepted_side(sell_quote, book, "asks");
if base.address < quote.address {
Some(PairQuotes {
token0: base.address.clone(),
token1: quote.address.clone(),
quotes_0_to_1: sell_base,
quotes_1_to_0: sell_quote,
})
} else {
Some(PairQuotes {
token0: quote.address.clone(),
token1: base.address.clone(),
quotes_0_to_1: sell_quote,
quotes_1_to_0: sell_base,
})
}
}
fn accepted_side(
side_quotes: SideQuotes,
book: &TitanBook,
side: &'static str,
) -> Vec<PriceLevelStreamQuote> {
side_quotes.unwrap_or_else(|rejection| {
let reason = side_reject_reason(rejection);
telemetry::record_rejected_side(reason);
tracing::debug!(
quote_address = %book.quote_address,
token1 = book.token1,
token2 = book.token2,
side,
reason = <&'static str>::from(reason),
"Dropping book side: its levels are not a usable price function"
);
Vec::new()
})
}
fn init_venue_series(venue: &str, simulation_overrides: bool) {
telemetry::record_served_components(venue, 0);
telemetry::record_last_seen(venue, 0);
telemetry::init_stale_removals(venue);
if simulation_overrides {
telemetry::init_override_venue_series(venue);
}
}
fn record_refused_entry(reason: EntryRejection) {
telemetry::record_refused_override_entry(reason);
tracing::debug!(reason = <&'static str>::from(reason), "Refusing a pAMM venue entry whole");
}
fn record_entry_shape(entry: &VenueOverrides) {
let accounts = &entry.overrides.accounts;
let slots = accounts
.values()
.map(|account| account.state_diff.len())
.sum();
telemetry::record_override_entry_size(accounts.len(), slots);
if entry.overrides.block_number.is_none() {
telemetry::record_override_entry_missing_field(MissingField::BlockNumber);
}
let Some(slot) = entry.slot else {
telemetry::record_override_entry_missing_field(MissingField::Slot);
return;
};
for pair in &entry.pairs {
if slot_of(pair.sequence) != slot {
telemetry::record_sequence_slot_mismatch(TitanQuoteStreamMessage::SOCKET);
tracing::debug!(
quote_address = %entry.quote_address,
slot,
sequence = pair.sequence,
"A venue entry's quote sequence does not carry the entry's beacon slot"
);
}
}
}
fn record_buffer_events(events: &BufferEvents) {
for (&event, ×) in events {
telemetry::record_buffer_event(event, times);
}
if !events.is_empty() {
tracing::debug!(?events, "Updated the pAMM simulation overrides buffer");
}
}
fn side_reject_reason(rejection: SideRejection) -> SideRejectReason {
match rejection {
SideRejection::UnsupportedLevel => SideRejectReason::UnsupportedLevel,
SideRejection::NonFiniteAmount => SideRejectReason::NonFiniteAmount,
SideRejection::ZeroAmount => SideRejectReason::ZeroAmount,
SideRejection::ConflictingKnots => SideRejectReason::ConflictingKnots,
}
}
fn build_component(
tokens: &HashMap<Bytes, Token>,
config: &PriceLevelStreamConfig,
id: Bytes,
token0: &Bytes,
token1: &Bytes,
via_router: bool,
) -> ProtocolComponent {
let protocol_system =
if via_router { config.fallback_protocol_system() } else { config.protocol_system() };
ProtocolComponent::new(
id,
protocol_system.clone(),
protocol_system,
Chain::Ethereum,
vec![tokens[token0].clone(), tokens[token1].clone()],
vec![config.address.clone()],
HashMap::from([(PAMM_ADDRESS_ATTRIBUTE.to_string(), config.address.clone())]),
Bytes::default(),
Utc::now().naive_utc(),
)
}
fn component_id(pamm: &Bytes, token0: &Bytes, token1: &Bytes) -> Bytes {
Bytes::from([pamm.as_ref(), token0.as_ref(), token1.as_ref()].concat())
}
#[cfg(test)]
mod tests {
use std::{
str::FromStr,
time::{Duration, Instant},
};
use rstest::rstest;
use super::{
super::{
config::{default_served_pamms, DEFAULT_AUTO_DETECTED_GAS_COST},
state::QUOTE_TTL,
telemetry::{
recorded::{
all_label_values, counter_registered, counter_value, gauge_value,
histogram_values, record_async, SnapshotMap,
},
FRAMES_ACCEPTED, FRAMES_REJECTED, FRAME_AGE, LAST_SEEN, RECONNECTS, REJECTED_SIDES,
SERVED_COMPONENTS, SERVING_STATE, SKIPPED_BOOKS, STALE_REMOVALS,
UNREGISTERED_PAMM_ENTRIES,
},
test_support::*,
titan::TitanLevel,
},
*,
};
const BASE_WALL_NANOS: u64 = 1_788_624_558_000_000_000;
struct Clock {
base: u64,
start: Instant,
}
impl Clock {
fn new() -> Self {
Self::based_at(BASE_WALL_NANOS)
}
fn based_at(base: u64) -> Self {
Self { base, start: Instant::now() }
}
fn at(&self, seconds: u64) -> Now {
self.after(Duration::from_secs(seconds))
}
fn after(&self, elapsed: Duration) -> Now {
Now {
wall_nanos: self.base +
u64::try_from(elapsed.as_nanos())
.expect("a test duration fits a u64 of nanoseconds"),
monotonic: self.start + elapsed,
}
}
}
fn settings(configs: Vec<PriceLevelStreamConfig>) -> TrackerSettings {
TrackerSettings {
registry: configs
.into_iter()
.map(|config| (config.address.clone(), config))
.collect(),
denied: HashSet::new(),
tokens: tokens(),
auto_detect: false,
auto_detected_gas_cost: BigUint::from(DEFAULT_AUTO_DETECTED_GAS_COST),
stale_after: DEFAULT_STALE_AFTER,
via_fallback_router: false,
quote_guard: true,
simulation_overrides: true,
}
}
fn tracker_serving(
configs: Vec<PriceLevelStreamConfig>,
via_fallback_router: bool,
) -> FreshnessTracker {
FreshnessTracker::new(TrackerSettings { via_fallback_router, ..settings(configs) })
}
fn tracker() -> FreshnessTracker {
tracker_serving(vec![fermiswap()], false)
}
fn kipseli_custom() -> PriceLevelStreamConfig {
PriceLevelStreamConfig::new("custom-kipseli", address(KIPSELI), BigUint::from(42_000u64))
}
fn level(price: f64, cum_volume: f64) -> TitanLevel {
TitanLevel { price, cum_volume }
}
fn quote(amount_in: u64, amount_out: u64) -> PriceLevelStreamQuote {
PriceLevelStreamQuote::new(BigUint::from(amount_in), BigUint::from(amount_out))
}
fn book(
quote_address: &str,
token1: &str,
token2: &str,
bids: Vec<TitanLevel>,
asks: Vec<TitanLevel>,
) -> TitanBook {
TitanBook {
maker: Some("test".to_string()),
quote_address: address(quote_address),
token1: token1.to_string(),
token2: token2.to_string(),
token1_address: address(symbol_address(token1)),
token2_address: address(symbol_address(token2)),
calculated_from: QuoteSequence::Absent,
asks,
bids,
}
}
fn two_sided(quote_address: &str, token1: &str, token2: &str, price: f64) -> TitanBook {
book(quote_address, token1, token2, vec![level(price, 1.0)], vec![level(price, 1.0)])
}
fn message_at(block: u64, seconds: u64, books: Vec<TitanBook>) -> TitanPriceLevelMessage {
TitanPriceLevelMessage {
block,
slot: Some(15_387_623),
ts: BASE_WALL_NANOS + seconds * NANOS_PER_SECOND,
books,
}
}
fn message(block: u64, books: Vec<TitanBook>) -> TitanPriceLevelMessage {
message_at(block, 0, books)
}
fn wbtc_usdc_books() -> Vec<TitanBook> {
vec![two_sided(PAMM, "WBTC", "USDC", 100_000.0)]
}
fn weth_usdc_books() -> Vec<TitanBook> {
vec![two_sided(PAMM, "WETH", "USDC", 3_000.0)]
}
fn wbtc_and_weth_books() -> Vec<TitanBook> {
vec![two_sided(PAMM, "WBTC", "USDC", 100_000.0), two_sided(PAMM, "WETH", "USDC", 3_000.0)]
}
fn wbtc_usdc_id(pamm: &str) -> String {
format!("{pamm}{}{}", &WBTC[2..], &USDC[2..])
}
fn weth_usdc_id(pamm: &str) -> String {
format!("{pamm}{}{}", &USDC[2..], &WETH[2..])
}
fn expected_id() -> String {
wbtc_usdc_id(PAMM)
}
fn state_of(update: &Update) -> &PriceLevelStreamState {
update.states[&expected_id()]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state")
}
fn quotable_until(update: &Update) -> Instant {
state_of(update)
.quotable_until()
.expect("quotable_until set")
}
#[test]
fn first_message_emits_new_pair_with_both_directions() {
let clock = Clock::new();
let mut tracker = tracker();
let Update { block_number, is_partial, sync_states, states, new_pairs, removed_pairs } =
tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert_eq!(block_number, 100);
assert!(is_partial);
assert!(sync_states.is_empty());
assert!(removed_pairs.is_empty());
let id = expected_id();
let component = &new_pairs[&id];
assert_eq!(component.protocol_system, "pricelevelstream:fermiswap");
assert_eq!(
component.static_attributes[PAMM_ADDRESS_ATTRIBUTE],
Bytes::from_str(PAMM).unwrap()
);
let state = states[&id]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.token0, Bytes::from_str(WBTC).unwrap());
assert_eq!(state.token1, Bytes::from_str(USDC).unwrap());
assert_eq!(state.quotes_0_to_1.len(), 1);
assert_eq!(state.quotes_1_to_0.len(), 1);
assert_eq!(state.quotes_0_to_1[0].amount_in, BigUint::from(100_000_000u64));
assert_eq!(state.gas_cost, BigUint::from(120_000u64));
assert!(state.quotable_until().is_some());
}
#[test]
fn repeated_message_is_not_a_new_pair() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let update = tracker
.on_price_level_message(message(101, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(update.new_pairs.is_empty());
assert!(update.removed_pairs.is_empty());
assert!(update
.states
.contains_key(&expected_id()));
}
#[test]
fn block_regression_is_rejected() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(101, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(tracker
.on_price_level_message(message_at(100, 1, weth_usdc_books()), clock.at(1))
.is_none());
let update = tracker
.on_price_level_message(message_at(102, 2, wbtc_usdc_books()), clock.at(2))
.expect("update expected");
assert!(update.new_pairs.is_empty());
}
#[rstest]
#[case::at_the_limit(0, false)]
#[case::inside_the_limit(1, true)]
fn message_age_at_the_stale_after_limit(#[case] built_at: u64, #[case] accepted: bool) {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker
.on_price_level_message(message_at(100, built_at, wbtc_usdc_books()), clock.at(24));
assert_eq!(update.is_some(), accepted);
}
#[rstest]
#[case::beyond_the_limit(13, false)]
#[case::at_the_limit(12, true)]
fn message_timestamp_at_the_future_skew_limit(#[case] built_at: u64, #[case] accepted: bool) {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker
.on_price_level_message(message_at(100, built_at, wbtc_usdc_books()), clock.at(0));
assert_eq!(update.is_some(), accepted);
}
#[test]
fn older_timestamp_message_is_rejected() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 5, wbtc_usdc_books()), clock.at(5))
.expect("update expected");
assert!(tracker
.on_price_level_message(message_at(100, 4, wbtc_usdc_books()), clock.at(5))
.is_none());
}
#[test]
fn equal_timestamp_message_is_accepted() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 5, wbtc_usdc_books()), clock.at(5))
.expect("update expected");
let changed = vec![two_sided(PAMM, "WBTC", "USDC", 101_000.0)];
let update = tracker
.on_price_level_message(message_at(100, 5, changed), clock.at(5))
.expect("update expected");
assert!(update
.states
.contains_key(&expected_id()));
}
#[test]
fn block_jump_beyond_the_elapsed_bound_is_rejected() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(tracker
.on_price_level_message(message_at(103, 1, wbtc_usdc_books()), clock.at(1))
.is_none());
assert!(tracker
.on_price_level_message(message_at(u64::MAX / 2, 1, wbtc_usdc_books()), clock.at(1))
.is_none());
assert!(tracker
.on_price_level_message(message_at(101, 2, wbtc_usdc_books()), clock.at(2))
.is_some());
}
#[test]
fn block_jump_within_the_elapsed_bound_is_accepted() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(tracker
.on_price_level_message(message_at(107, 60, wbtc_usdc_books()), clock.at(60))
.is_some());
}
#[test]
fn rejections_are_counted_by_reason() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
tracker.on_price_level_message(message_at(100, 5, wbtc_usdc_books()), clock.at(5));
tracker.on_price_level_message(message_at(100, 4, wbtc_usdc_books()), clock.at(20));
tracker.on_price_level_message(message_at(100, 5, wbtc_usdc_books()), clock.at(29));
tracker.on_price_level_message(message_at(100, 45, wbtc_usdc_books()), clock.at(29));
tracker.on_price_level_message(message_at(99, 6, wbtc_usdc_books()), clock.at(29));
tracker.on_price_level_message(message_at(200, 6, wbtc_usdc_books()), clock.at(29));
});
assert_eq!(counter_value(&snapshot, FRAMES_ACCEPTED, &[]), 1);
for reason in ["too_old", "in_future", "out_of_order", "block_regression", "block_jump"] {
assert_eq!(
counter_value(
&snapshot,
FRAMES_REJECTED,
&[("reason", reason), ("socket", "price_levels")]
),
1,
"{reason}"
);
}
}
#[test]
fn accepted_message_records_its_signed_age() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
tracker.on_price_level_message(message_at(100, 7, wbtc_usdc_books()), clock.at(9));
tracker.on_price_level_message(message_at(100, 12, wbtc_usdc_books()), clock.at(9));
tracker.on_price_level_message(message_at(100, 6, wbtc_usdc_books()), clock.at(9));
});
assert_eq!(histogram_values(&snapshot, FRAME_AGE, &[]), vec![2.0, -3.0]);
}
#[test]
fn auto_detection_stops_at_its_cap() {
let (registered, snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker =
FreshnessTracker::new(TrackerSettings { auto_detect: true, ..settings(vec![]) });
for index in 0..(MAX_AUTO_DETECTED + 2) as u64 {
let venue = format!("0x{index:040x}");
let message = TitanPriceLevelMessage {
block: 100,
slot: None,
ts: BASE_WALL_NANOS + index * 1_000,
books: vec![two_sided(&venue, "WBTC", "USDC", 100_000.0)],
};
let served = tracker
.on_price_level_message(message, clock.at(1))
.is_some();
assert_eq!(served, (index as usize) < MAX_AUTO_DETECTED, "venue {index}");
}
tracker.registry.len()
});
assert_eq!(registered, MAX_AUTO_DETECTED);
assert_eq!(counter_value(&snapshot, UNREGISTERED_PAMM_ENTRIES, &[]), 2);
}
#[test]
fn quote_guard_off_emits_states_that_never_expire() {
let clock = Clock::new();
let mut tracker = FreshnessTracker::new(TrackerSettings {
quote_guard: false,
..settings(vec![fermiswap()])
});
let update = tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(15))
.expect("update expected");
assert!(state_of(&update)
.quotable_until()
.is_none());
assert_eq!(
tracker
.stale_deadline()
.expect("serving"),
clock.at(24).monotonic
);
}
#[test]
fn quotable_until_is_one_block_after_the_message_was_built() {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker
.on_price_level_message(message_at(100, 7, wbtc_usdc_books()), clock.at(9))
.expect("update expected");
assert_eq!(
quotable_until(&update),
clock.at(9).monotonic + (QUOTE_TTL - Duration::from_secs(2))
);
}
#[test]
fn quotable_until_never_exceeds_one_block_for_a_message_ahead_of_the_clock() {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker
.on_price_level_message(message_at(100, 12, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert_eq!(quotable_until(&update), clock.at(0).monotonic + QUOTE_TTL);
}
#[test]
fn message_older_than_one_block_yields_an_unquotable_state() {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(15))
.expect("update expected");
assert_eq!(quotable_until(&update), clock.at(15).monotonic);
assert_eq!(
tracker
.stale_deadline()
.expect("serving"),
clock.at(24).monotonic
);
}
#[test]
fn omitted_pair_is_not_removed_by_the_message() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let update = tracker
.on_price_level_message(message_at(101, 1, weth_usdc_books()), clock.at(1))
.expect("update expected");
assert!(update.removed_pairs.is_empty());
assert_eq!(update.new_pairs.len(), 1);
assert_eq!(update.states.len(), 1);
assert!(!update
.states
.contains_key(&expected_id()));
}
#[test]
fn omitted_venue_is_not_removed_by_the_message() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(tracker
.on_price_level_message(message_at(101, 1, Vec::new()), clock.at(1))
.is_none());
assert!(tracker.stale_deadline().is_some());
}
#[test]
fn stale_deadline_fired_a_second_early_removes_nothing() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(tracker
.on_stale_deadline(clock.at(23).monotonic)
.is_none());
assert!(tracker.stale_deadline().is_some());
}
#[test]
fn component_turns_stale_at_its_deadline() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let update = tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
assert!(update.states.is_empty());
assert!(update.new_pairs.is_empty());
assert_eq!(update.removed_pairs.len(), 1);
assert!(update
.removed_pairs
.contains_key(&expected_id()));
assert_eq!(update.block_number, 100);
assert!(update.is_partial);
assert!(tracker.stale_deadline().is_none());
}
#[test]
fn stale_deadline_fired_with_nothing_served_removes_nothing() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
assert!(tracker
.on_stale_deadline(clock.at(25).monotonic)
.is_none());
}
#[test]
fn fresh_message_after_the_stale_removal_re_adds_the_component() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
let update = tracker
.on_price_level_message(message_at(102, 26, wbtc_usdc_books()), clock.at(26))
.expect("update expected");
assert!(update
.new_pairs
.contains_key(&expected_id()));
assert!(update.removed_pairs.is_empty());
}
#[test]
fn stale_removal_is_counted_per_venue() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
});
assert_eq!(counter_value(&snapshot, STALE_REMOVALS, &[("venue", "fermiswap")]), 1);
}
#[test]
fn deadline_is_shortened_by_the_message_age_at_acceptance() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(3))
.expect("update expected");
assert_eq!(
tracker
.stale_deadline()
.expect("serving"),
clock.at(24).monotonic
);
}
#[test]
fn replayed_message_does_not_extend_the_deadline() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
tracker
.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(10))
.expect("update expected");
assert_eq!(
tracker
.stale_deadline()
.expect("serving"),
clock.at(24).monotonic
);
}
#[test]
fn omitted_pair_turns_stale_alone_while_the_rest_stays_served() {
let clock = Clock::new();
let mut tracker = tracker();
let both = wbtc_and_weth_books();
tracker
.on_price_level_message(message_at(100, 0, both), clock.at(0))
.expect("update expected");
for second in 1..=23 {
tracker.on_price_level_message(
message_at(100 + second / 12, second, weth_usdc_books()),
clock.at(second),
);
}
let update = tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
assert_eq!(update.removed_pairs.len(), 1);
assert!(update
.removed_pairs
.contains_key(&expected_id()));
assert_eq!(
tracker
.stale_deadline()
.expect("serving"),
clock.at(47).monotonic
);
}
#[test]
fn components_from_one_message_turn_stale_together() {
let clock = Clock::new();
let mut tracker = tracker();
let both = wbtc_and_weth_books();
tracker
.on_price_level_message(message_at(100, 0, both), clock.at(0))
.expect("update expected");
let update = tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
assert_eq!(update.removed_pairs.len(), 2);
}
#[test]
fn pair_set_oscillation_emits_no_removal() {
let clock = Clock::new();
let mut tracker = tracker();
let wide = || wbtc_and_weth_books();
let narrow = weth_usdc_books;
tracker
.on_price_level_message(message_at(100, 0, wide()), clock.at(0))
.expect("update expected");
for second in 1..=10u64 {
let pairs = if second % 2 == 0 { wide() } else { narrow() };
let update = tracker
.on_price_level_message(message_at(100, second, pairs), clock.at(second))
.expect("update expected");
assert!(update.removed_pairs.is_empty(), "second {second}");
assert!(update.new_pairs.is_empty(), "second {second}");
}
}
#[test]
fn implausible_first_block_is_forgotten_at_stale_removal() {
let clock = Clock::new();
let mut tracker = tracker();
tracker
.on_price_level_message(message_at(u64::MAX / 2, 0, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
for second in 1..=23 {
assert!(tracker
.on_price_level_message(
message_at(100, second, wbtc_usdc_books()),
clock.at(second)
)
.is_none());
}
let removal = tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
assert_eq!(removal.removed_pairs.len(), 1);
assert_eq!(removal.block_number, u64::MAX / 2);
let update = tracker
.on_price_level_message(message_at(100, 25, wbtc_usdc_books()), clock.at(25))
.expect("update expected");
assert_eq!(update.block_number, 100);
assert!(update
.new_pairs
.contains_key(&expected_id()));
}
#[test]
fn implausible_block_on_a_message_serving_nothing() {
let clock = Clock::new();
let mut tracker = tracker();
let unbound = vec![two_sided(PAMM, "NVDAx", "USDC", 180.0)];
assert!(tracker
.on_price_level_message(message_at(u64::MAX / 2, 0, unbound), clock.at(0))
.is_none());
let update = tracker
.on_price_level_message(message_at(100, 1, wbtc_usdc_books()), clock.at(1))
.expect("update expected");
assert_eq!(update.block_number, 100);
assert!(update
.new_pairs
.contains_key(&expected_id()));
}
#[test]
fn recovery_re_adds_only_the_pairs_the_message_carries() {
let clock = Clock::new();
let mut tracker = tracker();
let both = wbtc_and_weth_books();
tracker
.on_price_level_message(message_at(100, 0, both), clock.at(0))
.expect("update expected");
tracker
.on_stale_deadline(clock.at(24).monotonic)
.expect("removal expected");
let update = tracker
.on_price_level_message(message_at(102, 25, weth_usdc_books()), clock.at(25))
.expect("update expected");
assert_eq!(update.new_pairs.len(), 1);
assert!(!update
.new_pairs
.contains_key(&expected_id()));
assert!(update.removed_pairs.is_empty());
}
#[test]
fn a_reversed_order_pair_keeps_each_direction_on_its_own_quotes() {
let clock = Clock::new();
let mut tracker = tracker();
let reversed =
vec![book(PAMM, "WETH", "USDC", vec![level(3_000.0, 1.0)], vec![level(3_100.0, 2.0)])];
let update = tracker
.on_price_level_message(message(100, reversed), clock.at(0))
.expect("update expected");
let state = update.states[&weth_usdc_id(PAMM)]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.token0, address(USDC));
assert_eq!(state.token1, address(WETH));
assert_eq!(state.quotes_0_to_1, vec![quote(6_200_000_000, 2_000_000_000_000_000_000)]);
assert_eq!(state.quotes_1_to_0, vec![quote(1_000_000_000_000_000_000, 3_000_000_000)]);
let usdc = token(USDC, "USDC", 6);
let weth = token(WETH, "WETH", 18);
let sold_weth = state
.get_amount_out(BigUint::from(1_000_000_000_000_000_000u64), &weth, &usdc)
.expect("selling one WETH quotes");
assert_eq!(sold_weth.amount, BigUint::from(3_000_000_000u64));
let sold_usdc = state
.get_amount_out(BigUint::from(6_200_000_000u64), &usdc, &weth)
.expect("selling 6,200 USDC quotes");
assert_eq!(sold_usdc.amount, BigUint::from(2_000_000_000_000_000_000u64));
}
#[test]
fn one_direction_message_re_adds_the_pair_with_the_other_direction_unquotable() {
let clock = Clock::new();
let mut tracker = tracker();
let one_way = vec![book(PAMM, "WBTC", "USDC", vec![level(100_000.0, 1.0)], Vec::new())];
let update = tracker
.on_price_level_message(message_at(100, 0, one_way), clock.at(0))
.expect("update expected");
let state = update.states[&expected_id()]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.quotes_0_to_1.len(), 1);
assert!(state.quotes_1_to_0.is_empty());
let usdc = token(USDC, "USDC", 6);
let wbtc = token(WBTC, "WBTC", 8);
assert!(state
.get_amount_out(BigUint::from(1_000_000u64), &usdc, &wbtc)
.is_err());
}
#[test]
fn new_tracker_starts_every_registered_venue_series_at_zero() {
let ((), snapshot) = record_async(async {
let tracker = tracker();
drop(tracker);
});
assert_eq!(gauge_value(&snapshot, SERVED_COMPONENTS, &[("venue", "fermiswap")]), 0.0);
assert_eq!(gauge_value(&snapshot, LAST_SEEN, &[("venue", "fermiswap")]), 0.0);
assert!(
counter_registered(&snapshot, STALE_REMOVALS, &[("venue", "fermiswap")]),
"stale_removals_total is a missing series for a registered venue"
);
assert_eq!(counter_value(&snapshot, STALE_REMOVALS, &[("venue", "fermiswap")]), 0);
assert_eq!(gauge_value(&snapshot, SERVING_STATE, &[]), 0.0);
}
#[test]
fn an_auto_detected_venue_starts_its_series_at_zero() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker =
FreshnessTracker::new(TrackerSettings { auto_detect: true, ..settings(vec![]) });
tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
});
let venue = [("venue", PAMM)];
assert!(
counter_registered(&snapshot, STALE_REMOVALS, &venue),
"stale_removals_total is a missing series for an auto-detected venue"
);
assert_eq!(counter_value(&snapshot, STALE_REMOVALS, &venue), 0);
assert_eq!(gauge_value(&snapshot, SERVED_COMPONENTS, &venue), 1.0);
}
#[test]
fn accepted_message_gauges_its_venue_as_served() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
tracker.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0));
});
assert_eq!(gauge_value(&snapshot, SERVED_COMPONENTS, &[("venue", "fermiswap")]), 1.0);
assert_eq!(
gauge_value(&snapshot, LAST_SEEN, &[("venue", "fermiswap")]),
(BASE_WALL_NANOS / NANOS_PER_SECOND) as f64
);
assert_eq!(gauge_value(&snapshot, SERVING_STATE, &[]), 1.0);
}
#[test]
fn stale_removal_gauges_its_venue_back_to_zero() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
tracker.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0));
tracker.on_stale_deadline(clock.at(24).monotonic);
});
assert_eq!(gauge_value(&snapshot, SERVED_COMPONENTS, &[("venue", "fermiswap")]), 0.0);
assert_eq!(gauge_value(&snapshot, SERVING_STATE, &[]), 0.0);
}
#[test]
fn unregistered_pamm_produces_no_update_without_auto_detection() {
let clock = Clock::new();
let mut tracker = tracker_serving(vec![], false);
assert!(tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.is_none());
}
#[test]
fn denied_pamm_is_not_auto_detected() {
let clock = Clock::new();
let denied = HashSet::from([Bytes::from_str(PAMM).unwrap()]);
let mut tracker = FreshnessTracker::new(TrackerSettings {
denied,
auto_detect: true,
..settings(vec![])
});
assert!(tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.is_none());
}
#[test]
fn auto_detected_pamm_is_served_under_its_address() {
let clock = Clock::new();
let mut tracker =
FreshnessTracker::new(TrackerSettings { auto_detect: true, ..settings(vec![]) });
let update = tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let component = &update.new_pairs[&expected_id()];
assert_eq!(component.protocol_system, format!("pricelevelstream:{PAMM}"));
let state = update.states[&expected_id()]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.gas_cost, BigUint::from(DEFAULT_AUTO_DETECTED_GAS_COST));
let update = tracker
.on_price_level_message(message(101, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert!(update.new_pairs.is_empty());
}
#[test]
fn auto_detected_gas_cost_override_applies() {
let clock = Clock::new();
let mut tracker = FreshnessTracker::new(TrackerSettings {
auto_detect: true,
auto_detected_gas_cost: BigUint::from(42_000u64),
..settings(vec![])
});
let update = tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let state = update.states[&expected_id()]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.gas_cost, BigUint::from(42_000u64));
}
#[test]
fn unregistered_venues_counter_and_log_cap() {
let (logged, snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker_serving(vec![], false);
for round in 0..2u64 {
for index in 0..70u64 {
let venue = format!("0x{index:040x}");
let message = TitanPriceLevelMessage {
block: 100,
slot: None,
ts: BASE_WALL_NANOS + (round * 70 + index) * 1_000,
books: vec![two_sided(&venue, "WBTC", "USDC", 100_000.0)],
};
tracker.on_price_level_message(message, clock.at(1));
}
}
tracker.logged_unregistered.len()
});
assert_eq!(counter_value(&snapshot, UNREGISTERED_PAMM_ENTRIES, &[]), 140);
assert_eq!(logged, MAX_UNREGISTERED_LOGGED);
}
#[rstest]
#[case::unadmitted_token("NVDAx")]
#[case::another_unadmitted_token("cbBTC")]
fn books_naming_an_unadmitted_asset_are_skipped(#[case] token1: &str) {
let clock = Clock::new();
let mut tracker = tracker();
let unserved = vec![two_sided(PAMM, token1, "USDC", 180.0)];
assert!(tracker
.on_price_level_message(message(100, unserved), clock.at(0))
.is_none());
}
#[rstest]
#[case::unadmitted_token("NVDAx", false, "unadmitted_token")]
#[case::another_unadmitted_token("cbBTC", false, "unadmitted_token")]
#[case::malformed_address("WBTC", true, "malformed_address")]
fn skipped_books_are_counted_by_reason(
#[case] token1: &str,
#[case] malform: bool,
#[case] expected_reason: &str,
) {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
let mut book = two_sided(PAMM, token1, "USDC", 180.0);
if malform {
book.token1_address = address("0x2260fac5e5542a773aa44fbcfedf7c193bc2c5");
}
tracker.on_price_level_message(message(100, vec![book]), clock.at(0));
});
for reason in ["malformed_address", "unadmitted_token", "one_asset_pair"] {
let expected = u64::from(reason == expected_reason);
assert_eq!(
counter_value(&snapshot, SKIPPED_BOOKS, &[("reason", reason)]),
expected,
"{reason}"
);
}
}
#[rstest]
#[case::unsupported_level(vec![level(0.0, 1.0)], "unsupported_level")]
#[case::non_finite_amount(vec![level(f64::MAX, 1.0)], "non_finite_amount")]
#[case::zero_amount(vec![level(100_000.0, 0.000_000_001)], "zero_amount")]
#[case::conflicting_knots(
vec![level(100_000.0, 1.0), level(101_000.0, 1.0)],
"conflicting_knots"
)]
fn rejected_sides_are_counted_by_reason(
#[case] bids: Vec<TitanLevel>,
#[case] expected_reason: &str,
) {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
let corrupt = vec![book(PAMM, "WBTC", "USDC", bids, vec![level(100_000.0, 1.0)])];
tracker
.on_price_level_message(message(100, corrupt), clock.at(0))
.expect("the valid side is still served");
});
assert_eq!(counter_value(&snapshot, REJECTED_SIDES, &[("reason", expected_reason)]), 1);
}
#[test]
fn no_streamed_symbol_becomes_a_metric_label() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = tracker();
let books = vec![
two_sided(PAMM, "NVDAx", "USDC", 180.0),
two_sided(PAMM, "cbBTC", "USDC", 80_000.0),
book(PAMM, "WBTC", "USDC", vec![level(0.0, 1.0)], vec![level(100_000.0, 1.0)]),
];
tracker
.on_price_level_message(message(100, books), clock.at(0))
.expect("the WBTC/USDC asks are served");
});
assert_eq!(counter_value(&snapshot, SKIPPED_BOOKS, &[("reason", "unadmitted_token")]), 2);
assert_eq!(counter_value(&snapshot, REJECTED_SIDES, &[("reason", "unsupported_level")]), 1);
let labels = all_label_values(&snapshot);
for symbol in ["NVDAx", "cbBTC", "WBTC", "USDC"] {
assert!(!labels.contains(&symbol), "{symbol} became a metric label: {labels:?}");
}
}
#[test]
fn a_book_whose_legs_name_one_asset_is_skipped() {
let ((), snapshot) = record_async(async {
let clock = Clock::new();
let mut tracker = FreshnessTracker::new(settings(vec![fermiswap()]));
let mut book = two_sided(PAMM, "USDC", "USDC", 1.0);
book.token2 = "USDbC".to_string();
let self_pair = vec![book];
assert!(tracker
.on_price_level_message(message(100, self_pair), clock.at(0))
.is_none());
});
assert_eq!(counter_value(&snapshot, SKIPPED_BOOKS, &[("reason", "one_asset_pair")]), 1);
assert_eq!(counter_value(&snapshot, SKIPPED_BOOKS, &[("reason", "malformed_address")]), 0);
assert_eq!(counter_value(&snapshot, SKIPPED_BOOKS, &[("reason", "unadmitted_token")]), 0);
let labels = all_label_values(&snapshot);
for symbol in ["USDC", "USDbC"] {
assert!(!labels.contains(&symbol), "{symbol} became a metric label: {labels:?}");
}
}
#[test]
fn no_update_both_removes_and_adds_an_id() {
let clock = Clock::new();
let mut tracker = tracker();
let mut updates = Vec::new();
updates.extend(
tracker.on_price_level_message(message_at(100, 0, wbtc_usdc_books()), clock.at(0)),
);
updates.extend(tracker.on_stale_deadline(clock.at(24).monotonic));
updates.extend(
tracker.on_price_level_message(message_at(102, 25, wbtc_usdc_books()), clock.at(25)),
);
assert_eq!(updates.len(), 3);
for update in &updates {
for id in update.removed_pairs.keys() {
assert!(!update.new_pairs.contains_key(id), "{id} removed and added");
assert!(!update.states.contains_key(id), "{id} removed with a state");
}
}
}
#[test]
fn venues_are_served_under_the_fallback_family() {
let clock = Clock::new();
let mut tracker = tracker_serving(vec![fermiswap()], true);
let update = tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
let component = &update.new_pairs[&expected_id()];
assert_eq!(component.protocol_system, "fallback:fermiswap");
assert_eq!(
component.static_attributes[PAMM_ADDRESS_ATTRIBUTE],
Bytes::from_str(PAMM).unwrap()
);
}
#[rstest]
#[case::registered_on_the_public_identity(
vec![kipseli_custom()],
false,
"custom-kipseli",
42_000
)]
#[case::auto_detected(vec![], true, KIPSELI, DEFAULT_AUTO_DETECTED_GAS_COST)]
fn an_aliased_venue_is_served_under_its_public_identity(
#[case] registry: Vec<PriceLevelStreamConfig>,
#[case] auto_detect: bool,
#[case] expected_name: &str,
#[case] expected_gas: u64,
) {
let clock = Clock::new();
let mut tracker =
FreshnessTracker::new(TrackerSettings { auto_detect, ..settings(registry) });
let update = tracker
.on_price_level_message(message(100, captured_books_of("Kipseli")), clock.at(0))
.expect("update expected");
let public = address(KIPSELI);
let mut ids: Vec<&String> = update.new_pairs.keys().collect();
ids.sort();
assert_eq!(ids, [&wbtc_usdc_id(KIPSELI), &weth_usdc_id(KIPSELI)]);
for (id, component) in &update.new_pairs {
assert!(!id.contains(&KIPSELI_STREAMED[2..]), "{id} carries the streamed address");
assert_eq!(component.protocol_system, format!("pricelevelstream:{expected_name}"));
assert_eq!(component.static_attributes[PAMM_ADDRESS_ATTRIBUTE], public);
assert_eq!(component.contract_ids, vec![public.clone()]);
}
for state in update.states.values() {
let state = state
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state");
assert_eq!(state.gas_cost, BigUint::from(expected_gas));
}
}
#[test]
fn denying_the_public_identity_denies_the_books_of_its_alias() {
let clock = Clock::new();
let mut tracker = FreshnessTracker::new(TrackerSettings {
denied: HashSet::from([address(KIPSELI)]),
auto_detect: true,
..settings(vec![])
});
assert!(tracker
.on_price_level_message(message(100, captured_books_of("Kipseli")), clock.at(0))
.is_none());
}
#[test]
fn a_rejected_side_leaves_the_opposite_direction_served() {
let clock = Clock::new();
let mut tracker = tracker();
let corrupt_bids =
vec![book(PAMM, "WBTC", "USDC", vec![level(0.0, 1.0)], vec![level(100_000.0, 1.0)])];
let update = tracker
.on_price_level_message(message(100, corrupt_bids), clock.at(0))
.expect("update expected");
let state = state_of(&update);
assert!(state.quotes_0_to_1.is_empty(), "the rejected side was served");
assert_eq!(state.quotes_1_to_0.len(), 1);
let usdc = token(USDC, "USDC", 6);
let wbtc = token(WBTC, "WBTC", 8);
assert!(state
.get_amount_out(BigUint::from(100_000_000_000u64), &usdc, &wbtc)
.is_ok());
assert!(state
.get_amount_out(BigUint::from(100_000_000u64), &wbtc, &usdc)
.is_err());
}
#[test]
fn auto_detected_venue_is_served_under_the_fallback_family() {
let clock = Clock::new();
let mut tracker = FreshnessTracker::new(TrackerSettings {
auto_detect: true,
via_fallback_router: true,
..settings(vec![])
});
let update = tracker
.on_price_level_message(message(100, wbtc_usdc_books()), clock.at(0))
.expect("update expected");
assert_eq!(update.new_pairs[&expected_id()].protocol_system, format!("fallback:{PAMM}"));
}
const MATCHING_MESSAGE_TS: u64 = 1_792_115_920_294_943_036;
const CAPTURED_BLOCK: u64 = 26_201_954;
const GOLIATH: &str = "0x4367985a63063fc970b009c6e599e9225181f551";
const TAURUSFI: &str = "0x20861433d9119b866eeb398cb1ad46652a3cf953";
const METRIC: &str = "0x99ab7c1c5eab47801f7937075998527a550fba8a";
const METRIC_SECOND_SOURCE: &str = "0x30a88bf894d1b806125a23ebf23d715496fd7102";
const UNREGISTERED_VENUE: &str = "0x00000000000000000000000000000000deadbeef";
const OVERRIDE_MATCH_TOTAL: &str = "price_level_stream_override_match_total";
const OVERRIDE_BUFFER_TOTAL: &str = "price_level_stream_override_buffer_total";
const REFUSED_ENTRIES_TOTAL: &str = "price_level_stream_override_entries_refused_total";
const UNREADABLE_QUOTE_SEQUENCE_TOTAL: &str =
"price_level_stream_unreadable_quote_sequence_total";
const SEQUENCE_SLOT_MISMATCH_TOTAL: &str = "price_level_stream_sequence_slot_mismatch_total";
const OVERRIDE_BLOCK_MISMATCH_TOTAL: &str = "price_level_stream_override_block_mismatch_total";
const OVERRIDE_MERGED_SOURCES_TOTAL: &str = "price_level_stream_override_merged_sources_total";
const OVERRIDE_SKIPPED_SOURCES_TOTAL: &str =
"price_level_stream_override_skipped_sources_total";
const MESSAGES_WITHOUT_SLOT_TOTAL: &str = "price_level_stream_messages_without_slot_total";
const MISSING_FIELD_TOTAL: &str = "price_level_stream_override_entry_missing_field_total";
const UNSERVED_VENUE_ENTRIES_TOTAL: &str = "price_level_stream_unserved_venue_entries_total";
const DUPLICATE_BOOKS_TOTAL: &str = "price_level_stream_duplicate_books_total";
const ENTRY_ACCOUNTS: &str = "price_level_stream_override_entry_accounts";
const ENTRY_STORAGE_SLOTS: &str = "price_level_stream_override_entry_storage_slots";
fn capture_tracker() -> FreshnessTracker {
let known = default_served_pamms()
.into_iter()
.map(|config| PriceLevelStreamConfig {
address: canonical_pamm_address(&config.address),
..config
})
.collect();
FreshnessTracker::new(TrackerSettings { tokens: captured_tokens(), ..settings(known) })
}
fn matching_message() -> TitanPriceLevelMessage {
TitanPriceLevelMessage {
block: CAPTURED_BLOCK,
slot: Some(CAPTURED_SLOT),
ts: MATCHING_MESSAGE_TS,
books: matching_books(),
}
}
fn pair_id(venue: &str, token_a: &str, token_b: &str) -> String {
let (first, second) = (address(token_a), address(token_b));
let (token0, token1) = if first <= second { (first, second) } else { (second, first) };
component_id(&address(venue), &token0, &token1).to_string()
}
fn state_at<'a>(update: &'a Update, id: &str) -> &'a PriceLevelStreamState {
update.states[id]
.as_any()
.downcast_ref::<PriceLevelStreamState>()
.expect("price level state")
}
fn ids_with_overrides(update: &Update, present: bool) -> Vec<String> {
let mut ids: Vec<String> = update
.states
.keys()
.filter(|id| {
state_at(update, id)
.simulation_overrides()
.is_some() ==
present
})
.cloned()
.collect();
ids.sort();
ids
}
fn outcome_total(snapshot: &SnapshotMap, outcome: &str) -> u64 {
snapshot
.iter()
.filter(|((_, name, labels), _)| {
name == OVERRIDE_MATCH_TOTAL &&
labels
.get("outcome")
.map(String::as_str) ==
Some(outcome)
})
.map(|((_, name, labels), _)| {
let pairs: Vec<(&str, &str)> = labels
.iter()
.map(|(key, value)| (key.as_str(), value.as_str()))
.collect();
counter_value(snapshot, name, &pairs)
})
.sum()
}
#[test]
fn the_captured_messages_attach_overrides_to_every_matching_book() {
let clock = Clock::based_at(MATCHING_MESSAGE_TS);
let mut tracker = capture_tracker();
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(captured_quote_stream_message());
tracker.on_price_level_message(matching_message(), clock.after(Duration::ZERO))
});
let update = update.expect("update expected");
assert_eq!(update.states.len(), 30, "a captured book went unserved");
let mut without = vec![
pair_id(KIPSELI, WBTC, USDC),
pair_id(KIPSELI, WETH, USDC),
pair_id(TAURUSFI, WETH, USDC),
];
without.sort();
assert_eq!(ids_with_overrides(&update, false), without);
assert_eq!(
state_at(&update, &pair_id(GOLIATH, WETH, USDC)).simulation_overrides(),
Some(&test_overrides())
);
let metric = state_at(&update, &pair_id(METRIC, WETH, USDC))
.simulation_overrides()
.expect("Metric's WETH/USDC overrides");
assert!(
metric
.accounts
.contains_key(&address(METRIC_SECOND_SOURCE)),
"Metric's second quote address was not merged in"
);
for (outcome, count) in
[("same_sequence", 16), ("earlier_sequence", 11), ("none_in_slot", 3)]
{
assert_eq!(outcome_total(&snapshot, outcome), count, "{outcome}");
}
assert_eq!(
counter_value(&snapshot, OVERRIDE_MERGED_SOURCES_TOTAL, &[("venue", "metric")]),
4
);
assert_eq!(counter_value(&snapshot, OVERRIDE_BLOCK_MISMATCH_TOTAL, &[]), 0);
assert_eq!(counter_value(&snapshot, MESSAGES_WITHOUT_SLOT_TOTAL, &[]), 0);
}
const fn sequence_in(slot: u64, n: u64) -> u128 {
((slot as u128) << 64) | n as u128
}
const SEQUENCE: u128 = sequence_in(CAPTURED_SLOT, 48_901);
fn override_entry(
venue: &str,
built_at_ns: u64,
nonce: u64,
pairs: &[(&str, &str, u128)],
) -> String {
let asset_pairs: Vec<String> = pairs
.iter()
.map(|(token_1, token_2, _)| {
format!(r#"{{"token_1": "{token_1}", "token_2": "{token_2}"}}"#)
})
.collect();
let sequences: Vec<String> = pairs
.iter()
.map(|(_, _, sequence)| sequence.to_string())
.collect();
format!(
r#"{{
"maker": "Synthetic",
"quoteAddress": "{venue}",
"blockNumber": {CAPTURED_BLOCK},
"slot": {CAPTURED_SLOT},
"timestamp": {built_at_ns},
"assetPairs": [{}],
"pairSequences": [{}],
"stateOverride": {{
"{SYNTHETIC_ACCOUNT}": {{"balance": "0x1", "nonce": "{nonce:#x}"}}
}}
}}"#,
asset_pairs.join(", "),
sequences.join(", ")
)
}
fn quote_stream_message(entries: &[String]) -> TitanQuoteStreamMessage {
serde_json::from_str(&format!(r#"{{"venues": [{}]}}"#, entries.join(", ")))
.expect("the quote stream message parses")
}
fn one_entry(
venue: &str,
built_at_ns: u64,
pairs: &[(&str, &str, u128)],
) -> TitanQuoteStreamMessage {
quote_stream_message(&[override_entry(venue, built_at_ns, 1, pairs)])
}
const WHOLE_SECOND_NANOS: u64 = 1_792_115_920_000_000_000;
fn captured_slot_message(books: Vec<TitanBook>) -> TitanPriceLevelMessage {
message_at_slot(CAPTURED_BLOCK, Some(CAPTURED_SLOT), books)
}
fn message_at_slot(
block: u64,
slot: Option<u64>,
books: Vec<TitanBook>,
) -> TitanPriceLevelMessage {
TitanPriceLevelMessage { block, slot, ts: WHOLE_SECOND_NANOS, books }
}
fn book_at_sequence(
quote_address: &str,
token1: &str,
token2: &str,
price: f64,
sequence: u128,
) -> TitanBook {
TitanBook {
calculated_from: QuoteSequence::Valid(sequence),
..two_sided(quote_address, token1, token2, price)
}
}
fn wbtc_usdc_at(sequence: u128) -> TitanBook {
book_at_sequence(PAMM, "WBTC", "USDC", 100_000.0, sequence)
}
fn detecting_tracker(simulation_overrides: bool) -> FreshnessTracker {
FreshnessTracker::new(TrackerSettings {
auto_detect: true,
simulation_overrides,
..settings(vec![fermiswap()])
})
}
fn tracker_with_overrides(simulation_overrides: bool) -> FreshnessTracker {
FreshnessTracker::new(TrackerSettings {
simulation_overrides,
..settings(vec![fermiswap()])
})
}
fn usdc_for_one_wbtc(state: &PriceLevelStreamState) -> BigUint {
state
.get_amount_out(
BigUint::from(100_000_000u64),
&token(WBTC, "WBTC", 8),
&token(USDC, "USDC", 6),
)
.expect("the state quotes")
.amount
}
fn with_calculated_from(calculated_from: &str) -> TitanPriceLevelMessage {
let text = format!(
r#"{{"slot": 1, "block": 100, "ts": {BASE_WALL_NANOS}, "books": [
{{"maker": "Fermi", "quoteAddress": "{PAMM}", "token1": "WBTC", "token2": "USDC",
"token1Address": "{WBTC}", "token2Address": "{USDC}",
"calculated_from": {calculated_from},
"bids": [{{"price": 100000.0, "cumVolume": 1.0}}],
"asks": [{{"price": 100000.0, "cumVolume": 1.0}}]}}
]}}"#
);
serde_json::from_str(&text).expect("the message parses")
}
const UNREADABLE: &str = r#""283851543383726791766048901""#;
#[test]
fn a_book_with_an_unreadable_quote_sequence_still_quotes() {
let clock = Clock::new();
let mut tracker = tracker();
let update = tracker.on_price_level_message(with_calculated_from(UNREADABLE), clock.at(0));
let update = update.expect("update expected");
assert_eq!(usdc_for_one_wbtc(state_of(&update)), BigUint::from(100_000_000_000u64));
}
#[rstest]
#[case::entry_under_the_streamed_address(KIPSELI_STREAMED)]
#[case::entry_under_the_public_identity(KIPSELI)]
fn an_aliased_venue_gets_overrides_under_its_public_identity(#[case] entry_venue: &str) {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker_serving(vec![kipseli_custom()], false);
let books = vec![book_at_sequence(KIPSELI_STREAMED, "WBTC", "USDC", 100_000.0, SEQUENCE)];
tracker.on_quote_stream_message(one_entry(
entry_venue,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE)],
));
let update = tracker
.on_price_level_message(captured_slot_message(books), clock.after(Duration::ZERO));
let update = update.expect("update expected");
assert_eq!(ids_with_overrides(&update, true), vec![pair_id(KIPSELI, WBTC, USDC)]);
for id in update.states.keys() {
assert!(!id.contains(&KIPSELI_STREAMED[2..]), "{id} carries the streamed address");
}
}
#[test]
fn an_entry_reaches_only_its_own_venue_and_pairs() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = detecting_tracker(true);
let books = vec![
wbtc_usdc_at(SEQUENCE),
book_at_sequence(PAMM, "WETH", "USDC", 3_000.0, SEQUENCE),
book_at_sequence(PAMM, "WBTC", "WETH", 33.0, SEQUENCE),
book_at_sequence(UNREGISTERED_VENUE, "WBTC", "USDC", 100_000.0, SEQUENCE),
];
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE), (WETH, USDC, SEQUENCE)],
));
let update = tracker
.on_price_level_message(captured_slot_message(books), clock.after(Duration::ZERO));
let update = update.expect("update expected");
assert_eq!(update.states.len(), 4);
let mut listed = vec![pair_id(PAMM, WBTC, USDC), pair_id(PAMM, WETH, USDC)];
listed.sort();
assert_eq!(ids_with_overrides(&update, true), listed);
assert_eq!(
state_at(&update, &pair_id(PAMM, WBTC, USDC)).simulation_overrides(),
state_at(&update, &pair_id(PAMM, WETH, USDC)).simulation_overrides()
);
}
#[test]
fn an_entry_merges_into_the_venues_its_priced_addresses_name() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let second_source = "0x00000000000000000000000000000000000000aa";
let second_account = "0x00000000000000000000000000000000000000bb";
let pairs = [(WBTC, USDC, SEQUENCE)];
let quote_address = format!(r#""quoteAddress": "{second_source}","#);
let priced = format!(r#""pricedAddresses": ["{second_source}", "{PAMM}"],"#);
let second = override_entry(second_source, WHOLE_SECOND_NANOS, 7, &pairs)
.replace("e_address, &format!("{quote_address} {priced}"))
.replace(SYNTHETIC_ACCOUNT, second_account);
let later_only = |source: &str| {
override_entry(source, WHOLE_SECOND_NANOS, 9, &[(WBTC, USDC, SEQUENCE + 1)]).replace(
&format!(r#""quoteAddress": "{source}","#),
&format!(r#""quoteAddress": "{source}", "pricedAddresses": ["{PAMM}"],"#),
)
};
let entries = quote_stream_message(&[
second,
later_only("0x00000000000000000000000000000000000000cc"),
later_only("0x00000000000000000000000000000000000000dd"),
override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &pairs),
]);
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(entries);
tracker.on_price_level_message(
captured_slot_message(vec![wbtc_usdc_at(SEQUENCE)]),
clock.after(Duration::ZERO),
)
});
let update = update.expect("update expected");
let overrides = state_of(&update)
.simulation_overrides()
.expect("overrides");
assert_eq!(overrides.accounts.len(), 2);
assert!(overrides
.accounts
.contains_key(&address(second_account)));
assert_eq!(overrides.accounts[&address(SYNTHETIC_ACCOUNT)].nonce, Some(1));
assert_eq!(
counter_value(&snapshot, OVERRIDE_MERGED_SOURCES_TOTAL, &[("venue", "fermiswap")]),
1
);
assert_eq!(
counter_value(&snapshot, OVERRIDE_SKIPPED_SOURCES_TOTAL, &[("venue", "fermiswap")]),
2
);
}
#[test]
fn entries_are_stored_once_their_venue_is_served() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let now = clock.after(Duration::ZERO);
let pairs = [(WBTC, USDC, SEQUENCE)];
let message = || {
captured_slot_message(vec![book_at_sequence(
UNREGISTERED_VENUE,
"WBTC",
"USDC",
100_000.0,
SEQUENCE,
)])
};
let mut tracker = detecting_tracker(true);
tracker.on_quote_stream_message(one_entry(UNREGISTERED_VENUE, WHOLE_SECOND_NANOS, &pairs));
let first = tracker.on_price_level_message(message(), now);
tracker.on_quote_stream_message(one_entry(UNREGISTERED_VENUE, WHOLE_SECOND_NANOS, &pairs));
let second = tracker.on_price_level_message(message(), now);
let first = first.expect("update expected");
let second = second.expect("update expected");
assert!(ids_with_overrides(&first, true).is_empty(), "stored before the venue was served");
assert_eq!(
ids_with_overrides(&second, true),
vec![pair_id(UNREGISTERED_VENUE, WBTC, USDC)]
);
}
#[test]
fn a_book_with_only_a_later_entry_gets_none_and_still_quotes() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE + 1)],
));
let update = tracker.on_price_level_message(
captured_slot_message(vec![wbtc_usdc_at(SEQUENCE)]),
clock.after(Duration::ZERO),
);
let update = update.expect("update expected");
let state = state_of(&update);
assert_eq!(state.simulation_overrides(), None);
assert_eq!(usdc_for_one_wbtc(state), BigUint::from(100_000_000_000u64));
}
#[test]
fn a_duplicate_book_is_served_with_its_own_quote_sequence() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let entries = quote_stream_message(&[
override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &[(WBTC, USDC, SEQUENCE)]),
override_entry(PAMM, WHOLE_SECOND_NANOS, 2, &[(WBTC, USDC, SEQUENCE + 5)]),
]);
let books = vec![
wbtc_usdc_at(SEQUENCE + 5),
book_at_sequence(PAMM, "WBTC", "USDC", 101_000.0, SEQUENCE),
];
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(entries);
tracker
.on_price_level_message(captured_slot_message(books), clock.after(Duration::ZERO))
});
let update = update.expect("update expected");
let state = state_of(&update);
assert_eq!(usdc_for_one_wbtc(state), BigUint::from(101_000_000_000u64));
let overrides = state
.simulation_overrides()
.expect("overrides");
assert_eq!(overrides.accounts[&address(SYNTHETIC_ACCOUNT)].nonce, Some(1));
assert_eq!(counter_value(&snapshot, DUPLICATE_BOOKS_TOTAL, &[]), 1);
}
#[test]
fn a_refused_entry_does_not_cost_the_rest_of_its_message() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let no_timestamp = override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &[(WETH, USDC, SEQUENCE)])
.replace(&WHOLE_SECOND_NANOS.to_string(), "null");
let mut tracker = tracker();
let books =
vec![book_at_sequence(PAMM, "WETH", "USDC", 3_000.0, SEQUENCE), wbtc_usdc_at(SEQUENCE)];
tracker.on_quote_stream_message(quote_stream_message(&[
no_timestamp,
override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &[(WBTC, USDC, SEQUENCE)]),
]));
let update = tracker
.on_price_level_message(captured_slot_message(books), clock.after(Duration::ZERO));
let update = update.expect("update expected");
assert_eq!(ids_with_overrides(&update, true), vec![pair_id(PAMM, WBTC, USDC)]);
}
#[test]
fn overrides_off_leaves_every_state_without_overrides() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker_with_overrides(false);
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE)],
));
let update = tracker.on_price_level_message(
captured_slot_message(vec![wbtc_usdc_at(SEQUENCE)]),
clock.after(Duration::ZERO),
);
assert_eq!(state_of(&update.expect("update expected")).simulation_overrides(), None);
}
#[rstest]
#[case::same_sequence(Some(SEQUENCE), wbtc_usdc_at(SEQUENCE), "same_sequence")]
#[case::earlier_sequence(Some(SEQUENCE), wbtc_usdc_at(SEQUENCE + 3), "earlier_sequence")]
#[case::none_in_slot(None, wbtc_usdc_at(SEQUENCE), "none_in_slot")]
#[case::no_quote_sequence(
Some(SEQUENCE),
two_sided(PAMM, "WBTC", "USDC", 100_000.0),
"no_quote_sequence"
)]
fn each_match_outcome_is_counted_under_its_venue(
#[case] entry_sequence: Option<u128>,
#[case] book: TitanBook,
#[case] outcome: &str,
) {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let ((), snapshot) = record_async(async {
if let Some(sequence) = entry_sequence {
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, sequence)],
));
}
tracker.on_price_level_message(
captured_slot_message(vec![book]),
clock.after(Duration::ZERO),
);
});
for counted in ["same_sequence", "earlier_sequence", "none_in_slot", "no_quote_sequence"] {
assert_eq!(
counter_value(
&snapshot,
OVERRIDE_MATCH_TOTAL,
&[("venue", "fermiswap"), ("outcome", counted)]
),
u64::from(counted == outcome),
"{counted}"
);
}
}
#[test]
fn the_slot_window_follows_the_price_level_messages() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let two_slots_on = message_at_slot(
CAPTURED_BLOCK + 2,
Some(CAPTURED_SLOT + 2),
vec![wbtc_usdc_at(sequence_in(CAPTURED_SLOT + 2, 1))],
);
let entry = || one_entry(PAMM, WHOLE_SECOND_NANOS, &[(WBTC, USDC, SEQUENCE)]);
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(entry());
let update = tracker.on_price_level_message(two_slots_on, clock.after(Duration::ZERO));
tracker.on_quote_stream_message(entry());
update
});
assert_eq!(state_of(&update.expect("update expected")).simulation_overrides(), None);
for (event, count) in
[("added", 1), ("left_slot_window", 1), ("arrived_outside_slot_window", 1)]
{
assert_eq!(
counter_value(&snapshot, OVERRIDE_BUFFER_TOTAL, &[("event", event)]),
count,
"{event}"
);
}
}
#[rstest]
#[case::a_book_names_a_later_slot(wbtc_usdc_at(sequence_in(CAPTURED_SLOT + 2, 1)), 1)]
#[case::no_book_names_a_quote_sequence(two_sided(PAMM, "WBTC", "USDC", 100_000.0), 0)]
fn a_message_without_a_slot_moves_the_window_by_its_books(
#[case] book: TitanBook,
#[case] left_slot_window: u64,
) {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let ((), snapshot) = record_async(async {
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE)],
));
tracker.on_price_level_message(
message_at_slot(CAPTURED_BLOCK + 2, None, vec![book]),
clock.after(Duration::ZERO),
);
});
assert_eq!(
counter_value(&snapshot, OVERRIDE_BUFFER_TOTAL, &[("event", "left_slot_window")]),
left_slot_window
);
assert_eq!(counter_value(&snapshot, MESSAGES_WITHOUT_SLOT_TOTAL, &[]), 1);
assert_eq!(
counter_value(&snapshot, SEQUENCE_SLOT_MISMATCH_TOTAL, &[("socket", "price_levels")]),
0
);
}
#[test]
fn broken_assumptions_are_counted() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let next_slot = message_at_slot(
CAPTURED_BLOCK + 1,
Some(CAPTURED_SLOT + 1),
vec![wbtc_usdc_at(SEQUENCE)],
);
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE)],
));
tracker.on_price_level_message(next_slot, clock.after(Duration::ZERO))
});
assert!(state_of(&update.expect("update expected"))
.simulation_overrides()
.is_some());
assert_eq!(
counter_value(&snapshot, SEQUENCE_SLOT_MISMATCH_TOTAL, &[("socket", "price_levels")]),
1
);
assert_eq!(counter_value(&snapshot, OVERRIDE_BLOCK_MISMATCH_TOTAL, &[]), 1);
}
#[test]
fn the_shape_of_each_accepted_entry_is_counted() {
let pairs = [(WBTC, USDC, SEQUENCE)];
let entry = || override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &pairs);
let entries = quote_stream_message(&[
entry().replace(&format!(r#""blockNumber": {CAPTURED_BLOCK},"#), ""),
entry().replace(&format!(r#""slot": {CAPTURED_SLOT},"#), ""),
override_entry(
PAMM,
WHOLE_SECOND_NANOS,
1,
&[(WBTC, USDC, sequence_in(CAPTURED_SLOT + 5, 1))],
),
override_entry(UNREGISTERED_VENUE, WHOLE_SECOND_NANOS, 1, &pairs),
]);
let mut tracker = tracker();
let ((), snapshot) = record_async(async { tracker.on_quote_stream_message(entries) });
for (name, labels) in [
(MISSING_FIELD_TOTAL, vec![("field", "block_number")]),
(MISSING_FIELD_TOTAL, vec![("field", "slot")]),
(SEQUENCE_SLOT_MISMATCH_TOTAL, vec![("socket", "quote_stream")]),
(UNSERVED_VENUE_ENTRIES_TOTAL, vec![]),
] {
assert_eq!(counter_value(&snapshot, name, &labels), 1, "{name} {labels:?}");
}
assert_eq!(histogram_values(&snapshot, ENTRY_ACCOUNTS, &[]), vec![1.0; 4]);
assert_eq!(histogram_values(&snapshot, ENTRY_STORAGE_SLOTS, &[]), vec![0.0; 4]);
}
#[rstest]
#[case::unreadable(UNREADABLE, true, 1)]
#[case::absent("null", true, 0)]
#[case::unreadable_without_overrides(UNREADABLE, false, 1)]
fn an_unreadable_quote_sequence_is_counted_apart_from_an_absent_one(
#[case] calculated_from: &str,
#[case] overrides_on: bool,
#[case] counted: u64,
) {
let clock = Clock::new();
let (update, snapshot) = record_async(async {
tracker_with_overrides(overrides_on)
.on_price_level_message(with_calculated_from(calculated_from), clock.at(0))
});
assert!(update.is_some());
assert!(
counter_registered(&snapshot, UNREADABLE_QUOTE_SEQUENCE_TOTAL, &[]),
"unreadable_quote_sequence_total is a missing series"
);
assert_eq!(counter_value(&snapshot, UNREADABLE_QUOTE_SEQUENCE_TOTAL, &[]), counted);
}
#[test]
fn buffer_events_are_counted() {
let pairs = [(WBTC, USDC, SEQUENCE), (WETH, USDC, SEQUENCE)];
let no_timestamp = override_entry(PAMM, WHOLE_SECOND_NANOS, 1, &pairs)
.replace(&WHOLE_SECOND_NANOS.to_string(), "null");
let messages = [
one_entry(PAMM, WHOLE_SECOND_NANOS, &pairs),
one_entry(PAMM, WHOLE_SECOND_NANOS, &pairs),
one_entry(PAMM, WHOLE_SECOND_NANOS + 1, &pairs),
quote_stream_message(&[override_entry(PAMM, WHOLE_SECOND_NANOS + 1, 2, &pairs)]),
quote_stream_message(&[no_timestamp]),
];
let mut tracker = tracker();
let ((), snapshot) = record_async(async {
for message in messages {
tracker.on_quote_stream_message(message);
}
});
for event in
["added", "resent_unchanged", "replaced_by_newer", "resent_with_different_state"]
{
assert_eq!(
counter_value(&snapshot, OVERRIDE_BUFFER_TOTAL, &[("event", event)]),
2,
"{event}"
);
}
assert_eq!(
counter_value(&snapshot, REFUSED_ENTRIES_TOTAL, &[("reason", "no_timestamp")]),
1
);
}
#[rstest]
#[case::overrides_on(true)]
#[case::overrides_off(false)]
fn series_a_new_tracker_registers(#[case] overrides_on: bool) {
let ((), snapshot) = record_async(async {
drop(tracker_with_overrides(overrides_on));
});
for (name, labels) in [
(OVERRIDE_MATCH_TOTAL, vec![("venue", "fermiswap"), ("outcome", "same_sequence")]),
(OVERRIDE_MERGED_SOURCES_TOTAL, vec![("venue", "fermiswap")]),
(OVERRIDE_SKIPPED_SOURCES_TOTAL, vec![("venue", "fermiswap")]),
(OVERRIDE_BUFFER_TOTAL, vec![("event", "added")]),
(REFUSED_ENTRIES_TOTAL, vec![("reason", "no_timestamp")]),
(OVERRIDE_BLOCK_MISMATCH_TOTAL, vec![]),
(RECONNECTS, vec![("socket", "quote_stream"), ("reason", "closed")]),
] {
assert_eq!(
counter_registered(&snapshot, name, &labels),
overrides_on,
"{name} registration with overrides {overrides_on}"
);
assert_eq!(counter_value(&snapshot, name, &labels), 0, "{name}");
}
assert!(counter_registered(&snapshot, UNREADABLE_QUOTE_SEQUENCE_TOTAL, &[]));
assert!(counter_registered(&snapshot, MESSAGES_WITHOUT_SLOT_TOTAL, &[]));
}
#[rstest]
#[case::overrides_on(true)]
#[case::overrides_off(false)]
fn an_auto_detected_venue_registers_its_match_outcomes(#[case] overrides_on: bool) {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = detecting_tracker(overrides_on);
let books = vec![two_sided(UNREGISTERED_VENUE, "WBTC", "USDC", 100_000.0)];
let ((), snapshot) = record_async(async {
tracker
.on_price_level_message(captured_slot_message(books), clock.after(Duration::ZERO));
});
for outcome in ["same_sequence", "earlier_sequence", "none_in_slot", "no_quote_sequence"] {
assert_eq!(
counter_registered(
&snapshot,
OVERRIDE_MATCH_TOTAL,
&[("venue", UNREGISTERED_VENUE), ("outcome", outcome)]
),
overrides_on,
"{outcome}"
);
}
assert_eq!(
counter_value(
&snapshot,
OVERRIDE_MATCH_TOTAL,
&[("venue", UNREGISTERED_VENUE), ("outcome", "no_quote_sequence")]
),
u64::from(overrides_on)
);
}
#[test]
fn no_streamed_value_becomes_a_metric_label() {
let clock = Clock::based_at(WHOLE_SECOND_NANOS);
let mut tracker = tracker();
let (update, snapshot) = record_async(async {
tracker.on_quote_stream_message(one_entry(
PAMM,
WHOLE_SECOND_NANOS,
&[(WBTC, USDC, SEQUENCE)],
));
tracker.on_price_level_message(
captured_slot_message(vec![wbtc_usdc_at(SEQUENCE)]),
clock.after(Duration::ZERO),
)
});
assert!(update.is_some());
assert_eq!(
counter_value(
&snapshot,
OVERRIDE_MATCH_TOTAL,
&[("venue", "fermiswap"), ("outcome", "same_sequence")]
),
1
);
let labels = all_label_values(&snapshot);
for streamed_value in [SEQUENCE.to_string(), pair_id(PAMM, WBTC, USDC), PAMM.to_string()] {
assert!(
!labels.contains(&streamed_value.as_str()),
"{streamed_value} became a metric label: {labels:?}"
);
}
}
}