diff --git a/.gitignore b/.gitignore
index ec061ab..a474c8e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
 lcov.info
 /target
 /Cargo.lock
+dodo.py
+.doit.db*
+__pycache__
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 85ba945..4447b4b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,4 +13,5 @@ keywords = ["CosmWasm"]
 [workspace.dependencies]
 storey = { path = "packages/storey", version = "0.3" }
 storey-encoding = { path = "packages/storey-encoding", version = "0.1" }
+storey-macros = { path = "packages/storey-macros", version = "0.1" }
 storey-storage = { path = "packages/storey-storage", version = "0.1" }
diff --git a/packages/cw-storey/Cargo.toml b/packages/cw-storey/Cargo.toml
index 93979aa..6e9819e 100644
--- a/packages/cw-storey/Cargo.toml
+++ b/packages/cw-storey/Cargo.toml
@@ -16,3 +16,6 @@ rmp-serde = "1.1"
 serde = "1"
 
 storey = { workspace = true }
+
+[dev-dependencies]
+mocks = { path = "../mocks" }
diff --git a/packages/cw-storey/src/backend.rs b/packages/cw-storey/src/backend.rs
index 60594cd..9729be1 100644
--- a/packages/cw-storey/src/backend.rs
+++ b/packages/cw-storey/src/backend.rs
@@ -5,6 +5,7 @@ use storey::storage::{
 };
 
 /// A wrapper around a type implementing [`cosmwasm_std::Storage`] that integrates it with [`storey`].
+#[repr(transparent)]
 pub struct CwStorage<S: ?Sized>(pub S);
 
 impl<S> StorageBackend for CwStorage<S>
@@ -33,9 +34,18 @@ impl<S> IterableStorage for CwStorage<S>
 where
     S: cosmwasm_std::Storage + ?Sized,
 {
-    type KeysIterator<'a> = Box<dyn Iterator<Item = Vec<u8>> + 'a> where Self: 'a;
-    type ValuesIterator<'a> = Box<dyn Iterator<Item = Vec<u8>> + 'a> where Self: 'a;
-    type PairsIterator<'a> = Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> where Self: 'a;
+    type KeysIterator<'a>
+        = Box<dyn Iterator<Item = Vec<u8>> + 'a>
+    where
+        Self: 'a;
+    type ValuesIterator<'a>
+        = Box<dyn Iterator<Item = Vec<u8>> + 'a>
+    where
+        Self: 'a;
+    type PairsIterator<'a>
+        = Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>
+    where
+        Self: 'a;
 
     fn keys<'a>(&'a self, start: Bound<&[u8]>, end: Bound<&[u8]>) -> Self::KeysIterator<'a> {
         let (start, end) = bounds_to_option(start, end);
@@ -72,9 +82,18 @@ impl<S> RevIterableStorage for CwStorage<S>
 where
     S: cosmwasm_std::Storage + ?Sized,
 {
-    type RevKeysIterator<'a> = Box<dyn Iterator<Item = Vec<u8>> + 'a> where Self: 'a;
-    type RevValuesIterator<'a> = Box<dyn Iterator<Item = Vec<u8>> + 'a> where Self: 'a;
-    type RevPairsIterator<'a> = Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a> where Self: 'a;
+    type RevKeysIterator<'a>
+        = Box<dyn Iterator<Item = Vec<u8>> + 'a>
+    where
+        Self: 'a;
+    type RevValuesIterator<'a>
+        = Box<dyn Iterator<Item = Vec<u8>> + 'a>
+    where
+        Self: 'a;
+    type RevPairsIterator<'a>
+        = Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>
+    where
+        Self: 'a;
 
     fn rev_keys<'a>(&'a self, start: Bound<&[u8]>, end: Bound<&[u8]>) -> Self::RevKeysIterator<'a> {
         let (start, end) = bounds_to_option(start, end);
