chain: move JoinSplit to sprout

zebra-chain/src/sapling.rs

@@ -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;

zebra-chain/src/sapling/tests.rs

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

zebra-chain/src/sapling/tests/arbitrary.rs

@@ -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 = ();

zebra-chain/src/sprout.rs

@@ -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;

zebra-chain/src/sprout/joinsplit.rs

@@ -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)?,
+            ],
+        })
+    }
+}

zebra-chain/src/sprout/tests.rs

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

zebra-chain/src/sprout/tests/arbitrary.rs

@@ -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>;
+}

zebra-chain/src/transaction.rs

@@ -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;

zebra-chain/src/transaction/joinsplit.rs

@@ -1,66 +1,10 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    amount::{Amount, NonNegative},
+    primitives::{ed25519, ZkSnarkProof},
-    primitives::{ed25519, x25519, ZkSnarkProof},
+    sprout::JoinSplit,
-    sprout,
 };
 
-/// 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.

zebra-chain/src/transaction/serialize.rs

@@ -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();

zebra-chain/src/transaction/tests/arbitrary.rs

@@ -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::{
+use super::super::{JoinSplitData, LockTime, Memo, ShieldedData, Transaction};
-    JoinSplit, 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>>(),
+            any::<sprout::JoinSplit<P>>(),
-            vec(any::<JoinSplit<P>>(), 0..10),
+            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 = ();