cast/cmd/

send.rs

use std::{path::PathBuf, str::FromStr, time::Duration};

use alloy_eips::Encodable2718;
use alloy_ens::NameOrAddress;
use alloy_network::{AnyNetwork, EthereumWallet, TransactionBuilder};
use alloy_provider::{Provider, ProviderBuilder};
use alloy_rpc_types::TransactionRequest;
use alloy_serde::WithOtherFields;
use alloy_signer::Signer;
use clap::Parser;
use eyre::{Result, eyre};
use foundry_cli::{
    opts::TransactionOpts,
    utils::{LoadConfig, get_provider_with_curl},
};
use foundry_wallets::WalletSigner;

use crate::tx::{self, CastTxBuilder, CastTxSender, SendTxOpts};

/// CLI arguments for `cast send`.
#[derive(Debug, Parser)]
pub struct SendTxArgs {
    /// The destination of the transaction.
    ///
    /// If not provided, you must use cast send --create.
    #[arg(value_parser = NameOrAddress::from_str)]
    to: Option<NameOrAddress>,

    /// The signature of the function to call.
    sig: Option<String>,

    /// The arguments of the function to call.
    #[arg(allow_negative_numbers = true)]
    args: Vec<String>,

    /// Raw hex-encoded data for the transaction. Used instead of \[SIG\] and \[ARGS\].
    #[arg(
        long,
        conflicts_with_all = &["sig", "args"]
    )]
    data: Option<String>,

    #[command(flatten)]
    send_tx: SendTxOpts,

    #[command(subcommand)]
    command: Option<SendTxSubcommands>,

    /// Send via `eth_sendTransaction` using the `--from` argument or $ETH_FROM as sender
    #[arg(long, requires = "from")]
    unlocked: bool,

    #[command(flatten)]
    tx: TransactionOpts,

    /// The path of blob data to be sent.
    #[arg(
        long,
        value_name = "BLOB_DATA_PATH",
        conflicts_with = "legacy",
        requires = "blob",
        help_heading = "Transaction options"
    )]
    path: Option<PathBuf>,
}

#[derive(Debug, Parser)]
pub enum SendTxSubcommands {
    /// Use to deploy raw contract bytecode.
    #[command(name = "--create")]
    Create {
        /// The bytecode of the contract to deploy.
        code: String,

        /// The signature of the function to call.
        sig: Option<String>,

        /// The arguments of the function to call.
        #[arg(allow_negative_numbers = true)]
        args: Vec<String>,
    },
}

impl SendTxArgs {
    pub async fn run(self) -> eyre::Result<()> {
        let Self { to, mut sig, mut args, data, send_tx, tx, command, unlocked, path } = self;

        let blob_data = if let Some(path) = path { Some(std::fs::read(path)?) } else { None };

        if let Some(data) = data {
            sig = Some(data);
        }

        let code = if let Some(SendTxSubcommands::Create {
            code,
            sig: constructor_sig,
            args: constructor_args,
        }) = command
        {
            // ensure we don't violate settings for transactions that can't be CREATE: 7702 and 4844
            // which require mandatory target
            if to.is_none() && !tx.auth.is_empty() {
                return Err(eyre!(
                    "EIP-7702 transactions can't be CREATE transactions and require a destination address"
                ));
            }
            // ensure we don't violate settings for transactions that can't be CREATE: 7702 and 4844
            // which require mandatory target
            if to.is_none() && blob_data.is_some() {
                return Err(eyre!(
                    "EIP-4844 transactions can't be CREATE transactions and require a destination address"
                ));
            }

            sig = constructor_sig;
            args = constructor_args;
            Some(code)
        } else {
            None
        };

        let config = send_tx.eth.load_config()?;
        let provider = get_provider_with_curl(&config, send_tx.eth.rpc.curl)?;

        if let Some(interval) = send_tx.poll_interval {
            provider.client().set_poll_interval(Duration::from_secs(interval))
        }

        let 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)?;

        let timeout = send_tx.timeout.unwrap_or(config.transaction_timeout);

        // Check if this is a Tempo transaction - requires special handling for local signing
        let is_tempo = builder.is_tempo();

        // Tempo transactions with browser wallets are not supported
        if is_tempo && send_tx.eth.wallet.browser {
            return Err(eyre!("Tempo transactions are not supported with browser wallets."));
        }

