Add descriptor malleable satisfaction support

Author: sanket1729

src/descriptor/bare.rs

@@ -158,6 +158,17 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
         Ok((witness, script_sig))
     }
 
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        let ms = self.ms.satisfy_malleable(satisfier)?;
+        let script_sig = witness_to_scriptsig(&ms);
+        let witness = vec![];
+        Ok((witness, script_sig))
+    }
+
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         let scriptsig_len = self.ms.max_satisfaction_size()?;
         Ok(4 * (varint_len(scriptsig_len) + scriptsig_len))
@@ -338,6 +349,14 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
         }
     }
 
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        self.get_satisfaction(satisfier)
+    }
+
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         Ok(4 * (1 + 73 + BareCtx::pk_len(&self.pk)))
     }

src/descriptor/mod.rs

@@ -114,15 +114,23 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
     where
         Pk: ToPublicKey;
 
-    /// Returns satisfying witness and scriptSig to spend an
+    /// Returns satisfying non-malleable witness and scriptSig to spend an
     /// output controlled by the given descriptor if it possible to
     /// construct one using the satisfier S.
     fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
     where
         Pk: ToPublicKey,
         S: Satisfier<Pk>;
 
-    /// Attempts to produce a satisfying witness and scriptSig to spend an
+    /// Returns satisfying, possibly malleable witness and scriptSig to spend an
+    /// output controlled by the given descriptor if it possible to
+    /// construct one using the satisfier S.
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>;
+
+    /// Attempts to produce a non-malleable satisfying witness and scriptSig to spend an
     /// output controlled by the given descriptor; add the data to a given
     /// `TxIn` output.
     fn satisfy<S>(&self, txin: &mut bitcoin::TxIn, satisfier: S) -> Result<(), Error>
@@ -421,7 +429,7 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Descriptor<Pk> {
         }
     }
 
-    /// Returns satisfying witness and scriptSig to spend an
+    /// Returns satisfying non-malleable witness and scriptSig to spend an
     /// output controlled by the given descriptor if it possible to
     /// construct one using the satisfier S.
     fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
@@ -438,6 +446,23 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Descriptor<Pk> {
         }
     }
 
+    /// Returns a possilbly mallable satisfying non-malleable witness and scriptSig to spend an
+    /// output controlled by the given descriptor if it possible to
+    /// construct one using the satisfier S.
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        match *self {
+            Descriptor::Bare(ref bare) => bare.get_satisfaction_mall(satisfier),
+            Descriptor::Pkh(ref pkh) => pkh.get_satisfaction_mall(satisfier),
+            Descriptor::Wpkh(ref wpkh) => wpkh.get_satisfaction_mall(satisfier),
+            Descriptor::Wsh(ref wsh) => wsh.get_satisfaction_mall(satisfier),
+            Descriptor::Sh(ref sh) => sh.get_satisfaction_mall(satisfier),
+        }
+    }
+
     /// Computes an upper bound on the weight of a satisfying witness to the
     /// transaction. Assumes all signatures are 73 bytes, including push opcode
     /// and sighash suffix. Includes the weight of the VarInts encoding the

src/descriptor/segwitv0.rs

@@ -215,6 +215,20 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wsh<Pk> {
         Ok((witness, script_sig))
     }
 
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        let mut witness = match self.inner {
+            WshInner::SortedMulti(ref smv) => smv.satisfy(satisfier)?,
+            WshInner::Ms(ref ms) => ms.satisfy_malleable(satisfier)?,
+        };
+        witness.push(self.explicit_script().into_bytes());
+        let script_sig = Script::new();
+        Ok((witness, script_sig))
+    }
+
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         let (script_size, max_sat_elems, max_sat_size) = match self.inner {
             WshInner::SortedMulti(ref smv) => (
@@ -433,6 +447,14 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wpkh<Pk> {
         }
     }
 
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        self.get_satisfaction(satisfier)
+    }
+
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         Ok(4 + 1 + 73 + Segwitv0::pk_len(&self.pk))
     }

src/descriptor/sh.rs

@@ -293,6 +293,28 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Sh<Pk> {
         }
     }
 
+    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        Pk: ToPublicKey,
+        S: Satisfier<Pk>,
+    {
+        let script_sig = self.unsigned_script_sig();
+        match self.inner {
+            ShInner::Wsh(ref wsh) => {
+                let (witness, _) = wsh.get_satisfaction_mall(satisfier)?;
+                Ok((witness, script_sig))
+            }
+            ShInner::Ms(ref ms) => {
+                let mut script_witness = ms.satisfy_malleable(satisfier)?;
+                script_witness.push(ms.encode().into_bytes());
+                let script_sig = witness_to_scriptsig(&script_witness);
+                let witness = vec![];
+                Ok((witness, script_sig))
+            }
+            _ => self.get_satisfaction(satisfier),
+        }
+    }
+
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {
         Ok(match self.inner {
             // add weighted script sig, len byte stays the same