fix: detect reverted withdrawal transactions

finalizer/src/error.rs

@@ -16,6 +16,9 @@ pub enum Error {
 
     #[error("middleware error {0}")]
     Middleware(String),
+
+    #[error("withdrawal transaction was reverted")]
+    WithdrawalTransactionReverted,
 }
 
 impl<M: Middleware> From<ContractError<M>> for Error {

finalizer/src/lib.rs

@@ -223,6 +223,7 @@ where
             tx.tx.clone(),
             self.tx_retry_timeout,
             nonce,
+            self.batch_finalization_gas_limit,
         )
         .await;
 
@@ -232,6 +233,18 @@ where
         let withdrawals = withdrawals.into_iter().map(|w| w.key()).collect::<Vec<_>>();
 
         match tx {
+            Ok(Some(tx)) if tx.status.expect("EIP-658 is enabled; qed").is_zero() => {
+                tracing::error!(
+                    "withdrawal transaction {:?} was reverted",
+                    tx.transaction_hash
+                );
+
+                FINALIZER_METRICS.reverted_withdrawal_transactions.inc();
+
+                storage::inc_unsuccessful_finalization_attempts(&self.pgpool, &withdrawals).await?;
+
+                return Err(Error::WithdrawalTransactionReverted);
+            }
             Ok(Some(tx)) => {
                 tracing::info!(
                     "withdrawal transaction {:?} successfully mined",

finalizer/src/metrics.rs

@@ -17,6 +17,9 @@ pub(super) struct FinalizerMetrics {
 
     /// Number of withdrawals failed to fetch withdrawal parameters for.
     pub failed_to_fetch_withdrawal_params: Counter,
+
+    /// Number of withdrawal transactions that were reverted.
+    pub reverted_withdrawal_transactions: Counter,
 }
 
 #[vise::register]

tx-sender/src/lib.rs

@@ -95,6 +95,7 @@ pub async fn send_tx_adjust_gas<M, T>(
     tx: T,
     retry_timeout: Duration,
     nonce: U256,
+    gas_limit: U256,
 ) -> Result<Option<TransactionReceipt>, <M as Middleware>::Error>
 where
     M: Middleware,
@@ -103,6 +104,7 @@ where
     let mut submit_tx = tx.into();
     m.fill_transaction(&mut submit_tx, None).await?;
     submit_tx.set_nonce(nonce);
+    submit_tx.set_gas(gas_limit);
 
     for retry_num in 0..usize::MAX {
         if retry_num > 0 {
@@ -174,9 +176,15 @@ mod tests {
             .gas_price(gas_price);
 
         tokio::time::timeout(Duration::from_secs(3), async {
-            send_tx_adjust_gas(provider.clone(), tx, Duration::from_secs(1), 0.into())
-                .await
-                .unwrap_err()
+            send_tx_adjust_gas(
+                provider.clone(),
+                tx,
+                Duration::from_secs(1),
+                0.into(),
+                6000000.into(),
+            )
+            .await
+            .unwrap_err()
         })
         .await
         .ok();
@@ -238,8 +246,20 @@ mod tests {
 
         tokio::time::timeout(Duration::from_secs(3), async {
             let (first, second) = tokio::join!(
-                send_tx_adjust_gas(provider.clone(), tx_1, Duration::from_secs(1), 0.into()),
-                send_tx_adjust_gas(provider.clone(), tx_2, Duration::from_secs(1), 1.into())
+                send_tx_adjust_gas(
+                    provider.clone(),
+                    tx_1,
+                    Duration::from_secs(1),
+                    0.into(),
+                    6000000.into()
+                ),
+                send_tx_adjust_gas(
+                    provider.clone(),
+                    tx_2,
+                    Duration::from_secs(1),
+                    1.into(),
+                    6000000.into()
+                )
             );
             first.unwrap();
             second.unwrap();
@@ -377,9 +397,15 @@ mod tests {
             .from(from);
 
         tokio::time::timeout(Duration::from_secs(3), async {
-            send_tx_adjust_gas(provider.clone(), tx, Duration::from_secs(1), 0.into())
-                .await
-                .unwrap()
+            send_tx_adjust_gas(
+                provider.clone(),
+                tx,
+                Duration::from_secs(1),
+                0.into(),
+                6000000.into(),
+            )
+            .await
+            .unwrap()
         })
         .await
         .ok();