        // Case 1:
        // Default to sending via eth_sendTransaction if the --unlocked flag is passed.
        // This should be the only way this RPC method is used as it requires a local node
        // or remote RPC with unlocked accounts.
        if unlocked && !send_tx.eth.wallet.browser {
            // only check current chain id if it was specified in the config
            if let Some(config_chain) = config.chain {
                let current_chain_id = provider.get_chain_id().await?;
                let config_chain_id = config_chain.id();
                // switch chain if current chain id is not the same as the one specified in the
                // config
                if config_chain_id != current_chain_id {
                    sh_warn!("Switching to chain {}", config_chain)?;
                    provider
                        .raw_request::<_, ()>(
                            "wallet_switchEthereumChain".into(),
                            [serde_json::json!({
                                "chainId": format!("0x{:x}", config_chain_id),
                            })],
                        )
                        .await?;
                }
            }

            let (tx, _) = builder.build(config.sender).await?;

            cast_send(
                provider,
                tx.into_inner().into(),
                send_tx.cast_async,
                send_tx.sync,
                send_tx.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
        // enough information to sign and we must bail.
        } else {
            // Retrieve the signer, and bail if it can't be constructed.
            let signer = send_tx.eth.wallet.signer().await?;
            let from = signer.address();

            tx::validate_from_address(send_tx.eth.wallet.from, from)?;

            // Browser wallets work differently as they sign and send the transaction in one step.
            if send_tx.eth.wallet.browser
                && let WalletSigner::Browser(ref browser_signer) = signer
            {
                let (tx_request, _) = builder.build(from).await?;
                let tx_hash =
                    browser_signer.send_transaction_via_browser(tx_request.into_inner()).await?;

                if send_tx.cast_async {
                    sh_println!("{tx_hash:#x}")?;
                } else {
                    let receipt = CastTxSender::new(&provider)
                        .receipt(
                            format!("{tx_hash:#x}"),
                            None,
                            send_tx.confirmations,
                            Some(timeout),
                            false,
                        )
                        .await?;
                    sh_println!("{receipt}")?;
                }

                return Ok(());
            }

            // Tempo transactions need to be signed locally and sent as raw transactions
            // because EthereumWallet doesn't understand type 0x76
            // TODO(onbjerg): All of this is a side effect of a few things, most notably that we do
            // not use `FoundryNetwork` and `FoundryTransactionRequest` everywhere, which is
            // downstream of the fact that we use `EthereumWallet` everywhere.
            if is_tempo {
                let (ftx, _) = builder.build(&signer).await?;

                let signed_tx = ftx.build(&EthereumWallet::new(signer)).await?;

                // Encode and send raw
                let mut raw_tx = Vec::with_capacity(signed_tx.encode_2718_len());
                signed_tx.encode_2718(&mut raw_tx);

                let cast = CastTxSender::new(&provider);
                let pending_tx = cast.send_raw(&raw_tx).await?;
                let tx_hash = pending_tx.inner().tx_hash();

                if send_tx.cast_async {
                    sh_println!("{tx_hash:#x}")?;
                } else if send_tx.sync {
                    // For sync mode, we already have the hash, just wait for receipt
                    let receipt = cast
                        .receipt(
                            format!("{tx_hash:#x}"),
                            None,
                            send_tx.confirmations,
                            Some(timeout),
                            false,
                        )
                        .await?;
                    sh_println!("{receipt}")?;
                } else {
                    let receipt = cast
                        .receipt(
                            format!("{tx_hash:#x}"),
                            None,
                            send_tx.confirmations,
                            Some(timeout),
                            false,
                        )
                        .await?;
                    sh_println!("{receipt}")?;
                }

                return Ok(());
            }

            let (tx_request, _) = builder.build(&signer).await?;

            let wallet = EthereumWallet::from(signer);
            let provider = ProviderBuilder::<_, _, AnyNetwork>::default()
                .wallet(wallet)
                .connect_provider(&provider);

            cast_send(
                provider,
                tx_request.into_inner().into(),
                send_tx.cast_async,
                send_tx.sync,
                send_tx.confirmations,
                timeout,
            )
            .await
        }
    }
}

pub(crate) async fn cast_send<P: Provider<AnyNetwork>>(
    provider: P,
    tx: WithOtherFields<TransactionRequest>,
    cast_async: bool,
    sync: bool,
    confs: u64,
    timeout: u64,
) -> Result<()> {
    let cast = CastTxSender::new(&provider);

    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(())
}