Added EthClient::Noop to match Charon's implementation

Author: mskrzypkows

crates/cli/src/commands/create_dkg.rs

@@ -331,6 +331,8 @@ async fn run_create_dkg(mut args: CreateDkgArgs) -> Result<(), CreateDkgError> {
         });
     }
 
+    // Taking total number of operators, operator_enrs and operator_addresses are
+    // mutually exclusive so no if statement is needed.
     let num_operators = operators.len() as u64;
     let safe_thresh = safe_threshold(num_operators)?;
     let threshold = if args.threshold == 0 {
@@ -387,10 +389,7 @@ async fn run_create_dkg(mut args: CreateDkgArgs) -> Result<(), CreateDkgError> {
             pluto_cluster::eip712sigs::sign_cluster_definition_hash(key, &def)?;
     }
 
-    // Verify signatures when an ETH1 endpoint is available. Skipped when the
-    // endpoint is empty because the client cannot connect — safe for DKG create
-    // since operators have no signatures at this stage.
-    if !args.publish && !args.execution_engine_addr.is_empty() {
+    if !args.publish {
         let eth1 = pluto_eth1wrap::EthClient::new(&args.execution_engine_addr).await?;
         def.verify_signatures(&eth1).await?;
     }
@@ -541,6 +540,10 @@ fn is_main_or_gnosis(network: &str) -> bool {
     network == MAINNET.name || network == GNOSIS.name
 }
 
+// Ports cluster.Threshold from charon (cluster/helpers.go), which computes
+// ceil(2n/3) using math.Ceil(float64(2*n) / 3). The integer identity
+// ceil(a/b) == (a + b - 1) / b gives ceil(2n/3) == (2n + 2) / 3, producing
+// identical results for all n.
 fn safe_threshold(num_operators: u64) -> Result<u64, CreateDkgError> {
     let two_n = num_operators
         .checked_mul(2)
@@ -752,12 +755,12 @@ mod tests {
     )]
     #[test_case(
         CreateDkgArgs { threshold: 1, ..default_args() },
-        "Create DKG error: threshold must be greater than 1" ;
+        "Create DKG error: threshold must be greater than 1 (threshold=1, min=2)" ;
         "threshold_below_minimum"
     )]
     #[test_case(
         CreateDkgArgs { operator_enrs: VALID_ENRS[..3].iter().map(|s| s.to_string()).collect(), threshold: 4, ..default_args() },
-        "Create DKG error: threshold cannot be greater than number of operators" ;
+        "Create DKG error: threshold (4) cannot be greater than number of operators (3)" ;
         "threshold_above_maximum"
     )]
     #[tokio::test]

crates/dkg/src/disk.rs

@@ -551,8 +551,6 @@ mod tests {
     }
 
     async fn noop_eth1_client() -> pluto_eth1wrap::EthClient {
-        pluto_eth1wrap::EthClient::new("http://0.0.0.0:0")
-            .await
-            .unwrap()
+        pluto_eth1wrap::EthClient::new("").await.unwrap()
     }
 }

crates/eth1wrap/src/lib.rs

@@ -33,23 +33,32 @@ pub enum EthClientError {
     /// The Ethereum Address was invalid.
     #[error("Invalid address: {0}")]
     InvalidAddress(#[from] alloy::primitives::AddressError),
+
+    /// No execution engine endpoint was configured.
+    #[error("execution engine endpoint is not set")]
+    NoExecutionEngineAddr,
 }
 
 /// Defines the interface for the Ethereum EL RPC client.
-pub struct EthClient(DynProvider);
-
-impl std::ops::Deref for EthClient {
-    type Target = DynProvider;
-
-    fn deref(&self) -> &DynProvider {
-        &self.0
-    }
+pub enum EthClient {
+    /// Connected client backed by a live provider.
+    Connected(DynProvider),
+    /// Noop client returned when no address is provided. Mirrors Go's
+    /// noopClient.
+    Noop,
 }
 
 impl EthClient {
-    /// Create a new `EthClient` connected to the given address using defaults
-    /// for retry.
+    /// Create a new `EthClient`. When `address` is empty a noop client is
+    /// returned that errors with [`EthClientError::NoExecutionEngineAddr`]
+    /// if `verify_smart_contract_based_signature` is ever called, matching
+    /// Go's `NewDefaultEthClientRunner("")` behaviour.
     pub async fn new(address: impl AsRef<str>) -> Result<EthClient> {
+        let address = address.as_ref();
+        if address.is_empty() {
+            return Ok(EthClient::Noop);
+        }
+
         // The maximum number of retries for rate limit errors.
         const MAX_RETRY: u32 = 10;
         // The initial backoff in milliseconds.
@@ -61,12 +70,12 @@ impl EthClient {
 
         let client = ClientBuilder::default()
             .layer(retry_layer)
-            .connect(address.as_ref())
+            .connect(address)
             .await?;
 
         let provider = ProviderBuilder::new().connect_client(client);
 
-        Ok(EthClient(provider.erased()))
+        Ok(EthClient::Connected(provider.erased()))
     }
 
     /// Check if `sig` is a valid signature of `hash` according to ERC-1271.
@@ -76,12 +85,16 @@ impl EthClient {
         hash: [u8; 32],
         sig: &[u8],
     ) -> Result<bool> {
+        let EthClient::Connected(provider) = self else {
+            return Err(EthClientError::NoExecutionEngineAddr);
+        };
+
         // Magic value defined in [ERC-1271](https://eips.ethereum.org/EIPS/eip-1271).
         const MAGIC_VALUE: [u8; 4] = [0x16, 0x26, 0xba, 0x7e];
 
         let address = alloy::primitives::Address::parse_checksummed(contract_address, None)?;
 
-        let instance = IERC1271::new(address, &self.0);
+        let instance = IERC1271::new(address, provider);
 
         let call = instance
             .isValidSignature(hash.into(), sig.to_vec().into())