Struct GenericJoinSplit 

pub struct GenericJoinSplit {
    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: Option<Vec<u8>>,
    pub enc_ciphertexts: [EncryptedNote; 2],
}

The same as JoinSplit but with a serialized proof, so that the type isn’t generic anymore.

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: Option<Vec<u8>>

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

enc_ciphertexts: [EncryptedNote; 2]

A ciphertext component for this output note.

Trait Implementations

impl Clone for GenericJoinSplit

fn clone(&self) -> GenericJoinSplit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for GenericJoinSplit

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P> From<JoinSplit<P>> for GenericJoinSplit

where P: ZkSnarkProof,

fn from(val: JoinSplit<P>) -> Self

Converts to this type from the input type.

impl PartialEq for GenericJoinSplit

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for GenericJoinSplit

impl StructuralPartialEq for GenericJoinSplit