submit tx with retry

Author: jayantk

apps/fortuna/src/eth_utils/nonce_manager.rs

@@ -2,8 +2,11 @@
 // Copied from: https://github.com/gakonst/ethers-rs/blob/34ed9e372e66235aed7074bc3f5c14922b139242/ethers-middleware/src/nonce_manager.rs
 
 use {
+    super::legacy_tx_middleware::LegacyTxMiddleware,
     axum::async_trait,
+    ethers::prelude::GasOracle,
     ethers::{
+        middleware::gas_oracle::GasOracleMiddleware,
         providers::{Middleware, MiddlewareError, PendingTransaction},
         types::{transaction::eip2718::TypedTransaction, *},
     },
@@ -72,15 +75,6 @@ where
         Ok(nonce)
     } // guard dropped here
 
-    /// Resets the initialized flag so the next usage of the manager will reinitialize the nonce
-    /// based on the chain state.
-    /// This is useful when the RPC does not return an error if the transaction is submitted with
-    /// an incorrect nonce.
-    /// This is the only new method compared to the original NonceManagerMiddleware.
-    pub fn reset(&self) {
-        self.initialized.store(false, Ordering::SeqCst);
-    }
-
     async fn get_transaction_count_with_manager(
         &self,
         block: Option<BlockId>,
@@ -100,6 +94,33 @@ where
     }
 }
 
+pub trait NonceManaged {
+    fn reset(&self);
+}
+
+impl<M: Middleware> NonceManaged for NonceManagerMiddleware<M> {
+    /// Resets the initialized flag so the next usage of the manager will reinitialize the nonce
+    /// based on the chain state.
+    /// This is useful when the RPC does not return an error if the transaction is submitted with
+    /// an incorrect nonce.
+    /// This is the only new method compared to the original NonceManagerMiddleware.
+    fn reset(&self) {
+        self.initialized.store(false, Ordering::SeqCst);
+    }
+}
+
+impl<M: NonceManaged + Middleware, G: GasOracle> NonceManaged for GasOracleMiddleware<M, G> {
+    fn reset(&self) {
+        self.inner().reset();
+    }
+}
+
+impl<T: NonceManaged + Middleware> NonceManaged for LegacyTxMiddleware<T> {
+    fn reset(&self) {
+        self.inner().reset();
+    }
+}
+
 #[derive(Error, Debug)]
 /// Thrown when an error happens at the Nonce Manager
 pub enum NonceManagerError<M: Middleware> {

apps/fortuna/src/eth_utils/utils.rs

@@ -1,14 +1,15 @@
 use {
+    crate::config::EscalationPolicyConfig,
+    crate::eth_utils::nonce_manager::NonceManaged,
     anyhow::{anyhow, Result},
-    ethers::{contract::ContractCall, middleware::Middleware},
-    ethers::types::U256,
+    backoff::ExponentialBackoff,
     ethers::types::TransactionReceipt,
+    ethers::types::U256,
+    ethers::{contract::ContractCall, middleware::Middleware},
+    std::sync::atomic::AtomicU64,
     std::sync::Arc,
-    tracing,
-    std::sync::atomic::AtomicU64, 
-    crate::config::EscalationPolicyConfig,
     tokio::time::{timeout, Duration},
-    backoff::ExponentialBackoff,
+    tracing,
 };
 
 const TX_CONFIRMATION_TIMEOUT_SECS: u64 = 30;
@@ -81,7 +82,7 @@ pub async fn estimate_tx_cost<T: Middleware + 'static>(
     Ok(gas_price * gas_used)
 }
 
-pub async fn submit_tx_with_backoff<T: Middleware + 'static>(
+pub async fn submit_tx_with_backoff<T: Middleware + NonceManaged + 'static>(
     middleware: Arc<T>,
     call: ContractCall<T, ()>,
     gas_limit: U256,
@@ -110,7 +111,8 @@ pub async fn submit_tx_with_backoff<T: Middleware + 'static>(
                 gas_limit,
                 gas_multiplier_pct,
                 fee_multiplier_pct,
