Merge #297: Add pretaproot descriptor and addressabledescriptor

121e0b4 Add an API to convert Descriptor into a pre-taproot descriptor (sanket1729)
9e0735e Add pretaproot descriptors/remove macros (sanket1729)
b827c26 Remove comment about Tr descriptor (sanket1729)
79b2659 Change from arc.clone() to Arc::clone() (sanket1729)

Pull request description:

  Still not completely sure if this is what you wanted. I think we might also want new descriptor enums for `PreTaprootDescriptor` and `AddressableDescriptor`

ACKs for top commit:
  apoelstra:
    ACK 121e0b4

Tree-SHA512: 890cf9e8cf2869f02c46a6ce051e27cc1bb6d2cc425c4fccb24d45d115922eff5afe5939d7afa6c8f112510f30b81c17e64715afc3fa70cc0e05e059dd94a42d

Author: sanket1729

src/descriptor/mod.rs

@@ -41,6 +41,9 @@ use {
     TranslatePk2,
 };
 
+// Directly export from lib.rs, exporting the trait here causes conflicts in this file
+pub(crate) mod pretaproot;
+
 mod bare;
 mod segwitv0;
 mod sh;
@@ -91,7 +94,6 @@ pub trait DescriptorTrait<Pk: MiniscriptKey> {
     /// Some descriptors like pk() don't have any address.
     /// Errors:
     /// - On raw/bare descriptors that don't have any address
-    /// - In Tr descriptors where the precomputed spend data is not available
     fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
     where
         Pk: ToPublicKey;
@@ -339,6 +341,43 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
             Descriptor::Tr(ref _tr) => DescriptorType::Tr,
         }
     }
