Add a public bundle-builder function as an alternative to the mutable builder.

CHANGELOG.md

@@ -6,6 +6,31 @@ and this project adheres to Rust's notion of
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- `orchard::builder::bundle`
+- `orchard::builder::BundleType`
+- `orchard::builder::OutputInfo`
+- `orchard::bundle::Flags::{ENABLED, SPENDS_DISABLED, OUTPUTS_DISABLED}`
+
+### Changed
+- `orchard::builder::Builder::new` now takes the bundle type to be used
+  in bundle construction, instead of taking the flags and anchor separately.
+- `orchard::builder::Builder::add_recipient` has been renamed to `add_output`
+  in order to clarify than more than one output of a given transaction may be
+  sent to the same recipient.
+- `orchard::builder::Builder::build` now takes an additional `BundleType` argument
+  that specifies how actions should be padded, instead of using hardcoded padding.
+  It also now returns a `Result<Option<Bundle<...>>, ...>` instead of a 
+  `Result<Bundle<...>, ...>`.
+- `orchard::builder::BuildError` has additional variants:
+  - `SpendsDisabled`
+  - `OutputsDisabled`
+  - `AnchorMismatch`
+- `orchard::builder::SpendInfo::new` now returns a `Result<SpendInfo, SpendError>`
+  instead of an `Option`.
+
+### Removed
+- `orchard::bundle::Flags::from_parts`
 
 ## [0.6.0] - 2023-09-08
 ### Changed
@@ -22,8 +47,8 @@ and this project adheres to Rust's notion of
 - `orchard::builder`:
   - `{SpendInfo::new, InputView, OutputView}`
   - `Builder::{spends, outputs}`
-  - `SpendError` 
-  - `OutputError` 
+  - `SpendError`
+  - `OutputError`
 
 ### Changed
 - MSRV is now 1.60.0.

benches/circuit.rs

@@ -7,7 +7,7 @@ use criterion::{BenchmarkId, Criterion};
 use pprof::criterion::{Output, PProfProfiler};
 
 use orchard::{
-    builder::Builder,
+    builder::{Builder, BundleType},
     bundle::Flags,
     circuit::{ProvingKey, VerifyingKey},
     keys::{FullViewingKey, Scope, SpendingKey},
@@ -26,16 +26,16 @@ fn criterion_benchmark(c: &mut Criterion) {
     let pk = ProvingKey::build();
 
     let create_bundle = |num_recipients| {
-        let mut builder = Builder::new(
-            Flags::from_parts(true, true),
+        let mut builder = Builder::new(BundleType::Transactional(
+            Flags::ENABLED,
             Anchor::from_bytes([0; 32]).unwrap(),
-        );
+        ));
         for _ in 0..num_recipients {
             builder
-                .add_recipient(None, recipient, NoteValue::from_raw(10), None)
+                .add_output(None, recipient, NoteValue::from_raw(10), None)
                 .unwrap();
         }
-        let bundle: Bundle<_, i64> = builder.build(rng).unwrap();
+        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap();
 
         let instances: Vec<_> = bundle
             .actions()

benches/note_decryption.rs

@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use orchard::{
-    builder::Builder,
+    builder::{Builder, BundleType},
     bundle::Flags,
     circuit::ProvingKey,
     keys::{FullViewingKey, PreparedIncomingViewingKey, Scope, SpendingKey},
@@ -45,19 +45,19 @@ fn bench_note_decryption(c: &mut Criterion) {
         .collect();
 
     let bundle = {
-        let mut builder = Builder::new(
-            Flags::from_parts(true, true),
+        let mut builder = Builder::new(BundleType::Transactional(
+            Flags::ENABLED,
             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_recipient(None, recipient, NoteValue::from_raw(10), None)
+            .add_output(None, recipient, NoteValue::from_raw(10), None)
             .unwrap();
         builder
-            .add_recipient(None, recipient, NoteValue::from_raw(10), None)
+            .add_output(None, recipient, NoteValue::from_raw(10), None)
             .unwrap();
-        let bundle: Bundle<_, i64> = builder.build(rng).unwrap();
+        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap();
         bundle
             .create_proof(&pk, rng)
             .unwrap()