Use DescTestError instead of miniscript::Error

Author: kanishk779

integration_test/run.sh

@@ -31,7 +31,6 @@ sleep 3
 
 RPC_URL=http://localhost:12348 \
     RPC_COOKIE=${TESTDIR}/1/regtest/.cookie \
-    RUST_BACKTRACE=1 \
     cargo run
 
 RESULT=$?

integration_test/src/test_desc.rs

@@ -46,24 +46,34 @@ fn get_vout(cl: &Client, txid: Txid, value: u64, spk: Script) -> (OutPoint, TxOu
 // Currently this is not being used, since miniscript::Error is being propagated
 // But if the types of errors grow in future, we can extend this enum and use it.
 #[derive(Debug, PartialEq)]
-pub enum MalleableDescError {
+pub enum DescTestError {
     /// PSBT was not able to finalize
     PsbtFinalizeError,
+    /// Problem with address computation
+    AddressComputationError,
+    /// Error while parsing the descriptor
+    DescParseError,
 }
 
-impl fmt::Display for MalleableDescError{
+impl fmt::Display for DescTestError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            MalleableDescError::PsbtFinalizeError => {
+            DescTestError::PsbtFinalizeError => {
                 f.write_str("PSBT was not able to finalize")
             }
+            DescTestError::AddressComputationError => {
+                f.write_str("Problem with address computation")
+            } 
+            DescTestError::DescParseError => {
+                f.write_str("Not able to parse the descriptor")
+            }
         }
     }
 }
 
-impl error::Error for MalleableDescError {}
+impl error::Error for DescTestError {}
 
-pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: &str) -> Result<Witness, Error> {
+pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: &str) -> Result<Witness, DescTestError> {
     let secp = secp256k1::Secp256k1::new();
     let sks = &testdata.secretdata.sks;
     let xonly_keypairs = &testdata.secretdata.x_only_keypairs;
@@ -75,12 +85,21 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: &str) -> Result
         .unwrap();
     assert_eq!(blocks.len(), 1);
 
-    let desc = test_util::parse_test_desc(&desc, &testdata.pubdata)?;
+    let desc = test_util::parse_test_desc(&desc, &testdata.pubdata);
+    if let Err(Error) = desc { 
+        return Err(DescTestError::DescParseError);
+    }
+    let desc = desc.unwrap();
     let derived_desc = desc.derived_descriptor(&secp, 0).unwrap();
+    let desc_address = derived_desc.address(bitcoin::Network::Regtest);
+    if let Err(Error) = desc_address {
+        return Err(DescTestError::AddressComputationError);
+    }
+    let desc_address = desc_address.unwrap();
     // Next send some btc to each address corresponding to the miniscript
     let txid = cl
         .send_to_address(
-            &derived_desc.address(bitcoin::Network::Regtest)?,
+            &desc_address,
             btc(1),
             None,
             None,
@@ -289,7 +308,7 @@ pub fn test_desc_satisfy(cl: &Client, testdata: &TestData, desc: &str) -> Result
     // Finalize the transaction using psbt
     // Let miniscript do it's magic!
     if let Err(e) = psbt.finalize_mut(&secp) {
-        return Err(Error::Unexpected(String::from("PSBT was not able to finalize")));
+        return Err(DescTestError::PsbtFinalizeError);
     }
     let tx = psbt.extract(&secp).expect("Extraction error");