diff --git a/packages/cw-storey/src/containers.rs b/packages/cw-storey/src/containers.rs
deleted file mode 100644
index 7bf97f4..0000000
--- a/packages/cw-storey/src/containers.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! Storage containers for use with [*CosmWasm*] smart contracts.
-//!
-//! [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
-
-/// The [`storey::containers::Item`] type with the default encoding for [*CosmWasm*] smart
-/// contracts.
-///
-/// [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
-pub type Item<T> = storey::containers::Item<T, crate::encoding::CwEncoding>;
-
-/// The [`storey::containers::Column`] type with the default encoding for [*CosmWasm*] smart
-/// contracts.
-///
-/// [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
-pub type Column<T> = storey::containers::Column<T, crate::encoding::CwEncoding>;
-
-pub use storey::containers::Map;
diff --git a/packages/cw-storey/src/containers/key_set.rs b/packages/cw-storey/src/containers/key_set.rs
new file mode 100644
index 0000000..b308469
--- /dev/null
+++ b/packages/cw-storey/src/containers/key_set.rs
@@ -0,0 +1,204 @@
+use cosmwasm_std::{Addr, Int128, Int256, Int512, Int64, Uint128, Uint256, Uint512, Uint64};
+use storey::containers::map::key::{
+    DynamicKey, FixedSizeKey, KeySetDefaults, NumericKeyDecodeError,
+};
+use storey::containers::map::{Key, OwnedKey};
+
+/// The CosmWasm key set for use with storey's [`Map`](storey::containers::Map).
+///
+/// This key set includes the usual standard library types (like `u32` or `String`) as well as `cosmwasm_std` types (like `Addr` and `Uint128`).
+///
+/// For more information about key sets, take a look at the [`storey::containers::map::Key`] trait.
+#[derive(KeySetDefaults)]
+pub struct CwKeySet;
+
+impl Key<CwKeySet> for Addr {
+    type Kind = DynamicKey;
+
+    fn encode(&self) -> Vec<u8> {
+        self.as_str().as_bytes().to_vec()
+    }
+}
+
+impl OwnedKey<CwKeySet> for Addr {
+    type Error = <String as OwnedKey>::Error;
+
+    fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+    where
+        Self: Sized,
+    {
+        <String as OwnedKey>::from_bytes(bytes).map(Addr::unchecked)
+    }
+}
+
+macro_rules! cosmwasm_std_uints1 {
+    ($($ty:ty => $size:expr, $stdty:ty),*) => {
+        $(
+            impl Key<CwKeySet> for $ty {
+                type Kind = FixedSizeKey<$size>;
+
+                fn encode(&self) -> Vec<u8> {
+                    self.to_be_bytes().to_vec()
+                }
+            }
+
+            impl OwnedKey<CwKeySet> for $ty {
+                type Error = NumericKeyDecodeError;
+
+                fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+                where
+                    Self: Sized,
+                {
+                    let array: [u8; $size] = bytes.try_into().map_err(|_| NumericKeyDecodeError::InvalidLength)?;
+                    Ok(<$stdty>::from_be_bytes(array).into())
+                }
+            }
+        )*
+    }
+}
+
+cosmwasm_std_uints1!(
+    Uint64 => 8, u64,
+    Uint128 => 16, u128
+);
+
+macro_rules! cosmwasm_std_uints2 {
+    ($($ty:ty => $size:expr),*) => {
+        $(
+            impl Key<CwKeySet> for $ty {
+                type Kind = FixedSizeKey<$size>;
+
+                fn encode(&self) -> Vec<u8> {
+                    self.to_be_bytes().to_vec()
+                }
+            }
+
+            impl OwnedKey<CwKeySet> for $ty {
+                type Error = NumericKeyDecodeError;
+
+                fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+                where
+                    Self: Sized,
+                {
+                    let array: [u8; $size] = bytes.try_into().map_err(|_| NumericKeyDecodeError::InvalidLength)?;
+                    Ok(<$ty>::from_be_bytes(array))
+                }
+            }
+        )*
+    }
+}
+
+cosmwasm_std_uints2!(
+    Uint256 => 32,
+    Uint512 => 64
+);
+
+macro_rules! cosmwasm_std_ints {
+    ($($ty:ty => $size:expr),*) => {
+        $(
+            impl Key<CwKeySet> for $ty {
+                type Kind = FixedSizeKey<$size>;
+
+                fn encode(&self) -> Vec<u8> {
+                    let mut bytes = self.to_be_bytes();
+                    bytes[0] ^= 0x80;
+
+                    bytes.to_vec()
+                }
+            }
+
+            impl OwnedKey<CwKeySet> for $ty {
+                type Error = NumericKeyDecodeError;
+
+                fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+                where
+                    Self: Sized,
+                {
+                    let mut array: [u8; $size] = bytes.try_into().map_err(|_| NumericKeyDecodeError::InvalidLength)?;
+                    array[0] ^= 0x80;
+
+                    Ok(<$ty>::from_be_bytes(array))
+                }
+            }
+        )*
+    }
+}
+
+cosmwasm_std_ints!(Int64 => 8, Int128 => 16, Int256 => 32, Int512 => 64);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn unsigned_ints_1() {
+        let test_vector = [
+            (Uint64::from(0u64), [0, 0, 0, 0, 0, 0, 0, 0]),
+            (Uint64::from(1u64), [0, 0, 0, 0, 0, 0, 0, 1]),
+            (
+                Uint64::from(0x1234567890abcdefu64),
+                [0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef],
+            ),
+        ];
+
+        for (num, expected) in test_vector.iter() {
+            let encoded = num.encode();
+            assert_eq!(encoded, *expected);
+        }
+
+        for (expected, bytes) in test_vector.iter() {
+            let decoded = Uint64::from_bytes(bytes).unwrap();
+            assert_eq!(decoded, *expected);
+        }
+    }
+
+    #[test]
+    fn unsigned_ints_2() {
+        let test_vector = [
+            (Uint256::from(0u64), [0; 32]),
+            (
+                Uint256::new([
+                    0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90,
+                    0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34,
+                    0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
+                ]),
+                [
+                    0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90,
+                    0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12, 0x34,
+                    0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
+                ],
+            ),
+        ];
+
+        for (num, expected) in test_vector.iter() {
+            let encoded = num.encode();
+            assert_eq!(encoded, *expected);
+        }
+
+        for (expected, bytes) in test_vector.iter() {
+            let decoded = Uint256::from_bytes(bytes).unwrap();
+            assert_eq!(decoded, *expected);
+        }
+    }
+
+    #[test]
+    fn signed_ints() {
+        let nums = [
+            Int256::from(-542),
+            Int256::from(-111),
+            Int256::from(0),
+            Int256::from(121),
+            Int256::from(342),
+        ];
+
+        let mut byte_nums = nums.iter().map(|n| n.encode()).collect::<Vec<_>>();
+        byte_nums.sort();
+
+        let result = byte_nums
+            .iter()
+            .map(|bytes| Int256::from_bytes(bytes).unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(result, nums);
+    }
+}
diff --git a/packages/cw-storey/src/containers/mod.rs b/packages/cw-storey/src/containers/mod.rs
new file mode 100644
index 0000000..2c93b2a
--- /dev/null
+++ b/packages/cw-storey/src/containers/mod.rs
@@ -0,0 +1,43 @@
+//! Storage containers for use with [*CosmWasm*] smart contracts.
+//!
+//! [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
+
+mod key_set;
+
+pub use key_set::CwKeySet;
+
+/// The [`storey::containers::Item`] type with the default encoding for [*CosmWasm*] smart
+/// contracts.
+///
+/// [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
+pub type Item<T> = storey::containers::Item<T, crate::encoding::CwEncoding>;
+
+/// The [`storey::containers::Column`] type with the default encoding for [*CosmWasm*] smart
+/// contracts.
+///
+/// [*CosmWasm*]: https://github.com/CosmWasm/cosmwasm
+pub type Column<T> = storey::containers::Column<T, crate::encoding::CwEncoding>;
+
+/// The [`storey::containers::Map`] type with the [`CwKeySet`] key set, which includes the
+/// usual standard library types (like `u32` or `String`) as well as `cosmwasm_std` types (like `Addr` and `Uint128`).
+pub type Map<K, V> = storey::containers::Map<K, V, CwKeySet>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use cosmwasm_std::Addr;
+    use mocks::backend::TestStorage;
+
+    #[test]
+    fn map_addr() {
+        let map: Map<Addr, Item<u32>> = Map::new(0);
+        let mut storage = TestStorage::new();
+
+        let key = Addr::unchecked("addr1");
+
+        map.access(&mut storage).entry_mut(&key).set(&42).unwrap();
+
+        assert_eq!(map.access(&storage).entry(&key).get().unwrap(), Some(42));
+    }
+}
diff --git a/packages/storey-macros/Cargo.toml b/packages/storey-macros/Cargo.toml
new file mode 100644
index 0000000..4989101
--- /dev/null
+++ b/packages/storey-macros/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "storey-macros"
+version = "0.1.0"
+edition = "2021"
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+categories.workspace = true
+keywords.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+proc-macro-error = "1"
+syn = { version = "2", features = ["full"] }
+quote = "1"
diff --git a/packages/storey-macros/src/key_set.rs b/packages/storey-macros/src/key_set.rs
new file mode 100644
index 0000000..a03fbc3
--- /dev/null
+++ b/packages/storey-macros/src/key_set.rs
@@ -0,0 +1,103 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse_quote, Ident, ItemStruct};
+
+pub fn derive(input: ItemStruct) -> Result<TokenStream, syn::Error> {
+    let name = &input.ident;
+
+    let key_impls = derive_key_impls(name);
+    let owned_key_impls = derive_owned_key_impls(name);
+    let arrays = derive_arrays(name);
+
+    Ok(quote! {
+        #key_impls
+        #owned_key_impls
+        #arrays
+    })
+}
+
+pub fn derive_key_impls(name: &Ident) -> TokenStream {
+    let mut types = get_owned_delegations();
+    types.extend(get_key_only_delegations());
+
+    quote! {
+        #(
+            impl Key<#name> for #types {
+                type Kind = <#types as Key>::Kind;
+
+                fn encode(&self) -> Vec<u8> {
+                    <#types as Key>::encode(self)
+                }
+            }
+        )*
+    }
+}
+
+pub fn derive_owned_key_impls(name: &Ident) -> TokenStream {
+    let types = get_owned_delegations();
+
+    quote! {
+        #(
+            impl OwnedKey<#name> for #types {
+                type Error = <#types as OwnedKey>::Error;
+
+                fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+                where
+                    Self: Sized,
+                {
+                    <#types as OwnedKey>::from_bytes(bytes)
+                }
+            }
+        )*
+    }
+}
+
+pub fn derive_arrays(name: &Ident) -> TokenStream {
+    quote::quote! {
+        impl<const N: usize> Key<#name> for [u8; N] {
+            type Kind = <Self as Key>::Kind;
+
+            fn encode(&self) -> Vec<u8> {
+                <Self as Key>::encode(self)
+            }
+        }
+
+        impl<const N: usize> OwnedKey<#name> for [u8; N] {
+            type Error = <Self as OwnedKey>::Error;
+
+            fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+            where
+                Self: Sized,
+            {
+                <Self as OwnedKey>::from_bytes(bytes)
+            }
+        }
+    }
+}
+
+fn get_owned_delegations() -> Vec<syn::Type> {
+    // these implement both Key and OwnedKey
+
+    vec![
+        parse_quote!(String),
+        parse_quote!(Box<str>),
+        parse_quote!(Vec<u8>),
+        parse_quote!(Box<[u8]>),
+        parse_quote!(u8),
+        parse_quote!(u16),
+        parse_quote!(u32),
+        parse_quote!(u64),
+        parse_quote!(u128),
+        parse_quote!(i8),
+        parse_quote!(i16),
+        parse_quote!(i32),
+        parse_quote!(i64),
+        parse_quote!(i128),
+    ]
+}
+
+fn get_key_only_delegations() -> Vec<syn::Type> {
+    // these implement Key but not OwnedKey
+
+    vec![parse_quote!(str), parse_quote!([u8])]
+}
diff --git a/packages/storey-macros/src/lib.rs b/packages/storey-macros/src/lib.rs
new file mode 100644
index 0000000..ee6b9bd
--- /dev/null
+++ b/packages/storey-macros/src/lib.rs
@@ -0,0 +1,13 @@
+mod key_set;
+
+#[proc_macro_derive(KeySetDefaults)]
+pub fn key_set_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(input as syn::ItemStruct);
+
+    let expanded = match key_set::derive(input) {
+        Ok(res) => res,
+        Err(e) => e.into_compile_error(),
+    };
+
+    proc_macro::TokenStream::from(expanded)
+}
diff --git a/packages/storey/Cargo.toml b/packages/storey/Cargo.toml
index 87c2055..8f41281 100644
--- a/packages/storey/Cargo.toml
+++ b/packages/storey/Cargo.toml
@@ -16,6 +16,7 @@ keywords.workspace = true
 thiserror = "1"
 
 storey-encoding.workspace = true
