feat(zkstack): Add chain registrar for registering new chains

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

@@ -132,7 +132,7 @@ jobs:
         run: |
           ci_run ./zkstack_cli/zkstackup/install -g --path ./zkstack_cli/zkstackup/zkstackup || true
           ci_run zkstackup -g --local
-  
+
 
       - name: Create and initialize legacy chain
         run: |
@@ -298,7 +298,7 @@ jobs:
         run: |
           ci_run zkstack chain create \
           --chain-name offline_chain \
-          --chain-id sequential \
+          --chain-id 384 \
           --prover-mode no-proofs \
           --wallet-creation localhost \
           --l1-batch-commit-data-generator-mode rollup \
@@ -309,12 +309,13 @@ jobs:
           --ignore-prerequisites \
           --evm-emulator false
 
-          ci_run zkstack chain build-transactions --chain offline_chain --l1-rpc-url http://127.0.0.1:8545
+          ci_run zkstack chain propose-chain --chain offline_chain --dev
+          ci_run zkstack ecosystem register-chain --no-broadcast --chain offline_chain --dev
 
           governor_pk=$(awk '/governor:/ {flag=1} flag && /private_key:/ {print $2; exit}' ./configs/wallets.yaml)
 
           ci_run zkstack dev send-transactions \
-          --file ./transactions/chain/offline_chain/register-hyperchain-txns.json \
+          --file ./transactions/chain/384/register-hyperchain-txns.json \
           --l1-rpc-url http://127.0.0.1:8545 \
           --private-key $governor_pk
 

.github/workflows/ci-prover-e2e.yml

@@ -105,10 +105,10 @@ jobs:
           ci_run zkstack prover run --component=compressor --docker=false &>prover_logs/compressor.log &
       - name: Wait for batch to be executed on L1
         env:
-            DATABASE_URL: postgres://postgres:notsecurepassword@localhost:5432/zksync_prover_localhost_proving_chain
-            BATCH_NUMBER: 1
-            INTERVAL: 30
-            TIMEOUT: 600
+          DATABASE_URL: postgres://postgres:notsecurepassword@localhost:5432/zksync_prover_localhost_proving_chain
+          BATCH_NUMBER: 1
+          INTERVAL: 30
+          TIMEOUT: 600
         run: |
           PASSED_ENV_VARS="BATCH_NUMBER,DATABASE_URL,URL,INTERVAL,TIMEOUT" \
           ci_run ./bin/prover_checkers/batch_l1_status_checker

core/lib/basic_types/src/commitment.rs

@@ -44,6 +44,15 @@ impl Detokenize for L1BatchCommitmentMode {
     }
 }
 
+impl From<L1BatchCommitmentMode> for u8 {
+    fn from(val: L1BatchCommitmentMode) -> Self {
+        match val {
+            L1BatchCommitmentMode::Rollup => 0,
+            L1BatchCommitmentMode::Validium => 1,
+        }
+    }
+}
+
 impl FromStr for L1BatchCommitmentMode {
     type Err = &'static str;
 

zkstack_cli/crates/common/src/ethereum/chain_registrar.rs

@@ -0,0 +1,40 @@
+use std::sync::Arc;
+
+use ethers::{
+    abi::Address,
+    contract::abigen,
+    prelude::{Http, Provider},
+};
+
+abigen!(
+    ChainRegistar,
+    r"[
+        struct RegisteredChainConfig {address pendingChainAdmin;address chainAdmin;address diamondProxy;address l2BridgeAddress;}
+        function getRegisteredChainConfig(uint256 chainId) public view returns (RegisteredChainConfig memory)
+    ]"
+);
+
+#[derive(Clone, Copy)]
+pub struct ChainRegistrationResult {
+    pub diamond_proxy: Address,
+    pub chain_admin: Address,
+    pub l2_shared_bridge: Address,
+}
+
+pub async fn load_contracts_for_chain(
+    chain_registrar: Address,
+    l1_rpc: String,
+    l2_chain_id: u64,
+) -> anyhow::Result<ChainRegistrationResult> {
+    let client = Arc::new(Provider::<Http>::try_from(l1_rpc)?);
+    let contract = ChainRegistar::new(chain_registrar, client);
+    let (pending_chain_admin, _chain_admin, diamond_proxy, l2_bridge_address) = contract
+        .get_registered_chain_config(l2_chain_id.into())
+        .await?;
+
+    Ok(ChainRegistrationResult {
+        diamond_proxy,
+        chain_admin: pending_chain_admin,
+        l2_shared_bridge: l2_bridge_address,
+    })
+}

zkstack_cli/crates/common/src/ethereum/mod.rs

