Enum monero_wallet::transaction::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 copy 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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method 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. This cached preprocess MUST only be used once. Reuse of it enables recovery of your private key share. Third-party recovery of a cached preprocess also enables recovery of your private key share, so this MUST be treated with the same security as your private key share.

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

Create a sign machine from a cached preprocess. After this, the preprocess must be deleted so it’s never reused. Any reuse will presumably cause the signer to leak their secret share.

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

Read a Preprocess message. Despite taking self, this does not save the preprocess. It must be externally cached and passed into sign.

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

Sign a message. Takes in the participants’ preprocess messages. Returns the signature share to be broadcast to all participants, over an authenticated channel. The parties who participate here will become the signing set for this session.

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,