feat: Create tycho-test lib

- Move shared code from tycho-integration test into it
- Extend code to be used by the sdk range test
  - Allow doing router and executor overwrites
  - Allow setting executors_json and historical_trade to TychoEncoder
  - Move methods from sdk to tycho-test calculate_executor_storage_slot, setup_router_overwrites
  - Add RouterOverwritesData model
- Misc fixes:
  - Create tenderly link in N + 1 block
  - When execution fails and we can not decode the selector -> print the whole input data used

Took 2 hours 37 minutes


Took 11 seconds

Author: dianacarvalho1

Cargo.lock

@@ -12,7 +12,7 @@ categories = ["finance", "cryptography::cryptocurrencies"]
 readme = "README.md"
 
 [workspace]
-members = ["tycho-integration-test", "tycho_simulation_py"]
+members = ["tycho-integration-test", "tycho-test", "tycho_simulation_py"]
 
 [workspace.dependencies]
 # Serialization/Deserialization

Cargo.toml

@@ -6,30 +6,24 @@ edition = "2021"
 [dependencies]
 alloy = { workspace = true, features = ["rpc-types-eth", "sol-types"] }
 alloy-chains = "0.2.6"
-alloy-rpc-types-trace = "1.0.38"
 clap = { version = "4.5.48", features = ["derive"] }
 colored = "3.0.0"
 dotenv = { workspace = true }
 futures = { workspace = true }
 itertools = { workspace = true }
-lru = "0.16.1"
 num-bigint = { workspace = true }
 num-traits = { workspace = true }
 miette = { version = "7.6.0" }
-regex = "1.12.2"
 serde = { workspace = true }
 serde_json = { workspace = true }
 rand = "0.9.2"
 tokio = { workspace = true }
-tokio-retry2 = { version = "0.6.0", features = ["jitter"] }
 tracing = { workspace = true }
 metrics = "0.24.2"
 metrics-exporter-prometheus = "0.17.2"
 actix-web = "4.11.0"
 tycho-client = { workspace = true }
 tycho-common = { workspace = true }
-tycho-ethereum = { workspace = true }
-tycho-execution = { workspace = true }
 tycho-simulation = { path = "..", features = ["evm"] }
-urlencoding = "2.1.3"
+tycho-test = { path = "../tycho-test" }
 tracing-subscriber = { workspace = true }

tycho-integration-test/Cargo.toml

@@ -1,6 +1,4 @@
-mod execution;
 mod metrics;
