ZSA integration (step 7): Modify zebra-consensus to support Orchard ZSA

.github/workflows/ci-basic.yml

@@ -34,3 +34,5 @@ jobs:
         run: cargo doc --all-features --document-private-items
       - name: Run format check
         run: cargo fmt -- --check
+      - name: Run clippy
+        run: cargo clippy --workspace --all-features --all-targets -- -D warnings

zebra-chain/src/block/commitment.rs

@@ -125,7 +125,7 @@ impl Commitment {
             // NetworkUpgrade::current() returns the latest network upgrade that's activated at the provided height, so
             // on Regtest for heights above height 0, it could return NU6, and it's possible for the current network upgrade
             // to be NU6 (or Canopy, or any network upgrade above Heartwood) at the Heartwood activation height.
-            (Canopy | Nu5 | Nu6, activation_height)
+            (Canopy | Nu5 | Nu6 | Nu7, activation_height)
                 if height == activation_height
                     && Some(height) == Heartwood.activation_height(network) =>
             {
@@ -136,7 +136,7 @@ impl Commitment {
                 }
             }
             (Heartwood | Canopy, _) => Ok(ChainHistoryRoot(ChainHistoryMmrRootHash(bytes))),
-            (Nu5 | Nu6, _) => Ok(ChainHistoryBlockTxAuthCommitment(
+            (Nu5 | Nu6 | Nu7, _) => Ok(ChainHistoryBlockTxAuthCommitment(
                 ChainHistoryBlockTxAuthCommitmentHash(bytes),
             )),
         }

zebra-chain/src/history_tree.rs

@@ -102,7 +102,7 @@ impl NonEmptyHistoryTree {
                 )?;
                 InnerHistoryTree::PreOrchard(tree)
             }
-            NetworkUpgrade::Nu5 | NetworkUpgrade::Nu6 => {
+            NetworkUpgrade::Nu5 | NetworkUpgrade::Nu6 | NetworkUpgrade::Nu7 => {
                 let tree = Tree::<OrchardOnward>::new_from_cache(
                     network,
                     network_upgrade,
@@ -156,7 +156,7 @@ impl NonEmptyHistoryTree {
                 )?;
                 (InnerHistoryTree::PreOrchard(tree), entry)
             }
-            NetworkUpgrade::Nu5 | NetworkUpgrade::Nu6 => {
+            NetworkUpgrade::Nu5 | NetworkUpgrade::Nu6 | NetworkUpgrade::Nu7 => {
                 let (tree, entry) = Tree::<OrchardOnward>::new_from_block(
                     network,
                     block,

zebra-chain/src/orchard/commitment.rs

@@ -14,6 +14,8 @@ use halo2::{
 use lazy_static::lazy_static;
 use rand_core::{CryptoRng, RngCore};
 
+use orchard::note::AssetBase;
+
 use crate::{
     amount::Amount,
     error::RandError,
@@ -249,6 +251,15 @@ impl ValueCommitment {
         let v = pallas::Scalar::from(value);
         Self::from(*V * v + *R * rcv)
     }
+
+    /// Generate a new `ValueCommitment` from an existing `rcv on a `value` (ZSA version).
+    #[cfg(feature = "tx-v6")]
+    #[allow(non_snake_case)]
+    pub fn with_asset(rcv: pallas::Scalar, value: Amount, asset: &AssetBase) -> Self {
+        let v = pallas::Scalar::from(value);
+        let V_zsa = asset.cv_base();
+        Self::from(V_zsa * v + *R * rcv)
+    }
 }
 
 lazy_static! {

zebra-chain/src/orchard/orchard_flavor_ext.rs

@@ -9,7 +9,10 @@ use proptest_derive::Arbitrary;
 
 use orchard::{note_encryption::OrchardDomainCommon, orchard_flavor};
 
-use crate::serialization::{ZcashDeserialize, ZcashSerialize};
+use crate::{
+    orchard::ValueCommitment,
+    serialization::{ZcashDeserialize, ZcashSerialize},
+};
 
 #[cfg(feature = "tx-v6")]
 use crate::orchard_zsa::{Burn, NoBurn};
@@ -50,7 +53,13 @@ pub trait OrchardFlavorExt: Clone + Debug {
 
     /// A type representing a burn field for this protocol version.
     #[cfg(feature = "tx-v6")]
-    type BurnType: Clone + Debug + Default + ZcashDeserialize + ZcashSerialize + TestArbitrary;
+    type BurnType: Clone
+        + Debug
+        + Default
+        + ZcashDeserialize
+        + ZcashSerialize
+        + Into<ValueCommitment>
+        + TestArbitrary;
 }
 
 /// A structure representing a tag for Orchard protocol variant used for the transaction version `V5`.
@@ -78,6 +87,5 @@ impl OrchardFlavorExt for OrchardZSA {
     type Flavor = orchard_flavor::OrchardZSA;
     type EncryptedNote = note::EncryptedNote<{ Self::ENCRYPTED_NOTE_SIZE }>;
 
-    #[cfg(feature = "tx-v6")]
     type BurnType = Burn;
 }

zebra-chain/src/orchard/shielded_data.rs

@@ -119,7 +119,13 @@ impl<V: OrchardFlavorExt> ShieldedData<V> {
         let cv_balance: ValueCommitment =
             ValueCommitment::new(pallas::Scalar::zero(), self.value_balance);
 
+        #[cfg(not(feature = "tx-v6"))]
         let key_bytes: [u8; 32] = (cv - cv_balance).into();
+
+        // FIXME: use asset to create ValueCommitment here for burns and above for value_balance?
+        #[cfg(feature = "tx-v6")]
+        let key_bytes: [u8; 32] = (cv - cv_balance - self.burn.clone().into()).into();
+
         key_bytes.into()
     }
 
@@ -313,6 +319,9 @@ bitflags! {
         const ENABLE_SPENDS = 0b00000001;
         /// Enable creating new non-zero valued Orchard notes.
         const ENABLE_OUTPUTS = 0b00000010;
+        /// Enable ZSA transaction (otherwise all notes within actions must use native asset).
+        // FIXME: Should we use this flag explicitly anywhere in Zebra?
+        const ENABLE_ZSA = 0b00000100;
     }
 }
 

zebra-chain/src/orchard_zsa.rs

@@ -4,7 +4,10 @@
 #[cfg(any(test, feature = "proptest-impl"))]
 pub(crate) mod arbitrary;
 
-mod common;
+/// FIXME: feature = "proptest-impl" and pub are needed to access test vectors from another crates,
+/// remove it then
+#[cfg(any(test, feature = "proptest-impl"))]
+pub mod tests;
 
 mod burn;
 mod issuance;

zebra-chain/src/orchard_zsa/burn.rs

@@ -2,15 +2,34 @@
 
 use std::io;
 
+use halo2::pasta::pallas;
+
 use crate::{
     amount::Amount,
     block::MAX_BLOCK_BYTES,
-    serialization::{SerializationError, TrustedPreallocate, ZcashDeserialize, ZcashSerialize},
+    orchard::ValueCommitment,
+    serialization::{
+        ReadZcashExt, SerializationError, TrustedPreallocate, ZcashDeserialize, ZcashSerialize,
+    },
 };
 
 use orchard::{note::AssetBase, value::NoteValue};
 
-use super::common::ASSET_BASE_SIZE;
+// The size of the serialized AssetBase in bytes (used for TrustedPreallocate impls)
+pub(super) const ASSET_BASE_SIZE: u64 = 32;
+
+impl ZcashSerialize for AssetBase {
+    fn zcash_serialize<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
+        writer.write_all(&self.to_bytes())
+    }
+}
+
+impl ZcashDeserialize for AssetBase {
+    fn zcash_deserialize<R: io::Read>(mut reader: R) -> Result<Self, SerializationError> {
+        Option::from(AssetBase::from_bytes(&reader.read_32_bytes()?))
+            .ok_or_else(|| SerializationError::Parse("Invalid orchard_zsa AssetBase!"))
+    }
+}
 
 // Sizes of the serialized values for types in bytes (used for TrustedPreallocate impls)
 const AMOUNT_SIZE: u64 = 8;
@@ -93,6 +112,13 @@ impl<'de> serde::Deserialize<'de> for BurnItem {
 #[derive(Default, Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct NoBurn;
 
+impl From<NoBurn> for ValueCommitment {
+    fn from(_burn: NoBurn) -> ValueCommitment {
+        // FIXME: is there a simpler way to get zero ValueCommitment?
+        ValueCommitment::new(pallas::Scalar::zero(), Amount::zero())
+    }
+}
+
 impl ZcashSerialize for NoBurn {
     fn zcash_serialize<W: io::Write>(&self, mut _writer: W) -> Result<(), io::Error> {
         Ok(())
@@ -115,6 +141,18 @@ impl From<Vec<BurnItem>> for Burn {
     }
 }
 
+// FIXME: consider conversion from reference to Burn instead, to avoid using `clone` when it's called
+impl From<Burn> for ValueCommitment {
+    fn from(burn: Burn) -> ValueCommitment {
+        burn.0
+            .into_iter()
+            .map(|BurnItem(asset, amount)| {
+                ValueCommitment::with_asset(pallas::Scalar::zero(), amount, &asset)
+            })
+            .sum()
+    }
+}
+
 impl ZcashSerialize for Burn {
     fn zcash_serialize<W: io::Write>(&self, writer: W) -> Result<(), io::Error> {
         self.0.zcash_serialize(writer)