feat(eigenda): EigenDA V2 M0 (#3983)

## What ❔
This PR modifies the client for EigenDA, adding the option to use
EigenDA V2.

It replaces the old v1 crate `rust-eigenda-client` for the new v2 crate
`rust-eigenda-v2-client`.

It modifies the `EigenConfig` to leave only the necessary fields for v2.
It removes:
- `settlement_layer_confirmation_depth`
- `eigenda_svc_manager_address`
- `wait_for_finalization`
- `points`
- `custom_quorum_numbers`

It adds:
- `cert_verifier_router_addr`
- `blob_version`
- `polynomial_form`
- `operator_state_retriever_addr`
- `registry_coordinator_addr`

The client now uses a `PayloadDisperser` to disperse the blobs, with the
`send_payload` method.
And uses the `get_cert` method to get the inclusion data.

How to test:

```bash
zkstackup --local
```


Modify `etc/env/file_based/overrides/validium.yaml`:

```yaml
da_dispatcher:
  use_dummy_inclusion_data: true
da_client:
  client: Eigen
  disperser_rpc: <your_disperser_rpc>
  eigenda_eth_rpc: <your_eth_rpc> 
  authenticated: true
  cert_verifier_router_addr: <your_cert_verifier_address> 
  operator_state_retriever_addr: <your_operator_state_retriever_addr>
  registry_coordinator_addr: <your_registry_coordinator_addr>
  blob_version: <your_blob_version> 
  polynomial_form: <your_polynomial_form> #Either coeff or eval
```

Modify `etc/env/file_based/secrets.yaml`:

```yaml
da:
  client: Eigen
  private_key: <your_private_key> #The private key you want to use with the eigenda disperser
```

Run replacing with your l1 rpc:

```bash
zkstack containers --observability true

zkstack chain create \
          --chain-name eigenda \
          --chain-id sequential \
          --prover-mode no-proofs \
          --wallet-creation localhost \
          --l1-batch-commit-data-generator-mode validium \
          --base-token-address 0x0000000000000000000000000000000000000001 \
          --base-token-price-nominator 1 \
          --base-token-price-denominator 1 \
          --set-as-default false

zkstack ecosystem init \
          --deploy-paymaster true \
          --deploy-erc20 true \
          --deploy-ecosystem true \
          --l1-rpc-url <your_l1_rpc> \
          --server-db-url=postgres://postgres:notsecurepassword@localhost:5432 \
          --server-db-name=zksync_server_localhost_eigenda \
          --chain eigenda \
          --verbose
```

Then run

```bash
zkstack server --chain eigenda
```

<!-- What are the changes this PR brings about? -->
<!-- Example: This PR adds a PR template to the repo. -->
<!-- (For bigger PRs adding more context is appreciated) -->

## Why ❔
To support the latest version of EigenDA (V2 M0), while preserving
compatibility with the existing client (V1 M0).
<!-- Why are these changes done? What goal do they contribute to? What
are the principles behind them? -->
<!-- The `Why` has to be clear to non-Matter Labs entities running their
own ZK Chain -->
<!-- Example: PR templates ensure PR reviewers, observers, and future
iterators are in context about the evolution of repos. -->

## Is this a breaking change?
- [x] Yes
- [ ] No

## Operational changes
<!-- Any config changes? Any new flags? Any changes to any scripts? -->
<!-- Please add anything that non-Matter Labs entities running their own
ZK Chain may need to know -->

## Checklist

<!-- Check your PR fulfills the following items. -->
<!-- For draft PRs check the boxes as you complete them. -->

- [ ] PR title corresponds to the body of PR (we generate changelog
entries from PRs).
- [ ] Tests for the changes have been added / updated.
- [ ] Documentation comments have been added / updated.
- [ ] Code has been formatted via `zkstack dev fmt` and `zkstack dev
lint`.

---------

Co-authored-by: juan518munoz <[email protected]>
Co-authored-by: Juan Munoz <[email protected]>
Co-authored-by: Juan Bono <[email protected]>

Author: 3 people

core/Cargo.lock

@@ -238,8 +238,10 @@ ripemd = "0.1.3"
 tonic = { version = "0.11.0", default-features = false }
 pbjson-types = "0.6.0"
 
-# Eigen
-rust-eigenda-client = "0.1.6"
+# EigenDA
+rust-eigenda-v2-client = "=0.1.4"
+rust-eigenda-v2-common = "=0.1.3"
+rust-eigenda-signers = "0.1.6"
 
 # Here and below:
 # We *always* pin the latest version of protocol to disallow accidental changes in the execution logic.

core/Cargo.toml

@@ -14,7 +14,7 @@ use smart_config::{testing::Tester, value::ExposeSecret, ByteSize, ConfigSource,
 use zksync_config::{
     configs::{
         api::{MaxResponseSizeOverrides, Namespace},
-        da_client::{avail::AvailClientConfig, eigen::PointsSource},
+        da_client::avail::AvailClientConfig,
         database::MerkleTreeMode,
         object_store::ObjectStoreMode,
         observability::LogFormat,
@@ -647,14 +647,11 @@ fn eigen_da_client_from_env() {
     let env = r#"
         EN_DA_CLIENT="Eigen"
         EN_DA_DISPERSER_RPC="http://localhost:8080"
-        EN_DA_SETTLEMENT_LAYER_CONFIRMATION_DEPTH=0
         EN_DA_EIGENDA_ETH_RPC="http://localhost:8545"
-        EN_DA_EIGENDA_SVC_MANAGER_ADDRESS="0x0000000000000000000000000000000000000123"
-        EN_DA_WAIT_FOR_FINALIZATION=true
-        EN_DA_AUTHENTICATED=false
-        EN_DA_POINTS_SOURCE="Path"
-        EN_DA_POINTS_PATH="resources"
-        EN_DA_CUSTOM_QUORUM_NUMBERS="2"
+        EN_DA_CERT_VERIFIER_ROUTER_ADDR="0x0000000000000000000000000000000000000123"
+        EN_DA_OPERATOR_STATE_RETRIEVER_ADDR="0x0000000000000000000000000000000000000124"
+        EN_DA_REGISTRY_COORDINATOR_ADDR="0x0000000000000000000000000000000000000125"
+        EN_DA_BLOB_VERSION="0"
 
         # Secrets
         EN_DA_SECRETS_PRIVATE_KEY="f55baf7c0e4e33b1d78fbf52f069c426bc36cff1aceb9bc8f45d14c07f034d73"
@@ -671,24 +668,23 @@ fn eigen_da_client_from_env() {
         panic!("unexpected config: {config:?}");
     };
     assert_eq!(config.disperser_rpc, "http://localhost:8080");
-    assert_eq!(config.settlement_layer_confirmation_depth, 0);
     assert_eq!(
         config.eigenda_eth_rpc.as_ref().unwrap().expose_str(),
         "http://localhost:8545/"
     );
+    assert_eq!(config.blob_version, 0);
     assert_eq!(
-        config.eigenda_svc_manager_address,
+        config.cert_verifier_router_addr,
         "0x0000000000000000000000000000000000000123"
-            .parse()
-            .unwrap()
     );
-    assert!(config.wait_for_finalization);
-    assert!(!config.authenticated);
-    let PointsSource::Path { path } = &config.points else {
-        panic!("unexpected points: {config:?}");
-    };
-    assert_eq!(path, "resources");
-    assert_eq!(config.custom_quorum_numbers, [2]);
+    assert_eq!(
+        config.operator_state_retriever_addr,
+        "0x0000000000000000000000000000000000000124"
+    );
+    assert_eq!(
+        config.registry_coordinator_addr,
+        "0x0000000000000000000000000000000000000125"
+    );
 
     let secrets: DataAvailabilitySecrets = tester.for_config().test_complete(env.clone()).unwrap();
     let DataAvailabilitySecrets::Eigen(secrets) = secrets else {

core/bin/external_node/src/config/tests/mod.rs

@@ -33,7 +33,9 @@ allow = [
     "Apache-2.0 WITH LLVM-exception",
     "0BSD",
     "BSL-1.0",
-    "Unicode-3.0"
+    "Unicode-3.0",
+    "BUSL-1.1",
+    "CDLA-Permissive-2.0"
 ]
 confidence-threshold = 0.8
 

core/deny.toml

@@ -1,46 +1,35 @@
+use serde::Deserialize;
 use smart_config::{
-    de::{Delimited, FromSecretString, Optional, Serde},
+    de::{FromSecretString, Optional, Serde},
     DescribeConfig, DeserializeConfig,
 };
-use zksync_basic_types::{secrets::PrivateKey, url::SensitiveUrl, Address};
-
-#[derive(Clone, Debug, PartialEq, DescribeConfig, DeserializeConfig)]
-#[config(tag = "source")]
-pub enum PointsSource {
-    Path { path: String },
-    Url { g1_url: String, g2_url: String },
-}
+use zksync_basic_types::{secrets::PrivateKey, url::SensitiveUrl};
 
 /// Configuration for the EigenDA remote disperser client.
-#[derive(Clone, Debug, PartialEq, DescribeConfig, DeserializeConfig)]
+///
+/// This configuration is meant to be used by the EigenDA V2 client.
+/// It is an insecure integration, where the dispersal is not verified.
+#[derive(Clone, Debug, PartialEq, Deserialize, DescribeConfig, DeserializeConfig)]
 pub struct EigenConfig {
     /// URL of the Disperser RPC server
     pub disperser_rpc: String,
-    /// Block height needed to reach in order to consider the blob finalized
-    /// a value less or equal to 0 means that the disperser will not wait for finalization
-    #[config(default_t = 0)]
-    pub settlement_layer_confirmation_depth: u32,
     /// URL of the Ethereum RPC server
     #[config(secret, with = Optional(Serde![str]))]
     pub eigenda_eth_rpc: Option<SensitiveUrl>,
-    /// Address of the service manager contract
-    pub eigenda_svc_manager_address: Address,
-    /// Wait for the blob to be finalized before returning the response
-    #[config(default_t = true)]
-    pub wait_for_finalization: bool,
-    /// Authenticated dispersal
-    #[config(default_t = true)]
-    pub authenticated: bool,
-    /// Points source
-    #[config(nest)]
-    pub points: PointsSource,
-    /// Custom quorum numbers
-    #[config(default, with = Delimited(","))]
-    pub custom_quorum_numbers: Vec<u8>,
+    /// Address of the EigenDA cert verifier router
+    pub cert_verifier_router_addr: String,
+    /// Blob version
+    pub blob_version: u16,
+    /// Address of the operator state retriever
+    pub operator_state_retriever_addr: String,
+    /// Address of the registry coordinator
+    pub registry_coordinator_addr: String,
 }
 
+/// Configuration for the EigenDA secrets.
 #[derive(Clone, Debug, DescribeConfig, DeserializeConfig)]
 pub struct EigenSecrets {
+    /// Private key used for dispersing the blobs
     #[config(with = FromSecretString)]
     pub private_key: PrivateKey,
 }

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

@@ -33,7 +33,7 @@ mod tests {
         ConfigRepository, ConfigSchema, Environment, Yaml,
     };
 
-    use super::{avail::AvailClientConfig, eigen::PointsSource, *};
+    use super::{avail::AvailClientConfig, *};
     use crate::configs::{object_store::ObjectStoreMode, DataAvailabilitySecrets, Secrets};
 
     #[test]
@@ -295,14 +295,11 @@ mod tests {
         let env = r#"
           DA_CLIENT="Eigen"
           DA_DISPERSER_RPC="http://localhost:8080"
-          DA_SETTLEMENT_LAYER_CONFIRMATION_DEPTH=0
           DA_EIGENDA_ETH_RPC="http://localhost:8545"
-          DA_EIGENDA_SVC_MANAGER_ADDRESS="0x0000000000000000000000000000000000000123"
-          DA_WAIT_FOR_FINALIZATION=true
-          DA_AUTHENTICATED=false
-          DA_POINTS_SOURCE="Path"
-          DA_POINTS_PATH="./resources"
-          DA_CUSTOM_QUORUM_NUMBERS="2,3"
+          DA_CERT_VERIFIER_ROUTER_ADDR="0x0000000000000000000000000000000000000123"
+          DA_OPERATOR_STATE_RETRIEVER_ADDR="0x0000000000000000000000000000000000000124"
+          DA_REGISTRY_COORDINATOR_ADDR="0x0000000000000000000000000000000000000125"
+          DA_BLOB_VERSION="0"
         "#;
         let env = Environment::from_dotenv("test.env", env)
             .unwrap()
@@ -314,38 +311,36 @@ mod tests {
         };
 
         assert_eq!(config.disperser_rpc, "http://localhost:8080");
-        assert_eq!(config.settlement_layer_confirmation_depth, 0);
         assert_eq!(
             config.eigenda_eth_rpc.as_ref().unwrap().expose_str(),
             "http://localhost:8545/"
         );
-        assert!(config.wait_for_finalization);
-        assert!(!config.authenticated);
 
-        let PointsSource::Path { path } = &config.points else {
-            panic!("Unexpected config: {config:?}");
-        };
-        assert_eq!(path, "./resources");
-        assert_eq!(config.custom_quorum_numbers, [2, 3]);
+        assert_eq!(config.blob_version, 0);
+        assert_eq!(
+            config.cert_verifier_router_addr,
+            "0x0000000000000000000000000000000000000123"
+        );
+        assert_eq!(
+            config.operator_state_retriever_addr,
+            "0x0000000000000000000000000000000000000124"
+        );
+        assert_eq!(
+            config.registry_coordinator_addr,
+            "0x0000000000000000000000000000000000000125"
+        );
     }
 
     #[test]
     fn eigen_config_from_yaml() {
         let yaml = r#"
-          client: Eigen
-          disperser_rpc: https://disperser-holesky.eigenda.xyz:443
-          settlement_layer_confirmation_depth: 1
-          eigenda_eth_rpc: https://holesky.infura.io/
-          eigenda_svc_manager_address: 0xD4A7E1Bd8015057293f0D0A557088c286942e84b
-          wait_for_finalization: true
-          authenticated: true
-          points:
-            source: Url
-            g1_url: https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g1.point
-            g2_url: https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g2.point.powerOf2
-          custom_quorum_numbers:
-            - 1
-            - 3
+            client: Eigen
+            disperser_rpc: https://disperser-holesky.eigenda.xyz:443
+            eigenda_eth_rpc: https://holesky.infura.io/
+            cert_verifier_router_addr: "0x0000000000000000000000000000000000000123"
+            operator_state_retriever_addr: "0x0000000000000000000000000000000000000124"
+            registry_coordinator_addr: "0x0000000000000000000000000000000000000125"
+            blob_version: 0
         "#;
         let yaml = Yaml::new("test.yml", serde_yaml::from_str(yaml).unwrap()).unwrap();
 
@@ -361,40 +356,36 @@ mod tests {
             config.disperser_rpc,
             "https://disperser-holesky.eigenda.xyz:443"
         );
-        assert_eq!(config.settlement_layer_confirmation_depth, 1);
         assert_eq!(
             config.eigenda_eth_rpc.as_ref().unwrap().expose_str(),
             "https://holesky.infura.io/"
         );
+
+        assert_eq!(config.blob_version, 0);
         assert_eq!(
-            config.eigenda_svc_manager_address,
-            "0xD4A7E1Bd8015057293f0D0A557088c286942e84b"
-                .parse()
-                .unwrap()
+            config.cert_verifier_router_addr,
+            "0x0000000000000000000000000000000000000123"
+        );
+        assert_eq!(
+            config.operator_state_retriever_addr,
+            "0x0000000000000000000000000000000000000124"
+        );
+        assert_eq!(
+            config.registry_coordinator_addr,
+            "0x0000000000000000000000000000000000000125"
         );
-        assert!(config.wait_for_finalization);
-        assert!(config.authenticated);
-        let PointsSource::Url { g1_url, g2_url } = &config.points else {
-            panic!("Unexpected config: {config:?}");
-        };
-        assert_eq!(g1_url, "https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g1.point");
-        assert_eq!(g2_url, "https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g2.point.powerOf2");
     }
 
     #[test]
     fn eigen_config_from_yaml_with_enum_coercion() {
         let yaml = r#"
           eigen:
             disperser_rpc: https://disperser-holesky.eigenda.xyz:443
-            settlement_layer_confirmation_depth: 1
             eigenda_eth_rpc: https://holesky.infura.io/
-            eigenda_svc_manager_address: 0xD4A7E1Bd8015057293f0D0A557088c286942e84b
-            wait_for_finalization: true
-            authenticated: true
-            points: # This still doesn't correspond to the previous schema!
-              url:
-                g1_url: https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g1.point
-                g2_url: https://raw.githubusercontent.com/lambdaclass/zksync-eigenda-tools/6944c9b09ae819167ee9012ca82866b9c792d8a1/resources/g2.point.powerOf2
+            blob_version: 0
+            cert_verifier_router_addr: "0x0000000000000000000000000000000000000123"
+            operator_state_retriever_addr: "0x0000000000000000000000000000000000000124"
+            registry_coordinator_addr: "0x0000000000000000000000000000000000000125"
         "#;
         let yaml = Yaml::new("test.yml", serde_yaml::from_str(yaml).unwrap()).unwrap();
 

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

@@ -404,52 +404,6 @@ impl DataAvailabilityDal<'_, '_> {
         Ok(row.map(|row| L1BatchNumber(row.l1_batch_number as u32)))
     }
 
-    /// Fetches the pubdata for the L1 batch with a given blob id.
-    pub async fn get_blob_data_by_blob_id(
-        &mut self,
-        blob_id: &str,
-    ) -> DalResult<Option<L1BatchDA>> {
-        let row = sqlx::query!(
-            r#"
-            SELECT
-                number,
-                pubdata_input,
-                system_logs,
-                sealed_at
-            FROM
-                l1_batches
-            LEFT JOIN
-                data_availability
-                ON data_availability.l1_batch_number = l1_batches.number
-            WHERE
-                number != 0
-                AND data_availability.blob_id = $1
-            ORDER BY
-                number
-            LIMIT
-                1
-            "#,
-            blob_id,
-        )
-        .instrument("get_blob_data_by_blob_id")
-        .with_arg("blob_id", &blob_id)
-        .fetch_optional(self.storage)
-        .await?
-        .map(|row| L1BatchDA {
-            // `unwrap` is safe here because we have a `WHERE` clause that filters out `NULL` values
-            pubdata: row.pubdata_input.unwrap(),
-            l1_batch_number: L1BatchNumber(row.number as u32),
-            sealed_at: row.sealed_at.unwrap().and_utc(),
-            system_logs: row
-                .system_logs
-                .into_iter()
-                .map(|raw_log| L2ToL1Log::from_slice(&raw_log))
-                .collect(),
-        });
-
-        Ok(row)
-    }
-
     pub async fn set_dummy_inclusion_data_for_old_batches(
         &mut self,
         current_l2_da_validator: Address,

core/lib/dal/src/data_availability_dal.rs

@@ -173,6 +173,7 @@ impl<DB: PruneDatabase, H: HashTree> MerkleTreeRecovery<DB, H> {
             %entries.key_range = entries_key_range(&entries),
         ),
     )]
+    #[allow(clippy::missing_errors_doc)]
     pub fn extend_linear(&mut self, entries: Vec<TreeEntry>) -> anyhow::Result<()> {
         tracing::debug!("Started extending tree");
         RECOVERY_METRICS.chunk_size.observe(entries.len());
@@ -200,6 +201,7 @@ impl<DB: PruneDatabase, H: HashTree> MerkleTreeRecovery<DB, H> {
             entries.len = entries.len(),
         ),
     )]
+    #[allow(clippy::missing_errors_doc)]
     pub fn extend_random(&mut self, entries: Vec<TreeEntry>) -> anyhow::Result<()> {
         tracing::debug!("Started extending tree");
         RECOVERY_METRICS.chunk_size.observe(entries.len());
@@ -223,7 +225,11 @@ impl<DB: PruneDatabase, H: HashTree> MerkleTreeRecovery<DB, H> {
         skip_all,
         fields(recovered_version = self.recovered_version),
     )]
-    #[allow(clippy::missing_panics_doc, clippy::range_plus_one)]
+    #[allow(
+        clippy::missing_panics_doc,
+        clippy::range_plus_one,
+        clippy::missing_errors_doc
+    )]
     pub fn finalize(mut self) -> anyhow::Result<DB> {
         let mut manifest = self.db.manifest().unwrap();
         // ^ `unwrap()` is safe: manifest is inserted into the DB on creation

core/lib/merkle_tree/src/recovery/mod.rs

@@ -93,6 +93,7 @@ impl StaleKeysRepairTask {
 
     /// Runs stale key detection for a single tree version.
     #[tracing::instrument(skip(db))]
+    #[allow(clippy::missing_errors_doc, clippy::missing_panics_doc)]
     pub fn bogus_stale_keys(db: &RocksDBWrapper, version: u64) -> Vec<NodeKey> {
         const SAMPLE_COUNT: usize = 5;
 

core/lib/merkle_tree/src/repair.rs

@@ -161,6 +161,7 @@ impl CommonStorage<'static> {
     /// Creates a storage snapshot. Require protective reads to be persisted for the batch, otherwise
     /// will return `Ok(None)`.
     #[tracing::instrument(skip(connection))]
+    #[allow(clippy::missing_errors_doc, clippy::missing_panics_doc)]
     pub async fn snapshot(
         connection: &mut Connection<'static, Core>,
         l1_batch_number: L1BatchNumber,