diff --git a/framework/base/src/lib.rs b/framework/base/src/lib.rs
index 0dcde3ebea..73d5a5e0e4 100644
--- a/framework/base/src/lib.rs
+++ b/framework/base/src/lib.rs
@@ -34,6 +34,7 @@ pub mod types;
 
 #[cfg(feature = "std")]
 mod std_impl;
+mod storage_v2;
 
 pub use hex_call_data::*;
 pub use hex_literal;
diff --git a/framework/base/src/storage/storage_key.rs b/framework/base/src/storage/storage_key.rs
index 74b4fa5171..99fa1f4eea 100644
--- a/framework/base/src/storage/storage_key.rs
+++ b/framework/base/src/storage/storage_key.rs
@@ -8,6 +8,7 @@ use crate::{
     *,
 };
 
+#[derive(Default)]
 pub struct StorageKey<A>
 where
     A: ManagedTypeApi + ErrorApi + 'static,
@@ -116,3 +117,12 @@ impl<M: ManagedTypeApi> Clone for StorageKey<M> {
         }
     }
 }
+
+impl<A> PartialEq for StorageKey<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.buffer.eq(&other.buffer)
+    }
+}
diff --git a/framework/base/src/storage_v2.rs b/framework/base/src/storage_v2.rs
new file mode 100644
index 0000000000..6953eaa4f5
--- /dev/null
+++ b/framework/base/src/storage_v2.rs
@@ -0,0 +1,7 @@
+mod context;
+mod key;
+
+#[allow(unused_imports)]
+pub use context::*;
+#[allow(unused_imports)]
+pub use key::*;
diff --git a/framework/base/src/storage_v2/context.rs b/framework/base/src/storage_v2/context.rs
new file mode 100644
index 0000000000..427a66f979
--- /dev/null
+++ b/framework/base/src/storage_v2/context.rs
@@ -0,0 +1,264 @@
+use core::marker::PhantomData;
+
+use crate::{
+    api::{
+        ErrorApi, ManagedTypeApi, StorageReadApi, StorageReadApiImpl, StorageWriteApi,
+        StorageWriteApiImpl as _,
+    },
+    storage::StorageKey,
+    types::{ManagedBuffer, ManagedType},
+};
+
+#[allow(dead_code)]
+pub trait StorageContext<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    type ReadAccess: StorageContextRead<A>;
+    type WriteAccess: StorageContextWrite<A>;
+
+    unsafe fn unsafe_clone(&self) -> Self;
+
+    fn downcast_read(&self) -> &Self::ReadAccess;
+
+    fn try_downcast_write(&self) -> Option<&Self::WriteAccess>;
+
+    fn subcontext(&self, delta: StorageKey<A>) -> Self;
+}
+
+#[allow(dead_code)]
+pub trait StorageContextRead<R>: StorageContext<R>
+where
+    R: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_raw(&self) -> StorageKey<R>;
+}
+
+#[allow(dead_code)]
+pub trait StorageContextWrite<W>: StorageContextRead<W>
+where
+    W: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn write_raw(&self, value: ManagedBuffer<W>);
+}
+
+/// Layout marker.
+///
+/// Cannot create instance of this type.
+#[allow(dead_code)]
+pub enum Layout {}
+
+impl<A> StorageContext<A> for Layout
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    type ReadAccess = NoAccess<A>;
+    type WriteAccess = NoAccess<A>;
+
+    unsafe fn unsafe_clone(&self) -> Self {
+        unreachable!()
+    }
+
+    fn downcast_read(&self) -> &Self::ReadAccess {
+        unreachable!()
+    }
+
+    fn try_downcast_write(&self) -> Option<&Self::WriteAccess> {
+        unreachable!()
+    }
+
+    fn subcontext(&self, _delta: StorageKey<A>) -> Self {
+        unreachable!()
+    }
+}
+
+pub enum NoAccess<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    _Phantom(PhantomData<A>),
+}
+
+impl<A> StorageContext<A> for NoAccess<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    type ReadAccess = NoAccess<A>;
+    type WriteAccess = NoAccess<A>;
+
+    unsafe fn unsafe_clone(&self) -> Self {
+        unreachable!()
+    }
+
+    fn downcast_read(&self) -> &Self::ReadAccess {
+        unreachable!()
+    }
+
+    fn try_downcast_write(&self) -> Option<&Self::WriteAccess> {
+        unreachable!()
+    }
+
+    fn subcontext(&self, _delta: StorageKey<A>) -> Self {
+        unreachable!()
+    }
+}
+
+impl<A> StorageContextRead<A> for NoAccess<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_raw(&self) -> StorageKey<A> {
+        unreachable!()
+    }
+}
+
+impl<A> StorageContextWrite<A> for NoAccess<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn write_raw(&self, _value: ManagedBuffer<A>) {
+        unreachable!()
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub struct SelfRead<'r, M>
+where
+    M: ManagedTypeApi + ErrorApi + 'static,
+{
+    key: StorageKey<M>,
+    _phantom: PhantomData<&'r ()>,
+}
+
+#[allow(dead_code)]
+impl<M> SelfRead<'_, M>
+where
+    M: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub fn new(key: StorageKey<M>) -> Self {
+        SelfRead {
+            key,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<A> StorageContext<A> for SelfRead<'_, A>
+where
+    A: StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    type ReadAccess = Self;
+    type WriteAccess = NoAccess<A>;
+
+    unsafe fn unsafe_clone(&self) -> Self {
+        Self {
+            key: self.key.clone(),
+            _phantom: PhantomData,
+        }
+    }
+
+    fn downcast_read(&self) -> &Self::ReadAccess {
+        self
+    }
+
+    fn try_downcast_write(&self) -> Option<&Self::WriteAccess> {
+        None
+    }
+
+    fn subcontext(&self, delta: StorageKey<A>) -> Self {
+        let mut subcontext_key = self.key.clone();
+        subcontext_key.append_managed_buffer(&delta.buffer);
+        Self::new(subcontext_key)
+    }
+}
+
+impl<A> StorageContextRead<A> for SelfRead<'_, A>
+where
+    A: StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_raw(&self) -> StorageKey<A> {
+        unsafe {
+            let result = ManagedBuffer::new_uninit();
+            A::storage_read_api_impl()
+                .storage_load_managed_buffer_raw(self.key.get_handle(), result.get_handle());
+            StorageKey::from(result)
+        }
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub struct SelfWrite<'w, M>
+where
+    M: ManagedTypeApi + ErrorApi + 'static,
+{
+    key: StorageKey<M>,
+    _phantom: PhantomData<&'w mut ()>,
+}
+
+#[allow(dead_code)]
+impl<M> SelfWrite<'_, M>
+where
+    M: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub fn new(key: StorageKey<M>) -> Self {
+        SelfWrite {
+            key,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<A> StorageContext<A> for SelfWrite<'_, A>
+where
+    A: StorageReadApi + StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    type ReadAccess = Self;
+    type WriteAccess = Self;
+
+    unsafe fn unsafe_clone(&self) -> Self {
+        Self {
+            key: self.key.clone(),
+            _phantom: PhantomData,
+        }
+    }
+
+    fn downcast_read(&self) -> &Self::ReadAccess {
+        self
+    }
+
+    fn try_downcast_write(&self) -> Option<&Self::WriteAccess> {
+        Some(self)
+    }
+
+    fn subcontext(&self, delta: StorageKey<A>) -> Self {
+        let mut subcontext_key = self.key.clone();
+        subcontext_key.append_managed_buffer(&delta.buffer);
+        Self::new(subcontext_key)
+    }
+}
+
+impl<A> StorageContextRead<A> for SelfWrite<'_, A>
+where
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_raw(&self) -> StorageKey<A> {
+        unsafe {
+            let result = ManagedBuffer::new_uninit();
+            A::storage_read_api_impl()
+                .storage_load_managed_buffer_raw(self.key.get_handle(), result.get_handle());
+            StorageKey::from(result)
+        }
+    }
+}
+
+impl<A> StorageContextWrite<A> for SelfWrite<'_, A>
+where
+    A: StorageReadApi + StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn write_raw(&self, value: ManagedBuffer<A>) {
+        A::storage_write_api_impl()
+            .storage_store_managed_buffer_raw(self.key.get_handle(), value.handle.clone());
+    }
+}
diff --git a/framework/base/src/storage_v2/key.rs b/framework/base/src/storage_v2/key.rs
new file mode 100644
index 0000000000..e07f5b7c8c
--- /dev/null
+++ b/framework/base/src/storage_v2/key.rs
@@ -0,0 +1,376 @@
+use core::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    ptr::NonNull,
+};
+
+use alloc::borrow::ToOwned;
+
+use crate::{
+    api::{
+        ErrorApi, ManagedTypeApi, StorageReadApi, StorageReadApiImpl, StorageWriteApi,
+        StorageWriteApiImpl,
+    },
+    storage::StorageKey,
+    types::{ManagedBuffer, ManagedType},
+};
+
+#[allow(dead_code)]
+pub trait Key<A>: 'static
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn full_key(&self) -> StorageKey<A>;
+
+    fn key_eq<Other: Key<A>>(&self, other: &Other) -> bool {
+        self.full_key().eq(&other.full_key())
+    }
+
+    fn append_to(&self, target: &mut StorageKey<A>) {
+        target.append_bytes(b".");
+        target.append_managed_buffer(&self.full_key().buffer);
+    }
+}
+
+impl<A> Key<A> for StorageKey<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn full_key(&self) -> StorageKey<A> {
+        self.clone()
+    }
+}
+
+#[allow(dead_code)]
+pub trait ConstKey<A>: Key<A> + Default
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn root_key() -> &'static ManagedBuffer<A>;
+}
+
+// impl<A, K> Key<A> for K
+// where
+//     K: ConstKey<A>,
+//     A: ManagedTypeApi + ErrorApi + 'static,
+// {
+//     fn full_key(&self) -> DynamicKey<A> {
+//         K::root_key().to_owned()
+//     }
+
+//     fn key_eq<Other: Key<A>>(&self, other: &Other) -> bool {
+//         false
+//         // TypeId::of::<Self>() == TypeId::of::<Other>()
+//     }
+// }
+
+#[allow(dead_code)]
+pub struct StrKey(&'static str);
+
+impl Deref for StrKey {
+    type Target = &'static str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<A> Key<A> for StrKey
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn full_key(&self) -> StorageKey<A> {
+        StorageKey::new(self.as_bytes())
+    }
+}
+
+#[allow(dead_code)]
+pub trait StoragePath<A>: Sized
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_value_raw(&self) -> StorageKey<A>;
+
+    fn maybe_write_value_raw(&mut self, value: &ManagedBuffer<A>);
+
+    unsafe fn duplicate_unchecked(&self) -> Self;
+
+    fn concat_key<K: Key<A>>(self, key: K) -> Self;
+
+    // fn concat_key_ref<K: Key>(&self, key: K) -> Self {
+    //     unsafe { self.duplicate_unchecked().concat_key(key) }
+    // }
+
+    // fn concat_key_ref_mut<K: Key>(&mut self, key: K) -> Self {
+    //     unsafe { self.duplicate_unchecked().concat_key(key) }
+    // }
+}
+
+#[allow(dead_code)]
+pub trait StoragePathMut<A>: StoragePath<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    fn write_value_raw(&mut self, value: &ManagedBuffer<A>);
+}
+
+#[allow(dead_code)]
+pub trait StoragePathIntoRefMut<'a, A>: StoragePathMut<A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    type RefMut: StoragePathMut<A>;
+
+    fn as_ref_mut(&'a mut self) -> Self::RefMut;
+}
+
+#[allow(dead_code)]
+pub trait StoragePathConcat<A, K>
+where
+    K: Key<A>,
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    type Output: StoragePath<A>;
+
+    fn concat(self, key: K) -> Self::Output;
+}
+
+// pub trait StoragePathMut {
+//     fn write_value_raw(&self, value: &str);
+
+//     unsafe fn duplicate_unchecked_mut(&self) -> Self;
+// }
+
+#[derive(Default)]
+pub struct SelfStorageRoot;
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub struct SelfStorageRootMut;
+
+#[allow(dead_code)]
+pub struct SelfStorageRootRef<'a, A> {
+    _phantom: PhantomData<(&'a SelfStorageRoot, A)>,
+}
+
+#[allow(dead_code)]
+impl<'a, A> SelfStorageRootRef<'a, A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub unsafe fn new_ref() -> Self {
+        SelfStorageRootRef {
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn root_path(self, root_key: &StorageKey<A>) -> SelfStorageRef<'a, A> {
+        SelfStorageRef {
+            source_ref: self,
+            key: root_key.to_owned(),
+        }
+    }
+}
+
+// impl<'a> Deref for SelfStorageRootRef<'a> {
+//     type Target = SelfStorageRoot;
+
+//     // fn deref(&self) -> &Self::Target {
+//     //     &SelfStorageRoot
+//     // }
+// }
+
+pub struct SelfStorageRootRefMut<'a, A> {
+    _phantom: PhantomData<(&'a SelfStorageRoot, A)>,
+}
+
+#[allow(dead_code)]
+impl<'a, A> SelfStorageRootRefMut<'a, A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub unsafe fn new_ref() -> Self {
+        SelfStorageRootRefMut {
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn root_path(self, root_key: &StorageKey<A>) -> SelfStorageRefMut<'a, A> {
+        SelfStorageRefMut {
+            source_ref: self,
+            key: root_key.to_owned(),
+        }
+    }
+}
+
+impl<'a, _A> Deref for SelfStorageRootRefMut<'a, _A> {
+    type Target = SelfStorageRoot;
+
+    fn deref(&self) -> &Self::Target {
+        &SelfStorageRoot
+    }
+}
+
+impl<'a, _A> DerefMut for SelfStorageRootRefMut<'a, _A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        let ptr = NonNull::<SelfStorageRoot>::dangling();
+        unsafe { &mut *ptr.as_ptr() }
+    }
+}
+
+#[allow(dead_code)]
+pub struct SelfStorageRef<'a, A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub source_ref: SelfStorageRootRef<'a, A>,
+    pub key: StorageKey<A>,
+}
+
+impl<'a, A> StoragePath<A> for SelfStorageRef<'a, A>
+where
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_value_raw(&self) -> StorageKey<A> {
+        unsafe {
+            let result = ManagedBuffer::new_uninit();
+            A::storage_read_api_impl()
+                .storage_load_managed_buffer_raw(self.key.get_handle(), result.get_handle());
+            StorageKey::from(result)
+        }
+    }
+
+    fn maybe_write_value_raw(&mut self, value: &ManagedBuffer<A>) {
+        // read-only
+        let storage_path = self.key.clone();
+        A::storage_write_api_impl()
+            .storage_store_managed_buffer_raw(storage_path.get_handle(), value.get_handle());
+    }
+
+    unsafe fn duplicate_unchecked(&self) -> Self {
+        SelfStorageRef {
+            source_ref: SelfStorageRootRef::new_ref(),
+            key: self.key.clone(),
+        }
+    }
+
+    fn concat_key<K: Key<A>>(mut self, key: K) -> Self {
+        key.append_to(&mut self.key);
+        self
+    }
+}
+
+// impl<'a, K: Key> StoragePathConcat<K> for SelfStorageRootRef<'a> {
+//     type Output = SelfStorageRef<'a>;
+
+//     fn concat(self, key: K) -> Self::Output {
+//         SelfStorageRef {
+//             source_ref: self,
+//             key: key.full_key(),
+//         }
+//     }
+// }
+
+#[allow(dead_code)]
+pub struct SelfStorageRefMut<'a, A>
+where
+    A: ManagedTypeApi + ErrorApi + 'static,
+{
+    pub source_ref: SelfStorageRootRefMut<'a, A>,
+    pub key: StorageKey<A>,
+}
+
+impl<'a, A> StoragePath<A> for SelfStorageRefMut<'a, A>
+where
+    A: StorageReadApi + StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn read_value_raw(&self) -> StorageKey<A> {
+        unsafe {
+            let result = ManagedBuffer::new_uninit();
+            A::storage_read_api_impl()
+                .storage_load_managed_buffer_raw(self.key.get_handle(), result.get_handle());
+            StorageKey::from(result)
+        }
+    }
+
+    fn maybe_write_value_raw(&mut self, value: &ManagedBuffer<A>) {
+        A::storage_write_api_impl()
+            .storage_store_managed_buffer_raw(self.key.get_handle(), value.get_handle());
+    }
+
+    unsafe fn duplicate_unchecked(&self) -> Self {
+        SelfStorageRefMut {
+            source_ref: SelfStorageRootRefMut::new_ref(),
+            key: self.key.clone(),
+        }
+    }
+
+    fn concat_key<K: Key<A>>(mut self, key: K) -> Self {
+        key.append_to(&mut self.key);
+        self
+    }
+}
+
+impl<'a, A> StoragePathMut<A> for SelfStorageRefMut<'a, A>
+where
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    fn write_value_raw(&mut self, value: &ManagedBuffer<A>) {
+        A::storage_write_api_impl()
+            .storage_store_managed_buffer_raw(self.key.get_handle(), value.get_handle());
+    }
+}
+
+impl<'a, A> StoragePathIntoRefMut<'a, A> for SelfStorageRefMut<'a, A>
+where
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    type RefMut = SelfStorageRefMut<'a, A>;
+
+    fn as_ref_mut(&'a mut self) -> Self::RefMut {
+        unsafe { self.duplicate_unchecked() }
+    }
+}
+
+impl<'a, A, K> StoragePathConcat<A, K> for SelfStorageRootRefMut<'a, A>
+where
+    K: Key<A>,
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    type Output = SelfStorageRefMut<'a, A>;
+
+    fn concat(self, key: K) -> Self::Output {
+        SelfStorageRefMut {
+            source_ref: self,
+            key: key.full_key(),
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub trait StorageSource: Default + 'static {
+    fn can_write() -> bool;
+}
+
+impl StorageSource for SelfStorageRoot {
+    fn can_write() -> bool {
+        // println!("SelfStorage false");
+        false
+    }
+}
+impl StorageSource for SelfStorageRootMut {
+    fn can_write() -> bool {
+        // println!("SelfStorageMut true");
+        true
+    }
+}
+
+pub fn _path_lifetimes<A>(root: SelfStorageRootRefMut<'_, A>)
+where
+    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi + 'static,
+{
+    let mut path1 = root.root_path(&StorageKey::new(b"root"));
+    let _path1a = path1.as_ref_mut().concat_key(StrKey("key1a"));
+    // let path1b = path1.into_ref_mut().concat_key("key1a".to_owned());
+    // let path1a = path1.concat_key("key1a".to_owned());
+}