Struct Transaction 

pub struct Transaction {
    pub from: Address,
    pub to: Address,
    pub amount: u128,
    pub source_chain: Chain,
    pub destination_chain: Chain,
    pub data: Option<Vec<u8>>,
    pub gas_limit: Option<u64>,
    pub nonce: Option<u64>,
}

Represents a blockchain transaction

Fields

from: Address

Sender address

to: Address

Recipient address

amount: u128

Amount to transfer

source_chain: Chain

Source blockchain

destination_chain: Chain

Destination blockchain

data: Option<Vec<u8>>

Transaction data/payload

gas_limit: Option<u64>

Gas limit

nonce: Option<u64>

Nonce for transaction uniqueness (prevents replay attacks)

Implementations

impl Transaction

pub fn is_cross_chain(&self) -> bool

Check if this is a cross-chain transaction

pub fn hash(&self) -> String

Get transaction hash using Keccak256

This implementation ensures deterministic hashing by:

1. Using canonical name representation instead of Debug formatting
2. Explicitly marking presence/absence of optional fields
3. Including all fields in a fixed order

Determinism Guarantee

The same transaction parameters will always produce the same hash, regardless of the order of construction or serialization format changes.

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 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.