Merge pull request #4544 from matter-labs/sb/fix-medium-interop-support

kelemeno · web-flow · commit 1e83af81f83c · 2025-11-13T14:42:53.000+01:00
fix(v30): various interop fixes
diff --git a/contracts b/contracts
@@ -1 +1 @@
-Subproject commit 3fcd17de091693718e4b938b9756325b7a78c156
+Subproject commit f93938f6a94c02608765b656b282717f39465969
diff --git a/core/Cargo.lock b/core/Cargo.lock
diff --git a/core/lib/constants/src/contracts.rs b/core/lib/constants/src/contracts.rs
@@ -234,7 +234,7 @@ pub const GW_ASSET_TRACKER_ADDRESS: Address = H160([
 
 pub const DUMMY_ADDRESS_1: Address = H160([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
-    0x01, 0x01, 0x00, 0x0b,
+    0x01, 0x01, 0x00, 0x0a,
 ]);
 
 pub const DUMMY_ADDRESS_2: Address = H160([
diff --git a/core/lib/dal/src/sync_dal.rs b/core/lib/dal/src/sync_dal.rs
@@ -19,6 +19,7 @@ impl SyncDal<'_, '_> {
         &mut self,
         numbers: std::ops::Range<L2BlockNumber>,
     ) -> DalResult<Vec<SyncBlock>> {
+        // FIXME: for some reason query below does not compile
         // Check if range is non-empty, because BETWEEN in SQL in `unordered`.
         if numbers.is_empty() {
             return Ok(vec![]);
diff --git a/core/lib/types/src/system_contracts.rs b/core/lib/types/src/system_contracts.rs
@@ -4,7 +4,7 @@ use zksync_basic_types::{AccountTreeId, Address, U256};
 use zksync_contracts::{read_sys_contract_bytecode, ContractLanguage, SystemContractsRepo};
 use zksync_system_constants::{
     BOOTLOADER_UTILITIES_ADDRESS, CODE_ORACLE_ADDRESS, COMPRESSOR_ADDRESS, CREATE2_FACTORY_ADDRESS,
-    DUMMY_ADDRESS_2, DUMMY_ADDRESS_3, DUMMY_ADDRESS_4, EVENT_WRITER_ADDRESS,
+    DUMMY_ADDRESS_1, DUMMY_ADDRESS_2, DUMMY_ADDRESS_3, DUMMY_ADDRESS_4, EVENT_WRITER_ADDRESS,
     EVM_GAS_MANAGER_ADDRESS, EVM_HASHES_STORAGE_ADDRESS, EVM_PREDEPLOYS_MANAGER_ADDRESS,
     GW_ASSET_TRACKER_ADDRESS, IDENTITY_ADDRESS, L2_ASSET_ROUTER_ADDRESS, L2_ASSET_TRACKER_ADDRESS,
     L2_BRIDGEHUB_ADDRESS, L2_CHAIN_ASSET_HANDLER_ADDRESS, L2_GENESIS_UPGRADE_ADDRESS,
@@ -32,7 +32,7 @@ use crate::{
 pub const TX_NONCE_INCREMENT: U256 = U256([1, 0, 0, 0]); // 1
 pub const DEPLOYMENT_NONCE_INCREMENT: U256 = U256([0, 0, 1, 0]); // 2^128
 
-static SYSTEM_CONTRACT_LIST: [(&str, &str, Address, ContractLanguage); 48] = [
+static SYSTEM_CONTRACT_LIST: [(&str, &str, Address, ContractLanguage); 49] = [
     (
         "",
         "AccountCodeStorage",
@@ -295,7 +295,13 @@ static SYSTEM_CONTRACT_LIST: [(&str, &str, Address, ContractLanguage); 48] = [
         GW_ASSET_TRACKER_ADDRESS,
         ContractLanguage::Sol,
     ),
-    // FIXME: I DUMMY_ADDRESS_1 is missing
+    // todo FIXME, deploy normally instead using DUMMY_ADDRESS and deploying on genesis
+    (
+        "../../l1-contracts/zkout/",
+        "TransparentUpgradeableProxy",
+        DUMMY_ADDRESS_1,
+        ContractLanguage::Sol,
+    ),
     (
         "../../l1-contracts/zkout/",
         "BridgedStandardERC20",
diff --git a/core/lib/vm_executor/Cargo.toml b/core/lib/vm_executor/Cargo.toml
@@ -24,6 +24,8 @@ tokio.workspace = true
 anyhow.workspace = true
 tracing.workspace = true
 vise.workspace = true
+serde_json.workspace = true
+serde.workspace = true
 
 [dev-dependencies]
 assert_matches.workspace = true
diff --git a/core/lib/vm_executor/src/batch/factory.rs b/core/lib/vm_executor/src/batch/factory.rs
@@ -1,4 +1,4 @@
-use std::{fmt, marker::PhantomData, rc::Rc, sync::Arc, time::Duration};
+use std::{fmt, io::Write, marker::PhantomData, rc::Rc, sync::Arc, time::Duration};
 
 use anyhow::Context as _;
 use once_cell::sync::OnceCell;
@@ -249,7 +249,7 @@ impl<S: ReadStorage, Tr: BatchTracer> BatchVm<S, Tr> {
         with_compression: bool,
     ) -> BatchTransactionExecutionResult {
         let legacy_tracer_result = Arc::new(OnceCell::default());
-        let legacy_tracer = if Tr::TRACE_CALLS {
+        let legacy_tracer = if true {
             vec![CallTracer::new(legacy_tracer_result.clone()).into_tracer_pointer()]
         } else {
             vec![]
@@ -296,6 +296,13 @@ impl<S: ReadStorage, Tr: BatchTracer> BatchVm<S, Tr> {
             }
         };
 
+        // Save the formatted call_traces to a file
+        if let Ok(mut file) = std::fs::File::create("call_traces.json") {
+            if let Ok(json) = serde_json::to_string(&call_traces) {
+                let _ = writeln!(file, "{}", json);
+            }
+        }
+
         BatchTransactionExecutionResult {
             tx_result: Box::new(tx_result),
             compression_result: compressed_bytecodes,
diff --git a/core/node/eth_sender/src/publish_criterion.rs b/core/node/eth_sender/src/publish_criterion.rs
@@ -329,7 +329,7 @@ impl GasConsts {
 
     /// Additional gas cost of processing `Commit` operation per batch.
     /// It's applicable if SL is Gateway.
-    const GATEWAY_BATCH_COMMIT_BASE_COST: u64 = 200_000;
+    const GATEWAY_BATCH_COMMIT_BASE_COST: u64 = 2_000_000;
 
     /// All gas cost of processing `PROVE` operation per batch.
     /// It's applicable if SL is GATEWAY.
@@ -342,7 +342,9 @@ impl GasConsts {
 
     /// Base gas cost of processing `EXECUTION` operation per batch.
     /// It's applicable if SL is GATEWAY.
-    const GATEWAY_BATCH_EXECUTION_COST: u64 = 100_000;
+    /// FIXME: needs to be calculated properly since it will now include
+    /// working through all interop transactions.
+    const GATEWAY_BATCH_EXECUTION_COST: u64 = 2_000_000;
     /// Gas cost of processing `l1_operation` in batch.
     /// It's applicable if SL is GATEWAY.
     const GATEWAY_L1_OPERATION_COST: u64 = 4_000;
@@ -353,7 +355,7 @@ impl GasConsts {
 
     /// Additional gas cost of processing `Execute` operation per batch.
     /// It's applicable iff SL is Ethereum.
-    const L1_BATCH_EXECUTE_BASE_COST: u64 = 50_000;
+    const L1_BATCH_EXECUTE_BASE_COST: u64 = 100_000;
 
     /// Additional gas cost of processing `Execute` operation per L1->L2 tx.
     /// It's applicable iff SL is Ethereum.
diff --git a/core/tests/ts-integration/src/constants.ts b/core/tests/ts-integration/src/constants.ts
@@ -14,9 +14,9 @@ export const L2_MESSAGE_ROOT_ADDRESS = '0x00000000000000000000000000000000000100
 export const L2_INTEROP_ROOT_STORAGE_ADDRESS = '0x0000000000000000000000000000000000010008';
 export const L2_MESSAGE_VERIFICATION_ADDRESS = '0x0000000000000000000000000000000000010009';
 export const L2_CHAIN_ASSET_HANDLER_ADDRESS = '0x000000000000000000000000000000000001000A';
-export const L2_INTEROP_CENTER_ADDRESS = '0x000000000000000000000000000000000001000B';
-export const L2_INTEROP_HANDLER_ADDRESS = '0x000000000000000000000000000000000001000C';
-export const L2_ASSET_TRACKER_ADDRESS = '0x000000000000000000000000000000000001000D';
+export const L2_INTEROP_CENTER_ADDRESS = '0x000000000000000000000000000000000001000C';
+export const L2_INTEROP_HANDLER_ADDRESS = '0x000000000000000000000000000000000001000D';
+export const L2_ASSET_TRACKER_ADDRESS = '0x000000000000000000000000000000000001000E';
 
 // System contract addresses
 export const SYSTEM_CONTEXT_ADDRESS = '0x000000000000000000000000000000000000800b';
diff --git a/core/tests/ts-integration/src/helpers.ts b/core/tests/ts-integration/src/helpers.ts
@@ -6,6 +6,8 @@ import { ZkSyncArtifact } from '@matterlabs/hardhat-zksync-solc/dist/src/types';
 import * as path from 'path';
 import { loadConfig } from 'utils/src/file-configs';
 
+import { log } from 'console';
+
 // import { L2_BRIDGEHUB_ADDRESS } from '../src/constants';
 
 /**
@@ -175,13 +177,15 @@ export async function waitForBlockToBeFinalizedOnL1(wallet: zksync.Wallet, block
 }
 
 export async function waitForL2ToL1LogProof(wallet: zksync.Wallet, blockNumber: number, txHash: string) {
+    log('waiting for block to be finalized');
     // First, we wait for block to be finalized.
     await waitUntilBlockFinalized(wallet, blockNumber);
 
+    log('waiting for log proof');
     // Second, we wait for the log proof.
     let i = 0;
     while ((await wallet.provider.getLogProof(txHash)) == null) {
-        console.log('Waiting for log proof...', i);
+        log(`Waiting for log proof... ${i}`);
         await zksync.utils.sleep(wallet.provider.pollingInterval);
         i++;
     }
diff --git a/core/tests/ts-integration/src/modifiers/balance-checker.ts b/core/tests/ts-integration/src/modifiers/balance-checker.ts
@@ -11,7 +11,7 @@ import { getL2bUrl } from '../helpers';
 import { IERC20__factory as IERC20Factory } from 'zksync-ethers/build/typechain';
 import {
     ArtifactL2AssetTracker,
-    ArtifactBridgeHub,
+    ArtifactL1BridgeHub,
     ArtifactL1AssetRouter,
     ArtifactNativeTokenVault,
     L2_ASSET_TRACKER_ADDRESS
@@ -374,7 +374,7 @@ async function getChainBalance(l1: boolean, wallet: zksync.Wallet, token: string
 async function isMinterChain(l1: boolean, wallet: zksync.Wallet, token: string): Promise<boolean> {
     const bridgehub = new zksync.Contract(
         await (await wallet.getBridgehubContract()).getAddress(),
-        ArtifactBridgeHub.abi,
+        ArtifactL1BridgeHub.abi,
         wallet.providerL1!
     );
     const assetRouter = new zksync.Contract(
diff --git a/core/tests/ts-integration/tests/ether.test.ts b/core/tests/ts-integration/tests/ether.test.ts
@@ -14,6 +14,7 @@ import * as zksync from 'zksync-ethers';
 import { scaledGasPrice, waitForL2ToL1LogProof } from '../src/helpers';
 import { ethers } from 'ethers';
 import { RetryableWallet } from '../src/retry-provider';
+import { log } from 'console';
 
 describe('ETH token checks', () => {
     let testMaster: TestMaster;
@@ -250,21 +251,26 @@ describe('ETH token checks', () => {
         if (testMaster.isFastMode()) {
             return;
         }
+        log('Starting withdrawal test');
         const amount = 1n;
 
         const l2ethBalanceChange = isETHBasedChain
             ? await shouldChangeETHBalances([{ wallet: alice, change: -amount }])
             : await shouldChangeTokenBalances(l2EthTokenAddressNonBase, [{ wallet: alice, change: -amount }]);
+        log('Sending...');
 
         const withdrawalPromise = alice.withdraw({
             token: isETHBasedChain ? zksync.utils.ETH_ADDRESS : l2EthTokenAddressNonBase,
             amount
         });
         await expect(withdrawalPromise).toBeAccepted([l2ethBalanceChange]);
         const withdrawalTx = await withdrawalPromise;
+        log('awaited...');
         const l2TxReceipt = await alice.provider.getTransactionReceipt(withdrawalTx.hash);
+        log('Waiting for proof...');
         await waitForL2ToL1LogProof(alice, l2TxReceipt!.blockNumber, withdrawalTx.hash);
 
+        log('Finalizing...');
         // TODO (SMA-1374): Enable L1 ETH checks as soon as they're supported.
         await expect(alice.finalizeWithdrawal(withdrawalTx.hash)).toBeAccepted();
         const tx = await alice.provider.getTransactionReceipt(withdrawalTx.hash);
diff --git a/core/tests/ts-integration/tests/interop.test.ts b/core/tests/ts-integration/tests/interop.test.ts
@@ -4,6 +4,8 @@
 
 import { TestMaster } from '../src';
 import { Token } from '../src/types';
+import * as utils from 'utils';
+import { loadConfig, shouldLoadConfigFromFile } from 'utils/build/file-configs';
 
 import * as zksync from 'zksync-ethers';
 import * as ethers from 'ethers';
@@ -13,6 +15,8 @@ import { RetryableWallet } from '../src/retry-provider';
 
 import { scaledGasPrice, deployContract, waitUntilBlockFinalized } from '../src/helpers';
 
+const fileConfig = shouldLoadConfigFromFile();
+
 /**
  * Formats an Ethereum address as ERC-7930 InteroperableAddress bytes
  * Format: version (2 bytes) + chain type (2 bytes) + chain ref len (1 byte) + chain ref + addr len (1 byte) + address
@@ -343,6 +347,10 @@ describe('Interop behavior checks', () => {
         tokenA.assetId = await interop1NativeTokenVault.assetId(tokenA.l2Address);
         tokenA.l2AddressSecondChain = await interop2NativeTokenVault.tokenAddress(tokenA.assetId);
         interop1TokenA = new zksync.Contract(tokenA.l2Address, ArtifactMintableERC20.abi, interop1Wallet);
+
+        await utils.spawn(
+            `zkstack chain gateway migrate-token-balances --to-gateway true  --gateway-chain-name gateway --chain ${fileConfig.chain}`
+        );
     });
 
     test('Can perform cross chain transfer', async () => {
diff --git a/core/tests/ts-integration/tests/l2-erc20.test.ts b/core/tests/ts-integration/tests/l2-erc20.test.ts
@@ -11,7 +11,50 @@ import * as ethers from 'ethers';
 import { Provider, Wallet } from 'ethers';
 import { scaledGasPrice, deployContract, readContract, waitForL2ToL1LogProof } from '../src/helpers';
 import { encodeNTVAssetId } from 'zksync-ethers/build/utils';
-import { ARTIFACTS_PATH } from '../src/constants';
+import { ARTIFACTS_PATH, L2_ASSET_TRACKER_ADDRESS } from '../src/constants';
+import { sleep } from 'utils/src';
+
+async function migrateTokenBalanceFromL1ToGateway(
+    alice: zksync.Wallet,
+    assetId: string,
+    l1NativeTokenVault: ethers.Contract
+) {
+    const l2AssetTracker = new zksync.Contract(
+        L2_ASSET_TRACKER_ADDRESS,
+        (await readContract(`${ARTIFACTS_PATH}`, 'L2AssetTracker')).abi,
+        alice
+    );
+    const l1AssetTracker = new ethers.Contract(
+        await l1NativeTokenVault.l1AssetTracker(),
+        (await readContract(`${ARTIFACTS_PATH}`, 'L1AssetTracker')).abi,
+        alice.ethWallet()
+    );
+
+    const initiatingTx = await l2AssetTracker.initiateL1ToGatewayMigrationOnL2(assetId);
+    await initiatingTx.wait();
+
+    // Now we need to wait for the L2 to L1 message to be processed.
+    const l2TxReceipt = await alice.provider.getTransactionReceipt(initiatingTx.hash);
+    await waitForL2ToL1LogProof(alice, l2TxReceipt!.blockNumber, initiatingTx.hash);
+
+    const finalizeWithdrawalParams = await alice.finalizeWithdrawalParams(initiatingTx.hash);
+
+    const finalizeDepositParams = {
+        chainId: (await alice.provider.getNetwork()).chainId,
+        l2BatchNumber: finalizeWithdrawalParams.l1BatchNumber,
+        l2MessageIndex: finalizeWithdrawalParams.l2MessageIndex,
+        l2Sender: finalizeWithdrawalParams.sender,
+        l2TxNumberInBatch: finalizeWithdrawalParams.l2TxNumberInBlock,
+        message: finalizeWithdrawalParams.message,
+        merkleProof: finalizeWithdrawalParams.proof
+    };
+
+    // Finalize the migration on L1.
+    await expect(l1AssetTracker.receiveMigrationOnL1(finalizeDepositParams)).toBeAccepted();
+
+    // TODO: the above tx has created some priority ops, we should wait for them
+    await sleep(5);
+}
 
 describe('L2 native ERC20 contract checks', () => {
     let testMaster: TestMaster;
@@ -118,6 +161,22 @@ describe('L2 native ERC20 contract checks', () => {
         await expect(aliceErc20.balanceOf(alice.address)).resolves.toBeGreaterThan(0n); // 'Alice should have non-zero balance'
     });
 
+    test('Migrate token balance to Gateway', async () => {
+        // TODO: if the chain settles on L1, skip this part + check that the token has not yet
+        // been registered on L1
+
+        // Ensure that the token has not yet been registered on L1
+        const tokenAddressOnL1 = await l1NativeTokenVault.tokenAddress(zkTokenAssetId);
+        expect(tokenAddressOnL1).toEqual(ethers.ZeroAddress);
+
+        // Register the token on L2.
+        const registerTx = await l2NativeTokenVault.registerToken(await aliceErc20.getAddress());
+        await registerTx.wait();
+
+        // Migrate the balance to the Gateway
+        await migrateTokenBalanceFromL1ToGateway(alice, zkTokenAssetId, l1NativeTokenVault);
+    });
+
     test('Can perform a withdrawal', async () => {
         if (testMaster.isFastMode()) {
             return;
diff --git a/etc/env/file_based/genesis.yaml b/etc/env/file_based/genesis.yaml
@@ -1,10 +1,10 @@
 genesis_protocol_semantic_version: 0.30.0
 genesis_protocol_version: null
-genesis_root: 0xba3ab211944676593a7c0a99b8a7fd4a23cda91a1c46179addbfae1391ffd55b
-genesis_rollup_leaf_index: 94
-genesis_batch_commitment: 0x678a7ca6085e3724ebb201316944ee3ec43ac83140400d21a5e772ec9e060f90
-bootloader_hash: 0x0100091118d2d6c46d8e646b67026ef848826845d0aff1cb72cddb6b98e4e90c
-default_aa_hash: 0x010005f7fc2bd2320582602ba8e850df381b4ada8c613b4efc7883be575083e9
+genesis_root: 0x31a9cb6cdec8c1c0433a2d3e02b38914f03f033fefb382f25079978e5660fec4
+genesis_rollup_leaf_index: 102
+genesis_batch_commitment: 0xa350a63e4b3c3ce95b95b70cf477ee4e8ce4cafc80339c9e891313dd9ffd3abc
+bootloader_hash: 0x010009618912f1830c8560fdb5d418583619bbb26d20dc7a620bed5596c1968f
+default_aa_hash: 0x010005f727313439a1ea22799dc1ec63e50775f46a9ca659031e5b18cc91e02d
 evm_emulator_hash: 0x01000d8bae37b82f311186426184866498b357f41d7a02ced11f3e3fbfbacd63
 l1_chain_id: 9
 l2_chain_id: 270
diff --git a/etc/utils/src/constants.ts b/etc/utils/src/constants.ts
@@ -45,7 +45,7 @@ function readContract(path: string, fileName: string, contractName?: string) {
     contractName = contractName || fileName;
     return JSON.parse(fs.readFileSync(`${path}/${fileName}.sol/${contractName}.json`, { encoding: 'utf-8' }));
 }
-export const ArtifactBridgeHub = readContract(`${ARTIFACTS_PATH}`, 'Bridgehub');
+export const ArtifactL1BridgeHub = readContract(`${ARTIFACTS_PATH}`, 'L1Bridgehub');
 export const ArtifactInteropCenter = readContract(`${ARTIFACTS_PATH}`, 'InteropCenter');
 export const ArtifactInteropHandler = readContract(`${ARTIFACTS_PATH}`, 'InteropHandler');
 export const ArtifactL2InteropRootStorage = readContract(`${SYSTEM_ARTIFACTS_PATH}`, 'L2InteropRootStorage');
diff --git a/etc/utils/src/tokens.ts b/etc/utils/src/tokens.ts
@@ -7,7 +7,7 @@ import * as zksync from 'zksync-ethers';
 
 import {
     ArtifactL1AssetTracker,
-    ArtifactBridgeHub,
+    ArtifactL1BridgeHub,
     ArtifactL1AssetRouter,
     ArtifactNativeTokenVault,
     ArtifactL1NativeTokenVault,
@@ -24,7 +24,7 @@ export interface EcosystemContracts {
 export async function getEcosystemContracts(wallet: zksync.Wallet): Promise<EcosystemContracts> {
     const bridgehub = new ethers.Contract(
         await (await wallet.getBridgehubContract()).getAddress(),
-        ArtifactBridgeHub.abi,
+        ArtifactL1BridgeHub.abi,
         wallet.providerL1!
     );
     // console.log('bridgehub', await bridgehub.getAddress());
diff --git a/infrastructure/scripts/interop.sh b/infrastructure/scripts/interop.sh
@@ -39,7 +39,7 @@ zkstack chain init \
             --l1-rpc-url=http://127.0.0.1:8545 \
             --server-db-url=postgres://postgres:notsecurepassword@localhost:5432 \
             --server-db-name=zksync_server_localhost_validium \
-            --chain validium --update-submodules false \
+            --chain validium \
             --validium-type no-da
 
 zkstack chain create \
@@ -60,7 +60,7 @@ zkstack chain init \
             --l1-rpc-url=http://127.0.0.1:8545 \
             --server-db-url=postgres://postgres:notsecurepassword@localhost:5432 \
             --server-db-name=zksync_server_localhost_gateway \
-            --chain gateway --update-submodules false
+            --chain gateway
 
 zkstack server --ignore-prerequisites --chain era &> ./zruns/era1.log &
 zkstack server wait --ignore-prerequisites --verbose --chain era
diff --git a/zkstack_cli/crates/zkstack/src/commands/ecosystem/args/common.rs b/zkstack_cli/crates/zkstack/src/commands/ecosystem/args/common.rs
@@ -14,9 +14,9 @@ use crate::{
 pub struct CommonEcosystemArgs {
     #[clap(long, default_value_t = false, default_missing_value = "true")]
     pub(crate) zksync_os: bool,
-    #[clap(long, default_value_t = true)]
+    #[clap(long, default_value_t = true, num_args = 0..=1)]
     pub(crate) update_submodules: bool,
-    #[clap(long, default_value_t = false, default_missing_value = "true")]
+    #[clap(long, default_value_t = false, default_missing_value = "true", num_args = 0..=1)]
     pub(crate) skip_contract_compilation_override: bool,
     #[clap(long, help = MSG_L1_RPC_URL_HELP)]
     pub(crate) l1_rpc_url: Option<String>,
