Merge remote-tracking branch 'origin/draft-v31' into sma/refactor-tests

Author: zkzoomer

.github/workflows/ci-core-lint-reusable.yml

@@ -82,7 +82,6 @@ jobs:
           ci_run zkstack dev lint -t js --check
           ci_run zkstack dev lint -t ts --check
           ci_run zkstack dev lint -t rs --check
-          ci_run zkstack dev lint -t rust-toolchain
           ci_run zkstack dev lint -t autocompletion
 
       - name: Check Database

core/lib/eth_client/src/contracts_loader.rs

@@ -186,25 +186,21 @@ pub async fn get_zk_chain_on_chain_params(
     diamond_proxy_addr: Address,
 ) -> Result<ZkChainOnChainConfig, ContractCallError> {
     let abi = getters_facet_contract();
-    let l2_da_commitment_scheme: Token = CallFunctionArgs::new("getDAValidatorPair", ())
+    let token: Token = CallFunctionArgs::new("getDAValidatorPair", ())
         .for_contract(diamond_proxy_addr, &abi)
         .call(eth_client)
         .await?;
-    let l2_da_commitment_scheme =
-        if let Token::Tuple(l2_da_commitment_scheme) = l2_da_commitment_scheme {
-            if let [Token::Address(_), Token::Uint(l2_da_commitment_scheme)] =
-                l2_da_commitment_scheme.as_slice()
-            {
-                Some(
-                    L2DACommitmentScheme::try_from(l2_da_commitment_scheme.as_u64() as u8)
-                        .expect("wrong l2_da_commitment_scheme"),
-                )
-            } else {
-                None
-            }
-        } else {
-            None
-        };
+
+    let l2_da_commitment_scheme = match token {
+        Token::Tuple(tuple) if tuple.len() == 2 => match tuple.as_slice() {
+            [Token::Address(_), Token::Uint(value)] if *value <= U256::from(u8::MAX) => Some(
+                L2DACommitmentScheme::try_from(value.as_u64() as u8)
+                    .expect("Wrong L2DACommitmentScheme"),
+            ),
+            _ => None,
+        },
+        _ => None,
+    };
 
     Ok(ZkChainOnChainConfig {
         l2_da_commitment_scheme,

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

@@ -1112,6 +1112,7 @@ pub struct GatewayMigrationStatus {
     pub latest_notification: Option<GatewayMigrationNotification>,
     pub state: GatewayMigrationState,
     pub settlement_layer: Option<SettlementLayer>,
+    pub wait_for_batches_to_be_committed: bool,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]

core/node/api_server/src/web3/namespaces/unstable/mod.rs

@@ -8,11 +8,13 @@ use zksync_dal::{Connection, Core, CoreDal, DalError};
 use zksync_mini_merkle_tree::MiniMerkleTree;
 use zksync_multivm::{interface::VmEvent, zk_evm_latest::ethereum_types::U64};
 use zksync_types::{
+    aggregated_operations::L1BatchAggregatedActionType,
     api,
     api::{
         ChainAggProof, DataAvailabilityDetails, GatewayMigrationStatus, L1ToL2TxsStatus, TeeProof,
         TransactionDetailedResult, TransactionExecutionInfo,
     },
+    eth_sender::EthTxFinalityStatus,
     server_notification::GatewayMigrationState,
     tee_types::TeeType,
     web3,
@@ -248,6 +250,27 @@ impl UnstableNamespace {
             .await
             .map_err(DalError::generalize)?;
 
+        let all_batches_with_interop_roots_committed = match connection
+            .interop_root_dal()
+            .get_latest_processed_interop_root_l1_batch_number()
+            .await
+            .map_err(DalError::generalize)?
+        {
+            None => true,
+            Some(latest_processed_l1_batch_number) => {
+                match connection
+                    .eth_sender_dal()
+                    .get_last_sent_successfully_eth_tx_by_batch_and_op(
+                        L1BatchNumber::from(latest_processed_l1_batch_number),
+                        L1BatchAggregatedActionType::Commit,
+                    )
+                    .await
+                {
+                    Some(tx) => tx.eth_tx_finality_status == EthTxFinalityStatus::Finalized,
+                    None => false,
+                }
+            }
+        };
         let state = GatewayMigrationState::from_sl_and_notification(
             self.state
                 .api_config
@@ -264,6 +287,7 @@ impl UnstableNamespace {
                 .api_config
                 .settlement_layer
                 .settlement_layer_for_sending_txs(),
+            wait_for_batches_to_be_committed: !all_batches_with_interop_roots_committed,
         })
     }
 

core/node/eth_sender/src/eth_tx_aggregator.rs

@@ -857,12 +857,13 @@ impl EthTxAggregator {
             op_restrictions.precommit_restriction = reason;
             // From V31 when migrating to or from gateway, we need to wait for all blocks to be executed,
             // so there is no restriction for prove and execute operations
-            if let Some(SettlementLayer::Gateway(_)) = self.settlement_layer {
-                // For the migration from gateway to L1, we need we need to ensure all batches containing interop roots get committed and executed.
-                if !self
+            if matches!(self.settlement_layer, Some(SettlementLayer::Gateway(_))) {
+                if self
                     .is_waiting_for_batches_with_interop_roots_to_be_committed(storage)
                     .await?
                 {
+                    // For the migration from gateway to L1, we need to ensure all batches containing interop roots
+                    // get committed and executed. Once this happens, we can re-enable commit & precommit.
                     op_restrictions.commit_restriction = None;
                     op_restrictions.precommit_restriction = None;
                 }

core/tests/gateway-migration-test/tests/migration.test.ts

@@ -226,9 +226,23 @@ describe('Migration from gateway test', function () {
                 }
             }
         } else {
-            await utils.spawn(
-                `zkstack chain gateway migrate-from-gateway --chain ${fileConfig.chain} --gateway-chain-name ${gatewayChain}`
-            );
+            let migrationSucceeded = false;
+            for (let i = 0; i < 60; i++) {
+                try {
+                    await utils.spawn(
+                        `zkstack chain gateway migrate-from-gateway --chain ${fileConfig.chain} --gateway-chain-name ${gatewayChain}`
+                    );
+                    migrationSucceeded = true;
+                    break;
+                } catch (e) {
+                    console.log(`Migration attempt ${i} failed with error: ${e}`);
+                    await utils.sleep(2);
+                }
+            }
+
+            if (!migrationSucceeded) {
+                throw new Error('Migration from gateway did not succeed after 60 attempts');
+            }
         }
         await mainNodeSpawner.mainNode?.waitForShutdown();
         // Node is already killed, so we simply start the new server

zkstack_cli/crates/config/src/forge_interface/gateway_vote_preparation/input.rs

@@ -1,11 +1,9 @@
-use std::str::FromStr;
-
 use ethers::types::{Address, H256, U256};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     forge_interface::deploy_ecosystem::input::InitialDeploymentConfig, traits::FileConfigTrait,
-    ContractsConfig, ContractsGenesisConfig,
+    ContractsConfig,
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -16,13 +14,6 @@ pub struct GatewayContractsConfig {
     pub create2_factory_salt: H256,
     pub create2_factory_addr: Option<Address>,
     pub validator_timelock_execution_delay: U256,
-    pub genesis_root: H256,
-    pub genesis_rollup_leaf_index: U256,
-    pub genesis_batch_commitment: H256,
-    pub latest_protocol_version: U256,
-    pub default_aa_hash: H256,
-    pub bootloader_hash: H256,
-    pub evm_emulator_hash: Option<H256>,
     pub avail_l1_da_validator: Option<Address>,
     pub bridgehub_proxy_address: Address,
 }
@@ -52,15 +43,14 @@ impl GatewayVotePreparationConfig {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         initial_deployment_config: &InitialDeploymentConfig,
-        genesis_input: &ContractsGenesisConfig,
-        external_contracts_config: &ContractsConfig, // from external context
+        external_contracts_config: &ContractsConfig,
         era_chain_id: U256,
         gateway_chain_id: U256,
         owner_address: Address,
         testnet_verifier: bool,
         is_zk_sync_os: bool,
         refund_recipient: Address,
-    ) -> anyhow::Result<Self> {
+    ) -> Self {
         let contracts = GatewayContractsConfig {
             governance_security_council_address: Address::zero(),
             governance_min_delay: U256::from(initial_deployment_config.governance_min_delay),
@@ -70,17 +60,6 @@ impl GatewayVotePreparationConfig {
             validator_timelock_execution_delay: U256::from(
                 initial_deployment_config.validator_timelock_execution_delay,
             ),
-            genesis_root: H256::from_str(&genesis_input.genesis_root_hash()?)?,
-            genesis_rollup_leaf_index: U256::from(genesis_input.rollup_last_leaf_index()?),
-            genesis_batch_commitment: H256::from_str(&genesis_input.genesis_commitment()?)?,
-            latest_protocol_version: genesis_input.protocol_semantic_version()?.pack(),
-            default_aa_hash: H256::from_str(&genesis_input.default_aa_hash()?)?,
-            bootloader_hash: H256::from_str(&genesis_input.bootloader_hash()?)?,
-            evm_emulator_hash: genesis_input
-                .evm_emulator_hash()?
-                .as_ref()
-                .map(|hash| H256::from_str(&hash.to_string()))
-                .transpose()?,
             avail_l1_da_validator: external_contracts_config.l1.avail_l1_da_validator_addr,
             bridgehub_proxy_address: external_contracts_config
                 .ecosystem_contracts
@@ -91,7 +70,7 @@ impl GatewayVotePreparationConfig {
             token_weth_address: initial_deployment_config.token_weth_address,
         };
 
-        Ok(Self {
+        Self {
             era_chain_id,
             owner_address,
             testnet_verifier,
@@ -107,6 +86,6 @@ impl GatewayVotePreparationConfig {
                 .force_deployments_data
                 .clone()
                 .unwrap_or_default(),
-        })
+        }
     }
 }

zkstack_cli/crates/zkstack/src/commands/chain/args/init/da_configs.rs

@@ -31,6 +31,16 @@ pub enum ValidiumTypeInternal {
     EigenDA,
 }
 
+impl ValidiumTypeInternal {
+    pub fn as_str(&self) -> &str {
+        match self {
+            ValidiumTypeInternal::NoDA => "NoDA",
+            ValidiumTypeInternal::Avail => "Avail",
+            ValidiumTypeInternal::EigenDA => "EigenDA",
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, EnumIter, Display, ValueEnum)]
 pub enum AvailClientTypeInternal {
     FullClient,

zkstack_cli/crates/zkstack/src/commands/chain/gateway/convert_to_gateway.rs

@@ -50,6 +50,15 @@ pub struct ConvertToGatewayArgs {
 
     #[clap(long, default_value_t = false)]
     pub only_save_calldata: bool,
+
+    /// L1 RPC URL. If not provided, will be read from chain secrets config.
+    #[clap(long)]
+    pub l1_rpc_url: Option<String>,
+
+    /// Skip applying gateway config overrides (overrides/gateway.yaml).
+    /// By default, the gateway.yaml file is required.
+    #[clap(long, default_value_t = false)]
+    pub no_gateway_overrides: bool,
 }
 
 fn parse_decimal_u256(s: &str) -> Result<U256, String> {
@@ -60,21 +69,26 @@ fn parse_decimal_u256(s: &str) -> Result<U256, String> {
 }
 
 pub async fn run(convert_to_gw_args: ConvertToGatewayArgs, shell: &Shell) -> anyhow::Result<()> {
-    let args = convert_to_gw_args.forge_args;
+    let args = convert_to_gw_args.forge_args.clone();
     let ecosystem_config = ZkStackConfig::ecosystem(shell)?;
     let chain_config = ecosystem_config
         .load_current_chain()
         .context(MSG_CHAIN_NOT_INITIALIZED)?;
-    let l1_url = chain_config.get_secrets_config().await?.l1_rpc_url()?;
+    let l1_url = match convert_to_gw_args.l1_rpc_url {
+        Some(url) => url,
+        None => chain_config.get_secrets_config().await?.l1_rpc_url()?,
+    };
     let chain_contracts_config = chain_config.get_contracts_config()?;
-    let contracts_config = chain_config.get_contracts_genesis_config().await?;
-    override_config(
-        shell,
-        &ecosystem_config
-            .default_configs_path_for_ctm(chain_config.vm_option)
-            .join(PATH_TO_GATEWAY_OVERRIDE_CONFIG),
-        &chain_config,
-    )?;
+
+    if !convert_to_gw_args.no_gateway_overrides {
+        override_config(
+            shell,
+            &ecosystem_config
+                .default_configs_path_for_ctm(chain_config.vm_option)
+                .join(PATH_TO_GATEWAY_OVERRIDE_CONFIG),
+            &chain_config,
+        )?;
+    }
 
     let chain_deployer_wallet = chain_config
         .get_wallets_config()?
@@ -141,15 +155,14 @@ pub async fn run(convert_to_gw_args: ConvertToGatewayArgs, shell: &Shell) -> any
         &chain_deployer_wallet,
         GatewayVotePreparationConfig::new(
             &ecosystem_config.get_initial_deployment_config().unwrap(),
-            &contracts_config,
             &chain_contracts_config,
             ecosystem_config.era_chain_id.as_u64().into(),
             chain_config.chain_id.as_u64().into(),
             ecosystem_config.get_contracts_config()?.l1.governance_addr,
             ecosystem_config.prover_version == ProverMode::NoProofs,
             chain_config.vm_option.is_zksync_os(),
             chain_deployer_wallet.address,
-        )?,
+        ),
         l1_url.clone(),
         convert_to_gw_args
             .ctm_chain_id

zkstack_cli/crates/zkstack/src/commands/chain/gateway/create_tx_filterer.rs

@@ -1,6 +1,8 @@
 use anyhow::Context;
+use clap::Parser;
 use ethers::contract::BaseContract;
 use lazy_static::lazy_static;
+use serde::{Deserialize, Serialize};
 use xshell::Shell;
 use zkstack_cli_common::{
     config::global_config,
@@ -28,13 +30,28 @@ lazy_static! {
         BaseContract::from(DEPLOYGATEWAYTRANSACTIONFILTERERABI_ABI.clone());
 }
 
-pub async fn run(args: ForgeScriptArgs, shell: &Shell) -> anyhow::Result<()> {
+#[derive(Debug, Serialize, Deserialize, Parser)]
+pub struct CreateTxFiltererArgs {
+    /// All ethereum environment related arguments
+    #[clap(flatten)]
+    #[serde(flatten)]
+    pub forge_args: ForgeScriptArgs,
+
+    /// L1 RPC URL. If not provided, will be read from chain secrets config.
+    #[clap(long)]
+    pub l1_rpc_url: Option<String>,
+}
+
+pub async fn run(args: CreateTxFiltererArgs, shell: &Shell) -> anyhow::Result<()> {
     let chain_name = global_config().chain_name.clone();
     let ecosystem_config = ZkStackConfig::ecosystem(shell)?;
     let chain_config = ecosystem_config
         .load_chain(chain_name)
         .context(MSG_CHAIN_NOT_INITIALIZED)?;
-    let l1_url = chain_config.get_secrets_config().await?.l1_rpc_url()?;
+    let l1_url = match args.l1_rpc_url {
+        Some(url) => url,
+        None => chain_config.get_secrets_config().await?.l1_rpc_url()?,
+    };
     let mut chain_contracts_config = chain_config.get_contracts_config()?;
 
     let chain_deployer_wallet = chain_config
@@ -44,7 +61,7 @@ pub async fn run(args: ForgeScriptArgs, shell: &Shell) -> anyhow::Result<()> {
 
     let output: GatewayTxFiltererOutput = deploy_gateway_tx_filterer(
         shell,
-        args.clone(),
+        args.forge_args.clone(),
         &chain_config,
         &chain_deployer_wallet,
         &chain_contracts_config,
@@ -54,7 +71,7 @@ pub async fn run(args: ForgeScriptArgs, shell: &Shell) -> anyhow::Result<()> {
 
     set_transaction_filterer(
         shell,
-        &args,
+        &args.forge_args,
         &chain_config.path_to_foundry_scripts(),
         AdminScriptMode::Broadcast(chain_config.get_wallets_config()?.governor),
         chain_config.chain_id.as_u64(),