feat: add len to ThinStateDiff (#191)

* feat!: add missing fields to BlockHeader

* feat: add len to ThinStateDiff

Author: ShahakShama

src/block.rs

@@ -8,8 +8,8 @@ use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
 use crate::core::{
-    EventCommitment, GlobalRoot, SequencerContractAddress, SequencerPublicKey, StateDiffCommitment,
-    TransactionCommitment,
+    EventCommitment, GlobalRoot, ReceiptCommitment, SequencerContractAddress, SequencerPublicKey,
+    StateDiffCommitment, TransactionCommitment,
 };
 use crate::crypto::{verify_message_hash_signature, CryptoError, Signature};
 use crate::data_availability::L1DataAvailabilityMode;
@@ -61,13 +61,17 @@ pub struct BlockHeader {
     #[serde(skip_serializing)]
     pub state_diff_commitment: Option<StateDiffCommitment>,
     #[serde(skip_serializing)]
+    pub state_diff_length: Option<usize>,
+    #[serde(skip_serializing)]
     pub transaction_commitment: Option<TransactionCommitment>,
     #[serde(skip_serializing)]
     pub event_commitment: Option<EventCommitment>,
     #[serde(skip_serializing)]
     pub n_transactions: Option<usize>,
     #[serde(skip_serializing)]
     pub n_events: Option<usize>,
+    #[serde(skip_serializing)]
+    pub receipt_commitment: Option<ReceiptCommitment>,
     pub starknet_version: StarknetVersion,
 }
 

src/core.rs

@@ -227,6 +227,23 @@ pub struct TransactionCommitment(pub StarkHash);
 )]
 pub struct EventCommitment(pub StarkHash);
 
+/// The commitment on the receipts in a [Block](`crate::block::Block`).
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Default,
+    Eq,
+    PartialEq,
+    Hash,
+    Deserialize,
+    Serialize,
+    PartialOrd,
+    Ord,
+    Display,
+)]
+pub struct ReceiptCommitment(pub StarkHash);
+
 #[derive(
     Debug, Copy, Clone, Default, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
 )]

src/state.rs

@@ -84,6 +84,22 @@ impl ThinStateDiff {
             diff.deprecated_declared_classes,
         )
     }
+
+    #[allow(clippy::len_without_is_empty)]
+    /// This has the same value as `state_diff_length` in the corresponding `BlockHeader`.
+    pub fn len(&self) -> usize {
+        let mut result = 0usize;
+        result += self.deployed_contracts.len();
+        result += self.declared_classes.len();
+        result += self.deprecated_declared_classes.len();
+        result += self.nonces.len();
+        result += self.replaced_classes.len();
+
+        for (_contract_address, storage_diffs) in &self.storage_diffs {
+            result += storage_diffs.len();
+        }
+        result
+    }
 }
 
 impl From<StateDiff> for ThinStateDiff {

src/state_test.rs

@@ -1,7 +1,10 @@
 use std::collections::HashMap;
 
+use indexmap::indexmap;
 use serde_json::json;
 
+use super::ThinStateDiff;
+use crate::core::{ClassHash, CompiledClassHash, Nonce};
 use crate::deprecated_contract_class::EntryPointOffset;
 
 #[test]
@@ -22,3 +25,39 @@ fn entry_point_offset_into_json_str() {
     let offset = EntryPointOffset(123);
     assert_eq!(json!(offset), json!(format!("{:#x}", offset.0)));
 }
+
+#[test]
+fn thin_state_diff_len() {
+    let state_diff = ThinStateDiff {
+        deployed_contracts: indexmap! {
+            0u64.into() => ClassHash(4u64.into()),
+        },
+        storage_diffs: indexmap! {
+            0u64.into() => indexmap! {
+                0u64.into() => 0u64.into(),
+                1u64.into() => 1u64.into(),
+            },
+            1u64.into() => indexmap! {
+                0u64.into() => 0u64.into(),
+            },
+        },
+        declared_classes: indexmap! {
+            ClassHash(4u64.into()) => CompiledClassHash(9u64.into()),
+            ClassHash(5u64.into()) => CompiledClassHash(10u64.into()),
+        },
+        deprecated_declared_classes: vec![
+            ClassHash(6u64.into()),
+            ClassHash(7u64.into()),
+            ClassHash(8u64.into()),
+        ],
+        nonces: indexmap! {
+            0u64.into() => Nonce(1u64.into()),
+            1u64.into() => Nonce(1u64.into()),
+        },
+        replaced_classes: indexmap! {
+            2u64.into() => ClassHash(4u64.into()),
+            3u64.into() => ClassHash(5u64.into()),
+        },
+    };
+    assert_eq!(state_diff.len(), 13);
+}