Struct zebra_chain::sprout::JoinSplit

pub struct JoinSplit<P: ZkSnarkProof> {
    pub vpub_old: Amount<NonNegative>,
    pub vpub_new: Amount<NonNegative>,
    pub anchor: Root,
    pub nullifiers: [Nullifier; 2],
    pub commitments: [NoteCommitment; 2],
    pub ephemeral_key: PublicKey,
    pub random_seed: RandomSeed,
    pub vmacs: [Mac; 2],
    pub zkproof: P,
    pub enc_ciphertexts: [EncryptedNote; 2],
}

A JoinSplit Description, as described in protocol specification §7.2.

Fields

vpub_old: Amount<NonNegative>

A value that the JoinSplit transfer removes from the transparent value pool.

vpub_new: Amount<NonNegative>

A value that the JoinSplit transfer inserts into the transparent value pool.

anchor: Root

A root of the Sprout note commitment tree at some block height in the past, or the root produced by a previous JoinSplit transfer in this transaction.

nullifiers: [Nullifier; 2]

A nullifier for the input notes.

commitments: [NoteCommitment; 2]

A note commitment for this output note.

ephemeral_key: PublicKey

An X25519 public key.

random_seed: RandomSeed

A 256-bit seed that must be chosen independently at random for each JoinSplit description.

vmacs: [Mac; 2]

A message authentication tag.

zkproof: P

A ZK JoinSplit proof, either a Groth16Proof or a Bctv14Proof.

enc_ciphertexts: [EncryptedNote; 2]

A ciphertext component for this output note.

Implementations

impl<P: ZkSnarkProof> JoinSplit<P>

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

Return the sprout value balance, the change in the transaction value pool due to this sprout JoinSplit.

https://zebra.zfnd.org/dev/rfcs/0012-value-pools.html#definitions

See sprout_value_balance for details.

Trait Implementations

impl<P: ZkSnarkProof + Arbitrary + 'static> Arbitrary for JoinSplit<P>

type Parameters = ()

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

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.

type Strategy = BoxedStrategy<JoinSplit<P>>

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

fn arbitrary() -> Self::Strategy

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

impl<P: Clone + ZkSnarkProof> Clone for JoinSplit<P>

fn clone(&self) -> JoinSplit<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: ZkSnarkProof> Debug for JoinSplit<P>

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for JoinSplit<P>

where P: ZkSnarkProof,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: PartialEq + ZkSnarkProof> PartialEq for JoinSplit<P>

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

where P: ZkSnarkProof,

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 JoinSplit<Bctv14Proof>

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 TrustedPreallocate for JoinSplit<Groth16Proof>

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<P: ZkSnarkProof> ZcashDeserialize for JoinSplit<P>

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

Try to read self from the given reader.

impl<P: ZkSnarkProof> ZcashSerialize for JoinSplit<P>

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<P: Eq + ZkSnarkProof> Eq for JoinSplit<P>

impl<P: ZkSnarkProof> StructuralPartialEq for JoinSplit<P>