Enum TransactionSubcommand 

pub enum TransactionSubcommand {
    Call(CallArgs),
    MakeTx(MakeTxArgs),
    Classify {
        raw_tx: Option<String>,
    },
    Tx {
        tx_hash: Option<String>,
        from: Option<NameOrAddress>,
        nonce: Option<u64>,
        field: Option<String>,
        raw: bool,
        lane: bool,
        rpc: RpcOpts,
        to_request: bool,
        network: Option<NetworkVariant>,
    },
    Receipt {
        tx_hash: String,
        field: Option<String>,
        confirmations: u64,
        cast_async: bool,
        rpc: RpcOpts,
    },
    SendTx(SendTxArgs),
    BatchMakeTx(BatchMakeTxArgs),
    BatchSend(BatchSendArgs),
    PublishTx {
        raw_tx: String,
        cast_async: bool,
        rpc: RpcOpts,
    },
    Estimate(EstimateArgs),
    Run(RunArgs),
}

Call and transaction subcommands.

Variants

Call(CallArgs)

Perform a call on an account without publishing a transaction

Examples:

• cast call $TOKEN “balanceOf(address)(uint256)” vitalik.eth
• cast call $TOKEN “transfer(address,uint256)” vitalik.eth 100 –trace

MakeTx(MakeTxArgs)

Build and sign a transaction

Examples:

• cast mktx vitalik.eth –value 0.1ether –private-key $PK
• cast mktx $TOKEN “transfer(address,uint256)” vitalik.eth 100 –account dev

Classify

Classify a raw transaction as Tempo T5 payment/general lane.

Fields

raw_tx: Option<String>

The raw signed transaction.

Tx

Get information about a transaction

Examples:

• cast tx $TX_HASH
• cast tx $TX_HASH blockNumber (only print the blockNumber field)
• cast tx $TX_HASH –raw

Fields

tx_hash: Option<String>

The transaction hash.

from: Option<NameOrAddress>

The sender of the transaction.

nonce: Option<u64>

Nonce of the transaction.

field: Option<String>

If specified, only get the given field of the transaction. If “raw”, the RLP encoded transaction will be printed.

raw: bool

Print the raw RLP encoded transaction.

lane: bool

Classify the transaction as Tempo T5 payment/general lane.

rpc: RpcOpts

to_request: bool

If specified, the transaction will be converted to a TransactionRequest JSON format.

network: Option<NetworkVariant>

Specify the Network for correct encoding.

Receipt

Get the transaction receipt for a transaction

Examples:

• cast receipt $TX_HASH
• cast receipt $TX_HASH status (only print the status field)

Fields

tx_hash: String

The transaction hash.

field: Option<String>

If specified, only get the given field of the transaction.

confirmations: u64

The number of confirmations until the receipt is fetched

cast_async: bool

Exit immediately if the transaction was not found.

rpc: RpcOpts

SendTx(SendTxArgs)

Sign and publish a transaction

Examples:

• cast send vitalik.eth –value 0.1ether –private-key $PK (transfer ETH)
• cast send $TOKEN “transfer(address,uint256)” vitalik.eth 100 –account dev
• cast send –private-key $PK –create $BYTECODE (deploy a contract)

BatchMakeTx(BatchMakeTxArgs)

Build and sign a batch transaction (Tempo).

BatchSend(BatchSendArgs)

Sign and publish a batch transaction (Tempo).

PublishTx

Publish a raw transaction to the network.

Fields

raw_tx: String

The raw transaction

cast_async: bool

Only print the transaction hash and exit immediately.

rpc: RpcOpts

Estimate(EstimateArgs)

Estimate the gas cost of a transaction

Examples:

• cast estimate vitalik.eth –value 0.1ether
• cast estimate $CONTRACT “deposit()” –value 1ether

Run(RunArgs)

Runs a published transaction in a local environment and prints the trace

If the node serves an EIP-7928 block access list (BAL) for the transaction’s block, the transaction’s prestate is read from it instead of replaying the earlier transactions of the block. Pass --no-bal to always replay the block.

Examples:

• cast run $TX_HASH
• cast run $TX_HASH –quick (only use the state from the previous block)
• cast run $TX_HASH –debug (open the transaction in the debugger)

Trait Implementations

impl FromArgMatches for TransactionSubcommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for TransactionSubcommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1512 bytes

Size for each variant:

• Call: 1512 bytes
• MakeTx: 1328 bytes
• Classify: 32 bytes
• Tx: 232 bytes
• Receipt: 192 bytes
• SendTx: 1344 bytes
• BatchMakeTx: 1104 bytes
• BatchSend: 1152 bytes
• PublishTx: 160 bytes
• Estimate: 1272 bytes
• Run: 280 bytes