+
+    /// .
+    /// Convert a Descriptor into [`pretaproot::PreTaprootDescriptor`]
+    /// # Examples
+    ///
+    /// ```
+    /// use std::str::FromStr;
+    /// use miniscript::descriptor::Descriptor;
+    /// use miniscript::{PreTaprootDescriptor, PreTaprootDescriptorTrait};
+    /// use miniscript::bitcoin;
+    ///
+    /// // A descriptor with a string generic
+    /// let desc = Descriptor::<bitcoin::PublicKey>::from_str("wpkh(02e18f242c8b0b589bfffeac30e1baa80a60933a649c7fb0f1103e78fbf58aa0ed)")
+    ///     .expect("Valid segwitv0 descriptor");
+    /// let pre_tap_desc = desc.into_pre_taproot_desc().expect("Wsh is pre taproot");
+    ///
+    /// // Now the script code and explicit script no longer fail on longer fail
+    /// // on PreTaprootDescriptor using PreTaprootDescriptorTrait
+    /// let script_code = pre_tap_desc.script_code();
+    /// assert_eq!(script_code.to_string(),
+    ///     "Script(OP_DUP OP_HASH160 OP_PUSHBYTES_20 62107d047e8818b594303fe0657388cc4fc8771f OP_EQUALVERIFY OP_CHECKSIG)"
+    /// );
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if descriptor is not a pre taproot descriptor.
+    pub fn into_pre_taproot_desc(self) -> Result<pretaproot::PreTaprootDescriptor<Pk>, Self> {
+        match self {
+            Descriptor::Bare(bare) => Ok(pretaproot::PreTaprootDescriptor::Bare(bare)),
+            Descriptor::Pkh(pkh) => Ok(pretaproot::PreTaprootDescriptor::Pkh(pkh)),
+            Descriptor::Wpkh(wpkh) => Ok(pretaproot::PreTaprootDescriptor::Wpkh(wpkh)),
+            Descriptor::Sh(sh) => Ok(pretaproot::PreTaprootDescriptor::Sh(sh)),
+            Descriptor::Wsh(wsh) => Ok(pretaproot::PreTaprootDescriptor::Wsh(wsh)),
+            Descriptor::Tr(tr) => Err(Descriptor::Tr(tr)),
+        }
+    }
 }
 
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Descriptor<P> {

src/descriptor/pretaproot.rs

@@ -0,0 +1,286 @@
+use std::{
+    fmt,
+    str::{self, FromStr},
+};
+
+use bitcoin::{self, Script};
+
+use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
+
+/// Script descriptor
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum PreTaprootDescriptor<Pk: MiniscriptKey> {
+    /// Bare descriptor
+    Bare(Bare<Pk>),
+    /// Pay-to-PubKey-Hash
+    Pkh(Pkh<Pk>),
+    /// Pay-to-Witness-PubKey-Hash
+    Wpkh(Wpkh<Pk>),
+    /// Pay-to-ScriptHash(includes nested wsh/wpkh/sorted multi)
+    Sh(Sh<Pk>),
+    /// Pay-to-Witness-ScriptHash with Segwitv0 context
+    Wsh(Wsh<Pk>),
+}
+
+impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for PreTaprootDescriptor<Pk> {
+    /// Whether the descriptor is safe
+    /// Checks whether all the spend paths in the descriptor are possible
+    /// on the bitcoin network under the current standardness and consensus rules
+    /// Also checks whether the descriptor requires signauture on all spend paths
+    /// And whether the script is malleable.
+    /// In general, all the guarantees of miniscript hold only for safe scripts.
+    /// All the analysis guarantees of miniscript only hold safe scripts.
+    /// The signer may not be able to find satisfactions even if one exists
+    fn sanity_check(&self) -> Result<(), Error> {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.sanity_check(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.sanity_check(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.sanity_check(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.sanity_check(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.sanity_check(),
+        }
+    }
+    /// Computes the Bitcoin address of the descriptor, if one exists
+    fn address(&self, network: bitcoin::Network) -> Result<bitcoin::Address, Error>
+    where
+        Pk: ToPublicKey,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.address(network),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.address(network),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.address(network),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.address(network),
+            PreTaprootDescriptor::Sh(ref sh) => sh.address(network),
+        }
+    }
+
+    /// Computes the scriptpubkey of the descriptor
+    fn script_pubkey(&self) -> Script
+    where
+        Pk: ToPublicKey,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.script_pubkey(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.script_pubkey(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.script_pubkey(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.script_pubkey(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.script_pubkey(),
+        }
+    }
+
+    /// Computes the scriptSig that will be in place for an unsigned
+    /// input spending an output with this descriptor. For pre-segwit
+    /// descriptors, which use the scriptSig for signatures, this
+    /// returns the empty script.
+    ///
+    /// This is used in Segwit transactions to produce an unsigned
+    /// transaction whose txid will not change during signing (since
+    /// only the witness data will change).
+    fn unsigned_script_sig(&self) -> Script
+    where
+        Pk: ToPublicKey,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.unsigned_script_sig(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.unsigned_script_sig(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.unsigned_script_sig(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.unsigned_script_sig(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.unsigned_script_sig(),
+        }
+    }
+
+    /// Computes the "witness script" of the descriptor, i.e. the underlying
+    /// script before any hashing is done. For `Bare`, `Pkh` and `Wpkh` this
+    /// is the scriptPubkey; for `ShWpkh` and `Sh` this is the redeemScript;
+    /// for the others it is the witness script.
+    /// Errors:
+    /// - When the descriptor is Tr
+    fn explicit_script(&self) -> Result<Script, Error>
+    where
+        Pk: ToPublicKey,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.explicit_script(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.explicit_script(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.explicit_script(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.explicit_script(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.explicit_script(),
+        }
+    }
+
+    /// 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>,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.get_satisfaction(satisfier),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.get_satisfaction(satisfier),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.get_satisfaction(satisfier),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.get_satisfaction(satisfier),
+            PreTaprootDescriptor::Sh(ref sh) => sh.get_satisfaction(satisfier),
+        }
+    }
+
+    /// 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 {
+            PreTaprootDescriptor::Bare(ref bare) => bare.get_satisfaction_mall(satisfier),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.get_satisfaction_mall(satisfier),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.get_satisfaction_mall(satisfier),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.get_satisfaction_mall(satisfier),
+            PreTaprootDescriptor::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
+    /// scriptSig and witness stack length.
+    fn max_satisfaction_weight(&self) -> Result<usize, Error> {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.max_satisfaction_weight(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.max_satisfaction_weight(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.max_satisfaction_weight(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.max_satisfaction_weight(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.max_satisfaction_weight(),
+        }
+    }
+
+    /// Get the `scriptCode` of a transaction output.
+    ///
+    /// The `scriptCode` is the Script of the previous transaction output being serialized in the
+    /// sighash when evaluating a `CHECKSIG` & co. OP code.
+    /// Returns Error for Tr descriptors
+    fn script_code(&self) -> Result<Script, Error>
+    where
+        Pk: ToPublicKey,
+    {
+        match *self {
+            PreTaprootDescriptor::Bare(ref bare) => bare.script_code(),
+            PreTaprootDescriptor::Pkh(ref pkh) => pkh.script_code(),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => wpkh.script_code(),
+            PreTaprootDescriptor::Wsh(ref wsh) => wsh.script_code(),
+            PreTaprootDescriptor::Sh(ref sh) => sh.script_code(),
+        }
+    }
+}
+
+impl<Pk> expression::FromTree for PreTaprootDescriptor<Pk>
+where
+    Pk: MiniscriptKey + str::FromStr,
+    Pk::Hash: str::FromStr,
+    <Pk as FromStr>::Err: ToString,
+    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+{
+    /// Parse an expression tree into a descriptor
+    fn from_tree(top: &expression::Tree) -> Result<PreTaprootDescriptor<Pk>, Error> {
+        Ok(match (top.name, top.args.len() as u32) {
+            ("pkh", 1) => PreTaprootDescriptor::Pkh(Pkh::from_tree(top)?),
+            ("wpkh", 1) => PreTaprootDescriptor::Wpkh(Wpkh::from_tree(top)?),
+            ("sh", 1) => PreTaprootDescriptor::Sh(Sh::from_tree(top)?),
+            ("wsh", 1) => PreTaprootDescriptor::Wsh(Wsh::from_tree(top)?),
+            _ => PreTaprootDescriptor::Bare(Bare::from_tree(top)?),
+        })
+    }
+}
+
+impl<Pk> FromStr for PreTaprootDescriptor<Pk>
+where
+    Pk: MiniscriptKey + str::FromStr,
+    Pk::Hash: str::FromStr,
+    <Pk as FromStr>::Err: ToString,
+    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+{
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<PreTaprootDescriptor<Pk>, Error> {
+        let desc_str = verify_checksum(s)?;
+        let top = expression::Tree::from_str(desc_str)?;
+        expression::FromTree::from_tree(&top)
+    }
+}
+
+impl<Pk: MiniscriptKey> fmt::Debug for PreTaprootDescriptor<Pk> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            PreTaprootDescriptor::Bare(ref sub) => write!(f, "{:?}", sub),
+            PreTaprootDescriptor::Pkh(ref pkh) => write!(f, "{:?}", pkh),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => write!(f, "{:?}", wpkh),
+            PreTaprootDescriptor::Sh(ref sub) => write!(f, "{:?}", sub),
+            PreTaprootDescriptor::Wsh(ref sub) => write!(f, "{:?}", sub),
+        }
+    }
+}
+
+impl<Pk: MiniscriptKey> fmt::Display for PreTaprootDescriptor<Pk> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            PreTaprootDescriptor::Bare(ref sub) => write!(f, "{}", sub),
+            PreTaprootDescriptor::Pkh(ref pkh) => write!(f, "{}", pkh),
+            PreTaprootDescriptor::Wpkh(ref wpkh) => write!(f, "{}", wpkh),
+            PreTaprootDescriptor::Sh(ref sub) => write!(f, "{}", sub),
+            PreTaprootDescriptor::Wsh(ref sub) => write!(f, "{}", sub),
+        }
+    }
+}
+
+serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
+
+// Have the trait in a separate module to avoid conflicts
+pub(crate) mod traits {
+    use bitcoin::Script;
+
+    use {
+        descriptor::{Pkh, Sh, Wpkh, Wsh},
+        DescriptorTrait, MiniscriptKey, ToPublicKey,
+    };
+
+    use super::PreTaprootDescriptor;
+
+    /// A general trait for Pre taproot bitcoin descriptor.
+    /// Similar to [`DescriptorTrait`], but `explicit_script` and `script_code` methods cannot fail
+    pub trait PreTaprootDescriptorTrait<Pk: MiniscriptKey>: DescriptorTrait<Pk> {
+        /// Same as [`DescriptorTrait::explicit_script`], but a non failing version.
+        /// All PreTaproot descriptors have a unique explicit script
+        fn explicit_script(&self) -> Script
+        where
+            Pk: ToPublicKey,
+        {
+            // This expect can technically be avoided if we implement this for types, but
+            // having this expect saves lots of LoC because of default implementation
+            <Self as DescriptorTrait<Pk>>::explicit_script(&self)
+                .expect("Pre taproot descriptor have explicit script")
+        }
+
+        /// Same as [`DescriptorTrait::script_code`], but a non failing version.
+        /// All PreTaproot descriptors have a script code
+        fn script_code(&self) -> Script
+        where
+            Pk: ToPublicKey,
+        {
+            <Self as DescriptorTrait<Pk>>::script_code(&self)
+                .expect("Pre taproot descriptor have non-failing script code")
+        }
+    }
+
+    impl<Pk: MiniscriptKey> PreTaprootDescriptorTrait<Pk> for Pkh<Pk> {}
+
+    impl<Pk: MiniscriptKey> PreTaprootDescriptorTrait<Pk> for Sh<Pk> {}
+
+    impl<Pk: MiniscriptKey> PreTaprootDescriptorTrait<Pk> for Wpkh<Pk> {}
+
+    impl<Pk: MiniscriptKey> PreTaprootDescriptorTrait<Pk> for Wsh<Pk> {}
+
+    impl<Pk: MiniscriptKey> PreTaprootDescriptorTrait<Pk> for PreTaprootDescriptor<Pk> {}
+}

src/descriptor/tr.rs

@@ -60,7 +60,13 @@ impl<Pk: MiniscriptKey> Clone for Tr<Pk> {
         Self {
             internal_key: self.internal_key.clone(),
             tree: self.tree.clone(),
-            spend_info: Mutex::new(self.spend_info.lock().expect("Lock poisoned").clone()),
+            spend_info: Mutex::new(
+                self.spend_info
+                    .lock()
+                    .expect("Lock poisoned")
+                    .as_ref()
+                    .map(Arc::clone),
+            ),
         }
     }
 }
@@ -216,7 +222,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
         // read only panics if the lock is poisoned (meaning other thread having a lock panicked)
         let read_lock = self.spend_info.lock().expect("Lock poisoned");
         if let Some(ref spend_info) = *read_lock {
-            return spend_info.clone();
+            return Arc::clone(spend_info);
         }
         drop(read_lock);
 
@@ -260,7 +266,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
             }
         };
         let spend_info = Arc::new(data);
-        *self.spend_info.lock().expect("Lock poisoned") = Some(spend_info.clone());
+        *self.spend_info.lock().expect("Lock poisoned") = Some(Arc::clone(&spend_info));
         spend_info
     }
 }

src/lib.rs

@@ -129,6 +129,8 @@ pub use miniscript::decode::Terminal;
 pub use miniscript::satisfy::{Preimage32, Satisfier};
 pub use miniscript::Miniscript;
 
+pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
+
 ///Public key trait which can be converted to Hash type
 pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
     /// Check if the publicKey is uncompressed. The default