fix(cketh): report the ETH minimum deposit in get_minter_info

The live harness read the ETH scan minimum through deposit_eth, which
registers the caller's deposit address as a side effect. The minter now
reports the minimum as a backward-compatible minimum_eth_deposit_amount
field in get_minter_info, and the harness reads both asset minimums
through one side-effect-free method generic over Into<Asset>.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EaB5zAqurYgyPNDyYkcqoD

Author: gregorydemay

rs/ethereum/cketh/minter/cketh_minter.did

@@ -254,6 +254,10 @@ type MinterInfo = record {
     // balance scan to treat it as a deposit candidate. A smaller balance is never detected.
     minimum_deposit_amounts : opt vec record { erc20_contract_address: text; minimum_deposit_amount: nat};
 
+    // Minimum balance, in wei, that a deposit address must hold for the
+    // balance scan to treat it as an ETH deposit candidate. A smaller balance is never detected.
+    minimum_eth_deposit_amount : opt nat;
+
     // Last scraped block number for logs of the ETH helper contract.
     last_eth_scraped_block_number: opt nat;
 

rs/ethereum/cketh/minter/src/endpoints.rs

@@ -87,6 +87,7 @@ pub struct MinterInfo {
     pub last_gas_fee_estimate: Option<GasFeeEstimate>,
     pub erc20_balances: Option<Vec<Erc20Balance>>,
     pub minimum_deposit_amounts: Option<Vec<Erc20MinimumDeposit>>,
+    pub minimum_eth_deposit_amount: Option<Nat>,
     pub last_eth_scraped_block_number: Option<Nat>,
     pub last_erc20_scraped_block_number: Option<Nat>,
     pub last_deposit_with_subaccount_scraped_block_number: Option<Nat>,

rs/ethereum/cketh/minter/src/main.rs

@@ -411,6 +411,7 @@ async fn get_minter_info() -> MinterInfo {
             ),
             erc20_balances,
             minimum_deposit_amounts,
+            minimum_eth_deposit_amount: Some(min_deposit(&Asset::Eth).into()),
             last_eth_scraped_block_number,
             last_erc20_scraped_block_number,
             last_deposit_with_subaccount_scraped_block_number,

rs/ethereum/cketh/minter/tests/ckerc20.rs

@@ -2365,6 +2365,7 @@ fn should_retrieve_minter_info() {
         .collect();
 
     const USD_STABLECOIN_MINIMUM_DEPOSIT: u64 = 10_000_000;
+    const MINIMUM_ETH_DEPOSIT_WEI: u64 = 5_000_000_000_000_000;
     let minimum_deposit_amounts = supported_ckerc20_tokens
         .iter()
         .map(|token| Erc20MinimumDeposit {
@@ -2398,6 +2399,7 @@ fn should_retrieve_minter_info() {
             last_gas_fee_estimate: None,
             erc20_balances: Some(erc20_balances),
             minimum_deposit_amounts: Some(minimum_deposit_amounts),
+            minimum_eth_deposit_amount: Some(Nat::from(MINIMUM_ETH_DEPOSIT_WEI)),
             last_eth_scraped_block_number: Some(LAST_SCRAPED_BLOCK_NUMBER_AT_INSTALL.into()),
             last_erc20_scraped_block_number: Some(LAST_SCRAPED_BLOCK_NUMBER_AT_INSTALL.into()),
             last_deposit_with_subaccount_scraped_block_number: Some(

rs/ethereum/cketh/minter/tests/cketh.rs

@@ -1192,6 +1192,8 @@ fn should_derive_minter_address() {
 #[allow(deprecated)]
 #[test]
 fn should_retrieve_minter_info() {
+    const MINIMUM_ETH_DEPOSIT_WEI: u64 = 5_000_000_000_000_000;
+
     let cketh = CkEthSetup::default();
     let max_eth_logs_block_range = cketh.max_logs_block_range();
     let caller: Principal = cketh.caller.into();
@@ -1223,6 +1225,7 @@ fn should_retrieve_minter_info() {
             last_gas_fee_estimate: None,
             erc20_balances: None,
             minimum_deposit_amounts: None,
+            minimum_eth_deposit_amount: Some(Nat::from(MINIMUM_ETH_DEPOSIT_WEI)),
             last_eth_scraped_block_number: Some(LAST_SCRAPED_BLOCK_NUMBER_AT_INSTALL.into()),
             last_erc20_scraped_block_number: Some(LAST_SCRAPED_BLOCK_NUMBER_AT_INSTALL.into()),
             last_deposit_with_subaccount_scraped_block_number: Some(

rs/ethereum/cketh/minter/tests/deposit_from_cex.rs

@@ -8,6 +8,7 @@
 //!    principal and subaccount.
 
 use assert_matches::assert_matches;
+use ic_cketh_minter::asset::Asset;
 use ic_cketh_minter::balance_scan::batcher::{
     BalanceOfCall, MAX_CALLS_PER_BATCH, decode_balance_batch, encode_balance_batch,
     encode_eth_balance_batch,
@@ -21,7 +22,7 @@ use ic_cketh_test_utils::anvil::{
 };
 use ic_cketh_test_utils::ckerc20::{CkErc20Setup, Erc20Token};
 use ic_cketh_test_utils::live::{
-    CexDeposit, DepositPlan, EthCexDeposit, EthDepositPlan, LiveSetup,
+    CexDeposit, DepositPlan, EthCexDeposit, EthDepositPlan, LiveSetup, contract_address,
 };
 use ic_cketh_test_utils::{CkEthSetup, SWEEPER_ADDRESS};
 use ic_ethereum_types::Address;
@@ -305,9 +306,9 @@ fn should_flag_only_erc20_deposits_at_or_above_the_per_token_minimum() {
         .supported_erc20_tokens_owned()
         .try_into()
         .expect("expected exactly 2 supported tokens");
-    let usdt_minimum = setup.minimum_deposit_amount(&usdt);
+    let usdt_minimum = setup.minimum_deposit_amount(contract_address(&usdt));
     let usdt_above_minimum = 2 * usdt_minimum;
-    let usdc_at_minimum = setup.minimum_deposit_amount(&usdc);
+    let usdc_at_minimum = setup.minimum_deposit_amount(contract_address(&usdc));
     let usdt_below_minimum = usdt_minimum / 10;
     let plans = [
         (setup.depositor(1), usdt.clone(), usdt_above_minimum),
@@ -372,9 +373,9 @@ fn should_credit_mixed_erc20_and_eth_deposits_through_one_sweep_per_asset() {
     let erc20_only = (setup.depositor(1), [1_u8; 32]);
     let both_assets = (setup.depositor(2), [2_u8; 32]);
     let eth_only = (setup.depositor(3), [3_u8; 32]);
-    let usdc_amount = 3 * setup.minimum_deposit_amount(&usdc);
-    let usdt_amount = 5 * setup.minimum_deposit_amount(&usdt);
-    let eth_minimum = setup.minimum_eth_deposit_amount(both_assets.0, both_assets.1);
+    let usdc_amount = 3 * setup.minimum_deposit_amount(contract_address(&usdc));
+    let usdt_amount = 5 * setup.minimum_deposit_amount(contract_address(&usdt));
+    let eth_minimum = setup.minimum_deposit_amount(Asset::Eth);
     let both_eth_amount = 4 * eth_minimum;
     let eth_only_amount = 7 * eth_minimum;
 
@@ -463,7 +464,7 @@ fn should_flag_only_eth_deposits_at_or_above_the_minimum() {
     const DEPOSIT_SUBACCOUNT: [u8; 32] = [42; 32];
 
     let setup = LiveSetup::<CkErc20Setup>::new();
-    let minimum = setup.minimum_eth_deposit_amount(setup.depositor(1), DEPOSIT_SUBACCOUNT);
+    let minimum = setup.minimum_deposit_amount(Asset::Eth);
     let above_minimum = 2 * minimum;
     let at_minimum = minimum;
     let below_minimum = minimum / 10;
@@ -543,8 +544,8 @@ fn should_credit_twenty_erc20_deposits_through_one_sweep_per_token() {
         .supported_erc20_tokens_owned()
         .try_into()
         .expect("expected exactly 2 supported tokens");
-    let usdc_deposit = 10 * setup.minimum_deposit_amount(&usdc);
-    let usdt_deposit = 15 * setup.minimum_deposit_amount(&usdt);
+    let usdc_deposit = 10 * setup.minimum_deposit_amount(contract_address(&usdc));
+    let usdt_deposit = 15 * setup.minimum_deposit_amount(contract_address(&usdt));
 
     // Every depositor gets a distinct principal and a distinct subaccount, so no two share a
     // deposit address and each attestation binds a different account.
@@ -607,7 +608,7 @@ fn should_credit_twenty_eth_deposits_through_ten_deposit_sweeps() {
     let funded_gas = setup.anvil_eth_balance(&sweeper);
     let delegate = setup.sweep_contracts().delegate;
     let minter_eth_before = setup.minter_eth_balance();
-    let eth_minimum = setup.minimum_eth_deposit_amount(setup.depositor(0), [0; 32]);
+    let eth_minimum = setup.minimum_deposit_amount(Asset::Eth);
 
     let plans: Vec<EthDepositPlan> = (0..DEPOSITORS)
         .map(|index| EthDepositPlan {
@@ -660,7 +661,7 @@ fn should_sweep_a_second_eth_deposit_despite_resending_a_stale_authorization() {
     let mints_before = setup
         .minter_count_events(|event| matches!(event.payload, EventPayload::MintedCkEth { .. }));
     let owner = setup.depositor(1);
-    let eth_minimum = setup.minimum_eth_deposit_amount(owner, DEPOSIT_SUBACCOUNT);
+    let eth_minimum = setup.minimum_deposit_amount(Asset::Eth);
 
     let (setup, first_deposits) = setup
         .call_minter_deposit_eth([EthDepositPlan {
@@ -759,7 +760,7 @@ fn should_sweep_a_second_erc20_deposit_despite_resending_a_stale_authorization()
         .supported_erc20_tokens_owned()
         .try_into()
         .expect("expected exactly 2 supported tokens");
-    let usdc_minimum = setup.minimum_deposit_amount(&usdc);
+    let usdc_minimum = setup.minimum_deposit_amount(contract_address(&usdc));
     let owner = setup.depositor(1);
 
     let (setup, first_deposits) = setup

rs/ethereum/cketh/test_utils/src/live.rs

@@ -50,6 +50,7 @@
 
 use candid::{Decode, Encode, Nat, Principal};
 use ic_base_types::PrincipalId;
+use ic_cketh_minter::asset::Asset;
 use ic_cketh_minter::endpoints::events::{
     Asset as EventAsset, Event, EventPayload, TransactionStatus,
 };
@@ -253,36 +254,38 @@ impl LiveSetup<CkErc20Setup> {
         self.fixture.supported_erc20_tokens.clone()
     }
 
-    pub fn minimum_deposit_amount(&self, token: &Erc20Token) -> u128 {
-        let minimum = self
-            .get_minter_info()
-            .minimum_deposit_amounts
-            .expect("BUG: the minter reports no minimum deposit amounts")
-            .into_iter()
-            .find(|minimum| {
-                Address::from_str(&minimum.erc20_contract_address)
-                    .expect("BUG: the minter reported an invalid token address")
-                    == contract_address(token)
-            })
-            .unwrap_or_else(|| {
-                panic!(
-                    "BUG: the minter reports no minimum deposit amount for {}",
-                    token.contract.address
-                )
-            });
-        let no_minimum_sentinel: Nat = Erc20Value::MAX.into();
-        assert_ne!(
-            minimum.minimum_deposit_amount, no_minimum_sentinel,
-            "the minter reports no real minimum deposit amount for {}",
-            token.contract.address
-        );
-        nat_to_u128(minimum.minimum_deposit_amount)
-    }
-
-    /// The ETH minimum as `deposit_eth` reports it. Read through `caller`'s own registration,
-    /// which `deposit_eth` makes idempotently, so pass an account the test deposits for anyway.
-    pub fn minimum_eth_deposit_amount(&self, caller: Principal, subaccount: [u8; 32]) -> u128 {
-        nat_to_u128(self.deposit_eth(caller, subaccount).minimum_deposit_amount)
+    /// The minimum balance `asset`'s deposit address must hold for the balance scan to flag it,
+    /// as `get_minter_info` reports it.
+    pub fn minimum_deposit_amount(&self, asset: impl Into<Asset>) -> u128 {
+        let info = self.get_minter_info();
+        let minimum = match asset.into() {
+            Asset::Eth => info
+                .minimum_eth_deposit_amount
+                .expect("BUG: the minter reports no ETH minimum deposit amount"),
+            Asset::Erc20(token_address) => {
+                let minimum = info
+                    .minimum_deposit_amounts
+                    .expect("BUG: the minter reports no minimum deposit amounts")
+                    .into_iter()
+                    .find(|minimum| {
+                        Address::from_str(&minimum.erc20_contract_address)
+                            .expect("BUG: the minter reported an invalid token address")
+                            == token_address
+                    })
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "BUG: the minter reports no minimum deposit amount for {token_address}"
+                        )
+                    });
+                let no_minimum_sentinel: Nat = Erc20Value::MAX.into();
+                assert_ne!(
+                    minimum.minimum_deposit_amount, no_minimum_sentinel,
+                    "the minter reports no real minimum deposit amount for {token_address}"
+                );
+                minimum.minimum_deposit_amount
+            }
+        };
+        nat_to_u128(minimum)
     }
 
     /// Calls `deposit_eth` as `caller`, which registers (idempotently) that user's