Modify builder API to return a Result<Option<Bundle<...>>, ...>

CHANGELOG.md

@@ -13,19 +13,21 @@ and this project adheres to Rust's notion of
 - `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.
-- `orchard::builder::SpendInfo::new` now returns a `Result<SpendInfo, SpendError>`
-  instead of an `Option`.
-- `orchard::builder::Builder::new` now takes the bundle type to be used
-  in bundle construction, instead of taking the flags and anchor separately.
+  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`

benches/circuit.rs

@@ -35,7 +35,7 @@ fn criterion_benchmark(c: &mut Criterion) {
                 .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

@@ -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).unwrap();
+        let bundle: Bundle<_, i64> = builder.build(rng).unwrap().unwrap();
         bundle
             .create_proof(&pk, rng)
             .unwrap()

src/builder.rs

@@ -333,7 +333,7 @@ pub fn bundle<V: TryFrom<i64>>(
     mut spends: Vec<SpendInfo>,
     mut outputs: Vec<OutputInfo>,
     bundle_type: BundleType,
-) -> Result<Bundle<InProgress<Unproven, Unauthorized>, V>, BuildError> {
+) -> Result<Option<Bundle<InProgress<Unproven, Unauthorized>, V>>, BuildError> {
     let (flags, anchor) = bundle_type.bundle_config();
 
     let num_requested_spends = spends.len();
@@ -413,16 +413,18 @@ pub fn bundle<V: TryFrom<i64>>(
     .into_bvk();
     assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
 
-    Ok(Bundle::from_parts(
-        NonEmpty::from_vec(actions).unwrap(),
-        flags,
-        result_value_balance,
-        anchor,
-        InProgress {
-            proof: Unproven { circuits },
-            sigs: Unauthorized { bsk },
-        },
-    ))
+    Ok(NonEmpty::from_vec(actions).map(|actions| {
+        Bundle::from_parts(
+            actions,
+            flags,
+            result_value_balance,
+            anchor,
+            InProgress {
+                proof: Unproven { circuits },
+                sigs: Unauthorized { bsk },
+            },
+        )
+    }))
 }
 
 /// A builder that constructs a [`Bundle`] from a set of notes to be spent, and outputs
@@ -543,7 +545,7 @@ impl Builder {
     pub fn build<V: TryFrom<i64>>(
         self,
         rng: impl RngCore,
-    ) -> Result<Bundle<InProgress<Unproven, Unauthorized>, V>, BuildError> {
+    ) -> Result<Option<Bundle<InProgress<Unproven, Unauthorized>, V>>, BuildError> {
         bundle(rng, self.spends, self.outputs, self.bundle_type)
     }
 }
@@ -902,6 +904,7 @@ pub mod testing {
             builder
                 .build(&mut self.rng)
                 .unwrap()
+                .unwrap()
                 .create_proof(&pk, &mut self.rng)
                 .unwrap()
                 .prepare(&mut self.rng, [0; 32])
@@ -1013,6 +1016,7 @@ mod tests {
         let bundle: Bundle<Authorized, i64> = builder
             .build(&mut rng)
             .unwrap()
+            .unwrap()
             .create_proof(&pk, &mut rng)
             .unwrap()
             .prepare(rng, [0; 32])

tests/builder.rs

@@ -47,7 +47,7 @@ fn bundle_chain() {
             builder.add_output(None, recipient, NoteValue::from_raw(5000), None),
             Ok(())
         );
-        let unauthorized = builder.build(&mut rng).unwrap();
+        let unauthorized = builder.build(&mut rng).unwrap().unwrap();
         let sighash = unauthorized.commitment().into();
         let proven = unauthorized.create_proof(&pk, &mut rng).unwrap();
         proven.apply_signatures(rng, sighash, &[]).unwrap()
@@ -89,7 +89,7 @@ fn bundle_chain() {
             builder.add_output(None, recipient, NoteValue::from_raw(5000), None),
             Ok(())
         );
-        let unauthorized = builder.build(&mut rng).unwrap();
+        let unauthorized = builder.build(&mut rng).unwrap().unwrap();
         let sighash = unauthorized.commitment().into();
         let proven = unauthorized.create_proof(&pk, &mut rng).unwrap();
         proven