[WIP] Eigenda implementation, zk_toolbox version

.gitignore

@@ -119,3 +119,6 @@ configs/*
 era-observability/
 core/tests/ts-integration/deployments-zk
 transactions/
+
+# Ecosystem backups
+ecosystem_backups/

backup-ecosystem.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# This script backs up the Postgres databases and chain configuration files for a given ecosystem. 
+# With it you can make a testnet deployment and save the L2 state for later recovery.
+
+# Check if the ecosystem name was provided as an argument
+if [ -z "$1" ]; then
+  echo "Usage: ./backup-ecosystem ECOSYSTEM_NAME"
+  exit 1
+fi
+
+# Store the first argument as ECOSYSTEM_NAME
+ECOSYSTEM_NAME=$1
+
+# Prompt for the Postgres password and store it in PGPASSWORD
+read -sp "Enter Postgres password: " PGPASSWORD
+export PGPASSWORD
+
+# Path to the secrets.yaml file
+SECRETS_FILE="./chains/${ECOSYSTEM_NAME}/configs/secrets.yaml"
+
+# Check if the secrets.yaml file exists
+if [ ! -f "$SECRETS_FILE" ]; then
+  echo "Error: $SECRETS_FILE does not exist."
+  exit 1
+fi
+
+# Extract server_url and prover_url from the secrets.yaml file
+SERVER_DB_NAME=$(grep 'server_url' "$SECRETS_FILE" | awk -F'/' '{print $NF}')
+PROVER_DB_NAME=$(grep 'prover_url' "$SECRETS_FILE" | awk -F'/' '{print $NF}')
+
+# Export the database names
+echo "Extracted SERVER_DB_NAME: $SERVER_DB_NAME"
+echo "Extracted PROVER_DB_NAME: $PROVER_DB_NAME"
+
+# Create backup directory
+mkdir -p "./ecosystem_backups/${ECOSYSTEM_NAME}"
+
+# Run pg_dump commands
+echo "Running pg_dump for $SERVER_DB_NAME..."
+pg_dump -U postgres -h localhost "$SERVER_DB_NAME" > "ecosystem_backups/${ECOSYSTEM_NAME}/${SERVER_DB_NAME}_backup.sql"
+echo "Running pg_dump for $PROVER_DB_NAME..."
+pg_dump -U postgres -h localhost "$PROVER_DB_NAME" > "ecosystem_backups/${ECOSYSTEM_NAME}/${PROVER_DB_NAME}_backup.sql"
+
+# Unset the PGPASSWORD variable for security
+unset PGPASSWORD
+
+# Copy the chain configuration files
+cp -r "./chains/${ECOSYSTEM_NAME}" "./ecosystem_backups/${ECOSYSTEM_NAME}/"
+
+# Copy the configs directory
+cp -r "./configs" "./ecosystem_backups/${ECOSYSTEM_NAME}/"
+
+echo "Backup completed."

core/bin/genesis_generator/src/main.rs

@@ -87,6 +87,7 @@ async fn generate_new_config(
         genesis_commitment: None,
         bootloader_hash: Some(base_system_contracts.bootloader),
         default_aa_hash: Some(base_system_contracts.default_aa),
+        evm_emulator_hash: base_system_contracts.evm_emulator,
         ..genesis_config
     };
 

core/bin/system-constants-generator/src/utils.rs

@@ -71,12 +71,14 @@ pub static GAS_TEST_SYSTEM_CONTRACTS: Lazy<BaseSystemContracts> = Lazy::new(|| {
 
     let bytecode = read_sys_contract_bytecode("", "DefaultAccount", ContractLanguage::Sol);
     let hash = hash_bytecode(&bytecode);
+
     BaseSystemContracts {
         default_aa: SystemContractCode {
             code: bytes_to_be_words(bytecode),
             hash,
         },
         bootloader,
+        evm_emulator: None,
     }
 });
 
@@ -221,6 +223,7 @@ pub(super) fn execute_internal_transfer_test() -> u32 {
     let base_system_smart_contracts = BaseSystemContracts {
         bootloader,
         default_aa,
+        evm_emulator: None,
     };
 
     let system_env = SystemEnv {

core/bin/zksync_server/src/node_builder.rs

@@ -28,7 +28,7 @@ use zksync_node_framework::{
         consensus::MainNodeConsensusLayer,
         contract_verification_api::ContractVerificationApiLayer,
         da_clients::{
-            avail::AvailWiringLayer, no_da::NoDAClientWiringLayer,
+            avail::AvailWiringLayer, eigen_da::EigenDAWiringLayer, no_da::NoDAClientWiringLayer,
             object_store::ObjectStorageClientWiringLayer,
         },
         da_dispatcher::DataAvailabilityDispatcherLayer,
@@ -509,17 +509,23 @@ impl MainNodeBuilder {
             return Ok(self);
         };
 
-        let secrets = try_load_config!(self.secrets.data_availability);
+        let secrets = self.secrets.data_availability.clone();
 
         match (da_client_config, secrets) {
-            (DAClientConfig::Avail(config), DataAvailabilitySecrets::Avail(secret)) => {
-                self.node.add_layer(AvailWiringLayer::new(config, secret));
+            (DAClientConfig::Avail(_), None) => {
+                anyhow::bail!("Data availability secrets are required for the Avail client");
             }
 
+            (DAClientConfig::Avail(config), Some(DataAvailabilitySecrets::Avail(secret))) => {
+                self.node.add_layer(AvailWiringLayer::new(config, secret));
+            }
             (DAClientConfig::ObjectStore(config), _) => {
                 self.node
                     .add_layer(ObjectStorageClientWiringLayer::new(config));
             }
+            (DAClientConfig::EigenDA(config), _) => {
+                self.node.add_layer(EigenDAWiringLayer::new(config));
+            }
         }
 
         Ok(self)

core/lib/config/src/configs/chain.rs

@@ -138,6 +138,8 @@ pub struct StateKeeperConfig {
     pub bootloader_hash: Option<H256>,
     #[deprecated(note = "Use GenesisConfig::default_aa_hash instead")]
     pub default_aa_hash: Option<H256>,
+    #[deprecated(note = "Use GenesisConfig::evm_emulator_hash instead")]
+    pub evm_emulator_hash: Option<H256>,
     #[deprecated(note = "Use GenesisConfig::l1_batch_commit_data_generator_mode instead")]
     #[serde(default)]
     pub l1_batch_commit_data_generator_mode: L1BatchCommitmentMode,
@@ -178,6 +180,7 @@ impl StateKeeperConfig {
             protective_reads_persistence_enabled: true,
             bootloader_hash: None,
             default_aa_hash: None,
+            evm_emulator_hash: None,
             l1_batch_commit_data_generator_mode: L1BatchCommitmentMode::Rollup,
         }
     }

core/lib/config/src/configs/da_client/eigen_da.rs

@@ -0,0 +1,8 @@
+use serde::Deserialize;
+
+#[derive(Clone, Debug, PartialEq, Deserialize, Default)]
+pub struct EigenDAConfig {
+    pub api_node_url: String,
+    pub custom_quorum_numbers: Option<Vec<u32>>,
+    pub account_id: Option<String>,
+}

core/lib/config/src/configs/da_client/mod.rs

@@ -1,6 +1,11 @@
+use eigen_da::EigenDAConfig;
+
 use crate::{AvailConfig, ObjectStoreConfig};
 
 pub mod avail;
+pub mod eigen_da;
+
+pub const EIGENDA_CLIENT_CONFIG_NAME: &str = "EigenDA";
 
 pub const AVAIL_CLIENT_CONFIG_NAME: &str = "Avail";
 pub const OBJECT_STORE_CLIENT_CONFIG_NAME: &str = "ObjectStore";
@@ -9,4 +14,5 @@ pub const OBJECT_STORE_CLIENT_CONFIG_NAME: &str = "ObjectStore";
 pub enum DAClientConfig {
     Avail(AvailConfig),
     ObjectStore(ObjectStoreConfig),
+    EigenDA(EigenDAConfig),
 }

core/lib/config/src/configs/da_dispatcher.rs

@@ -6,6 +6,7 @@ pub const DEFAULT_POLLING_INTERVAL_MS: u32 = 5000;
 pub const DEFAULT_MAX_ROWS_TO_DISPATCH: u32 = 100;
 pub const DEFAULT_MAX_RETRIES: u16 = 5;
 pub const DEFAULT_USE_DUMMY_INCLUSION_DATA: bool = false;
+pub const DEFAULT_MAX_CONCURRENT_REQUESTS: u32 = 100;
 
 #[derive(Debug, Clone, PartialEq, Deserialize)]
 pub struct DADispatcherConfig {
@@ -19,6 +20,8 @@ pub struct DADispatcherConfig {
     // TODO: run a verification task to check if the L1 contract expects the inclusion proofs to
     // avoid the scenario where contracts expect real proofs, and server is using dummy proofs.
     pub use_dummy_inclusion_data: Option<bool>,
+    /// The maximun number of concurrent request to send to the DA server.
+    pub max_concurrent_requests: Option<u32>,
 }
 
 impl DADispatcherConfig {
@@ -28,6 +31,7 @@ impl DADispatcherConfig {
             max_rows_to_dispatch: Some(DEFAULT_MAX_ROWS_TO_DISPATCH),
             max_retries: Some(DEFAULT_MAX_RETRIES),
             use_dummy_inclusion_data: Some(DEFAULT_USE_DUMMY_INCLUSION_DATA),
+            max_concurrent_requests: Some(DEFAULT_MAX_CONCURRENT_REQUESTS),
         }
     }
 

core/lib/config/src/configs/genesis.rs

@@ -17,6 +17,7 @@ pub struct GenesisConfig {
     pub genesis_commitment: Option<H256>,
     pub bootloader_hash: Option<H256>,
     pub default_aa_hash: Option<H256>,
+    pub evm_emulator_hash: Option<H256>,
     pub l1_chain_id: L1ChainId,
     pub sl_chain_id: Option<SLChainId>,
     pub l2_chain_id: L2ChainId,
@@ -49,6 +50,7 @@ impl GenesisConfig {
             genesis_commitment: Some(H256::repeat_byte(0x17)),
             bootloader_hash: Default::default(),
             default_aa_hash: Default::default(),
+            evm_emulator_hash: Default::default(),
             l1_chain_id: L1ChainId(9),
             sl_chain_id: None,
             protocol_version: Some(ProtocolSemanticVersion {

core/lib/config/src/testonly.rs

@@ -192,6 +192,7 @@ impl Distribution<configs::chain::StateKeeperConfig> for EncodeDist {
             fee_account_addr: None,
             bootloader_hash: None,
             default_aa_hash: None,
+            evm_emulator_hash: None,
             l1_batch_commit_data_generator_mode: Default::default(),
         }
     }
@@ -732,6 +733,7 @@ impl Distribution<configs::GenesisConfig> for EncodeDist {
             genesis_commitment: Some(rng.gen()),
             bootloader_hash: Some(rng.gen()),
             default_aa_hash: Some(rng.gen()),
+            evm_emulator_hash: Some(rng.gen()),
             fee_account: rng.gen(),
             l1_chain_id: L1ChainId(self.sample(rng)),
             sl_chain_id: None,
@@ -966,6 +968,7 @@ impl Distribution<configs::da_dispatcher::DADispatcherConfig> for EncodeDist {
             max_rows_to_dispatch: self.sample(rng),
             max_retries: self.sample(rng),
             use_dummy_inclusion_data: self.sample(rng),
+            max_concurrent_requests: self.sample(rng),
         }
     }
 }

core/lib/constants/src/contracts.rs

@@ -130,6 +130,11 @@ pub const CODE_ORACLE_ADDRESS: Address = H160([
     0x00, 0x00, 0x80, 0x12,
 ]);
 
+pub const EVM_GAS_MANAGER_ADDRESS: Address = H160([
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x80, 0x13,
+]);
+
 /// Note, that the `Create2Factory` is explicitly deployed on a non-system-contract address.
 pub const CREATE2_FACTORY_ADDRESS: Address = H160([
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

core/lib/contracts/src/lib.rs

@@ -293,6 +293,7 @@ fn read_zbin_bytecode_from_path(bytecode_path: PathBuf) -> Vec<u8> {
     fs::read(&bytecode_path)
         .unwrap_or_else(|err| panic!("Can't read .zbin bytecode at {:?}: {}", bytecode_path, err))
 }
+
 /// Hash of code and code which consists of 32 bytes words
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SystemContractCode {
@@ -304,18 +305,23 @@ pub struct SystemContractCode {
 pub struct BaseSystemContracts {
     pub bootloader: SystemContractCode,
     pub default_aa: SystemContractCode,
+    /// Never filled in constructors for now. The only way to get the EVM emulator enabled is to call [`Self::with_evm_emulator()`].
+    pub evm_emulator: Option<SystemContractCode>,
 }
 
 #[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq)]
 pub struct BaseSystemContractsHashes {
     pub bootloader: H256,
     pub default_aa: H256,
+    pub evm_emulator: Option<H256>,
 }
 
 impl PartialEq for BaseSystemContracts {
     fn eq(&self, other: &Self) -> bool {
         self.bootloader.hash == other.bootloader.hash
             && self.default_aa.hash == other.default_aa.hash
+            && self.evm_emulator.as_ref().map(|contract| contract.hash)
+                == other.evm_emulator.as_ref().map(|contract| contract.hash)
     }
 }
 
@@ -339,14 +345,27 @@ impl BaseSystemContracts {
         BaseSystemContracts {
             bootloader,
             default_aa,
+            evm_emulator: None,
         }
     }
-    // BaseSystemContracts with proved bootloader - for handling transactions.
+
+    /// BaseSystemContracts with proved bootloader - for handling transactions.
     pub fn load_from_disk() -> Self {
         let bootloader_bytecode = read_proved_batch_bootloader_bytecode();
         BaseSystemContracts::load_with_bootloader(bootloader_bytecode)
     }
 
+    /// Loads the latest EVM emulator for these base system contracts. Logically, it only makes sense to do for the latest protocol version.
+    pub fn with_latest_evm_emulator(mut self) -> Self {
+        let bytecode = read_sys_contract_bytecode("", "EvmInterpreter", ContractLanguage::Yul);
+        let hash = hash_bytecode(&bytecode);
+        self.evm_emulator = Some(SystemContractCode {
+            code: bytes_to_be_words(bytecode),
+            hash,
+        });
+        self
+    }
+
     /// BaseSystemContracts with playground bootloader - used for handling eth_calls.
     pub fn playground() -> Self {
         let bootloader_bytecode = read_playground_batch_bootloader_bytecode();
@@ -475,6 +494,7 @@ impl BaseSystemContracts {
         BaseSystemContractsHashes {
             bootloader: self.bootloader.hash,
             default_aa: self.default_aa.hash,
+            evm_emulator: self.evm_emulator.as_ref().map(|contract| contract.hash),
         }
     }
 }