@@ -0,0 +1,58 @@
+pub mod chain_registrar;
+pub mod token;
+
+use std::{ops::Add, time::Duration};
+
+use ethers::{
+    core::k256::ecdsa::SigningKey,
+    middleware::MiddlewareBuilder,
+    prelude::{Http, LocalWallet, Provider, Signer, SignerMiddleware},
+    providers::Middleware,
+    types::{Address, TransactionRequest},
+};
+pub use token::{get_token_info, mint_token};
+
+use crate::wallets::Wallet;
+
+pub fn create_ethers_client(
+    mut wallet: LocalWallet,
+    l1_rpc: String,
+    chain_id: Option<u64>,
+) -> anyhow::Result<SignerMiddleware<Provider<Http>, ethers::prelude::Wallet<SigningKey>>> {
+    if let Some(chain_id) = chain_id {
+        wallet = wallet.with_chain_id(chain_id);
+    }
+    let client = Provider::<Http>::try_from(l1_rpc)?.with_signer(wallet);
+    Ok(client)
+}
+
+pub async fn distribute_eth(
+    main_wallet: Wallet,
+    addresses: Vec<Address>,
+    l1_rpc: String,
+    chain_id: u64,
+    amount: u128,
+) -> anyhow::Result<()> {
+    let client = create_ethers_client(main_wallet.private_key.unwrap(), l1_rpc, Some(chain_id))?;
+    let mut pending_txs = vec![];
+    let mut nonce = client.get_transaction_count(client.address(), None).await?;
+    for address in addresses {
+        let tx = TransactionRequest::new()
+            .to(address)
+            .value(amount)
+            .nonce(nonce)
+            .chain_id(chain_id);
+        nonce = nonce.add(1);
+        pending_txs.push(
+            client
+                .send_transaction(tx, None)
+                .await?
+                // It's safe to set such low number of confirmations and low interval for localhost
+                .confirmations(1)
+                .interval(Duration::from_millis(30)),
+        );
+    }
+
+    futures::future::join_all(pending_txs).await;
+    Ok(())
+}

zkstack_cli/crates/common/src/ethereum.rs → zkstack_cli/crates/common/src/ethereum/token.rs

@@ -1,60 +1,14 @@
-use std::{ops::Add, sync::Arc, time::Duration};
+use std::{sync::Arc, time::Duration};
 
 use ethers::{
+    abi::Address,
     contract::abigen,
-    core::k256::ecdsa::SigningKey,
     middleware::MiddlewareBuilder,
-    prelude::{Http, LocalWallet, Provider, Signer, SignerMiddleware},
-    providers::Middleware,
-    types::{Address, TransactionRequest},
+    prelude::{Http, Provider},
 };
 use types::TokenInfo;
 
-use crate::{logger, wallets::Wallet};
-
-pub fn create_ethers_client(
-    mut wallet: LocalWallet,
-    l1_rpc: String,
-    chain_id: Option<u64>,
-) -> anyhow::Result<SignerMiddleware<Provider<Http>, ethers::prelude::Wallet<SigningKey>>> {
-    if let Some(chain_id) = chain_id {
-        wallet = wallet.with_chain_id(chain_id);
-    }
-    let client = Provider::<Http>::try_from(l1_rpc)?.with_signer(wallet);
-    Ok(client)
-}
-
-pub async fn distribute_eth(
-    main_wallet: Wallet,
-    addresses: Vec<Address>,
-    l1_rpc: String,
-    chain_id: u64,
-    amount: u128,
-) -> anyhow::Result<()> {
-    let client = create_ethers_client(main_wallet.private_key.unwrap(), l1_rpc, Some(chain_id))?;
-    let mut pending_txs = vec![];
-    let mut nonce = client.get_transaction_count(client.address(), None).await?;
-    for address in addresses {
-        let tx = TransactionRequest::new()
-            .to(address)
-            .value(amount)
-            .nonce(nonce)
-            .chain_id(chain_id);
-        nonce = nonce.add(1);
-        pending_txs.push(
-            client
-                .send_transaction(tx, None)
-                .await?
-                // It's safe to set such low number of confirmations and low interval for localhost
-                .confirmations(1)
-                .interval(Duration::from_millis(30)),
-        );
-    }
-
-    futures::future::join_all(pending_txs).await;
-    Ok(())
-}
-
+use crate::{ethereum::create_ethers_client, logger, wallets::Wallet};
 abigen!(
     TokenContract,
     r"[

zkstack_cli/crates/config/src/contracts.rs

@@ -71,11 +71,12 @@ impl ContractsConfig {
             .diamond_cut_data
             .clone_from(&deploy_l1_output.contracts_config.diamond_cut_data);
         self.l1.chain_admin_addr = deploy_l1_output.deployed_addresses.chain_admin;
+        self.ecosystem_contracts.chain_registrar =
+            deploy_l1_output.deployed_addresses.chain_registrar;
     }
 
     pub fn set_chain_contracts(&mut self, register_chain_output: &RegisterChainOutput) {
         self.l1.diamond_proxy_addr = register_chain_output.diamond_proxy_addr;
-        self.l1.governance_addr = register_chain_output.governance_addr;
         self.l1.chain_admin_addr = register_chain_output.chain_admin_addr;
     }
 
@@ -132,6 +133,7 @@ pub struct EcosystemContracts {
     pub transparent_proxy_admin_addr: Address,
     pub validator_timelock_addr: Address,
     pub diamond_cut_data: String,
+    pub chain_registrar: Address,
 }
 
 impl ZkStackConfig for EcosystemContracts {}

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

@@ -111,6 +111,7 @@ pub struct DeployL1Config {
     pub era_chain_id: L2ChainId,
     pub owner_address: Address,
     pub testnet_verifier: bool,
+    pub l2_deployer: Address,
     pub contracts: ContractsDeployL1Config,
     pub tokens: TokensDeployL1Config,
 }
@@ -166,6 +167,7 @@ impl DeployL1Config {
             tokens: TokensDeployL1Config {
                 token_weth_address: initial_deployment_config.token_weth_address,
             },
+            l2_deployer: wallets_config.governor.address,
         }
     }
 }

