Struct RawTransactionOrderless 

pub struct RawTransactionOrderless {
    pub sender: AccountAddress,
    pub nonce: Vec<u8>,
    pub payload: TransactionPayload,
    pub max_gas_amount: u64,
    pub gas_unit_price: u64,
    pub expiration_timestamp_secs: u64,
    pub chain_id: ChainId,
}

An orderless transaction using hash-based replay protection.

Unlike standard transactions that use sequence numbers, orderless transactions use a random nonce and a short expiration window (typically 60 seconds) to prevent replay attacks. This allows transactions to be submitted in any order.

Note

Orderless transactions must be configured with a very short expiration time (recommended: 60 seconds or less) since the replay protection relies on the chain remembering recently seen transaction hashes.

Fields

sender: AccountAddress

Sender’s address.

nonce: Vec<u8>

Random nonce for uniqueness (32 bytes recommended).

payload: TransactionPayload

The transaction payload (entry function, script, etc.).

max_gas_amount: u64

Maximum gas units the sender is willing to pay.

gas_unit_price: u64

Price per gas unit in octas.

expiration_timestamp_secs: u64

Expiration time in seconds since Unix epoch. Should be short (e.g., current time + 60 seconds).

chain_id: ChainId

Chain ID to prevent cross-chain replay.

Implementations

impl RawTransactionOrderless

pub fn new( sender: AccountAddress, payload: TransactionPayload, max_gas_amount: u64, gas_unit_price: u64, expiration_timestamp_secs: u64, chain_id: ChainId, ) -> Self

Creates a new orderless transaction with a random nonce.

pub fn with_nonce( sender: AccountAddress, nonce: Vec<u8>, payload: TransactionPayload, max_gas_amount: u64, gas_unit_price: u64, expiration_timestamp_secs: u64, chain_id: ChainId, ) -> Self

Creates a new orderless transaction with a specific nonce.

pub fn signing_message(&self) -> AptosResult<Vec<u8>>

Generates the signing message for this orderless transaction.

Errors

Returns an error if BCS serialization of the transaction fails.

pub fn to_bcs(&self) -> AptosResult<Vec<u8>>

Serializes this transaction to BCS bytes.

Errors

Returns an error if BCS serialization fails.

Trait Implementations

impl Clone for RawTransactionOrderless

fn clone(&self) -> RawTransactionOrderless

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawTransactionOrderless

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawTransactionOrderless

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RawTransactionOrderless

fn eq(&self, other: &RawTransactionOrderless) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RawTransactionOrderless

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RawTransactionOrderless

impl StructuralPartialEq for RawTransactionOrderless