fix: handle empty receipt when transactions are discarded by RPCs (#10457)

* Update progress.rs

* Update receipts.rs

* Update receipts.rs

* Update progress.rs

* Update receipts.rs

* Update progress.rs

* Update receipts.rs

* Update progress.rs

* Update Cargo.toml

* Update progress.rs

* Update coverage.rs

* Update vanity.rs

* Update progress.rs

* Update receipts.rs

Author: DeVikingMark

crates/cast/src/cmd/wallet/vanity.rs

@@ -149,8 +149,8 @@ impl VanityArgs {
             "Successfully found vanity address in {:.3} seconds.{}{}\nAddress: {}\nPrivate Key: 0x{}",
             timer.elapsed().as_secs_f64(),
             if nonce.is_some() { "\nContract address: " } else { "" },
-            if let Some(nonce) = nonce {
-                wallet.address().create(nonce).to_checksum(None)
+            if let Some(nonce_val) = nonce {
+                wallet.address().create(nonce_val).to_checksum(None)
             } else {
                 String::new()
             },

crates/forge/src/coverage.rs

@@ -166,8 +166,8 @@ impl CoverageReporter for LcovReporter {
                         }
                     }
                     CoverageItemKind::Branch { branch_id, path_id, .. } => {
-                        let hits = if hits == 0 { "-" } else { &hits.to_string() };
-                        writeln!(out, "BRDA:{line},{branch_id},{path_id},{hits}")?;
+                        let hits_str = if hits == 0 { "-" } else { &hits.to_string() };
+                        writeln!(out, "BRDA:{line},{branch_id},{path_id},{hits_str}")?;
                     }
                 }
             }

crates/script/Cargo.toml

@@ -54,6 +54,7 @@ alloy-dyn-abi.workspace = true
 alloy-primitives.workspace = true
 alloy-eips.workspace = true
 alloy-consensus.workspace = true
+thiserror.workspace = true
 
 [dev-dependencies]
 tempfile.workspace = true

crates/script/src/progress.rs

@@ -1,4 +1,4 @@
-use crate::receipts::{TxStatus, check_tx_status, format_receipt};
+use crate::receipts::{PendingReceiptError, TxStatus, check_tx_status, format_receipt};
 use alloy_chains::Chain;
 use alloy_primitives::{
     B256,
@@ -207,20 +207,37 @@ impl ScriptProgress {
         let mut tasks = futures::stream::iter(futs).buffer_unordered(10);
 
         let mut errors: Vec<String> = vec![];
+        let mut discarded_transactions = false;
 
         while let Some((tx_hash, result)) = tasks.next().await {
             match result {
                 Err(err) => {
-                    errors.push(format!("Failure on receiving a receipt for {tx_hash:?}:\n{err}"));
-
-                    seq_progress.inner.write().finish_tx_spinner(tx_hash);
+                    // Check if this is a retry error for pending receipts
+                    if err.downcast_ref::<PendingReceiptError>().is_some() {
+                        // We've already retried several times with sleep, but the receipt is still
+                        // pending
+                        discarded_transactions = true;
+                        deployment_sequence.remove_pending(tx_hash);
+                        seq_progress
+                            .inner
+                            .write()
+                            .finish_tx_spinner_with_msg(tx_hash, &err.to_string())?;
+                    } else {
+                        errors.push(format!(
+                            "Failure on receiving a receipt for {tx_hash:?}:\n{err}"
+                        ));
+                        seq_progress.inner.write().finish_tx_spinner(tx_hash);
+                    }
                 }
                 Ok(TxStatus::Dropped) => {
                     // We want to remove it from pending so it will be re-broadcast.
                     deployment_sequence.remove_pending(tx_hash);
-                    errors.push(format!("Transaction dropped from the mempool: {tx_hash:?}"));
+                    discarded_transactions = true;
 
-                    seq_progress.inner.write().finish_tx_spinner(tx_hash);
+                    let msg = format!(
+                        "Transaction {tx_hash:?} dropped from the mempool. It will be retried when using --resume."
+                    );
+                    seq_progress.inner.write().finish_tx_spinner_with_msg(tx_hash, &msg)?;
                 }
                 Ok(TxStatus::Success(receipt)) => {
                     trace!(tx_hash=?tx_hash, "received tx receipt");
@@ -249,11 +266,20 @@ impl ScriptProgress {
         // print any errors
         if !errors.is_empty() {
             let mut error_msg = errors.join("\n");
-            if !deployment_sequence.pending.is_empty() {
-                error_msg += "\n\n Add `--resume` to your command to try and continue broadcasting
-        the transactions."
+
+            // Add information about using --resume if necessary
+            if !deployment_sequence.pending.is_empty() || discarded_transactions {
+                error_msg += r#"
+
+Add `--resume` to your command to try and continue broadcasting the transactions. This will attempt to resend transactions that were discarded by the RPC."#;
             }
+
             eyre::bail!(error_msg);
+        } else if discarded_transactions {
+            // If we have discarded transactions but no errors, still inform the user
+            sh_warn!(
+                "Some transactions were discarded by the RPC node. Use `--resume` to retry these transactions."
+            )?;
         }
 
         Ok(())

crates/script/src/receipts.rs

@@ -6,6 +6,15 @@ use eyre::{Result, eyre};
 use foundry_common::{provider::RetryProvider, retry, retry::RetryError, shell};
 use std::time::Duration;
 
+/// Marker error type for pending receipts
+#[derive(Debug, thiserror::Error)]
+#[error(
+    "Received a pending receipt for {tx_hash}, but transaction is still known to the node, retrying"
+)]
+pub struct PendingReceiptError {
+    pub tx_hash: TxHash,
+}
+
 /// Convenience enum for internal signalling of transaction status
 pub enum TxStatus {
     Dropped,
@@ -37,7 +46,30 @@ pub async fn check_tx_status(
                 .get_receipt()
                 .await
             {
-                Ok(receipt) => Ok(receipt.into()),
+                Ok(receipt) => {
+                    // Check if the receipt is pending (missing block information)
+                    let is_pending = receipt.block_number.is_none()
+                        || receipt.block_hash.is_none()
+                        || receipt.transaction_index.is_none();
+
+                    if !is_pending {
+                        return Ok(receipt.into());
+                    }
+
+                    // Receipt is pending, try to sleep and retry a few times
+                    match provider.get_transaction_by_hash(hash).await {
+                        Ok(_) => {
+                            // Sleep for a short time to allow the transaction to be mined
+                            tokio::time::sleep(Duration::from_millis(500)).await;
+                            // Transaction is still known to the node, retry
+                            Err(RetryError::Retry(PendingReceiptError { tx_hash: hash }.into()))
+                        }
+                        Err(_) => {
+                            // Transaction is not known to the node, mark it as dropped
+                            Ok(TxStatus::Dropped)
+                        }
+                    }
+                }
                 Err(e) => match provider.get_transaction_by_hash(hash).await {
                     Ok(_) => match e {
                         PendingTransactionError::TxWatcher(WatchTxError::Timeout) => {