diff --git a/crates/batch-prover/src/da_block_handler.rs b/crates/batch-prover/src/da_block_handler.rs
index 1e6b415c15..8fc8515f91 100644
--- a/crates/batch-prover/src/da_block_handler.rs
+++ b/crates/batch-prover/src/da_block_handler.rs
@@ -20,6 +20,7 @@ use sov_prover_storage_manager::ProverStorageManager;
 use sov_rollup_interface::da::{BlockHeaderTrait, SequencerCommitment};
 use sov_rollup_interface::services::da::{DaService, SlotData};
 use sov_rollup_interface::spec::SpecId;
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::zk::ZkvmHost;
 use tokio::select;
 use tokio::sync::Mutex;
@@ -306,8 +307,10 @@ pub(crate) fn break_sequencer_commitments_into_groups<DB: BatchProverLedgerOps>(
 
     let mut range = 0usize..=0usize;
     let mut cumulative_state_diff = StateDiff::new();
+    let mut cumulative_st_statediff = StatefulStateDiff::default();
     for (index, sequencer_commitment) in sequencer_commitments.iter().enumerate() {
         let mut sequencer_commitment_state_diff = StateDiff::new();
+        let mut sequencer_st_statediff = StatefulStateDiff::default();
         for l2_height in
             sequencer_commitment.l2_start_block_number..=sequencer_commitment.l2_end_block_number
         {
@@ -319,14 +322,27 @@ pub(crate) fn break_sequencer_commitments_into_groups<DB: BatchProverLedgerOps>(
                     sequencer_commitment.l2_end_block_number
                 ))?;
             sequencer_commitment_state_diff =
-                merge_state_diffs(sequencer_commitment_state_diff, state_diff);
+                merge_state_diffs(sequencer_commitment_state_diff, state_diff.0);
+            sequencer_st_statediff = sequencer_st_statediff.merge(state_diff.1);
         }
         cumulative_state_diff = merge_state_diffs(
             cumulative_state_diff,
             sequencer_commitment_state_diff.clone(),
         );
-
-        let compressed_state_diff = compress_blob(&borsh::to_vec(&cumulative_state_diff)?);
+        cumulative_st_statediff = cumulative_st_statediff.merge(sequencer_st_statediff.clone());
+
+        let uncompressed_state_diff = borsh::to_vec(&cumulative_state_diff)?;
+        let compressed_state_diff = compress_blob(&uncompressed_state_diff);
+        dbg!(uncompressed_state_diff.len(), compressed_state_diff.len());
+
+        let uncompressed_st_state_diff = borsh::to_vec(&cumulative_st_statediff)?;
+        let hex_state_diff = hex::encode(&uncompressed_st_state_diff);
+        let compressed_st_state_diff = compress_blob(&uncompressed_st_state_diff);
+        dbg!(
+            uncompressed_st_state_diff.len(),
+            compressed_st_state_diff.len(),
+            hex_state_diff
+        );
 
         // Threshold is checked by comparing compressed state diff size as the data will be compressed before it is written on DA
         let state_diff_threshold_reached = compressed_state_diff.len() > MAX_TXBODY_SIZE;
@@ -344,6 +360,7 @@ pub(crate) fn break_sequencer_commitments_into_groups<DB: BatchProverLedgerOps>(
             result_range.push(range);
             // Reset the cumulative state diff to be equal to the current commitment state diff
             cumulative_state_diff = sequencer_commitment_state_diff;
+            cumulative_st_statediff = sequencer_st_statediff;
             range = index..=index;
             current_spec = commitment_spec
         } else {
diff --git a/crates/sequencer/src/runner.rs b/crates/sequencer/src/runner.rs
index e684e193af..1186fb58c2 100644
--- a/crates/sequencer/src/runner.rs
+++ b/crates/sequencer/src/runner.rs
@@ -48,6 +48,7 @@ use sov_rollup_interface::da::{BlockHeaderTrait, DaSpec};
 use sov_rollup_interface::fork::ForkManager;
 use sov_rollup_interface::services::da::DaService;
 use sov_rollup_interface::soft_confirmation::{L2Header, SignedL2Header};
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::zk::StorageRootHash;
 use sov_state::storage::NativeStorage;
 use sov_state::ProverStorage;
@@ -384,7 +385,7 @@ where
         da_block: <Da as DaService>::FilteredBlock,
         l1_fee_rate: u128,
         l2_block_mode: L2BlockMode,
-    ) -> anyhow::Result<(u64, u64, StateDiff)> {
+    ) -> anyhow::Result<(u64, u64, (StateDiff, StatefulStateDiff))> {
         let start = Instant::now();
         let da_height = da_block.header().height();
         let (l2_height, l1_height) = match self
@@ -769,7 +770,7 @@ where
                             // Only errors when there are no receivers
                             let _ = self.soft_confirmation_tx.send(l2_height);
 
-                            let _ = da_commitment_tx.send((l2_height, state_diff));
+                            let _ = da_commitment_tx.send((l2_height, state_diff.0));
                         },
                         Err(e) => {
                             error!("Sequencer error: {}", e);
@@ -801,7 +802,7 @@ where
                             // Only errors when there are no receivers
                             let _ = self.soft_confirmation_tx.send(l2_height);
 
-                            let _ = da_commitment_tx.send((l2_height, state_diff));
+                            let _ = da_commitment_tx.send((l2_height, state_diff.0));
                         },
                         Err(e) => {
                             error!("Sequencer error: {}", e);
diff --git a/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/mod.rs b/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/mod.rs
index 7dfc4921e3..1a304f2da9 100644
--- a/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/mod.rs
+++ b/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/mod.rs
@@ -6,6 +6,7 @@ use rocksdb::WriteBatch;
 use sov_rollup_interface::da::SequencerCommitment;
 use sov_rollup_interface::fork::{Fork, ForkMigration};
 use sov_rollup_interface::soft_confirmation::L2Block;
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::stf::StateDiff;
 use sov_rollup_interface::zk::{Proof, StorageRootHash};
 use sov_schema_db::{Schema, SchemaBatch, SeekKeyEncoder, DB};
@@ -574,7 +575,7 @@ impl BatchProverLedgerOps for LedgerDB {
     fn set_l2_state_diff(
         &self,
         l2_height: SoftConfirmationNumber,
-        state_diff: StateDiff,
+        state_diff: (StateDiff, StatefulStateDiff),
     ) -> anyhow::Result<()> {
         let mut schema_batch = SchemaBatch::new();
         schema_batch.put::<ProverStateDiffs>(&l2_height, &state_diff)?;
@@ -587,7 +588,7 @@ impl BatchProverLedgerOps for LedgerDB {
     fn get_l2_state_diff(
         &self,
         l2_height: SoftConfirmationNumber,
-    ) -> anyhow::Result<Option<StateDiff>> {
+    ) -> anyhow::Result<Option<(StateDiff, StatefulStateDiff)>> {
         self.db.get::<ProverStateDiffs>(&l2_height)
     }
 
diff --git a/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/traits.rs b/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/traits.rs
index fbacdd30fe..ea81c87093 100644
--- a/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/traits.rs
+++ b/crates/sovereign-sdk/full-node/db/sov-db/src/ledger_db/traits.rs
@@ -5,6 +5,7 @@ use anyhow::Result;
 use borsh::BorshSerialize;
 use sov_rollup_interface::da::SequencerCommitment;
 use sov_rollup_interface::soft_confirmation::L2Block;
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::stf::StateDiff;
 use sov_rollup_interface::zk::{Proof, StorageRootHash};
 use sov_schema_db::SchemaBatch;
@@ -186,11 +187,14 @@ pub trait BatchProverLedgerOps: SharedLedgerOps + Send + Sync {
     fn set_l2_state_diff(
         &self,
         l2_height: SoftConfirmationNumber,
-        state_diff: StateDiff,
+        state_diff: (StateDiff, StatefulStateDiff),
     ) -> Result<()>;
 
     /// Returns an L2 state diff
-    fn get_l2_state_diff(&self, l2_height: SoftConfirmationNumber) -> Result<Option<StateDiff>>;
+    fn get_l2_state_diff(
+        &self,
+        l2_height: SoftConfirmationNumber,
+    ) -> Result<Option<(StateDiff, StatefulStateDiff)>>;
 
     /// Clears all pending proving sessions
     fn clear_pending_proving_sessions(&self) -> Result<()>;
diff --git a/crates/sovereign-sdk/full-node/db/sov-db/src/schema/tables.rs b/crates/sovereign-sdk/full-node/db/sov-db/src/schema/tables.rs
index 54ac6638c5..4c7c7234cf 100644
--- a/crates/sovereign-sdk/full-node/db/sov-db/src/schema/tables.rs
+++ b/crates/sovereign-sdk/full-node/db/sov-db/src/schema/tables.rs
@@ -14,6 +14,7 @@ use jmt::storage::{NibblePath, Node, NodeKey, StaleNodeIndex};
 use jmt::Version;
 use sov_rollup_interface::da::SequencerCommitment;
 use sov_rollup_interface::mmr::{MMRChunk, MMRNodeHash, Wtxid};
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::stf::StateDiff;
 use sov_schema_db::schema::{KeyDecoder, KeyEncoder, ValueCodec};
 use sov_schema_db::{CodecError, SeekKeyEncoder};
@@ -436,7 +437,7 @@ define_table_with_default_codec!(
 
 define_table_with_default_codec!(
     /// L2 height to state diff for prover
-    (ProverStateDiffs) SoftConfirmationNumber => StateDiff
+    (ProverStateDiffs) SoftConfirmationNumber => (StateDiff, StatefulStateDiff)
 );
 
 define_table_with_seek_key_codec!(
diff --git a/crates/sovereign-sdk/full-node/db/sov-db/src/schema/types/batch_proof.rs b/crates/sovereign-sdk/full-node/db/sov-db/src/schema/types/batch_proof.rs
index 5f2307f1ba..55b7da72a8 100644
--- a/crates/sovereign-sdk/full-node/db/sov-db/src/schema/types/batch_proof.rs
+++ b/crates/sovereign-sdk/full-node/db/sov-db/src/schema/types/batch_proof.rs
@@ -124,7 +124,7 @@ impl From<StoredBatchProofOutput> for BatchProofOutputRpcResponse {
             StoredBatchProofOutput::V3(value) => Self {
                 initial_state_root: value.initial_state_root.to_vec(),
                 final_state_root: value.final_state_root.to_vec(),
-                state_diff: value.state_diff,
+                state_diff: value.state_diff.0,
                 da_slot_hash: None,
                 sequencer_da_public_key: vec![],
                 sequencer_public_key: vec![],
diff --git a/crates/sovereign-sdk/module-system/sov-modules-core/src/storage/mod.rs b/crates/sovereign-sdk/module-system/sov-modules-core/src/storage/mod.rs
index 390aab55b4..137bf5e8dc 100644
--- a/crates/sovereign-sdk/module-system/sov-modules-core/src/storage/mod.rs
+++ b/crates/sovereign-sdk/module-system/sov-modules-core/src/storage/mod.rs
@@ -7,6 +7,7 @@ use core::fmt;
 use borsh::{BorshDeserialize, BorshSerialize};
 #[cfg(feature = "sync")]
 use serde::Serialize;
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::stf::{StateDiff, StateRootTransition};
 use sov_rollup_interface::witness::Witness;
 use sov_rollup_interface::zk::{SparseMerkleProofSha2, StorageRootHash};
@@ -209,7 +210,7 @@ pub trait Storage: Clone {
         (
             StateRootTransition,
             Self::StateUpdate,
-            StateDiff, // computed in Zk mode
+            (StateDiff, StatefulStateDiff), // computed in Zk mode
         ),
         anyhow::Error,
     >;
diff --git a/crates/sovereign-sdk/module-system/sov-modules-stf-blueprint/src/lib.rs b/crates/sovereign-sdk/module-system/sov-modules-stf-blueprint/src/lib.rs
index 8d4d2fdd89..89ea3b5725 100644
--- a/crates/sovereign-sdk/module-system/sov-modules-stf-blueprint/src/lib.rs
+++ b/crates/sovereign-sdk/module-system/sov-modules-stf-blueprint/src/lib.rs
@@ -24,6 +24,7 @@ use sov_rollup_interface::da::SequencerCommitment;
 use sov_rollup_interface::fork::ForkManager;
 use sov_rollup_interface::soft_confirmation::{L2Block, SignedL2Header};
 use sov_rollup_interface::spec::SpecId;
+use sov_rollup_interface::stateful_statediff::StatefulStateDiff;
 use sov_rollup_interface::stf::{
     SoftConfirmationError, SoftConfirmationResult, StateTransitionError,
 };
@@ -87,7 +88,7 @@ pub struct ApplySequencerCommitmentsOutput {
     /// Final state root after all sequencer commitments were applied
     pub final_state_root: StorageRootHash,
     /// State diff generated after applying
-    pub state_diff: CumulativeStateDiff,
+    pub state_diff: (CumulativeStateDiff, StatefulStateDiff),
     /// Last processed L2 block height
     pub last_l2_height: u64,
     /// Last soft confirmation hash
@@ -424,6 +425,7 @@ where
         forks: &[Fork],
     ) -> ApplySequencerCommitmentsOutput {
         let mut state_diff = CumulativeStateDiff::default();
+        let mut st_statediff = StatefulStateDiff::default();
 
         let sequencer_commitment_merkle_roots = sequencer_commitments
             .iter()
@@ -570,7 +572,8 @@ where
 
                 assert_eq!(current_state_root, result.state_root_transition.init_root);
                 current_state_root = result.state_root_transition.final_root;
-                state_diff.extend(result.state_diff);
+                state_diff.extend(result.state_diff.0);
+                st_statediff = st_statediff.merge(result.state_diff.1);
 
                 l2_height += 1;
 
@@ -619,7 +622,7 @@ where
 
         ApplySequencerCommitmentsOutput {
             final_state_root: current_state_root,
-            state_diff,
+            state_diff: (state_diff, st_statediff),
             // There has to be a height
             last_l2_height: last_commitment_end_height.unwrap(),
             final_soft_confirmation_hash: prev_soft_confirmation_hash.unwrap(),
diff --git a/crates/sovereign-sdk/module-system/sov-state/src/prover_storage.rs b/crates/sovereign-sdk/module-system/sov-state/src/prover_storage.rs
index c5e7ce935c..924284cc29 100644
--- a/crates/sovereign-sdk/module-system/sov-state/src/prover_storage.rs
+++ b/crates/sovereign-sdk/module-system/sov-state/src/prover_storage.rs
@@ -140,7 +140,14 @@ impl Storage for ProverStorage {
         &self,
         state_log: &ReadWriteLog,
         witness: &mut Witness,
-    ) -> Result<(StateRootTransition, Self::StateUpdate, StateDiff), anyhow::Error> {
+    ) -> Result<
+        (
+            StateRootTransition,
+            Self::StateUpdate,
+            (StateDiff, StatefulStateDiff),
+        ),
+        anyhow::Error,
+    > {
         let version = self.version();
         let jmt = JellyfishMerkleTree::<_, DefaultHasher>::new(&self.db);
 
@@ -242,7 +249,7 @@ impl Storage for ProverStorage {
                 final_root: new_root.into(),
             },
             state_update,
-            diff,
+            (diff, st_statediff),
         ))
     }
 
diff --git a/crates/sovereign-sdk/module-system/sov-state/src/zk_storage.rs b/crates/sovereign-sdk/module-system/sov-state/src/zk_storage.rs
index 17b8757c78..03a589e022 100644
--- a/crates/sovereign-sdk/module-system/sov-state/src/zk_storage.rs
+++ b/crates/sovereign-sdk/module-system/sov-state/src/zk_storage.rs
@@ -1,6 +1,6 @@
 use jmt::KeyHash;
 use sov_modules_core::{OrderedWrites, ReadWriteLog, Storage, StorageKey, StorageValue};
-use sov_rollup_interface::stateful_statediff;
+use sov_rollup_interface::stateful_statediff::{self, StatefulStateDiff};
 use sov_rollup_interface::stf::{StateDiff, StateRootTransition};
 use sov_rollup_interface::witness::Witness;
 use sov_rollup_interface::zk::StorageRootHash;
@@ -55,7 +55,14 @@ impl Storage for ZkStorage {
         &self,
         state_log: &ReadWriteLog,
         witness: &mut Witness,
-    ) -> Result<(StateRootTransition, Self::StateUpdate, StateDiff), anyhow::Error> {
+    ) -> Result<
+        (
+            StateRootTransition,
+            Self::StateUpdate,
+            (StateDiff, StatefulStateDiff),
+        ),
+        anyhow::Error,
+    > {
         let prev_state_root = witness.get_hint();
 
         // For each value that's been read from the tree, verify the provided jmt proof
@@ -116,7 +123,6 @@ impl Storage for ZkStorage {
             .sum();
         let ststdiff = borsh::to_vec(&st_statediff).unwrap();
         let prevdiff = borsh::to_vec(&diff).unwrap();
-        let _ = st_statediff;
 
         println!(
             "zk: ststdiff: {} bytes, diff: {} bytes, ststdiff unparsed: {} bytes \n",
@@ -131,7 +137,7 @@ impl Storage for ZkStorage {
                 final_root: new_root,
             },
             (),
-            diff,
+            (diff, st_statediff),
         ))
     }
 
diff --git a/crates/sovereign-sdk/rollup-interface/Cargo.toml b/crates/sovereign-sdk/rollup-interface/Cargo.toml
index 0b7dc71433..900b5fb6db 100644
--- a/crates/sovereign-sdk/rollup-interface/Cargo.toml
+++ b/crates/sovereign-sdk/rollup-interface/Cargo.toml
@@ -15,7 +15,7 @@ readme = "README.md"
 resolver = "2"
 
 [dependencies]
-alloy-primitives = { workspace = true, features = ["serde"], optional = true }
+alloy-primitives = { workspace = true, features = ["serde"] }
 anyhow = { workspace = true, features = ["default"] }
 async-trait = { workspace = true, optional = true }
 bcs = { workspace = true }
@@ -40,7 +40,6 @@ serde_json = { workspace = true }
 [features]
 default = []
 native = [
-  "alloy-primitives",
   "tokio",
   "futures",
   "tracing",
diff --git a/crates/sovereign-sdk/rollup-interface/src/state_machine/stf.rs b/crates/sovereign-sdk/rollup-interface/src/state_machine/stf.rs
index 239afd6013..24d5a4a1d0 100644
--- a/crates/sovereign-sdk/rollup-interface/src/state_machine/stf.rs
+++ b/crates/sovereign-sdk/rollup-interface/src/state_machine/stf.rs
@@ -5,6 +5,7 @@
 //! main event loop of the rollup.
 
 use super::zk::StorageRootHash;
+use crate::stateful_statediff::StatefulStateDiff;
 use crate::RefCount;
 
 /// The configuration of a full node of the rollup which creates zk proofs.
@@ -64,7 +65,7 @@ pub struct SoftConfirmationResult<Cs, W, SL> {
     /// Witness after applying the whole block
     pub offchain_witness: W,
     /// State diff after applying the whole block
-    pub state_diff: StateDiff,
+    pub state_diff: (StateDiff, StatefulStateDiff),
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/crates/sovereign-sdk/rollup-interface/src/state_machine/zk/batch_proof/output/v3.rs b/crates/sovereign-sdk/rollup-interface/src/state_machine/zk/batch_proof/output/v3.rs
index b78f511a45..2bede46f8f 100644
--- a/crates/sovereign-sdk/rollup-interface/src/state_machine/zk/batch_proof/output/v3.rs
+++ b/crates/sovereign-sdk/rollup-interface/src/state_machine/zk/batch_proof/output/v3.rs
@@ -4,6 +4,7 @@ use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize};
 
 use super::CumulativeStateDiff;
+use crate::stateful_statediff::StatefulStateDiff;
 use crate::zk::StorageRootHash;
 
 /// The public output of a SNARK batch proof in Sovereign, this struct makes a claim that
@@ -24,7 +25,7 @@ pub struct BatchProofCircuitOutputV3 {
     /// This will be [0; 32] for pre fork 1 proofs
     pub final_soft_confirmation_hash: [u8; 32],
     /// State diff of L2 blocks in the processed sequencer commitments.
-    pub state_diff: CumulativeStateDiff,
+    pub state_diff: (CumulativeStateDiff, StatefulStateDiff),
     /// The last processed l2 height in the processed sequencer commitments.
     /// This will be 0 for pre fork 1 proofs
     pub last_l2_height: u64,
diff --git a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/compression.rs b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/compression.rs
index 3e8ce1642e..7f8da815d1 100644
--- a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/compression.rs
+++ b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/compression.rs
@@ -2,9 +2,10 @@
 
 use alloy_primitives::{B256, U256};
 use borsh::{BorshDeserialize, BorshSerialize};
+use serde::{Deserialize, Serialize};
 
 /// diff(a, b) = Add(a+b)
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CompressionAdd {
     pub(crate) diff: U256,
     pub(crate) size: u8,
@@ -24,7 +25,7 @@ impl CompressionAdd {
 }
 
 /// A special case when Add(x) for x <= 31 to fit into 1 serialized byte
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CompressionAddInlined {
     pub(crate) diff: u8,
 }
@@ -43,7 +44,7 @@ impl CompressionAddInlined {
 }
 
 /// diff(a, b) = Sub(a - b)
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CompressionSub {
     pub(crate) diff: U256,
     pub(crate) size: u8,
@@ -63,7 +64,7 @@ impl CompressionSub {
 }
 
 /// Only try to remove leading zeroes.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CompressionTransform {
     pub(crate) diff: U256,
     pub(crate) size: u8,
@@ -83,7 +84,7 @@ impl CompressionTransform {
 }
 
 /// It's a special case when we store diff as is (32 bytes)
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct CompressionAbsent {
     pub(crate) diff: U256,
 }
@@ -97,7 +98,7 @@ impl CompressionAbsent {
 }
 
 /// All possible diffs of a slot of U256
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SlotChange {
     /// Add
     Add(CompressionAdd),
@@ -253,7 +254,7 @@ pub fn compress_one_best_strategy(new_value: U256) -> SlotChange {
 }
 
 /// All possible diffs of a slot of Option<B256>
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum CodeHashChange {
     /// Same
     Same,
diff --git a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/merge.rs b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/merge.rs
index a620e9f8b1..024f5ddbbd 100644
--- a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/merge.rs
+++ b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/merge.rs
@@ -328,11 +328,10 @@ mod tests {
                 compress_two_best_strategy(*x, *y)
             })
             .collect();
-        let final_change = changes.into_iter().fold(
+        changes.into_iter().fold(
             SlotChange::AddInlined(CompressionAddInlined { diff: 0 }),
             |init, elem| init.merge(elem),
-        );
-        final_change
+        )
     }
 
     fn apply_slot_change(val: U256, change: SlotChange) -> U256 {
@@ -390,10 +389,9 @@ mod tests {
                 compress_two_code_hash(*x, *y)
             })
             .collect();
-        let final_change = changes
+        changes
             .into_iter()
-            .fold(CodeHashChange::Removed, |init, elem| init.merge(elem));
-        final_change
+            .fold(CodeHashChange::Removed, |init, elem| init.merge(elem))
     }
 
     fn apply_code_change(val: Option<B256>, change: CodeHashChange) -> Option<B256> {
diff --git a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/mod.rs b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/mod.rs
index 9f8d11fc00..2be1b24cdf 100644
--- a/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/mod.rs
+++ b/crates/sovereign-sdk/rollup-interface/src/stateful_statediff/mod.rs
@@ -218,7 +218,7 @@ pub fn build_post_state(
 }
 
 /// Reflects account change
-#[derive(Debug, Clone, Copy, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone, Copy, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
 pub struct AccountChange {
     balance: SlotChange,
     nonce: SlotChange,
@@ -226,7 +226,7 @@ pub struct AccountChange {
 }
 
 /// Reflects storage change
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
 pub struct StorageChange {
     #[borsh(serialize_with = "ser_btree_u256", deserialize_with = "der_btree_u256")]
     storage: BTreeMap<U256, Option<SlotChange>>,
@@ -234,7 +234,7 @@ pub struct StorageChange {
 
 /// Reflects new Evm.latest_block_hashes
 // TODO maybe keep (u64, B256) in StatefulStateDiff but compress on borsh serde?
-#[derive(Debug, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
 pub struct LatestBlockHashes {
     starting_block_number: u64,
     #[borsh(serialize_with = "ser_vec_b256", deserialize_with = "der_vec_b256")]
@@ -242,7 +242,7 @@ pub struct LatestBlockHashes {
 }
 
 /// Reflects all state change
-#[derive(Debug, Default, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Default, Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize)]
 pub struct StatefulStateDiff {
     // TODO: Remove before mainnet
     #[borsh(
diff --git a/crates/storage-ops/src/tests.rs b/crates/storage-ops/src/tests.rs
index 56ac71625a..982eac8b86 100644
--- a/crates/storage-ops/src/tests.rs
+++ b/crates/storage-ops/src/tests.rs
@@ -136,7 +136,7 @@ pub fn test_pruning_ledger_db_soft_confirmations() {
             .put::<L2Witness>(&SoftConfirmationNumber(i), &(vec![5; 32], vec![6; 32]))
             .unwrap();
         ledger_db
-            .put::<ProverStateDiffs>(&SoftConfirmationNumber(i), &vec![])
+            .put::<ProverStateDiffs>(&SoftConfirmationNumber(i), &(vec![], Default::default()))
             .unwrap();
 
         da_slot_height += 1;
@@ -262,7 +262,7 @@ pub fn test_pruning_ledger_db_batch_prover_soft_confirmations() {
             .put::<L2Witness>(&SoftConfirmationNumber(i), &(vec![5; 32], vec![6; 32]))
             .unwrap();
         ledger_db
-            .put::<ProverStateDiffs>(&SoftConfirmationNumber(i), &vec![])
+            .put::<ProverStateDiffs>(&SoftConfirmationNumber(i), &(vec![], Default::default()))
             .unwrap();
 
         da_slot_height += 1;