feat(eigen-client-extra-features): Small changes

Cargo.toml

@@ -222,6 +222,10 @@ pbjson-types = "0.6.0"
 
 # Eigen
 tokio-stream = "0.1.16"
+rust-kzg-bn254 = "0.2.1"
+ark-bn254 = "0.5.0"
+num-bigint = "0.4.6"
+serial_test = "3.1.1"
 
 # Here and below:
 # We *always* pin the latest version of protocol to disallow accidental changes in the execution logic.

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

@@ -1,10 +1,31 @@
 use serde::Deserialize;
 use zksync_basic_types::secrets::PrivateKey;
-
-#[derive(Clone, Debug, Default, PartialEq, Deserialize)]
+/// Configuration for the EigenDA remote disperser client.
+#[derive(Clone, Debug, PartialEq, Deserialize, Default)]
 pub struct EigenConfig {
-    pub rpc_node_url: String,
-    pub inclusion_polling_interval_ms: u64,
+    /// 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
+    pub settlement_layer_confirmation_depth: i32,
+    /// URL of the Ethereum RPC server
+    pub eigenda_eth_rpc: String,
+    /// Address of the service manager contract
+    pub eigenda_svc_manager_address: String,
+    /// Maximun amount of time in milliseconds to wait for a status query response
+    pub status_query_timeout: u64,
+    /// Interval in milliseconds to query the status of a blob
+    pub status_query_interval: u64,
+    /// Wait for the blob to be finalized before returning the response
+    pub wait_for_finalization: bool,
+    /// Authenticated dispersal
+    pub authenticated: bool,
+    /// Verify the certificate of dispatched blobs
+    pub verify_cert: bool,
+    /// Path to the file containing the points used for KZG
+    pub path_to_points: String,
+    /// Chain ID of the Ethereum network
+    pub chain_id: u64,
 }
 
 #[derive(Clone, Debug, PartialEq)]

core/lib/env_config/src/da_client.rs

@@ -248,17 +248,36 @@ mod tests {
         let mut lock = MUTEX.lock();
         let config = r#"
             DA_CLIENT="Eigen"
-            DA_RPC_NODE_URL="localhost:12345"
-            DA_INCLUSION_POLLING_INTERVAL_MS="1000"
+            DA_EIGEN_CLIENT_TYPE="Disperser"
+            DA_DISPERSER_RPC="http://localhost:8080"
+            DA_SETTLEMENT_LAYER_CONFIRMATION_DEPTH=0
+            DA_EIGENDA_ETH_RPC="http://localhost:8545"
+            DA_EIGENDA_SVC_MANAGER_ADDRESS="0x123"
+            DA_STATUS_QUERY_TIMEOUT=2
+            DA_STATUS_QUERY_INTERVAL=3
+            DA_WAIT_FOR_FINALIZATION=true
+            DA_AUTHENTICATED=false
+            DA_VERIFY_CERT=false
+            DA_PATH_TO_POINTS="resources"
+            DA_CHAIN_ID=1
         "#;
         lock.set_env(config);
 
         let actual = DAClientConfig::from_env().unwrap();
         assert_eq!(
             actual,
             DAClientConfig::Eigen(EigenConfig {
-                rpc_node_url: "localhost:12345".to_string(),
-                inclusion_polling_interval_ms: 1000,
+                disperser_rpc: "http://localhost:8080".to_string(),
+                settlement_layer_confirmation_depth: 0,
+                eigenda_eth_rpc: "http://localhost:8545".to_string(),
+                eigenda_svc_manager_address: "0x123".to_string(),
+                status_query_timeout: 2,
+                status_query_interval: 3,
+                wait_for_finalization: true,
+                authenticated: false,
+                verify_cert: false,
+                path_to_points: "resources".to_string(),
+                chain_id: 1
             })
         );
     }

core/lib/env_config/src/lib.rs

@@ -1,4 +1,3 @@
-use anyhow::Context as _;
 use serde::de::DeserializeOwned;
 
 mod api;
