Upstream PR 471 (OrchardZSA) – internal review and fixes

.github/workflows/ci.yml

@@ -9,10 +9,11 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
+
     steps:
       - uses: actions/checkout@v4
       - name: Run tests
-        run: cargo test --verbose
+        run: cargo test --verbose --release
       - name: Verify working directory is clean
         run: git diff --exit-code
 

.gitignore

@@ -1,4 +1,5 @@
 /target
 **/*.rs.bk
 .vscode
+.idea
 action-circuit-layout.png

Cargo.toml

@@ -30,6 +30,7 @@ ff = { version = "0.13", default-features = false }
 fpe = { version = "0.6", default-features = false, features = ["alloc"] }
 group = "0.13"
 hex = { version = "0.4", default-features = false, features = ["alloc"] }
+secp256k1 = { version = "0.29", default-features = false, features = ["alloc", "rand"], optional = true }
 lazy_static = "1"
 memuse = { version = "0.2.2", default-features = false }
 pasta_curves = "0.5"
@@ -82,13 +83,14 @@ pprof = { version = "0.11", features = ["criterion", "flamegraph"] }
 bench = false
 
 [features]
-default = ["circuit", "multicore", "std"]
+default = ["circuit", "multicore", "std", "zsa-issuance"]
 std = ["core2/std", "group/wnaf-memuse", "reddsa/std"]
 circuit = ["dep:halo2_gadgets", "dep:halo2_proofs", "std"]
 unstable-frost = []
 multicore = ["halo2_proofs?/multicore"]
 dev-graph = ["halo2_proofs?/dev-graph", "image", "plotters"]
 test-dependencies = ["proptest", "rand/std"]
+zsa-issuance = ["dep:secp256k1"]
 
 [[bench]]
 name = "note_decryption"
@@ -109,5 +111,7 @@ debug = true
 debug = true
 
 [patch.crates-io]
+sinsemilla = { git = "https://github.com/zcash/sinsemilla", rev = "aabb707e862bc3d7b803c77d14e5a771bcee3e8c" }
+zcash_note_encryption = { git = "https://github.com/zcash/zcash_note_encryption", rev = "9f7e93d42cef839d02b9d75918117941d453f8cb" }
 halo2_gadgets = { git = "https://github.com/zcash/halo2", rev = "2308caf68c48c02468b66cfc452dad54e355e32f" }
 halo2_proofs = { git = "https://github.com/zcash/halo2", rev = "2308caf68c48c02468b66cfc452dad54e355e32f" }

README.md

@@ -1,6 +1,6 @@
 # orchard [![Crates.io](https://img.shields.io/crates/v/orchard.svg)](https://crates.io/crates/orchard) #
 
-Requires Rust 1.66+.
+Requires Rust 1.70+.
 
 ## Documentation
 

benches/circuit.rs

@@ -10,28 +10,43 @@ use orchard::{
     builder::{Builder, BundleType},
     circuit::{ProvingKey, VerifyingKey},
     keys::{FullViewingKey, Scope, SpendingKey},
+    note::AssetBase,
+    orchard_flavor::{OrchardVanilla, OrchardZSA},
     value::NoteValue,
     Anchor, Bundle,
 };
 use rand::rngs::OsRng;
 
-fn criterion_benchmark(c: &mut Criterion) {
+mod utils;
+
+use utils::OrchardFlavorBench;
+
+fn criterion_benchmark<FL: OrchardFlavorBench>(c: &mut Criterion) {
     let rng = OsRng;
 
     let sk = SpendingKey::from_bytes([7; 32]).unwrap();
     let recipient = FullViewingKey::from(&sk).address_at(0u32, Scope::External);
 
-    let vk = VerifyingKey::build();
-    let pk = ProvingKey::build();
+    let vk = VerifyingKey::build::<FL>();
+    let pk = ProvingKey::build::<FL>();
 
     let create_bundle = |num_recipients| {
-        let mut builder = Builder::new(BundleType::DEFAULT, Anchor::from_bytes([0; 32]).unwrap());
+        let mut builder = Builder::new(
+            BundleType::DEFAULT_VANILLA,
+            Anchor::from_bytes([0; 32]).unwrap(),
+        );
         for _ in 0..num_recipients {
             builder
-                .add_output(None, recipient, NoteValue::from_raw(10), [0; 512])
+                .add_output(
+                    None,
+                    recipient,
+                    NoteValue::from_raw(10),
+                    AssetBase::native(),
+                    [0; 512],
+                )
                 .unwrap();
         }
-        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap().0;
+        let bundle: Bundle<_, i64, FL> = builder.build(rng).unwrap().0;
 
         let instances: Vec<_> = bundle
             .actions()
@@ -45,23 +60,23 @@ fn criterion_benchmark(c: &mut Criterion) {
     let recipients_range = 1..=4;
 
     {
-        let mut group = c.benchmark_group("proving");
+        let mut group = FL::benchmark_group(c, "proving");
         group.sample_size(10);
         for num_recipients in recipients_range.clone() {
             let (bundle, instances) = create_bundle(num_recipients);
             group.bench_function(BenchmarkId::new("bundle", num_recipients), |b| {
                 b.iter(|| {
                     bundle
                         .authorization()
-                        .create_proof(&pk, &instances, rng)
+                        .create_proof::<FL>(&pk, &instances, rng)
                         .unwrap()
                 });
             });
         }
     }
 
     {
-        let mut group = c.benchmark_group("verifying");
+        let mut group = FL::benchmark_group(c, "verifying");
         for num_recipients in recipients_range {
             let (bundle, instances) = create_bundle(num_recipients);
             let bundle = bundle
@@ -78,15 +93,25 @@ fn criterion_benchmark(c: &mut Criterion) {
 }
 
 #[cfg(unix)]
-criterion_group! {
-    name = benches;
-    config = Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = criterion_benchmark
+fn create_config() -> Criterion {
+    Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)))
 }
+
 #[cfg(windows)]
+fn create_config() -> Criterion {
+    Criterion::default()
+}
+
 criterion_group! {
-    name = benches;
-    config = Criterion::default();
-    targets = criterion_benchmark
+    name = benches_vanilla;
+    config = create_config();
+    targets = criterion_benchmark::<OrchardVanilla>
 }
-criterion_main!(benches);
+
+criterion_group! {
+    name = benches_zsa;
+    config = create_config();
+    targets = criterion_benchmark::<OrchardZSA>
+}
+
+criterion_main!(benches_vanilla, benches_zsa);

benches/note_decryption.rs

@@ -3,7 +3,9 @@ use orchard::{
     builder::{Builder, BundleType},
     circuit::ProvingKey,
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendingKey},
-    note_encryption::{CompactAction, OrchardDomain},
+    note::AssetBase,
+    orchard_flavor::{OrchardVanilla, OrchardZSA},
+    primitives::{CompactAction, OrchardDomain},
     value::NoteValue,
     Anchor, Bundle,
 };
@@ -13,9 +15,13 @@ use zcash_note_encryption::{batch, try_compact_note_decryption, try_note_decrypt
 #[cfg(unix)]
 use pprof::criterion::{Output, PProfProfiler};
 
-fn bench_note_decryption(c: &mut Criterion) {
+mod utils;
+
+use utils::OrchardFlavorBench;
+
+fn bench_note_decryption<FL: OrchardFlavorBench>(c: &mut Criterion) {
     let rng = OsRng;
-    let pk = ProvingKey::build();
+    let pk = ProvingKey::build::<FL>();
 
     let fvk = FullViewingKey::from(&SpendingKey::from_bytes([7; 32]).unwrap());
     let valid_ivk = fvk.to_ivk(Scope::External);
@@ -44,16 +50,31 @@ fn bench_note_decryption(c: &mut Criterion) {
         .collect();
 
     let bundle = {
-        let mut builder = Builder::new(BundleType::DEFAULT, Anchor::from_bytes([0; 32]).unwrap());
+        let mut builder = Builder::new(
+            BundleType::DEFAULT_VANILLA,
+            Anchor::from_bytes([0; 32]).unwrap(),
+        );
         // The builder pads to two actions, and shuffles their order. Add two recipients
         // so the first action is always decryptable.
         builder
-            .add_output(None, recipient, NoteValue::from_raw(10), [0; 512])
+            .add_output(
+                None,
+                recipient,
+                NoteValue::from_raw(10),
+                AssetBase::native(),
+                [0; 512],
+            )
             .unwrap();
         builder
-            .add_output(None, recipient, NoteValue::from_raw(10), [0; 512])
+            .add_output(
+                None,
+                recipient,
+                NoteValue::from_raw(10),
+                AssetBase::native(),
+                [0; 512],
+            )
             .unwrap();
-        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap().0;
+        let bundle: Bundle<_, i64, FL> = builder.build(rng).unwrap().0;
         bundle
             .create_proof(&pk, rng)
             .unwrap()
@@ -65,7 +86,7 @@ fn bench_note_decryption(c: &mut Criterion) {
     let domain = OrchardDomain::for_action(action);
 
     let compact = {
-        let mut group = c.benchmark_group("note-decryption");
+        let mut group = FL::benchmark_group(c, "note-decryption");
         group.throughput(Throughput::Elements(1));
 
         group.bench_function("valid", |b| {
@@ -87,7 +108,7 @@ fn bench_note_decryption(c: &mut Criterion) {
     };
 
     {
-        let mut group = c.benchmark_group("compact-note-decryption");
+        let mut group = FL::benchmark_group(c, "compact-note-decryption");
         group.throughput(Throughput::Elements(invalid_ivks.len() as u64));
         group.bench_function("invalid", |b| {
             b.iter(|| {
@@ -114,7 +135,7 @@ fn bench_note_decryption(c: &mut Criterion) {
             })
             .collect();
 
-        let mut group = c.benchmark_group("batch-note-decryption");
+        let mut group = FL::benchmark_group(c, "batch-note-decryption");
 
         for size in [10, 50, 100] {
             group.throughput(Throughput::Elements((ivks * size) as u64));
@@ -141,11 +162,25 @@ fn bench_note_decryption(c: &mut Criterion) {
 }
 
 #[cfg(unix)]
+fn create_config() -> Criterion {
+    Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)))
+}
+
+#[cfg(windows)]
+fn create_config() -> Criterion {
+    Criterion::default()
+}
+
 criterion_group! {
-    name = benches;
-    config = Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = bench_note_decryption
+    name = benches_vanilla;
+    config = create_config();
+    targets = bench_note_decryption::<OrchardVanilla>
 }
-#[cfg(not(unix))]
-criterion_group!(benches, bench_note_decryption);
-criterion_main!(benches);
+
+criterion_group! {
+    name = benches_zsa;
+    config = create_config();
+    targets = bench_note_decryption::<OrchardZSA>
+}
+
+criterion_main!(benches_vanilla, benches_zsa);

benches/utils.rs

@@ -0,0 +1,28 @@
+use criterion::{measurement::Measurement, BenchmarkGroup, Criterion};
+
+use orchard::orchard_flavor::{OrchardFlavor, OrchardVanilla, OrchardZSA};
+
+pub(crate) trait OrchardFlavorBench: OrchardFlavor {
+    fn benchmark_group<'a, M: Measurement>(
+        c: &'a mut Criterion<M>,
+        group_name: &str,
+    ) -> BenchmarkGroup<'a, M>;
+}
+
+impl OrchardFlavorBench for OrchardVanilla {
+    fn benchmark_group<'a, M: Measurement>(
+        c: &'a mut Criterion<M>,
+        group_name: &str,
+    ) -> BenchmarkGroup<'a, M> {
+        c.benchmark_group(format!("[OrchardVanilla] {}", group_name))
+    }
+}
+
+impl OrchardFlavorBench for OrchardZSA {
+    fn benchmark_group<'a, M: Measurement>(
+        c: &'a mut Criterion<M>,
+        group_name: &str,
+    ) -> BenchmarkGroup<'a, M> {
+        c.benchmark_group(format!("[OrchardZSA] {}", group_name))
+    }
+}

book/src/SUMMARY.md

@@ -18,4 +18,5 @@
   - [Circuit](design/circuit.md)
     - [Gadgets](design/circuit/gadgets.md)
     - [CommitIvk](design/circuit/commit-ivk.md)
-    - [NoteCommit](design/circuit/note-commit.md)
+    - [Orchard NoteCommit](design/circuit/note-commit.md)
+    - [OrchardZSA NoteCommit](design/circuit/zsa-note-commit.md)