feat(cast): make unsigned raw txs

Author: yash-atreya

crates/cast/bin/cmd/mktx.rs

@@ -3,7 +3,7 @@ use alloy_network::{eip2718::Encodable2718, EthereumWallet, TransactionBuilder};
 use alloy_primitives::hex;
 use alloy_signer::Signer;
 use clap::Parser;
-use eyre::Result;
+use eyre::{OptionExt, Result};
 use foundry_cli::{
     opts::{EthereumOpts, TransactionOpts},
     utils::{get_provider, LoadConfig},
@@ -44,6 +44,12 @@ pub struct MakeTxArgs {
 
     #[command(flatten)]
     eth: EthereumOpts,
+
+    /// Generate a raw RLP-encoded unsigned transaction.
+    ///
+    /// Relaxes the wallet requirement.
+    #[arg(long, requires = "from")]
+    raw_unsigned: bool,
 }
 
 #[derive(Debug, Parser)]
@@ -64,7 +70,7 @@ pub enum MakeTxSubcommands {
 
 impl MakeTxArgs {
     pub async fn run(self) -> Result<()> {
-        let Self { to, mut sig, mut args, command, tx, path, eth } = self;
+        let Self { to, mut sig, mut args, command, tx, path, eth, raw_unsigned } = self;
 
         let blob_data = if let Some(path) = path { Some(std::fs::read(path)?) } else { None };
 
@@ -83,23 +89,32 @@ impl MakeTxArgs {
 
         let config = eth.load_config()?;
 
-        // Retrieve the signer, and bail if it can't be constructed.
-        let signer = eth.wallet.signer().await?;
-        let from = signer.address();
-
-        tx::validate_from_address(eth.wallet.from, from)?;
-
         let provider = get_provider(&config)?;
 
-        let (tx, _) = CastTxBuilder::new(provider, tx, &config)
+        let tx_builder = CastTxBuilder::new(provider, tx, &config)
             .await?
             .with_to(to)
             .await?
             .with_code_sig_and_args(code, sig, args)
             .await?
-            .with_blob_data(blob_data)?
-            .build(&signer)
-            .await?;
+            .with_blob_data(blob_data)?;
+
+        if raw_unsigned {
+            // Build unsigned raw tx
+            let from = eth.wallet.from.ok_or_eyre("missing `--from` address")?;
+            let raw_tx = tx_builder.build_unsigned_raw(from).await?;
+
+            sh_println!("{raw_tx}")?;
+            return Ok(());
+        }
+
+        // Retrieve the signer, and bail if it can't be constructed.
+        let signer = eth.wallet.signer().await?;
+        let from = signer.address();
+
+        tx::validate_from_address(eth.wallet.from, from)?;
+
+        let (tx, _) = tx_builder.build(&signer).await?;
 
         let tx = tx.build(&EthereumWallet::new(signer)).await?;
 

crates/cast/bin/tx.rs

@@ -1,8 +1,9 @@
-use alloy_consensus::{SidecarBuilder, SimpleCoder};
+use alloy_consensus::{SidecarBuilder, SignableTransaction, SimpleCoder};
 use alloy_dyn_abi::ErrorExt;
 use alloy_json_abi::Function;
 use alloy_network::{
-    AnyNetwork, TransactionBuilder, TransactionBuilder4844, TransactionBuilder7702,
+    AnyNetwork, AnyTypedTransaction, TransactionBuilder, TransactionBuilder4844,
+    TransactionBuilder7702,
 };
 use alloy_primitives::{hex, Address, Bytes, TxKind, U256};
 use alloy_provider::Provider;
@@ -277,7 +278,7 @@ impl<P: Provider<AnyNetwork>> CastTxBuilder<P, InputState> {
         self,
         sender: impl Into<SenderKind<'_>>,
     ) -> Result<(WithOtherFields<TransactionRequest>, Option<Function>)> {
-        self._build(sender, true).await
+        self._build(sender, true, false).await
     }
 
     /// Builds [TransactionRequest] without filling missing fields. Used for read-only calls such as
@@ -286,13 +287,26 @@ impl<P: Provider<AnyNetwork>> CastTxBuilder<P, InputState> {
         self,
         sender: impl Into<SenderKind<'_>>,
     ) -> Result<(WithOtherFields<TransactionRequest>, Option<Function>)> {
-        self._build(sender, false).await
+        self._build(sender, false, false).await
+    }
+
+    /// Builds an unsigned RLP-encoded raw transaction.
+    ///
+    /// Returns the hex encoded string representation of the transaction.
+    pub async fn build_unsigned_raw(self, from: Address) -> Result<String> {
+        let (tx, _) = self._build(SenderKind::Address(from), true, true).await?;
+        let tx = tx.build_unsigned()?;
+        match tx {
+            AnyTypedTransaction::Ethereum(t) => Ok(hex::encode_prefixed(t.encoded_for_signing())),
+            _ => eyre::bail!("Cannot generate unsigned transaction for non-Ethereum transactions"),
+        }
     }
 
     async fn _build(
         mut self,
         sender: impl Into<SenderKind<'_>>,
         fill: bool,
+        unsigned: bool,
     ) -> Result<(WithOtherFields<TransactionRequest>, Option<Function>)> {
         let sender = sender.into();
         let from = sender.address();
@@ -316,7 +330,17 @@ impl<P: Provider<AnyNetwork>> CastTxBuilder<P, InputState> {
             nonce
         };
 
-        self.resolve_auth(sender, tx_nonce).await?;
+        if !unsigned {
+            self.resolve_auth(sender, tx_nonce).await?;
+        } else if self.auth.is_some() {
+            let Some(CliAuthorizationList::Signed(signed_auth)) = self.auth.take() else {
+                eyre::bail!(
+                    "SignedAuthorization needs to be provided for generating unsigned 7702 txs"
+                )
+            };
+
+            self.tx.set_authorization_list(vec![signed_auth]);
+        }
 
         if let Some(access_list) = match self.access_list.take() {
             None => None,

crates/cast/tests/cli/main.rs

@@ -1110,6 +1110,32 @@ casttest!(mktx_signer_from_match, |_prj, cmd| {
 "#]]);
 });
 
+casttest!(mktx_raw_unsigned, |_prj, cmd| {
+    cmd.args([
+        "mktx",
+        "--from",
+        "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf",
+        "--chain",
+        "1",
+        "--nonce",
+        "0",
+        "--gas-limit",
+        "21000",
+        "--gas-price",
+        "10000000000",
+        "--priority-gas-price",
+        "1000000000",
+        "0x0000000000000000000000000000000000000001",
+        "--raw-unsigned",
+    ])
+    .assert_success()
+    .stdout_eq(str![[
+        r#"0x02e80180843b9aca008502540be4008252089400000000000000000000000000000000000000018080c0
+
+"#
+    ]]);
+});
+
 // tests that the raw encoded transaction is returned
 casttest!(tx_raw, |_prj, cmd| {
     let rpc = next_http_rpc_endpoint();