octo
/
Zebra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chain: move JoinSplit to sprout

This commit is contained in:
Henry de Valence 2020-08-17 02:06:38 -07:00
parent 1fc859d0c5
commit 5c176d2f96
11 changed files with 199 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
zebra-chain/src/sapling.rs
View File

@ -1,10 +1,10 @@
//! Sapling-related functionality.
mod spend;
mod output;
mod spend;
pub use spend::Spend;
pub use output::Output;
pub use spend::Spend;
// XXX clean up these modules
@ -15,4 +15,4 @@ pub mod note;
pub mod tree;
#[cfg(test)]
mod tests;
mod tests;

2
zebra-chain/src/sapling/tests.rs
View File

@ -1 +1 @@
mod arbitrary;
mod arbitrary;

3
zebra-chain/src/sapling/tests/arbitrary.rs
View File

@ -1,9 +1,8 @@
use proptest::{arbitrary::any, array, collection::vec, prelude::*};
use crate::primitives::Groth16Proof;
use super::super::{Spend, Output, keys, tree, commitment, note};
use super::super::{commitment, keys, note, tree, Output, Spend};
impl Arbitrary for Spend {
type Parameters = ();

8
zebra-chain/src/sprout.rs
View File

@ -1,7 +1,15 @@
//! Sprout-related functionality.
mod joinsplit;
pub use joinsplit::JoinSplit;
// XXX clean up these modules
pub mod address;
pub mod commitment;
pub mod keys;
pub mod note;
pub mod tree;
#[cfg(test)]
mod tests;

118
zebra-chain/src/sprout/joinsplit.rs Normal file
View File

@ -0,0 +1,118 @@
use std::{convert::TryInto, io};
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use serde::{Deserialize, Serialize};
use crate::{
amount::{Amount, NonNegative},
primitives::{x25519, ZkSnarkProof},
serialization::{
ReadZcashExt, SerializationError, WriteZcashExt, ZcashDeserialize, ZcashSerialize,
},
};
use super::{commitment, note, tree};
/// A _JoinSplit Description_, as described in [protocol specification §7.2][ps].
///
/// [ps]: https://zips.z.cash/protocol/protocol.pdf#joinsplitencoding
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct JoinSplit<P: ZkSnarkProof> {
/// A value that the JoinSplit transfer removes from the transparent value
/// pool.
pub vpub_old: Amount<NonNegative>,
/// A value that the JoinSplit transfer inserts into the transparent value
/// pool.
///
pub vpub_new: Amount<NonNegative>,
/// 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.
pub anchor: tree::NoteTreeRootHash,
/// A nullifier for the input notes.
pub nullifiers: [note::Nullifier; 2],
/// A note commitment for this output note.
pub commitments: [commitment::NoteCommitment; 2],
/// An X25519 public key.
pub ephemeral_key: x25519::PublicKey,
/// A 256-bit seed that must be chosen independently at random for each
/// JoinSplit description.
pub random_seed: [u8; 32],
/// A message authentication tag.
pub vmacs: [note::MAC; 2],
/// A ZK JoinSplit proof, either a
/// [`Groth16Proof`](crate::primitives::Groth16Proof) or a
/// [`Bctv14Proof`](crate::primitives::Bctv14Proof).
#[serde(bound(serialize = "P: ZkSnarkProof", deserialize = "P: ZkSnarkProof"))]
pub zkproof: P,
/// A ciphertext component for this output note.
pub enc_ciphertexts: [note::EncryptedCiphertext; 2],
}
// Because x25519_dalek::PublicKey does not impl PartialEq
impl<P: ZkSnarkProof> PartialEq for JoinSplit<P> {
fn eq(&self, other: &Self) -> bool {
self.vpub_old == other.vpub_old
&& self.vpub_new == other.vpub_new
&& self.anchor == other.anchor
&& self.nullifiers == other.nullifiers
&& self.commitments == other.commitments
&& self.ephemeral_key.as_bytes() == other.ephemeral_key.as_bytes()
&& self.random_seed == other.random_seed
&& self.vmacs == other.vmacs
&& self.zkproof == other.zkproof
&& self.enc_ciphertexts == other.enc_ciphertexts
}
}
// Because x25519_dalek::PublicKey does not impl Eq
impl<P: ZkSnarkProof> Eq for JoinSplit<P> {}
impl<P: ZkSnarkProof> ZcashSerialize for JoinSplit<P> {
fn zcash_serialize<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
writer.write_u64::<LittleEndian>(self.vpub_old.into())?;
writer.write_u64::<LittleEndian>(self.vpub_new.into())?;
writer.write_32_bytes(&self.anchor.into())?;
writer.write_32_bytes(&self.nullifiers[0].into())?;
writer.write_32_bytes(&self.nullifiers[1].into())?;
writer.write_32_bytes(&self.commitments[0].into())?;
writer.write_32_bytes(&self.commitments[1].into())?;
writer.write_all(&self.ephemeral_key.as_bytes()[..])?;
writer.write_all(&self.random_seed[..])?;
self.vmacs[0].zcash_serialize(&mut writer)?;
self.vmacs[1].zcash_serialize(&mut writer)?;
self.zkproof.zcash_serialize(&mut writer)?;
self.enc_ciphertexts[0].zcash_serialize(&mut writer)?;
self.enc_ciphertexts[1].zcash_serialize(&mut writer)?;
Ok(())
}
}
impl<P: ZkSnarkProof> ZcashDeserialize for JoinSplit<P> {
fn zcash_deserialize<R: io::Read>(mut reader: R) -> Result<Self, SerializationError> {
Ok(JoinSplit::<P> {
vpub_old: reader.read_u64::<LittleEndian>()?.try_into()?,
vpub_new: reader.read_u64::<LittleEndian>()?.try_into()?,
anchor: tree::NoteTreeRootHash::from(reader.read_32_bytes()?),
nullifiers: [
reader.read_32_bytes()?.into(),
reader.read_32_bytes()?.into(),
],
commitments: [
commitment::NoteCommitment::from(reader.read_32_bytes()?),
commitment::NoteCommitment::from(reader.read_32_bytes()?),
],
ephemeral_key: x25519_dalek::PublicKey::from(reader.read_32_bytes()?),
random_seed: reader.read_32_bytes()?,
vmacs: [
note::MAC::zcash_deserialize(&mut reader)?,
note::MAC::zcash_deserialize(&mut reader)?,
],
zkproof: P::zcash_deserialize(&mut reader)?,
enc_ciphertexts: [
note::EncryptedCiphertext::zcash_deserialize(&mut reader)?,
note::EncryptedCiphertext::zcash_deserialize(&mut reader)?,
],
})
}
}

