feat: remove full state diff deserialization (#50)

`contracts` and `classes` are not used in the state transition process
in any way, and do not contribute to output section transversal as
they're at the end of the output stream. There's no reason to parse
these and immediately discard them.

Author: xJonathanLEI

piltover/src/bindgen.rs

@@ -53,67 +53,6 @@ impl<P: starknet::providers::Provider + Sync> AppchainContractReader<P> {
     }
 }
 #[derive()]
-pub struct ContractChanges {
-    pub addr: starknet::core::types::Felt,
-    pub nonce: starknet::core::types::Felt,
-    pub class_hash: Option<starknet::core::types::Felt>,
-    pub storage_changes: Vec<(starknet::core::types::Felt, starknet::core::types::Felt)>,
-}
-impl cainome::cairo_serde::CairoSerde for ContractChanges {
-    type RustType = Self;
-    const SERIALIZED_SIZE: std::option::Option<usize> = None;
-    #[inline]
-    fn cairo_serialized_size(__rust: &Self::RustType) -> usize {
-        let mut __size = 0;
-        __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.addr);
-        __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.nonce);
-        __size += Option::<starknet::core::types::Felt>::cairo_serialized_size(&__rust.class_hash);
-        __size += Vec :: <
-        (starknet :: core :: types :: Felt, starknet :: core :: types :: Felt)
-        > :: cairo_serialized_size(& __rust.storage_changes);
-        __size
-    }
-    fn cairo_serialize(__rust: &Self::RustType) -> Vec<starknet::core::types::Felt> {
-        let mut __out: Vec<starknet::core::types::Felt> = vec![];
-        __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.addr));
-        __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.nonce));
-        __out.extend(Option::<starknet::core::types::Felt>::cairo_serialize(
-            &__rust.class_hash,
-        ));
-        __out.extend(Vec::<(
-            starknet::core::types::Felt,
-            starknet::core::types::Felt,
-        )>::cairo_serialize(&__rust.storage_changes));
-        __out
-    }
-    fn cairo_deserialize(
-        __felts: &[starknet::core::types::Felt],
-        __offset: usize,
-    ) -> cainome::cairo_serde::Result<Self::RustType> {
-        let mut __offset = __offset;
-        let addr = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?;
-        __offset += starknet::core::types::Felt::cairo_serialized_size(&addr);
-        let nonce = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?;
-        __offset += starknet::core::types::Felt::cairo_serialized_size(&nonce);
-        let class_hash =
-            Option::<starknet::core::types::Felt>::cairo_deserialize(__felts, __offset)?;
-        __offset += Option::<starknet::core::types::Felt>::cairo_serialized_size(&class_hash);
-        let storage_changes =
-            Vec::<(starknet::core::types::Felt, starknet::core::types::Felt)>::cairo_deserialize(
-                __felts, __offset,
-            )?;
-        __offset += Vec :: <
-        (starknet :: core :: types :: Felt, starknet :: core :: types :: Felt)
-        > :: cairo_serialized_size(& storage_changes);
-        Ok(ContractChanges {
-            addr,
-            nonce,
-            class_hash,
-            storage_changes,
-        })
-    }
-}
-#[derive()]
 pub struct LogStateTransitionFact {
     pub state_transition_fact: cainome::cairo_serde::U256,
 }
