Remove the DescriptorTrait

We never abstract over the `DescriptorTrait` so it is questionable if it
should exist at all. For `Descriptor` at least, we can just implement
the methods directly instead of using the trait. This makes using the
type for ergonomic also since users no longer need to import the trait
to use a descriptor.

Removing the `DescriptorTrait` allows us to remove the `pretaproot`
module also.

Remove the `DescriptorTrait`. Implement trait methods on the
`Descriptor` type directly. Implement infallible versions of the trait
methods on each descriptor as required.

Author: tcharding

examples/htlc.rs

@@ -19,7 +19,6 @@ use std::str::FromStr;
 use bitcoin::Network;
 use miniscript::descriptor::Wsh;
 use miniscript::policy::{Concrete, Liftable};
-use miniscript::DescriptorTrait;
 
 fn main() {
     // HTLC policy with 10:1 odds for happy (co-operative) case compared to uncooperative case.
@@ -54,7 +53,7 @@ fn main() {
 
     // Get the scriptPpubkey for this Wsh descriptor.
     assert_eq!(
-        format!("{:x}", htlc_descriptor.spk()),
+        format!("{:x}", htlc_descriptor.script_pubkey()),
         "0020d853877af928a8d2a569c9c0ed14bd16f6a80ce9cccaf8a6150fd8f7f8867ae2"
     );
 
@@ -66,7 +65,7 @@ fn main() {
 
     // Get the address for this Wsh descriptor.v
     assert_eq!(
-        format!("{}", htlc_descriptor.address(Network::Bitcoin).unwrap()),
+        format!("{}", htlc_descriptor.address(Network::Bitcoin)),
         "bc1qmpfcw7he9z5d9ftfe8qw699azmm2sr8fen903fs4plv007yx0t3qxfmqv5"
     );
 }

examples/parse.rs

@@ -17,7 +17,7 @@
 use std::str::FromStr;
 
 use miniscript::descriptor::DescriptorType;
-use miniscript::{Descriptor, DescriptorTrait};
+use miniscript::Descriptor;
 
 fn main() {
     let desc = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(
@@ -44,7 +44,7 @@ fn main() {
     // us to call infallible methods for getting script pubkey.
     if let Descriptor::Wsh(wsh) = &desc {
         assert_eq!(
-            format!("{:x}", wsh.spk()),
+            format!("{:x}", wsh.script_pubkey()),
             "0020daef16dd7c946a3e735a6e43310cb2ce33dfd14a04f76bf8241a16654cb2f0f9"
         );
     }

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();

examples/xpub_descriptors.rs

@@ -18,7 +18,7 @@ use std::str::FromStr;
 
 use miniscript::bitcoin::secp256k1::{Secp256k1, Verification};
 use miniscript::bitcoin::{Address, Network};
-use miniscript::{Descriptor, DescriptorPublicKey, DescriptorTrait, TranslatePk2};
+use miniscript::{Descriptor, DescriptorPublicKey, TranslatePk2};
 
 const XPUB_1: &str = "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB";
 const XPUB_2: &str = "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH";

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};
@@ -60,25 +59,42 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     pub fn as_inner(&self) -> &Miniscript<Pk, BareCtx> {
         &self.ms
     }
+
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        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> {
-    /// Obtain the corresponding script pubkey for this descriptor
-    /// Non failing verion of [`DescriptorTrait::script_pubkey`] for this descriptor
-    pub fn spk(&self) -> Script {
+    /// Obtains the corresponding script pubkey for this descriptor.
+    pub fn script_pubkey(&self) -> Script {
         self.ms.encode()
     }
 
-    /// Obtain the underlying miniscript for this descriptor
-    /// Non failing verion of [`DescriptorTrait::explicit_script`] for this descriptor
+    /// Obtains the underlying miniscript for this descriptor.
     pub fn inner_script(&self) -> Script {
-        self.spk()
+        self.script_pubkey()
     }
 
-    /// Obtain the pre bip-340 signature script code for this descriptor
-    /// Non failing verion of [`DescriptorTrait::script_code`] for this descriptor
+    /// Obtains the pre bip-340 signature script code for this descriptor.
     pub fn ecdsa_sighash_script_code(&self) -> Script {
-        self.spk()
+        self.script_pubkey()
     }
 }
 
@@ -132,43 +148,12 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        self.ms.sanity_check()?;
-        Ok(())
-    }
-
-    fn address(&self, _network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Err(Error::BareDescriptorAddr)
-    }
-
-    fn script_pubkey(&self) -> Script
-    where
-        Pk: ToPublicKey,
-    {
-        self.spk()
-    }
-
-    fn unsigned_script_sig(&self) -> Script
-    where
-        Pk: ToPublicKey,
-    {
-        Script::new()
-    }
-
-    fn explicit_script(&self) -> Result<Script, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.inner_script())
-    }
-
-    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
+    /// 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
-        Pk: ToPublicKey,
         S: Satisfier<Pk>,
     {
         let ms = self.ms.satisfy(satisfier)?;
@@ -177,28 +162,18 @@ 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>
+    /// 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
-        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))
-    }
-
-    fn script_code(&self) -> Result<Script, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.ecdsa_sighash_script_code())
-    }
 }
 
 impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
