Add Hash256 type

Implement a new hash type that does not displat/fromstr in backwards
direction.
We need support for support for double hashing, but if we use upstream
sha256d::Hash, our FromString/Display requirements break

Author: sanket1729

src/lib.rs

@@ -135,7 +135,7 @@ pub use crate::interpreter::Interpreter;
 pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use crate::miniscript::decode::Terminal;
 pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
-pub use crate::miniscript::Miniscript;
+pub use crate::miniscript::{hash256, Miniscript};
 use crate::prelude::*;
 
 ///Public key trait which can be converted to Hash type

src/miniscript/hash256.rs

@@ -0,0 +1,132 @@
+// Miniscript
+// Written in 2022 by
+//     Sanket Kanjalkar <[email protected]>
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//! Hash256 type
+//!
+//! Functionality similar to `sha256d` Hash type in bitcoin, but the FromStr
+//! `Display` are *NOT* REVERSE.
+//!
+
+// use bitcoin::hashes::sha256d;
+
+// /// Wrapper for [`sha256d::Hash`]. The only difference between [`sha256d::Hash`]
+// /// and [`Hash256`] is that this does not do a reverse serialization from string.
+// #[derive(Debug, Copy, Clone, Ord, PartialEq, PartialOrd, Eq, Hash, Default)]
+// pub struct Hash256(sha256d::Hash);
+
+// impl Hash256 {
+//     /// Obtains [`Hash256`] from inner [`sha256d::Hash`]
+//     pub fn from_inner(h: sha256d::Hash) -> sha256d::Hash {
+//         Self(h)
+//     }
+
+//     /// Obtains the inner [`sha256d::Hash`]
+//     pub fn into_inner(self) -> sha256d::Hash {
+//         self.0
+//     }
+
+//     /// Obtains a reference to the inner [`sha256d::Hash`]
+//     pub fn as_inner(&self) -> &sha256d::Hash {
+//         &self.0
+//     }
+// }
+
+// impl From<sha256d::Hash> for Hash256 {
+//     fn from(hash: sha256d::Hash) -> Self {
+//         Self(hash)
+//     }
+// }
+
+// impl FromStr for Hash256 {
+//     type Err;
+
+//     fn from_str(s: &str) -> Result<Self, Self::Err> {
+//         todo!()
+//     }
+// }
+use core::str;
+
+use bitcoin::hashes::{
+    self, borrow_slice_impl, hex, hex_fmt_impl, index_impl, serde_impl, sha256, Hash as HashTrait,
+};
+
+/// Output of the SHA256d hash function
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct Hash(
+    #[cfg_attr(
+        feature = "schemars",
+        schemars(schema_with = "crate::util::json_hex_string::len_32")
+    )]
+    [u8; 32],
+);
+
+hex_fmt_impl!(Debug, Hash);
+hex_fmt_impl!(Display, Hash);
+hex_fmt_impl!(LowerHex, Hash);
+index_impl!(Hash);
+serde_impl!(Hash, 32);
+borrow_slice_impl!(Hash);
+
+impl str::FromStr for Hash {
+    type Err = hex::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        hex::FromHex::from_hex(s)
+    }
+}
+
+impl HashTrait for Hash {
+    type Engine = sha256::HashEngine;
+    type Inner = [u8; 32];
+
+    fn engine() -> sha256::HashEngine {
+        sha256::Hash::engine()
+    }
+
+    fn from_engine(e: sha256::HashEngine) -> Hash {
+        let sha2 = sha256::Hash::from_engine(e);
+        let sha2d = sha256::Hash::hash(&sha2[..]);
+
+        let mut ret = [0; 32];
+        ret.copy_from_slice(&sha2d[..]);
+        Hash(ret)
+    }
+
+    const LEN: usize = 32;
+
+    fn from_slice(sl: &[u8]) -> Result<Hash, hashes::Error> {
+        if sl.len() != 32 {
+            Err(hashes::Error::InvalidLength(Self::LEN, sl.len()))
+        } else {
+            let mut ret = [0; 32];
+            ret.copy_from_slice(sl);
+            Ok(Hash(ret))
+        }
+    }
+
+    /// sha256d has DISPLAY_BACKWARD as true
+    const DISPLAY_BACKWARD: bool = false;
+
+    fn into_inner(self) -> Self::Inner {
+        self.0
+    }
+
+    fn as_inner(&self) -> &Self::Inner {
+        &self.0
+    }
+
+    fn from_inner(inner: Self::Inner) -> Self {
+        Hash(inner)
+    }
+}

src/miniscript/mod.rs

@@ -37,6 +37,7 @@ pub mod analyzable;
 pub mod astelem;
 pub(crate) mod context;
 pub mod decode;
+pub mod hash256;
 pub mod iter;
 pub mod lex;
 pub mod limits;