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 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 = 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> 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,