feat(gateway): refine l2 l1 logs proofs

core/bin/zksync_server/src/node_builder.rs

@@ -288,6 +288,7 @@ impl MainNodeBuilder {
                 .as_ref()
                 .and_then(|x| Some(x.gas_adjuster?.settlement_mode))
                 .unwrap_or(SettlementMode::SettlesToL1),
+            self.genesis_config.l2_chain_id,
         ));
         Ok(self)
     }

core/lib/constants/src/lib.rs

@@ -3,6 +3,7 @@ pub mod contracts;
 pub mod crypto;
 pub mod ethereum;
 pub mod fees;
+pub mod message_root;
 pub mod system_context;
 pub mod system_logs;
 pub mod trusted_slots;

core/lib/constants/src/message_root.rs

@@ -0,0 +1,14 @@
+/// Position of `chainCount` in `MessageRoot`'s storage layout.
+pub const CHAIN_COUNT_KEY: usize = 0;
+
+/// Position of `chainIndexToId` in `MessageRoot`'s storage layout.
+pub const CHAIN_INDEX_TO_ID_KEY: usize = 2;
+
+/// Position of `FullTree::_height` in `MessageRoot`'s storage layout.
+pub const AGG_TREE_HEIGHT_KEY: usize = 3;
+
+/// Position of `FullTree::nodes` in `MessageRoot`'s storage layout.
+pub const AGG_TREE_NODES_KEY: usize = 5;
+
+/// Position of `chainTree` in `MessageRoot`'s storage layout.
+pub const CHAIN_TREE_KEY: usize = 7;

core/lib/dal/migrations/20241011081834_batch_chain_merkle_path.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE l1_batches
+    DROP COLUMN batch_chain_merkle_path BYTEA;

core/lib/dal/migrations/20241011081834_batch_chain_merkle_path.up.sql

@@ -0,0 +1,5 @@
+ALTER TABLE l1_batches
+    ADD COLUMN batch_chain_merkle_path BYTEA;
+
+-- postgres doesn't allow dropping enum variant, so nothing is done in down.sql
+ALTER TYPE event_type ADD VALUE 'ChainBatchRoot';

core/lib/dal/src/blocks_dal.rs

@@ -20,9 +20,9 @@ use zksync_types::{
         StorageOracleInfo,
     },
     commitment::{L1BatchCommitmentArtifacts, L1BatchWithMetadata},
-    l2_to_l1_log::UserL2ToL1Log,
+    l2_to_l1_log::{BatchAndChainMerklePath, UserL2ToL1Log},
     writes::TreeWrite,
-    Address, Bloom, L1BatchNumber, L2BlockNumber, ProtocolVersionId, H256, U256,
+    Address, Bloom, L1BatchNumber, L2BlockNumber, ProtocolVersionId, SLChainId, H256, U256,
 };
 use zksync_vm_interface::CircuitStatistic;
 
@@ -1849,6 +1849,150 @@ impl BlocksDal<'_, '_> {
         Ok(Some((H256::from_slice(&hash), row.timestamp as u64)))
     }
 