-            ).await
+            )
+            .await
         },
         |e, dur| {
             let retry_number = num_retries.load(std::sync::atomic::Ordering::Relaxed);
@@ -125,11 +127,11 @@ pub async fn submit_tx_with_backoff<T: Middleware + 'static>(
     )
     .await;
 
-    let duration = start_time.elapsed();    
+    let duration = start_time.elapsed();
     let num_retries = num_retries.load(std::sync::atomic::Ordering::Relaxed);
 
     Ok(SubmitTxResult {
-        num_retries: num_retries,
+        num_retries,
         gas_multiplier: escalation_policy.get_gas_multiplier_pct(num_retries),
         fee_multiplier: escalation_policy.get_fee_multiplier_pct(num_retries),
         duration,
@@ -141,16 +143,15 @@ pub async fn submit_tx_with_backoff<T: Middleware + 'static>(
 /// submits the transaction if the gas estimate is below the gas limit.
 /// It will return a permanent or transient error depending on the error type and whether
 /// retry is possible or not.
-pub async fn submit_tx<T: Middleware + 'static>(
+pub async fn submit_tx<T: Middleware + NonceManaged + 'static>(
     client: Arc<T>,
     call: &ContractCall<T, ()>,
     gas_limit: U256,
     // A value of 100 submits the tx with the same gas/fee as the estimate.
     gas_estimate_multiplier_pct: u64,
     fee_estimate_multiplier_pct: u64,
 ) -> Result<TransactionReceipt, backoff::Error<anyhow::Error>> {
-    
-    let gas_estimate_res = call.estimate_gas().await;        
+    let gas_estimate_res = call.estimate_gas().await;
 
     let gas_estimate = gas_estimate_res.map_err(|e| {
         // we consider the error transient even if it is a contract revert since
@@ -173,7 +174,7 @@ pub async fn submit_tx<T: Middleware + 'static>(
     // the padded gas estimate doesn't exceed the maximum amount of gas we are willing to use.
     let gas_estimate = gas_estimate.saturating_mul(gas_estimate_multiplier_pct.into()) / 100;
 
-    let call = call.gas(gas_estimate);
+    let call = call.clone().gas(gas_estimate);
 
     let mut transaction = call.tx.clone();
 
@@ -207,8 +208,7 @@ pub async fn submit_tx<T: Middleware + 'static>(
         })?;
 
     let reset_nonce = || {
-        let nonce_manager = client.inner().inner();
-        nonce_manager.reset();
+        client.reset();
     };
 
     let pending_receipt = timeout(

apps/fortuna/src/keeper/process_event.rs

@@ -42,21 +42,21 @@ pub async fn process_event_with_backoff(
         .reveal(event.sequence_number)
         .map_err(|e| anyhow!("Error revealing: {:?}", e))?;
 
-    let contract_call = contract
-        .reveal_with_callback(
-            event.provider_address,
-            event.sequence_number,
-            event.user_random_number,
-            provider_revelation,
-        );
+    let contract_call = contract.reveal_with_callback(
+        event.provider_address,
+        event.sequence_number,
+        event.user_random_number,
+        provider_revelation,
+    );
 
     let success = submit_tx_with_backoff(
         contract.client(),
         contract_call,
         gas_limit,
         escalation_policy,
-    ).await;
-    
+    )
+    .await;
+
     metrics
         .requests_processed
         .get_or_create(&account_label)
@@ -96,12 +96,12 @@ pub async fn process_event_with_backoff(
                 if let Some(gas_used) = receipt.gas_used {
                     let gas_used_float = gas_used.as_u128() as f64 / 1e18;
                     metrics
-                       .total_gas_spent
+                        .total_gas_spent
                         .get_or_create(&account_label)
                         .inc_by(gas_used_float);
-            
+
                     if let Some(gas_price) = receipt.effective_gas_price {
-                       let gas_fee = (gas_used * gas_price).as_u128() as f64 / 1e18;
+                        let gas_fee = (gas_used * gas_price).as_u128() as f64 / 1e18;
                         metrics
                             .total_gas_fee_spent
                             .get_or_create(&account_label)