chore: message-root-support (#2706)

## What ❔

<!-- What are the changes this PR brings about? -->
<!-- Example: This PR adds a PR template to the repo. -->
<!-- (For bigger PRs adding more context is appreciated) -->

## Why ❔

<!-- Why are these changes done? What goal do they contribute to? What
are the principles behind them? -->
<!-- Example: PR templates ensure PR reviewers, observers, and future
iterators are in context about the evolution of repos. -->

## Checklist

<!-- Check your PR fulfills the following items. -->
<!-- For draft PRs check the boxes as you complete them. -->

- [ ] PR title corresponds to the body of PR (we generate changelog
entries from PRs).
- [ ] Tests for the changes have been added / updated.
- [ ] Documentation comments have been added / updated.
- [ ] Code has been formatted via `zk fmt` and `zk lint`.

---------

Co-authored-by: Stanislav Breadless <[email protected]>

core/lib/multivm/src/versions/vm_latest/tests/constants.rs

@@ -1,22 +1,22 @@
-use ethabi::Token;
-use itertools::Itertools;
-use zksync_types::{
-    get_immutable_key, get_l2_message_root_init_logs, AccountTreeId, StorageKey, StorageLog,
-    StorageLogKind, H256, IMMUTABLE_SIMULATOR_STORAGE_ADDRESS, L2_BRIDGEHUB_ADDRESS,
-    L2_MESSAGE_ROOT_ADDRESS,
-};
+// use ethabi::Token;
+// use itertools::Itertools;
+// use zksync_types::{
+//     get_immutable_key, get_l2_message_root_init_logs, AccountTreeId, StorageKey, StorageLog,
+//     StorageLogKind, H256, IMMUTABLE_SIMULATOR_STORAGE_ADDRESS, L2_BRIDGEHUB_ADDRESS,
+//     L2_MESSAGE_ROOT_ADDRESS,
+// };
 
-use crate::{
-    interface::{TxExecutionMode, VmExecutionMode, VmInterface},
-    vm_latest::{
-        tests::{
-            tester::{DeployContractsTx, TxType, VmTesterBuilder},
-            utils::read_message_root,
-        },
-        HistoryEnabled,
-    },
-    vm_m5::storage::Storage,
-};
+// use crate::{
+//     // interface::{TxExecutionMode, VmExecutionMode, VmInterface},
+//     vm_latest::{
+//         tests::{
+//             tester::{DeployContractsTx, TxType, VmTesterBuilder},
+//             utils::read_message_root,
+//         },
+//         HistoryEnabled,
+//     },
+//     vm_m5::storage::Storage,
+// };
 /// Some of the constants of the system are implicitly calculated, but they may affect the code and so
 /// we added additional checks on them to keep any unwanted changes of those apparent.
 #[test]
@@ -27,94 +27,94 @@ fn test_that_bootloader_encoding_space_is_large_enoguh() {
     assert!(encoding_space >= 330000, "Bootloader tx space is too small");
 }
 
-/// Test that checks that the initial logs for the L2 Message Root are correct
-#[test]
-fn test_l2_message_root_init_logs() {
-    let mut vm = VmTesterBuilder::new(HistoryEnabled)
-        .with_empty_in_memory_storage()
-        .with_execution_mode(TxExecutionMode::VerifyExecute)
-        .with_random_rich_accounts(1)
-        .build();
+// Test that checks that the initial logs for the L2 Message Root are correct
+// #[test]
+// fn test_l2_message_root_init_logs() {
+//     let mut vm = VmTesterBuilder::new(HistoryEnabled)
+//         .with_empty_in_memory_storage()
+//         .with_execution_mode(TxExecutionMode::VerifyExecute)
+//         .with_random_rich_accounts(1)
+//         .build();
 
-    let message_root_bytecode = read_message_root();
-    let account = &mut vm.rich_accounts[0];
-    let DeployContractsTx { tx, address, .. } = account.get_deploy_tx(
-        &message_root_bytecode,
-        Some(&[Token::Address(L2_BRIDGEHUB_ADDRESS)]),
-        TxType::L2,
-    );
+//     let message_root_bytecode = read_message_root();
+//     let account = &mut vm.rich_accounts[0];
+//     let DeployContractsTx { tx, address, .. } = account.get_deploy_tx(
+//         &message_root_bytecode,
+//         Some(&[Token::Address(L2_BRIDGEHUB_ADDRESS)]),
+//         TxType::L2,
+//     );
 
-    vm.vm.push_transaction(tx);
-    let result = vm.vm.execute(VmExecutionMode::OneTx);
-    assert!(!result.result.is_failed(), "Transaction wasn't successful");
+//     vm.vm.push_transaction(tx);
+//     let result = vm.vm.execute(VmExecutionMode::OneTx);
+//     assert!(!result.result.is_failed(), "Transaction wasn't successful");
 
-    // That's the only key in the immutable simulator that should be changed. It depends on the address
-    // of the deployed contract, so we check that the way it was generated for a random deployed contract is the same.
-    let expected_change_immutable_key = get_immutable_key(&address, H256::zero());
-    let expected_genesis_immutable_key = get_immutable_key(&L2_MESSAGE_ROOT_ADDRESS, H256::zero());
+//     // That's the only key in the immutable simulator that should be changed. It depends on the address
+//     // of the deployed contract, so we check that the way it was generated for a random deployed contract is the same.
+//     let expected_change_immutable_key = get_immutable_key(&address, H256::zero());
+//     let expected_genesis_immutable_key = get_immutable_key(&L2_MESSAGE_ROOT_ADDRESS, H256::zero());
 
-    let mut expected_init_logs = get_l2_message_root_init_logs()
-        .into_iter()
-        .map(|x| StorageLog {
-            // We unify all the logs to all have the same kind
-            kind: StorageLogKind::InitialWrite,
-            key: x.key,
-            value: x.value,
-        })
-        .collect::<Vec<_>>();
+//     let mut expected_init_logs = get_l2_message_root_init_logs()
+//         .into_iter()
+//         .map(|x| StorageLog {
+//             // We unify all the logs to all have the same kind
+//             kind: StorageLogKind::InitialWrite,
+//             key: x.key,
+//             value: x.value,
+//         })
+//         .collect::<Vec<_>>();
 
-    let ordering = |a: &StorageLog, b: &StorageLog| match a.key.cmp(&b.key) {
-        std::cmp::Ordering::Equal => a.value.cmp(&b.value),
-        other => other,
-    };
+//     let ordering = |a: &StorageLog, b: &StorageLog| match a.key.cmp(&b.key) {
+//         std::cmp::Ordering::Equal => a.value.cmp(&b.value),
+//         other => other,
+//     };
 
-    expected_init_logs.sort_by(ordering);
+//     expected_init_logs.sort_by(ordering);
 
-    let correct_init_logs = vm
-        .vm
-        .storage
-        .borrow_mut()
-        .get_modified_storage_keys()
-        .iter()
-        .filter_map(|(&storage_key, &value)| {
-            if *storage_key.address() == address {
-                Some(StorageLog {
-                    kind: StorageLogKind::InitialWrite,
-                    key: StorageKey::new(
-                        // Note, that it in the end we will compare those with the genesis logs that
-                        // have the `L2_MESSAGE_ROOT_ADDRESS` as the address
-                        AccountTreeId::new(L2_MESSAGE_ROOT_ADDRESS),
-                        *storage_key.key(),
-                    ),
-                    value,
-                })
-            } else if *storage_key.address() == IMMUTABLE_SIMULATOR_STORAGE_ADDRESS {
-                assert!(
-                    *storage_key.key() == expected_change_immutable_key,
-                    "Incorrect immutable key has been changed"
-                );
+//     let correct_init_logs = vm
+//         .vm
+//         .storage
+//         .borrow_mut()
+//         .get_modified_storage_keys()
+//         .iter()
+//         .filter_map(|(&storage_key, &value)| {
+//             if *storage_key.address() == address {
+//                 Some(StorageLog {
+//                     kind: StorageLogKind::InitialWrite,
+//                     key: StorageKey::new(
+//                         // Note, that it in the end we will compare those with the genesis logs that
+//                         // have the `L2_MESSAGE_ROOT_ADDRESS` as the address
+//                         AccountTreeId::new(L2_MESSAGE_ROOT_ADDRESS),
+//                         *storage_key.key(),
+//                     ),
+//                     value,
+//                 })
+//             } else if *storage_key.address() == IMMUTABLE_SIMULATOR_STORAGE_ADDRESS {
+//                 assert!(
+//                     *storage_key.key() == expected_change_immutable_key,
+//                     "Incorrect immutable key has been changed"
+//                 );
 
-                Some(StorageLog {
-                    kind: StorageLogKind::InitialWrite,
-                    key: StorageKey::new(
-                        AccountTreeId::new(IMMUTABLE_SIMULATOR_STORAGE_ADDRESS),
-                        // For comparison to work, we replace the immutable key with the one that is used for genesis
-                        expected_genesis_immutable_key,
-                    ),
-                    value,
-                })
-            } else {
-                None
-            }
-        })
-        .sorted_by(ordering)
-        .collect::<Vec<_>>();
+//                 Some(StorageLog {
+//                     kind: StorageLogKind::InitialWrite,
+//                     key: StorageKey::new(
+//                         AccountTreeId::new(IMMUTABLE_SIMULATOR_STORAGE_ADDRESS),
+//                         // For comparison to work, we replace the immutable key with the one that is used for genesis
+//                         expected_genesis_immutable_key,
+//                     ),
+//                     value,
+//                 })
+//             } else {
+//                 None
+//             }
+//         })
+//         .sorted_by(ordering)
+//         .collect::<Vec<_>>();
 
-    assert_eq!(expected_init_logs, correct_init_logs);
+//     assert_eq!(expected_init_logs, correct_init_logs);
 
-    let batch_result = vm.vm.execute(VmExecutionMode::Batch);
-    assert!(
-        !batch_result.result.is_failed(),
-        "Transaction wasn't successful"
-    );
-}
+//     let batch_result = vm.vm.execute(VmExecutionMode::Batch);
+//     assert!(
+//         !batch_result.result.is_failed(),
+//         "Transaction wasn't successful"
+//     );
+// }

core/lib/multivm/src/versions/vm_latest/tests/utils.rs

@@ -75,11 +75,11 @@ pub(crate) fn read_nonce_holder_tester() -> Vec<u8> {
     read_bytecode("etc/contracts-test-data/artifacts-zk/contracts/custom-account/nonce-holder-test.sol/NonceHolderTest.json")
 }
 
-pub(crate) fn read_message_root() -> Vec<u8> {
-    read_bytecode(
-        "contracts/l1-contracts/artifacts-zk/contracts/bridgehub/MessageRoot.sol/MessageRoot.json",
-    )
-}
+// pub(crate) fn read_message_root() -> Vec<u8> {
+//     read_bytecode(
+//         "contracts/l1-contracts/artifacts-zk/contracts/bridgehub/MessageRoot.sol/MessageRoot.json",
+//     )
+// }
 
 pub(crate) fn read_error_contract() -> Vec<u8> {
     read_bytecode(

core/lib/types/src/api/mod.rs

@@ -195,28 +195,49 @@ pub struct L2ToL1LogProof {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct LeafAggProof {
+    pub leaf_chain_proof: LeafChainProof,
+    pub chain_agg_proof: ChainAggProof,
+    pub local_msg_root: H256,
+    pub sl_batch_number: U256,
+    pub sl_chain_id: U256,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct LeafChainProof {
     pub batch_leaf_proof: Vec<H256>,
     pub batch_leaf_proof_mask: U256,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ChainAggProof {
     pub chain_id_leaf_proof: Vec<H256>,
     pub chain_id_leaf_proof_mask: U256,
-    pub local_msg_root: H256,
-    pub sl_batch_number: U256,
-    pub sl_chain_id: U256,
 }
 
 impl LeafAggProof {
     pub fn encode(self) -> (u32, Vec<H256>) {
         let mut encoded_result = vec![];
 
         let LeafAggProof {
-            batch_leaf_proof,
-            batch_leaf_proof_mask,
-            chain_id_leaf_proof_mask,
+            leaf_chain_proof,
+            chain_agg_proof,
             sl_batch_number,
             sl_chain_id,
             ..
         } = self;
 
+        let LeafChainProof {
+            batch_leaf_proof,
+            batch_leaf_proof_mask,
+        } = leaf_chain_proof;
+
+        let ChainAggProof {
+            chain_id_leaf_proof: _,
+            chain_id_leaf_proof_mask,
+        } = chain_agg_proof;
+
         let batch_leaf_proof_len = batch_leaf_proof.len() as u32;
 
         encoded_result.push(u256_to_h256(batch_leaf_proof_mask));

core/lib/types/src/storage/mod.rs

@@ -153,10 +153,10 @@ fn get_system_context_init_logs(chain_id: L2ChainId) -> Vec<StorageLog> {
 /// and so for now the correctness of those values is tested in a unit tests within the multivm crate.
 pub fn get_l2_message_root_init_logs() -> Vec<StorageLog> {
     let slots_values = vec![
-        (
-            "8e94fed44239eb2314ab7a406345e6c5a8f0ccedf3b600de3d004e672c33abf4",
-            "0000000000000000000000000000000000000000000000000000000000000001",
-        ),
+        // (
+        //     "8e94fed44239eb2314ab7a406345e6c5a8f0ccedf3b600de3d004e672c33abf4",
+        //     "0000000000000000000000000000000000000000000000000000000000000001",
+        // ),
         (
             "0000000000000000000000000000000000000000000000000000000000000007",
             "0000000000000000000000000000000000000000000000000000000000000001",
@@ -199,11 +199,11 @@ pub fn get_l2_message_root_init_logs() -> Vec<StorageLog> {
 }
 
 pub fn get_system_contracts_init_logs(chain_id: L2ChainId) -> Vec<StorageLog> {
-    let system_context_init_logs = get_system_context_init_logs(chain_id);
-    let l2_message_root_init_logs = get_l2_message_root_init_logs();
+    get_system_context_init_logs(chain_id)
+    // let l2_message_root_init_logs = get_l2_message_root_init_logs();
 
-    system_context_init_logs
-        .into_iter()
-        .chain(l2_message_root_init_logs)
-        .collect()
+    // system_context_init_logs
+    // .into_iter()
+    // .chain(l2_message_root_init_logs)
+    // .collect()
 }