Enum TransactionData 

#[non_exhaustive]
pub enum TransactionData {
    V1(TransactionV1),
}

Transaction

BCS

The BCS serialized form for this type is defined by the following ABNF:

transaction = %d00 transaction-v1

transaction-v1 = transaction-kind address gas-payment transaction-expiration

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

V1(TransactionV1)

Implementations

impl Transaction

pub fn digest(&self) -> Digest

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

Serialize the transaction as a Vec<u8> of BCS bytes.

pub fn to_base64(&self) -> String

Serialize the transaction as a base64-encoded string.

pub fn from_bcs(bytes: &[u8]) -> Result<Transaction, Error>

Deserialize a transaction from a Vec<u8> of BCS bytes.

pub fn from_base64(bytes: &str) -> Result<Transaction, Error>

Deserialize a transaction from a base64-encoded string.

impl Transaction

pub fn signing_digest(&self) -> [u8; 32]

pub fn signing_digest_hex(&self) -> String

impl Transaction

pub fn is_v1(&self) -> bool

Checks if this is a v1 variant.

pub fn as_v1(&self) -> &TransactionV1

Converts this into a v1 if it is a v1 variant, or panics otherwise.

pub fn as_v1_mut(&mut self) -> &mut TransactionV1

Converts this into a mut v1 if it is a v1 variant, or panics otherwise.

pub fn as_v1_opt(&self) -> Option<&TransactionV1>

Converts this into a v1 if it is a v1 variant, or returns None otherwise.

pub fn as_v1_mut_opt(&mut self) -> Option<&mut TransactionV1>

Converts this into a mut v1 if it is a v1 variant, or returns None otherwise.

pub fn into_v1_opt(self) -> Option<TransactionV1>

Converts this into a v1 if it is a v1 variant, or returns None otherwise.

pub fn into_v1(self) -> TransactionV1

Converts this into a v1 if it is a v1 variant, or panics otherwise.

Trait Implementations

impl Arbitrary for Transaction

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<Transaction>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( args_shared: <Transaction as Arbitrary>::Parameters, ) -> <Transaction as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

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<(), Error>

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<TransactionV1> for Transaction

fn from(v1: TransactionV1) -> Transaction

Converts to this type from the input type.

impl Hash for Transaction

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TransactionDataAPI for TransactionData

fn sender(&self) -> IotaAddress

Returns the address of the transaction sender.

fn kind(&self) -> &TransactionKind

Returns a reference to the transaction kind.

fn kind_mut(&mut self) -> &mut TransactionKind

Returns a mutable reference to the transaction kind.

fn into_kind(self) -> TransactionKind

Consumes self and returns the transaction kind.

fn signers(&self) -> NonEmpty<IotaAddress>

Returns the transaction signer(s). Includes both the sender and the gas owner if they differ (i.e. for sponsored transactions).

fn gas_data(&self) -> &GasData

Returns a reference to the gas data (owner, payment objects, price, budget).

fn gas_owner(&self) -> IotaAddress

Returns the address that owns the gas payment objects.

fn gas(&self) -> &[ObjectRef]

Returns the gas payment object references.

fn gas_price(&self) -> u64

Returns the gas price for this transaction.

fn gas_budget(&self) -> u64

Returns the gas budget for this transaction.

fn expiration(&self) -> &TransactionExpiration

Returns the transaction expiration.

fn shared_input_objects(&self) -> Vec<SharedObjectRef>

Returns a list of the transaction data shared input objects.

fn move_calls(&self) -> Vec<(&ObjectID, &str, &str)>

Returns a list of Move calls as (package_id, module_name, function_name) tuples.

fn input_objects(&self) -> UserInputResult<Vec<InputObjectKind>>

Returns all input objects required by this transaction.

fn receiving_objects(&self) -> Vec<ObjectRef>

Returns object references for all objects being received in this transaction.

fn validity_check(&self, config: &ProtocolConfig) -> UserInputResult

Validates the transaction data against the given protocol config, including gas checks.

fn validity_check_no_gas_check( &self, config: &ProtocolConfig, ) -> UserInputResult

Validates the transaction data against the given protocol config, skipping gas-related checks.

fn is_sponsored_tx(&self) -> bool

Check if the transaction is sponsored (namely gas owner != sender)

fn check_sponsorship(&self) -> UserInputResult

Check if the transaction is compliant with sponsorship.

fn is_end_of_epoch_tx(&self) -> bool

returns true if the transaction is one that is specially sequenced to run at the very end of the epoch

fn is_system_tx(&self) -> bool

Returns true if this is a system transaction.

fn is_genesis_tx(&self) -> bool

Returns true if this is the genesis transaction.

fn sender_mut_for_testing(&mut self) -> &mut IotaAddress

Returns a mutable reference to the sender address. Testing only.

fn gas_data_mut(&mut self) -> &mut GasData

Returns a mutable reference to the gas data.

fn expiration_mut_for_testing(&mut self) -> &mut TransactionExpiration

Returns a mutable reference to the expiration. Testing only.

fn new_system_transaction(kind: TransactionKind) -> TransactionData

