Add read only storage access sketch

module-system/sov-modules-core/src/storage/mod.rs

@@ -12,6 +12,7 @@ use crate::common::{AlignedVec, Prefix, Version, Witness};
 
 mod cache;
 mod codec;
+mod read_access;
 mod scratchpad;
 
 pub use cache::*;

module-system/sov-modules-core/src/storage/read_access.rs

@@ -0,0 +1,39 @@
+use crate::{Storage, StorageKey, StorageValue};
+
+pub trait StateReader {
+    /// Get a value from the storage.
+    fn get(&self, key: &StorageKey) -> Option<StorageValue>;
+}
+
+pub trait AsReadonly {
+    /// Readonly version of the access.
+    type Readonly;
+
+    /// Performs the conversion.
+    fn as_readonly(&self, level: Option<IsolationLevel>) -> Self::Readonly;
+}
+
+pub enum IsolationLevel {
+    /// Read isolation level.
+    ReadCommitted,
+    /// Write isolation level.
+    DirtyRead,
+}
+
+pub struct StateSnapshot<S: Storage> {
+    inner: S,
+}
+
+impl<S: Storage> StateSnapshot<S> {
+    pub fn new(inner: S) -> Self {
+        Self { inner }
+    }
+}
+
+impl<S: Storage> StateReader for StateSnapshot<S> {
+    fn get(&self, key: &StorageKey) -> Option<StorageValue> {
+        // TODO propagate witness?
+        let witness: S::Witness = Default::default();
+        self.inner.get(key, None, &witness)
+    }
+}

module-system/sov-modules-core/src/storage/scratchpad.rs

@@ -10,6 +10,7 @@ use sov_rollup_interface::stf::Event;
 use crate::archival_state::{ArchivalAccessoryWorkingSet, ArchivalJmtWorkingSet};
 use crate::common::{GasMeter, Prefix};
 use crate::module::{Context, Spec};
+use crate::storage::read_access::{AsReadonly, IsolationLevel, StateSnapshot};
 use crate::storage::{
     CacheKey, CacheValue, EncodeKeyLike, NativeStorage, OrderedReadsAndWrites, StateCodec,
     StateValueCodec, Storage, StorageInternalCache, StorageKey, StorageProof, StorageValue,
@@ -335,6 +336,23 @@ impl<C: Context> StateCheckpoint<C> {
     }
 }
 
+impl<C: Context> AsReadonly for StateCheckpoint<C> {
+    type Readonly = StateSnapshot<<C as Spec>::Storage>;
+
+    fn as_readonly(&self, level: Option<IsolationLevel>) -> Self::Readonly {
+        // TODO think about uncommitted changes and how to handle them. There are three options
+        //  1. Return a snapshot of the current state, ignoring uncommitted changes
+        //  2. Return a snapshot of the current state, but also include uncommitted changes
+        //  3. Return an error
+
+        let level = level.unwrap_or_else(|| IsolationLevel::ReadCommitted);
+        match level {
+            IsolationLevel::ReadCommitted => StateSnapshot::new(self.delta.inner.clone()),
+            IsolationLevel::DirtyRead => StateSnapshot::new(self.delta.inner.clone()), // TODO clone cache?
+        }
+    }
+}
+
 /// This structure contains the read-write set and the events collected during the execution of a transaction.
 /// There are two ways to convert it into a StateCheckpoint:
 /// 1. By using the checkpoint() method, where all the changes are added to the underlying StateCheckpoint.