diff --git a/crates/store/src/entry.rs b/crates/store/src/entry.rs
index c5ce1b947..d2afcfd90 100644
--- a/crates/store/src/entry.rs
+++ b/crates/store/src/entry.rs
@@ -1,16 +1,16 @@
 use crate::key::AsKeyParts;
 use crate::slice::Slice;
 
-pub trait DataType: Sized {
+pub trait DataType<'a>: Sized {
     type Error;
 
-    fn from_slice(slice: Slice) -> Result<Self, Self::Error>;
-    fn as_slice(&self) -> Result<Slice, Self::Error>;
+    fn from_slice(slice: Slice<'a>) -> Result<Self, Self::Error>;
+    fn as_slice(&'a self) -> Result<Slice<'a>, Self::Error>;
 }
 
 pub trait Entry {
     type Key: AsKeyParts;
-    type DataType: DataType;
+    type DataType<'a>: DataType<'a>;
 
     fn key(&self) -> &Self::Key;
 }
diff --git a/crates/store/src/handle.rs b/crates/store/src/handle.rs
index bb82c6f92..63702685d 100644
--- a/crates/store/src/handle.rs
+++ b/crates/store/src/handle.rs
@@ -33,23 +33,26 @@ impl<'base, 'k, 'v, L: WriteLayer<'k, 'v>> StoreHandle<L> {
 }
 
 #[derive(Debug, Error)]
-pub enum Error<E: DataType> {
+pub enum Error<'a, E: DataType<'a>> {
     LayerError(eyre::Report),
     CodecError(E::Error),
 }
 
-impl<E: DataType> From<eyre::Report> for Error<E> {
+impl<'a, E: DataType<'a>> From<eyre::Report> for Error<'a, E> {
     fn from(err: eyre::Report) -> Self {
         Self::LayerError(err)
     }
 }
 
-impl<'k, L: ReadLayer<'k>> StoreHandle<L> {
-    pub fn has<E: Entry>(&self, entry: &'k E) -> Result<bool, Error<E::DataType>> {
+impl<'a, 'k, L: ReadLayer<'k>> StoreHandle<L> {
+    pub fn has<E: Entry>(&self, entry: &'k E) -> Result<bool, Error<E::DataType<'_>>> {
         Ok(self.inner.has(entry.key())?)
     }
 
-    pub fn get<E: Entry>(&self, entry: &'k E) -> Result<Option<E::DataType>, Error<E::DataType>> {
+    pub fn get<E: Entry>(
+        &self,
+        entry: &'k E,
+    ) -> Result<Option<E::DataType<'_>>, Error<E::DataType<'_>>> {
         match self.inner.get(entry.key())? {
             Some(value) => Ok(Some(
                 E::DataType::from_slice(value).map_err(Error::CodecError)?,
@@ -61,23 +64,23 @@ impl<'k, L: ReadLayer<'k>> StoreHandle<L> {
     pub fn iter<E: Entry<Key: FromKeyParts>>(
         &'k self,
         start: &'k E,
-    ) -> Result<Iter<Structured<E::Key>, Structured<E::DataType>>, Error<E::DataType>> {
+    ) -> Result<Iter<Structured<E::Key>, Structured<E::DataType<'_>>>, Error<E::DataType<'_>>> {
         Ok(self.inner.iter(start.key())?.structured_value())
     }
 }
 
 impl<'k, 'v, L: WriteLayer<'k, 'v>> StoreHandle<L> {
     pub fn put<E: Entry>(
-        &mut self,
+        &'v mut self,
         entry: &'k E,
-        value: &'v E::DataType,
-    ) -> Result<(), Error<E::DataType>> {
+        value: &'v E::DataType<'v>,
+    ) -> Result<(), Error<E::DataType<'_>>> {
         self.inner
             .put(entry.key(), value.as_slice().map_err(Error::CodecError)?)
             .map_err(Error::LayerError)
     }
 
-    pub fn delete<E: Entry>(&mut self, entry: &'k E) -> Result<(), Error<E::DataType>> {
+    pub fn delete<E: Entry>(&mut self, entry: &'k E) -> Result<(), Error<E::DataType<'_>>> {
         self.inner.delete(entry.key()).map_err(Error::LayerError)
     }
 }
diff --git a/crates/store/src/iter.rs b/crates/store/src/iter.rs
index 7c6c875d5..84c0bce4d 100644
--- a/crates/store/src/iter.rs
+++ b/crates/store/src/iter.rs
@@ -51,7 +51,7 @@ impl<'a, V> Iter<'a, Unstructured, V> {
 }
 
 impl<'a, K> Iter<'a, K, Unstructured> {
-    pub fn structured_value<V: DataType>(self) -> Iter<'a, K, Structured<V>> {
+    pub fn structured_value<V: DataType<'a>>(self) -> Iter<'a, K, Structured<V>> {
         Iter {
             inner: self.inner,
             _priv: PhantomData,
@@ -158,7 +158,7 @@ impl<'a, K: FromKeyParts> TryIntoKey<'a> for Structured<K> {
     }
 }
 
-impl<'a, V: DataType> TryIntoValue<'a> for Structured<V> {
+impl<'a, V: DataType<'a>> TryIntoValue<'a> for Structured<V> {
     type Value = V;
     type Error = Error<V::Error>;
 
diff --git a/crates/store/src/types.rs b/crates/store/src/types.rs
index 19b43e107..b6fa18a15 100644
--- a/crates/store/src/types.rs
+++ b/crates/store/src/types.rs
@@ -8,12 +8,12 @@ pub use context::{ContextIdentity, ContextMeta, ContextState, ContextTransaction
 pub use generic::GenericData;
 
 pub trait PredefinedEntry: key::AsKeyParts {
-    type DataType: DataType;
+    type DataType<'a>: DataType<'a>;
 }
 
 impl<T: PredefinedEntry> Entry for T {
     type Key = T;
-    type DataType = T::DataType;
+    type DataType<'a> = T::DataType<'a>;
 
     fn key(&self) -> &Self::Key {
         self
diff --git a/crates/store/src/types/context.rs b/crates/store/src/types/context.rs
index d17942bb6..7cae2187d 100644
--- a/crates/store/src/types/context.rs
+++ b/crates/store/src/types/context.rs
@@ -8,9 +8,12 @@ use crate::slice::Slice;
 use crate::types::PredefinedEntry;
 
 #[derive(Eq, Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub struct ContextMeta {}
+pub struct ContextMeta {
+    // todo! make [u8; 32] when application_id<->meta is a separate record
+    pub application_id: Box<str>,
+}
 
-impl DataType for ContextMeta {
+impl DataType<'_> for ContextMeta {
     type Error = io::Error;
 
     fn from_slice(slice: Slice) -> Result<Self, Self::Error> {
@@ -23,32 +26,36 @@ impl DataType for ContextMeta {
 }
 
 impl PredefinedEntry for key::ContextMeta {
-    type DataType = ContextMeta;
+    type DataType<'a> = ContextMeta;
 }
 
-#[derive(Eq, Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub struct ContextState {}
+#[derive(Eq, Clone, Debug, PartialEq)]
+pub struct ContextState<'a> {
+    pub value: Slice<'a>,
+}
 
-impl DataType for ContextState {
+impl<'a> DataType<'a> for ContextState<'a> {
     type Error = io::Error;
 
-    fn from_slice(slice: Slice) -> Result<Self, Self::Error> {
-        borsh::from_slice(&slice)
+    fn from_slice(slice: Slice<'a>) -> Result<Self, Self::Error> {
+        Ok(Self { value: slice })
     }
 
-    fn as_slice(&self) -> Result<Slice, Self::Error> {
-        borsh::to_vec(self).map(Into::into)
+    fn as_slice(&'a self) -> Result<Slice<'a>, Self::Error> {
+        Ok(self.value.as_ref().into())
     }
 }
 
 impl PredefinedEntry for key::ContextState {
-    type DataType = ContextState;
+    type DataType<'a> = ContextState<'a>;
 }
 
 #[derive(Eq, Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub struct ContextIdentity {}
+pub struct ContextIdentity {
+    pub private_key: Option<[u8; 32]>,
+}
 
-impl DataType for ContextIdentity {
+impl DataType<'_> for ContextIdentity {
     type Error = io::Error;
 
     fn from_slice(slice: Slice) -> Result<Self, Self::Error> {
@@ -61,13 +68,18 @@ impl DataType for ContextIdentity {
 }
 
 impl PredefinedEntry for key::ContextIdentity {
-    type DataType = ContextIdentity;
+    type DataType<'a> = ContextIdentity;
 }
 
 #[derive(Eq, Clone, Debug, PartialEq, BorshSerialize, BorshDeserialize)]
-pub struct ContextTransaction {}
+pub struct ContextTransaction {
+    pub context_id: [u8; 32],
+    pub method: Box<str>,
+    pub payload: Box<[u8]>,
+    pub prior_hash: [u8; 32],
+}
 
-impl DataType for ContextTransaction {
+impl DataType<'_> for ContextTransaction {
     type Error = io::Error;
 
     fn from_slice(slice: Slice) -> Result<Self, Self::Error> {
@@ -80,5 +92,5 @@ impl DataType for ContextTransaction {
 }
 
 impl PredefinedEntry for key::ContextTransaction {
-    type DataType = ContextTransaction;
+    type DataType<'a> = ContextTransaction;
 }
diff --git a/crates/store/src/types/generic.rs b/crates/store/src/types/generic.rs
index f1be481b4..64159a782 100644
--- a/crates/store/src/types/generic.rs
+++ b/crates/store/src/types/generic.rs
@@ -6,20 +6,22 @@ use crate::slice::Slice;
 use crate::types::PredefinedEntry;
 
 #[derive(Eq, Clone, Debug, PartialEq)]
-pub struct GenericData(Box<[u8]>);
+pub struct GenericData<'a> {
+    value: Slice<'a>,
+}
 
-impl DataType for GenericData {
+impl<'a> DataType<'a> for GenericData<'a> {
     type Error = Infallible;
 
-    fn from_slice(slice: Slice) -> Result<Self, Self::Error> {
-        Ok(Self(slice.into_boxed()))
+    fn from_slice(slice: Slice<'a>) -> Result<Self, Self::Error> {
+        Ok(Self { value: slice })
     }
 
-    fn as_slice(&self) -> Result<Slice, Self::Error> {
-        Ok(self.0.as_ref().into())
+    fn as_slice(&'a self) -> Result<Slice<'a>, Self::Error> {
+        Ok(self.value.as_ref().into())
     }
 }
 
 impl PredefinedEntry for key::Generic {
-    type DataType = GenericData;
+    type DataType<'a> = GenericData<'a>;
 }