@@ -983,8 +922,6 @@ pub struct StarknetOsOutput {
     pub full_output: starknet::core::types::Felt,
     pub messages_to_l1: Vec<MessageToStarknet>,
     pub messages_to_l2: Vec<MessageToAppchain>,
-    pub contracts: Vec<ContractChanges>,
-    pub classes: Vec<(starknet::core::types::Felt, starknet::core::types::Felt)>,
 }
 impl cainome::cairo_serde::CairoSerde for StarknetOsOutput {
     type RustType = Self;
@@ -1005,10 +942,6 @@ impl cainome::cairo_serde::CairoSerde for StarknetOsOutput {
         __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.full_output);
         __size += Vec::<MessageToStarknet>::cairo_serialized_size(&__rust.messages_to_l1);
         __size += Vec::<MessageToAppchain>::cairo_serialized_size(&__rust.messages_to_l2);
-        __size += Vec::<ContractChanges>::cairo_serialized_size(&__rust.contracts);
-        __size += Vec :: <
-        (starknet :: core :: types :: Felt, starknet :: core :: types :: Felt)
-        > :: cairo_serialized_size(& __rust.classes);
         __size
     }
     fn cairo_serialize(__rust: &Self::RustType) -> Vec<starknet::core::types::Felt> {
@@ -1049,11 +982,6 @@ impl cainome::cairo_serde::CairoSerde for StarknetOsOutput {
         __out.extend(Vec::<MessageToAppchain>::cairo_serialize(
             &__rust.messages_to_l2,
         ));
-        __out.extend(Vec::<ContractChanges>::cairo_serialize(&__rust.contracts));
-        __out.extend(Vec::<(
-            starknet::core::types::Felt,
-            starknet::core::types::Felt,
-        )>::cairo_serialize(&__rust.classes));
         __out
     }
     fn cairo_deserialize(
@@ -1086,15 +1014,6 @@ impl cainome::cairo_serde::CairoSerde for StarknetOsOutput {
         __offset += Vec::<MessageToStarknet>::cairo_serialized_size(&messages_to_l1);
         let messages_to_l2 = Vec::<MessageToAppchain>::cairo_deserialize(__felts, __offset)?;
         __offset += Vec::<MessageToAppchain>::cairo_serialized_size(&messages_to_l2);
-        let contracts = Vec::<ContractChanges>::cairo_deserialize(__felts, __offset)?;
-        __offset += Vec::<ContractChanges>::cairo_serialized_size(&contracts);
-        let classes =
-            Vec::<(starknet::core::types::Felt, starknet::core::types::Felt)>::cairo_deserialize(
-                __felts, __offset,
-            )?;
-        __offset += Vec :: <
-        (starknet :: core :: types :: Felt, starknet :: core :: types :: Felt)
-        > :: cairo_serialized_size(& classes);
         Ok(StarknetOsOutput {
             initial_root,
             final_root,
@@ -1108,8 +1027,6 @@ impl cainome::cairo_serde::CairoSerde for StarknetOsOutput {
             full_output,
             messages_to_l1,
             messages_to_l2,
-            contracts,
-            classes,
         })
     }
 }

src/snos_output.cairo

@@ -41,8 +41,6 @@ pub struct StarknetOsOutput {
     pub full_output: felt252,
     pub messages_to_l1: Span<MessageToStarknet>,
     pub messages_to_l2: Span<MessageToAppchain>,
-    pub contracts: Array<ContractChanges>,
-    pub classes: Array<(felt252, felt252)>,
 }
 
 #[derive(Drop, Serde, Debug)]
@@ -104,14 +102,6 @@ pub fn deserialize_os_output(ref input_iter: SpanIter<felt252>) -> StarknetOsOut
         let _ = read_segment(ref input_iter, 2 * 2 * n_blobs);
     }
     let (messages_to_l1, messages_to_l2) = deserialize_messages(ref input_iter);
-    let (contracts, classes) = if use_kzg_da.is_zero() {
-        (
-            deserialize_contract_state(ref input_iter, *full_output),
-            deserialize_contract_class_da_changes(ref input_iter, *full_output),
-        )
-    } else {
-        (array![], array![])
-    };
     StarknetOsOutput {
         initial_root: *header[PREVIOUS_MERKLE_UPDATE_OFFSET],
         final_root: *header[NEW_MERKLE_UPDATE_OFFSET],
@@ -125,8 +115,6 @@ pub fn deserialize_os_output(ref input_iter: SpanIter<felt252>) -> StarknetOsOut
         full_output: *full_output,
         messages_to_l1: messages_to_l1,
         messages_to_l2: messages_to_l2,
-        contracts,
-        classes,
     }
 }
 
@@ -151,83 +139,6 @@ pub fn deserialize_messages(
     (messages_to_l1.span(), messages_to_l2.span())
 }
 
