1use std::{
2 any::Any,
3 collections::{hash_map::Entry, HashMap, HashSet},
4 future::Future,
5 pin::Pin,
6 sync::Arc,
7};
8
9use alloy::primitives::{Address, U256};
10use thiserror::Error;
11use tokio::sync::{watch, RwLock, RwLockReadGuard};
12use tracing::{debug, error, info, warn};
13use tycho_client::feed::{synchronizer::ComponentWithState, BlockHeader, FeedMessage, HeaderLike};
14use tycho_common::{
15 dto::{ChangeType, ProtocolStateDelta},
16 models::{blockchain::BlockAggregatedChanges, token::Token, Chain},
17 simulation::protocol_sim::{Balances, BlockContext, ProtocolSim},
18 Bytes,
19};
20#[cfg(test)]
21use {
22 mockall::mock,
23 num_bigint::BigUint,
24 tycho_common::simulation::{
25 errors::{SimulationError, TransitionError},
26 protocol_sim::GetAmountOutResult,
27 },
28};
29
30use crate::{
31 evm::{
32 engine_db::{update_engine, SHARED_TYCHO_DB},
33 override_stream::{OverrideSnapshot, StateOverrideProvider},
34 protocol::{
35 utils::bytes_to_address,
36 vm::{constants::ERC20_PROXY_BYTECODE, erc20_token::IMPLEMENTATION_SLOT},
37 },
38 simulation::{BlockEnvOverrides, PendingOverrides},
39 tycho_models::{AccountUpdate, ResponseAccount},
40 },
41 protocol::{
42 errors::InvalidSnapshotError,
43 models::{DecoderContext, ProtocolComponent, TryFromWithBlock, Update},
44 },
45};
46
47#[derive(Error, Debug)]
48pub enum StreamDecodeError {
49 #[error("{0}")]
50 Fatal(String),
51}
52
53#[derive(Default)]
54struct DecoderState {
55 tokens: HashMap<Bytes, Token>,
56 states: HashMap<String, Box<dyn ProtocolSim>>,
57 components: HashMap<String, ProtocolComponent>,
58 contracts_map: HashMap<Bytes, HashSet<String>>,
60 proxy_token_addresses: HashMap<Address, Address>,
62 failed_components: HashSet<String>,
66 current_block_number: u64,
68}
69
70type DecodeFut =
71 Pin<Box<dyn Future<Output = Result<Box<dyn ProtocolSim>, InvalidSnapshotError>> + Send + Sync>>;
72type AccountBalances = HashMap<Bytes, HashMap<Bytes, Bytes>>;
73type RegistryFn<H> = dyn Fn(
74 ComponentWithState,
75 H,
76 AccountBalances,
77 Arc<RwLock<DecoderState>>,
78 Option<watch::Receiver<OverrideSnapshot>>,
79 ) -> DecodeFut
80 + Send
81 + Sync;
82type FilterFn = fn(&ComponentWithState) -> bool;
83
84pub struct TychoStreamDecoder<H>
97where
98 H: HeaderLike,
99{
100 state: Arc<RwLock<DecoderState>>,
101 skip_state_decode_failures: bool,
102 min_token_quality: u32,
103 registry: HashMap<String, Box<RegistryFn<H>>>,
104 inclusion_filters: HashMap<String, Vec<FilterFn>>,
105 protocols_skip_unknown_tokens: HashSet<String>,
107 override_providers: HashMap<String, Arc<dyn StateOverrideProvider>>,
110 block_time_secs: u64,
113 chain: Chain,
116}
117
118fn is_deprecated_curve_registration<T: 'static>(exchange: &str) -> bool {
122 exchange == "vm:curve" &&
123 std::any::type_name::<T>() !=
124 std::any::type_name::<crate::evm::protocol::curve::CurveState>()
125}
126
127impl<H> TychoStreamDecoder<H>
128where
129 H: HeaderLike + Clone + Sync + Send + 'static + std::fmt::Debug,
130{
131 pub fn new(chain: Chain) -> Self {
137 Self {
138 state: Arc::new(RwLock::new(DecoderState::default())),
139 skip_state_decode_failures: false,
140 min_token_quality: 100,
141 registry: HashMap::new(),
142 inclusion_filters: HashMap::new(),
143 protocols_skip_unknown_tokens: HashSet::new(),
144 override_providers: HashMap::new(),
145 block_time_secs: chain.block_time_secs(),
146 chain,
147 }
148 }
149
150 fn execution_block(&self, header: &BlockHeader) -> BlockContext {
155 if header.partial_block_index.is_some() {
156 BlockContext::new(header.number, header.timestamp)
157 } else {
158 BlockContext::new(header.number + 1, header.timestamp + self.block_time_secs)
159 }
160 }
161
162 fn refresh_execution_block<C>(
171 updated_states: &mut HashMap<String, Box<dyn ProtocolSim>>,
172 stored_states: &mut HashMap<String, Box<dyn ProtocolSim>>,
173 failed_components: &HashSet<String>,
174 removed_components: &HashMap<String, C>,
175 execution_block: &BlockContext,
176 ) {
177 for state in updated_states.values_mut() {
178 state.apply_block(execution_block);
179 }
180 for (id, state) in stored_states.iter_mut() {
181 if failed_components.contains(id) ||
182 removed_components.contains_key(id) ||
183 updated_states.contains_key(id)
184 {
185 continue;
186 }
187 if state.apply_block(execution_block) {
188 updated_states.insert(id.clone(), state.clone_box());
189 }
190 }
191 }
192
193 pub fn set_override_provider(
199 &mut self,
200 protocol_system: String,
201 provider: Arc<dyn StateOverrideProvider>,
202 ) {
203 self.override_providers
204 .insert(protocol_system, provider);
205 }
206
207 pub async fn set_tokens(&self, tokens: HashMap<Bytes, Token>) {
212 let mut guard = self.state.write().await;
213 guard.tokens = tokens;
214 }
215
216 pub fn skip_state_decode_failures(&mut self, skip: bool) {
217 self.skip_state_decode_failures = skip;
218 }
219
220 pub fn min_token_quality(&mut self, quality: u32) {
226 self.min_token_quality = quality;
227 }
228
229 pub fn register_decoder_with_context<T>(&mut self, exchange: &str, mut context: DecoderContext)
244 where
245 T: ProtocolSim
246 + TryFromWithBlock<ComponentWithState, H, Error = InvalidSnapshotError>
247 + Send
248 + 'static,
249 {
250 if let Some(requested) = context
251 .chain
252 .filter(|requested| *requested != self.chain)
253 {
254 warn!(
255 exchange,
256 requested_chain = %requested,
257 decoder_chain = %self.chain,
258 "DecoderContext declares a different chain than the decoder; using the decoder's \
259 chain"
260 );
261 }
262 context.chain = Some(self.chain);
263
264 if is_deprecated_curve_registration::<T>(exchange) {
265 warn!(
266 registered_type = std::any::type_name::<T>(),
267 "Registering \"vm:curve\" with the generic VM adapter is deprecated; register the \
268 native `CurveState` decoder instead (`exchange::<CurveState>(\"vm:curve\", ...)`). \
269 The VM-adapter path still works but will be removed in a future release."
270 );
271 }
272 let decoder = Box::new(
273 move |component: ComponentWithState,
274 header: H,
275 account_balances: AccountBalances,
276 state: Arc<RwLock<DecoderState>>,
277 live_override: Option<watch::Receiver<OverrideSnapshot>>| {
278 let mut context = context.clone();
279 context.live_override = live_override;
280 Box::pin(async move {
281 let guard = state.read().await;
282 T::try_from_with_header(
283 component,
284 header,
285 &account_balances,
286 &guard.tokens,
287 &context,
288 )
289 .await
290 .map(|c| Box::new(c) as Box<dyn ProtocolSim>)
291 }) as DecodeFut
292 },
293 );
294 self.registry
295 .insert(exchange.to_string(), decoder);
296 }
297
298 pub fn register_decoder<T>(&mut self, exchange: &str)
310 where
311 T: ProtocolSim
312 + TryFromWithBlock<ComponentWithState, H, Error = InvalidSnapshotError>
313 + Send
314 + 'static,
315 {
316 let context = DecoderContext::new();
317 self.register_decoder_with_context::<T>(exchange, context);
318 }
319
320 pub fn register_decoder_dropping_unknown_tokens<T>(&mut self, exchange: &str)
324 where
325 T: ProtocolSim
326 + TryFromWithBlock<ComponentWithState, H, Error = InvalidSnapshotError>
327 + Send
328 + 'static,
329 {
330 self.register_decoder::<T>(exchange);
331 self.protocols_skip_unknown_tokens
332 .insert(exchange.to_string());
333 }
334
335 pub fn register_filter(&mut self, exchange: &str, predicate: FilterFn) {
354 self.inclusion_filters
355 .entry(exchange.to_string())
356 .or_default()
357 .push(predicate);
358 }
359
360 fn admits(&self, exchange: &str, snapshot: &ComponentWithState) -> bool {
363 let Some(predicates) = self.inclusion_filters.get(exchange) else { return true };
364 predicates
365 .iter()
366 .all(|predicate| predicate(snapshot))
367 }
368
369 pub async fn decode(&self, msg: &FeedMessage<H>) -> Result<Update, StreamDecodeError> {
372 let mut updated_states = HashMap::new();
374 let mut new_pairs = HashMap::new();
375 let mut removed_pairs = HashMap::new();
376 let mut contracts_map = HashMap::new();
377 let mut msg_failed_components = HashSet::new();
378
379 let header = msg
380 .state_msgs
381 .values()
382 .next()
383 .ok_or_else(|| StreamDecodeError::Fatal("Missing block!".into()))?
384 .header
385 .clone();
386
387 let block_number = header
388 .clone()
389 .block_number_or_timestamp();
390 let current_block = header.clone().block();
391 let is_partial = current_block
392 .as_ref()
393 .map(|h| h.partial_block_index.is_some())
394 .unwrap_or(false);
395
396 for (protocol, protocol_msg) in msg.state_msgs.iter() {
397 let drops_unknown_tokens = self
398 .protocols_skip_unknown_tokens
399 .contains(protocol.as_str());
400 if let Some(deltas) = protocol_msg.deltas.as_ref() {
402 let mut state_guard = self.state.write().await;
403
404 let new_tokens = deltas
405 .new_tokens
406 .iter()
407 .filter(|(addr, t)| {
408 t.quality >= self.min_token_quality &&
409 !state_guard.tokens.contains_key(*addr)
410 })
411 .map(|(addr, t)| (addr.clone(), t.clone()))
412 .collect::<HashMap<Bytes, Token>>();
413
414 if !new_tokens.is_empty() {
415 debug!(n = new_tokens.len(), "NewTokens");
416 state_guard.tokens.extend(new_tokens);
417 }
418 }
419
420 {
422 let mut state_guard = self.state.write().await;
423 let removed_components: Vec<(String, ProtocolComponent)> = protocol_msg
424 .removed_components
425 .iter()
426 .map(|(id, comp)| {
427 if *id != comp.id {
428 error!(
429 "Component id mismatch in removed components {id} != {}",
430 comp.id
431 );
432 return Err(StreamDecodeError::Fatal("Component id mismatch".into()));
433 }
434
435 let tokens = comp
436 .tokens
437 .iter()
438 .flat_map(|addr| state_guard.tokens.get(addr).cloned())
439 .collect::<Vec<_>>();
440
441 if tokens.len() == comp.tokens.len() {
442 Ok(Some((
443 id.clone(),
444 ProtocolComponent::from_with_tokens(comp.clone(), tokens),
445 )))
446 } else {
447 Ok(None)
448 }
449 })
450 .collect::<Result<Vec<Option<(String, ProtocolComponent)>>, StreamDecodeError>>(
451 )?
452 .into_iter()
453 .flatten()
454 .collect();
455
456 for (id, component) in removed_components {
458 state_guard.components.remove(&id);
459 state_guard.states.remove(&id);
460 removed_pairs.insert(id, component);
461 }
462
463 info!(
465 "Processing {} contracts from snapshots",
466 protocol_msg
467 .snapshots
468 .get_vm_storage()
469 .len()
470 );
471
472 let mut proxy_token_accounts: HashMap<Address, AccountUpdate> = HashMap::new();
473 let mut storage_by_address: HashMap<Address, ResponseAccount> = HashMap::new();
474 for (key, value) in protocol_msg
475 .snapshots
476 .get_vm_storage()
477 .iter()
478 {
479 let account: ResponseAccount = value.clone().into();
480
481 if state_guard.tokens.contains_key(key) {
482 let original_address = account.address;
483 let (impl_addr, proxy_state) = match state_guard
492 .proxy_token_addresses
493 .get(&original_address)
494 {
495 Some(impl_addr) => {
496 let proxy_state = AccountUpdate::new(
503 original_address,
504 value.chain,
505 account.slots.clone(),
506 Some(account.native_balance),
507 None,
508 ChangeType::Update,
509 );
510 (*impl_addr, proxy_state)
511 }
512 None => {
513 let impl_addr = generate_proxy_token_address(
517 state_guard.proxy_token_addresses.len() as u32,
518 )?;
519 state_guard
520 .proxy_token_addresses
521 .insert(original_address, impl_addr);
522
523 let proxy_state = create_proxy_token_account(
525 original_address,
526 Some(impl_addr),
527 &account.slots,
528 value.chain,
529 Some(account.native_balance),
530 );
531
532 (impl_addr, proxy_state)
533 }
534 };
535
536 proxy_token_accounts.insert(original_address, proxy_state);
537
538 let impl_update = ResponseAccount {
540 address: impl_addr,
541 slots: HashMap::new(),
542 ..account.clone()
543 };
544 storage_by_address.insert(impl_addr, impl_update);
545 } else {
546 storage_by_address.insert(account.address, account);
548 }
549 }
550
551 let mut proxy_creates: Vec<AccountUpdate> = Vec::new();
555 let mut proxy_updates: HashMap<Address, AccountUpdate> = HashMap::new();
556 for (addr, update) in proxy_token_accounts {
557 if matches!(update.change, ChangeType::Creation) {
558 proxy_creates.push(update);
559 } else {
560 proxy_updates.insert(addr, update);
561 }
562 }
563
564 info!("Updating engine with {} contracts from snapshots", storage_by_address.len());
565 update_engine(
566 SHARED_TYCHO_DB.clone(),
567 header.clone().block(),
568 Some(storage_by_address),
569 proxy_updates,
570 )
571 .map_err(|e| StreamDecodeError::Fatal(e.to_string()))?;
572
573 if !proxy_creates.is_empty() {
577 SHARED_TYCHO_DB
578 .force_update_accounts(proxy_creates)
579 .map_err(|e| StreamDecodeError::Fatal(e.to_string()))?;
580 }
581 info!("Engine updated");
582 drop(state_guard);
583 }
584
585 let account_balances = protocol_msg
588 .clone()
589 .snapshots
590 .get_vm_storage()
591 .iter()
592 .filter_map(|(addr, acc)| {
593 if acc.token_balances.is_empty() {
594 return None;
595 }
596 let balances = acc
597 .token_balances
598 .iter()
599 .map(|(token_addr, ab)| (token_addr.clone(), ab.balance.clone()))
600 .collect::<HashMap<Bytes, Bytes>>();
601 Some((addr.clone(), balances))
602 })
603 .collect::<AccountBalances>();
604
605 let mut new_components = HashMap::new();
606 let mut count_token_skips = 0;
607 let mut components_to_store = HashMap::new();
608 {
609 let state_guard = self.state.read().await;
610
611 'snapshot_loop: for (id, snapshot) in protocol_msg
613 .snapshots
614 .get_states()
615 .clone()
616 {
617 if !self.admits(protocol.as_str(), &snapshot) {
619 continue;
620 }
621
622 let mut component_tokens = Vec::new();
624 let mut new_tokens_accounts = HashMap::new();
625 for token in snapshot.component.tokens.clone() {
626 match state_guard.tokens.get(&token) {
627 Some(token) => {
628 let token_address = match bytes_to_address(&token.address) {
631 Ok(addr) => addr,
632 Err(_) if drops_unknown_tokens => {
633 warn!(
634 "Token address could not be decoded {}, ignoring the token in component {:x?}",
635 token.address, id
636 );
637 continue;
638 }
639 Err(_) => {
640 count_token_skips += 1;
641 msg_failed_components.insert(id.clone());
642 warn!(
643 "Token address could not be decoded {}, ignoring pool {:x?}",
644 token.address, id
645 );
646 continue 'snapshot_loop;
647 }
648 };
649 component_tokens.push(token.clone());
650 if !state_guard
652 .proxy_token_addresses
653 .contains_key(&token_address)
654 {
655 new_tokens_accounts.insert(
656 token_address,
657 create_proxy_token_account(
658 token_address,
659 None,
660 &HashMap::new(),
661 snapshot.component.chain,
662 None,
663 ),
664 );
665 }
666 }
667 None if drops_unknown_tokens => {
668 warn!(
669 "Token not found {}, ignoring the token in component {:x?}",
670 token, id
671 );
672 }
673 None => {
674 count_token_skips += 1;
675 msg_failed_components.insert(id.clone());
676 debug!("Token not found {}, ignoring pool {:x?}", token, id);
677 continue 'snapshot_loop;
678 }
679 }
680 }
681 let component = ProtocolComponent::from_with_tokens(
682 snapshot.component.clone(),
683 component_tokens,
684 );
685
686 if !new_tokens_accounts.is_empty() {
688 update_engine(
689 SHARED_TYCHO_DB.clone(),
690 header.clone().block(),
691 None,
692 new_tokens_accounts,
693 )
694 .map_err(|e| StreamDecodeError::Fatal(e.to_string()))?;
695 }
696
697 if !component
700 .static_attributes
701 .contains_key("manual_updates")
702 {
703 for contract in &component.contract_ids {
704 contracts_map
705 .entry(contract.clone())
706 .or_insert_with(HashSet::new)
707 .insert(id.clone());
708 }
709 for (_, tracing) in snapshot.entrypoints.iter() {
712 for contract in tracing.accessed_slots.keys().cloned() {
713 contracts_map
714 .entry(contract)
715 .or_insert_with(HashSet::new)
716 .insert(id.clone());
717 }
718 }
719 }
720
721 new_pairs.insert(id.clone(), component.clone());
723
724 components_to_store.insert(id.clone(), component);
726
727 if let Some(state_decode_f) = self.registry.get(protocol.as_str()) {
729 let live_override = self
730 .override_providers
731 .get(protocol.as_str())
732 .and_then(|provider| provider.subscribe(protocol.as_str()));
733 match state_decode_f(
734 snapshot,
735 header.clone(),
736 account_balances.clone(),
737 self.state.clone(),
738 live_override,
739 )
740 .await
741 {
742 Ok(state) => {
743 new_components.insert(id.clone(), state);
744 }
745 Err(e) => {
746 if self.skip_state_decode_failures {
747 warn!(pool = id, error = %e, "StateDecodingFailure");
748 msg_failed_components.insert(id.clone());
749 continue 'snapshot_loop;
750 } else {
751 error!(pool = id, error = %e, "StateDecodingFailure");
752 return Err(StreamDecodeError::Fatal(format!("{e}")));
753 }
754 }
755 }
756 } else if self.skip_state_decode_failures {
757 warn!(pool = id, "MissingDecoderRegistration");
758 msg_failed_components.insert(id.clone());
759 continue 'snapshot_loop;
760 } else {
761 error!(pool = id, "MissingDecoderRegistration");
762 return Err(StreamDecodeError::Fatal(format!(
763 "Missing decoder registration for: {id}"
764 )));
765 }
766 }
767 }
768
769 if !components_to_store.is_empty() {
771 let mut state_guard = self.state.write().await;
772 for (id, component) in components_to_store {
773 state_guard
774 .components
775 .insert(id, component);
776 }
777 }
778
779 if !protocol_msg.snapshots.states.is_empty() {
780 info!("Decoded {} snapshots for protocol {protocol}", new_components.len());
781 }
782 if count_token_skips > 0 {
783 info!("Skipped {count_token_skips} pools due to missing tokens");
784 }
785
786 updated_states.extend(new_components);
788
789 if let Some(deltas) = protocol_msg.deltas.clone() {
791 let mut state_guard = self.state.write().await;
793
794 let mut account_update_by_address: HashMap<Address, AccountUpdate> = HashMap::new();
795 let mut new_proxy_accounts: Vec<AccountUpdate> = Vec::new();
797 for (key, value) in deltas.account_deltas.iter() {
798 let mut update: AccountUpdate = value.clone().into();
799
800 if update.code.is_none() && matches!(update.change, ChangeType::Creation) {
806 error!(
807 update = ?update,
808 "FaultyCreationDelta"
809 );
810 update.code = Some(vec![]);
811 }
812
813 if state_guard.tokens.contains_key(key) {
814 let original_address = update.address;
815 let impl_addr = match state_guard
822 .proxy_token_addresses
823 .get(&original_address)
824 {
825 Some(impl_addr) => {
826 let proxy_update = AccountUpdate {
831 code: None,
832 change: ChangeType::Update,
833 ..update.clone()
834 };
835 account_update_by_address.insert(original_address, proxy_update);
836
837 *impl_addr
838 }
839 None => {
840 let impl_addr = generate_proxy_token_address(
845 state_guard.proxy_token_addresses.len() as u32,
846 )?;
847 state_guard
848 .proxy_token_addresses
849 .insert(original_address, impl_addr);
850
851 let proxy_state = create_proxy_token_account(
856 original_address,
857 Some(impl_addr),
858 &update.slots,
859 update.chain,
860 update.balance,
861 );
862 new_proxy_accounts.push(proxy_state);
863
864 impl_addr
865 }
866 };
867
868 if update.code.is_some() {
870 let impl_update = AccountUpdate {
871 address: impl_addr,
872 slots: HashMap::new(),
873 ..update.clone()
874 };
875 account_update_by_address.insert(impl_addr, impl_update);
876 }
877 } else {
878 account_update_by_address.insert(update.address, update);
880 }
881 }
882 drop(state_guard);
883
884 let state_guard = self.state.read().await;
885 info!("Updating engine with {} contract deltas", deltas.account_deltas.len());
886 update_engine(
887 SHARED_TYCHO_DB.clone(),
888 header.clone().block(),
889 None,
890 account_update_by_address,
891 )
892 .map_err(|e| StreamDecodeError::Fatal(e.to_string()))?;
893
894 if !new_proxy_accounts.is_empty() {
897 SHARED_TYCHO_DB
898 .force_update_accounts(new_proxy_accounts)
899 .map_err(|e| StreamDecodeError::Fatal(e.to_string()))?;
900 }
901 info!("Engine updated");
902
903 let mut pools_to_update = HashSet::new();
905 for (account, _update) in deltas.account_deltas {
906 pools_to_update.extend(
908 contracts_map
909 .get(&account)
910 .cloned()
911 .unwrap_or_default(),
912 );
913 pools_to_update.extend(
915 state_guard
916 .contracts_map
917 .get(&account)
918 .cloned()
919 .unwrap_or_default(),
920 );
921 }
922
923 let all_balances = Balances {
925 component_balances: deltas
926 .component_balances
927 .iter()
928 .map(|(pool_id, bals)| {
929 let mut balances = HashMap::new();
930 for (t, b) in bals {
931 balances.insert(t.clone(), b.balance.clone());
932 }
933 pools_to_update.insert(pool_id.clone());
934 (pool_id.clone(), balances)
935 })
936 .collect(),
937 account_balances: deltas
938 .account_balances
939 .iter()
940 .map(|(account, bals)| {
941 let mut balances = HashMap::new();
942 for (t, b) in bals {
943 balances.insert(t.clone(), b.balance.clone());
944 }
945 pools_to_update.extend(
946 contracts_map
947 .get(account)
948 .cloned()
949 .unwrap_or_default(),
950 );
951 (account.clone(), balances)
952 })
953 .collect(),
954 };
955
956 for (id, update) in deltas.state_deltas {
958 let update_with_block = Self::add_block_info_to_delta(
960 ProtocolStateDelta::from(update),
961 current_block.clone(),
962 );
963 match Self::apply_update(
964 &id,
965 update_with_block,
966 &mut updated_states,
967 &state_guard,
968 &all_balances,
969 ) {
970 Ok(_) => {
971 pools_to_update.remove(&id);
972 }
973 Err(e) => {
974 if self.skip_state_decode_failures {
975 warn!(pool = id, error = %e, "Failed to apply state update, marking component as removed");
976 updated_states.remove(&id);
978 if let Some(component) = new_pairs.remove(&id) {
980 removed_pairs.insert(id.clone(), component);
981 } else if let Some(component) = state_guard.components.get(&id) {
982 removed_pairs.insert(id.clone(), component.clone());
983 } else {
984 warn!(pool = id, "Component not found in new_pairs or state, cannot add to removed_pairs");
987 }
988 pools_to_update.remove(&id);
989
990 msg_failed_components.insert(id.clone());
992 } else {
993 return Err(e);
994 }
995 }
996 }
997 }
998
999 for pool in pools_to_update {
1001 let default_delta_with_block = Self::add_block_info_to_delta(
1003 ProtocolStateDelta::default(),
1004 current_block.clone(),
1005 );
1006 match Self::apply_update(
1007 &pool,
1008 default_delta_with_block,
1009 &mut updated_states,
1010 &state_guard,
1011 &all_balances,
1012 ) {
1013 Ok(_) => {}
1014 Err(e) => {
1015 if self.skip_state_decode_failures {
1016 warn!(pool = pool, error = %e, "Failed to apply contract/balance update, marking component as removed");
1017 updated_states.remove(&pool);
1019 if let Some(component) = new_pairs.remove(&pool) {
1021 removed_pairs.insert(pool.clone(), component);
1022 } else if let Some(component) = state_guard.components.get(&pool) {
1023 removed_pairs.insert(pool.clone(), component.clone());
1024 } else {
1025 warn!(pool = pool, "Component not found in new_pairs or state, cannot add to removed_pairs");
1028 }
1029
1030 msg_failed_components.insert(pool.clone());
1032 } else {
1033 return Err(e);
1034 }
1035 }
1036 }
1037 }
1038 };
1039 }
1040
1041 let mut state_guard = self.state.write().await;
1043
1044 state_guard
1046 .failed_components
1047 .extend(msg_failed_components);
1048
1049 updated_states.retain(|id, _| {
1053 !state_guard
1054 .failed_components
1055 .contains(id)
1056 });
1057 new_pairs.retain(|id, _| {
1058 !state_guard
1059 .failed_components
1060 .contains(id)
1061 });
1062
1063 if let Some(header) = current_block.as_ref() {
1064 let execution_block = self.execution_block(header);
1065 let decoder_state = &mut *state_guard;
1066 Self::refresh_execution_block(
1067 &mut updated_states,
1068 &mut decoder_state.states,
1069 &decoder_state.failed_components,
1070 &removed_pairs,
1071 &execution_block,
1072 );
1073 }
1074
1075 state_guard
1076 .states
1077 .extend(updated_states.clone());
1078
1079 state_guard.current_block_number = block_number;
1080
1081 for (id, component) in new_pairs.iter() {
1083 state_guard
1084 .components
1085 .insert(id.clone(), component.clone());
1086 }
1087
1088 for id in removed_pairs.keys() {
1090 state_guard.components.remove(id);
1091 }
1092
1093 for (key, values) in contracts_map {
1094 state_guard
1095 .contracts_map
1096 .entry(key)
1097 .or_insert_with(HashSet::new)
1098 .extend(values);
1099 }
1100
1101 Ok(Update::new(block_number, updated_states, new_pairs)
1103 .set_is_partial(is_partial)
1104 .set_removed_pairs(removed_pairs)
1105 .set_sync_states(msg.sync_states.clone()))
1106 }
1107
1108 pub async fn apply_deltas_ephemeral(
1128 &self,
1129 pending_deltas: &HashMap<String, BlockAggregatedChanges>,
1130 header: H,
1131 ) -> Result<Update, StreamDecodeError> {
1132 let block_number = header
1133 .clone()
1134 .block_number_or_timestamp();
1135 let current_block = header.block();
1136 let state_guard = self.state.read().await;
1137
1138 let mut updated_states: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
1139
1140 for deltas in pending_deltas.values() {
1141 let all_balances = Balances {
1142 component_balances: deltas
1143 .component_balances
1144 .iter()
1145 .map(|(pool_id, bals)| {
1146 let balances = bals
1147 .iter()
1148 .map(|(t, b)| (t.clone(), b.balance.clone()))
1149 .collect();
1150 (pool_id.clone(), balances)
1151 })
1152 .collect(),
1153 account_balances: HashMap::new(),
1154 };
1155
1156 for (id, state_delta) in &deltas.state_deltas {
1157 let dto_delta = Self::add_block_info_to_delta(
1158 ProtocolStateDelta::from(state_delta.clone()),
1159 current_block.clone(),
1160 );
1161 if let Err(e) = Self::apply_update(
1162 id,
1163 dto_delta,
1164 &mut updated_states,
1165 &state_guard,
1166 &all_balances,
1167 ) {
1168 warn!(pool = id, error = %e, "EphemeralDeltaTransitionError");
1169 }
1170 }
1171
1172 if !deltas.account_deltas.is_empty() {
1173 Self::apply_pending_overrides(
1174 deltas,
1175 ¤t_block,
1176 &mut updated_states,
1177 &state_guard,
1178 &all_balances,
1179 )?;
1180 }
1181 }
1182
1183 if let Some(header) = current_block.as_ref() {
1188 let execution_block = BlockContext::new(header.number, header.timestamp);
1189 for state in updated_states.values_mut() {
1190 state.apply_block(&execution_block);
1191 }
1192 }
1193
1194 Ok(Update::new(block_number, updated_states, HashMap::new()))
1195 }
1196
1197 fn apply_pending_overrides(
1207 deltas: &BlockAggregatedChanges,
1208 current_block: &Option<BlockHeader>,
1209 updated_states: &mut HashMap<String, Box<dyn ProtocolSim>>,
1210 state_guard: &RwLockReadGuard<'_, DecoderState>,
1211 all_balances: &Balances,
1212 ) -> Result<(), StreamDecodeError> {
1213 let mut linked_pools: HashSet<&String> = HashSet::new();
1214 for account in deltas.account_deltas.keys() {
1215 if let Some(pools) = state_guard.contracts_map.get(account) {
1216 linked_pools.extend(pools);
1217 }
1218 }
1219
1220 let block = current_block
1221 .as_ref()
1222 .map(|h| BlockEnvOverrides { number: Some(h.number), timestamp: Some(h.timestamp) });
1223 let overrides: Arc<dyn Any + Send + Sync> =
1224 Arc::new(PendingOverrides::from_account_deltas(&deltas.account_deltas, block));
1225 for id in linked_pools {
1226 if !updated_states.contains_key(id) {
1230 let empty_delta = Self::add_block_info_to_delta(
1231 ProtocolStateDelta { component_id: id.clone(), ..Default::default() },
1232 current_block.clone(),
1233 );
1234 if let Err(e) =
1235 Self::apply_update(id, empty_delta, updated_states, state_guard, all_balances)
1236 {
1237 warn!(pool = id, error = %e, "EphemeralDeltaTransitionError");
1238 continue;
1239 }
1240 }
1241 if let Some(state) = updated_states.get_mut(id) {
1242 state
1243 .set_pending_overrides(Arc::clone(&overrides))
1244 .map_err(|e| {
1245 StreamDecodeError::Fatal(format!("Pending overrides for pool {id}: {e}"))
1246 })?;
1247 }
1248 }
1249 Ok(())
1250 }
1251
1252 fn add_block_info_to_delta(
1254 mut delta: ProtocolStateDelta,
1255 block_header_opt: Option<BlockHeader>,
1256 ) -> ProtocolStateDelta {
1257 if let Some(header) = block_header_opt {
1258 delta.updated_attributes.insert(
1261 "block_number".to_string(),
1262 Bytes::from(header.number.to_be_bytes().to_vec()),
1263 );
1264 delta.updated_attributes.insert(
1265 "block_timestamp".to_string(),
1266 Bytes::from(header.timestamp.to_be_bytes().to_vec()),
1267 );
1268 }
1269 delta
1270 }
1271
1272 fn apply_update(
1273 id: &String,
1274 update: ProtocolStateDelta,
1275 updated_states: &mut HashMap<String, Box<dyn ProtocolSim>>,
1276 state_guard: &RwLockReadGuard<'_, DecoderState>,
1277 all_balances: &Balances,
1278 ) -> Result<(), StreamDecodeError> {
1279 match updated_states.entry(id.clone()) {
1280 Entry::Occupied(mut entry) => {
1281 let state: &mut Box<dyn ProtocolSim> = entry.get_mut();
1283 state
1284 .delta_transition(update, &state_guard.tokens, all_balances)
1285 .map_err(|e| {
1286 error!(pool = id, error = ?e, "DeltaTransitionError");
1287 StreamDecodeError::Fatal(format!("TransitionFailure: {e:?}"))
1288 })?;
1289 }
1290 Entry::Vacant(_) => {
1291 match state_guard.states.get(id) {
1292 Some(stored_state) => {
1295 let mut state = stored_state.clone();
1296 state
1297 .delta_transition(update, &state_guard.tokens, all_balances)
1298 .map_err(|e| {
1299 error!(pool = id, error = ?e, "DeltaTransitionError");
1300 StreamDecodeError::Fatal(format!("TransitionFailure: {e:?}"))
1301 })?;
1302 updated_states.insert(id.clone(), state);
1303 }
1304 None => debug!(pool = id, reason = "MissingState", "DeltaTransitionError"),
1305 }
1306 }
1307 }
1308 Ok(())
1309 }
1310}
1311
1312fn generate_proxy_token_address(idx: u32) -> Result<Address, StreamDecodeError> {
1314 let padded_idx = format!("{idx:x}");
1315 let padded_zeroes = "0".repeat(33 - padded_idx.len());
1316 let proxy_token_address = format!("{padded_zeroes}{padded_idx}BAdbaBe");
1317 let decoded = hex::decode(proxy_token_address).map_err(|e| {
1318 StreamDecodeError::Fatal(format!("Invalid proxy token address encoding: {e}"))
1319 })?;
1320
1321 const ADDRESS_LENGTH: usize = 20;
1322 if decoded.len() != ADDRESS_LENGTH {
1323 return Err(StreamDecodeError::Fatal(format!(
1324 "Invalid proxy token address length: expected {}, got {}",
1325 ADDRESS_LENGTH,
1326 decoded.len(),
1327 )));
1328 }
1329
1330 Ok(Address::from_slice(&decoded))
1331}
1332
1333fn create_proxy_token_account(
1338 addr: Address,
1339 new_address: Option<Address>,
1340 storage: &HashMap<U256, U256>,
1341 chain: Chain,
1342 balance: Option<U256>,
1343) -> AccountUpdate {
1344 let mut slots = storage.clone();
1345 if let Some(new_address) = new_address {
1346 slots.insert(*IMPLEMENTATION_SLOT, U256::from_be_slice(new_address.as_slice()));
1347 }
1348
1349 AccountUpdate {
1350 address: addr,
1351 chain,
1352 slots,
1353 balance,
1354 code: Some(ERC20_PROXY_BYTECODE.to_vec()),
1355 change: ChangeType::Creation,
1356 }
1357}
1358
1359#[cfg(test)]
1360mock! {
1361 #[derive(Debug)]
1362 pub ProtocolSim {
1363 pub fn fee(&self) -> f64;
1364 pub fn spot_price(&self, base: &Token, quote: &Token) -> Result<f64, SimulationError>;
1365 pub fn get_amount_out(
1366 &self,
1367 amount_in: BigUint,
1368 token_in: &Token,
1369 token_out: &Token,
1370 ) -> Result<GetAmountOutResult, SimulationError>;
1371 pub fn get_limits(
1372 &self,
1373 sell_token: Bytes,
1374 buy_token: Bytes,
1375 ) -> Result<(BigUint, BigUint), SimulationError>;
1376 pub fn delta_transition(
1377 &mut self,
1378 delta: ProtocolStateDelta,
1379 tokens: &HashMap<Bytes, Token>,
1380 balances: &Balances,
1381 ) -> Result<(), TransitionError>;
1382 pub fn clone_box(&self) -> Box<dyn ProtocolSim>;
1383 pub fn eq(&self, other: &dyn ProtocolSim) -> bool;
1384 pub fn base_token(&self) -> &Token;
1385 pub fn quote_token(&self) -> &Token;
1386 pub fn directions(&self) -> Vec<(Bytes, Bytes)>;
1387 }
1388}
1389
1390#[cfg(test)]
1391crate::impl_non_serializable_protocol!(MockProtocolSim, "test protocol");
1392
1393#[cfg(test)]
1394impl ProtocolSim for MockProtocolSim {
1395 fn fee(&self) -> f64 {
1396 self.fee()
1397 }
1398
1399 fn spot_price(&self, base: &Token, quote: &Token) -> Result<f64, SimulationError> {
1400 self.spot_price(base, quote)
1401 }
1402
1403 fn get_amount_out(
1404 &self,
1405 amount_in: BigUint,
1406 token_in: &Token,
1407 token_out: &Token,
1408 ) -> Result<GetAmountOutResult, SimulationError> {
1409 self.get_amount_out(amount_in, token_in, token_out)
1410 }
1411
1412 fn get_limits(
1413 &self,
1414 sell_token: Bytes,
1415 buy_token: Bytes,
1416 ) -> Result<(BigUint, BigUint), SimulationError> {
1417 self.get_limits(sell_token, buy_token)
1418 }
1419
1420 fn delta_transition(
1421 &mut self,
1422 delta: ProtocolStateDelta,
1423 tokens: &HashMap<Bytes, Token>,
1424 balances: &Balances,
1425 ) -> Result<(), TransitionError> {
1426 self.delta_transition(delta, tokens, balances)
1427 }
1428
1429 fn clone_box(&self) -> Box<dyn ProtocolSim> {
1430 self.clone_box()
1431 }
1432
1433 fn as_any(&self) -> &dyn Any {
1434 panic!("MockProtocolSim does not support as_any")
1435 }
1436
1437 fn as_any_mut(&mut self) -> &mut dyn Any {
1438 panic!("MockProtocolSim does not support as_any_mut")
1439 }
1440
1441 fn eq(&self, other: &dyn ProtocolSim) -> bool {
1442 self.eq(other)
1443 }
1444
1445 fn typetag_name(&self) -> &'static str {
1446 "MockProtocolSim"
1448 }
1449
1450 fn typetag_deserialize(&self) {
1451 unreachable!()
1452 }
1453}
1454
1455#[cfg(test)]
1458impl crate::book::component::PairState for MockProtocolSim {
1459 fn base_token(&self) -> &Token {
1460 self.base_token()
1461 }
1462
1463 fn quote_token(&self) -> &Token {
1464 self.quote_token()
1465 }
1466
1467 fn directions(&self) -> Vec<(Bytes, Bytes)> {
1468 self.directions()
1469 }
1470}
1471
1472#[cfg(test)]
1473mod tests {
1474 use std::str::FromStr;
1475
1476 use alloy::primitives::address;
1477 use mockall::predicate::*;
1478 use rstest::*;
1479 use tycho_client::feed::BlockHeader;
1480 use tycho_common::{models::Chain, Bytes};
1481
1482 use super::*;
1483
1484 fn header_at(number: u64, timestamp: u64, partial: Option<u32>) -> BlockHeader {
1485 BlockHeader {
1486 hash: Bytes::from([0u8; 32]),
1487 number,
1488 parent_hash: Bytes::from([0u8; 32]),
1489 revert: false,
1490 timestamp,
1491 partial_block_index: partial,
1492 }
1493 }
1494
1495 fn block_sensitive_state() -> Box<dyn ProtocolSim> {
1497 use crate::evm::protocol::{
1498 aerodrome_slipstreams::state::AerodromeSlipstreamsState,
1499 utils::{
1500 slipstreams::{dynamic_fee_module::DynamicFeeConfig, observations::Observation},
1501 uniswap::{tick_list::TickInfo, tick_math::get_sqrt_ratio_at_tick},
1502 },
1503 };
1504
1505 Box::new(
1506 AerodromeSlipstreamsState::new(
1507 "block-sensitive".to_string(),
1508 0,
1509 1_000_000_000_000_000_000,
1510 get_sqrt_ratio_at_tick(0).unwrap(),
1511 0,
1512 1,
1513 3000,
1514 1,
1515 0,
1516 vec![TickInfo::new(-120, 0).unwrap(), TickInfo::new(120, 0).unwrap()],
1517 vec![Observation { block_timestamp: 500, initialized: true, ..Default::default() }],
1518 DynamicFeeConfig::new(2700, 30_000, 0, true, 750),
1519 )
1520 .expect("state should build")
1521 .with_position_assumption(crate::protocol::models::BlockPositionAssumption::First),
1524 )
1525 }
1526
1527 #[test]
1528 fn confirmed_header_targets_the_next_block() {
1529 let decoder = TychoStreamDecoder::<BlockHeader>::new(Chain::Base);
1530
1531 let execution_block = decoder.execution_block(&header_at(100, 1_000, None));
1532
1533 assert_eq!(execution_block.number(), 101);
1534 assert_eq!(execution_block.timestamp(), 1_000 + Chain::Base.block_time_secs());
1535 }
1536
1537 #[test]
1538 fn partial_header_targets_the_block_that_is_still_open() {
1539 let decoder = TychoStreamDecoder::<BlockHeader>::new(Chain::Ethereum);
1540
1541 let execution_block = decoder.execution_block(&header_at(100, 1_000, Some(3)));
1542
1543 assert_eq!(execution_block.number(), 100);
1544 assert_eq!(execution_block.timestamp(), 1_000);
1545 }
1546
1547 #[test]
1548 fn refresh_re_emits_a_state_whose_fee_flipped_without_a_delta() {
1549 let mut stored = HashMap::from([("block-sensitive".to_string(), {
1553 let mut state = block_sensitive_state();
1554 state.apply_block(&BlockContext::new(100, 500));
1555 state
1556 })]);
1557 let mut updated: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
1558
1559 TychoStreamDecoder::<BlockHeader>::refresh_execution_block(
1560 &mut updated,
1561 &mut stored,
1562 &HashSet::new(),
1563 &HashMap::<String, ()>::new(),
1564 &BlockContext::new(101, 502),
1565 );
1566
1567 let emitted = updated
1568 .get("block-sensitive")
1569 .expect("a fee flip must be emitted even without a delta");
1570 assert_eq!(emitted.fee(), 750.0 / 1_000_000.0);
1571 assert_eq!(stored["block-sensitive"].fee(), 750.0 / 1_000_000.0);
1573 }
1574
1575 #[test]
1576 fn refresh_never_re_emits_failed_components() {
1577 let mut stored = HashMap::from([("zombie".to_string(), {
1580 let mut state = block_sensitive_state();
1581 state.apply_block(&BlockContext::new(100, 500));
1582 state
1583 })]);
1584 let failed = HashSet::from(["zombie".to_string()]);
1585 let mut updated: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
1586
1587 TychoStreamDecoder::<BlockHeader>::refresh_execution_block(
1588 &mut updated,
1589 &mut stored,
1590 &failed,
1591 &HashMap::<String, ()>::new(),
1592 &BlockContext::new(101, 502),
1593 );
1594
1595 assert!(updated.is_empty());
1596 }
1597
1598 #[test]
1599 fn refresh_never_re_emits_removed_components() {
1600 let mut stored = HashMap::from([("gone".to_string(), {
1603 let mut state = block_sensitive_state();
1604 state.apply_block(&BlockContext::new(100, 500));
1605 state
1606 })]);
1607 let removed = HashMap::from([("gone".to_string(), ())]);
1608 let mut updated: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
1609
1610 TychoStreamDecoder::<BlockHeader>::refresh_execution_block(
1611 &mut updated,
1612 &mut stored,
1613 &HashSet::new(),
1614 &removed,
1615 &BlockContext::new(101, 502),
1616 );
1617
1618 assert!(updated.is_empty());
1619 }
1620
1621 #[test]
1622 fn refresh_stays_quiet_when_no_fee_changed() {
1623 let mut stored: HashMap<String, Box<dyn ProtocolSim>> = HashMap::from([
1626 ("idle-sensitive".to_string(), {
1627 let mut state = block_sensitive_state();
1628 state.apply_block(&BlockContext::new(101, 502));
1629 state
1630 }),
1631 (
1632 "univ2".to_string(),
1633 Box::new(crate::evm::protocol::uniswap_v2::state::UniswapV2State::new(
1634 U256::from(1_000_000u64),
1635 U256::from(1_000_000u64),
1636 )) as Box<dyn ProtocolSim>,
1637 ),
1638 ]);
1639 let mut updated: HashMap<String, Box<dyn ProtocolSim>> = HashMap::new();
1640
1641 TychoStreamDecoder::<BlockHeader>::refresh_execution_block(
1642 &mut updated,
1643 &mut stored,
1644 &HashSet::new(),
1645 &HashMap::<String, ()>::new(),
1646 &BlockContext::new(102, 504),
1647 );
1648
1649 assert!(updated.is_empty());
1650 }
1651 use crate::evm::protocol::{curve::CurveState, uniswap_v2::state::UniswapV2State};
1652
1653 #[test]
1654 fn curve_vm_adapter_registration_flagged_deprecated() {
1655 assert!(!is_deprecated_curve_registration::<CurveState>("vm:curve"));
1657 assert!(is_deprecated_curve_registration::<UniswapV2State>("vm:curve"));
1659 assert!(!is_deprecated_curve_registration::<UniswapV2State>("uniswap_v2"));
1661 }
1662
1663 async fn setup_decoder(set_tokens: bool) -> TychoStreamDecoder<BlockHeader> {
1664 let mut decoder = TychoStreamDecoder::new(Chain::Ethereum);
1665 decoder.register_decoder::<UniswapV2State>("uniswap_v2");
1666 if set_tokens {
1667 let tokens = [
1668 Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").lpad(20, 0),
1669 Bytes::from("0xdac17f958d2ee523a2206206994597c13d831ec7").lpad(20, 0),
1670 ]
1671 .iter()
1672 .map(|addr| {
1673 let addr_str = format!("{addr:x}");
1674 (
1675 addr.clone(),
1676 Token::new(addr, &addr_str, 18, 100, &[Some(100_000)], Chain::Ethereum, 100),
1677 )
1678 })
1679 .collect();
1680 decoder.set_tokens(tokens).await;
1681 }
1682 decoder
1683 }
1684
1685 fn load_test_msg(name: &str) -> FeedMessage<BlockHeader> {
1686 use std::{fs, path::Path};
1687
1688 use tycho_client::feed::dto;
1689 let project_root = env!("CARGO_MANIFEST_DIR");
1690 let asset_path = Path::new(project_root).join(format!("tests/assets/decoder/{name}.json"));
1691 let json_data = fs::read_to_string(asset_path).expect("Failed to read test asset");
1692 let feed_msg: dto::FeedMessage<BlockHeader> =
1693 serde_json::from_str(&json_data).expect("Failed to deserialize FeedMsg json!");
1694 FeedMessage::from(feed_msg)
1695 }
1696
1697 #[tokio::test]
1698 async fn test_decode() {
1699 let decoder = setup_decoder(true).await;
1700
1701 let msg = load_test_msg("uniswap_v2_snapshot");
1702 let res1 = decoder
1703 .decode(&msg)
1704 .await
1705 .expect("decode failure");
1706 let msg = load_test_msg("uniswap_v2_delta");
1707 let res2 = decoder
1708 .decode(&msg)
1709 .await
1710 .expect("decode failure");
1711
1712 assert_eq!(res1.states.len(), 1);
1713 assert_eq!(res2.states.len(), 1);
1714 assert_eq!(res1.sync_states.len(), 1);
1715 assert_eq!(res2.sync_states.len(), 1);
1716 }
1717
1718 #[tokio::test]
1719 async fn test_decode_token_creation_delta_with_existing_proxy() {
1720 let decoder = setup_decoder(true).await;
1721 let msg = load_test_msg("uniswap_v2_delta_token_creation");
1722
1723 decoder
1726 .decode(&msg)
1727 .await
1728 .expect("first decode (proxy creation) failed");
1729
1730 decoder
1734 .decode(&msg)
1735 .await
1736 .expect("decode of a token Creation delta with an existing proxy failed");
1737 }
1738
1739 #[tokio::test]
1740 async fn test_decode_component_missing_token() {
1741 let decoder = setup_decoder(false).await;
1742 let tokens = [Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").lpad(20, 0)]
1743 .iter()
1744 .map(|addr| {
1745 let addr_str = format!("{addr:x}");
1746 (
1747 addr.clone(),
1748 Token::new(addr, &addr_str, 18, 100, &[Some(100_000)], Chain::Ethereum, 100),
1749 )
1750 })
1751 .collect();
1752 decoder.set_tokens(tokens).await;
1753
1754 let msg = load_test_msg("uniswap_v2_snapshot");
1755 let res1 = decoder
1756 .decode(&msg)
1757 .await
1758 .expect("decode failure");
1759
1760 assert_eq!(res1.states.len(), 0);
1761 }
1762
1763 #[rstest]
1764 #[case::unknown_token(false)]
1765 #[case::undecodable_address(true)]
1766 #[tokio::test]
1767 async fn test_dropping_decoder_keeps_component(#[case] bad_address: bool) {
1768 let weth = Bytes::from("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").lpad(20, 0);
1769 let other = match bad_address {
1771 true => Bytes::from([1u8; 21].to_vec()),
1772 false => Bytes::from("0xdac17f958d2ee523a2206206994597c13d831ec7").lpad(20, 0),
1773 };
1774 let mut decoder = TychoStreamDecoder::new(Chain::Ethereum);
1775 decoder.register_decoder_dropping_unknown_tokens::<UniswapV2State>("uniswap_v2");
1776 let token = |address: &Bytes, symbol| {
1777 let token =
1778 Token::new(address, symbol, 18, 100, &[Some(100_000)], Chain::Ethereum, 100);
1779 (address.clone(), token)
1780 };
1781 let mut known = HashMap::from([token(&weth, "WETH")]);
1782 if bad_address {
1783 known.extend([token(&other, "OTHER")]);
1784 }
1785 decoder.set_tokens(known).await;
1786 let mut msg = load_test_msg("uniswap_v2_snapshot");
1787 let (id, snapshot) = msg
1788 .state_msgs
1789 .get_mut("uniswap_v2")
1790 .unwrap()
1791 .snapshots
1792 .states
1793 .iter_mut()
1794 .next()
1795 .unwrap();
1796 snapshot.component.tokens = vec![weth, other];
1797 let id = id.clone();
1798
1799 let update = decoder.decode(&msg).await.unwrap();
1800
1801 let symbols: Vec<_> = update.new_pairs[&id]
1802 .tokens
1803 .iter()
1804 .map(|token| token.symbol.as_str())
1805 .collect();
1806 assert_eq!(symbols, ["WETH"]);
1807 assert_eq!(update.states.len(), 1);
1808 }
1809
1810 #[tokio::test]
1811 async fn test_decode_component_bad_id() {
1812 let decoder = setup_decoder(true).await;
1813 let msg = load_test_msg("uniswap_v2_snapshot_broken_id");
1814
1815 match decoder.decode(&msg).await {
1816 Err(StreamDecodeError::Fatal(msg)) => {
1817 assert_eq!(msg, "Component id mismatch");
1818 }
1819 Ok(_) => {
1820 panic!("Expected failures to be raised")
1821 }
1822 }
1823 }
1824
1825 #[rstest]
1826 #[case(true)]
1827 #[case(false)]
1828 #[tokio::test]
1829 async fn test_decode_component_bad_state(#[case] skip_failures: bool) {
1830 let mut decoder = setup_decoder(true).await;
1831 decoder.skip_state_decode_failures = skip_failures;
1832
1833 let msg = load_test_msg("uniswap_v2_snapshot_broken_state");
1834 match decoder.decode(&msg).await {
1835 Err(StreamDecodeError::Fatal(msg)) => {
1836 if !skip_failures {
1837 assert_eq!(msg, "Missing attributes reserve0");
1838 } else {
1839 panic!("Expected failures to be ignored. Err: {msg}")
1840 }
1841 }
1842 Ok(res) => {
1843 if !skip_failures {
1844 panic!("Expected failures to be raised")
1845 } else {
1846 assert_eq!(res.states.len(), 0);
1847 }
1848 }
1849 }
1850 }
1851
1852 #[tokio::test]
1853 async fn test_decode_updates_state_on_contract_change() {
1854 let decoder = setup_decoder(true).await;
1855
1856 let mut mock_state = MockProtocolSim::new();
1858
1859 mock_state
1860 .expect_clone_box()
1861 .times(1)
1862 .returning(|| {
1863 let mut cloned_mock_state = MockProtocolSim::new();
1864 cloned_mock_state
1866 .expect_delta_transition()
1867 .times(1)
1868 .returning(|_, _, _| Ok(()));
1869 cloned_mock_state
1870 .expect_clone_box()
1871 .times(1)
1872 .returning(|| Box::new(MockProtocolSim::new()));
1873 Box::new(cloned_mock_state)
1874 });
1875
1876 let pool_id =
1878 "0x93d199263632a4ef4bb438f1feb99e57b4b5f0bd0000000000000000000005c2".to_string();
1879 decoder
1880 .state
1881 .write()
1882 .await
1883 .states
1884 .insert(pool_id.clone(), Box::new(mock_state) as Box<dyn ProtocolSim>);
1885 decoder
1886 .state
1887 .write()
1888 .await
1889 .contracts_map
1890 .insert(
1891 Bytes::from("0xba12222222228d8ba445958a75a0704d566bf2c8").lpad(20, 0),
1892 HashSet::from([pool_id.clone()]),
1893 );
1894
1895 let msg = load_test_msg("balancer_v2_delta");
1897
1898 let _ = decoder
1900 .decode(&msg)
1901 .await
1902 .expect("decode failure");
1903
1904 }
1906
1907 #[tokio::test]
1910 async fn test_apply_deltas_ephemeral_sets_pending_overrides_on_the_clone_only() {
1911 use tycho_common::models::{
1912 blockchain::BlockAggregatedChanges, contract::AccountDelta,
1913 protocol::ProtocolComponentStateDelta, ChangeType as ModelChangeType,
1914 };
1915
1916 use crate::evm::protocol::uniswap_v4::state::{UniswapV4Fees, UniswapV4State};
1917
1918 let decoder = TychoStreamDecoder::<BlockHeader>::new(Chain::Ethereum);
1919 let pool_id = "0xhooked".to_string();
1920 let quiet_pool_id = "0xhooked-no-log".to_string();
1921 let pool = UniswapV4State::new(
1922 1000,
1923 U256::from(1u8) << 96,
1924 UniswapV4Fees::new(0, 0, 3000),
1925 0,
1926 60,
1927 vec![],
1928 )
1929 .unwrap();
1930 let hook = Bytes::from(vec![7u8; 20]);
1931 {
1932 let mut state = decoder.state.write().await;
1933 state
1934 .states
1935 .insert(pool_id.clone(), Box::new(pool.clone()));
1936 state
1937 .states
1938 .insert(quiet_pool_id.clone(), Box::new(pool));
1939 state
1940 .contracts_map
1941 .insert(hook.clone(), HashSet::from([pool_id.clone(), quiet_pool_id.clone()]));
1942 }
1943
1944 let deltas = BlockAggregatedChanges {
1945 extractor: "uniswap_v4_hooks".to_string(),
1946 state_deltas: HashMap::from([(
1947 pool_id.clone(),
1948 ProtocolComponentStateDelta {
1949 component_id: pool_id.clone(),
1950 updated_attributes: HashMap::from([(
1951 "liquidity".to_string(),
1952 Bytes::from(2000_u64.to_be_bytes().to_vec()),
1953 )]),
1954 deleted_attributes: HashSet::new(),
1955 created_attributes: HashSet::new(),
1956 },
1957 )]),
1958 account_deltas: HashMap::from([(
1959 hook.clone(),
1960 AccountDelta::new(
1961 Chain::Ethereum,
1962 hook.clone(),
1963 HashMap::from([(Bytes::from(vec![0u8]), Some(Bytes::from(vec![9u8])))]),
1964 None,
1965 None,
1966 ModelChangeType::Update,
1967 ),
1968 )]),
1969 ..Default::default()
1970 };
1971 let header = BlockHeader { number: 10, timestamp: 20, ..Default::default() };
1972
1973 let update = decoder
1974 .apply_deltas_ephemeral(
1975 &HashMap::from([("uniswap_v4_hooks".to_string(), deltas)]),
1976 header,
1977 )
1978 .await
1979 .unwrap();
1980
1981 let clone = update.states[&pool_id]
1982 .as_any()
1983 .downcast_ref::<UniswapV4State>()
1984 .unwrap();
1985 let pending = clone
1986 .pending_overrides()
1987 .expect("the clone carries the pending block's overrides");
1988 assert_eq!(
1989 pending.block,
1990 Some(BlockEnvOverrides { number: Some(10), timestamp: Some(20) })
1991 );
1992 assert_eq!(
1993 pending.storage.as_ref().unwrap()[&Address::from_slice(&hook)][&U256::ZERO],
1994 U256::from(9)
1995 );
1996 let quiet = update.states[&quiet_pool_id]
1997 .as_any()
1998 .downcast_ref::<UniswapV4State>()
1999 .expect("a pool whose hook was written is cloned without a delta of its own");
2000 assert!(quiet.pending_overrides().is_some());
2001
2002 let stored = decoder.state.read().await;
2003 for id in [&pool_id, &quiet_pool_id] {
2004 let stored = stored.states[id]
2005 .as_any()
2006 .downcast_ref::<UniswapV4State>()
2007 .unwrap();
2008 assert!(stored.pending_overrides().is_none(), "confirmed state is never overlaid");
2009 }
2010 }
2011
2012 #[test]
2013 fn test_generate_proxy_token_address() {
2014 let idx = 1;
2015 let generated_address =
2016 generate_proxy_token_address(idx).expect("proxy token address should be valid");
2017 assert_eq!(generated_address, address!("000000000000000000000000000000001badbabe"));
2018
2019 let idx = 123456;
2020 let generated_address =
2021 generate_proxy_token_address(idx).expect("proxy token address should be valid");
2022 assert_eq!(generated_address, address!("00000000000000000000000000001e240badbabe"));
2023 }
2024
2025 fn hooked_v4_msg() -> FeedMessage<BlockHeader> {
2031 use tycho_client::feed::synchronizer::{Snapshot, StateSyncMessage};
2032 use tycho_common::models::protocol::{ProtocolComponent, ProtocolComponentState};
2033
2034 let id = "0x00000000000000000000000000000000000000000000000000000000000000c4";
2035 let static_attributes = HashMap::from([
2036 ("key_lp_fee".to_string(), Bytes::from(500_i32.to_be_bytes().to_vec())),
2037 ("tick_spacing".to_string(), Bytes::from(60_i32.to_be_bytes().to_vec())),
2038 (
2039 "hooks".to_string(),
2040 Bytes::from_str("0x00000000000000000000000000000000000000c4").unwrap(),
2041 ),
2042 ]);
2043 let attributes = HashMap::from([
2044 ("liquidity".to_string(), Bytes::from(100_u64.to_be_bytes().to_vec())),
2045 ("tick".to_string(), Bytes::from(300_i32.to_be_bytes().to_vec())),
2046 (
2047 "sqrt_price_x96".to_string(),
2048 Bytes::from(
2049 79228162514264337593543950336_u128
2050 .to_be_bytes()
2051 .to_vec(),
2052 ),
2053 ),
2054 ("protocol_fees/zero2one".to_string(), Bytes::from(0_u32.to_be_bytes().to_vec())),
2055 ("protocol_fees/one2zero".to_string(), Bytes::from(0_u32.to_be_bytes().to_vec())),
2056 ("ticks/60/net_liquidity".to_string(), Bytes::from(400_i128.to_be_bytes().to_vec())),
2057 ]);
2058
2059 let snapshot = ComponentWithState {
2060 state: ProtocolComponentState::new(id, attributes, HashMap::new()),
2061 component: ProtocolComponent {
2062 id: id.to_string(),
2063 static_attributes,
2064 ..Default::default()
2065 },
2066 component_tvl: None,
2067 entrypoints: Vec::new(),
2068 };
2069
2070 FeedMessage {
2071 state_msgs: HashMap::from([(
2072 "uniswap_v4_hooks".to_string(),
2073 StateSyncMessage {
2074 header: header_at(1, 1_000, None),
2075 snapshots: Snapshot {
2076 states: HashMap::from([(id.to_string(), snapshot)]),
2077 vm_storage: HashMap::new(),
2078 },
2079 deltas: None,
2080 removed_components: HashMap::new(),
2081 },
2082 )]),
2083 sync_states: HashMap::new(),
2084 }
2085 }
2086
2087 fn hooked_v4_decoder(chain: Chain, context: DecoderContext) -> TychoStreamDecoder<BlockHeader> {
2089 let mut decoder = TychoStreamDecoder::new(chain);
2090 decoder.register_decoder_with_context::<crate::evm::protocol::uniswap_v4::state::UniswapV4State>(
2091 "uniswap_v4_hooks", context
2092 );
2093 decoder
2094 }
2095
2096 #[tokio::test]
2097 async fn test_unregistered_hook_is_rejected_off_the_generic_vm_chains() {
2098 let decoder = hooked_v4_decoder(Chain::Robinhood, DecoderContext::new());
2099
2100 let Err(StreamDecodeError::Fatal(message)) = decoder.decode(&hooked_v4_msg()).await else {
2101 panic!("a hooked pool on robinhood must not decode");
2102 };
2103
2104 assert!(message.contains("unsupported uniswap v4 hook"), "{message}");
2105 assert!(message.contains("robinhood"), "{message}");
2106 }
2107
2108 #[tokio::test]
2109 async fn test_decoder_chain_overrides_the_registered_context_chain() {
2110 let decoder =
2111 hooked_v4_decoder(Chain::Robinhood, DecoderContext::new().chain(Chain::Ethereum));
2112
2113 let Err(StreamDecodeError::Fatal(message)) = decoder.decode(&hooked_v4_msg()).await else {
2114 panic!("the decoder's chain must win over the context's");
2115 };
2116
2117 assert!(message.contains("robinhood"), "{message}");
2118 }
2119
2120 #[tokio::test]
2121 async fn test_unregistered_hook_takes_the_generic_path_on_ethereum() {
2122 let decoder = hooked_v4_decoder(Chain::Ethereum, DecoderContext::new());
2123
2124 let Err(StreamDecodeError::Fatal(message)) = decoder.decode(&hooked_v4_msg()).await else {
2125 panic!("the generic VM creator has no balance_owner attribute to work from");
2126 };
2127
2128 assert!(!message.contains("unsupported uniswap v4 hook"), "{message}");
2129 assert!(message.contains("balance_owner"), "{message}");
2130 }
2131
2132 #[tokio::test(flavor = "multi_thread")]
2133 async fn test_euler_hook_low_pool_manager_balance() {
2134 let mut decoder = TychoStreamDecoder::new(Chain::Ethereum);
2135
2136 decoder.register_decoder_with_context::<crate::evm::protocol::uniswap_v4::state::UniswapV4State>(
2137 "uniswap_v4_hooks", DecoderContext::new().vm_traces(true)
2138 );
2139
2140 let weth = Bytes::from_str("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2").unwrap();
2141 let teth = Bytes::from_str("0xd11c452fc99cf405034ee446803b6f6c1f6d5ed8").unwrap();
2142 let tokens = HashMap::from([
2143 (
2144 weth.clone(),
2145 Token::new(&weth, "WETH", 18, 100, &[Some(100_000)], Chain::Ethereum, 100),
2146 ),
2147 (
2148 teth.clone(),
2149 Token::new(&teth, "tETH", 18, 100, &[Some(100_000)], Chain::Ethereum, 100),
2150 ),
2151 ]);
2152
2153 decoder.set_tokens(tokens.clone()).await;
2154
2155 let msg = load_test_msg("euler_hook_snapshot");
2156 let res = decoder
2157 .decode(&msg)
2158 .await
2159 .expect("decode failure");
2160
2161 let pool_state = res
2162 .states
2163 .get("0xc70d7fbd7fcccdf726e02fed78548b40dc52502b097c7a1ee7d995f4d4396134")
2164 .expect("Couldn't find target pool");
2165 let amount_out = pool_state
2166 .get_amount_out(
2167 BigUint::from_str("1000000000000000000").unwrap(),
2168 tokens.get(&teth).unwrap(),
2169 tokens.get(&weth).unwrap(),
2170 )
2171 .expect("Get amount out failed");
2172
2173 assert_eq!(amount_out.amount, BigUint::from_str("1216190190361759119").unwrap());
2174 }
2175
2176 fn pons_feed_message(snapshot: ComponentWithState) -> FeedMessage<BlockHeader> {
2178 use tycho_client::feed::synchronizer::{Snapshot, StateSyncMessage};
2179
2180 use crate::evm::protocol::uniswap_v4::pons_fixture;
2181
2182 FeedMessage {
2183 state_msgs: HashMap::from([(
2184 "uniswap_v4_hooks".to_string(),
2185 StateSyncMessage {
2186 header: pons_fixture::header(),
2187 snapshots: Snapshot {
2188 states: HashMap::from([(pons_fixture::POOL_ID.to_string(), snapshot)]),
2189 vm_storage: HashMap::new(),
2190 },
2191 deltas: None,
2192 removed_components: HashMap::new(),
2193 },
2194 )]),
2195 sync_states: HashMap::new(),
2196 }
2197 }
2198
2199 async fn pons_stream_decoder() -> TychoStreamDecoder<BlockHeader> {
2201 use crate::evm::protocol::uniswap_v4::{
2202 hooks::hook_handler_creator::initialize_hook_handlers, pons_fixture,
2203 state::UniswapV4State,
2204 };
2205
2206 initialize_hook_handlers().expect("hook handler registration should succeed");
2207 let mut decoder = TychoStreamDecoder::new(Chain::Robinhood);
2208 decoder.register_decoder::<UniswapV4State>("uniswap_v4_hooks");
2209 decoder
2210 .set_tokens(pons_fixture::tokens())
2211 .await;
2212 decoder
2213 }
2214
2215 #[tokio::test]
2219 async fn test_pons_pool_decodes_through_the_stream_decoder_on_robinhood() {
2220 use crate::evm::protocol::uniswap_v4::{
2221 hooks::pons_v2::hook_handler::PonsV2HookHandler, pons_fixture, state::UniswapV4State,
2222 };
2223
2224 let decoder = pons_stream_decoder().await;
2225
2226 let result = decoder
2227 .decode(&pons_feed_message(pons_fixture::snapshot()))
2228 .await
2229 .expect("decode failure");
2230
2231 let emitted = result
2232 .states
2233 .get(pons_fixture::POOL_ID)
2234 .expect("the Pons pool must reach consumers");
2235 let pool = emitted
2236 .as_any()
2237 .downcast_ref::<UniswapV4State>()
2238 .expect("a uniswap_v4_hooks component decodes into a UniswapV4State");
2239 let handler = pool
2240 .hook
2241 .as_ref()
2242 .expect("a Pons pool must carry a hook handler");
2243 let pons = handler
2244 .as_any()
2245 .downcast_ref::<PonsV2HookHandler>()
2246 .expect("the registry must hand back the native Pons handler");
2247 assert_eq!(u32::from(pons.hook_fee_bps()), pons_fixture::HOOK_FEE_BPS);
2248 assert_eq!(u32::from(pons.creator_tax_bps()), pons_fixture::CREATOR_TAX_BPS);
2249
2250 let core = pons_fixture::decode_on(pons_fixture::hookless_snapshot(), Chain::Robinhood)
2251 .await
2252 .expect("the same pool with no hook must decode too");
2253 let (xlg, nvda) = (pons_fixture::xlg(), pons_fixture::nvda());
2254 let amount_in = BigUint::from(10u64).pow(18);
2255 for (token_in, token_out) in [(&xlg, &nvda), (&nvda, &xlg)] {
2256 let core_out = core
2257 .get_amount_out(amount_in.clone(), token_in, token_out)
2258 .expect("the reference pool quotes one whole token")
2259 .amount;
2260 let hooked_out = emitted
2261 .get_amount_out(amount_in.clone(), token_in, token_out)
2262 .expect("the emitted pool quotes one whole token")
2263 .amount;
2264
2265 let expected = pons_fixture::net_of_hook_take(&core_out);
2266 assert!(expected < core_out, "the hook must take something out of {core_out}");
2267 assert_eq!(hooked_out, expected, "{} -> {}", token_in.symbol, token_out.symbol);
2268 }
2269 }
2270
2271 #[tokio::test]
2274 async fn test_unknown_hook_component_is_not_emitted_on_robinhood() {
2275 use crate::evm::protocol::uniswap_v4::pons_fixture;
2276
2277 let mut decoder = pons_stream_decoder().await;
2278 decoder.skip_state_decode_failures(true);
2279
2280 let result = decoder
2281 .decode(&pons_feed_message(pons_fixture::unknown_hook_snapshot()))
2282 .await
2283 .expect("a skipped decode failure is not fatal");
2284
2285 assert!(
2286 !result
2287 .states
2288 .contains_key(pons_fixture::POOL_ID),
2289 "a pool whose hook cannot be modelled must not be quoted"
2290 );
2291 assert!(result.states.is_empty());
2292 }
2293
2294 fn component_with_id(id: &str) -> ComponentWithState {
2295 use tycho_common::models::protocol::{ProtocolComponent, ProtocolComponentState};
2296
2297 ComponentWithState {
2298 state: ProtocolComponentState::new(id, HashMap::new(), HashMap::new()),
2299 component: ProtocolComponent { id: id.to_string(), ..Default::default() },
2300 component_tvl: None,
2301 entrypoints: Vec::new(),
2302 }
2303 }
2304
2305 fn rejects_a(component: &ComponentWithState) -> bool {
2306 component.component.id != "a"
2307 }
2308
2309 fn rejects_b(component: &ComponentWithState) -> bool {
2310 component.component.id != "b"
2311 }
2312
2313 #[test]
2314 fn test_admits_requires_every_registered_filter() {
2315 let mut decoder = TychoStreamDecoder::<BlockHeader>::new(Chain::Ethereum);
2318 decoder.register_filter("x", rejects_a);
2319 decoder.register_filter("x", rejects_b);
2320
2321 assert!(!decoder.admits("x", &component_with_id("a")));
2322 assert!(!decoder.admits("x", &component_with_id("b")));
2323 assert!(decoder.admits("x", &component_with_id("c")));
2324 assert!(decoder.admits("y", &component_with_id("a")));
2325 }
2326}