Struct monero_wallet::send::Eventuality

pub struct Eventuality(/* private fields */);

The eventual output of a SignableTransaction.

If a SignableTransaction is signed and published on-chain, it will create a Transaction identifiable to whoever else has the same SignableTransaction (with the same outgoing view key). This structure enables checking if a Transaction is in fact such an output, as it can.

Since Monero is a privacy coin without outgoing view keys, this only performs a fuzzy match. The fuzzy match executes over the outputs and associated data necessary to work with the outputs (the transaction randomness, ciphertexts). This transaction does not check if the inputs intended to be spent where actually the inputs spent (as infeasible).

The transaction randomness does bind to the inputs intended to be spent, so an on-chain transaction will not match for multiple Eventualitys unless the SignableTransactions they were built from were in conflict (and their intended transactions cannot simultaneously exist on-chain).

Implementations

impl Eventuality

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

Return the extra field any transaction following this intent would use.

This enables building a HashMap of Extra -> Eventuality for efficiently fetching the Eventuality an on-chain transaction may complete.

This extra is cryptographically bound to the inputs intended to be spent. If the SignableTransactions the Eventualitys are built from are not in conflict (their intended transactions can simultaneously exist on-chain), then each extra will only have a single Eventuality associated (barring a cryptographic problem considered hard failing).

pub fn matches(&self, tx: &Transaction<Pruned>) -> bool

Return if this TX matches the SignableTransaction this was created from.

Matching the SignableTransaction means this transaction created the expected outputs, they’re scannable, they’re not locked, and this transaction claims to use the intended inputs (though this is not guaranteed). This ‘claim’ is evaluated by this transaction using the transaction keys derived from the intended inputs. This ensures two SignableTransactions with the same intended payments don’t match for each other’s Eventualitys (as they’ll have distinct inputs intended).

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

Write the Eventuality.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization.

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

Serialize the Eventuality to a Vec<u8>.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization.

pub fn read<R: Read>(r: &mut R) -> Result<Eventuality>

Read a Eventuality.

This is not a Monero protocol defined struct, and this is accordingly not a Monero protocol defined serialization.

Trait Implementations

impl Clone for Eventuality

fn clone(&self) -> Eventuality

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Eventuality

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

Formats the value using the given formatter.

impl From<SignableTransaction> for Eventuality

fn from(tx: SignableTransaction) -> Eventuality

Converts to this type from the input type.

impl PartialEq for Eventuality

fn eq(&self, other: &Eventuality) -> 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 Zeroize for Eventuality

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Eventuality

impl StructuralPartialEq for Eventuality