Struct TransactionPayload 

pub struct TransactionPayload {
    pub owner: Arc<str>,
    pub nonce: u64,
    pub chain_id: String,
    pub commands: Vec<Command>,
}

The payload of a transaction containing all transaction data before signing.

This structure represents the actual content of a transaction that gets signed and validated. It includes the sender’s address, a nonce for replay protection, a chain identifier, and a list of commands to execute.

Fields

• owner - the address the commands act for: the multisig address for a multisig-owned transaction, the signing wallet otherwise (v1 payloads spell this field sender, still accepted on the wire)
• nonce - microseconds since the Unix epoch, minted by the client. Not a counter: the sequencer refuses one it has already seen (409), one older than its replay window (407), one further ahead than its skew allowance (408), and zero (410)
• chain_id - Identifier of the blockchain/network (e.g., “real-1”)
• commands - List of commands to execute as part of this transaction

Examples

Building a payload with multiple commands

use types::api::{TransactionPayload, Command, CancelOrderRequest};

let payload = TransactionPayload::builder()
    .sender("0x2ade910d9b7a5afa4aaaab80cf90016bd3e1e7d126b5995bf232e07d1fb00081")
    .nonce(42)
    .chain_id("real-1")
    .command(Command::CancelOrder(
        CancelOrderRequest::builder()
            .account("0x123")
            .market("0x123")
            .build()
            .expect("Failed to build cancel order")
    ))
    .build()
    .expect("Failed to build payload");

Validation

The payload validates all commands and ensures that the sender has permission to execute commands on the specified accounts.

Fields

owner: Arc<str>

nonce: u64

chain_id: String

commands: Vec<Command>

Implementations

impl TransactionPayload

pub fn builder() -> TransactionPayloadBuilder

Creates a new builder for constructing a TransactionPayload.

This is the recommended way to create new TransactionPayload instances, as it ensures all required fields are properly validated before construction.

Returns

A new TransactionPayloadBuilder instance

Examples

use types::api::TransactionPayload;

let payload = TransactionPayload::builder()
    .sender("0x2ade910d9b7a5afa4aaaab80cf90016bd3e1e7d126b5995bf232e07d1fb00081")
    .nonce(1)
    .chain_id("real-1")
    .build()
    .expect("Failed to build payload");

pub fn from_base64(payload: &str) -> Result<TransactionPayload, Error>

Decodes the base64 payload of a Transaction back into its commands.

The counterpart to what the builder encodes when it signs, for reading an envelope you did not build — inspecting a multisig proposal’s payload_b64 before adding a signature to it, say.

The *_id fields of the decoded commands are left at their default: they are engine-side companions to the string ids, never carried on the wire.

Errors

• ERROR_TRANSACTION_PAYLOAD_INVALID_BASE64 — not valid base64
• ERROR_INVALID_TRANSACTION_PAYLOAD — not a valid payload JSON

pub fn chain_id_error(&self, network: &str) -> Option<Error>

The rejection for this payload’s chain_id against the network actually serving the request, or None when they agree.

A mismatch means the transaction was signed for another network: the signature binds it to a chain id this engine does not answer to. A method rather than a free function taking both values positionally, because the two &str are not interchangeable and would silently report the mismatch backwards if swapped.

Trait Implementations

impl Clone for TransactionPayload

fn clone(&self) -> TransactionPayload

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TransactionPayload

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionPayload

fn deserialize<__D>( __deserializer: __D, ) -> Result<TransactionPayload, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TransactionPayload

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.