1
zebra-chain/src/sprout/tests.rs Normal file
View File

@ -0,0 +1 @@
mod arbitrary;

57
zebra-chain/src/sprout/tests/arbitrary.rs Normal file
View File

@ -0,0 +1,57 @@
use proptest::{arbitrary::any, array, prelude::*};
use crate::{
amount::{Amount, NonNegative},
primitives::ZkSnarkProof,
};
use super::super::{commitment, note, tree, JoinSplit};
impl<P: ZkSnarkProof + Arbitrary + 'static> Arbitrary for JoinSplit<P> {
type Parameters = ();
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
(
any::<Amount<NonNegative>>(),
any::<Amount<NonNegative>>(),
any::<tree::NoteTreeRootHash>(),
array::uniform2(any::<note::Nullifier>()),
array::uniform2(any::<commitment::NoteCommitment>()),
array::uniform32(any::<u8>()),
array::uniform32(any::<u8>()),
array::uniform2(any::<note::MAC>()),
any::<P>(),
array::uniform2(any::<note::EncryptedCiphertext>()),
)
.prop_map(
|(
vpub_old,
vpub_new,
anchor,
nullifiers,
commitments,
ephemeral_key_bytes,
random_seed,
vmacs,
zkproof,
enc_ciphertexts,
)| {
Self {
vpub_old,
vpub_new,
anchor,
nullifiers,
commitments,
ephemeral_key: x25519_dalek::PublicKey::from(ephemeral_key_bytes),
random_seed,
vmacs,
zkproof,
enc_ciphertexts,
}
},
)
.boxed()
}
type Strategy = BoxedStrategy<Self>;
}

2
zebra-chain/src/transaction.rs
View File

@ -13,7 +13,7 @@ mod shielded_data;
mod tests;
pub use hash::TransactionHash;
pub use joinsplit::{JoinSplit, JoinSplitData};
pub use joinsplit::JoinSplitData;
pub use lock_time::LockTime;
pub use memo::Memo;
pub use shielded_data::ShieldedData;

62
zebra-chain/src/transaction/joinsplit.rs
View File

