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.

impl Transaction

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 weight(&self) -> usize

Calculate the transaction’s weight.

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 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 = Vec<Preprocess<Ed25519, ClsagAddendum>>

Preprocess message for this machine.

type SignatureShare = Vec<SignatureShare<Ed25519>>

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 = Vec<SignatureShare<Ed25519>>

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> Eq for Transaction<P>

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

impl<P> StructuralPartialEq for Transaction<P>

where P: PotentiallyPruned,