Add a public bundle construction function & use it in the builder.

CHANGELOG.md

@@ -7,14 +7,30 @@ and this project adheres to Rust's notion of
 
 ## [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

benches/circuit.rs

@@ -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_output(None, recipient, NoteValue::from_raw(10), None)
                 .unwrap();
         }
-        let bundle: Bundle<_, i64> = builder.build(rng, &BundleType::Transactional).unwrap();
+        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap();
 
         let instances: Vec<_> = bundle
             .actions()

benches/note_decryption.rs

@@ -45,10 +45,10 @@ 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
@@ -57,7 +57,7 @@ fn bench_note_decryption(c: &mut Criterion) {
         builder
             .add_output(None, recipient, NoteValue::from_raw(10), None)
             .unwrap();
-        let bundle: Bundle<_, i64> = builder.build(rng, &BundleType::Transactional).unwrap();
+        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap();
         bundle
             .create_proof(&pk, rng)
             .unwrap()