diff --git a/storage/src/demo_val.rs b/storage/src/demo_val.rs
index 8b3f08a..380509f 100644
--- a/storage/src/demo_val.rs
+++ b/storage/src/demo_val.rs
@@ -110,11 +110,8 @@ impl DemoVal {
   }
 }
 
-impl StorageEntity for DemoVal {
-  fn to_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    &self,
-    tx: &mut Tx,
-  ) -> Result<StorageEntry, E> {
+impl<'a, E, Tx: StorageBackendHandle<'a, E>> StorageEntity<'a, E, Tx> for DemoVal {
+  fn to_storage_entry(&self, tx: &mut Tx) -> Result<StorageEntry, E> {
     let mut entry = StorageEntry {
       ref_count: 1,
       refs: Vec::new(),
@@ -141,10 +138,7 @@ impl StorageEntity for DemoVal {
     Ok(entry)
   }
 
-  fn from_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    tx: &mut Tx,
-    entry: StorageEntry,
-  ) -> Result<Self, E> {
+  fn from_storage_entry(tx: &mut Tx, entry: StorageEntry) -> Result<Self, E> {
     Self::read_from_entry(tx, &mut StorageEntryReader::new(&entry))
   }
 }
diff --git a/storage/src/storage.rs b/storage/src/storage.rs
index 6a0bbdc..d0fc1ed 100644
--- a/storage/src/storage.rs
+++ b/storage/src/storage.rs
@@ -12,14 +12,14 @@ impl<SB: StorageBackend> Storage<SB> {
     Self { sb }
   }
 
-  pub fn get_head<SE: StorageEntity>(
+  pub fn get_head<SE: for<'a> StorageEntity<'a, SB::InTransactionError<()>, SB::Handle<'a, ()>>>(
     &mut self,
     ptr: StorageHeadPtr,
   ) -> Result<Option<SE>, SB::Error<()>> {
     self.sb.transaction(|sb| sb.get_head(ptr))
   }
 
-  pub fn set_head<SE: StorageEntity>(
+  pub fn set_head<SE: for<'a> StorageEntity<'a, SB::InTransactionError<()>, SB::Handle<'a, ()>>>(
     &mut self,
     ptr: StorageHeadPtr,
     value: &SE,
@@ -31,7 +31,9 @@ impl<SB: StorageBackend> Storage<SB> {
     self.sb.transaction(|sb| sb.remove_head(ptr))
   }
 
-  pub fn store_tmp<SE: StorageEntity>(
+  pub fn store_tmp<
+    SE: for<'a> StorageEntity<'a, SB::InTransactionError<()>, SB::Handle<'a, ()>>,
+  >(
     &mut self,
     value: &SE,
   ) -> Result<StorageEntryPtr, SB::Error<()>> {
diff --git a/storage/src/storage_backend_handle.rs b/storage/src/storage_backend_handle.rs
index bcfe038..00e2989 100644
--- a/storage/src/storage_backend_handle.rs
+++ b/storage/src/storage_backend_handle.rs
@@ -24,7 +24,10 @@ pub trait StorageBackendHandle<'a, E>: Sized {
     self.write_bytes(ptr, data.map(|data| bincode::serialize(&data).unwrap()))
   }
 
-  fn get_head<SE: StorageEntity>(&mut self, head_ptr: StorageHeadPtr) -> Result<Option<SE>, E> {
+  fn get_head<SE: StorageEntity<'a, E, Self>>(
+    &mut self,
+    head_ptr: StorageHeadPtr,
+  ) -> Result<Option<SE>, E> {
     let entry_ptr = match self.read(head_ptr)? {
       Some(entry_ptr) => entry_ptr,
       None => return Ok(None),
@@ -38,7 +41,11 @@ pub trait StorageBackendHandle<'a, E>: Sized {
     SE::from_storage_entry(self, entry).map(Some)
   }
 
-  fn set_head<SE: StorageEntity>(&mut self, head_ptr: StorageHeadPtr, value: &SE) -> Result<(), E> {
+  fn set_head<SE: StorageEntity<'a, E, Self>>(
+    &mut self,
+    head_ptr: StorageHeadPtr,
+    value: &SE,
+  ) -> Result<(), E> {
     let entry_ptr = self.store(value)?;
     self.ref_delta(entry_ptr, 1)?;
 
@@ -57,7 +64,7 @@ pub trait StorageBackendHandle<'a, E>: Sized {
     self.write(head_ptr, None)
   }
 
-  fn store<SE: StorageEntity>(&mut self, value: &SE) -> Result<StorageEntryPtr, E> {
+  fn store<SE: StorageEntity<'a, E, Self>>(&mut self, value: &SE) -> Result<StorageEntryPtr, E> {
     let ptr = StoragePtr::random(&mut thread_rng());
     let entry = value.to_storage_entry(self)?;
     self.write(ptr, Some(&entry))?;
@@ -139,7 +146,7 @@ pub trait StorageBackendHandle<'a, E>: Sized {
     self.cache().get(&key).cloned()
   }
 
-  fn store_and_cache<SE: StorageEntity>(
+  fn store_and_cache<SE: StorageEntity<'a, E, Self>>(
     &mut self,
     value: &SE,
     key: RcKey,
diff --git a/storage/src/storage_entity.rs b/storage/src/storage_entity.rs
index 58d8d03..1ee5f69 100644
--- a/storage/src/storage_entity.rs
+++ b/storage/src/storage_entity.rs
@@ -1,13 +1,6 @@
 use crate::{storage_backend_handle::StorageBackendHandle, storage_entry::StorageEntry};
 
-pub trait StorageEntity: Sized {
-  fn to_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    &self,
-    tx: &mut Tx,
-  ) -> Result<StorageEntry, E>;
-
-  fn from_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    tx: &mut Tx,
-    entry: StorageEntry,
-  ) -> Result<Self, E>;
+pub trait StorageEntity<'a, E, Tx: StorageBackendHandle<'a, E>>: Sized {
+  fn to_storage_entry(&self, tx: &mut Tx) -> Result<StorageEntry, E>;
+  fn from_storage_entry(tx: &mut Tx, entry: StorageEntry) -> Result<Self, E>;
 }
diff --git a/valuescript_vm/src/bytecode.rs b/valuescript_vm/src/bytecode.rs
index 56ae374..7f1610d 100644
--- a/valuescript_vm/src/bytecode.rs
+++ b/valuescript_vm/src/bytecode.rs
@@ -45,11 +45,8 @@ impl DecoderMaker for Rc<Bytecode> {
   }
 }
 
-impl StorageEntity for Bytecode {
-  fn to_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    &self,
-    _tx: &mut Tx,
-  ) -> Result<storage::StorageEntry, E> {
+impl<'a, E, Tx: StorageBackendHandle<'a, E>> StorageEntity<'a, E, Tx> for Bytecode {
+  fn to_storage_entry(&self, _tx: &mut Tx) -> Result<storage::StorageEntry, E> {
     Ok(storage::StorageEntry {
       ref_count: 1,
       refs: vec![],
@@ -57,10 +54,7 @@ impl StorageEntity for Bytecode {
     })
   }
 
-  fn from_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    _tx: &mut Tx,
-    entry: storage::StorageEntry,
-  ) -> Result<Self, E> {
+  fn from_storage_entry(_tx: &mut Tx, entry: storage::StorageEntry) -> Result<Self, E> {
     Ok(Bytecode::new(entry.data))
   }
 }
diff --git a/valuescript_vm/src/val_storage.rs b/valuescript_vm/src/val_storage.rs
index 2410173..2a43c44 100644
--- a/valuescript_vm/src/val_storage.rs
+++ b/valuescript_vm/src/val_storage.rs
@@ -47,11 +47,8 @@ impl Tag {
   }
 }
 
-impl StorageEntity for Val {
-  fn from_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    tx: &mut Tx,
-    entry: StorageEntry,
-  ) -> Result<Self, E> {
+impl<'a, E, Tx: StorageBackendHandle<'a, E>> StorageEntity<'a, E, Tx> for Val {
+  fn from_storage_entry(tx: &mut Tx, entry: StorageEntry) -> Result<Self, E> {
     let mut reader = StorageEntryReader::new(&entry);
     let res = read_from_entry(tx, &mut reader);
     assert!(reader.done());
@@ -59,10 +56,7 @@ impl StorageEntity for Val {
     res
   }
 
-  fn to_storage_entry<'a, E, Tx: StorageBackendHandle<'a, E>>(
-    &self,
-    tx: &mut Tx,
-  ) -> Result<StorageEntry, E> {
+  fn to_storage_entry(&self, tx: &mut Tx) -> Result<StorageEntry, E> {
     let mut entry = StorageEntry {
       ref_count: 1,
       refs: vec![],