+storey-macros.workspace = true
 storey-storage.workspace = true
 
 [dev-dependencies]
diff --git a/packages/storey/src/containers/column.rs b/packages/storey/src/containers/column.rs
index 2049a7a..5041660 100644
--- a/packages/storey/src/containers/column.rs
+++ b/packages/storey/src/containers/column.rs
@@ -9,7 +9,9 @@ use crate::storage::{IterableStorage, StorageBranch};
 use crate::storage::{Storage, StorageMut};
 
 use super::common::TryGetError;
-use super::{BoundFor, BoundedIterableAccessor, IterableAccessor, NonTerminal, Storable};
+use super::{
+    BoundFor, BoundedIterableAccessor, IterableAccessor, IterableStorable, NonTerminal, Storable,
+};
 
 /// The first (lowest) ID that is pushed to the column.
 const FIRST_ID: u32 = 1;
@@ -97,25 +99,16 @@ where
     }
 }
 
-impl<T, E> Storable for Column<T, E>
+impl<T, E> IterableStorable for Column<T, E>
 where
     E: Encoding,
     T: EncodableWith<E> + DecodableWith<E>,
 {
-    type Kind = NonTerminal;
-    type Accessor<S> = ColumnAccess<E, T, S>;
     type Key = u32;
     type KeyDecodeError = ColumnIdDecodeError;
     type Value = T;
     type ValueDecodeError = E::DecodeError;
 
-    fn access_impl<S>(storage: S) -> ColumnAccess<E, T, S> {
-        ColumnAccess {
-            storage,
-            phantom: PhantomData,
-        }
-    }
-
     fn decode_key(key: &[u8]) -> Result<Self::Key, ColumnIdDecodeError> {
         let key = decode_id(key)?;
 
@@ -127,6 +120,22 @@ where
     }
 }
 
