1use std::{
2 collections::{HashMap, HashSet},
3 pin::Pin,
4 time::{Duration, Instant, SystemTime, UNIX_EPOCH},
5};
6
7use async_stream::stream;
8use num_bigint::BigUint;
9use tokio_stream::{Stream, StreamExt};
10use tycho_common::{models::token::Token, Bytes};
11
12use super::{
13 config::{
14 canonical_pamm_address, default_denied_pamms, default_served_pamms, PriceLevelStreamConfig,
15 DEFAULT_AUTO_DETECTED_GAS_COST,
16 },
17 titan::{
18 self, ConnectionSettings, TitanQuoteStreamMessage, TITAN_PRICE_LEVEL_URL,
19 TITAN_PRICE_LEVEL_URL_ENV, TITAN_QUOTE_STREAM_URL, TITAN_QUOTE_STREAM_URL_ENV,
20 },
21 tracker::{FreshnessTracker, Now, TrackerSettings, DEFAULT_STALE_AFTER},
22};
23use crate::protocol::models::Update;
24
25pub const PAMM_ADDRESS_ATTRIBUTE: &str = "pamm_address";
27
28pub const MAX_STALE_AFTER: Duration = Duration::from_secs(3600);
33
34pub struct PriceLevelStreamBuilder {
48 registry: HashMap<Bytes, PriceLevelStreamConfig>,
50 denied: HashSet<Bytes>,
52 tokens: HashMap<Bytes, Token>,
53 url: Option<String>,
54 quote_stream_url: Option<String>,
56 simulation_overrides: bool,
58 auto_detect: bool,
59 auto_detected_gas_cost: Option<BigUint>,
60 connection: ConnectionSettings,
61 fallback_router: bool,
64 stale_after: Duration,
66 quote_guard: bool,
68}
69
70impl Default for PriceLevelStreamBuilder {
71 fn default() -> Self {
72 Self {
73 registry: HashMap::new(),
74 denied: HashSet::new(),
75 tokens: HashMap::new(),
76 url: None,
77 quote_stream_url: None,
78 simulation_overrides: true,
79 auto_detect: false,
80 auto_detected_gas_cost: None,
81 connection: ConnectionSettings::default(),
82 fallback_router: true,
83 stale_after: DEFAULT_STALE_AFTER,
84 quote_guard: true,
85 }
86 }
87}
88
89impl PriceLevelStreamBuilder {
90 pub fn new() -> Self {
91 Self::default()
92 }
93
94 pub fn auto_detect(mut self, enabled: bool) -> Self {
106 self.auto_detect = enabled;
107 self
108 }
109
110 pub fn auto_detected_gas_cost(mut self, gas_cost: BigUint) -> Self {
115 self.auto_detected_gas_cost = Some(gas_cost);
116 self
117 }
118
119 pub fn endpoint(mut self, url: impl Into<String>) -> Self {
130 self.url = Some(url.into());
131 self
132 }
133
134 pub fn quote_stream_endpoint(mut self, url: impl Into<String>) -> Self {
140 self.quote_stream_url = Some(url.into());
141 self
142 }
143
144 pub fn without_simulation_overrides(mut self) -> Self {
153 self.simulation_overrides = false;
154 self
155 }
156
157 pub fn connect_timeout(mut self, timeout: Duration) -> Self {
161 self.connection.connect_timeout = timeout;
162 self
163 }
164
165 pub fn read_idle_timeout(mut self, timeout: Duration) -> Self {
172 self.connection.read_idle_timeout = timeout;
173 self
174 }
175
176 pub fn max_backoff(mut self, max_backoff: Duration) -> Self {
179 self.connection.max_backoff = max_backoff;
180 self
181 }
182
183 pub fn add_pamm(mut self, config: PriceLevelStreamConfig) -> Self {
194 let config =
195 PriceLevelStreamConfig { address: canonical_pamm_address(&config.address), ..config };
196 self.denied.remove(&config.address);
197 self.registry
198 .insert(config.address.clone(), config);
199 self
200 }
201
202 pub fn deny_pamm(mut self, address: Bytes) -> Self {
213 let address = canonical_pamm_address(&address);
214 self.registry.remove(&address);
215 self.denied.insert(address);
216 self
217 }
218
219 pub fn with_known_pamms(mut self) -> Self {
226 for config in default_served_pamms() {
227 let config = PriceLevelStreamConfig {
228 address: canonical_pamm_address(&config.address),
229 ..config
230 };
231 if self.denied.contains(&config.address) {
232 continue;
233 }
234 self.registry
235 .entry(config.address.clone())
236 .or_insert(config);
237 }
238 for address in default_denied_pamms() {
239 let address = canonical_pamm_address(&address);
240 if self.registry.contains_key(&address) {
241 continue;
242 }
243 self.denied.insert(address);
244 }
245 self
246 }
247
248 pub fn with_tokens(mut self, tokens: HashMap<Bytes, Token>) -> Self {
253 self.tokens = tokens;
254 self
255 }
256
257 pub fn without_fallback_router(mut self) -> Self {
264 self.fallback_router = false;
265 self
266 }
267
268 pub fn stale_after(mut self, duration: Duration) -> Self {
279 self.stale_after = duration.min(MAX_STALE_AFTER);
280 self
281 }
282
283 pub fn without_quote_guard(mut self) -> Self {
294 self.quote_guard = false;
295 self
296 }
297
298 pub fn build(self) -> impl Stream<Item = Update> + Send {
334 let Self {
335 registry,
336 denied,
337 tokens,
338 url,
339 quote_stream_url,
340 simulation_overrides,
341 auto_detect,
342 auto_detected_gas_cost,
343 connection,
344 fallback_router,
345 stale_after,
346 quote_guard,
347 } = self;
348 if registry.is_empty() && !auto_detect {
349 tracing::warn!(
350 "No pAMMs registered and auto-detection is off; the stream will never produce \
351 an update"
352 );
353 }
354 if tokens.is_empty() {
355 tracing::warn!(
356 "No token metadata provided; every streamed book will be skipped and the stream \
357 will never produce an update"
358 );
359 }
360 let url = url.unwrap_or_else(|| {
361 std::env::var(TITAN_PRICE_LEVEL_URL_ENV)
362 .unwrap_or_else(|_| TITAN_PRICE_LEVEL_URL.to_string())
363 });
364 let quote_stream_url = simulation_overrides.then(|| {
365 quote_stream_url.unwrap_or_else(|| {
366 std::env::var(TITAN_QUOTE_STREAM_URL_ENV)
367 .unwrap_or_else(|_| TITAN_QUOTE_STREAM_URL.to_string())
368 })
369 });
370 if let Some(quote_stream_url) = "e_stream_url {
371 if (url == TITAN_PRICE_LEVEL_URL) != (quote_stream_url == TITAN_QUOTE_STREAM_URL) {
372 tracing::warn!(
373 price_level_url = url,
374 quote_stream_url,
375 "Only one of the two Titan endpoints is customized; the quote stream of one \
376 region may not match the price levels of another, which costs states their \
377 simulation overrides"
378 );
379 }
380 }
381 let auto_detected_gas_cost =
382 auto_detected_gas_cost.unwrap_or_else(|| BigUint::from(DEFAULT_AUTO_DETECTED_GAS_COST));
383 let mut tracker = FreshnessTracker::new(TrackerSettings {
384 registry,
385 denied,
386 tokens,
387 auto_detect,
388 auto_detected_gas_cost,
389 stale_after,
390 via_fallback_router: fallback_router,
391 quote_guard,
392 simulation_overrides,
393 });
394
395 stream! {
396 let messages = titan::messages(url, connection);
397 tokio::pin!(messages);
398 let mut quote_stream_messages: Pin<
400 Box<dyn Stream<Item = TitanQuoteStreamMessage> + Send>,
401 > = match quote_stream_url {
402 Some(url) => {
403 Box::pin(titan::messages::<TitanQuoteStreamMessage>(url, connection))
404 }
405 None => Box::pin(tokio_stream::pending()),
406 };
407 loop {
408 let deadline = tracker.stale_deadline();
409 let sleep_until_deadline = tokio::time::sleep_until(
410 deadline.map_or_else(tokio::time::Instant::now, tokio::time::Instant::from_std),
411 );
412 let update = tokio::select! {
413 Some(message) = messages.next() => {
414 tracker.on_price_level_message(message, now())
415 }
416 Some(message) = quote_stream_messages.next() => {
417 tracker.on_quote_stream_message(message);
418 None
419 }
420 () = sleep_until_deadline, if deadline.is_some() => {
421 tracker.on_stale_deadline(timer_now())
422 }
423 };
424 if let Some(update) = update {
425 yield update;
426 }
427 }
428 }
429 }
430}
431
432fn now() -> Now {
436 Now { wall_nanos: wall_clock_nanos(), monotonic: timer_now() }
437}
438
439fn wall_clock_nanos() -> u64 {
442 let since_epoch = SystemTime::now()
443 .duration_since(UNIX_EPOCH)
444 .ok()
445 .and_then(|since_epoch| u64::try_from(since_epoch.as_nanos()).ok());
446 match since_epoch {
447 Some(wall_nanos) => wall_nanos,
448 None => {
449 tracing::error!(
450 "System clock unrepresentable as unix nanoseconds; every price level message will \
451 be rejected as in_future"
452 );
453 0
454 }
455 }
456}
457
458fn timer_now() -> Instant {
462 tokio::time::Instant::now().into_std()
463}
464
465#[cfg(test)]
466mod tests {
467 use std::{
468 pin::Pin,
469 str::FromStr,
470 sync::{
471 atomic::{AtomicBool, AtomicUsize, Ordering},
472 Arc,
473 },
474 time::Duration,
475 };
476
477 use futures::{future::BoxFuture, SinkExt};
478 use num_bigint::BigUint;
479 use rstest::rstest;
480 use tokio_tungstenite::tungstenite::Message;
481
482 use super::{
483 super::{
484 config::{default_denied_pamms, PriceLevelStreamConfig},
485 state::PriceLevelStreamState,
486 telemetry::{
487 recorded::{counter_value, record_async},
488 RECONNECTS,
489 },
490 test_support::{
491 address, captured_message_text, captured_quote_stream_text, captured_tokens,
492 fermiswap, matching_message_text, message_text, message_then_repeat, token,
493 token_map, tokens, wall_nanos_now, FakeConnection, FakeTitan, KIPSELI,
494 KIPSELI_STREAMED, PAMM, USDC, WBTC, WETH,
495 },
496 },
497 *,
498 };
499
500 #[test]
501 fn explicit_add_and_deny_are_last_wins() {
502 let address = Bytes::from_str(PAMM).unwrap();
503 let custom =
504 || PriceLevelStreamConfig::new("custom", Bytes::from_str(PAMM).unwrap(), 1u64.into());
505
506 let builder = PriceLevelStreamBuilder::new()
507 .add_pamm(custom())
508 .deny_pamm(address.clone());
509 assert!(!builder.registry.contains_key(&address));
510 assert!(builder.denied.contains(&address));
511
512 let builder = PriceLevelStreamBuilder::new()
513 .deny_pamm(address.clone())
514 .add_pamm(custom());
515 assert_eq!(builder.registry[&address].protocol, "custom");
516 assert!(builder.denied.is_empty());
517 }
518
519 #[test]
520 fn quote_guard_is_on_unless_opted_out() {
521 assert!(PriceLevelStreamBuilder::new().quote_guard);
522 assert!(
523 !PriceLevelStreamBuilder::new()
524 .without_quote_guard()
525 .quote_guard
526 );
527 }
528
529 fn timings(fake: &FakeTitan) -> PriceLevelStreamBuilder {
536 PriceLevelStreamBuilder::new()
537 .endpoint(fake.url())
538 .stale_after(STALE_AFTER)
539 .connect_timeout(Duration::from_secs(1))
540 .read_idle_timeout(Duration::from_millis(100))
541 .max_backoff(Duration::from_millis(20))
542 }
543
544 fn fast_timings(fake: &FakeTitan) -> PriceLevelStreamBuilder {
546 timings(fake).without_simulation_overrides()
547 }
548
549 fn two_socket_timings(prices: &FakeTitan, overrides: &FakeTitan) -> PriceLevelStreamBuilder {
552 timings(prices).quote_stream_endpoint(overrides.url())
553 }
554
555 fn fast_builder(fake: &FakeTitan) -> PriceLevelStreamBuilder {
557 fast_timings(fake)
558 .add_pamm(fermiswap())
559 .with_tokens(tokens())
560 }
561
562 const STALE_AFTER: Duration = Duration::from_secs(2);
565
566 const WAIT: Duration = Duration::from_secs(5);
568
569 async fn next_within(
570 stream: &mut Pin<&mut impl Stream<Item = Update>>,
571 limit: Duration,
572 ) -> Option<Update> {
573 tokio::time::timeout(limit, stream.next())
574 .await
575 .ok()
576 .flatten()
577 }
578
579 async fn expect_first_update(stream: &mut Pin<&mut impl Stream<Item = Update>>) -> Update {
581 let first = next_within(stream, WAIT)
582 .await
583 .expect("first update");
584 assert_eq!(first.new_pairs.len(), 1);
585 assert!(first.removed_pairs.is_empty());
586 first
587 }
588
589 async fn expect_removal(stream: &mut Pin<&mut impl Stream<Item = Update>>) -> Update {
592 tokio::time::timeout(WAIT, async {
593 loop {
594 let update = stream
595 .next()
596 .await
597 .expect("stream ended");
598 if !update.removed_pairs.is_empty() {
599 return update;
600 }
601 assert!(update.new_pairs.is_empty(), "component re-added before the removal");
602 }
603 })
604 .await
605 .expect("removal")
606 }
607
608 fn assert_removal_only(update: &Update, expected_removed: usize) {
609 assert!(update.states.is_empty());
610 assert!(update.new_pairs.is_empty());
611 assert!(update.sync_states.is_empty());
612 assert!(update.is_partial);
613 assert_eq!(update.removed_pairs.len(), expected_removed);
614 }
615
616 fn fresh_message() -> Message {
617 Message::Text(message_text(100, wall_nanos_now()).into())
618 }
619
620 async fn first_connection_sends_one_message(index: usize, mut socket: FakeConnection) {
622 if index == 0 {
623 let _ = socket.send(fresh_message()).await;
624 }
625 std::future::pending::<()>().await;
626 }
627
628 #[tokio::test]
629 async fn silence_past_stale_after_removes_every_served_component() {
630 let fake = FakeTitan::spawn(first_connection_sends_one_message).await;
631 let stream = fast_builder(&fake).build();
632 tokio::pin!(stream);
633
634 expect_first_update(&mut stream).await;
635 let removal = next_within(&mut stream, WAIT)
638 .await
639 .expect("removal");
640
641 assert_removal_only(&removal, 1);
642 assert_eq!(removal.block_number, 100);
643 assert!(fake.connections.load(Ordering::SeqCst) >= 2, "no reconnect on idle timeout");
644 }
645
646 #[tokio::test]
647 async fn repeated_immediate_closes_remove_within_stale_after() {
648 let fake = FakeTitan::spawn(|index, mut socket| async move {
649 if index == 0 {
650 let _ = socket.send(fresh_message()).await;
651 tokio::time::sleep(Duration::from_millis(20)).await;
652 }
653 let _ = socket.close(None).await;
654 })
655 .await;
656 let stream = fast_builder(&fake).build();
657 tokio::pin!(stream);
658
659 expect_first_update(&mut stream).await;
660 let removal = next_within(&mut stream, WAIT)
661 .await
662 .expect("removal");
663
664 assert_removal_only(&removal, 1);
665 }
666
667 #[test]
668 fn refused_reconnects_remove_within_stale_after() {
669 let (removal, snapshot) = record_async(async {
670 let mut fake = FakeTitan::spawn(|_, mut socket| async move {
671 let _ = socket.send(fresh_message()).await;
672 tokio::time::sleep(Duration::from_millis(20)).await;
673 let _ = socket.close(None).await;
674 })
675 .await;
676 let stream = fast_builder(&fake).build();
677 tokio::pin!(stream);
678
679 expect_first_update(&mut stream).await;
680 fake.shutdown();
684 expect_removal(&mut stream).await
685 });
686
687 assert_removal_only(&removal, 1);
688 assert!(
689 counter_value(
690 &snapshot,
691 RECONNECTS,
692 &[("reason", "connect_failed"), ("socket", "price_levels")]
693 ) >= 1,
694 "no connect was refused"
695 );
696 }
697
698 #[tokio::test]
699 async fn replayed_messages_remove_within_stale_after_and_never_re_add() {
700 let replay = fresh_message();
702 let fake = FakeTitan::spawn(message_then_repeat(
703 replay.clone(),
704 replay,
705 Duration::from_millis(50),
706 ))
707 .await;
708 let stream = fast_builder(&fake)
709 .read_idle_timeout(Duration::from_secs(5))
710 .build();
711 tokio::pin!(stream);
712
713 expect_first_update(&mut stream).await;
714 let removal = expect_removal(&mut stream).await;
717
718 assert_removal_only(&removal, 1);
719 assert!(next_within(&mut stream, Duration::from_millis(500))
721 .await
722 .is_none());
723 }
724
725 #[tokio::test]
726 async fn fresh_message_after_removal_re_adds_the_component() {
727 let fake = FakeTitan::spawn(|_, mut socket| async move {
728 let _ = socket.send(fresh_message()).await;
729 tokio::time::sleep(STALE_AFTER + Duration::from_millis(500)).await;
730 let _ = socket
731 .send(Message::Text(message_text(101, wall_nanos_now()).into()))
732 .await;
733 std::future::pending::<()>().await;
734 })
735 .await;
736 let stream = fast_builder(&fake)
737 .read_idle_timeout(Duration::from_secs(5))
738 .build();
739 tokio::pin!(stream);
740
741 expect_first_update(&mut stream).await;
742 let removal = next_within(&mut stream, WAIT)
743 .await
744 .expect("removal");
745 let re_added = next_within(&mut stream, WAIT)
746 .await
747 .expect("re-add");
748
749 assert_removal_only(&removal, 1);
750 assert_eq!(re_added.new_pairs.len(), 1);
751 assert!(re_added.removed_pairs.is_empty());
752 assert_eq!(re_added.block_number, 101);
753 }
754
755 #[tokio::test]
756 async fn messages_are_forwarded_without_waiting_on_timers() {
757 let fake = FakeTitan::spawn(fresh_message_every(Duration::from_millis(50))).await;
758 let stream = fast_builder(&fake)
759 .stale_after(Duration::from_secs(24))
760 .build();
761 tokio::pin!(stream);
762
763 expect_first_update(&mut stream).await;
764 for _ in 0..5 {
765 let update = next_within(&mut stream, Duration::from_secs(1))
766 .await
767 .expect("steady-state message");
768 assert!(update.removed_pairs.is_empty());
769 }
770 }
771
772 #[tokio::test]
773 async fn no_connection_before_first_poll() {
774 let fake = FakeTitan::spawn(first_connection_sends_one_message).await;
775 let stream = fast_builder(&fake).build();
776 tokio::pin!(stream);
777
778 tokio::time::sleep(Duration::from_millis(150)).await;
779
780 assert_eq!(fake.connections.load(Ordering::SeqCst), 0, "connected before first poll");
781 }
782
783 #[tokio::test]
784 async fn drop_closes_the_socket() {
785 let server_saw_close = Arc::new(AtomicBool::new(false));
786 let fake = {
787 let server_saw_close = server_saw_close.clone();
788 FakeTitan::spawn(move |_, mut socket| {
789 let server_saw_close = server_saw_close.clone();
790 async move {
791 let _ = socket.send(fresh_message()).await;
792 while let Some(Ok(message)) = socket.next().await {
794 if matches!(message, Message::Close(_)) {
795 break;
796 }
797 }
798 server_saw_close.store(true, Ordering::SeqCst);
799 }
800 })
801 .await
802 };
803 let mut stream = Box::pin(
806 fast_builder(&fake)
807 .read_idle_timeout(Duration::from_secs(5))
808 .build(),
809 );
810 expect_first_update(&mut stream.as_mut()).await;
811
812 drop(stream);
813 tokio::time::sleep(Duration::from_millis(200)).await;
814
815 assert!(server_saw_close.load(Ordering::SeqCst), "socket not closed on drop");
816 assert_eq!(fake.connections.load(Ordering::SeqCst), 1, "reconnected after drop");
817 }
818
819 #[tokio::test]
822 async fn stale_after_above_the_cap_still_serves() {
823 assert_eq!(
824 PriceLevelStreamBuilder::new()
825 .stale_after(Duration::MAX)
826 .stale_after,
827 MAX_STALE_AFTER
828 );
829 let fake = FakeTitan::spawn(first_connection_sends_one_message).await;
830 let stream = fast_builder(&fake)
831 .stale_after(Duration::MAX)
832 .build();
833 tokio::pin!(stream);
834
835 expect_first_update(&mut stream).await;
836 }
837
838 #[tokio::test]
839 async fn without_quote_guard_emits_states_that_never_expire() {
840 let fake = FakeTitan::spawn(first_connection_sends_one_message).await;
841 let stream = fast_builder(&fake)
842 .without_quote_guard()
843 .build();
844 tokio::pin!(stream);
845
846 let first = expect_first_update(&mut stream).await;
847
848 let state = first
849 .states
850 .values()
851 .next()
852 .expect("one state")
853 .as_any()
854 .downcast_ref::<PriceLevelStreamState>()
855 .expect("price level state");
856 assert!(state.quotable_until().is_none());
857 }
858
859 fn fresh_message_every(
862 interval: Duration,
863 ) -> impl Fn(usize, FakeConnection) -> BoxFuture<'static, ()> + Send + Sync + 'static {
864 move |_, mut socket| {
865 Box::pin(async move {
866 while socket
867 .send(fresh_message())
868 .await
869 .is_ok()
870 {
871 tokio::time::sleep(interval).await;
872 }
873 })
874 }
875 }
876
877 #[test]
879 fn fallback_router_is_on_unless_opted_out() {
880 assert!(PriceLevelStreamBuilder::new().fallback_router);
881 assert!(
882 !PriceLevelStreamBuilder::new()
883 .without_fallback_router()
884 .fallback_router
885 );
886 }
887
888 #[test]
889 fn defaults_never_override_explicit_calls() {
890 let fermiswap_router = Bytes::from_str(PAMM).unwrap();
892 for builder in [
893 PriceLevelStreamBuilder::new()
894 .deny_pamm(fermiswap_router.clone())
895 .with_known_pamms(),
896 PriceLevelStreamBuilder::new()
897 .with_known_pamms()
898 .deny_pamm(fermiswap_router.clone()),
899 ] {
900 assert!(!builder
901 .registry
902 .contains_key(&fermiswap_router));
903 assert!(builder
904 .denied
905 .contains(&fermiswap_router));
906 assert!(!builder.registry.is_empty());
908 }
909
910 let Some(denied_venue) = default_denied_pamms().pop() else { return };
913 let custom = || PriceLevelStreamConfig::new("custom", denied_venue.clone(), 1u64.into());
914 for builder in [
915 PriceLevelStreamBuilder::new()
916 .add_pamm(custom())
917 .with_known_pamms(),
918 PriceLevelStreamBuilder::new()
919 .with_known_pamms()
920 .add_pamm(custom()),
921 ] {
922 assert_eq!(builder.registry[&denied_venue].protocol, "custom");
923 assert!(!builder.denied.contains(&denied_venue));
924 }
925 }
926
927 #[test]
928 fn with_known_pamms_registers_known_venues() {
929 let fermiswap_router = Bytes::from_str(PAMM).unwrap();
931
932 let builder = PriceLevelStreamBuilder::new();
933 assert!(builder.registry.is_empty());
934 assert!(builder.denied.is_empty());
935
936 let builder = builder.with_known_pamms();
937 assert_eq!(builder.registry[&fermiswap_router].protocol, "fermiswap");
938 assert_eq!(
940 builder.denied,
941 default_denied_pamms()
942 .into_iter()
943 .collect()
944 );
945 assert!(builder.denied.is_disjoint(
946 &builder
947 .registry
948 .keys()
949 .cloned()
950 .collect()
951 ));
952
953 let custom =
955 || PriceLevelStreamConfig::new("custom", fermiswap_router.clone(), BigUint::from(1u64));
956 for builder in [
957 PriceLevelStreamBuilder::new()
958 .add_pamm(custom())
959 .with_known_pamms(),
960 PriceLevelStreamBuilder::new()
961 .with_known_pamms()
962 .add_pamm(custom()),
963 ] {
964 assert_eq!(builder.registry[&fermiswap_router].protocol, "custom");
965 assert_eq!(builder.registry[&fermiswap_router].gas_cost, BigUint::from(1u64));
966 }
967 }
968
969 #[test]
972 fn families_match_the_execution_side_prefixes() {
973 use tycho_execution::encoding::evm::{FALLBACK_PREFIX, PRICE_LEVEL_STREAM_PREFIX};
974
975 use super::super::config::{FALLBACK_FAMILY, PRICE_LEVEL_STREAM_FAMILY};
976
977 assert_eq!(format!("{PRICE_LEVEL_STREAM_FAMILY}:"), PRICE_LEVEL_STREAM_PREFIX);
978 assert_eq!(format!("{FALLBACK_FAMILY}:"), FALLBACK_PREFIX);
979 }
980
981 #[rstest]
985 #[case::by_public_identity(KIPSELI)]
986 #[case::by_streamed_address(KIPSELI_STREAMED)]
987 fn registering_a_venue_registers_its_public_identity(#[case] registered: &str) {
988 let public = address(KIPSELI);
989
990 let builder = PriceLevelStreamBuilder::new().add_pamm(PriceLevelStreamConfig::new(
991 "custom",
992 address(registered),
993 1u64.into(),
994 ));
995
996 assert_eq!(builder.registry[&public].protocol, "custom");
997 assert_eq!(builder.registry[&public].address, public);
998 assert_eq!(builder.registry.len(), 1);
999 }
1000
1001 #[rstest]
1004 #[case::by_public_identity(KIPSELI)]
1005 #[case::by_streamed_address(KIPSELI_STREAMED)]
1006 fn denying_a_venue_denies_its_public_identity(#[case] denied: &str) {
1007 let public = address(KIPSELI);
1008
1009 let builder = PriceLevelStreamBuilder::new()
1010 .with_known_pamms()
1011 .deny_pamm(address(denied));
1012
1013 assert!(!builder.registry.contains_key(&public));
1014 assert!(!builder
1015 .registry
1016 .contains_key(&address(KIPSELI_STREAMED)));
1017 assert!(builder.denied.contains(&public));
1018 assert!(builder
1020 .registry
1021 .contains_key(&address(PAMM)));
1022 }
1023
1024 #[rstest]
1027 #[case::add_public_then_deny_streamed(KIPSELI, KIPSELI_STREAMED)]
1028 #[case::add_streamed_then_deny_public(KIPSELI_STREAMED, KIPSELI)]
1029 fn mixed_address_forms_are_last_wins(#[case] added: &str, #[case] denied: &str) {
1030 let public = address(KIPSELI);
1031 let custom = || PriceLevelStreamConfig::new("custom", address(added), 1u64.into());
1032
1033 let builder = PriceLevelStreamBuilder::new()
1034 .add_pamm(custom())
1035 .deny_pamm(address(denied));
1036 assert!(builder.registry.is_empty());
1037 assert!(builder.denied.contains(&public));
1038
1039 let builder = PriceLevelStreamBuilder::new()
1040 .deny_pamm(address(denied))
1041 .add_pamm(custom());
1042 assert_eq!(builder.registry[&public].protocol, "custom");
1043 assert!(builder.denied.is_empty());
1044 }
1045
1046 const IMPOSTOR_WBTC: &str = "0x00000000000000000000000000000000deadbeef";
1048
1049 async fn first_connection_sends_captured_books(index: usize, mut socket: FakeConnection) {
1054 if index == 0 {
1055 let message = captured_message_text("Kipseli", 100, wall_nanos_now());
1056 let _ = socket
1057 .send(Message::Text(message.into()))
1058 .await;
1059 }
1060 std::future::pending::<()>().await;
1061 }
1062
1063 #[rstest]
1071 #[case::canonical_asset(vec![(WBTC, 8)], Some(WBTC))]
1072 #[case::impostor_only(vec![(IMPOSTOR_WBTC, 18)], None)]
1073 #[case::both_present(vec![(WBTC, 8), (IMPOSTOR_WBTC, 18)], Some(WBTC))]
1074 #[tokio::test]
1075 async fn an_impostor_symbol_is_never_priced(
1076 #[case] bitcoins: Vec<(&str, u32)>,
1077 #[case] expected_btc: Option<&str>,
1078 ) {
1079 let admitted = [token(USDC, "USDC", 6), token(WETH, "WETH", 18)]
1080 .into_iter()
1081 .chain(
1082 bitcoins
1083 .into_iter()
1084 .map(|(address, decimals)| token(address, "WBTC", decimals)),
1085 );
1086 let fake = FakeTitan::spawn(first_connection_sends_captured_books).await;
1087 let stream = fast_timings(&fake)
1088 .add_pamm(PriceLevelStreamConfig::new("kipseli", address(KIPSELI), 1u64.into()))
1089 .with_tokens(token_map(admitted))
1090 .build();
1091 tokio::pin!(stream);
1092
1093 let update = next_within(&mut stream, WAIT)
1094 .await
1095 .expect("first update");
1096
1097 let mut served: Vec<Vec<String>> = update
1099 .new_pairs
1100 .values()
1101 .map(|component| {
1102 component
1103 .tokens
1104 .iter()
1105 .map(|token| token.address.to_string())
1106 .collect()
1107 })
1108 .collect();
1109 served.sort();
1110 let mut expected = vec![vec![USDC.to_string(), WETH.to_string()]];
1111 if let Some(btc) = expected_btc {
1112 let mut pair = vec![btc.to_string(), USDC.to_string()];
1113 pair.sort();
1114 expected.push(pair);
1115 }
1116 expected.sort();
1117 assert_eq!(served, expected);
1118 for component in update.new_pairs.values() {
1120 assert_eq!(component.static_attributes[PAMM_ADDRESS_ATTRIBUTE], address(KIPSELI));
1121 }
1122 }
1123
1124 #[rstest]
1128 #[case::ping_only(Message::Ping(Vec::new().into()))]
1129 #[case::malformed_text(Message::Text("nonsense".into()))]
1130 #[tokio::test]
1131 async fn traffic_that_is_not_a_message_removes_within_stale_after(#[case] filler: Message) {
1132 let fake = FakeTitan::spawn(message_then_repeat(
1133 fresh_message(),
1134 filler,
1135 Duration::from_millis(10),
1136 ))
1137 .await;
1138 let stream = fast_builder(&fake).build();
1139 tokio::pin!(stream);
1140
1141 expect_first_update(&mut stream).await;
1142 let removal = expect_removal(&mut stream).await;
1143
1144 assert_removal_only(&removal, 1);
1145 assert!(fake.connections.load(Ordering::SeqCst) >= 2, "no reconnect on idle timeout");
1146 }
1147
1148 const SOCKET_HEAD_START: Duration = Duration::from_millis(250);
1152
1153 fn capture_builder(prices: &FakeTitan, overrides: &FakeTitan) -> PriceLevelStreamBuilder {
1157 two_socket_timings(prices, overrides)
1158 .with_known_pamms()
1159 .with_tokens(captured_tokens())
1160 }
1161
1162 fn matching_message() -> Message {
1165 Message::Text(matching_message_text(100, wall_nanos_now()).into())
1166 }
1167
1168 fn quote_stream_message() -> Message {
1171 Message::Text(captured_quote_stream_text().into())
1172 }
1173
1174 fn send_once_after(
1178 delay: Duration,
1179 message: Message,
1180 ) -> impl Fn(usize, FakeConnection) -> BoxFuture<'static, ()> + Send + Sync + 'static {
1181 move |index, mut socket| {
1182 let message = message.clone();
1183 Box::pin(async move {
1184 if index == 0 {
1185 tokio::time::sleep(delay).await;
1186 let _ = socket.send(message).await;
1187 }
1188 std::future::pending::<()>().await;
1189 })
1190 }
1191 }
1192
1193 fn connections(fake: &FakeTitan) -> usize {
1195 fake.connections.load(Ordering::SeqCst)
1196 }
1197
1198 fn states_with_overrides(update: &Update) -> Vec<&PriceLevelStreamState> {
1200 update
1201 .states
1202 .values()
1203 .map(|state| {
1204 state
1205 .as_any()
1206 .downcast_ref::<PriceLevelStreamState>()
1207 .expect("price level state")
1208 })
1209 .filter(|state| state.simulation_overrides().is_some())
1210 .collect()
1211 }
1212
1213 #[tokio::test]
1218 async fn a_quote_stream_message_attaches_overrides_to_the_books_it_priced() {
1219 let overrides =
1220 FakeTitan::spawn(send_once_after(Duration::ZERO, quote_stream_message())).await;
1221 let prices = FakeTitan::spawn(send_once_after(SOCKET_HEAD_START, matching_message())).await;
1222 let stream = capture_builder(&prices, &overrides)
1223 .read_idle_timeout(Duration::from_secs(5))
1224 .build();
1225 tokio::pin!(stream);
1226
1227 let update = next_within(&mut stream, WAIT)
1228 .await
1229 .expect("first update");
1230
1231 assert_eq!(update.states.len(), 30);
1232 let with_overrides = states_with_overrides(&update);
1233 assert_eq!(with_overrides.len(), 27);
1234 for state in with_overrides {
1235 let overrides = state
1236 .simulation_overrides()
1237 .expect("overrides");
1238 assert!(!overrides.accounts.is_empty(), "overrides with no account");
1239 assert_eq!(overrides.block_number, Some(26_201_954));
1240 }
1241 }
1242
1243 #[tokio::test]
1247 async fn a_late_quote_stream_message_leaves_served_states_without_overrides() {
1248 let overrides =
1249 FakeTitan::spawn(send_once_after(SOCKET_HEAD_START, quote_stream_message())).await;
1250 let prices = FakeTitan::spawn(move |index, mut socket| async move {
1251 if index == 0 {
1252 let _ = socket.send(matching_message()).await;
1253 tokio::time::sleep(2 * SOCKET_HEAD_START).await;
1254 let _ = socket.send(matching_message()).await;
1255 }
1256 std::future::pending::<()>().await;
1257 })
1258 .await;
1259 let stream = capture_builder(&prices, &overrides)
1260 .read_idle_timeout(Duration::from_secs(5))
1261 .build();
1262 tokio::pin!(stream);
1263
1264 let first = next_within(&mut stream, WAIT).await;
1265 let second = next_within(&mut stream, WAIT).await;
1266
1267 let first = first.expect("first update");
1268 assert_eq!(first.new_pairs.len(), 30);
1269 assert!(states_with_overrides(&first).is_empty(), "overrides before any entry arrived");
1270 assert_eq!(states_with_overrides(&second.expect("second update")).len(), 27);
1271 }
1272
1273 #[rstest]
1277 #[case::opt_out_after_the_endpoint(false)]
1278 #[case::opt_out_before_the_endpoint(true)]
1279 #[tokio::test]
1280 async fn without_simulation_overrides_connects_no_quote_stream_socket(
1281 #[case] opt_out_first: bool,
1282 ) {
1283 let overrides =
1284 FakeTitan::spawn(send_once_after(Duration::ZERO, quote_stream_message())).await;
1285 let prices = FakeTitan::spawn(send_once_after(SOCKET_HEAD_START, matching_message())).await;
1286 let builder = if opt_out_first {
1287 timings(&prices)
1288 .without_simulation_overrides()
1289 .quote_stream_endpoint(overrides.url())
1290 } else {
1291 timings(&prices)
1292 .quote_stream_endpoint(overrides.url())
1293 .without_simulation_overrides()
1294 };
1295 let stream = builder
1296 .with_known_pamms()
1297 .with_tokens(captured_tokens())
1298 .read_idle_timeout(Duration::from_secs(5))
1299 .build();
1300 tokio::pin!(stream);
1301
1302 let update = next_within(&mut stream, WAIT)
1303 .await
1304 .expect("first update");
1305
1306 assert_eq!(update.states.len(), 30);
1307 assert!(states_with_overrides(&update).is_empty());
1308 assert_eq!(connections(&overrides), 0, "connected the quote stream socket");
1309 }
1310
1311 #[rstest]
1322 #[case::silent(None, 2)]
1323 #[case::malformed(Some(Message::Text("nonsense".into())), 2)]
1324 #[case::closed(Some(Message::Close(None)), 2)]
1325 #[case::flooding(Some(quote_stream_message()), 1)]
1326 #[tokio::test]
1327 async fn the_price_level_socket_survives_any_quote_stream_socket(
1328 #[case] repeat: Option<Message>,
1329 #[case] connects: usize,
1330 ) {
1331 let overrides = FakeTitan::spawn(move |_, mut socket| {
1332 let repeat = repeat.clone();
1333 async move {
1334 while let Some(message) = repeat.clone() {
1335 if socket.send(message).await.is_err() {
1336 return;
1337 }
1338 tokio::time::sleep(Duration::from_millis(5)).await;
1339 }
1340 std::future::pending::<()>().await;
1341 }
1342 })
1343 .await;
1344 let prices = FakeTitan::spawn(first_connection_sends_one_message).await;
1345 let stream = two_socket_timings(&prices, &overrides)
1346 .add_pamm(fermiswap())
1347 .with_tokens(tokens())
1348 .build();
1349 tokio::pin!(stream);
1350
1351 expect_first_update(&mut stream).await;
1352 let removal = expect_removal(&mut stream).await;
1353
1354 assert_removal_only(&removal, 1);
1355 assert!(
1356 connections(&overrides) >= connects,
1357 "the quote stream socket connected {} times, expected at least {connects}",
1358 connections(&overrides)
1359 );
1360 }
1361
1362 #[tokio::test]
1365 async fn a_refused_quote_stream_socket_does_not_stall_the_price_level_socket() {
1366 let mut overrides =
1367 FakeTitan::spawn(send_once_after(Duration::ZERO, quote_stream_message())).await;
1368 let url = overrides.url();
1369 overrides.shutdown();
1370 let prices = FakeTitan::spawn(first_connection_sends_one_message).await;
1371 let stream = timings(&prices)
1372 .quote_stream_endpoint(url)
1373 .add_pamm(fermiswap())
1374 .with_tokens(tokens())
1375 .build();
1376 tokio::pin!(stream);
1377
1378 expect_first_update(&mut stream).await;
1379 let removal = expect_removal(&mut stream).await;
1380
1381 assert_removal_only(&removal, 1);
1382 }
1383
1384 #[tokio::test]
1389 async fn a_hung_quote_stream_socket_does_not_stall_the_price_level_socket() {
1390 let overrides = FakeTitan::spawn_hung().await;
1391 let prices = FakeTitan::spawn(first_connection_sends_one_message).await;
1392 let stream = two_socket_timings(&prices, &overrides)
1393 .connect_timeout(Duration::from_millis(200))
1394 .add_pamm(fermiswap())
1395 .with_tokens(tokens())
1396 .build();
1397 tokio::pin!(stream);
1398
1399 expect_first_update(&mut stream).await;
1400 let removal = expect_removal(&mut stream).await;
1401
1402 assert_removal_only(&removal, 1);
1403 assert!(
1404 connections(&overrides) >= 2,
1405 "the hung socket was connected to {} times, expected a retry",
1406 connections(&overrides)
1407 );
1408 }
1409
1410 #[test]
1414 fn a_refused_price_level_socket_does_not_stall_the_quote_stream_socket() {
1415 let (update, snapshot) = record_async(async {
1416 let overrides = FakeTitan::spawn(message_then_repeat(
1417 quote_stream_message(),
1418 quote_stream_message(),
1419 Duration::from_millis(20),
1420 ))
1421 .await;
1422 let mut prices = FakeTitan::spawn(first_connection_sends_one_message).await;
1423 prices.shutdown();
1424 let stream = two_socket_timings(&prices, &overrides)
1425 .add_pamm(fermiswap())
1426 .with_tokens(tokens())
1427 .build();
1428 tokio::pin!(stream);
1429 next_within(&mut stream, Duration::from_millis(500)).await
1430 });
1431
1432 assert!(update.is_none(), "an update without a price level message");
1433 assert!(
1434 counter_value(&snapshot, "price_level_stream_unserved_venue_entries_total", &[]) > 0,
1435 "the quote stream socket was never read"
1436 );
1437 }
1438
1439 #[tokio::test]
1441 async fn drop_closes_both_sockets() {
1442 let closed = Arc::new(AtomicUsize::new(0));
1443 let spawn_watching = |closed: Arc<AtomicUsize>, first: Message| async move {
1444 FakeTitan::spawn(move |_, mut socket| {
1445 let closed = closed.clone();
1446 let first = first.clone();
1447 async move {
1448 let _ = socket.send(first).await;
1449 while let Some(Ok(message)) = socket.next().await {
1450 if matches!(message, Message::Close(_)) {
1451 break;
1452 }
1453 }
1454 closed.fetch_add(1, Ordering::SeqCst);
1455 }
1456 })
1457 .await
1458 };
1459 let overrides = spawn_watching(closed.clone(), quote_stream_message()).await;
1460 let prices = spawn_watching(closed.clone(), matching_message()).await;
1461 let mut stream = Box::pin(
1462 capture_builder(&prices, &overrides)
1463 .read_idle_timeout(Duration::from_secs(5))
1464 .build(),
1465 );
1466 next_within(&mut stream.as_mut(), WAIT)
1467 .await
1468 .expect("first update");
1469
1470 drop(stream);
1471 tokio::time::sleep(Duration::from_millis(200)).await;
1472
1473 assert_eq!(closed.load(Ordering::SeqCst), 2, "a socket was not closed on drop");
1474 assert_eq!(connections(&prices), 1, "reconnected after drop");
1475 assert_eq!(connections(&overrides), 1, "reconnected after drop");
1476 }
1477}