Struct zebra_chain::sapling::spend::Spend

pub struct Spend<AnchorV: AnchorVariant> {
    pub cv: NotSmallOrderValueCommitment,
    pub per_spend_anchor: AnchorV::PerSpend,
    pub nullifier: Nullifier,
    pub rk: ValidatingKey,
    pub zkproof: Groth16Proof,
    pub spend_auth_sig: Signature<SpendAuth>,
}

A Spend Description, as described in protocol specification §7.3.

Differences between Transaction Versions

In Transaction::V4, each Spend has its own anchor. In Transaction::V5, there is a single shared_anchor for the entire transaction. This structural difference is modeled using the AnchorVariant type trait.

V4 transactions serialize the fields of spends and outputs together. V5 transactions split them into multiple arrays.

Fields

cv: NotSmallOrderValueCommitment

A value commitment to the value of the input note.

per_spend_anchor: AnchorV::PerSpend

An anchor for this spend.

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 shared anchor, rather than a per-spend anchor.

nullifier: Nullifier

The nullifier of the input note.

rk: ValidatingKey

The randomized public key for spend_auth_sig.

zkproof: Groth16Proof

The ZK spend proof.

spend_auth_sig: Signature<SpendAuth>

A signature authorizing this spend.

Implementations

impl Spend<SharedAnchor>

pub fn from_v5_parts( prefix: SpendPrefixInTransactionV5, zkproof: Groth16Proof, spend_auth_sig: Signature<SpendAuth> ) -> Spend<SharedAnchor>

Combine the prefix and non-prefix fields from V5 transaction deserialization.

pub fn into_v5_parts( self ) -> (SpendPrefixInTransactionV5, Groth16Proof, Signature<SpendAuth>)

Split out the prefix and non-prefix fields for V5 transaction serialization.

Trait Implementations

impl<AnchorV: Clone + AnchorVariant> Clone for Spend<AnchorV>

where AnchorV::PerSpend: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AnchorV: Debug + AnchorVariant> Debug for Spend<AnchorV>

where AnchorV::PerSpend: Debug,

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

Formats the value using the given formatter.

impl<'de, AnchorV: AnchorVariant> Deserialize<'de> for Spend<AnchorV>

where AnchorV::PerSpend: 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> Display for Spend<AnchorV>

where AnchorV: AnchorVariant + Clone,

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

Formats the value using the given formatter.

impl From<(Spend<PerSpendAnchor>, FieldNotPresent)> for Spend<PerSpendAnchor>

fn from(per_spend: (Spend<PerSpendAnchor>, FieldNotPresent)) -> Self

Take the Spend<PerSpendAnchor> from a spend + anchor tuple.

impl From<(Spend<SharedAnchor>, Root)> for Spend<PerSpendAnchor>

fn from(shared_spend: (Spend<SharedAnchor>, Root)) -> Self

Convert a Spend<SharedAnchor> and its shared anchor, into a Spend<PerSpendAnchor>.

impl<AnchorV: PartialEq + AnchorVariant> PartialEq for Spend<AnchorV>

where AnchorV::PerSpend: PartialEq,

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

where AnchorV::PerSpend: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TrustedPreallocate for Spend<PerSpendAnchor>

The maximum number of sapling spends in a valid Zcash on-chain transaction V4.

fn max_allocation() -> u64

Provides a loose upper bound on the size of the Vec<T: TrustedPreallocate> which can possibly be received from an honest peer.

impl ZcashDeserialize for Spend<PerSpendAnchor>

fn zcash_deserialize<R: Read>(reader: R) -> Result<Self, SerializationError>

Consensus

The anchor of each Spend description MUST refer to some earlier block’s final Sapling treestate. The anchor is encoded separately in each Spend description for v4 transactions, or encoded once and shared between all Spend descriptions in a v5 transaction.

https://zips.z.cash/protocol/protocol.pdf#spendsandoutputs

This rule is also implemented in zebra_state::service::check::anchors and crate::transaction::serialize.

The “anchor encoding for v4 transactions” is implemented here.

impl ZcashSerialize for Spend<PerSpendAnchor>

fn zcash_serialize<W: Write>(&self, writer: W) -> Result<(), Error>

Write self to the given writer using the canonical format.

fn zcash_serialize_to_vec(&self) -> Result<Vec<u8>, Error>

Helper function to construct a vec to serialize the current struct into

fn zcash_serialized_size(&self) -> usize

Get the size of self by using a fake writer.

impl<AnchorV: AnchorVariant + PartialEq> Eq for Spend<AnchorV>

impl<AnchorV: AnchorVariant> StructuralPartialEq for Spend<AnchorV>