Creates a new system transaction with no gas payment. Used for validator-initiated transactions (epoch changes, checkpoints, etc.).

fn new( kind: TransactionKind, sender: IotaAddress, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a new transaction with a single gas payment coin. The sender is also the gas owner.

fn new_with_gas_coins( kind: TransactionKind, sender: IotaAddress, gas_payment: Vec<ObjectRef>, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a new transaction with multiple gas payment coins. The sender is also the gas owner.

fn new_with_gas_coins_allow_sponsor( kind: TransactionKind, sender: IotaAddress, gas_payment: Vec<ObjectRef>, gas_budget: u64, gas_price: u64, gas_sponsor: IotaAddress, ) -> TransactionData

Creates a new transaction with multiple gas payment coins and a separate gas sponsor. Use this for sponsored transactions where the gas owner differs from the sender.

fn new_with_gas_data( kind: TransactionKind, sender: IotaAddress, gas_data: GasData, ) -> TransactionData

Creates a new transaction from a pre-built GasData struct.

fn new_move_call( sender: IotaAddress, package: ObjectID, module: Identifier, function: Identifier, type_arguments: Vec<TypeTag>, gas_payment: ObjectRef, arguments: Vec<CallArg>, gas_budget: u64, gas_price: u64, ) -> Result<TransactionData>

Creates a transaction that calls a single Move function with a single gas payment coin.

fn new_move_call_with_gas_coins( sender: IotaAddress, package: ObjectID, module: Identifier, function: Identifier, type_arguments: Vec<TypeTag>, gas_payment: Vec<ObjectRef>, arguments: Vec<CallArg>, gas_budget: u64, gas_price: u64, ) -> Result<TransactionData>

Creates a transaction that calls a single Move function with multiple gas payment coins.

fn new_transfer( recipient: IotaAddress, object_ref: ObjectRef, sender: IotaAddress, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a transaction that transfers an object to a recipient.

fn new_transfer_iota( recipient: IotaAddress, sender: IotaAddress, amount: Option<u64>, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a transaction that transfers IOTA coins to a recipient. If amount is None, the entire gas coin balance (minus gas fees) is transferred.

fn new_transfer_iota_allow_sponsor( recipient: IotaAddress, sender: IotaAddress, amount: Option<u64>, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, gas_sponsor: IotaAddress, ) -> TransactionData

Creates a sponsored transaction that transfers IOTA coins to a recipient. If amount is None, the entire gas coin balance (minus gas fees) is transferred.

fn new_pay( sender: IotaAddress, coins: Vec<ObjectRef>, recipients: Vec<IotaAddress>, amounts: Vec<u64>, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> Result<TransactionData>

Creates a transaction that pays multiple recipients from a set of input coins. The coins are merged and then split to satisfy the specified amounts.

fn new_pay_iota( sender: IotaAddress, coins: Vec<ObjectRef>, recipients: Vec<IotaAddress>, amounts: Vec<u64>, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> Result<TransactionData>

Creates a transaction that pays multiple recipients using IOTA coins. Similar to Self::new_pay but the gas coin is also used as an input coin.

fn new_pay_all_iota( sender: IotaAddress, coins: Vec<ObjectRef>, recipient: IotaAddress, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a transaction that sends all IOTA from the given coins to a single recipient. The gas coin is included as an input coin.

fn new_split_coin( sender: IotaAddress, coin: ObjectRef, amounts: Vec<u64>, gas_payment: ObjectRef, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a transaction that splits a coin into multiple coins with the specified amounts.

fn new_module( sender: IotaAddress, gas_payment: ObjectRef, modules: Vec<Vec<u8>>, dep_ids: Vec<ObjectID>, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a transaction that publishes new Move modules.

fn new_upgrade( sender: IotaAddress, gas_payment: ObjectRef, package_id: ObjectID, modules: Vec<Vec<u8>>, dep_ids: Vec<ObjectID>, (upgrade_capability, capability_owner): (ObjectRef, Owner), upgrade_policy: u8, digest: Vec<u8>, gas_budget: u64, gas_price: u64, ) -> Result<TransactionData>

Creates a transaction that upgrades an existing Move package. Requires the upgrade capability object and the upgrade policy.

fn new_programmable( sender: IotaAddress, gas_payment: Vec<ObjectRef>, pt: ProgrammableTransaction, gas_budget: u64, gas_price: u64, ) -> TransactionData

Creates a programmable transaction with multiple gas payment coins. The sender is also the gas owner.

fn new_programmable_allow_sponsor( sender: IotaAddress, gas_payment: Vec<ObjectRef>, pt: ProgrammableTransaction, gas_budget: u64, gas_price: u64, sponsor: IotaAddress, ) -> TransactionData

Creates a programmable transaction with multiple gas payment coins and a separate gas sponsor.

fn message_version(&self) -> u64

Returns the internal message version number.

fn execution_parts(&self) -> (TransactionKind, IotaAddress, GasData)

Consumes self and returns the transaction kind, sender address, and gas payment object references as a tuple.

impl Eq for Transaction

impl StructuralPartialEq for Transaction