refactor: Update LookupMap to allow and default to identity keys (#674)

near-sdk/src/environment/mod.rs

@@ -1,8 +1,5 @@
 pub mod env;
 
-#[cfg(feature = "unstable")]
-pub mod hash;
-
 #[cfg(not(target_arch = "wasm32"))]
 /// Mock blockchain utilities. These can only be used inside tests and are not available for
 /// a wasm32 target.

near-sdk/src/lib.rs

@@ -13,9 +13,6 @@ pub use near_sdk_macros::{
 #[cfg(feature = "unstable")]
 pub mod store;
 
-#[cfg(feature = "unstable")]
-pub use environment::hash as crypto_hash;
-
 pub mod collections;
 mod environment;
 pub use environment::env;

near-sdk/src/store/key.rs

@@ -0,0 +1,78 @@
+use borsh::BorshSerialize;
+
+use crate::env;
+
+mod private {
+    /// Seal `ToKey` implementations to limit usage to the builtin implementations
+    pub trait Sealed {}
+
+    impl Sealed for super::Sha256 {}
+    impl Sealed for super::Keccak256 {}
+    impl Sealed for super::Identity {}
+}
+
+/// Trait used to generate keys to store data based on a serializable structure.
+pub trait ToKey: self::private::Sealed {
+    /// Output type for the generated lookup key.
+    type KeyType: AsRef<[u8]>;
+
+    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    where
+        Q: BorshSerialize;
+}
+
+/// Sha256 hash helper which hashes through a syscall. This type satisfies the [`ToKey`] trait.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Sha256 {}
+
+impl ToKey for Sha256 {
+    type KeyType = [u8; 32];
+
+    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    where
+        Q: BorshSerialize,
+    {
+        // Prefix the serialized bytes, then hash the combined value.
+        buffer.extend(prefix);
+        key.serialize(buffer).unwrap_or_else(|_| env::abort());
+
+        env::sha256_array(buffer)
+    }
+}
+
+/// Keccak256 hash helper which hashes through a syscall. This type satisfies the [`ToKey`] trait.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Keccak256 {}
+
+impl ToKey for Keccak256 {
+    type KeyType = [u8; 32];
+
+    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    where
+        Q: BorshSerialize,
+    {
+        // Prefix the serialized bytes, then hash the combined value.
+        buffer.extend(prefix);
+        key.serialize(buffer).unwrap_or_else(|_| env::abort());
+
+        env::keccak256_array(buffer)
+    }
+}
+
+/// Identity hash which just prefixes all of the serializes bytes and uses it as the key.
+pub enum Identity {}
+
+impl ToKey for Identity {
+    type KeyType = Vec<u8>;
+
+    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    where
+        Q: BorshSerialize,
+    {
+        // Prefix the serialized bytes and return a copy of this buffer.
+        buffer.extend(prefix);
+        key.serialize(buffer).unwrap_or_else(|_| env::abort());
+
+        buffer.clone()
+    }
+}

near-sdk/src/store/lookup_map/impls.rs

@@ -2,14 +2,14 @@ use std::borrow::Borrow;
 
 use borsh::{BorshDeserialize, BorshSerialize};
 
-use super::{LookupMap, ERR_NOT_EXIST};
-use crate::{crypto_hash::CryptoHasher, env};
+use super::{LookupMap, ToKey, ERR_NOT_EXIST};
+use crate::env;
 
 impl<K, V, H> Extend<(K, V)> for LookupMap<K, V, H>
 where
     K: BorshSerialize + Ord,
     V: BorshSerialize,
-    H: CryptoHasher<Digest = [u8; 32]>,
+    H: ToKey,
 {
     fn extend<I>(&mut self, iter: I)
     where
@@ -23,9 +23,10 @@ where
 
 impl<K, V, H, Q: ?Sized> core::ops::Index<&Q> for LookupMap<K, V, H>
 where
-    K: BorshSerialize + Ord + Clone + Borrow<Q>,
+    K: BorshSerialize + Ord + Borrow<Q>,
     V: BorshSerialize + BorshDeserialize,
-    H: CryptoHasher<Digest = [u8; 32]>,
+    H: ToKey,
+
     Q: BorshSerialize + ToOwned<Owned = K>,
 {
     type Output = V;