Slight improvements to hash module - take 2 (#376)

* [core] add Debug impls to hash abstractions

* [core] add Write impl for std builds of hash::Wrap

core/src/hash/accumulator.rs

@@ -12,6 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(feature = "std")]
+use ::std::io::{
+    Result as IoResult,
+    Write,
+};
 use ink_prelude::vec::Vec;
 
 /// Hash builder that accumulates a buffer on the contract side.
@@ -74,6 +79,18 @@ pub struct Wrap<'a> {
     len: usize,
 }
 
+#[cfg(feature = "std")]
+impl<'a> Write for Wrap<'a> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        <Self as Accumulator>::write(self, buf);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        Ok(())
+    }
+}
+
 impl<'a> From<&'a mut [u8]> for Wrap<'a> {
     fn from(buffer: &'a mut [u8]) -> Self {
         Self { buffer, len: 0 }

core/src/hash/builder.rs

@@ -24,6 +24,7 @@ use core::marker::PhantomData;
 ///
 /// This means that a hash builder with this type as accumulator cannot
 /// build hashes for instances based on their SCALE encoding.
+#[derive(Debug)]
 pub enum NoAccumulator {}
 
 /// Generic hash builder to construct hashes given a builder strategy.
@@ -42,6 +43,7 @@ pub enum NoAccumulator {}
 /// - [`Keccak256`](`crate::hash::Keccak256`)
 /// - [`Blake2x256`](`crate::hash::Blake2x256`)
 /// - [`Blake2x128`](`crate::hash::Blake2x128`)
+#[derive(Debug)]
 pub struct HashBuilder<H, S = NoAccumulator> {
     /// The strategy used to build up the hash.
     strategy: S,

core/src/hash/hasher.rs

@@ -47,17 +47,21 @@ macro_rules! impl_hasher_for {
 }
 impl_hasher_for! {
     /// SHA2 256-bit hasher.
+    #[derive(Debug)]
     struct Sha2x256Hasher(sha2_256, 32);
 }
 impl_hasher_for! {
     /// KECCAK 256-bit hasher.
+    #[derive(Debug)]
     struct Keccak256Hasher(keccak_256, 32);
 }
 impl_hasher_for! {
     /// BLAKE2 256-bit hasher.
+    #[derive(Debug)]
     struct Blake2x256Hasher(blake2_256, 32);
 }
 impl_hasher_for! {
     /// BLAKE2 128-bit hasher.
+    #[derive(Debug)]
     struct Blake2x128Hasher(blake2_128, 16);
 }