Remove address from DescriptorTrait

In preparation for removing the `DescriptorTrait` move the `address`
trait methods onto each individual descriptor. Replaces the `addr`
method.

Author: heap-coder

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.
@@ -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/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";

src/descriptor/bare.rs

@@ -139,13 +139,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
-    fn address(&self, _network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Err(Error::BareDescriptorAddr)
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,
@@ -263,9 +256,8 @@ impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
         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)
     }
 
@@ -341,13 +333,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.addr(network))
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,

src/descriptor/mod.rs

@@ -76,14 +76,6 @@ pub type KeyMap = HashMap<DescriptorPublicKey, DescriptorSecretKey>;
 // because of traits cannot know underlying generic of Self.
 // Thus, we must implement additional trait for translate function
 pub trait DescriptorTrait<Pk: MiniscriptKey> {
-    /// Computes the Bitcoin address of the descriptor, if one exists
-    /// Some descriptors like pk() don't have any address.
-    /// Errors:
-    /// - On raw/bare descriptors that don't have any address
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey;
-
     /// Computes the scriptpubkey of the descriptor
     fn script_pubkey(&self) -> Script
     where
@@ -407,6 +399,25 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
     }
 }
 
+impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
+    /// Computes the Bitcoin address of the descriptor, if one exists
+    ///
+    /// Some descriptors like pk() don't have any address.
+    ///
+    /// # Errors
+    /// For raw/bare descriptors that don't have any address.
+    pub fn address(&self, network: Network) -> Result<Address, Error> {
+        match *self {
+            Descriptor::Bare(_) => Err(Error::BareDescriptorAddr),
+            Descriptor::Pkh(ref pkh) => Ok(pkh.address(network)),
+            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)),
+        }
+    }
+}
+
 impl<P, Q> TranslatePk<P, Q> for Descriptor<P>
 where
     P: MiniscriptKey,
@@ -438,21 +449,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Descriptor<Pk> {
-    /// Computes the Bitcoin address of the descriptor, if one exists
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        match *self {
-            Descriptor::Bare(ref bare) => bare.address(network),
-            Descriptor::Pkh(ref pkh) => pkh.address(network),
-            Descriptor::Wpkh(ref wpkh) => wpkh.address(network),
-            Descriptor::Wsh(ref wsh) => wsh.address(network),
-            Descriptor::Sh(ref sh) => sh.address(network),
-            Descriptor::Tr(ref tr) => tr.address(network),
-        }
-    }
-
     /// Computes the scriptpubkey of the descriptor
     fn script_pubkey(&self) -> Script
     where

src/descriptor/segwitv0.rs

@@ -92,9 +92,8 @@ impl<Pk: MiniscriptKey + ToPublicKey> Wsh<Pk> {
         self.inner_script().to_v0_p2wsh()
     }
 
-    /// 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 {
         match self.inner {
             WshInner::SortedMulti(ref smv) => Address::p2wsh(&smv.encode(), network),
             WshInner::Ms(ref ms) => Address::p2wsh(&ms.encode(), network),
@@ -198,13 +197,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wsh<Pk> {
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.addr(network))
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,
@@ -372,9 +364,8 @@ impl<Pk: MiniscriptKey + ToPublicKey> Wpkh<Pk> {
         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::p2wpkh(&self.pk.to_public_key(), network)
             .expect("Rust Miniscript types don't allow uncompressed pks in segwit descriptors")
     }
@@ -456,13 +447,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wpkh<Pk> {
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        Ok(self.addr(network))
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,

src/descriptor/sh.rs

@@ -228,23 +228,25 @@ impl<Pk: MiniscriptKey + ToPublicKey> Sh<Pk> {
         }
     }
 
-    /// Obtain the corresponding script pubkey for this descriptor
-    /// Non failing verion of [`DescriptorTrait::address`] for this descriptor
-    pub fn addr(&self, network: Network) -> Address {
-        match self.inner {
-            ShInner::Wsh(ref wsh) => {
-                Address::p2sh(&wsh.spk(), network).expect("Size checked in Miniscript")
-            }
-            ShInner::Wpkh(ref wpkh) => {
-                Address::p2sh(&wpkh.spk(), network).expect("Size checked in Miniscript")
-            }
-            ShInner::SortedMulti(ref smv) => {
-                Address::p2sh(&smv.encode(), network).expect("Size checked in Miniscript")
-            }
-            ShInner::Ms(ref ms) => {
-                Address::p2sh(&ms.encode(), network).expect("Size checked in Miniscript")
-            }
-        }
+    /// Obtains the corresponding address for this descriptor.
+    pub fn address(&self, network: Network) -> Address {
+        let addr = self.address_fallible(network);
+
+        // Size is checked in `check_global_consensus_validity`.
+        assert!(addr.is_ok());
+        addr.expect("only fails if size > MAX_SCRIPT_ELEMENT_SIZE")
+    }
+
+    fn address_fallible(&self, network: Network) -> Result<Address, Error> {
+        let script = match self.inner {
+            ShInner::Wsh(ref wsh) => wsh.script_pubkey(),
+            ShInner::Wpkh(ref wpkh) => wpkh.script_pubkey(),
+            ShInner::SortedMulti(ref smv) => smv.encode(),
+            ShInner::Ms(ref ms) => ms.encode(),
+        };
+        let address = Address::p2sh(&script, network)?;
+
+        Ok(address)
     }
 
     /// Obtain the underlying miniscript for this descriptor
@@ -274,18 +276,6 @@ impl<Pk: MiniscriptKey + ToPublicKey> Sh<Pk> {
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Sh<Pk> {
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        match self.inner {
-            ShInner::Wsh(ref wsh) => Ok(Address::p2sh(&wsh.spk(), network)?),
-            ShInner::Wpkh(ref wpkh) => Ok(Address::p2sh(&wpkh.spk(), network)?),
-            ShInner::SortedMulti(ref smv) => Ok(Address::p2sh(&smv.encode(), network)?),
-            ShInner::Ms(ref ms) => Ok(Address::p2sh(&ms.encode(), network)?),
-        }
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,

src/descriptor/tr.rs

@@ -292,11 +292,10 @@ impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
             .into_script()
     }
 
-    /// Obtain the corresponding script pubkey for this descriptor
-    /// Same as[`DescriptorTrait::address`] for this descriptor
-    pub fn addr(&self, network: Network) -> Result<Address, Error> {
+    /// Obtains the corresponding address for this descriptor.
+    pub fn address(&self, network: Network) -> Address {
         let spend_info = self.spend_info();
-        Ok(Address::p2tr_tweaked(spend_info.output_key(), network))
+        Address::p2tr_tweaked(spend_info.output_key(), network)
     }
 }
 
@@ -556,13 +555,6 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Tr<Pk> {
-    fn address(&self, network: Network) -> Result<Address, Error>
-    where
-        Pk: ToPublicKey,
-    {
-        self.addr(network)
-    }
-
     fn script_pubkey(&self) -> Script
     where
         Pk: ToPublicKey,