diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md
index 187017a..3637ddb 100644
--- a/packages/storage/Readme.md
+++ b/packages/storage/Readme.md
@@ -348,7 +348,7 @@ To insert, remove, read from the keymap, do the following:
 #
 # let mut deps = mock_dependencies();
 # let info = mock_info("sender", &[]);
-# pub static ADDR_VOTE: Keymap<Addr, Foo> = KeymapBuilder::new(b"page_vote").with_page_size(13).build();
+# pub static ADDR_VOTE: Keymap<&Addr, Foo> = KeymapBuilder::new(b"page_vote").with_page_size(13).build();
 #
 let user_addr: Addr = info.sender;
 
@@ -384,7 +384,7 @@ Here are some select examples from the unit tests:
 fn test_keymap_iter_keys() -> StdResult<()> {
     let mut storage = MockStorage::new();
 
-    let keymap: Keymap<String, Foo> = Keymap::new(b"test");
+    let keymap: Keymap<&str, Foo> = Keymap::new(b"test");
     let foo1 = Foo {
         string: "string one".to_string(),
         number: 1111,
@@ -394,19 +394,19 @@ fn test_keymap_iter_keys() -> StdResult<()> {
         number: 1111,
     };
 
-    let key1 = "key1".to_string();
-    let key2 = "key2".to_string();
+    let key1 = "key1";
+    let key2 = "key2";
 
-    keymap.insert(&mut storage, &key1, &foo1)?;
-    keymap.insert(&mut storage, &key2, &foo2)?;
+    keymap.insert(&mut storage, key1, &foo1)?;
+    keymap.insert(&mut storage, key2, &foo2)?;
 
     let mut x = keymap.iter_keys(&storage)?;
     let (len, _) = x.size_hint();
     assert_eq!(len, 2);
 
-    assert_eq!(x.next().unwrap()?, key1);
-
-    assert_eq!(x.next().unwrap()?, key2);
+    // slice types convert to owned types when iterating over keys
+    assert_eq!(x.next().unwrap()?, key1.to_string());
+    assert_eq!(x.next().unwrap()?, key2.to_string());
 
     Ok(())
 }
@@ -422,7 +422,7 @@ fn test_keymap_iter_keys() -> StdResult<()> {
 fn test_keymap_iter() -> StdResult<()> {
     let mut storage = MockStorage::new();
 
-    let keymap: Keymap<Vec<u8>, Foo> = Keymap::new(b"test");
+    let keymap: Keymap<&[u8], Foo> = Keymap::new(b"test");
     let foo1 = Foo {
         string: "string one".to_string(),
         number: 1111,
@@ -432,15 +432,14 @@ fn test_keymap_iter() -> StdResult<()> {
         number: 1111,
     };
 
-    keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-    keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?;
+    keymap.insert(&mut storage, b"key1", &foo1)?;
+    keymap.insert(&mut storage, b"key2", &foo2)?;
 
     let mut x = keymap.iter(&storage)?;
     let (len, _) = x.size_hint();
     assert_eq!(len, 2);
 
     assert_eq!(x.next().unwrap()?.1, foo1);
-
     assert_eq!(x.next().unwrap()?.1, foo2);
 
     Ok(())
diff --git a/packages/storage/src/de.rs b/packages/storage/src/de.rs
index e5c3673..4c3b2e2 100644
--- a/packages/storage/src/de.rs
+++ b/packages/storage/src/de.rs
@@ -3,6 +3,7 @@ use std::convert::TryInto;
 
 use cosmwasm_std::{Addr, StdError, StdResult};
 use serde::{Serialize, de::DeserializeOwned};
+use crate::int_key::IntKey;
 
 pub trait KeyDeserialize {
     type Output: Sized + DeserializeOwned + Serialize;
@@ -102,7 +103,7 @@ macro_rules! integer_de {
 
             #[inline(always)]
             fn from_vec(value: Vec<u8>) -> StdResult<Self::Output> {
-                Ok(<$t>::from_be_bytes(value.as_slice().try_into()
+                Ok(<$t>::from_cw_bytes(value.as_slice().try_into()
                     .map_err(|err: TryFromSliceError| StdError::generic_err(err.to_string()))?))
             }
         })*
diff --git a/packages/storage/src/int_key.rs b/packages/storage/src/int_key.rs
new file mode 100644
index 0000000..0292674
--- /dev/null
+++ b/packages/storage/src/int_key.rs
@@ -0,0 +1,130 @@
+use std::mem;
+
+/// Our int keys are simply the big-endian representation bytes for unsigned ints,
+/// but "sign-flipped" (xored msb) big-endian bytes for signed ints.
+///
+/// So that the representation of signed integers is in the right lexicographical order.
+pub trait IntKey: Sized + Copy {
+    type Buf: AsRef<[u8]> + AsMut<[u8]> + Into<Vec<u8>> + Default;
+
+    fn to_cw_bytes(&self) -> Self::Buf;
+    fn from_cw_bytes(bytes: Self::Buf) -> Self;
+}
+
+macro_rules! cw_uint_keys {
+    (for $($t:ty),+) => {
+        $(impl IntKey for $t {
+            type Buf = [u8; mem::size_of::<$t>()];
+
+            #[inline]
+            fn to_cw_bytes(&self) -> Self::Buf {
+                self.to_be_bytes()
+            }
+
+            #[inline]
+            fn from_cw_bytes(bytes: Self::Buf) -> Self {
+                Self::from_be_bytes(bytes)
+            }
+        })*
+    }
+}
+
+cw_uint_keys!(for u8, u16, u32, u64, u128);
+
+macro_rules! cw_int_keys {
+    (for $($t:ty, $ut:ty),+) => {
+        $(impl IntKey for $t {
+            type Buf = [u8; mem::size_of::<$t>()];
+
+            #[inline]
+            fn to_cw_bytes(&self) -> Self::Buf {
+                (*self as $ut ^ <$t>::MIN as $ut).to_be_bytes()
+            }
+
+            #[inline]
+            fn from_cw_bytes(bytes: Self::Buf) -> Self {
+                (Self::from_be_bytes(bytes) as $ut ^ <$t>::MIN as $ut) as _
+            }
+        })*
+    }
+}
+
+cw_int_keys!(for i8, u8, i16, u16, i32, u32, i64, u64, i128, u128);
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn x8_int_key_works() {
+        assert_eq!(0x42u8.to_cw_bytes(), [0x42]);
+        assert_eq!(0x42i8.to_cw_bytes(), [0xc2]);
+        assert_eq!((-0x3ei8).to_cw_bytes(), [0x42]);
+    }
+
+    #[test]
+    fn x16_int_key_works() {
+        assert_eq!(0x4243u16.to_cw_bytes(), [0x42, 0x43]);
+        assert_eq!(0x4243i16.to_cw_bytes(), [0xc2, 0x43]);
+        assert_eq!((-0x3dbdi16).to_cw_bytes(), [0x42, 0x43]);
+    }
+
+    #[test]
+    fn x32_int_key_works() {
+        assert_eq!(0x424344u32.to_cw_bytes(), [0x00, 0x42, 0x43, 0x44]);
+        assert_eq!(0x424344i32.to_cw_bytes(), [0x80, 0x42, 0x43, 0x44]);
+        assert_eq!((-0x7fbdbcbci32).to_cw_bytes(), [0x00, 0x42, 0x43, 0x44]);
+    }
+
+    #[test]
+    fn x64_int_key_works() {
+        assert_eq!(
+            0x42434445u64.to_cw_bytes(),
+            [0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44, 0x45]
+        );
+        assert_eq!(
+            0x42434445i64.to_cw_bytes(),
+            [0x80, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44, 0x45]
+        );
+        assert_eq!(
+            (-0x7fffffffbdbcbbbbi64).to_cw_bytes(),
+            [0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44, 0x45]
+        );
+    }
+
+    #[test]
+    fn x128_int_key_works() {
+        assert_eq!(
+            0x4243444546u128.to_cw_bytes(),
+            [
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44,
+                0x45, 0x46
+            ]
+        );
+        assert_eq!(
+            0x4243444546i128.to_cw_bytes(),
+            [
+                0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44,
+                0x45, 0x46
+            ]
+        );
+        assert_eq!(
+            (-0x7fffffffffffffffffffffbdbcbbbabai128).to_cw_bytes(),
+            [
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x44,
+                0x45, 0x46
+            ]
+        );
+    }
+
+    #[test]
+    fn unsigned_int_key_order() {
+        assert!(0u32.to_cw_bytes() < 652u32.to_cw_bytes());
+    }
+
+    #[test]
+    fn signed_int_key_order() {
+        assert!((-321i32).to_cw_bytes() < 0i32.to_cw_bytes());
+        assert!(0i32.to_cw_bytes() < 652i32.to_cw_bytes());
+    }
+}
diff --git a/packages/storage/src/keymap.rs b/packages/storage/src/keymap.rs
index 02e9895..450b5eb 100644
--- a/packages/storage/src/keymap.rs
+++ b/packages/storage/src/keymap.rs
@@ -200,33 +200,33 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// user facing get function
-    pub fn get(&self, storage: &dyn Storage, key: &K) -> Option<T> {
+    pub fn get(&self, storage: &dyn Storage, key: K) -> Option<T> {
         self.get_from_key(storage, key).ok()
     }
 
     /// internal item get function
-    fn get_from_key(&self, storage: &dyn Storage, key: &K) -> StdResult<T> {
-        let key_vec = self.serialize_key(key)?;
+    fn get_from_key(&self, storage: &dyn Storage, key: K) -> StdResult<T> {
+        let key_vec = self.serialize_key(&key)?;
         self.load_impl(storage, &key_vec)
     }
 
     /// user facing remove function
-    pub fn remove(&self, storage: &mut dyn Storage, key: &K) -> StdResult<()> {
-        let key_vec = self.serialize_key(key)?;
+    pub fn remove(&self, storage: &mut dyn Storage, key: K) -> StdResult<()> {
+        let key_vec = self.serialize_key(&key)?;
         self.remove_impl(storage, &key_vec);
 
         Ok(())
     }
 
     /// user facing insert function
-    pub fn insert(&self, storage: &mut dyn Storage, key: &K, item: &T) -> StdResult<()> {
-        let key_vec = self.serialize_key(key)?;
+    pub fn insert(&self, storage: &mut dyn Storage, key: K, item: &T) -> StdResult<()> {
+        let key_vec = self.serialize_key(&key)?;
         self.save_impl(storage, &key_vec, item)
     }
 
     /// user facing method that checks if any item is stored with this key.
-    pub fn contains(&self, storage: &dyn Storage, key: &K) -> bool {
-        match self.serialize_key(key) {
+    pub fn contains(&self, storage: &dyn Storage, key: K) -> bool {
+        match self.serialize_key(&key) {
             Ok(key_vec) => self.contains_impl(storage, &key_vec),
             Err(_) => false,
         }
@@ -328,7 +328,7 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// user facing get function
-    pub fn get(&self, storage: &dyn Storage, key: &K) -> Option<T> {
+    pub fn get(&self, storage: &dyn Storage, key: K) -> Option<T> {
         if let Ok(internal_item) = self.get_from_key(storage, key) {
             internal_item.get_item().ok()
         } else {
@@ -337,8 +337,8 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// internal item get function
-    fn get_from_key(&self, storage: &dyn Storage, key: &K) -> StdResult<InternalItem<T, Ser>> {
-        let key_vec = self.serialize_key(key)?;
+    fn get_from_key(&self, storage: &dyn Storage, key: K) -> StdResult<InternalItem<T, Ser>> {
+        let key_vec = self.serialize_key(&key)?;
         self.load_impl(storage, &key_vec)
     }
 
@@ -348,8 +348,8 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// user facing remove function
-    pub fn remove(&self, storage: &mut dyn Storage, key: &K) -> StdResult<()> {
-        let key_vec = self.serialize_key(key)?;
+    pub fn remove(&self, storage: &mut dyn Storage, key: K) -> StdResult<()> {
+        let key_vec = self.serialize_key(&key)?;
 
         let removed_pos = self.get_from_key(storage, key)?.index_pos.unwrap();
 
@@ -411,8 +411,8 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// user facing insert function
-    pub fn insert(&self, storage: &mut dyn Storage, key: &K, item: &T) -> StdResult<()> {
-        let key_vec = self.serialize_key(key)?;
+    pub fn insert(&self, storage: &mut dyn Storage, key: K, item: &T) -> StdResult<()> {
+        let key_vec = self.serialize_key(&key)?;
 
         match self.may_load_impl(storage, &key_vec)? {
             Some(existing_internal_item) => {
@@ -437,8 +437,8 @@ impl<'a, K: Serialize + KeyDeserialize, T: Serialize + DeserializeOwned, Ser: Se
     }
 
     /// user facing method that checks if any item is stored with this key.
-    pub fn contains(&self, storage: &dyn Storage, key: &K) -> bool {
-        match self.serialize_key(key) {
+    pub fn contains(&self, storage: &dyn Storage, key: K) -> bool {
+        match self.serialize_key(&key) {
             Ok(key_vec) => self.contains_impl(storage, &key_vec),
             Err(_) => false,
         }
@@ -1008,7 +1008,7 @@ mod tests {
 
         for i in 0..total_items {
             let key: Vec<u8> = (i as i32).to_be_bytes().to_vec();
-            keymap.insert(&mut storage, &key, &i)?;
+            keymap.insert(&mut storage, key, &i)?;
         }
 
         assert_eq!(keymap.get_len(&storage)?, 1000);
@@ -1025,11 +1025,11 @@ mod tests {
         let keymap: Keymap<i32, i32> = Keymap::new(b"test");
 
         for i in 0..total_items {
-            keymap.insert(&mut storage, &i, &i)?;
+            keymap.insert(&mut storage, i, &i)?;
         }
 
         for i in 0..total_items {
-            keymap.remove(&mut storage, &i)?;
+            keymap.remove(&mut storage, i)?;
         }
 
         assert_eq!(keymap.get_len(&storage)?, 0);
@@ -1047,7 +1047,7 @@ mod tests {
 
         for i in 0..total_items {
             let key: Vec<u8> = (i as i32).to_be_bytes().to_vec();
-            keymap.insert(&mut storage, &key, &i)?;
+            keymap.insert(&mut storage, key, &i)?;
         }
 
         for i in 0..((total_items / page_size) - 1) {
@@ -1075,7 +1075,7 @@ mod tests {
         let keymap: Keymap<i32, u32> = Keymap::new(b"test");
 
         for i in 0..total_items {
-            keymap.insert(&mut storage, &(i as i32), &i)?;
+            keymap.insert(&mut storage, i as i32, &i)?;
         }
 
         let values = keymap.paging_keys(&storage, 0, page_size)?;
@@ -1103,17 +1103,117 @@ mod tests {
             number: 1111,
         };
 
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-        keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?;
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo1)?;
+        keymap.insert(&mut storage, b"key2".to_vec(), &foo2)?;
 
-        let read_foo1 = keymap.get(&storage, &b"key1".to_vec()).unwrap();
-        let read_foo2 = keymap.get(&storage, &b"key2".to_vec()).unwrap();
+        let read_foo1 = keymap.get(&storage, b"key1".to_vec()).unwrap();
+        let read_foo2 = keymap.get(&storage, b"key2".to_vec()).unwrap();
 
         assert_eq!(foo1, read_foo1);
         assert_eq!(foo2, read_foo2);
         Ok(())
     }
 
+    #[test]
+    fn test_keymap_insert_multiple_borrowed_keys_bytes() -> StdResult<()> {
+        let mut storage = MockStorage::new();
+
+        let keymap: Keymap<&[u8], Foo> = Keymap::new(b"test");
+        let foo1 = Foo {
+            string: "string one".to_string(),
+            number: 1111,
+        };
+        let foo2 = Foo {
+            string: "string two".to_string(),
+            number: 1111,
+        };
+
+        keymap.insert(&mut storage, b"key1", &foo1)?;
+        keymap.insert(&mut storage, b"key2", &foo2)?;
+
+        let read_foo1 = keymap.get(&storage, b"key1").unwrap();
+        let read_foo2 = keymap.get(&storage, b"key2").unwrap();
+
+        assert_eq!(foo1, read_foo1);
+        assert_eq!(foo2, read_foo2);
+
+        let is_foo1 = keymap.contains(&storage, b"key1");
+        let is_foo2 = keymap.contains(&storage, b"key2");
+
+        assert!(is_foo1);
+        assert!(is_foo2);
+
+        // test iter
+        let mut x = keymap.iter(&storage)?;
+        let (len, _) = x.size_hint();
+        assert_eq!(len, 2);
+
+        // keys are returned with ownership
+        assert_eq!(x.next().unwrap()?, (b"key1".to_vec(), foo1));
+        assert_eq!(x.next().unwrap()?, (b"key2".to_vec(), foo2));
+
+        // test iter keys
+        let mut x = keymap.iter_keys(&storage)?;
+        let (len, _) = x.size_hint();
+        assert_eq!(len, 2);
+
+        // keys are returned with ownership
+        assert_eq!(x.next().unwrap()?, (b"key1".to_vec()));
+        assert_eq!(x.next().unwrap()?, (b"key2".to_vec()));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_keymap_insert_multiple_borrowed_keys_str() -> StdResult<()> {
+        let mut storage = MockStorage::new();
+
+        let keymap: Keymap<&str, Foo> = Keymap::new(b"test");
+        let foo1 = Foo {
+            string: "string one".to_string(),
+            number: 1111,
+        };
+        let foo2 = Foo {
+            string: "string two".to_string(),
+            number: 1111,
+        };
+
+        keymap.insert(&mut storage, "key1", &foo1)?;
+        keymap.insert(&mut storage, "key2", &foo2)?;
+
+        let read_foo1 = keymap.get(&storage, "key1").unwrap();
+        let read_foo2 = keymap.get(&storage, "key2").unwrap();
+
+        assert_eq!(foo1, read_foo1);
+        assert_eq!(foo2, read_foo2);
+
+        let is_foo1 = keymap.contains(&storage, "key1");
+        let is_foo2 = keymap.contains(&storage, "key2");
+
+        assert!(is_foo1);
+        assert!(is_foo2);
+
+        // test iter
+        let mut x = keymap.iter(&storage)?;
+        let (len, _) = x.size_hint();
+        assert_eq!(len, 2);
+
+        // keys are returned with ownership
+        assert_eq!(x.next().unwrap()?, ("key1".to_string(), foo1));
+        assert_eq!(x.next().unwrap()?, ("key2".to_string(), foo2));
+
+        // test iter keys
+        let mut x = keymap.iter_keys(&storage)?;
+        let (len, _) = x.size_hint();
+        assert_eq!(len, 2);
+
+        // keys are returned with ownership
+        assert_eq!(x.next().unwrap()?, ("key1".to_string()));
+        assert_eq!(x.next().unwrap()?, ("key2".to_string()));
+
+        Ok(())
+    }
+
     #[test]
     fn test_keymap_contains() -> StdResult<()> {
         let mut storage = MockStorage::new();
@@ -1124,8 +1224,8 @@ mod tests {
             number: 1111,
         };
 
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-        let contains_k1 = keymap.contains(&storage, &b"key1".to_vec());
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo1)?;
+        let contains_k1 = keymap.contains(&storage, b"key1".to_vec());
 
         assert!(contains_k1);
 
@@ -1146,8 +1246,8 @@ mod tests {
             number: 1111,
         };
 
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-        keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?;
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo1)?;
+        keymap.insert(&mut storage, b"key2".to_vec(), &foo2)?;
 
         let mut x = keymap.iter(&storage)?;
         let (len, _) = x.size_hint();
@@ -1177,8 +1277,8 @@ mod tests {
         let key1 = "key1".to_string();
         let key2 = "key2".to_string();
 
-        keymap.insert(&mut storage, &key1, &foo1)?;
-        keymap.insert(&mut storage, &key2, &foo2)?;
+        keymap.insert(&mut storage, key1.clone(), &foo1)?;
+        keymap.insert(&mut storage, key2.clone(), &foo2)?;
 
         let mut x = keymap.iter_keys(&storage)?;
         let (len, _) = x.size_hint();
@@ -1205,10 +1305,10 @@ mod tests {
             number: 2222,
         };
 
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo2)?;
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo1)?;
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo2)?;
 
-        let foo3 = keymap.get(&storage, &b"key1".to_vec()).unwrap();
+        let foo3 = keymap.get(&storage, b"key1".to_vec()).unwrap();
 
         assert_eq!(foo3, foo2);
 
@@ -1229,11 +1329,11 @@ mod tests {
             string: "string one".to_string(),
             number: 1111,
         };
-        keymap.insert(&mut storage, &"key1".to_string(), &foo1)?;
-        keymap.insert(&mut storage, &"key2".to_string(), &foo2)?;
+        keymap.insert(&mut storage, "key1".to_string(), &foo1)?;
+        keymap.insert(&mut storage, "key2".to_string(), &foo2)?;
 
-        let read_foo1 = keymap.get(&storage, &"key1".to_string()).unwrap();
-        let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap();
+        let read_foo1 = keymap.get(&storage, "key1".to_string()).unwrap();
+        let read_foo2 = keymap.get(&storage, "key2".to_string()).unwrap();
 
         assert_eq!(original_keymap.get_len(&storage)?, 0);
         assert_eq!(foo1, read_foo1);
@@ -1245,16 +1345,16 @@ mod tests {
         assert!(alt_same_suffix.is_empty(&storage)?);
 
         // show that it loads foo1 before removal
-        let before_remove_foo1 = keymap.get(&storage, &"key1".to_string());
+        let before_remove_foo1 = keymap.get(&storage, "key1".to_string());
         assert!(before_remove_foo1.is_some());
         assert_eq!(foo1, before_remove_foo1.unwrap());
         // and returns None after removal
-        keymap.remove(&mut storage, &"key1".to_string())?;
-        let removed_foo1 = keymap.get(&storage, &"key1".to_string());
+        keymap.remove(&mut storage, "key1".to_string())?;
+        let removed_foo1 = keymap.get(&storage, "key1".to_string());
         assert!(removed_foo1.is_none());
 
         // show what happens when reading from keys that have not been set yet.
-        assert!(keymap.get(&storage, &"key3".to_string()).is_none());
+        assert!(keymap.get(&storage, "key3".to_string()).is_none());
 
         Ok(())
     }
@@ -1289,27 +1389,27 @@ mod tests {
         let key1 = "k1".to_string();
         let key2 = "k2".to_string();
 
-        keymap.insert(&mut storage, &key1, &foo1)?;
+        keymap.insert(&mut storage, key1.clone(), &foo1)?;
         assert_eq!(keymap.get_len(&storage)?, 1);
         assert!(keymap.length.lock().unwrap().eq(&Some(1)));
 
         // add another item
-        keymap.insert(&mut storage, &key2, &foo2)?;
+        keymap.insert(&mut storage, key2.clone(), &foo2)?;
         assert_eq!(keymap.get_len(&storage)?, 2);
         assert!(keymap.length.lock().unwrap().eq(&Some(2)));
 
         // remove item and check length
-        keymap.remove(&mut storage, &key1)?;
+        keymap.remove(&mut storage, key1)?;
         assert_eq!(keymap.get_len(&storage)?, 1);
         assert!(keymap.length.lock().unwrap().eq(&Some(1)));
 
         // override item (should not change length)
-        keymap.insert(&mut storage, &key2, &foo1)?;
+        keymap.insert(&mut storage, key2.clone(), &foo1)?;
         assert_eq!(keymap.get_len(&storage)?, 1);
         assert!(keymap.length.lock().unwrap().eq(&Some(1)));
 
         // remove item and check length
-        keymap.remove(&mut storage, &key2)?;
+        keymap.remove(&mut storage, key2)?;
         assert_eq!(keymap.get_len(&storage)?, 0);
         assert!(keymap.length.lock().unwrap().eq(&Some(0)));
 
@@ -1340,20 +1440,20 @@ mod tests {
             string: "string one".to_string(),
             number: 1111,
         };
-        keymap.insert(&mut storage, &"key1".to_string(), &foo1)?;
-        keymap.insert(&mut storage, &"key2".to_string(), &foo2)?;
+        keymap.insert(&mut storage, "key1".to_string(), &foo1)?;
+        keymap.insert(&mut storage, "key2".to_string(), &foo2)?;
 
-        let read_foo1 = keymap.get(&storage, &"key1".to_string()).unwrap();
-        let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap();
+        let read_foo1 = keymap.get(&storage, "key1".to_string()).unwrap();
+        let read_foo2 = keymap.get(&storage, "key2".to_string()).unwrap();
 
         assert_eq!(foo1, read_foo1);
         assert_eq!(foo2, read_foo2);
-        assert!(keymap.contains(&storage, &"key1".to_string()));
+        assert!(keymap.contains(&storage, "key1".to_string()));
 
-        keymap.remove(&mut storage, &"key1".to_string())?;
+        keymap.remove(&mut storage, "key1".to_string())?;
 
-        let read_foo1 = keymap.get(&storage, &"key1".to_string());
-        let read_foo2 = keymap.get(&storage, &"key2".to_string()).unwrap();
+        let read_foo1 = keymap.get(&storage, "key1".to_string());
+        let read_foo2 = keymap.get(&storage, "key2".to_string()).unwrap();
 
         assert!(read_foo1.is_none());
         assert_eq!(foo2, read_foo2);
@@ -1371,7 +1471,7 @@ mod tests {
 
         for i in 0..total_items {
             let key: Vec<u8> = (i as i32).to_be_bytes().to_vec();
-            keymap.insert(&mut storage, &key, &i)?;
+            keymap.insert(&mut storage, key, &i)?;
         }
 
         for i in 0..((total_items / page_size) - 1) {
@@ -1399,7 +1499,7 @@ mod tests {
         let keymap: Keymap<i32, u32, Json> = KeymapBuilder::new(b"test").with_page_size(3).build();
 
         for i in 0..total_items {
-            keymap.insert(&mut storage, &(i as i32), &i)?;
+            keymap.insert(&mut storage, i as i32, &i)?;
         }
 
         let values = keymap.paging_keys(&storage, 0, page_size)?;
@@ -1431,9 +1531,9 @@ mod tests {
             number: 1111,
         };
 
-        keymap.insert(&mut storage, &b"key1".to_vec(), &foo1)?;
-        keymap.insert(&mut storage, &b"key2".to_vec(), &foo2)?;
-        keymap.insert(&mut storage, &b"key3".to_vec(), &foo3)?;
+        keymap.insert(&mut storage, b"key1".to_vec(), &foo1)?;
+        keymap.insert(&mut storage, b"key2".to_vec(), &foo2)?;
+        keymap.insert(&mut storage, b"key3".to_vec(), &foo3)?;
 
         let mut x = keymap.iter(&storage)?;
         let (len, _) = x.size_hint();
@@ -1464,10 +1564,10 @@ mod tests {
         let keymap: Keymap<i32, i32> = KeymapBuilder::new(b"test")
             .with_page_size(page_size)
             .build();
-        keymap.insert(&mut storage, &1234, &1234)?;
-        keymap.insert(&mut storage, &2143, &2143)?;
-        keymap.insert(&mut storage, &3412, &3412)?;
-        keymap.insert(&mut storage, &4321, &4321)?;
+        keymap.insert(&mut storage, 1234, &1234)?;
+        keymap.insert(&mut storage, 2143, &2143)?;
+        keymap.insert(&mut storage, 3412, &3412)?;
+        keymap.insert(&mut storage, 4321, &4321)?;
 
         let mut iter = keymap.iter(&storage)?.rev();
         assert_eq!(iter.next(), Some(Ok((4321, 4321))));
@@ -1514,7 +1614,7 @@ mod tests {
         let keymap: Keymap<i32, i32> = KeymapBuilder::new(b"test")
             .with_page_size(page_size)
             .build();
-        keymap.insert(&mut storage, &1234, &1234)?;
+        keymap.insert(&mut storage, 1234, &1234)?;
 
         let page_key = [keymap.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat();
         if keymap.page_size == 1 {
@@ -1532,7 +1632,7 @@ mod tests {
         let json_keymap: Keymap<i32, i32, Json> = KeymapBuilder::new(b"test2")
             .with_page_size(page_size)
             .build();
-        json_keymap.insert(&mut storage, &1234, &1234)?;
+        json_keymap.insert(&mut storage, 1234, &1234)?;
 
         let key = [json_keymap.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat();
         if json_keymap.page_size == 1 {
diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs
index b5d5b91..5769304 100644
--- a/packages/storage/src/lib.rs
+++ b/packages/storage/src/lib.rs
@@ -6,6 +6,7 @@ pub mod item;
 pub mod keymap;
 pub mod keyset;
 pub mod de;
+mod int_key;
 
 pub use append_store::AppendStore;
 pub use deque_store::DequeStore;