Delete the DescriptorTrait

We never abstract over the `DescriptorTrait`, it is therefore
questionable for it to exist. We have recently removed a number of trait
methods out of the trait and implemented them directly on the respective
descriptors. We can now do the same with the remaining 'satisfaction'
trait methods.

Implement the various satisfaction methods on each descriptor as
required. Implement the methods directly on `Descriptor`. Delete
the `DescriptorTrait`.

Author: tcharding

examples/sign_multisig.rs

@@ -19,7 +19,6 @@ use std::str::FromStr;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1;
-use miniscript::DescriptorTrait;
 
 fn main() {
     let mut tx = spending_transaction();

integration_test/src/test_cpp.rs

@@ -13,7 +13,7 @@ use miniscript::miniscript::iter;
 use miniscript::psbt::PsbtExt;
 use miniscript::MiniscriptKey;
 use miniscript::Segwitv0;
-use miniscript::{Descriptor, DescriptorTrait, Miniscript};
+use miniscript::{Descriptor, Miniscript};
 use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::{self, BufRead};

integration_test/src/test_desc.rs

@@ -13,8 +13,8 @@ use bitcoin::util::{psbt, sighash};
 use bitcoin::{self, Amount, OutPoint, SchnorrSig, Script, Transaction, TxIn, TxOut, Txid};
 use bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::miniscript::iter;
-use miniscript::psbt::{PsbtInputExt, PsbtExt};
-use miniscript::{Descriptor, DescriptorTrait, Miniscript, ToPublicKey};
+use miniscript::psbt::{PsbtExt, PsbtInputExt};
+use miniscript::{Descriptor, Miniscript, ToPublicKey};
 use miniscript::{MiniscriptKey, ScriptContext};
 use std::collections::BTreeMap;
 

src/descriptor/bare.rs

@@ -25,7 +25,6 @@ use bitcoin::blockdata::script;
 use bitcoin::{Address, Network, Script};
 
 use super::checksum::{desc_checksum, verify_checksum};
-use super::DescriptorTrait;
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
@@ -66,6 +65,20 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
         self.ms.sanity_check()?;
         Ok(())
     }
+
+    /// Computes an upper bound on the weight of a satisfying witness to the
+    /// transaction.
+    ///
+    /// Assumes all ec-signatures are 73 bytes, including push opcode and
+    /// sighash suffix. Includes the weight of the VarInts encoding the
+    /// scriptSig and witness stack length.
+    ///
+    /// # Errors
+    /// When the descriptor is impossible to safisfy (ex: sh(OP_FALSE)).
+    pub fn max_satisfaction_weight(&self) -> Result<usize, Error> {
+        let scriptsig_len = self.ms.max_satisfaction_size()?;
+        Ok(4 * (varint_len(scriptsig_len) + scriptsig_len))
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
@@ -83,6 +96,32 @@ impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
     pub fn ecdsa_sighash_script_code(&self) -> Script {
         self.script_pubkey()
     }
+
+    /// Returns satisfying non-malleable witness and scriptSig with minimum
+    /// weight to spend an output controlled by the given descriptor if it is
+    /// possible to construct one using the `satisfier`.
+    pub fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        S: Satisfier<Pk>,
+    {
+        let ms = self.ms.satisfy(satisfier)?;
+        let script_sig = witness_to_scriptsig(&ms);
+        let witness = vec![];
+        Ok((witness, script_sig))
+    }
+
+    /// Returns satisfying, possibly malleable, witness and scriptSig with
+    /// minimum weight to spend an output controlled by the given descriptor if
+    /// it is possible to construct one using the `satisfier`.
+    pub fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        S: Satisfier<Pk>,
+    {
+        let ms = self.ms.satisfy_malleable(satisfier)?;
+        let script_sig = witness_to_scriptsig(&ms);
+        let witness = vec![];
+        Ok((witness, script_sig))
+    }
 }
 
 impl<Pk: MiniscriptKey> fmt::Debug for Bare<Pk> {
@@ -135,35 +174,6 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
-    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
-    where
-        Pk: ToPublicKey,
-        S: Satisfier<Pk>,
-    {
-        let ms = self.ms.satisfy(satisfier)?;
-        let script_sig = witness_to_scriptsig(&ms);
-        let witness = vec![];
-        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))
-    }
-}
-
 impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
     fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool
     where
@@ -215,6 +225,16 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     pub fn into_inner(self) -> Pk {
         self.pk
     }
+
+    /// Computes an upper bound on the weight of a satisfying witness to the
+    /// transaction.
+    ///
+    /// Assumes all ec-signatures are 73 bytes, including push opcode and
+    /// sighash suffix. Includes the weight of the VarInts encoding the
+    /// scriptSig and witness stack length.
+    pub fn max_satisfaction_weight(&self) -> usize {
+        4 * (1 + 73 + BareCtx::pk_len(&self.pk))
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
@@ -240,6 +260,36 @@ impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
     pub fn ecdsa_sighash_script_code(&self) -> Script {
         self.script_pubkey()
     }
+
+    /// Returns satisfying non-malleable witness and scriptSig with minimum
+    /// weight to spend an output controlled by the given descriptor if it is
+    /// possible to construct one using the `satisfier`.
+    pub fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        S: Satisfier<Pk>,
+    {
+        if let Some(sig) = satisfier.lookup_ecdsa_sig(&self.pk) {
+            let sig_vec = sig.to_vec();
+            let script_sig = script::Builder::new()
+                .push_slice(&sig_vec[..])
+                .push_key(&self.pk.to_public_key())
+                .into_script();
+            let witness = vec![];
+            Ok((witness, script_sig))
+        } else {
+            Err(Error::MissingSig(self.pk.to_public_key()))
+        }
+    }
+
+    /// Returns satisfying, possibly malleable, witness and scriptSig with
+    /// minimum weight to spend an output controlled by the given descriptor if
+    /// it is possible to construct one using the `satisfier`.
+    pub fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    where
+        S: Satisfier<Pk>,
+    {
+        self.get_satisfaction(satisfier)
+    }
 }
 
 impl<Pk: MiniscriptKey> fmt::Debug for Pkh<Pk> {
@@ -300,38 +350,6 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
-    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
-    where
-        Pk: ToPublicKey,
-        S: Satisfier<Pk>,
-    {
-        if let Some(sig) = satisfier.lookup_ecdsa_sig(&self.pk) {
-            let sig_vec = sig.to_vec();
-            let script_sig = script::Builder::new()
-                .push_slice(&sig_vec[..])
-                .push_key(&self.pk.to_public_key())
-                .into_script();
-            let witness = vec![];
-            Ok((witness, script_sig))
-        } else {
-            Err(Error::MissingSig(self.pk.to_public_key()))
-        }
-    }
-
-    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)))
-    }
-}
-
 impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
     fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
     where