Struct Transaction 

pub struct Transaction { /* private fields */ }

Phoenix transaction.

Implementations

impl Transaction

pub fn new<R: RngCore + CryptoRng, P: Prove>( rng: &mut R, sender_sk: &SecretKey, refund_pk: &PublicKey, receiver_pk: &PublicKey, inputs: Vec<(Note, NoteOpening)>, root: BlsScalar, transfer_value: u64, obfuscate_transfer_note: 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 given the sender secret-key, receiver public-key, the input note positions in the transaction tree and the new output-notes.

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 prover is implemented incorrectly
• the memo, if given, is too large

pub fn from_payload_and_proof(payload: Payload, proof: Vec<u8>) -> Self

Creates a new phoenix transaction given the Payload and proof. Note that this function doesn’t guarantee that the proof matches the payload, if possible use Self::new instead.

pub fn set_proof(&mut self, proof: Vec<u8>)

Replaces the inner proof bytes for a given proof.

This can be used to delegate the proof generation after a Transaction is created. In order to do that, the transaction would be created using the serialized circuit-bytes for the proof-field. Those bytes can be sent to a 3rd-party prover-service that generates the proof-bytes and sends them back. The proof-bytes will then replace the circuit-bytes in the transaction using this function.

pub fn proof(&self) -> &[u8]

The proof of the transaction.

pub fn payload_hash(&self) -> BlsScalar

The payload-hash of the transaction used as input in the phoenix-circuit.

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

Returns the nullifiers of the transaction.

pub fn root(&self) -> &BlsScalar

Return the root of the notes tree.

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

Return the output notes of the transaction.

pub fn fee(&self) -> &Fee

Return the fee for the transaction.

pub fn stealth_address(&self) -> &StealthAddress

Return the stealth address for returning funds for Phoenix transactions as specified in the fee.

pub fn sender(&self) -> &Sender

Returns the sender data for Phoenix transactions as specified in the fee.

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 chain_id(&self) -> u8

Returns the chain ID of the transaction.

pub fn max_fee(&self) -> u64

Returns the max fee to be spend by the transaction.

pub fn deposit(&self) -> u64

Returns the deposit of the transaction.

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

Return the contract call data, if there is any.

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

Return the contract deploy data, if there is any.

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

Return the blob data, if there is any.

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

Return the mutable blob data, if there is any.

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

Returns the memo used with the transaction, if any.

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 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 to_var_bytes(&self) -> Vec<u8>

Serialize the Transaction into a variable length byte buffer.

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

Deserialize the Transaction from a bytes buffer.

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

pub fn public_inputs(&self) -> Vec<BlsScalar>

Return the public input to be used in the phoenix-transaction circuit verification

These are:

• payload_hash
• root
• [nullifier; I]
• [output_value_commitment; 2]
• max_fee
• deposit
• (npk_out_0, npk_out_1)
• (enc_A_npk_out_0, enc_B_npk_out_0)
• (enc_A_npk_out_1, enc_B_npk_out_1)

Panics

Panics if one of the output-notes doesn’t have the sender set to Sender::Encryption.

Trait Implementations

impl Archive for Transaction

where Payload: Archive, Vec<u8>: 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::Resolver, out: *mut Self::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 Payload: Archive, Archived<Payload>: Deserialize<Payload, __D>, Vec<u8>: Archive, Archived<Vec<u8>>: Deserialize<Vec<u8>, __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 PartialEq for Transaction

fn eq(&self, other: &Self) -> 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 Payload: Serialize<__S>, Vec<u8>: Serialize<__S>,

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

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

impl Eq for Transaction