fix execute encoding for transactions

core/lib/l1_contract_interface/src/i_executor/methods/execute_batches.rs

@@ -1,6 +1,7 @@
 use zksync_types::{
     commitment::{L1BatchWithMetadata, PriorityOpsMerkleProof},
     ethabi::{encode, Token},
+    ProtocolVersionId,
 };
 
 use crate::{
@@ -15,6 +16,49 @@ pub struct ExecuteBatches {
     pub priority_ops_proofs: Vec<PriorityOpsMerkleProof>,
 }
 
+impl ExecuteBatches {
+    // The encodings of `ExecuteBatches` operations are different depending on the protocol version
+    // of the underlying chain.
+    // However, we can send batches with older protocol versions just by changing the encoding.
+    // This makes the migration simpler.
+    pub fn encode_for_eth_tx(self, chain_protocol_version: ProtocolVersionId) -> Vec<Token> {
+        let internal_protocol_version = self.l1_batches[0].header.protocol_version.unwrap();
+
+        if internal_protocol_version.is_pre_gateway() && chain_protocol_version.is_pre_gateway() {
+            vec![Token::Array(
+                self.l1_batches
+                    .iter()
+                    .map(|batch| StoredBatchInfo::from(batch).into_token())
+                    .collect(),
+            )]
+        } else {
+            let encoded_data = encode(&[
+                Token::Array(
+                    self.l1_batches
+                        .iter()
+                        .map(|batch| StoredBatchInfo::from(batch).into_token())
+                        .collect(),
+                ),
+                Token::Array(
+                    self.priority_ops_proofs
+                        .iter()
+                        .map(|proof| proof.into_token())
+                        .collect(),
+                ),
+            ]);
+            let execute_data = [[SUPPORTED_ENCODING_VERSION].to_vec(), encoded_data]
+                .concat()
+                .to_vec();
+
+            vec![
+                Token::Uint(self.l1_batches[0].header.number.0.into()),
+                Token::Uint(self.l1_batches.last().unwrap().header.number.0.into()),
+                Token::Bytes(execute_data),
+            ]
+        }
+    }
+}
+
 impl Tokenize for &ExecuteBatches {
     fn into_tokens(self) -> Vec<Token> {
         let protocol_version = self.l1_batches[0].header.protocol_version.unwrap();

core/node/eth_sender/src/eth_tx_aggregator.rs

@@ -594,6 +594,7 @@ impl EthTxAggregator {
                         stm_protocol_version_id,
                         stm_validator_timelock_address,
                     ),
+                    chain_protocol_version_id,
                     is_gateway,
                 )
                 .await?;
@@ -642,7 +643,11 @@ impl EthTxAggregator {
             .await;
     }
 
-    fn encode_aggregated_op(&self, op: &AggregatedOperation) -> TxData {
+    fn encode_aggregated_op(
+        &self,
+        op: &AggregatedOperation,
+        chain_protocol_version_id: ProtocolVersionId,
+    ) -> TxData {
         let mut args = vec![Token::Uint(self.rollup_chain_id.as_u64().into())];
         let is_op_pre_gateway = op.protocol_version().is_pre_gateway();
 
@@ -686,8 +691,9 @@ impl EthTxAggregator {
                 (calldata, None)
             }
             AggregatedOperation::Execute(op) => {
-                args.extend(op.into_tokens());
-                let encoding_fn = if is_op_pre_gateway {
+                args.extend(op.encode_for_eth_tx(chain_protocol_version_id));
+                let encoding_fn = if is_op_pre_gateway && chain_protocol_version_id.is_pre_gateway()
+                {
                     &self.functions.post_shared_bridge_execute
                 } else {
                     &self.functions.post_gateway_execute
@@ -743,6 +749,7 @@ impl EthTxAggregator {
         storage: &mut Connection<'_, Core>,
         aggregated_op: &AggregatedOperation,
         timelock_contract_address: Address,
+        chain_protocol_version_id: ProtocolVersionId,
         is_gateway: bool,
     ) -> Result<EthTx, EthSenderError> {
         let mut transaction = storage.start_transaction().await.unwrap();
@@ -755,7 +762,8 @@ impl EthTxAggregator {
             (_, _) => None,
         };
         let nonce = self.get_next_nonce(&mut transaction, sender_addr).await?;
-        let encoded_aggregated_op = self.encode_aggregated_op(aggregated_op);
+        let encoded_aggregated_op =
+            self.encode_aggregated_op(aggregated_op, chain_protocol_version_id);
         let l1_batch_number_range = aggregated_op.l1_batch_range();
 
         let eth_tx_predicted_gas = match (op_type, is_gateway, self.aggregator.mode()) {

core/node/eth_sender/src/tester.rs

@@ -13,7 +13,7 @@ use zksync_object_store::MockObjectStore;
 use zksync_types::{
     aggregated_operations::AggregatedActionType, block::L1BatchHeader,
     commitment::L1BatchCommitmentMode, eth_sender::EthTx, pubdata_da::PubdataSendingMode,
-    settlement::SettlementMode, Address, L1BatchNumber, ProtocolVersion, H256,
+    settlement::SettlementMode, Address, L1BatchNumber, ProtocolVersion, ProtocolVersionId, H256,
 };
 
 use crate::{
@@ -525,6 +525,7 @@ impl EthSenderTester {
                 &mut self.conn.connection().await.unwrap(),
                 &aggregated_operation,
                 Address::random(),
+                ProtocolVersionId::latest(),
                 self.is_l2,
             )
             .await

core/node/eth_sender/src/tests.rs

@@ -236,6 +236,7 @@ async fn resend_each_block(commitment_mode: L1BatchCommitmentMode) -> anyhow::Re
             &mut tester.conn.connection().await.unwrap(),
             &get_dummy_operation(0),
             Address::random(),
+            ProtocolVersionId::latest(),
             false,
         )
         .await?;