fix: send logs, messages, multichain_batch_roots when settling on gateway

itegulov · itegulov · commit b6501b608fec · 2026-02-27T15:58:43.000+11:00
diff --git a/lib/batch_verification/src/tests/mod.rs b/lib/batch_verification/src/tests/mod.rs
@@ -81,6 +81,9 @@ pub fn dummy_batch_metadata(batch_number: u64, from: u64, to: u64) -> BatchMetad
         execution_version: 1,
         protocol_version: ProtocolSemanticVersion::legacy_genesis_version(),
         computational_native_used: None,
+        logs: vec![],
+        messages: vec![],
+        multichain_batch_root: Default::default(),
     }
 }
 
diff --git a/lib/contract_interface/src/lib.rs b/lib/contract_interface/src/lib.rs
@@ -290,27 +290,36 @@ alloy::sol! {
             bytes calldata _commitData
         ) external;
 
-       function proofPayload(StoredBatchInfo old, StoredBatchInfo[] newInfo, uint256[] proof);
+        function proofPayload(StoredBatchInfo old, StoredBatchInfo[] newInfo, uint256[] proof);
 
-       function proveBatchesSharedBridge(
+        function proveBatchesSharedBridge(
             address _chainAddress,
             uint256 _processBatchFrom,
             uint256 _processBatchTo,
             bytes calldata _proofData
-       );
+        );
+
+        struct PriorityOpsBatchInfo {
+            bytes32[] leftPath;
+            bytes32[] rightPath;
+            bytes32[] itemHashes;
+        }
 
-       struct PriorityOpsBatchInfo {
-           bytes32[] leftPath;
-           bytes32[] rightPath;
-           bytes32[] itemHashes;
+        struct L2Log {
+           uint8 l2ShardId;
+           bool isService;
+           uint16 txNumberInBatch;
+           address sender;
+           bytes32 key;
+           bytes32 value;
        }
 
-       function executeBatchesSharedBridge(
-           address _chainAddress,
-           uint256 _processFrom,
-           uint256 _processTo,
-           bytes calldata _executeData
-       );
+        function executeBatchesSharedBridge(
+            address _chainAddress,
+            uint256 _processFrom,
+            uint256 _processTo,
+            bytes calldata _executeData
+        );
     }
 
     // taken from v29 version of `IExecutor.sol`
diff --git a/lib/contract_interface/src/models.rs b/lib/contract_interface/src/models.rs
@@ -1,5 +1,5 @@
 use crate::{IExecutor, IExecutorV29, IExecutorV30};
-use alloy::primitives::{B256, Bytes, U256, keccak256};
+use alloy::primitives::{Address, B256, Bytes, U256, keccak256};
 use alloy::sol_types::SolValue;
 use serde::{Deserialize, Serialize};
 use std::fmt;
@@ -24,6 +24,30 @@ impl From<PriorityOpsBatchInfo> for IExecutor::PriorityOpsBatchInfo {
     }
 }
 
+/// User-friendly version of [`IExecutor::L2Log`].
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct L2Log {
+    pub l2_shard_id: u8,
+    pub is_service: bool,
+    pub tx_number_in_batch: u16,
+    pub sender: Address,
+    pub key: B256,
+    pub value: B256,
+}
+
+impl From<L2Log> for IExecutor::L2Log {
+    fn from(value: L2Log) -> Self {
+        IExecutor::L2Log {
+            l2ShardId: value.l2_shard_id,
+            isService: value.is_service,
+            txNumberInBatch: value.tx_number_in_batch,
+            sender: value.sender,
+            key: value.key,
+            value: value.value,
+        }
+    }
+}
+
 /// User-friendly version of [`crate::PubdataPricingMode`] with statically known possible variants.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub enum BatchDaInputMode {
diff --git a/lib/l1_sender/src/batcher_model.rs b/lib/l1_sender/src/batcher_model.rs
@@ -1,13 +1,13 @@
 use crate::batcher_metrics::{BATCHER_METRICS, BatchExecutionStage};
-use alloy::primitives::Bytes;
+use alloy::primitives::{B256, Bytes};
 use anyhow::Context as _;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::time::SystemTime;
 use time::UtcDateTime;
 use zksync_os_batch_types::{BatchInfo, BatchSignatureSet};
