Simple Mapping Storage Primitive

crates/storage/src/collections/mapping/mod.rs

@@ -0,0 +1,152 @@
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A simple mapping to contract storage.
+
+use crate::traits::{
+    clear_spread_root,
+    pull_packed_root_opt,
+    pull_spread_root,
+    push_packed_root,
+    push_spread_root,
+    ExtKeyPtr,
+    KeyPtr,
+    PackedLayout,
+    SpreadLayout,
+};
+
+use core::marker::PhantomData;
+
+use ink_env::hash::{
+    Blake2x256,
+    HashOutput,
+};
+use ink_primitives::Key;
+
+/// A mapping of key-value pairs directly into contract storage.
+///
+/// If a key does not exist the `Default` value for the `value` will be returned.
+#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
+pub struct Mapping<K, V> {
+    key: Key,
+    _marker: PhantomData<(K, V)>,
+}
+
+impl<K, V> Mapping<K, V>
+where
+    K: PackedLayout,
+    V: PackedLayout,
+{
+    /// Creates a new empty `Mapping`.
+    ///
+    /// Not sure how this should be exposed/initialize irl.
+    pub fn new(key: Key) -> Self {
+        Self {
+            key,
+            _marker: Default::default(),
+        }
+    }
+
+    /// Insert the given `value` to the contract storage.
+    pub fn insert(&mut self, key: K, value: V) {
+        push_packed_root(&value, &self.key(&key));
+    }
+
+    /// Get the `value` at `key` from the contract storage.
+    ///
+    /// Returns `None` if no `value` exists at the given `key`.
+    pub fn get(&self, key: &K) -> Option<V> {
+        pull_packed_root_opt(&self.key(key))
+    }
+
+    fn key(&self, key: &K) -> Key {
+        let encodedable_key = (self.key, key);
+        let mut output = <Blake2x256 as HashOutput>::Type::default();
+        ink_env::hash_encoded::<Blake2x256, _>(&encodedable_key, &mut output);
+        output.into()
+    }
+}
+
+impl<K, V> SpreadLayout for Mapping<K, V> {
+    const FOOTPRINT: u64 = 1;
+    const REQUIRES_DEEP_CLEAN_UP: bool = false;
+
+    #[inline]
+    fn pull_spread(ptr: &mut KeyPtr) -> Self {
+        let root_key = ExtKeyPtr::next_for::<Self>(ptr);
+        pull_spread_root::<Self>(root_key)
+    }
+
+    #[inline]
+    fn push_spread(&self, ptr: &mut KeyPtr) {
+        let root_key = ExtKeyPtr::next_for::<Self>(ptr);
+        push_spread_root::<Self>(self, root_key);
+    }
+
+    #[inline]
+    fn clear_spread(&self, ptr: &mut KeyPtr) {
+        let root_key = ExtKeyPtr::next_for::<Self>(ptr);
+        clear_spread_root::<Self>(self, root_key);
+    }
+}
+
+#[cfg(feature = "std")]
+const _: () = {
+    use crate::traits::StorageLayout;
+    use ink_metadata::layout::{
+        CellLayout,
+        Layout,
+        LayoutKey,
+    };
+
+    impl<K, V> StorageLayout for Mapping<K, V>
+    where
+        K: scale_info::TypeInfo + 'static,
+        V: scale_info::TypeInfo + 'static,
+    {
+        fn layout(key_ptr: &mut KeyPtr) -> Layout {
+            Layout::Cell(CellLayout::new::<Self>(LayoutKey::from(
+                key_ptr.advance_by(1),
+            )))
+        }
+    }
+};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn insert_and_get_work() {
+        ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+            let mut mapping = Mapping::new([0u8; 32].into());
+            mapping.insert(1, 2);
+            assert_eq!(mapping.get(&1), Some(2));
+
+            Ok(())
+        })
+        .unwrap()
+    }
+
+    #[test]
+    fn gets_default_if_no_key_set() {
+        ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+            let mapping: Mapping<u8, u8> = Mapping::new([0u8; 32].into());
+            assert_eq!(mapping.get(&1), None);
+
+            Ok(())
+        })
+        .unwrap()
+    }
+}