zkstack_cli/crates/config/src/forge_interface/deploy_ecosystem/output.rs

@@ -48,6 +48,7 @@ pub struct DeployL1DeployedAddressesOutput {
     pub bridgehub: L1BridgehubOutput,
     pub bridges: L1BridgesOutput,
     pub state_transition: L1StateTransitionOutput,
+    pub chain_registrar: Address,
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone)]

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

@@ -17,6 +17,8 @@ pub struct DeployL2ContractsInput {
     pub governance: Address,
     pub erc20_bridge: Address,
     pub consensus_registry_owner: Address,
+    pub chain_registrar: Address,
+    pub proposal_author: Address,
 }
 
 impl DeployL2ContractsInput {
@@ -31,6 +33,8 @@ impl DeployL2ContractsInput {
             governance: wallets.governor.address,
             erc20_bridge: contracts.bridges.erc20.l1_address,
             consensus_registry_owner: wallets.governor.address,
+            chain_registrar: contracts.ecosystem_contracts.chain_registrar,
+            proposal_author: wallets.governor.address,
         })
     }
 }

zkstack_cli/crates/config/src/forge_interface/mod.rs

@@ -2,6 +2,7 @@ pub mod accept_ownership;
 pub mod deploy_ecosystem;
 pub mod deploy_l2_contracts;
 pub mod paymaster;
+pub mod propose_registration;
 pub mod register_chain;
 pub mod script_params;
 pub mod setup_legacy_bridge;

zkstack_cli/crates/config/src/forge_interface/propose_registration/mod.rs

@@ -0,0 +1,64 @@
+use ethers::types::Address;
+use serde::{Deserialize, Serialize};
+use types::BaseToken;
+use zksync_basic_types::commitment::L1BatchCommitmentMode;
+
+use crate::traits::ZkStackConfig;
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+
+struct ChainConfig {
+    chain_id: u64,
+    blob_operator: Address,
+    operator: Address,
+    governor: Address,
+    base_token: BaseTokenInt,
+    pubdata_pricing_mode: u8,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+struct BaseTokenInt {
+    pub token_multiplier_setter: Option<Address>,
+    pub address: Address,
+    pub nominator: u64,
+    pub denominator: u64,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ProposeRegistrationInputConfig {
+    chain_registrar: Address,
+    chain: ChainConfig,
+}
+
+impl ProposeRegistrationInputConfig {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        chain_registrar: Address,
+        chain_id: u64,
+        blob_operator: Address,
+        operator: Address,
+        governor: Address,
+        token: BaseToken,
+        token_multiplier_setter: Option<Address>,
+        l1batch_commitment_mode: L1BatchCommitmentMode,
+    ) -> Self {
+        ProposeRegistrationInputConfig {
+            chain_registrar,
+            chain: ChainConfig {
+                chain_id,
+                blob_operator,
+                operator,
+                governor,
+                base_token: BaseTokenInt {
+                    token_multiplier_setter,
+                    address: token.address,
+                    nominator: token.nominator,
+                    denominator: token.denominator,
+                },
+                pubdata_pricing_mode: l1batch_commitment_mode as u8,
+            },
+        }
+    }
+}
+
+impl ZkStackConfig for ProposeRegistrationInputConfig {}