Enum Transaction 

pub enum Transaction {
    Phoenix(Transaction),
    Moonlight(Transaction),
}

The transaction used by the transfer contract.

Variants

Phoenix(Transaction)

A phoenix transaction.

Moonlight(Transaction)

A moonlight transaction.

Implementations

impl Transaction

pub fn phoenix<R: RngCore + CryptoRng, P: Prove>( rng: &mut R, sender_sk: &PhoenixSecretKey, refund_pk: &PhoenixPublicKey, receiver_pk: &PhoenixPublicKey, inputs: Vec<(Note, Opening<(), NOTES_TREE_DEPTH>)>, root: BlsScalar, transfer_value: u64, obfuscated_transaction: bool, deposit: u64, gas_limit: u64, gas_price: u64, chain_id: u8, data: Option<impl Into<TransactionData>>, prover: &P, ) -> Result<Self, Error>

Create a new phoenix transaction.

Errors

The creation of a transaction is not possible and will error if:

• one of the input-notes doesn’t belong to the sender_sk
• the transaction input doesn’t cover the transaction costs
• the inputs vector is either empty or larger than 4 elements
• the inputs vector contains duplicate Notes
• the Prove trait is implemented incorrectly

pub fn moonlight( sender_sk: &AccountSecretKey, receiver: Option<AccountPublicKey>, value: u64, deposit: u64, gas_limit: u64, gas_price: u64, nonce: u64, chain_id: u8, data: Option<impl Into<TransactionData>>, ) -> Result<Self, Error>

Create a new moonlight transaction.

Errors

The creation of a transaction is not possible and will error if:

• the memo, if given, is too large

pub fn moonlight_sender(&self) -> Option<&AccountPublicKey>

Return the sender of the account for Moonlight transactions.

pub fn moonlight_receiver(&self) -> Option<&AccountPublicKey>

Get the receiver of the transaction for Moonlight transactions, if it exists.

Returns

• Some(&AccountPublicKey) if the transaction is a Moonlight transaction and the receiver is different from the sender.
• None if the transaction is a Moonlight transaction and the receiver is the same as the sender.
• None if the transaction is a Phoenix transaction.

pub fn value(&self) -> Option<u64>

Return the value transferred in a Moonlight transaction.

pub fn nullifiers(&self) -> &[BlsScalar]

Returns the nullifiers of the transaction, if the transaction is a moonlight transaction, the result will be empty.

pub fn root(&self) -> Option<&BlsScalar>

Return the root of the UTXO tree for Phoenix transactions.

pub fn outputs(&self) -> &[Note]

Return the UTXO outputs of the transaction.

pub fn phoenix_sender(&self) -> Option<&Sender>

Returns the sender data for Phoenix transactions.

pub fn deposit(&self) -> u64

Returns the deposit of the transaction.

pub fn gas_limit(&self) -> u64

Returns the gas limit of the transaction.

pub fn gas_price(&self) -> u64

Returns the gas price of the transaction.

pub fn refund_address(&self) -> RefundAddress<'_>

Returns the refund-address of the transaction.

pub fn call(&self) -> Option<&ContractCall>

Return the contract call data, if there is any.

Call data is present only when inter-contract calls happen.

Returns

• Some(&ContractCall) if the transaction invokes another call to a contract.
• None if the transaction is an entrypoint call to a protocol contract without a second call attached to it.

pub fn deploy(&self) -> Option<&ContractDeploy>

Return the contract deploy data, if there is any.

pub fn memo(&self) -> Option<&[u8]>

Returns the memo used with the transaction, if any.

pub fn blob(&self) -> Option<&Vec<BlobData>>

Returns the Blob used with the transaction, if any.

pub fn blob_mut(&mut self) -> Option<&mut Vec<BlobData>>

Returns the Blob used with the transaction, if any.

pub fn strip_blobs(&mut self) -> Option<Vec<([u8; 32], BlobSidecar)>>

Extracts and removes the blob sidecar from the transaction, if any, and returns it as a vector of tuples containing the blob hash and the corresponding blob sidecar.

This function mutably accesses the blob storage within the transaction, clears the stored data, and returns the extracted parts while preserving their hashes.

Returns None if there are no blobs present in the transaction.

pub fn blob_to_memo(&self) -> Option<Self>

Creates a modified clone of this transaction if it contains a Blob, clones all fields except for the Blob, whose versioned hashes are set as Memo.

Returns none if the transaction is not a Blob transaction.

pub fn strip_off_bytecode(&self) -> Option<Self>

Creates a modified clone of this transaction if it contains data for deployment, clones all fields except for the bytecode’ ‘bytes’ part. Returns none if the transaction is not a deployment transaction.

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

Serialize the transaction into a byte buffer.

pub fn from_slice(buf: &[u8]) -> Result<Self, BytesError>

Deserialize the transaction from a byte slice.

Errors

Errors when the bytes are not canonical.

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

Return input bytes to hash the transaction.

Note: The result of this function is only meant to be used as an input for hashing and cannot be used to deserialize the transaction again.

pub fn hash(&self) -> BlsScalar

Create the unique transaction hash.

pub fn deploy_charge( &self, gas_per_deploy_byte: u64, min_deploy_points: u64, ) -> u64

Returns the charge for a contract deployment. The deployment of a contract will cost at least min_deploy_points. If the transaction is not a deploy-transaction, the deploy-charge will be 0.

pub fn blob_charge(&self, gas_per_blob: u64) -> Option<u64>

Returns the minimum gas charged for a blob transaction deployment. If the transaction is not a blob transaction, it returns None.

pub fn deploy_check( &self, gas_per_deploy_byte: u64, min_deploy_gas_price: u64, min_deploy_points: u64, ) -> Result<(), TxPreconditionError>

Check if the transaction is a deployment transaction and if it meets the minimum requirements for gas price and gas limit.

Errors

Returns an error if the transaction is a deployment transaction and the gas price is lower than the minimum required gas price or if the gas limit is lower than the required deployment charge.

pub fn blob_check( &self, gas_per_blob: u64, ) -> Result<Option<u64>, TxPreconditionError>

Check if the transaction is a blob transaction and if it meets the minimum requirements for gas limit.

Returns

• Ok(Some(u64)) the minimum gas amount to charge if the transaction is a blob transaction.
• Ok(None) if the transaction is not a blob transaction.
• Err(TxPreconditionError) in case of an error.

Errors

Returns an error if the transaction is a blob transaction and:

• the gas limit is lower than the minimum charge.
• the number of blobs is zero or greater than 6.

Trait Implementations

impl Archive for Transaction

where PhoenixTransaction: Archive, MoonlightTransaction: Archive,

type Archived = ArchivedTransaction

The archived representation of this type.

type Resolver = TransactionResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Self as Archive>::Resolver, out: *mut <Self as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

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<__D: Fallible + ?Sized> Deserialize<Transaction, __D> for Archived<Transaction>

where PhoenixTransaction: Archive, Archived<PhoenixTransaction>: Deserialize<PhoenixTransaction, __D>, MoonlightTransaction: Archive, Archived<MoonlightTransaction>: Deserialize<MoonlightTransaction, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Transaction, __D::Error>

Deserializes using the given deserializer

impl From<Transaction> for Transaction

fn from(tx: PhoenixTransaction) -> Self

Converts to this type from the input type.

impl From<Transaction> for Transaction

fn from(tx: MoonlightTransaction) -> Self

Converts to this type from the input type.

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<__S: Fallible + ?Sized> Serialize<__S> for Transaction

where PhoenixTransaction: Serialize<__S>, MoonlightTransaction: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for Transaction

impl StructuralPartialEq for Transaction