-use zksync_os_contract_interface::models::StoredBatchInfo;
+use zksync_os_contract_interface::models::{L2Log, StoredBatchInfo};
 use zksync_os_observability::LatencyDistributionTracker;
 use zksync_os_types::PubdataMode;
 use zksync_os_types::{ProtocolSemanticVersion, ProvingVersion};
@@ -41,6 +41,12 @@ pub struct BatchMetadata {
     pub protocol_version: ProtocolSemanticVersion,
     #[serde(default)]
     pub computational_native_used: Option<u64>,
+    #[serde(default)]
+    pub logs: Vec<L2Log>,
+    #[serde(default)]
+    pub messages: Vec<Vec<u8>>,
+    #[serde(default)]
+    pub multichain_batch_root: B256,
 }
 
 impl BatchMetadata {
diff --git a/lib/l1_sender/src/commands/commit.rs b/lib/l1_sender/src/commands/commit.rs
@@ -80,7 +80,7 @@ impl SendToL1 for CommitCommand {
     const MINED_STAGE: BatchExecutionStage = BatchExecutionStage::CommitL1TxMined;
     const PASSTHROUGH_STAGE: BatchExecutionStage = BatchExecutionStage::CommitL1Passthrough;
 
-    fn solidity_call(&self) -> Bytes {
+    fn solidity_call(&self, _gateway: bool) -> Bytes {
         if let Some(signatures_set) = &self.signatures {
             let mut signatures = signatures_set.to_vec().clone();
             signatures.sort_by(|a, b| a.signer().cmp(b.signer()));
diff --git a/lib/l1_sender/src/commands/execute.rs b/lib/l1_sender/src/commands/execute.rs
@@ -1,7 +1,7 @@
 use crate::batcher_metrics::BatchExecutionStage;
 use crate::batcher_model::{FriProof, SignedBatchEnvelope};
 use crate::commands::SendToL1;
-use alloy::primitives::{Bytes, FixedBytes, U256};
+use alloy::primitives::{Bytes, U256};
 use alloy::sol_types::{SolCall, SolValue};
 use std::fmt::Display;
 use zksync_os_contract_interface::models::PriorityOpsBatchInfo;
@@ -33,12 +33,12 @@ impl SendToL1 for ExecuteCommand {
 
     const PASSTHROUGH_STAGE: BatchExecutionStage = BatchExecutionStage::ExecuteL1Passthrough;
 
-    fn solidity_call(&self) -> Bytes {
+    fn solidity_call(&self, gateway: bool) -> Bytes {
         IExecutor::executeBatchesSharedBridgeCall::new((
             self.batches.first().unwrap().batch.batch_info.chain_address,
             U256::from(self.batches.first().unwrap().batch_number()),
             U256::from(self.batches.last().unwrap().batch_number()),
-            self.to_calldata_suffix().into(),
+            self.to_calldata_suffix(gateway).into(),
         ))
         .abi_encode()
         .into()
@@ -76,7 +76,7 @@ impl Display for ExecuteCommand {
 }
 
 impl ExecuteCommand {
-    fn to_calldata_suffix(&self) -> Vec<u8> {
+    fn to_calldata_suffix(&self, gateway: bool) -> Vec<u8> {
         let stored_batch_infos = self
             .batches
             .iter()
@@ -102,19 +102,41 @@ impl ExecuteCommand {
         {
             29 | 30 => (stored_batch_infos, priority_ops, interop_roots).abi_encode_params(),
             31 | 32 => {
-                // For now, these are not validated, so they can be empty.
-                // IMPORTANT: the struct is not correct, it only works while the array is empty
-                let logs: Vec<u8> = Default::default();
-                let messages: Vec<Vec<u8>> = Default::default();
-                let message_roots: Vec<FixedBytes<32>> = Default::default();
-
+                let mut logs = Vec::new();
+                let mut messages = Vec::new();
+                let mut multichain_batch_roots = Vec::new();
+                if gateway {
+                    logs = self
+                        .batches
+                        .iter()
+                        .map(|batch| {
+                            batch
+                                .batch
+                                .logs
+                                .iter()
+                                .cloned()
+                                .map(IExecutor::L2Log::from)
+                                .collect::<Vec<_>>()
+                        })
+                        .collect::<Vec<_>>();
+                    messages = self
+                        .batches
+                        .iter()
+                        .map(|batch| batch.batch.messages.clone())
+                        .collect::<Vec<_>>();
+                    multichain_batch_roots = self
+                        .batches
+                        .iter()
+                        .map(|batch| batch.batch.multichain_batch_root)
+                        .collect::<Vec<_>>();
+                }
                 (
                     stored_batch_infos,
                     priority_ops,
                     interop_roots,
                     logs,
                     messages,
-                    message_roots,
+                    multichain_batch_roots,
                 )
                     .abi_encode_params()
             }
diff --git a/lib/l1_sender/src/commands/mod.rs b/lib/l1_sender/src/commands/mod.rs
@@ -44,7 +44,7 @@ pub trait SendToL1:
     const MINED_STAGE: BatchExecutionStage;
     const PASSTHROUGH_STAGE: BatchExecutionStage;
     /// We use `Bytes` instead of `SolCall`, because SolCall is a trait that cannot be dyn
-    fn solidity_call(&self) -> Bytes;
+    fn solidity_call(&self, gateway: bool) -> Bytes;
 
     fn blob_sidecar(&self) -> Option<BlobTransactionSidecar> {
         None
diff --git a/lib/l1_sender/src/commands/prove.rs b/lib/l1_sender/src/commands/prove.rs
@@ -31,7 +31,7 @@ impl SendToL1 for ProofCommand {
     const MINED_STAGE: BatchExecutionStage = BatchExecutionStage::ProveL1TxMined;
     const PASSTHROUGH_STAGE: BatchExecutionStage = BatchExecutionStage::ProveL1Passthrough;
 
-    fn solidity_call(&self) -> Bytes {
+    fn solidity_call(&self, _gateway: bool) -> Bytes {
         proveBatchesSharedBridgeCall::new((
             self.batches.first().unwrap().batch.batch_info.chain_address,
             U256::from(self.batches.first().unwrap().batch_number()),
diff --git a/lib/l1_sender/src/lib.rs b/lib/l1_sender/src/lib.rs
@@ -72,6 +72,7 @@ pub async fn run_l1_sender<Input: SendToL1>(
         impl Provider<Ethereum>,
     >,
     config: L1SenderConfig<Input>,
+    gateway: bool,
 ) -> anyhow::Result<()> {
     let latency_tracker =
         ComponentStateReporter::global().handle_for(Input::NAME, L1SenderState::WaitingRecv);
@@ -135,7 +136,7 @@ pub async fn run_l1_sender<Input: SendToL1>(
                     )
                     .await?
                     .with_to(to_address)
-                    .with_input(cmd.solidity_call());
+                    .with_input(cmd.solidity_call(gateway));
 
                     if let Some(blob_sidecar) = cmd.blob_sidecar() {
                         let fee_per_blob_gas = provider.get_blob_base_fee().await?;
diff --git a/lib/l1_sender/src/pipeline_component.rs b/lib/l1_sender/src/pipeline_component.rs
@@ -16,6 +16,7 @@ pub struct L1Sender<F: TxFiller<Ethereum>, P: Provider<Ethereum>, C> {
     pub provider: FillProvider<F, P>,
     pub config: L1SenderConfig<C>,
     pub to_address: Address,
+    pub gateway: bool,
 }
 
 #[async_trait]
@@ -36,6 +37,14 @@ where
         input: PeekableReceiver<Self::Input>,
         output: mpsc::Sender<Self::Output>,
     ) -> anyhow::Result<()> {
-        run_l1_sender(input, output, self.to_address, self.provider, self.config).await
+        run_l1_sender(
+            input,
+            output,
+            self.to_address,
+            self.provider,
+            self.config,
+            self.gateway,
+        )
+        .await
     }
 }
diff --git a/node/bin/src/batcher/batch_builder.rs b/node/bin/src/batcher/batch_builder.rs
@@ -1,6 +1,6 @@
 use alloy::primitives::Address;
 use zksync_os_batch_types::BatchInfo;
-use zksync_os_contract_interface::models::StoredBatchInfo;
+use zksync_os_contract_interface::models::{L2Log, StoredBatchInfo};
 use zksync_os_interface::types::BlockOutput;
 use zksync_os_l1_sender::batcher_metrics::BatchExecutionStage;
 use zksync_os_l1_sender::batcher_model::{
@@ -32,7 +32,7 @@ pub(crate) fn seal_batch<ReadState: ReadStateHistory>(
     let protocol_version = blocks.first().unwrap().1.protocol_version.clone();
 
     let state_view = read_state.state_view_at(block_number_to)?;
-    let aggregated_root = read_aggregated_root(state_view);
+    let multichain_batch_root = read_aggregated_root(state_view);
     let batch_info = BatchInfo::new(
         blocks
             .iter()
@@ -50,10 +50,30 @@ pub(crate) fn seal_batch<ReadState: ReadStateHistory>(
         batch_number,
         pubdata_mode,
         sl_chain_id,
-        aggregated_root,
+        multichain_batch_root,
         &protocol_version,
     );
 
+    let mut logs = Vec::new();
+    let mut messages = Vec::new();
+    for block in blocks {
+        for output in block.0.tx_results.iter().flatten() {
+            for l2_to_l1_log in &output.l2_to_l1_logs {
+                logs.push(L2Log {
+                    l2_shard_id: l2_to_l1_log.log.l2_shard_id,
+                    is_service: l2_to_l1_log.log.is_service,
+                    tx_number_in_batch: l2_to_l1_log.log.tx_number_in_block,
+                    sender: l2_to_l1_log.log.sender,
+                    key: l2_to_l1_log.log.key,
+                    value: l2_to_l1_log.log.value,
+                });
+                if let Some(preimage) = l2_to_l1_log.preimage.as_ref() {
+                    messages.push(preimage.clone());
+                }
+            }
+        }
+    }
+
     use zk_os_forward_system::run::generate_batch_proof_input;
 
     let proving_version =
@@ -115,6 +135,9 @@ pub(crate) fn seal_batch<ReadState: ReadStateHistory>(
                     .map(|(block_output, _, _, _)| block_output.computational_native_used)
                     .sum(),
             ),
+            logs,
+            messages,
+            multichain_batch_root,
         },
         batch_prover_input,
     )
diff --git a/node/bin/src/lib.rs b/node/bin/src/lib.rs
@@ -970,6 +970,7 @@ async fn run_main_node_pipeline(
             provider: sl_provider.clone(),
             config: config.l1_sender_config.clone().into(),
             to_address: node_state_on_startup.l1_state.validator_timelock_sl,
+            gateway: config.general_config.gateway_rpc_url.is_some(),
         })
         .pipe(snark_proving_step)
         .pipe(GaplessL1ProofSender::new(
@@ -979,6 +980,7 @@ async fn run_main_node_pipeline(
             provider: sl_provider.clone(),
             config: config.l1_sender_config.clone().into(),
             to_address: node_state_on_startup.l1_state.validator_timelock_sl,
+            gateway: config.general_config.gateway_rpc_url.is_some(),
         })
         .pipe(
             PriorityTreePipelineStep::new(
@@ -994,6 +996,7 @@ async fn run_main_node_pipeline(
             provider: sl_provider,
             config: config.l1_sender_config.clone().into(),
             to_address: node_state_on_startup.l1_state.validator_timelock_sl,
+            gateway: config.general_config.gateway_rpc_url.is_some(),
         })
         .pipe(BatchSink::new(internal_config_manager))
         .spawn(tasks);
diff --git a/node/bin/src/prover_api/prover_job_map/map.rs b/node/bin/src/prover_api/prover_job_map/map.rs
@@ -514,6 +514,9 @@ mod tests {
             execution_version: 1,
             protocol_version: ProtocolSemanticVersion::legacy_genesis_version(),
             computational_native_used: None,
+            logs: vec![],
+            messages: vec![],
+            multichain_batch_root: Default::default(),
         };
 
         BatchForSigning::new(batch, vec![1, 2, 3])

Original file line number	Diff line number	Diff line change
`@@ -81,6 +81,9 @@ pub fn dummy_batch_metadata(batch_number: u64, from: u64, to: u64) -> BatchMetad`
`81`	`81`	`execution_version: 1,`
`82`	`82`	`protocol_version: ProtocolSemanticVersion::legacy_genesis_version(),`
`83`	`83`	`computational_native_used: None,`
	`84`	`+ logs: vec![],`
	`85`	`+ messages: vec![],`
	`86`	`+ multichain_batch_root: Default::default(),`
`84`	`87`	`}`
`85`	`88`	`}`
`86`	`89`