Use XXH32 instead of sha256 for const hashing

crates/primitives/Cargo.toml

@@ -19,7 +19,7 @@ derive_more = { version = "0.99", default-features = false, features = ["from",
 ink_prelude = { version = "4.0.0-alpha.1", path = "../prelude/", default-features = false }
 scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive", "full"] }
 scale-info = { version = "2", default-features = false, features = ["derive"], optional = true }
-sha2-const = { version = "0.1.2", default-features = false }
+const-fnv1a-hash = "1.1.0"
 
 [features]
 default = ["std"]

crates/primitives/src/key.rs

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use const_fnv1a_hash::fnv1a_hash_32;
 use ink_prelude::vec;
-use sha2_const::Sha256;
 
 /// A key into the smart contract storage.
 ///
@@ -33,18 +33,12 @@ impl KeyComposer {
     /// Concatenate two `Key` into one during compilation.
     pub const fn concat(left: Key, right: Key) -> Key {
         // If one of the keys is zero, then return another without hashing.
-        // If both keys are non-zero, return the hash of both keys.
+        // If both keys are non-zero, return the hash of the XOR difference of both keys.
         match (left, right) {
             (0, 0) => 0,
             (0, _) => right,
             (_, 0) => left,
-            (left, right) => {
-                let hash = Sha256::new()
-                    .update(&left.to_be_bytes())
-                    .update(&right.to_be_bytes())
-                    .finalize();
-                Key::from_be_bytes([hash[0], hash[1], hash[2], hash[3]])
-            }
+            (left, right) => fnv1a_hash_32(&(left ^ right).to_be_bytes(), None),
         }
     }
 
@@ -59,8 +53,7 @@ impl KeyComposer {
             return 0
         }
 
-        let hash = Sha256::new().update(bytes).finalize();
-        Key::from_be_bytes([hash[0], hash[1], hash[2], hash[3]])
+        fnv1a_hash_32(bytes, None)
     }
 
     /// Evaluates the storage key of the field in the structure, variant or union.
@@ -69,8 +62,7 @@ impl KeyComposer {
     /// 1. If `variant_name` is not empty then computes the ASCII byte representation and call it `V`.
     /// 1. Compute the ASCII byte representation of `field_name` and call it `F`.
     /// 1. Concatenate (`S` and `F`) or (`S`, `V` and `F`) using `::` as separator and call it `C`.
-    /// 1. Apply the `SHA2` 256-bit hash `H` of `C`.
-    /// 1. The first 4 bytes of `H` make up the storage key.
+    /// 1. The `FNV1A` 32-bit hash of `C` is the storage key.
     ///
     /// # Note
     ///
@@ -99,7 +91,6 @@ impl KeyComposer {
         } else {
             vec![struct_name.as_bytes(), field_name.as_bytes()].join(separator)
         };
-
         Ok(Self::from_bytes(composed_key.as_slice()))
     }
 }
@@ -119,33 +110,33 @@ mod tests {
     fn concat_works_correct() {
         assert_eq!(KeyComposer::concat(0, 13), 13);
         assert_eq!(KeyComposer::concat(31, 0), 31);
-        assert_eq!(KeyComposer::concat(31, 13), 0xD83A5CD8);
+        assert_eq!(KeyComposer::concat(31, 13), 0x3995d8bf);
         assert_eq!(KeyComposer::concat(0, 0), 0);
     }
 
     #[test]
     fn from_str_works_correct() {
         assert_eq!(KeyComposer::from_str(""), 0);
-        assert_eq!(KeyComposer::from_str("123"), 0xa665a459);
-        assert_eq!(KeyComposer::from_str("Hello world"), 0x64ec88ca);
+        assert_eq!(KeyComposer::from_str("123"), 0x7238631b);
+        assert_eq!(KeyComposer::from_str("Hello world"), 0x594d29c7);
     }
 
     #[test]
     fn from_bytes_works_correct() {
         assert_eq!(KeyComposer::from_bytes(b""), 0);
-        assert_eq!(KeyComposer::from_bytes(b"123"), 0xa665a459);
-        assert_eq!(KeyComposer::from_bytes(b"Hello world"), 0x64ec88ca);
+        assert_eq!(KeyComposer::from_bytes(b"123"), 0x7238631b);
+        assert_eq!(KeyComposer::from_bytes(b"Hello world"), 0x594d29c7);
     }
 
     #[test]
     fn compute_key_works_correct() {
         assert_eq!(
             KeyComposer::compute_key("Contract", "", "balances"),
-            Ok(0x05e859ec)
+            Ok(0xe26930c6)
         );
         assert_eq!(
             KeyComposer::compute_key("Enum", "Variant", "0"),
-            Ok(0x9d029590)
+            Ok(0x9e253b67)
         );
         assert_eq!(
             KeyComposer::compute_key("", "Variant", "0"),