+impl<T, E> Storable for Column<T, E>
+where
+    E: Encoding,
+    T: EncodableWith<E> + DecodableWith<E>,
+{
+    type Kind = NonTerminal;
+    type Accessor<S> = ColumnAccess<E, T, S>;
+
+    fn access_impl<S>(storage: S) -> ColumnAccess<E, T, S> {
+        ColumnAccess {
+            storage,
+            phantom: PhantomData,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Copy, thiserror::Error)]
 #[error("invalid key length, expected 4 bytes of big-endian u32")]
 pub struct ColumnIdDecodeError;
diff --git a/packages/storey/src/containers/item.rs b/packages/storey/src/containers/item.rs
index a936c01..78d5d2a 100644
--- a/packages/storey/src/containers/item.rs
+++ b/packages/storey/src/containers/item.rs
@@ -7,7 +7,7 @@ use crate::storage::StorageBranch;
 use crate::storage::{Storage, StorageMut};
 
 use super::common::TryGetError;
-use super::{Storable, Terminal};
+use super::{IterableStorable, Storable, Terminal};
 
 /// A single item in the storage.
 ///
@@ -80,10 +80,6 @@ where
 {
     type Kind = Terminal;
     type Accessor<S> = ItemAccess<E, T, S>;
-    type Key = ();
-    type KeyDecodeError = ItemKeyDecodeError;
-    type Value = T;
-    type ValueDecodeError = E::DecodeError;
 
     fn access_impl<S>(storage: S) -> ItemAccess<E, T, S> {
         ItemAccess {
@@ -91,6 +87,17 @@ where
             phantom: PhantomData,
         }
     }
+}
+
+impl<T, E> IterableStorable for Item<T, E>
+where
+    E: Encoding,
+    T: EncodableWith<E> + DecodableWith<E>,
+{
+    type Key = ();
+    type KeyDecodeError = ItemKeyDecodeError;
+    type Value = T;
+    type ValueDecodeError = E::DecodeError;
 
     fn decode_key(key: &[u8]) -> Result<(), ItemKeyDecodeError> {
         if key.is_empty() {
@@ -100,7 +107,7 @@ where
         }
     }
 
-    fn decode_value(value: &[u8]) -> Result<Self::Value, Self::ValueDecodeError> {
+    fn decode_value(value: &[u8]) -> Result<T, E::DecodeError> {
         T::decode(value)
     }
 }
diff --git a/packages/storey/src/containers/map/key.rs b/packages/storey/src/containers/map/key/impls.rs
similarity index 65%
rename from packages/storey/src/containers/map/key.rs
rename to packages/storey/src/containers/map/key/impls.rs
index d4de44d..7489645 100644
--- a/packages/storey/src/containers/map/key.rs
+++ b/packages/storey/src/containers/map/key/impls.rs
@@ -1,22 +1,6 @@
-/// A key that can be used with a [`Map`](super::Map).
-pub trait Key {
-    /// The kind of key, meaning either fixed size or dynamic size.
-    type Kind: KeyKind;
+//! Implementations of the `Key`/`OwnedKey` trait for Rust std types.
 
-    /// Encode the key into a byte vector.
-    fn encode(&self) -> Vec<u8>;
-}
-
-/// An owned key that can be used with a [`Map`](super::Map).
-pub trait OwnedKey: Key {
-    /// The error type that can occur when decoding the key.
-    type Error;
-
-    /// Decode the key from a byte slice.
-    fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
-    where
-        Self: Sized;
-}
+use super::{DynamicKey, FixedSizeKey, Key, OwnedKey};
 
 impl Key for String {
     type Kind = DynamicKey;
@@ -155,31 +139,6 @@ impl<const N: usize> OwnedKey for [u8; N] {
     }
 }
 
-/// A trait specifying the kind of key.
-///
-/// There are two kinds of keys: fixed-size keys and dynamic keys, which are
-/// represented by the [`FixedSizeKey`] and [`DynamicKey`] types, respectively.
-///
-/// This trait is [sealed](https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits)
-/// and cannot be implemented outside of this crate.
-pub trait KeyKind: sealed::KeyKindSeal {}
-
-/// A marker type representing a fixed-size key.
-pub struct FixedSizeKey<const L: usize>;
-
-/// A marker type representing a dynamic-size key.
-pub struct DynamicKey;
-
-impl<const L: usize> KeyKind for FixedSizeKey<L> {}
-impl KeyKind for DynamicKey {}
-
-mod sealed {
-    pub trait KeyKindSeal {}
-
-    impl<const L: usize> KeyKindSeal for super::FixedSizeKey<L> {}
-    impl KeyKindSeal for super::DynamicKey {}
-}
-
 /// An error type for decoding numeric keys.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, thiserror::Error)]
 pub enum NumericKeyDecodeError {
@@ -254,39 +213,3 @@ macro_rules! impl_key_for_signed {
 }
 
 impl_key_for_signed!(i8 : u8, i16 : u16, i32 : u32, i64 : u64, i128 : u128);
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn signed_int_ordering() {
-        let data = [-555555555, -3333, -1, 0, 1, 3333, 55555555];
-
-        let mut encoded = data.iter().map(|&x| x.encode()).collect::<Vec<_>>();
-        encoded.sort();
-
-        let decoded = encoded
-            .iter()
-            .map(|x| i32::from_bytes(x).unwrap())
-            .collect::<Vec<_>>();
-
-        assert_eq!(&data[..], &decoded);
-    }
-
-    #[test]
-    fn signed_int_encoding() {
-        // negative values have the leftmost bit unset
-        assert_eq!((i32::MIN).encode(), [0b00000000, 0x00, 0x00, 0x00]);
-        assert_eq!((-2000i32).encode(), [0b01111111, 0xff, 248, 48]);
-        assert_eq!((-3i32).encode(), [0b01111111, 0xff, 0xff, 0xfd]);
-        assert_eq!((-2i32).encode(), [0b01111111, 0xff, 0xff, 0xfe]);
-        assert_eq!((-1i32).encode(), [0b01111111, 0xff, 0xff, 0xff]);
-
-        // non-negative values are BE encoded, but with the leftmost bit set
-        assert_eq!(0i32.encode(), [0b10000000, 0x00, 0x00, 0x00]);
-        assert_eq!(1i32.encode(), [0b10000000, 0x00, 0x00, 0x01]);
-        assert_eq!(2i32.encode(), [0b10000000, 0x00, 0x00, 0x02]);
-        assert_eq!(i32::MAX.encode(), [0b11111111, 0xff, 0xff, 0xff]);
-    }
-}
diff --git a/packages/storey/src/containers/map/key/key_set.rs b/packages/storey/src/containers/map/key/key_set.rs
new file mode 100644
index 0000000..d4e730a
--- /dev/null
+++ b/packages/storey/src/containers/map/key/key_set.rs
@@ -0,0 +1,4 @@
+/// The default key set for use with a [`Map`](super::super::Map).
+///
+/// To find out more about key sets, take a look at the [`Key`](super::Key) trait's documentation.
+pub struct DefaultKeySet;
diff --git a/packages/storey/src/containers/map/key/kind.rs b/packages/storey/src/containers/map/key/kind.rs
new file mode 100644
index 0000000..8df23b1
--- /dev/null
+++ b/packages/storey/src/containers/map/key/kind.rs
@@ -0,0 +1,24 @@
+/// A trait specifying the kind of key.
+///
+/// There are two kinds of keys: fixed-size keys and dynamic keys, which are
+/// represented by the [`FixedSizeKey`] and [`DynamicKey`] types, respectively.
+///
+/// This trait is [sealed](https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits)
+/// and cannot be implemented outside of this crate.
+pub trait KeyKind: sealed::KeyKindSeal {}
+
+/// A marker type representing a fixed-size key.
+pub struct FixedSizeKey<const L: usize>;
+
+/// A marker type representing a dynamic-size key.
+pub struct DynamicKey;
+
+impl<const L: usize> KeyKind for FixedSizeKey<L> {}
+impl KeyKind for DynamicKey {}
+
+mod sealed {
+    pub trait KeyKindSeal {}
+
+    impl<const L: usize> KeyKindSeal for super::FixedSizeKey<L> {}
+    impl KeyKindSeal for super::DynamicKey {}
+}
diff --git a/packages/storey/src/containers/map/key/mod.rs b/packages/storey/src/containers/map/key/mod.rs
new file mode 100644
index 0000000..5beb45b
--- /dev/null
+++ b/packages/storey/src/containers/map/key/mod.rs
@@ -0,0 +1,141 @@
+mod impls;
+mod key_set;
+mod kind;
+
+pub use impls::{ArrayDecodeError, InvalidUtf8, NumericKeyDecodeError};
+pub use key_set::DefaultKeySet;
+pub use kind::{DynamicKey, FixedSizeKey, KeyKind};
+
+/// When applied to a type `KS`, this derive macro generates implementations of the [`Key<KS>`]
+/// and [`OwnedKey<KS>`] traits for appropriate Rust std types. This mirrors the implementations
+/// that exist for [`Key<DefaultKeySet>`](Key#foreign-impls) and [`OwnedKey<DefaultKeySet>`](OwnedKey#foreign-impls).
+///
+/// The purpose is to allow third-party crates to define their own key set types without
+/// reinventing the wheel for the standard library types.
+///
+/// More about key sets can be found in the [`Key`] trait documentation.
+pub use storey_macros::KeySetDefaults;
+
+/// A key that can be used with a [`Map`](super::Map).
+///
+/// # Key sets
+///
+/// The `KS` type parameter is the "key set" used. This is a marker type that
+/// specifies the kind of keys that can be used with the map. The default key
+/// set is [`DefaultKeySet`]. Providing another key set is an extension mechanism -
+/// third party crates can define their own key set types to support third-party key types,
+/// getting around orphan rules.
+///
+/// # Examples
+///
+/// This example shows how to define an alternative key set type. To use it with a map,
+/// the map also needs to be parameterized with the key set type;
+///
+/// ```
+/// use storey::containers::map::{Key, OwnedKey};
+/// use storey::containers::map::key::{DynamicKey, FixedSizeKey};
+///
+/// pub struct MyKeySet;
+///
+/// // imagine this is a third-party type
+/// pub struct ExtType;
+///
+/// impl Key<MyKeySet> for String {
+///     type Kind = DynamicKey;
+///
+///     fn encode(&self) -> Vec<u8> {
+///         self.as_bytes().to_vec()
+///     }
+/// }
+///
+/// impl OwnedKey<MyKeySet> for String {
+///     type Error = std::string::FromUtf8Error;
+///
+///     fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error> {
+///          String::from_utf8(bytes.to_vec())
+///     }
+/// }
+///
+/// impl Key<MyKeySet> for ExtType {
+///     type Kind = FixedSizeKey<16>;
+///
+///     fn encode(&self) -> Vec<u8> {
+///         todo!()
+///     }
+/// }
+///
+/// impl OwnedKey<MyKeySet> for ExtType {
+///     type Error = ();
+///
+///     fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error> {
+///          todo!()
+///     }
+/// }
+///
+/// // use the key set with a map
+/// let map: storey::containers::map::Map<String, u32, MyKeySet> = storey::containers::map::Map::new(0);
+/// ```
+pub trait Key<KS = DefaultKeySet> {
+    /// The kind of key, meaning either fixed size or dynamic size.
+    type Kind: KeyKind;
+
+    /// Encode the key into a byte vector.
+    fn encode(&self) -> Vec<u8>;
+}
+
+/// An owned key that can be used with a [`Map`](super::Map).
+///
+/// # Key sets
+///
+/// The `KS` type parameter is the "key set" used. This is a marker type that
+/// specifies the kind of keys that can be used with the map. The default key
+/// set is [`DefaultKeySet`]. Providing another key set is an extension mechanism -
+/// third party crates can define their own key set types to support third-party key types,
+/// without bumping into orphan rules.
+///
+/// An example of a custom key set is shown in the [`Key`] trait documentation.
+pub trait OwnedKey<T = DefaultKeySet>: Key<T> {
+    /// The error type that can occur when decoding the key.
+    type Error;
+
+    /// Decode the key from a byte slice.
+    fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error>
+    where
+        Self: Sized;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn signed_int_ordering() {
+        let data = [-555555555, -3333, -1, 0, 1, 3333, 55555555];
+
+        let mut encoded = data.iter().map(|&x| x.encode()).collect::<Vec<_>>();
+        encoded.sort();
+
+        let decoded = encoded
+            .iter()
+            .map(|x| i32::from_bytes(x).unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(&data[..], &decoded);
+    }
+
+    #[test]
+    fn signed_int_encoding() {
+        // negative values have the leftmost bit unset
+        assert_eq!((i32::MIN).encode(), [0b00000000, 0x00, 0x00, 0x00]);
+        assert_eq!((-2000i32).encode(), [0b01111111, 0xff, 248, 48]);
+        assert_eq!((-3i32).encode(), [0b01111111, 0xff, 0xff, 0xfd]);
+        assert_eq!((-2i32).encode(), [0b01111111, 0xff, 0xff, 0xfe]);
+        assert_eq!((-1i32).encode(), [0b01111111, 0xff, 0xff, 0xff]);
+
+        // non-negative values are BE encoded, but with the leftmost bit set
+        assert_eq!(0i32.encode(), [0b10000000, 0x00, 0x00, 0x00]);
+        assert_eq!(1i32.encode(), [0b10000000, 0x00, 0x00, 0x01]);
+        assert_eq!(2i32.encode(), [0b10000000, 0x00, 0x00, 0x02]);
+        assert_eq!(i32::MAX.encode(), [0b11111111, 0xff, 0xff, 0xff]);
+    }
+}
diff --git a/packages/storey/src/containers/map/mod.rs b/packages/storey/src/containers/map/mod.rs
index 5574b23..b93b4c8 100644
--- a/packages/storey/src/containers/map/mod.rs
+++ b/packages/storey/src/containers/map/mod.rs
@@ -1,6 +1,7 @@
 pub mod key;
 mod key_encoding;
 
+use key::DefaultKeySet;
 pub use key::{Key, OwnedKey};
 use key_encoding::KeyEncoding;
 use key_encoding::KeyEncodingT;
@@ -15,6 +16,7 @@ use self::key::FixedSizeKey;
 use super::BoundFor;
 use super::BoundedIterableAccessor;
 use super::IterableAccessor;
+use super::IterableStorable;
 use super::NonTerminal;
 use super::Storable;
 use super::Terminal;
@@ -26,6 +28,16 @@ use super::Terminal;
 /// A map does not directly manage the storage of its values. Instead, it doles out access to
 /// a collection of other containers.
 ///
+/// # Key sets
+///
+/// The `KS` type parameter is the "key set" used. This is a marker type that
+/// specifies the kind of keys that can be used with the map. The default key
+/// set is [`DefaultKeySet`]. Providing another key set is an extension mechanism -
+/// third party crates can define their own key set types to support third-party key types,
+/// without bumping into orphan rules.
+///
+/// An example of a custom key set implementation is shown in the [`Key`] trait documentation.
+///
 /// # Examples
 ///
 /// ```
@@ -55,18 +67,12 @@ use super::Terminal;
 /// assert_eq!(access.entry("foo").entry("bar").get().unwrap(), Some(1337));
 /// assert_eq!(access.entry("foo").entry("baz").get().unwrap(), None);
 /// ```
-pub struct Map<K: ?Sized, V> {
+pub struct Map<K: ?Sized, V, KS = DefaultKeySet> {
     prefix: u8,
-    phantom: PhantomData<(*const K, V)>,
+    phantom: PhantomData<(*const K, V, KS)>,
 }
 
-impl<K, V> Map<K, V>
-where
-    K: OwnedKey,
-    V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
-    (K::Kind, V::Kind): KeyEncodingT,
-{
+impl<K, V, KS> Map<K, V, KS> {
     /// Creates a new map with the given prefix.
     ///
     /// It is the responsibility of the caller to ensure that the prefix is unique and does not conflict
@@ -98,7 +104,7 @@ where
     /// let map = Map::<String, Item<u64, TestEncoding>>::new(0);
     /// let mut access = map.access(&mut storage);
     /// ```
-    pub fn access<F, S>(&self, storage: F) -> MapAccess<K, V, StorageBranch<S>>
+    pub fn access<F, S>(&self, storage: F) -> MapAccess<K, V, StorageBranch<S>, KS>
     where
         (F,): IntoStorage<S>,
     {
@@ -108,26 +114,29 @@ where
     }
 }
 
-impl<K, V> Storable for Map<K, V>
-where
-    K: OwnedKey,
-    V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
-    (K::Kind, V::Kind): KeyEncodingT,
-{
+impl<K, V, KS> Storable for Map<K, V, KS> {
     type Kind = NonTerminal;
-    type Accessor<S> = MapAccess<K, V, S>;
-    type Key = (K, V::Key);
-    type KeyDecodeError = MapKeyDecodeError<V::KeyDecodeError>;
-    type Value = V::Value;
-    type ValueDecodeError = V::ValueDecodeError;
+    type Accessor<S> = MapAccess<K, V, S, KS>;
 
-    fn access_impl<S>(storage: S) -> MapAccess<K, V, S> {
+    fn access_impl<S>(storage: S) -> MapAccess<K, V, S, KS> {
         MapAccess {
             storage,
             phantom: PhantomData,
         }
     }
+}
+
+impl<K, V, KS> IterableStorable for Map<K, V, KS>
+where
+    K: OwnedKey<KS>,
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
+    (K::Kind, V::Kind): KeyEncodingT,
+{
+    type Key = (K, V::Key);
+    type KeyDecodeError = MapKeyDecodeError<V::KeyDecodeError>;
+    type Value = V::Value;
+    type ValueDecodeError = V::ValueDecodeError;
 
     fn decode_key(key: &[u8]) -> Result<Self::Key, MapKeyDecodeError<V::KeyDecodeError>> {
         let behavior = <(K::Kind, V::Kind)>::BEHAVIOR;
@@ -188,14 +197,14 @@ impl<I: std::fmt::Display> crate::error::StoreyError for MapKeyDecodeError<I> {}
 /// An accessor for a map.
 ///
 /// The accessor provides methods for interacting with the map in storage.
-pub struct MapAccess<K: ?Sized, V, S> {
+pub struct MapAccess<K: ?Sized, V, S, KS = DefaultKeySet> {
     storage: S,
-    phantom: PhantomData<(*const K, V)>,
+    phantom: PhantomData<(*const K, V, KS)>,
 }
 
-impl<K, V, S> MapAccess<K, V, S>
+impl<K, V, S, KS> MapAccess<K, V, S, KS>
 where
-    K: Key,
+    K: Key<KS>,
     V: Storable,
     (K::Kind, V::Kind): KeyEncodingT,
 {
@@ -229,7 +238,7 @@ where
     pub fn entry<Q>(&self, key: &Q) -> V::Accessor<StorageBranch<&S>>
     where
         K: Borrow<Q>,
-        Q: Key<Kind = K::Kind> + ?Sized,
+        Q: Key<KS, Kind = K::Kind> + ?Sized,
     {
         let behavior = <(K::Kind, V::Kind)>::BEHAVIOR;
 
@@ -273,7 +282,7 @@ where
     pub fn entry_mut<Q>(&mut self, key: &Q) -> V::Accessor<StorageBranch<&mut S>>
     where
         K: Borrow<Q>,
-        Q: Key<Kind = K::Kind> + ?Sized,
+        Q: Key<KS, Kind = K::Kind> + ?Sized,
     {
         let behavior = <(K::Kind, V::Kind)>::BEHAVIOR;
 
@@ -294,11 +303,11 @@ fn len_prefix<T: AsRef<[u8]>>(bytes: T) -> Vec<u8> {
     result
 }
 
-impl<K, V, S> IterableAccessor for MapAccess<K, V, S>
+impl<K, V, S, KS> IterableAccessor for MapAccess<K, V, S, KS>
 where
-    K: OwnedKey,
-    V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
+    K: OwnedKey<KS>,
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
     S: IterableStorage,
     (K::Kind, V::Kind): KeyEncodingT,
 {
@@ -317,11 +326,11 @@ where
 // after it, we have to length-prefix the key. This makes bounded iteration behave differently
 // than in other cases (and rather unintuitively).
 
-impl<K, V, S> BoundedIterableAccessor for MapAccess<K, V, S>
+impl<K, V, S, KS> BoundedIterableAccessor for MapAccess<K, V, S, KS>
 where
-    K: OwnedKey,
-    V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
+    K: OwnedKey<KS>,
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
     S: IterableStorage,
     (K::Kind, V::Kind): BoundedIterationAllowed + KeyEncodingT,
 {
@@ -333,11 +342,11 @@ impl<const L: usize> BoundedIterationAllowed for (FixedSizeKey<L>, Terminal) {}
 impl<const L: usize> BoundedIterationAllowed for (FixedSizeKey<L>, NonTerminal) {}
 impl BoundedIterationAllowed for (DynamicKey, Terminal) {}
 
-impl<K, V, Q> BoundFor<Map<K, V>> for &Q
+impl<K, V, Q, KS> BoundFor<Map<K, V, KS>> for &Q
 where
-    K: Borrow<Q> + OwnedKey,
+    K: Borrow<Q> + OwnedKey<KS>,
     V: Storable,
-    Q: Key + ?Sized,
+    Q: Key<KS> + ?Sized,
     (K::Kind, V::Kind): KeyEncodingT,
 {
     fn into_bytes(self) -> Vec<u8> {
diff --git a/packages/storey/src/containers/mod.rs b/packages/storey/src/containers/mod.rs
index d3ddbc6..c44e63d 100644
--- a/packages/storey/src/containers/mod.rs
+++ b/packages/storey/src/containers/mod.rs
@@ -26,6 +26,13 @@ pub trait Storable {
     /// [`Storage`]: crate::storage::Storage
     type Accessor<S>;
 
+    /// Create an accessor for this collection/container, given a [`Storage`] implementation.
+    ///
+    /// [`Storage`]: crate::storage::Storage
+    fn access_impl<S>(storage: S) -> Self::Accessor<S>;
+}
+
+pub trait IterableStorable: Storable {
     /// The Key type for this collection/container. This is the type that will be used in
     /// key iteration.
     ///
@@ -45,11 +52,6 @@ pub trait Storable {
     /// The error type for decoding values.
     type ValueDecodeError;
 
-    /// Create an accessor for this collection/container, given a [`Storage`] implementation.
-    ///
-    /// [`Storage`]: crate::storage::Storage
-    fn access_impl<S>(storage: S) -> Self::Accessor<S>;
-
     /// Decode a key from a byte slice.
     ///
     /// This method is used in key iteration to provide a typed key rather than raw bytes
@@ -363,7 +365,7 @@ pub struct StorableIter<S, I> {
 
 impl<S, I> Iterator for StorableIter<S, I>
 where
-    S: Storable,
+    S: IterableStorable,
     I: Iterator<Item = (Vec<u8>, Vec<u8>)>,
 {
     type Item = Result<(S::Key, S::Value), KVDecodeError<S::KeyDecodeError, S::ValueDecodeError>>;
@@ -387,7 +389,7 @@ pub struct StorableKeys<S, I> {
 
 impl<S, I> Iterator for StorableKeys<S, I>
 where
-    S: Storable,
+    S: IterableStorable,
     I: Iterator<Item = Vec<u8>>,
 {
     type Item = Result<S::Key, S::KeyDecodeError>;
@@ -405,7 +407,7 @@ pub struct StorableValues<S, I> {
 
 impl<S, I> Iterator for StorableValues<S, I>
 where
-    S: Storable,
+    S: IterableStorable,
     I: Iterator<Item = Vec<u8>>,
 {
     type Item = Result<S::Value, S::ValueDecodeError>;
diff --git a/packages/storey/tests/key_set_defaults.rs b/packages/storey/tests/key_set_defaults.rs
new file mode 100644
index 0000000..7971053
--- /dev/null
+++ b/packages/storey/tests/key_set_defaults.rs
@@ -0,0 +1,54 @@
+use storey::containers::map::key::{Key, KeySetDefaults, OwnedKey};
+
+#[derive(KeySetDefaults)]
+pub struct MyKeySet;
+
+#[test]
+fn strings() {
+    let data = ["foo", "", "🧗🏼‍♀️hi"];
+
+    for s in data.iter() {
+        let encoded = <str as storey::containers::map::Key>::encode(s);
+        let my_encoded = <str as storey::containers::map::Key<MyKeySet>>::encode(s);
+        assert_eq!(encoded, my_encoded);
+    }
+
+    for s in data.iter() {
+        let s = s.to_string();
+
+        let encoded = <String as storey::containers::map::Key>::encode(&s);
+        let my_encoded = <String as storey::containers::map::Key<MyKeySet>>::encode(&s);
+        assert_eq!(encoded, my_encoded);
+
+        let my_decoded =
+            <String as storey::containers::map::OwnedKey<MyKeySet>>::from_bytes(&encoded).unwrap();
+        assert_eq!(s, my_decoded);
+    }
+
+    for s in data.iter() {
+        let s: Box<str> = (*s).into();
+
+        let encoded = <Box<str> as storey::containers::map::Key>::encode(&s);
+        let my_encoded = <Box<str> as storey::containers::map::Key<MyKeySet>>::encode(&s);
+        assert_eq!(encoded, my_encoded);
+
+        let my_decoded =
+            <Box<str> as storey::containers::map::OwnedKey<MyKeySet>>::from_bytes(&encoded)
+                .unwrap();
+        assert_eq!(s, my_decoded);
+    }
+}
+
+#[test]
+fn arrays() {
+    let data = [5u8; 99999];
+
+    let encoded = <[u8; 99999] as storey::containers::map::Key>::encode(&data);
+    let my_encoded = <[u8; 99999] as storey::containers::map::Key<MyKeySet>>::encode(&data);
+
+    assert_eq!(encoded, my_encoded);
+
+    let my_decoded =
+        <[u8; 99999] as storey::containers::map::OwnedKey<MyKeySet>>::from_bytes(&encoded).unwrap();
+    assert_eq!(data, my_decoded);
+}