feat: support for eth_sendrawtransactionSync in cast send (#12546)

* feat: support for eth_sendrawtransactionSync in cast send

* conflict

* fmt

* alloy send_transaction_sync

* doc

* refactor/reuse async fn receipt and test

Author: stevencartavia

crates/cast/src/cmd/send.rs

@@ -40,6 +40,11 @@ pub struct SendTxArgs {
     #[arg(id = "async", long = "async", alias = "cast-async", env = "CAST_ASYNC")]
     cast_async: bool,
 
+    /// Wait for transaction receipt synchronously instead of polling.
+    /// Note: uses `eth_sendTransactionSync` which may not be supported by all clients.
+    #[arg(long, conflicts_with = "async")]
+    sync: bool,
+
     /// The number of confirmations until the receipt is fetched.
     #[arg(long, default_value = "1")]
     confirmations: u64,
@@ -100,6 +105,7 @@ impl SendTxArgs {
             to,
             mut sig,
             cast_async,
+            sync,
             mut args,
             tx,
             confirmations,
@@ -183,7 +189,7 @@ impl SendTxArgs {
 
             let (tx, _) = builder.build(config.sender).await?;
 
-            cast_send(provider, tx, cast_async, confirmations, timeout).await
+            cast_send(provider, tx, cast_async, sync, confirmations, timeout).await
         // Case 2:
         // An option to use a local signer was provided.
         // If we cannot successfully instantiate a local signer, then we will assume we don't have
@@ -221,7 +227,7 @@ impl SendTxArgs {
                 .wallet(wallet)
                 .connect_provider(&provider);
 
-            cast_send(provider, tx_request, cast_async, confirmations, timeout).await
+            cast_send(provider, tx_request, cast_async, sync, confirmations, timeout).await
         }
     }
 }
@@ -230,19 +236,27 @@ async fn cast_send<P: Provider<AnyNetwork>>(
     provider: P,
     tx: WithOtherFields<TransactionRequest>,
     cast_async: bool,
+    sync: bool,
     confs: u64,
     timeout: u64,
 ) -> Result<()> {
-    let cast = Cast::new(provider);
-    let pending_tx = cast.send(tx).await?;
-    let tx_hash = pending_tx.inner().tx_hash();
+    let cast = Cast::new(&provider);
 
-    if cast_async {
-        sh_println!("{tx_hash:#x}")?;
-    } else {
-        let receipt =
-            cast.receipt(format!("{tx_hash:#x}"), None, confs, Some(timeout), false).await?;
+    if sync {
+        // Send transaction and wait for receipt synchronously
+        let receipt = cast.send_sync(tx).await?;
         sh_println!("{receipt}")?;
+    } else {
+        let pending_tx = cast.send(tx).await?;
+        let tx_hash = pending_tx.inner().tx_hash();
+
+        if cast_async {
+            sh_println!("{tx_hash:#x}")?;
+        } else {
+            let receipt =
+                cast.receipt(format!("{tx_hash:#x}"), None, confs, Some(timeout), false).await?;
+            sh_println!("{receipt}")?;
+        }
     }
 
     Ok(())

crates/cast/src/lib.rs

@@ -330,6 +330,34 @@ impl<P: Provider<AnyNetwork>> Cast<P> {
         Ok(res)
     }
 
+    /// Sends a transaction and waits for receipt synchronously
+    pub async fn send_sync(&self, tx: WithOtherFields<TransactionRequest>) -> Result<String> {
+        let mut receipt: TransactionReceiptWithRevertReason =
+            self.provider.send_transaction_sync(tx).await?.into();
+
+        // Allow to fail silently
+        let _ = receipt.update_revert_reason(&self.provider).await;
+
+        self.format_receipt(receipt, None)
+    }
+
+    /// Helper method to format transaction receipts consistently
+    fn format_receipt(
+        &self,
+        receipt: TransactionReceiptWithRevertReason,
+        field: Option<String>,
+    ) -> Result<String> {
+        Ok(if let Some(ref field) = field {
+            get_pretty_tx_receipt_attr(&receipt, field)
+                .ok_or_else(|| eyre::eyre!("invalid receipt field: {}", field))?
+        } else if shell::is_json() {
+            // to_value first to sort json object keys
+            serde_json::to_value(&receipt)?.to_string()
+        } else {
+            receipt.pretty()
+        })
+    }
+
     /// # Example
     ///
     /// ```
@@ -863,15 +891,7 @@ impl<P: Provider<AnyNetwork>> Cast<P> {
         // Allow to fail silently
         let _ = receipt.update_revert_reason(&self.provider).await;
 
-        Ok(if let Some(ref field) = field {
-            get_pretty_tx_receipt_attr(&receipt, field)
-                .ok_or_else(|| eyre::eyre!("invalid receipt field: {}", field))?
-        } else if shell::is_json() {
-            // to_value first to sort json object keys
-            serde_json::to_value(&receipt)?.to_string()
-        } else {
-            receipt.pretty()
-        })
+        self.format_receipt(receipt, field)
     }
 
     /// Perform a raw JSON-RPC request

crates/cast/tests/cli/main.rs

@@ -2497,6 +2497,31 @@ casttest!(send_eip7702, async |_prj, cmd| {
 "#]]);
 });
 
+casttest!(send_sync, async |_prj, cmd| {
+    let (_api, handle) = anvil::spawn(NodeConfig::test()).await;
+    let endpoint = handle.http_endpoint();
+
+    let output = cmd
+        .args([
+            "send",
+            "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+            "--value",
+            "1",
+            "--private-key",
+            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+            "--rpc-url",
+            &endpoint,
+            "--sync",
+        ])
+        .assert_success()
+        .get_output()
+        .stdout_lossy();
+
+    assert!(output.contains("transactionHash"));
+    assert!(output.contains("blockNumber"));
+    assert!(output.contains("gasUsed"));
+});
+
 casttest!(hash_message, |_prj, cmd| {
     cmd.args(["hash-message", "hello"]).assert_success().stdout_eq(str![[r#"
 0x50b2c43fd39106bafbba0da34fc430e1f91e3c96ea2acee2bc34119f92b37750