Enum Transaction 

pub enum Transaction<P = NotPruned>
where
    P: PotentiallyPruned,
{
    V1 {
        prefix: TransactionPrefix,
        signatures: <P as PotentiallyPruned>::RingSignatures,
    },
    V2 {
        prefix: TransactionPrefix,
        proofs: Option<<P as PotentiallyPruned>::RctProofs>,
    },
}

A Monero transaction.

Variants

V1

A version 1 transaction, used by the original Cryptonote codebase.

Fields

prefix: TransactionPrefix

The transaction’s prefix.

signatures: <P as PotentiallyPruned>::RingSignatures

The transaction’s ring signatures.

V2

A version 2 transaction, used by the RingCT protocol.

Fields

prefix: TransactionPrefix

The transaction’s prefix.

proofs: Option<<P as PotentiallyPruned>::RctProofs>

The transaction’s proofs.

Implementations

impl<P> Transaction<P>

where P: PotentiallyPruned,

pub fn version(&self) -> u8

Get the version of this transaction.

pub fn prefix(&self) -> &TransactionPrefix

Get the TransactionPrefix of this transaction.

pub fn prefix_mut(&mut self) -> &mut TransactionPrefix

Get a mutable reference to the TransactionPrefix of this transaction.

pub fn write<W>(&self, w: &mut W) -> Result<(), Error>

where W: Write,

Write the Transaction.

Some writable transactions may not be readable if they’re malformed, per Monero’s consensus rules.

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

Write the Transaction to a Vec<u8>.

pub fn read<R>(r: &mut R) -> Result<Transaction<P>, Error>

where R: Read,

Read a Transaction.

This MAY error if miscellaneous Monero conseusus rules are broken, as useful when deserializing. The result is not guaranteed to follow all Monero consensus rules or any specific set of consensus rules.

impl Transaction

pub const NON_MINER_SIZE_UPPER_BOUND: UpperBound<usize>

The maximum size for a non-miner transaction.

pub fn prunable_hash(&self) -> Option<[u8; 32]>

The prunable hash of the transaction.

This will return None for V1 transactions which do not have a well-defined prunable hash.

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

The hash of the transaction.

pub fn signature_hash(&self) -> Option<[u8; 32]>

Calculate the hash of this transaction as needed for signing it.

This returns None if the transaction is without signatures.

pub fn pruned_with_prunable(self) -> (Transaction<Pruned>, Vec<u8>)

Splits this transaction into its pruned and serialized prunable part.

pub fn weight(&self) -> usize

Calculate the transaction’s weight.

impl Transaction<Pruned>

pub fn hash_with_prunable_hash( &self, prunable_hash: [u8; 32], ) -> Option<[u8; 32]>

Return the hash of the pruned transaction.

This requires the transaction be version 2 and the hash of the pruned data be provided. If the proofs are RctType::Null, prunable_hash MUST equal [0; 32] for the result to be correct.

Trait Implementations

impl<P> Clone for Transaction<P>

where P: Clone + PotentiallyPruned, <P as PotentiallyPruned>::RingSignatures: Clone, <P as PotentiallyPruned>::RctProofs: Clone,

fn clone(&self) -> Transaction<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for Transaction<P>

where P: Debug + PotentiallyPruned, <P as PotentiallyPruned>::RingSignatures: Debug, <P as PotentiallyPruned>::RctProofs: Debug,

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

Formats the value using the given formatter.

impl<P> Eq for Transaction<P>

where P: Eq + PotentiallyPruned, <P as PotentiallyPruned>::RingSignatures: Eq, <P as PotentiallyPruned>::RctProofs: Eq,

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl From<Transaction> for Transaction<Pruned>

fn from(tx: Transaction) -> Transaction<Pruned>

Converts to this type from the input type.

impl<P> PartialEq for Transaction<P>

where P: PartialEq + PotentiallyPruned, <P as PotentiallyPruned>::RingSignatures: PartialEq, <P as PotentiallyPruned>::RctProofs: PartialEq,

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

Available on crate feature multisig only.

type Params = ()

Params used to instantiate this machine which can be used to rebuild from a cache.

type Keys = ThresholdKeys<Ed25519>

Keys used for signing operations.

type Preprocess = TransactionPreprocess

Preprocess message for this machine.

type SignatureShare = TransactionSignatureShare

SignatureShare message for this machine.

type SignatureMachine = TransactionSignatureMachine

SignatureMachine this SignMachine turns into.

fn cache(self) -> CachedPreprocess

Cache this preprocess for usage later.

fn from_cache( (): (), _: ThresholdKeys<Ed25519>, _: CachedPreprocess, ) -> (Self, Self::Preprocess)

Create a sign machine from a cached preprocess.

fn read_preprocess<R: Read>(&self, reader: &mut R) -> Result<Self::Preprocess>

Read a Preprocess message.

fn sign( self, commitments: HashMap<Participant, Self::Preprocess>, msg: &[u8], ) -> Result<(TransactionSignatureMachine, Self::SignatureShare), FrostError>

Sign a message.

impl SignatureMachine<Transaction> for TransactionSignatureMachine

Available on crate feature multisig only.

type SignatureShare = TransactionSignatureShare

SignatureShare message for this machine.

fn read_share<R: Read>(&self, reader: &mut R) -> Result<Self::SignatureShare>

Read a Signature Share message.

fn complete( self, shares: HashMap<Participant, Self::SignatureShare>, ) -> Result<Transaction, FrostError>

Complete signing. Takes in everyone elses’ shares. Returns the signature.

impl<P> StructuralPartialEq for Transaction<P>

where P: PotentiallyPruned,