@ -1,66 +1,10 @@
use serde::{Deserialize, Serialize};
use crate::{
amount::{Amount, NonNegative},
primitives::{ed25519, x25519, ZkSnarkProof},
sprout,
primitives::{ed25519, ZkSnarkProof},
sprout::JoinSplit,
};
/// A _JoinSplit Description_, as described in [protocol specification §7.2][ps].
///
/// [ps]: https://zips.z.cash/protocol/protocol.pdf#joinsplitencoding
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct JoinSplit<P: ZkSnarkProof> {
/// A value that the JoinSplit transfer removes from the transparent value
/// pool.
pub vpub_old: Amount<NonNegative>,
/// A value that the JoinSplit transfer inserts into the transparent value
/// pool.
///
pub vpub_new: Amount<NonNegative>,
/// 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.
pub anchor: sprout::tree::NoteTreeRootHash,
/// A nullifier for the input notes.
pub nullifiers: [sprout::note::Nullifier; 2],
/// A note commitment for this output note.
pub commitments: [sprout::commitment::NoteCommitment; 2],
/// An X25519 public key.
pub ephemeral_key: x25519::PublicKey,
/// A 256-bit seed that must be chosen independently at random for each
/// JoinSplit description.
pub random_seed: [u8; 32],
/// A message authentication tag.
pub vmacs: [sprout::note::MAC; 2],
/// A ZK JoinSplit proof, either a
/// [`Groth16Proof`](crate::primitives::Groth16Proof) or a
/// [`Bctv14Proof`](crate::primitives::Bctv14Proof).
#[serde(bound(serialize = "P: ZkSnarkProof", deserialize = "P: ZkSnarkProof"))]
pub zkproof: P,
/// A ciphertext component for this output note.
pub enc_ciphertexts: [sprout::note::EncryptedCiphertext; 2],
}
// Because x25519_dalek::PublicKey does not impl PartialEq
impl<P: ZkSnarkProof> PartialEq for JoinSplit<P> {
fn eq(&self, other: &Self) -> bool {
self.vpub_old == other.vpub_old
&& self.vpub_new == other.vpub_new
&& self.anchor == other.anchor
&& self.nullifiers == other.nullifiers
&& self.commitments == other.commitments
&& self.ephemeral_key.as_bytes() == other.ephemeral_key.as_bytes()
&& self.random_seed == other.random_seed
&& self.vmacs == other.vmacs
&& self.zkproof == other.zkproof
&& self.enc_ciphertexts == other.enc_ciphertexts
}
}
// Because x25519_dalek::PublicKey does not impl Eq
impl<P: ZkSnarkProof> Eq for JoinSplit<P> {}
/// A bundle of JoinSplit descriptions and signature data.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct JoinSplitData<P: ZkSnarkProof> {
@ -68,7 +12,7 @@ pub struct JoinSplitData<P: ZkSnarkProof> {
///
/// Storing this separately from `rest` ensures that it is impossible
/// to construct an invalid `JoinSplitData` with no `JoinSplit`s.
///
///`
/// However, it's not necessary to access or process `first` and `rest`
/// separately, as the [`JoinSplitData::joinsplits`] method provides an
/// iterator over all of the `JoinSplit`s.

54
zebra-chain/src/transaction/serialize.rs
View File

@ -31,56 +31,6 @@ impl ZcashDeserialize for jubjub::Fq {
}
}
}
impl<P: ZkSnarkProof> ZcashSerialize for JoinSplit<P> {
fn zcash_serialize<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
writer.write_u64::<LittleEndian>(self.vpub_old.into())?;
writer.write_u64::<LittleEndian>(self.vpub_new.into())?;
writer.write_32_bytes(&self.anchor.into())?;
writer.write_32_bytes(&self.nullifiers[0].into())?;
writer.write_32_bytes(&self.nullifiers[1].into())?;
writer.write_32_bytes(&self.commitments[0].into())?;
writer.write_32_bytes(&self.commitments[1].into())?;
writer.write_all(&self.ephemeral_key.as_bytes()[..])?;
writer.write_all(&self.random_seed[..])?;
self.vmacs[0].zcash_serialize(&mut writer)?;
self.vmacs[1].zcash_serialize(&mut writer)?;
self.zkproof.zcash_serialize(&mut writer)?;
self.enc_ciphertexts[0].zcash_serialize(&mut writer)?;
self.enc_ciphertexts[1].zcash_serialize(&mut writer)?;
Ok(())
}
}
impl<P: ZkSnarkProof> ZcashDeserialize for JoinSplit<P> {
fn zcash_deserialize<R: io::Read>(mut reader: R) -> Result<Self, SerializationError> {
Ok(JoinSplit::<P> {
vpub_old: reader.read_u64::<LittleEndian>()?.try_into()?,
vpub_new: reader.read_u64::<LittleEndian>()?.try_into()?,
anchor: sprout::tree::NoteTreeRootHash::from(reader.read_32_bytes()?),
nullifiers: [
reader.read_32_bytes()?.into(),
reader.read_32_bytes()?.into(),
],
commitments: [
sprout::commitment::NoteCommitment::from(reader.read_32_bytes()?),
sprout::commitment::NoteCommitment::from(reader.read_32_bytes()?),
],
ephemeral_key: x25519_dalek::PublicKey::from(reader.read_32_bytes()?),
random_seed: reader.read_32_bytes()?,
vmacs: [
sprout::note::MAC::zcash_deserialize(&mut reader)?,
sprout::note::MAC::zcash_deserialize(&mut reader)?,
],
zkproof: P::zcash_deserialize(&mut reader)?,
enc_ciphertexts: [
sprout::note::EncryptedCiphertext::zcash_deserialize(&mut reader)?,
sprout::note::EncryptedCiphertext::zcash_deserialize(&mut reader)?,
],
})
}
}
impl<P: ZkSnarkProof> ZcashSerialize for JoinSplitData<P> {
fn zcash_serialize<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
writer.write_compactsize(self.joinsplits().count() as u64)?;
@ -99,10 +49,10 @@ impl<P: ZkSnarkProof> ZcashDeserialize for Option<JoinSplitData<P>> {
match num_joinsplits {
0 => Ok(None),
n => {
let first = JoinSplit::zcash_deserialize(&mut reader)?;
let first = sprout::JoinSplit::zcash_deserialize(&mut reader)?;
let mut rest = Vec::with_capacity((n - 1) as usize);
for _ in 0..(n - 1) {
rest.push(JoinSplit::zcash_deserialize(&mut reader)?);
rest.push(sprout::JoinSplit::zcash_deserialize(&mut reader)?);
}
let pub_key = reader.read_32_bytes()?.into();
let sig = reader.read_64_bytes()?.into();

60
zebra-chain/src/transaction/tests/arbitrary.rs
View File

@ -3,15 +3,13 @@ use futures::future::Either;
use proptest::{arbitrary::any, array, collection::vec, option, prelude::*};
use crate::{
amount::{Amount, NonNegative},
amount::Amount,
block,
primitives::{Bctv14Proof, Groth16Proof, ZkSnarkProof},
sapling, sprout, transparent,
};
use super::super::{
JoinSplit, JoinSplitData, LockTime, Memo, ShieldedData, Transaction,
};
use super::super::{JoinSplitData, LockTime, Memo, ShieldedData, Transaction};
impl Transaction {
pub fn v1_strategy() -> impl Strategy<Value = Self> {
@ -131,62 +129,13 @@ impl Arbitrary for LockTime {
type Strategy = BoxedStrategy<Self>;
}
impl<P: ZkSnarkProof + Arbitrary + 'static> Arbitrary for JoinSplit<P> {
type Parameters = ();
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
(
any::<Amount<NonNegative>>(),
any::<Amount<NonNegative>>(),
any::<sprout::tree::NoteTreeRootHash>(),
array::uniform2(any::<sprout::note::Nullifier>()),
array::uniform2(any::<sprout::commitment::NoteCommitment>()),
array::uniform32(any::<u8>()),
array::uniform32(any::<u8>()),
array::uniform2(any::<sprout::note::MAC>()),
any::<P>(),
array::uniform2(any::<sprout::note::EncryptedCiphertext>()),
)
.prop_map(
|(
vpub_old,
vpub_new,
anchor,
nullifiers,
commitments,
ephemeral_key_bytes,
random_seed,
vmacs,
zkproof,
enc_ciphertexts,
)| {
Self {
vpub_old,
vpub_new,
anchor,
nullifiers,
commitments,
ephemeral_key: x25519_dalek::PublicKey::from(ephemeral_key_bytes),
random_seed,
vmacs,
zkproof,
enc_ciphertexts,
}
},
)
.boxed()
}
type Strategy = BoxedStrategy<Self>;
}
impl<P: ZkSnarkProof + Arbitrary + 'static> Arbitrary for JoinSplitData<P> {
type Parameters = ();
fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
(
any::<JoinSplit<P>>(),
vec(any::<JoinSplit<P>>(), 0..10),
any::<sprout::JoinSplit<P>>(),
vec(any::<sprout::JoinSplit<P>>(), 0..10),
array::uniform32(any::<u8>()),
vec(any::<u8>(), 64),
)
@ -235,7 +184,6 @@ impl Arbitrary for ShieldedData {
type Strategy = BoxedStrategy<Self>;
}
impl Arbitrary for Transaction {
type Parameters = ();