crates/storage/src/collections/mod.rs

@@ -22,6 +22,7 @@ pub mod binary_heap;
 pub mod bitstash;
 pub mod bitvec;
 pub mod hashmap;
+pub mod mapping;
 pub mod smallvec;
 pub mod stash;
 pub mod vec;
@@ -32,6 +33,7 @@ pub use self::{
     bitstash::BitStash,
     bitvec::Bitvec,
     hashmap::HashMap,
+    mapping::Mapping,
     stash::Stash,
     vec::Vec,
 };

crates/storage/src/traits/spread.rs

@@ -30,8 +30,8 @@ pub trait SpreadLayout {
     ///
     /// # Examples
     ///
-    /// An instance of type `i32` requires one storage cell, so its footprint is
-    /// 1. An instance of type `(i32, i32)` requires 2 storage cells since a
+    /// An instance of type `i32` requires one storage cell, so its footprint is 1.
+    /// An instance of type `(i32, i32)` requires 2 storage cells since a
     /// tuple or any other combined data structure always associates disjunctive
     /// cells for its sub types. The same applies to arrays, e.g. `[i32; 5]`
     /// has a footprint of 5.

examples/erc20/lib.rs

@@ -6,7 +6,7 @@ use ink_lang as ink;
 mod erc20 {
     #[cfg(not(feature = "ink-as-dependency"))]
     use ink_storage::{
-        collections::HashMap as StorageHashMap,
+        collections::mapping::Mapping,
         lazy::Lazy,
     };
 
@@ -16,10 +16,10 @@ mod erc20 {
         /// Total token supply.
         total_supply: Lazy<Balance>,
         /// Mapping from owner to number of owned token.
-        balances: StorageHashMap<AccountId, Balance>,
+        balances: Mapping<AccountId, Balance>,
         /// Mapping of the token amount which an account is allowed to withdraw
         /// from another account.
-        allowances: StorageHashMap<(AccountId, AccountId), Balance>,
+        allowances: Mapping<(AccountId, AccountId), Balance>,
     }
 
     /// Event emitted when a token transfer occurs.
@@ -61,12 +61,12 @@ mod erc20 {
         #[ink(constructor)]
         pub fn new(initial_supply: Balance) -> Self {
             let caller = Self::env().caller();
-            let mut balances = StorageHashMap::new();
+            let mut balances = Mapping::new([1u8; 32].into());
             balances.insert(caller, initial_supply);
             let instance = Self {
                 total_supply: Lazy::new(initial_supply),
                 balances,
-                allowances: StorageHashMap::new(),
+                allowances: Mapping::new([1u8; 32].into()),
             };
             Self::env().emit_event(Transfer {
                 from: None,
@@ -87,15 +87,15 @@ mod erc20 {
         /// Returns `0` if the account is non-existent.
         #[ink(message)]
         pub fn balance_of(&self, owner: AccountId) -> Balance {
-            self.balances.get(&owner).copied().unwrap_or(0)
+            self.balances.get(&owner).unwrap_or_default() // .copied().unwrap_or(0)
         }
 
         /// Returns the amount which `spender` is still allowed to withdraw from `owner`.
         ///
         /// Returns `0` if no allowance has been set `0`.
         #[ink(message)]
         pub fn allowance(&self, owner: AccountId, spender: AccountId) -> Balance {
-            self.allowances.get(&(owner, spender)).copied().unwrap_or(0)
+            self.allowances.get(&(owner, spender)).unwrap_or_default() //.copied().unwrap_or(0)
         }
 
         /// Transfers `value` amount of tokens from the caller's account to account `to`.