Struct Transaction 

pub struct Transaction {
    pub chain_id: ChainId,
    pub from: Address,
    pub to: Address,
    pub nonce: Nonce,
    pub tx_type: TransactionType,
    pub gas_limit: u64,
    pub gas_price: u64,
    pub timestamp: Timestamp,
    pub memo: Option<String>,
    pub pq_public_key: Vec<u8>,
}

A transaction on Tenzro Network

Transactions represent actions taken by accounts, including transfers, smart contract calls, agent operations, and model inference requests.

Note

The Default implementation creates a transaction with zero values and is intended for testing purposes only. Production transactions should be created with Transaction::new() and properly signed.

Post-quantum migration

The pq_public_key field carries the ML-DSA-65 verifying key bytes (FIPS 204, exactly 1952 bytes) and is mandatory. Tenzro Network does not support classical-only transactions — the field has no Option wrapper and no serde(default). Decoders reject any payload that omits or mis-sizes this field. There is no legacy fallback: a classical-only transaction cannot be constructed in this codebase and cannot be parsed from any external source.

Fields

chain_id: ChainId

The chain ID this transaction is valid for

from: Address

The sender’s address

to: Address

The recipient’s address (or contract address)

nonce: Nonce

The nonce for replay protection

tx_type: TransactionType

The transaction type and payload

gas_limit: u64

Maximum gas to spend

gas_price: u64

Gas price in the smallest unit of TNZO

timestamp: Timestamp

Transaction timestamp

memo: Option<String>

Optional memo or metadata

pq_public_key: Vec<u8>

ML-DSA-65 verifying key bytes (FIPS 204, exactly 1952 bytes). Bound into the hash() preimage so a hybrid signer commits to the PQ key before signing and any key-substitution attempt invalidates the transaction.

Implementations

impl Transaction

pub fn new( chain_id: ChainId, from: Address, to: Address, nonce: Nonce, tx_type: TransactionType, gas_limit: u64, gas_price: u64, pq_public_key: Vec<u8>, ) -> Self

Creates a new transaction. The pq_public_key is the ML-DSA-65 verifying key bytes (FIPS 204, exactly 1952 bytes) and is mandatory — classical-only transactions are not constructible.

pub fn with_memo(self, memo: String) -> Self

Adds a memo to the transaction

pub fn hash(&self) -> Hash

Computes the SHA-256 hash of the transaction.

The preimage layout is the canonical signing surface for the network. The mandatory ML-DSA-65 verifying key (pq_public_key) is included with an explicit u32 little-endian length prefix so the preimage is unambiguous and a key-substitution attempt invalidates the hash.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Transaction

impl PartialEq for Transaction

fn eq(&self, other: &Transaction) -> 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 Transaction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Transaction