Enum TransferData

pub enum TransferData<AnchorV>
where
    AnchorV: AnchorVariant + Clone,
{
    SpendsAndMaybeOutputs {
        shared_anchor: AnchorV::Shared,
        spends: AtLeastOne<Spend<AnchorV>>,
        maybe_outputs: Vec<Output>,
    },
    JustOutputs {
        outputs: AtLeastOne<Output>,
    },
}

A bundle of Spend and Output descriptions, and a shared anchor.

This wrapper type bundles at least one Spend or Output description with the required anchor data, so that an Option<ShieldedData> (which contains this type) correctly models the presence or absence of any spends and shielded data, across both V4 and V5 transactions.

Specifically, TransferData ensures that:

• there is at least one spend or output, and
• the shared anchor is only present when there are spends.

Variants

SpendsAndMaybeOutputs

A bundle containing at least one spend, and the shared spend anchor. There can also be zero or more outputs.

In Transaction::V5, if there are any spends, there must also be a shared spend anchor.

Fields

shared_anchor: AnchorV::Shared

The shared anchor for all Spends in this transaction.

The anchor is the root of the Sapling note commitment tree in a previous block. This root should be in the best chain for a transaction to be mined, and it must be in the relevant chain for a transaction to be valid.

Some transaction versions have a per-spend anchor, rather than a shared anchor.

Use the shared_anchor method to access this field.

spends: AtLeastOne<Spend<AnchorV>>

At least one spend.

Use the ShieldedData::spends method to get an iterator over the Spends in this TransferData.

maybe_outputs: Vec<Output>

Maybe some outputs (can be empty), in the order they appear in the transaction.

Use the ShieldedData::outputs method to get an iterator over the Outputs in this TransferData.

JustOutputs

A bundle containing at least one output, with no spends and no shared spend anchor.

In Transaction::V5, if there are no spends, there must not be a shared anchor.

Fields

outputs: AtLeastOne<Output>

At least one output, in the order they appear in the transaction.

Use the ShieldedData::outputs method to get an iterator over the Outputs in this TransferData.

Implementations

impl<AnchorV> TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone, Spend<PerSpendAnchor>: From<(Spend<AnchorV>, AnchorV::Shared)>,

pub fn spends_per_anchor( &self, ) -> impl Iterator<Item = Spend<PerSpendAnchor>> + '_

Iterate over the Spends for this transaction, returning Spend<PerSpendAnchor> regardless of the underlying transaction version.

Allows generic operations over V4 and V5 transactions, including:

• spend verification, and
• non-malleable transaction ID generation.

Correctness

Do not use this function for serialization.

impl<AnchorV> TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone,

pub fn spends(&self) -> impl Iterator<Item = &Spend<AnchorV>>

Iterate over the Spends for this transaction, returning them as their generic type.

pub fn outputs(&self) -> impl Iterator<Item = &Output>

Iterate over the Outputs for this transaction.

pub fn shared_anchor(&self) -> Option<AnchorV::Shared>

Provide the shared anchor for this transaction, if present.

The shared anchor is only present if:

• there is at least one spend, and
• this is a V5 transaction.

Trait Implementations

impl Arbitrary for TransferData<PerSpendAnchor>

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<TransferData<PerSpendAnchor>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Arbitrary for TransferData<SharedAnchor>

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<TransferData<SharedAnchor>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<AnchorV> Clone for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + Clone, AnchorV::Shared: Clone,

fn clone(&self) -> TransferData<AnchorV>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AnchorV> Debug for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + Debug, AnchorV::Shared: Debug,

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

Formats the value using the given formatter.

impl<'de, AnchorV> Deserialize<'de> for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + Deserialize<'de>, AnchorV::Shared: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<AnchorV> PartialEq for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + PartialEq, AnchorV::Shared: PartialEq,

fn eq(&self, other: &TransferData<AnchorV>) -> 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<AnchorV> Serialize for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + Serialize, AnchorV::Shared: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<AnchorV> Eq for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone + Eq, AnchorV::Shared: Eq,

impl<AnchorV> StructuralPartialEq for TransferData<AnchorV>

where AnchorV: AnchorVariant + Clone,