-mod stream_processor;
 
 use std::{
     collections::{HashMap, HashSet},
@@ -9,14 +7,7 @@ use std::{
     time::Duration,
 };
 
-use alloy::{
-    eips::BlockNumberOrTag,
-    network::Ethereum,
-    primitives::Address,
-    providers::{Provider, ProviderBuilder, RootProvider},
-    rpc::types::Block,
-};
-use alloy_chains::NamedChain;
+use alloy::{eips::BlockNumberOrTag, primitives::Address, providers::Provider, rpc::types::Block};
 use clap::Parser;
 use dotenv::dotenv;
 use itertools::Itertools;
@@ -28,18 +19,13 @@ use tokio::sync::Semaphore;
 use tracing::{error, info, warn};
 use tracing_subscriber::EnvFilter;
 use tycho_common::simulation::protocol_sim::ProtocolSim;
-use tycho_ethereum::entrypoint_tracer::{
-    allowance_slot_detector::{AllowanceSlotDetectorConfig, EVMAllowanceSlotDetector},
-    balance_slot_detector::{BalanceSlotDetectorConfig, EVMBalanceSlotDetector},
-};
 use tycho_simulation::{
     protocol::models::ProtocolComponent,
     rfq::protocols::hashflow::{client::HashflowClient, state::HashflowState},
     tycho_common::models::Chain,
     utils::load_all_tokens,
 };
-
-use crate::{
+use tycho_test::{
     execution::{
         encoding::encode_swap,
         models::{TychoExecutionInput, TychoExecutionResult},
@@ -173,7 +159,7 @@ async fn run(cli: Cli) -> miette::Result<()> {
     let cli = Arc::new(cli);
     let chain = cli.chain;
 
-    let rpc_tools = RPCTools::new(&cli.rpc_url, &chain).await?;
+    let rpc_tools = tycho_test::RPCTools::new(&cli.rpc_url, &chain).await?;
 
     // Load tokens from Tycho
     info!(%cli.tycho_url, "Loading tokens...");
@@ -247,7 +233,7 @@ async fn run(cli: Cli) -> miette::Result<()> {
 async fn process_update(
     cli: Arc<Cli>,
     chain: Chain,
-    rpc_tools: RPCTools,
+    rpc_tools: tycho_test::RPCTools,
     tycho_state: Arc<RwLock<TychoState>>,
     update: &StreamUpdate,
 ) -> miette::Result<()> {
@@ -490,6 +476,7 @@ async fn process_update(
         block_execution_info.clone(),
         &block,
         cli.block_wait_time,
+        None,
     )
     .await
     {
@@ -510,7 +497,7 @@ async fn process_update(
         }
         .clone();
 
-        let state = {
+        let state_str = {
             let current_state = tycho_state
                 .read()
                 .map_err(|e| miette!("Failed to acquire read lock on Tycho state: {e}"))?;
@@ -519,18 +506,15 @@ async fn process_update(
                 .states
                 .get(&execution_info.component_id)
             {
-                Some(state) => state.clone(),
-                None => {
-                    error!(id=%execution_info.component_id, "State not found in saved protocol states");
-                    continue;
-                }
+                Some(state) => format!("{:?}", state),
+                None => "".to_string(),
             }
         };
         (n_reverts, n_failures) = process_execution_result(
             simulation_id,
             result,
             execution_info,
-            state,
+            state_str,
             (*block).clone(),
             chain.id().to_string(),
             n_reverts,
@@ -691,11 +675,13 @@ async fn process_state(
         // Simulate execution amount out against the RPC
         let (solution, transaction) = match encode_swap(
             &component,
-            Arc::from(state.clone_box()),
+            Some(Arc::from(state.clone_box())),
             token_in,
             token_out,
             amount_in.clone(),
             chain,
+            None,
+            false,
         ) {
             Ok(res) => res,
             Err(e) => {
@@ -740,7 +726,8 @@ fn process_execution_result(
     simulation_id: &String,
     result: &TychoExecutionResult,
     execution_info: TychoExecutionInput,
-    state: Box<dyn ProtocolSim>,
+    state_str: String,
+
     block: Block,
     chain_id: String,
     mut n_reverts: i32,
@@ -775,7 +762,7 @@ fn process_execution_result(
 
             info!(
                 event_type = "execution_slippage",
-                state = ?state,
+                state = ?state_str,
                 token_in = %execution_info.token_in,
                 token_out = %execution_info.token_out,
                 simulated_amount  = %amount_out,
@@ -823,7 +810,7 @@ fn process_execution_result(
                 error_message = %revert_reason,
                 error_name = %error_name,
                 error_category = %error_category,
-                state = ?state,
+                state = ?state_str,
                 token_in = %execution_info.token_in,
                 token_out = %execution_info.token_out,
                 tenderly_url = %tenderly_url,
@@ -889,49 +876,6 @@ fn categorize_error(error_name: &str) -> &'static str {
     }
 }
 
-#[derive(Clone)]
-struct RPCTools {
-    rpc_url: String,
-    provider: RootProvider<Ethereum>,
-    evm_balance_slot_detector: Arc<EVMBalanceSlotDetector>,
-    evm_allowance_slot_detector: Arc<EVMAllowanceSlotDetector>,
-}
-
-impl RPCTools {
-    pub async fn new(rpc_url: &str, chain: &Chain) -> miette::Result<Self> {
-        let provider: RootProvider<Ethereum> = ProviderBuilder::default()
-            .with_chain(
-                NamedChain::try_from(chain.id())
-                    .into_diagnostic()
-                    .wrap_err("Invalid chain")?,
-            )
-            .connect(rpc_url)
-            .await
-            .into_diagnostic()
-            .wrap_err("Failed to connect to provider")?;
-        let evm_balance_slot_detector = Arc::new(
-            EVMBalanceSlotDetector::new(BalanceSlotDetectorConfig {
-                rpc_url: rpc_url.to_string(),
-                ..Default::default()
-            })
-            .into_diagnostic()?,
-        );
-        let evm_allowance_slot_detector = Arc::new(
-            EVMAllowanceSlotDetector::new(AllowanceSlotDetectorConfig {
-                rpc_url: rpc_url.to_string(),
-                ..Default::default()
-            })
-            .into_diagnostic()?,
-        );
-        Ok(Self {
-            rpc_url: rpc_url.to_string(),
-            provider,
-            evm_balance_slot_detector,
-            evm_allowance_slot_detector,
-        })
-    }
-}
-
 /// Generate a unique simulation ID based on protocol system and state ID
 fn generate_simulation_id(protocol_system: &str, state_id: &str) -> String {
     let random_number: u32 = rand::random::<u32>() % 90000 + 10000; // Range 10000-99999

tycho-integration-test/src/main.rs

@@ -0,0 +1,34 @@
+[package]
+name = "tycho-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+alloy = { workspace = true, features = ["rpc-types-eth", "sol-types"] }
+alloy-chains = "0.2.6"
+alloy-rpc-types-trace = "1.0.38"
+colored = "3.0.0"
+dotenv = { workspace = true }
+futures = { workspace = true }
+itertools = { workspace = true }
+lru = "0.16.1"
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+miette = { version = "7.6.0" }
+regex = "1.12.2"
+serde = { workspace = true }
+serde_json = { workspace = true }
+rand = "0.9.2"
+tokio = { workspace = true }
+tokio-retry2 = { version = "0.6.0", features = ["jitter"] }
+tracing = { workspace = true }
+metrics = "0.24.2"
+metrics-exporter-prometheus = "0.17.2"
+actix-web = "4.11.0"
+tycho-client = { workspace = true }
+tycho-common = { workspace = true }
+tycho-ethereum = { workspace = true }
+tycho-execution = { workspace = true }
+tycho-simulation = { path = "..", features = ["evm"] }
+urlencoding = "2.1.3"
+tracing-subscriber = { workspace = true }