Struct TransactionPayloadBuilder 

pub struct TransactionPayloadBuilder { /* private fields */ }

Builder for constructing TransactionPayload instances.

This builder provides a fluent interface for constructing transaction payloads with required validation.

Examples

use types::api::TransactionPayload;

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

Implementations

impl TransactionPayloadBuilder

pub fn new() -> TransactionPayloadBuilder

Creates a new TransactionPayloadBuilder with all fields initially unset.

pub fn owner<S>(self, owner: S) -> TransactionPayloadBuilder

where S: Into<String>,

Sets the owner address for the transaction payload.

The owner is the multisig address for multisig-owned transactions, or the signing wallet’s address for direct (single-signer) transactions. It is what is_valid_sender is checked against during command validation.

Arguments

• owner - Any value that can be converted to a String (blockchain address)

Examples

use types::api::TransactionPayload;

let builder = TransactionPayload::builder()
    .owner("0x2ade910d9b7a5afa4aaaab80cf90016bd3e1e7d126b5995bf232e07d1fb00081");

pub fn sender<S>(self, sender: S) -> TransactionPayloadBuilder

where S: Into<String>,

Deprecated alias for owner — kept so existing callers using the v1 name (SDK examples, external tests) keep compiling. New code should use owner.

pub fn nonce(self, nonce: u64) -> TransactionPayloadBuilder

Sets the nonce for replay protection.

Mint it as microseconds since the Unix epoch, freshly for every transaction. It is not a counter the client keeps: the sequencer holds a per-owner window of recently seen stamps and refuses one that is zero (410), older than the window (407), further ahead of its clock than the skew allowance (408), or already spent (409).

Arguments

• nonce - microseconds since the Unix epoch

Examples

use std::time::{SystemTime, UNIX_EPOCH};
use types::api::TransactionPayload;

let now_us = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .expect("system clock before the Unix epoch")
    .as_micros() as u64;

let builder = TransactionPayload::builder()
    .nonce(now_us);

pub fn chain_id<S>(self, chain_id: S) -> TransactionPayloadBuilder

where S: Into<String>,

Sets the chain identifier.

The chain ID identifies which blockchain/network this transaction is intended for, preventing transactions from being replayed on different chains.

Arguments

• chain_id - Any value that can be converted to a String (e.g., “real-1”)

Examples

use types::api::TransactionPayload;

let builder = TransactionPayload::builder()
    .chain_id("real-1");

pub fn command<C>(self, command: C) -> TransactionPayloadBuilder

where C: Into<Command>,

Adds a single command to the transaction payload.

Commands are executed in the order they are added.

Arguments

• command - Any value that can be converted into a Command

Examples

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

let builder = TransactionPayload::builder()
    .command(Command::CancelOrder(
        CancelOrderRequest::builder()
            .account("0x123")
            .market("0x123")
            .build()
            .expect("Failed to build cancel order")
    ));

pub fn commands<I>(self, commands: I) -> TransactionPayloadBuilder

where I: IntoIterator<Item = Command>,

Adds multiple commands to the transaction payload.

Commands are executed in the order they appear in the iterator.

Arguments

• commands - An iterator of Command values

Examples

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

let commands = vec![
    Command::CancelOrder(
        CancelOrderRequest::builder()
            .account("0x123")
            .market("0x123")
            .build()
            .expect("Failed to build")
    ),
];

let builder = TransactionPayload::builder()
    .commands(commands);

pub fn build(self) -> Result<TransactionPayload, TransactionPayloadBuilderError>

Builds the TransactionPayload from the configured builder.

This method validates that all required fields have been set and constructs the final TransactionPayload instance.

Returns

• Ok(TransactionPayload) - Successfully built payload
• Err(TransactionPayloadBuilderError) - Missing required field(s)

Errors

Returns TransactionPayloadBuilderError::MissingField if:

• nonce has not been set
• chain_id has not been set
• No commands have been added (at least one is required)

Notes

The sender field is optional during building and defaults to an empty string if not provided. This allows for payloads to be created before signing, where the sender will be set automatically from the signing key.

Examples

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

// at least one command is required — a payload with none is an error
let payload = TransactionPayload::builder()
    .nonce(1_800_000_000_000_000)
    .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");

Trait Implementations

impl Debug for TransactionPayloadBuilder

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

Formats the value using the given formatter.

impl Default for TransactionPayloadBuilder

fn default() -> TransactionPayloadBuilder

Returns the “default value” for a type.