Struct ShieldedData

pub struct ShieldedData {
    pub flags: Flags,
    pub value_balance: Amount,
    pub shared_anchor: Root,
    pub proof: Halo2Proof,
    pub actions: AtLeastOne<AuthorizedAction>,
    pub binding_sig: Signature<Binding>,
}

A bundle of Action descriptions and signature data.

Fields

flags: Flags

The orchard flags for this transaction. Denoted as flagsOrchard in the spec.

value_balance: Amount

The net value of Orchard spends minus outputs. Denoted as valueBalanceOrchard in the spec.

shared_anchor: Root

The shared anchor for all Spends in this transaction. Denoted as anchorOrchard in the spec.

proof: Halo2Proof

The aggregated zk-SNARK proof for all the actions in this transaction. Denoted as proofsOrchard in the spec.

actions: AtLeastOne<AuthorizedAction>

The Orchard Actions, in the order they appear in the transaction. Denoted as vActionsOrchard and vSpendAuthSigsOrchard in the spec.

binding_sig: Signature<Binding>

A signature on the transaction sighash. Denoted as bindingSigOrchard in the spec.

Implementations

impl ShieldedData

pub fn actions(&self) -> impl Iterator<Item = &Action>

Iterate over the Actions for the AuthorizedActions in this transaction, in the order they appear in it.

pub fn nullifiers(&self) -> impl Iterator<Item = &Nullifier>

Collect the Nullifiers for this transaction.

pub fn binding_verification_key(&self) -> VerificationKeyBytes<Binding>

Calculate the Action binding verification key.

Getting the binding signature validating key from the Action description value commitments and the balancing value implicitly checks that the balancing value is consistent with the value transferred in the Action descriptions, but also proves that the signer knew the randomness used for the Action value commitments, which prevents replays of Action descriptions that perform an output. In Orchard, all Action descriptions have a spend authorization signature, therefore the proof of knowledge of the value commitment randomness is less important, but stills provides defense in depth, and reduces the differences between Orchard and Sapling.

The net value of Orchard spends minus outputs in a transaction is called the balancing value, measured in zatoshi as a signed integer cv_balance.

Consistency of cv_balance with the value commitments in Action descriptions is enforced by the binding signature.

Instead of generating a key pair at random, we generate it as a function of the value commitments in the Action descriptions of the transaction, and the balancing value.

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

pub fn value_balance(&self) -> Amount<NegativeAllowed>

Provide access to the value_balance field of the shielded data.

Needed to calculate the sapling value balance.

pub fn note_commitments(&self) -> impl Iterator<Item = &Base>

Collect the cm_x’s for this transaction, if it contains Actions with outputs, in the order they appear in the transaction.

Trait Implementations

impl Arbitrary for ShieldedData

type Parameters = ()

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

type Strategy = BoxedStrategy<ShieldedData>

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 Clone for ShieldedData

fn clone(&self) -> ShieldedData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ShieldedData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShieldedData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ShieldedData

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

Formats the value using the given formatter.

impl PartialEq for ShieldedData

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ZcashSerialize for ShieldedData

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 Eq for ShieldedData

impl StructuralPartialEq for ShieldedData