+    pub async fn get_l1_batch_local_root(
+        &mut self,
+        number: L1BatchNumber,
+    ) -> DalResult<Option<H256>> {
+        let Some(row) = sqlx::query!(
+            r#"
+            SELECT
+                local_root
+            FROM
+                l1_batches
+            WHERE
+                number = $1
+            "#,
+            i64::from(number.0)
+        )
+        .instrument("get_l1_batch_local_root")
+        .with_arg("number", &number)
+        .fetch_optional(self.storage)
+        .await?
+        else {
+            return Ok(None);
+        };
+        let Some(local_root) = row.local_root else {
+            return Ok(None);
+        };
+        Ok(Some(H256::from_slice(&local_root)))
+    }
+
+    pub async fn get_l1_batch_l2_l1_merkle_root(
+        &mut self,
+        number: L1BatchNumber,
+    ) -> DalResult<Option<H256>> {
+        let Some(row) = sqlx::query!(
+            r#"
+            SELECT
+                l2_l1_merkle_root
+            FROM
+                l1_batches
+            WHERE
+                number = $1
+            "#,
+            i64::from(number.0)
+        )
+        .instrument("get_l1_batch_l2_l1_merkle_root")
+        .with_arg("number", &number)
+        .fetch_optional(self.storage)
+        .await?
+        else {
+            return Ok(None);
+        };
+        let Some(l2_l1_merkle_root) = row.l2_l1_merkle_root else {
+            return Ok(None);
+        };
+        Ok(Some(H256::from_slice(&l2_l1_merkle_root)))
+    }
+
+    pub async fn get_l1_batch_chain_merkle_path(
+        &mut self,
+        number: L1BatchNumber,
+    ) -> DalResult<Option<BatchAndChainMerklePath>> {
+        let Some(row) = sqlx::query!(
+            r#"
+            SELECT
+                batch_chain_merkle_path
+            FROM
+                l1_batches
+            WHERE
+                number = $1
+            "#,
+            i64::from(number.0)
+        )
+        .instrument("get_l1_batch_chain_merkle_path")
+        .with_arg("number", &number)
+        .fetch_optional(self.storage)
+        .await?
+        else {
+            return Ok(None);
+        };
+        let Some(batch_chain_merkle_path) = row.batch_chain_merkle_path else {
+            return Ok(None);
+        };
+        Ok(Some(
+            bincode::deserialize(&batch_chain_merkle_path).unwrap(),
+        ))
+    }
+
+    pub async fn get_executed_batch_roots_on_sl(
+        &mut self,
+        sl_chain_id: SLChainId,
+    ) -> DalResult<Vec<(L1BatchNumber, H256)>> {
+        let result = sqlx::query!(
+            r#"
+            SELECT
+                number, l2_l1_merkle_root
+            FROM
+                l1_batches
+            JOIN eth_txs ON eth_txs.id = l1_batches.eth_execute_tx_id
+            WHERE
+                batch_chain_merkle_path IS NOT NULL
+                AND chain_id = $1
+            ORDER BY number
+            "#,
+            sl_chain_id.0 as i64
+        )
+        .instrument("get_executed_batch_roots_on_sl")
+        .with_arg("sl_chain_id", &sl_chain_id)
+        .fetch_all(self.storage)
+        .await?
+        .into_iter()
+        .map(|row| {
+            let number = L1BatchNumber(row.number as u32);
+            let root = H256::from_slice(&row.l2_l1_merkle_root.unwrap());
+            (number, root)
+        })
+        .collect();
+        Ok(result)
+    }
+
+    pub async fn set_batch_chain_merkle_path(
+        &mut self,
+        number: L1BatchNumber,
+        proof: BatchAndChainMerklePath,
+    ) -> DalResult<()> {
+        let proof_bin = bincode::serialize(&proof).unwrap();
+        sqlx::query!(
+            r#"
+            UPDATE
+            l1_batches
+            SET
+                batch_chain_merkle_path = $2
+            WHERE
+                number = $1
+            "#,
+            i64::from(number.0),
+            &proof_bin
+        )
+        .instrument("set_batch_chain_merkle_path")
+        .with_arg("number", &number)
+        .execute(self.storage)
+        .await?;
+
+        Ok(())
+    }
+
     pub async fn get_l1_batch_metadata(
         &mut self,
         number: L1BatchNumber,

core/lib/dal/src/eth_watcher_dal.rs

@@ -12,6 +12,7 @@ pub struct EthWatcherDal<'a, 'c> {
 pub enum EventType {
     ProtocolUpgrades,
     PriorityTransactions,
+    ChainBatchRoot,
 }
 
 impl EthWatcherDal<'_, '_> {

core/lib/eth_client/src/clients/http/mod.rs

@@ -28,11 +28,13 @@ enum Method {
     TxReceipt,
     EthBalance,
     Logs,
+    LogsExtended,
     Block,
     #[metrics(name = "sign_prepared_tx_for_addr")]
     SignPreparedTx,
     Allowance,
     L2FeeHistory,
+    GetChainLogProof,
 }
 
 #[derive(Debug, Metrics)]