Add support for writing integration tests that fail : src folder

Author: kanishk779

src/descriptor/mod.rs

@@ -331,7 +331,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
             Descriptor::Wpkh(ref wpkh) => Ok(wpkh.address(network)),
             Descriptor::Wsh(ref wsh) => Ok(wsh.address(network)),
             Descriptor::Sh(ref sh) => Ok(sh.address(network)),
-            Descriptor::Tr(ref tr) => Ok(tr.address(network)),
+            Descriptor::Tr(ref tr) => Ok(tr.address(network)?),
         }
     }
 

src/descriptor/tr.rs

@@ -214,15 +214,15 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
     /// If spend data is already computed (i.e it is not `None`), this does not recompute it.
     ///
     /// [`TaprootSpendInfo`] is only required for spending via the script paths.
-    pub fn spend_info(&self) -> Arc<TaprootSpendInfo>
+    pub fn spend_info(&self) -> Result<Arc<TaprootSpendInfo>, Error>
     where
         Pk: ToPublicKey,
     {
         // If the value is already cache, read it
         // read only panics if the lock is poisoned (meaning other thread having a lock panicked)
         let read_lock = self.spend_info.lock().expect("Lock poisoned");
         if let Some(ref spend_info) = *read_lock {
-            return Arc::clone(spend_info);
+            return Ok(Arc::clone(spend_info));
         }
         drop(read_lock);
 
@@ -236,9 +236,13 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
             let mut builder = TaprootBuilder::new();
             for (depth, ms) in self.iter_scripts() {
                 let script = ms.encode();
-                builder = builder
-                    .add_leaf(depth, script)
-                    .expect("Computing spend data on a valid Tree should always succeed");
+                if let Ok(taproot_builder) = builder.add_leaf(depth, script) {
+                    builder = taproot_builder;
+                } else {
+                    return Err(Error::Unexpected(String::from(
+                        "Computing spend data on a valid Tree should always succeed",
+                    )));
+                }
             }
             // Assert builder cannot error here because we have a well formed descriptor
             match builder.finalize(&secp, self.internal_key.to_x_only_pubkey()) {
@@ -267,7 +271,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
         };
         let spend_info = Arc::new(data);
         *self.spend_info.lock().expect("Lock poisoned") = Some(Arc::clone(&spend_info));
-        spend_info
+        Ok(spend_info)
     }
 
     /// Checks whether the descriptor is safe.
@@ -315,7 +319,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
 impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> Script {
-        let output_key = self.spend_info().output_key();
+        let output_key = self.spend_info().unwrap().output_key();
         let builder = bitcoin::blockdata::script::Builder::new();
         builder
             .push_opcode(opcodes::all::OP_PUSHNUM_1)
@@ -324,9 +328,9 @@ impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
     }
 
     /// Obtains the corresponding address for this descriptor.
-    pub fn address(&self, network: Network) -> Address {
-        let spend_info = self.spend_info();
-        Address::p2tr_tweaked(spend_info.output_key(), network)
+    pub fn address(&self, network: Network) -> Result<Address, Error> {
+        let spend_info = self.spend_info()?;
+        Ok(Address::p2tr_tweaked(spend_info.output_key(), network))
     }
 
     /// Returns satisfying non-malleable witness and scriptSig with minimum
@@ -658,7 +662,7 @@ where
     Pk: ToPublicKey,
     S: Satisfier<Pk>,
 {
-    let spend_info = desc.spend_info();
+    let spend_info = desc.spend_info().unwrap();
     // First try the key spend path
     if let Some(sig) = satisfier.lookup_tap_key_spend_sig() {
         Ok((vec![sig.to_vec()], Script::new()))

src/psbt/mod.rs

@@ -959,7 +959,7 @@ fn update_input_with_descriptor_helper(
 
         // NOTE: they will both always be Tr
         if let (Descriptor::Tr(tr_derived), Descriptor::Tr(tr_xpk)) = (&derived, descriptor) {
-            let spend_info = tr_derived.spend_info();
+            let spend_info = tr_derived.spend_info().unwrap();
             let ik_derived = spend_info.internal_key();
             let ik_xpk = tr_xpk.internal_key();
             input.tap_internal_key = Some(ik_derived);