-fn deserialize_contract_state(
-    ref input_iter: SpanIter<felt252>, full_output: felt252,
-) -> Array<ContractChanges> {
-    let output_n_updates: usize = (*(input_iter.next().unwrap()))
-        .try_into()
-        .expect('Invalid output_n_updates');
-    let mut contract_changes = array![];
-    for _ in 0..output_n_updates {
-        contract_changes.append(deserialize_contract_state_inner(ref input_iter, full_output));
-    };
-    contract_changes
-}
-
-fn deserialize_contract_state_inner(
-    ref input_iter: SpanIter<felt252>, full_output: felt252,
-) -> ContractChanges {
-    let bound: u256 = 18446744073709551616; // 2^64
-    let addr = *(input_iter.next().unwrap());
-    let value: u256 = (*(input_iter.next().unwrap())).try_into().expect('Invalid value');
-    let new_value = value / bound;
-    let n_actual_updates = value % bound;
-    let was_class_updated = new_value / bound;
-    let new_state_nonce = new_value % bound;
-    let new_state_class_hash = if !full_output.is_zero() {
-        let _prev_state_class_hash = *(input_iter.next().unwrap());
-        Option::Some(*(input_iter.next().unwrap()))
-    } else {
-        if !was_class_updated.is_zero() {
-            Option::Some(*(input_iter.next().unwrap()))
-        } else {
-            Option::None
-        }
-    };
-
-    let n_actual_updates: usize = n_actual_updates.try_into().expect('Invalid n_actual_updates');
-    let storage_changes = deserialize_da_changes(ref input_iter, n_actual_updates, full_output);
-    ContractChanges {
-        addr: addr,
-        nonce: new_state_nonce.try_into().unwrap(),
-        class_hash: new_state_class_hash,
-        storage_changes,
-    }
-}
-
-fn deserialize_da_changes(
-    ref input_iter: SpanIter<felt252>, n_actual_updates: usize, full_output: felt252,
-) -> Array<(felt252, felt252)> {
-    let mut storage_changes = array![];
-    for _ in 0..n_actual_updates {
-        let key = *(input_iter.next().unwrap());
-        if full_output.is_non_zero() {
-            *(input_iter.next().unwrap());
-        };
-        let new_value = *(input_iter.next().unwrap());
-        storage_changes.append((key, new_value));
-    };
-    storage_changes
-}
-
-fn deserialize_contract_class_da_changes(
-    ref input_iter: SpanIter<felt252>, full_output: felt252,
-) -> Array<(felt252, felt252)> {
-    let output_n_updates: usize = (*(input_iter.next().unwrap()))
-        .try_into()
-        .expect('Invalid output_n_updates');
-    let mut contract_changes = array![];
-    for _ in 0..output_n_updates {
-        let class_hash = *(input_iter.next().unwrap());
-        if full_output.is_non_zero() {
-            *(input_iter.next().unwrap());
-        };
-        let compiled_class_hash = *(input_iter.next().unwrap());
-        contract_changes.append((class_hash, compiled_class_hash));
-    };
-    contract_changes
-}
-
 fn deserialize_messages_to_l1(ref input_iter: SpanIter<felt252>) -> Array<MessageToStarknet> {
     let mut messages_to_starknet = array![];
     loop {

src/state/tests/test_state.cairo

@@ -33,8 +33,6 @@ fn state_update_ok() {
         full_output: 0,
         messages_to_l1: array![].span(),
         messages_to_l2: array![].span(),
-        contracts: array![],
-        classes: array![],
     };
     mock.update(os_output);
 
@@ -61,8 +59,6 @@ fn genesis_state_update_ok() {
         full_output: 0,
         messages_to_l1: array![].span(),
         messages_to_l2: array![].span(),
-        contracts: array![],
-        classes: array![],
     };
     mock.update(os_output);
 
@@ -91,8 +87,6 @@ fn state_update_invalid_block_number() {
         full_output: 0,
         messages_to_l1: array![].span(),
         messages_to_l2: array![].span(),
-        contracts: array![],
-        classes: array![],
     };
 
     mock.update(os_output);
@@ -116,8 +110,6 @@ fn state_update_invalid_previous_root() {
         full_output: 0,
         messages_to_l1: array![].span(),
         messages_to_l2: array![].span(),
-        contracts: array![],
-        classes: array![],
     };
 
     mock.update(invalid_state_update);