fix(CA): using the bundled simulation for allowance and bridging transactions (#919)

geekbrother · web-flow · commit eb071adfca74 · 2025-01-30T09:00:36.000+01:00
diff --git a/src/error.rs b/src/error.rs
@@ -247,6 +247,12 @@ pub enum RpcError {
 
     #[error("Bridging final amount is less then expected")]
     BridgingFinalAmountLess,
+
+    #[error("Simulation provider unavailable")]
+    SimulationProviderUnavailable,
+
+    #[error("Simulation failed: {0}")]
+    SimulationFailed(String),
 }
 
 impl IntoResponse for RpcError {
@@ -623,6 +629,14 @@ impl IntoResponse for RpcError {
                 )),
             )
                 .into_response(),
+            Self::SimulationProviderUnavailable => (
+                StatusCode::SERVICE_UNAVAILABLE,
+                Json(new_error_response(
+                    "".to_string(),
+                    "Simulation provider is temporarily unavailable".to_string(),
+                )),
+            )
+                .into_response(),
             Self::CosignerPermissionDenied(e) => (
                     StatusCode::UNAUTHORIZED,
                     Json(new_error_response(
diff --git a/src/handlers/chain_agnostic/mod.rs b/src/handlers/chain_agnostic/mod.rs
@@ -287,12 +287,13 @@ pub async fn get_assets_changes_from_simulation(
     {
         if asset_changed.asset_type.clone() == AssetChangeType::Transfer
             && asset_changed.token_info.standard.clone() == TokenStandard::Erc20
+            && asset_changed.to.is_some()
         {
             asset_changes.push(Erc20AssetChange {
                 chain_id: transaction.chain_id.clone(),
                 asset_contract: asset_changed.token_info.contract_address,
                 amount: asset_changed.raw_amount,
-                receiver: asset_changed.to,
+                receiver: asset_changed.to.unwrap_or_default(),
             })
         }
     }
diff --git a/src/handlers/chain_agnostic/route.rs b/src/handlers/chain_agnostic/route.rs
@@ -15,7 +15,7 @@ use {
         utils::{
             crypto::{
                 convert_alloy_address_to_h160, decode_erc20_transfer_data, get_erc20_balance,
-                get_gas_estimate, get_nonce, Erc20FunctionType,
+                get_nonce, Erc20FunctionType,
             },
             network,
         },
@@ -29,6 +29,7 @@ use {
     hyper::HeaderMap,
     serde::{Deserialize, Serialize},
     std::{
+        collections::HashMap,
         net::SocketAddr,
         str::FromStr,
         sync::Arc,
@@ -48,7 +49,7 @@ use {
 };
 
 // Slippage for the gas estimation
-const ESTIMATED_GAS_SLIPPAGE: i8 = 100; // 100%, x2 slippage to cover the volatility
+const ESTIMATED_GAS_SLIPPAGE: i8 = 20; // 20% slippage to cover the volatility
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -410,7 +411,7 @@ async fn handler_internal(
                 )
                 .await?;
 
-            let mut approval_transaction = Transaction {
+            let approval_transaction = Transaction {
                 from: approval_tx.from,
                 to: approval_tx.to,
                 value: U256::ZERO,
@@ -419,70 +420,14 @@ async fn handler_internal(
                 nonce: current_nonce,
                 chain_id: format!("eip155:{}", bridge_tx.chain_id),
             };
-
-            // Estimate (or get cached) the gas for the approval transaction above and multiply by the slippage
-            let approval_gas_limit = match state
-                .providers
-                .simulation_provider
-                .clone()
-                .get_cached_gas_estimation(
-                    &approval_transaction.chain_id,
-                    approval_transaction.to,
-                    Some(Erc20FunctionType::Approve),
-                )
-                .await?
-            {
-                Some(cached_gas) => cached_gas,
-                None => {
-                    let estimated_gas_used = get_gas_estimate(
-                        &approval_transaction.chain_id,
-                        approval_transaction.from,
-                        approval_transaction.to,
-                        approval_transaction.value,
-                        approval_transaction.input.clone(),
-                        rpc_project_id.as_ref(),
-                        MessageSource::ChainAgnosticCheck,
-                    )
-                    .await?;
-                    // Save the approval tx gas estimation to the cache
-                    {
-                        let state = state.clone();
-                        let approval_tx_chain_id = approval_transaction.chain_id.clone();
-                        tokio::spawn(async move {
-                            state
-                                .providers
-                                .simulation_provider
-                                .clone()
-                                .set_cached_gas_estimation(
-                                    &approval_tx_chain_id,
-                                    approval_tx.to,
-                                    Some(Erc20FunctionType::Approve),
-                                    estimated_gas_used,
-                                )
-                                .await
-                                .unwrap_or_else(|e| {
-                                    error!(
-                            "Failed to save the approval gas estimation to the cache: {}",
-                            e
-                        )
-                                });
-                        });
-                    }
-                    estimated_gas_used
-                }
-            };
-
-            // Updating the gas limit for the approval transaction
-            approval_transaction.gas_limit =
-                U64::from((approval_gas_limit * (100 + ESTIMATED_GAS_SLIPPAGE as u64)) / 100);
             routes.push(approval_transaction);
 
             // Increment the nonce
             current_nonce += U64::from(1);
         }
     }
 
-    let mut bridging_transaction = Transaction {
+    let bridging_transaction = Transaction {
         from: from_address,
         to: bridge_tx.tx_target,
         value: bridge_tx.value,
@@ -491,55 +436,28 @@ async fn handler_internal(
         nonce: current_nonce,
         chain_id: format!("eip155:{}", bridge_tx.chain_id),
     };
+    routes.push(bridging_transaction);
 
-    // Estimate (or get cached) the gas for the bridging transaction above and multiply by the slippage
-    let bridging_gas_limit = match state
+    // Estimate the gas usage for the approval (if present) and bridging transactions
+    // and update gas limits for transactions
+    let simulation_results = state
         .providers
         .simulation_provider
-        .clone()
-        .get_cached_gas_estimation(&bridge_tx.chain_id.to_string(), bridge_tx.tx_target, None)
-        .await?
-    {
-        Some(cached_gas) => cached_gas,
-        None => {
-            let (_, estimated_gas_used) = get_assets_changes_from_simulation(
-                state.providers.simulation_provider.clone(),
-                &bridging_transaction,
-                state.metrics.clone(),
-            )
-            .await?;
-            // Save the bridging tx gas estimation to the cache
-            {
-                let state = state.clone();
-                let bridging_tx_chain_id = bridge_tx.chain_id.to_string().clone();
-                tokio::spawn(async move {
-                    state
-                        .providers
-                        .simulation_provider
-                        .clone()
-                        .set_cached_gas_estimation(
-                            &bridging_tx_chain_id,
-                            bridge_tx.tx_target,
-                            None,
-                            estimated_gas_used,
-                        )
-                        .await
-                        .unwrap_or_else(|e| {
-                            error!(
-                                "Failed to save the bridging gas estimation to the cache: {}",
-                                e
-                            )
-                        });
-                });
-            }
-            estimated_gas_used
+        .simulate_bundled_transactions(routes.clone(), HashMap::new(), state.metrics.clone())
+        .await?;
+    for (index, simulation_result) in simulation_results.simulation_results.iter().enumerate() {
+        // Making sure the nonce matches the transaction nonce
+        if U64::from(simulation_result.transaction.nonce) != routes[index].nonce {
+            return Err(RpcError::SimulationFailed(
+                "The nonce for the simulation result does not match the nonce for the transaction"
+                    .into(),
+            ));
         }
-    };
 
-    // Updating the gas limit for the bridging transaction
-    bridging_transaction.gas_limit =
-        U64::from((bridging_gas_limit * (100 + ESTIMATED_GAS_SLIPPAGE as u64)) / 100);
-    routes.push(bridging_transaction);
+        routes[index].gas_limit = U64::from(
+            (simulation_result.transaction.gas_used * (100 + ESTIMATED_GAS_SLIPPAGE as u64)) / 100,
+        );
+    }
 
     // Save the bridging transaction to the IRN
     let orchestration_id = Uuid::new_v4().to_string();
diff --git a/src/providers/mod.rs b/src/providers/mod.rs
@@ -47,6 +47,7 @@ use {
     },
     tracing::{debug, error, log::warn},
     wc::metrics::TaskMetrics,
+    yttrium::chain_abstraction::api::Transaction,
 };
 
 mod arbitrum;
@@ -1028,6 +1029,13 @@ pub trait SimulationProvider: Send + Sync {
         metrics: Arc<Metrics>,
     ) -> Result<tenderly::SimulationResponse, RpcError>;
 
+    async fn simulate_bundled_transactions(
+        &self,
+        transactions: Vec<Transaction>,
+        state_overrides: HashMap<Address, HashMap<B256, B256>>,
+        metrics: Arc<Metrics>,
+    ) -> Result<tenderly::BundledSimulationResponse, RpcError>;
+
     /// Get the cached gas estimation
     /// for the token contract and chain_id
     async fn get_cached_gas_estimation(
diff --git a/src/providers/tenderly.rs b/src/providers/tenderly.rs
@@ -13,6 +13,7 @@ use {
     serde::{Deserialize, Serialize},
     std::{collections::HashMap, sync::Arc, time::SystemTime},
     tracing::error,
+    yttrium::chain_abstraction::api::Transaction,
 };
 
 /// Gas estimation caching TTL paramters
@@ -26,7 +27,12 @@ pub struct SimulationRequest {
     pub input: Bytes,
     pub estimate_gas: bool,
     pub state_objects: HashMap<Address, StateStorage>,
-    pub save: bool,
+    pub save: bool, // Save the simulation to the dashboard
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct BundledSimulationRequests {
+    pub simulations: Vec<SimulationRequest>,
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
@@ -39,10 +45,18 @@ pub struct SimulationResponse {
     pub transaction: ResponseTransaction,
 }
 
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct BundledSimulationResponse {
+    pub simulation_results: Vec<SimulationResponse>,
+}
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct ResponseTransaction {
+    pub hash: String,
     pub gas_used: u64,
     pub transaction_info: ResponseTransactionInfo,
+    pub status: bool, // Was simulating transaction successful
+    pub nonce: u64,
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
@@ -55,7 +69,7 @@ pub struct AssetChange {
     #[serde(rename = "type")]
     pub asset_type: AssetChangeType,
     pub from: Address,
-    pub to: Address,
+    pub to: Option<Address>,
     pub raw_amount: U256,
     pub token_info: TokenInfo,
 }
@@ -228,10 +242,91 @@ impl SimulationProvider for TenderlyProvider {
                 "Failed to get the transaction simulation response from Tenderly with status: {}",
                 response.status()
             );
-            return Err(RpcError::ConversionProviderError);
+            return Err(RpcError::SimulationProviderUnavailable);
         }
         let response = response.json::<SimulationResponse>().await?;
 
+        // The transaction failed if the `status` field is false
+        if !response.transaction.status {
+            return Err(RpcError::SimulationFailed(format!(
+                "Failed to simulate the transaction with Tenderly. Transaction hash: {}",
+                response.transaction.hash
+            )));
+        }
+
+        Ok(response)
+    }
+
+    #[tracing::instrument(skip(self), fields(provider = "Tenderly"), level = "debug")]
+    async fn simulate_bundled_transactions(
+        &self,
+        transactions: Vec<Transaction>,
+        state_overrides: HashMap<Address, HashMap<B256, B256>>,
+        metrics: Arc<Metrics>,
+    ) -> Result<BundledSimulationResponse, RpcError> {
+        let url = Url::parse(format!("{}/simulate-bundle", &self.base_api_url).as_str())
+            .map_err(|_| RpcError::ConversionParseURLError)?;
+
+        let mut bundled_simulations = BundledSimulationRequests {
+            simulations: vec![],
+        };
+
+        for transaction in transactions {
+            let (_, evm_chain_id) = disassemble_caip2(&transaction.chain_id)?;
+
+            // fill the state_objects with the state_overrides
+            let mut state_objects: HashMap<Address, StateStorage> = HashMap::new();
+            for (address, state) in state_overrides.clone() {
+                let mut account_state = StateStorage {
+                    storage: HashMap::new(),
+                };
+                for (key, value) in state {
+                    account_state.storage.insert(key, value);
+                }
+                state_objects.insert(address, account_state);
+            }
+
+            bundled_simulations.simulations.push(SimulationRequest {
+                network_id: evm_chain_id,
+                from: transaction.from,
+                to: transaction.to,
+                input: transaction.input,
+                estimate_gas: true,
+                state_objects,
+                save: true,
+            });
+        }
+
+        let latency_start = SystemTime::now();
+        let response = self.send_post_request(url, &bundled_simulations).await?;
+
+        metrics.add_latency_and_status_code_for_provider(
+            self.provider_kind,
+            response.status().into(),
+            latency_start,
+            None,
+            Some("simulate_bundled".to_string()),
+        );
+
+        if !response.status().is_success() {
+            error!(
+                "Failed to get the transactions bundled simulation response from Tenderly with status: {}",
+                response.status()
+            );
+            return Err(RpcError::SimulationProviderUnavailable);
+        }
+        let response = response.json::<BundledSimulationResponse>().await?;
+
+        // Check for the status of each transaction
+        for simulation in response.simulation_results.iter() {
+            if !simulation.transaction.status {
+                return Err(RpcError::SimulationFailed(format!(
+                    "Failed to simulate bundled transactions with Tenderly. Failed transaction hash: {}",
+                    simulation.transaction.hash
+                )));
+            }
+        }
+
         Ok(response)
     }
 

Original file line number	Diff line number	Diff line change
`@@ -287,12 +287,13 @@ pub async fn get_assets_changes_from_simulation(`
`287`	`287`	`{`
`288`	`288`	`if asset_changed.asset_type.clone() == AssetChangeType::Transfer`
`289`	`289`	`&& asset_changed.token_info.standard.clone() == TokenStandard::Erc20`
	`290`	`+ && asset_changed.to.is_some()`
`290`	`291`	`{`
`291`	`292`	`asset_changes.push(Erc20AssetChange {`
`292`	`293`	`chain_id: transaction.chain_id.clone(),`
`293`	`294`	`asset_contract: asset_changed.token_info.contract_address,`
`294`	`295`	`amount: asset_changed.raw_amount,`
`295`		`- receiver: asset_changed.to,`
	`296`	`+ receiver: asset_changed.to.unwrap_or_default(),`
`296`	`297`	`})`
`297`	`298`	`}`
`298`	`299`	`}`