@@ -44,5 +43,5 @@ pub trait FromEnv: Sized {
 pub fn envy_load<T: DeserializeOwned>(name: &str, prefix: &str) -> anyhow::Result<T> {
     envy::prefixed(prefix)
         .from_env()
-        .with_context(|| format!("Cannot load config <{name}>"))
+        .map_err(|e| anyhow::anyhow!("Failed to load {} from env: {}", name, e))
 }

core/lib/protobuf_config/src/da_client.rs

@@ -53,11 +53,31 @@ impl ProtoRepr for proto::DataAvailabilityClient {
                 timeout_ms: *required(&conf.timeout_ms).context("timeout_ms")?,
             }),
             proto::data_availability_client::Config::Eigen(conf) => Eigen(EigenConfig {
-                rpc_node_url: required(&conf.rpc_node_url)
-                    .context("rpc_node_url")?
+                disperser_rpc: required(&conf.disperser_rpc)
+                    .context("disperser_rpc")?
                     .clone(),
-                inclusion_polling_interval_ms: *required(&conf.inclusion_polling_interval_ms)
-                    .context("inclusion_polling_interval_ms")?,
+                settlement_layer_confirmation_depth: *required(
+                    &conf.settlement_layer_confirmation_depth,
+                )
+                .context("settlement_layer_confirmation_depth")?,
+                eigenda_eth_rpc: required(&conf.eigenda_eth_rpc)
+                    .context("eigenda_eth_rpc")?
+                    .clone(),
+                eigenda_svc_manager_address: required(&conf.eigenda_svc_manager_address)
+                    .context("eigenda_svc_manager_address")?
+                    .clone(),
+                status_query_timeout: *required(&conf.status_query_timeout)
+                    .context("status_query_timeout")?,
+                status_query_interval: *required(&conf.status_query_interval)
+                    .context("status_query_interval")?,
+                wait_for_finalization: *required(&conf.wait_for_finalization)
+                    .context("wait_for_finalization")?,
+                authenticated: *required(&conf.authenticated).context("authenticated")?,
+                verify_cert: *required(&conf.verify_cert).context("verify_cert")?,
+                path_to_points: required(&conf.path_to_points)
+                    .context("path_to_points")?
+                    .clone(),
+                chain_id: *required(&conf.chain_id).context("chain_id")?,
             }),
             proto::data_availability_client::Config::ObjectStore(conf) => {
                 ObjectStore(object_store_proto::ObjectStore::read(conf)?)
@@ -96,8 +116,19 @@ impl ProtoRepr for proto::DataAvailabilityClient {
                 })
             }
             Eigen(config) => proto::data_availability_client::Config::Eigen(proto::EigenConfig {
-                rpc_node_url: Some(config.rpc_node_url.clone()),
-                inclusion_polling_interval_ms: Some(config.inclusion_polling_interval_ms),
+                disperser_rpc: Some(config.disperser_rpc.clone()),
+                settlement_layer_confirmation_depth: Some(
+                    config.settlement_layer_confirmation_depth,
+                ),
+                eigenda_eth_rpc: Some(config.eigenda_eth_rpc.clone()),
+                eigenda_svc_manager_address: Some(config.eigenda_svc_manager_address.clone()),
+                status_query_timeout: Some(config.status_query_timeout),
+                status_query_interval: Some(config.status_query_interval),
+                wait_for_finalization: Some(config.wait_for_finalization),
+                authenticated: Some(config.authenticated),
+                verify_cert: Some(config.verify_cert),
+                path_to_points: Some(config.path_to_points.clone()),
+                chain_id: Some(config.chain_id),
             }),
             ObjectStore(config) => proto::data_availability_client::Config::ObjectStore(
                 object_store_proto::ObjectStore::build(config),

core/lib/protobuf_config/src/proto/config/da_client.proto

@@ -37,8 +37,19 @@ message CelestiaConfig {
 }
 
 message EigenConfig {
-  optional string rpc_node_url = 1;
-  optional uint64 inclusion_polling_interval_ms = 2;
+  optional string disperser_rpc = 3;
+  optional int32 settlement_layer_confirmation_depth = 4;
+  optional string eigenda_eth_rpc = 5;
+  optional string eigenda_svc_manager_address = 6;
+  optional uint64 status_query_timeout = 7;
+  optional uint64 status_query_interval = 8;
+  optional bool wait_for_finalization = 9;
+  optional bool authenticated = 10;
+  optional bool verify_cert = 11;
+  optional string path_to_points = 12;
+  optional uint64 chain_id = 13;
+  reserved 1,2;
+  reserved "rpc_node_url","inclusion_polling_interval_ms";
 }
 
 message DataAvailabilityClient {

core/node/da_clients/Cargo.toml

@@ -55,3 +55,14 @@ pbjson-types.workspace = true
 
 # Eigen dependencies
 tokio-stream.workspace = true
+rlp.workspace = true
+rand.workspace = true
+sha3.workspace = true
+tiny-keccak.workspace = true
+ethabi.workspace = true
+rust-kzg-bn254.workspace = true
+ark-bn254.workspace = true
+num-bigint.workspace = true
+serial_test.workspace = true
+zksync_web3_decl.workspace = true
+zksync_eth_client.workspace = true