Add Hash256 associated type

Author: sanket1729

src/descriptor/key.rs

@@ -10,7 +10,7 @@ use bitcoin::util::bip32;
 use bitcoin::{self, XOnlyPublicKey, XpubIdentifier};
 
 use crate::prelude::*;
-use crate::{MiniscriptKey, ToPublicKey};
+use crate::{hash256, MiniscriptKey, ToPublicKey};
 
 /// The descriptor pubkey, either a single pubkey or an xpub.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
@@ -737,7 +737,8 @@ impl<K: InnerXKey> DescriptorXKey<K> {
 impl MiniscriptKey for DescriptorPublicKey {
     // This allows us to be able to derive public keys even for PkH s
     type Hash = Self;
-    type Sha256 = bitcoin::hashes::sha256::Hash;
+    type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn is_uncompressed(&self) -> bool {
         match self {
@@ -803,7 +804,8 @@ impl fmt::Display for DerivedDescriptorKey {
 impl MiniscriptKey for DerivedDescriptorKey {
     // This allows us to be able to derive public keys even for PkH s
     type Hash = Self;
-    type Sha256 = bitcoin::hashes::sha256::Hash;
+    type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn is_uncompressed(&self) -> bool {
         self.key.is_uncompressed()
@@ -831,6 +833,10 @@ impl ToPublicKey for DerivedDescriptorKey {
     fn to_sha256(hash: &sha256::Hash) -> sha256::Hash {
         *hash
     }
+
+    fn to_hash256(hash: &hash256::Hash) -> hash256::Hash {
+        *hash
+    }
 }
 
 #[cfg(test)]

src/descriptor/mod.rs

@@ -37,8 +37,8 @@ use self::checksum::verify_checksum;
 use crate::miniscript::{Legacy, Miniscript, Segwitv0};
 use crate::prelude::*;
 use crate::{
-    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, PkTranslator,
-    Satisfier, ToPublicKey, TranslatePk, Translator,
+    expression, hash256, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey,
+    PkTranslator, Satisfier, ToPublicKey, TranslatePk, Translator,
 };
 
 mod bare;
@@ -646,6 +646,12 @@ impl Descriptor<DescriptorPublicKey> {
                     sha256::Hash::from_str(sha256).map_err(|e| Error::Unexpected(e.to_string()))?;
                 Ok(hash)
             }
+
+            fn hash256(&mut self, hash256: &String) -> Result<hash256::Hash, Error> {
+                let hash = hash256::Hash::from_str(hash256)
+                    .map_err(|e| Error::Unexpected(e.to_string()))?;
+                Ok(hash)
+            }
         }
 
         let descriptor = Descriptor::<String>::from_str(s)?;
@@ -672,6 +678,10 @@ impl Descriptor<DescriptorPublicKey> {
             fn sha256(&mut self, sha256: &sha256::Hash) -> Result<String, ()> {
                 Ok(sha256.to_string())
             }
+
+            fn hash256(&mut self, hash256: &hash256::Hash) -> Result<String, ()> {
+                Ok(hash256.to_string())
+            }
         }
 
         fn key_to_string(pk: &DescriptorPublicKey, key_map: &KeyMap) -> Result<String, ()> {

src/interpreter/mod.rs

@@ -23,14 +23,14 @@ use core::fmt;
 use core::str::FromStr;
 
 use bitcoin::blockdata::witness::Witness;
-use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
+use bitcoin::hashes::{hash160, ripemd160, sha256};
 use bitcoin::util::{sighash, taproot};
 use bitcoin::{self, secp256k1, TxOut};
 
 use crate::miniscript::context::NoChecks;
 use crate::miniscript::ScriptContext;
 use crate::prelude::*;
-use crate::{Descriptor, Miniscript, Terminal, ToPublicKey};
+use crate::{hash256, Descriptor, Miniscript, Terminal, ToPublicKey};
 
 mod error;
 mod inner;
@@ -149,7 +149,8 @@ impl TypedHash160 {
 
 impl MiniscriptKey for BitcoinKey {
     type Hash = TypedHash160;
-    type Sha256 = bitcoin::hashes::sha256::Hash;
+    type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         match self {
@@ -454,7 +455,7 @@ pub enum HashLockType {
     ///SHA 256 hashlock
     Sha256(sha256::Hash),
     ///Hash 256 hashlock
-    Hash256(sha256d::Hash),
+    Hash256(hash256::Hash),
     ///Hash160 hashlock
     Hash160(hash160::Hash),
     ///Ripemd160 hashlock
@@ -1030,7 +1031,7 @@ fn verify_sersig<'txin>(
 mod tests {
 
     use bitcoin;
-    use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+    use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
     use bitcoin::secp256k1::{self, Secp256k1};
 
     use super::inner::ToNoChecks;
@@ -1146,11 +1147,8 @@ mod tests {
         let preimage = [0xab as u8; 32];
         let sha256_hash = sha256::Hash::hash(&preimage);
         let sha256 = no_checks_ms(&format!("sha256({})", sha256_hash));
-        let sha256d_hash_rev = sha256d::Hash::hash(&preimage);
-        let mut sha256d_hash_bytes = sha256d_hash_rev.clone().into_inner();
-        sha256d_hash_bytes.reverse();
-        let sha256d_hash = sha256d::Hash::from_inner(sha256d_hash_bytes);
-        let hash256 = no_checks_ms(&format!("hash256({})", sha256d_hash));
+        let hash256_hash = hash256::Hash::hash(&preimage);
+        let hash256 = no_checks_ms(&format!("hash256({})", hash256_hash));
         let hash160_hash = hash160::Hash::hash(&preimage);
         let hash160 = no_checks_ms(&format!("hash160({})", hash160_hash));
         let ripemd160_hash = ripemd160::Hash::hash(&preimage);
@@ -1232,7 +1230,7 @@ mod tests {
         assert_eq!(
             sha256d_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
-                hash: HashLockType::Hash256(sha256d_hash_rev),
+                hash: HashLockType::Hash256(hash256_hash),
                 preimage: preimage,
             }]
         );

src/interpreter/stack.rs

@@ -16,12 +16,13 @@
 
 use bitcoin;
 use bitcoin::blockdata::{opcodes, script};
-use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
 
 use super::error::PkEvalErrInner;
 use super::{
     verify_sersig, BitcoinKey, Error, HashLockType, KeySigPair, SatisfiedConstraint, TypedHash160,
 };
+use crate::hash256;
 use crate::prelude::*;
 
 /// Definition of Stack Element of the Stack used for interpretation of Miniscript.
@@ -290,13 +291,13 @@ impl<'txin> Stack<'txin> {
     /// `SIZE 32 EQUALVERIFY HASH256 h EQUAL`
     pub(super) fn evaluate_hash256(
         &mut self,
-        hash: &sha256d::Hash,
+        hash: &hash256::Hash,
     ) -> Option<Result<SatisfiedConstraint, Error>> {
         if let Some(Element::Push(preimage)) = self.pop() {
             if preimage.len() != 32 {
                 return Some(Err(Error::HashPreimageLengthMismatch));
             }
-            if sha256d::Hash::hash(preimage) == *hash {
+            if hash256::Hash::hash(preimage) == *hash {
                 self.push(Element::Satisfied);
                 Some(Ok(SatisfiedConstraint::HashLock {
                     hash: HashLockType::Hash256(*hash),

src/lib.rs

@@ -152,20 +152,26 @@ pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Ha
         false
     }
 
-    /// The associated [`Hash`] type for this pubkey.
+    /// The associated PublicKey Hash for this [`MiniscriptKey`],
+    /// used in the hash256 fragment.
     type Hash: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 
-    /// The associated [`sha256::Hash`] type for this [`MiniscriptKey`] type.
-    /// Used in the sha256 fragment
+    /// The associated [`sha256::Hash`] for this [`MiniscriptKey`],
+    /// used in the hash256 fragment.
     type Sha256: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 
+    /// The associated [`hash256::Hash`] for this [`MiniscriptKey`],
+    /// used in the hash256 fragment.
+    type Hash256: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
+
     /// Converts this key to the associated pubkey hash.
     fn to_pubkeyhash(&self) -> Self::Hash;
 }
 
 impl MiniscriptKey for bitcoin::secp256k1::PublicKey {
     type Hash = hash160::Hash;
     type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         hash160::Hash::hash(&self.serialize())
@@ -180,6 +186,7 @@ impl MiniscriptKey for bitcoin::PublicKey {
 
     type Hash = hash160::Hash;
     type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         hash160::Hash::hash(&self.to_bytes())
@@ -189,6 +196,7 @@ impl MiniscriptKey for bitcoin::PublicKey {
 impl MiniscriptKey for bitcoin::secp256k1::XOnlyPublicKey {
     type Hash = hash160::Hash;
     type Sha256 = sha256::Hash;
+    type Hash256 = hash256::Hash;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         hash160::Hash::hash(&self.serialize())
@@ -202,6 +210,7 @@ impl MiniscriptKey for bitcoin::secp256k1::XOnlyPublicKey {
 impl MiniscriptKey for String {
     type Hash = String;
     type Sha256 = String; // specify hashes as string
+    type Hash256 = String;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         (&self).to_string()
@@ -229,6 +238,9 @@ pub trait ToPublicKey: MiniscriptKey {
 
     /// Converts the generic associated [`MiniscriptKey::Sha256`] to [`sha256::Hash`]
     fn to_sha256(hash: &<Self as MiniscriptKey>::Sha256) -> sha256::Hash;
+
+    /// Converts the generic associated [`MiniscriptKey::Hash256`] to [`hash256::Hash`]
+    fn to_hash256(hash: &<Self as MiniscriptKey>::Hash256) -> hash256::Hash;
 }
 
 impl ToPublicKey for bitcoin::PublicKey {
@@ -243,6 +255,10 @@ impl ToPublicKey for bitcoin::PublicKey {
     fn to_sha256(hash: &sha256::Hash) -> sha256::Hash {
         *hash
     }
+
+    fn to_hash256(hash: &hash256::Hash) -> hash256::Hash {
+        *hash
+    }
 }
 
 impl ToPublicKey for bitcoin::secp256k1::PublicKey {
@@ -257,6 +273,10 @@ impl ToPublicKey for bitcoin::secp256k1::PublicKey {
     fn to_sha256(hash: &sha256::Hash) -> sha256::Hash {
         *hash
     }
+
+    fn to_hash256(hash: &hash256::Hash) -> hash256::Hash {
+        *hash
+    }
 }
 
 impl ToPublicKey for bitcoin::secp256k1::XOnlyPublicKey {
@@ -280,6 +300,10 @@ impl ToPublicKey for bitcoin::secp256k1::XOnlyPublicKey {
     fn to_sha256(hash: &sha256::Hash) -> sha256::Hash {
         *hash
     }
+
+    fn to_hash256(hash: &hash256::Hash) -> hash256::Hash {
+        *hash
+    }
 }
 
 /// Dummy key which de/serializes to the empty string; useful sometimes for testing
@@ -300,6 +324,7 @@ impl str::FromStr for DummyKey {
 impl MiniscriptKey for DummyKey {
     type Hash = DummyKeyHash;
     type Sha256 = DummySha256Hash;
+    type Hash256 = DummyHash256;
 
     fn to_pubkeyhash(&self) -> Self::Hash {
         DummyKeyHash
@@ -334,6 +359,11 @@ impl ToPublicKey for DummyKey {
         sha256::Hash::from_str("50863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352")
             .unwrap()
     }
+
+    fn to_hash256(_hash: &DummyHash256) -> hash256::Hash {
+        hash256::Hash::from_str("50863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352")
+            .unwrap()
+    }
 }
 
 /// Dummy keyhash which de/serializes to the empty string; useful sometimes for testing
@@ -390,8 +420,34 @@ impl hash::Hash for DummySha256Hash {
     }
 }
 
-/// Describes an object that can translate various keys and hashes from one key to the type
-/// associated with the other key. Used by the [`TranslatePk`] trait to do the actual translations.
+/// Dummy keyhash which de/serializes to the empty string; useful for testing
+#[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Debug)]
+pub struct DummyHash256;
+
+impl str::FromStr for DummyHash256 {
+    type Err = &'static str;
+    fn from_str(x: &str) -> Result<DummyHash256, &'static str> {
+        if x.is_empty() {
+            Ok(DummyHash256)
+        } else {
+            Err("non empty dummy hash")
+        }
+    }
+}
+
+impl fmt::Display for DummyHash256 {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("")
+    }
+}
+
+impl hash::Hash for DummyHash256 {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        "DummySha256Hash".hash(state);
+    }
+}
+
+/// Provides the conversion information required in [`TranslatePk`]
 pub trait Translator<P, Q, E>
 where
     P: MiniscriptKey,
@@ -403,8 +459,11 @@ where
     /// Translates public key hashes P::Hash -> Q::Hash.
     fn pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;
 
-    /// Translates sha256 hashes from P::Sha256 -> Q::Sha256
+    /// Provides the translation from P::Sha256 -> Q::Sha256
     fn sha256(&mut self, sha256: &P::Sha256) -> Result<Q::Sha256, E>;
+
+    /// Provides the translation from P::Hash256 -> Q::Hash256
+    fn hash256(&mut self, hash256: &P::Hash256) -> Result<Q::Hash256, E>;
 }
 
 /// Provides the conversion information required in [`TranslatePk`].
@@ -426,7 +485,7 @@ impl<P, Q, E, T> Translator<P, Q, E> for T
 where
     T: PkTranslator<P, Q, E>,
     P: MiniscriptKey,
-    Q: MiniscriptKey<Sha256 = P::Sha256>,
+    Q: MiniscriptKey<Sha256 = P::Sha256, Hash256 = P::Hash256>,
 {
     fn pk(&mut self, pk: &P) -> Result<Q, E> {
         <Self as PkTranslator<P, Q, E>>::pk(self, pk)
@@ -439,6 +498,10 @@ where
     fn sha256(&mut self, sha256: &<P as MiniscriptKey>::Sha256) -> Result<<Q>::Sha256, E> {
         Ok(sha256.clone())
     }
+
+    fn hash256(&mut self, hash256: &<P as MiniscriptKey>::Hash256) -> Result<<Q>::Hash256, E> {
+        Ok(hash256.clone())
+    }
 }
 
 /// Converts a descriptor using abstract keys to one using specific keys. Uses translator `t` to do