@@ -254,30 +229,40 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     }
 }
 
+impl<Pk: MiniscriptKey> Pkh<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> {
-    /// Obtain the corresponding script pubkey for this descriptor
-    /// Non failing verion of [`DescriptorTrait::script_pubkey`] for this descriptor
-    pub fn spk(&self) -> Script {
-        let addr = Address::p2pkh(&self.pk.to_public_key(), Network::Bitcoin);
+    /// Obtains the corresponding script pubkey for this descriptor.
+    pub fn script_pubkey(&self) -> Script {
+        // Fine to hard code the `Network` here because we immediately call
+        // `script_pubkey` which does not use the `network` field of `Address`.
+        let addr = self.address(Network::Bitcoin);
         addr.script_pubkey()
     }
 
-    /// Obtain the corresponding script pubkey for this descriptor
-    /// Non failing verion of [`DescriptorTrait::address`] for this descriptor
-    pub fn addr(&self, network: Network) -> Address {
+    /// Obtains the corresponding script pubkey for this descriptor.
+    pub fn address(&self, network: Network) -> Address {
         Address::p2pkh(&self.pk.to_public_key(), network)
     }
 
-    /// Obtain the underlying miniscript for this descriptor
-    /// Non failing verion of [`DescriptorTrait::explicit_script`] for this descriptor
+    /// Obtains the underlying miniscript for this descriptor.
     pub fn inner_script(&self) -> Script {
-        self.spk()
+        self.script_pubkey()
     }
 
-    /// Obtain the pre bip-340 signature script code for this descriptor
-    /// Non failing verion of [`DescriptorTrait::script_code`] for this descriptor
+    /// Obtains the pre bip-340 signature script code for this descriptor.
     pub fn ecdsa_sighash_script_code(&self) -> Script {
-        self.spk()
+        self.script_pubkey()
     }
 }
 
@@ -339,42 +324,12 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.addr(network))
-    }
-
-    fn script_pubkey(&self) -> Script
-    where
-        Pk: ToPublicKey,
-    {
-        self.spk()
-    }
-
-    fn unsigned_script_sig(&self) -> Script
-    where
-        Pk: ToPublicKey,
-    {
-        Script::new()
-    }
-
-    fn explicit_script(&self) -> Result<Script, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.inner_script())
-    }
-
-    fn get_satisfaction<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
+    /// 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
-        Pk: ToPublicKey,
         S: Satisfier<Pk>,
     {
         if let Some(sig) = satisfier.lookup_ecdsa_sig(&self.pk) {
@@ -390,24 +345,15 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
         }
     }
 
-    fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
+    /// 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
-        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)))
-    }
-
-    fn script_code(&self) -> Result<Script, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.ecdsa_sighash_script_code())
-    }
 }
 
 impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {