refactor: unify ERC20 storage slot discovery logic

Extracts duplicated access list handling code from `anvil_deal_erc20`
and `anvil_set_erc20_allowance` into a shared `find_erc20_storage_slot`
helper function.

Changes:
- Add comprehensive documentation explaining the slot discovery process
- Reduce code duplication by ~80 lines
- Improve maintainability and consistency between functions
- Fix unfulfilled clippy expectation in cast/tx.rs

This is a follow-up cleanup to #10746 which introduced `anvil_set_erc20_allowance`.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: mattsse

crates/anvil/src/eth/api.rs

@@ -1873,41 +1873,45 @@ impl EthApi {
         Ok(())
     }
 
-    /// Deals ERC20 tokens to a address
-    ///
-    /// Handler for RPC call: `anvil_dealERC20`
-    pub async fn anvil_deal_erc20(
+    /// Helper function to find the storage slot for an ERC20 function call by testing slots
+    /// from an access list until one produces the expected result.
+    ///
+    /// Rather than trying to reverse-engineer the storage layout, this function uses a
+    /// "trial and error" approach: try overriding each slot that the function accesses,
+    /// and see which one actually affects the function's return value.
+    ///
+    /// ## Parameters
+    /// - `token_address`: The ERC20 token contract address
+    /// - `calldata`: The encoded function call (e.g., `balanceOf(user)` or `allowance(owner,
+    ///   spender)`)
+    /// - `expected_value`: The value we want to set (balance or allowance amount)
+    ///
+    /// ## Returns
+    /// The storage slot (B256) that contains the target ERC20 data, or an error if no slot is
+    /// found.
+    async fn find_erc20_storage_slot(
         &self,
-        address: Address,
         token_address: Address,
-        balance: U256,
-    ) -> Result<()> {
-        node_info!("anvil_dealERC20");
-
-        sol! {
-            #[sol(rpc)]
-            contract IERC20 {
-                function balanceOf(address target) external view returns (uint256);
-            }
-        }
-
-        let calldata = IERC20::balanceOfCall { target: address }.abi_encode();
+        calldata: Bytes,
+        expected_value: U256,
+    ) -> Result<B256> {
         let tx = TransactionRequest::default().with_to(token_address).with_input(calldata.clone());
 
-        // first collect all the slots that are used by the balanceOf call
+        // first collect all the slots that are used by the function call
         let access_list_result =
             self.create_access_list(WithOtherFields::new(tx.clone()), None).await?;
         let access_list = access_list_result.access_list;
 
-        // now we can iterate over all the accessed slots and try to find the one that contains the
-        // balance by overriding the slot and checking the `balanceOfCall` of
+        // iterate over all the accessed slots and try to find the one that contains the
+        // target value by overriding the slot and checking the function call result
         for item in access_list.0 {
             if item.address != token_address {
                 continue;
             };
             for slot in &item.storage_keys {
-                let account_override = AccountOverride::default()
-                    .with_state_diff(std::iter::once((*slot, B256::from(balance.to_be_bytes()))));
+                let account_override = AccountOverride::default().with_state_diff(std::iter::once(
+                    (*slot, B256::from(expected_value.to_be_bytes())),
+                ));
 
                 let state_override = StateOverridesBuilder::default()
                     .append(token_address, account_override)
@@ -1922,25 +1926,55 @@ impl EthApi {
                     continue;
                 };
 
-                let Ok(result_balance) = U256::abi_decode(&result) else {
+                let Ok(result_value) = U256::abi_decode(&result) else {
                     // response returned something other than a U256
                     continue;
                 };
 
-                if result_balance == balance {
-                    self.anvil_set_storage_at(
-                        token_address,
-                        U256::from_be_bytes(slot.0),
-                        B256::from(balance.to_be_bytes()),
-                    )
-                    .await?;
-                    return Ok(());
+                if result_value == expected_value {
+                    return Ok(*slot);
                 }
             }
         }
 
-        // unable to set the balance
-        Err(BlockchainError::Message("Unable to set ERC20 balance, no slot found".to_string()))
+        Err(BlockchainError::Message("Unable to find storage slot".to_string()))
+    }
+
+    /// Deals ERC20 tokens to a address
+    ///
+    /// Handler for RPC call: `anvil_dealERC20`
+    pub async fn anvil_deal_erc20(
+        &self,
+        address: Address,
+        token_address: Address,
+        balance: U256,
+    ) -> Result<()> {
+        node_info!("anvil_dealERC20");
+
+        sol! {
+            #[sol(rpc)]
+            contract IERC20 {
+                function balanceOf(address target) external view returns (uint256);
+            }
+        }
+
+        let calldata = IERC20::balanceOfCall { target: address }.abi_encode().into();
+
+        // Find the storage slot that contains the balance
+        let slot =
+            self.find_erc20_storage_slot(token_address, calldata, balance).await.map_err(|_| {
+                BlockchainError::Message("Unable to set ERC20 balance, no slot found".to_string())
+            })?;
+
+        // Set the storage slot to the desired balance
+        self.anvil_set_storage_at(
+            token_address,
+            U256::from_be_bytes(slot.0),
+            B256::from(balance.to_be_bytes()),
+        )
+        .await?;
+
+        Ok(())
     }
 
     /// Sets the ERC20 allowance for a spender
@@ -1962,56 +1996,23 @@ impl EthApi {
             }
         }
 
-        let calldata = IERC20::allowanceCall { owner, spender }.abi_encode();
-        let tx = TransactionRequest::default().with_to(token_address).with_input(calldata.clone());
-
-        // first collect all the slots that are used by the allowance call
-        let access_list_result =
-            self.create_access_list(WithOtherFields::new(tx.clone()), None).await?;
-        let access_list = access_list_result.access_list;
-
-        // now we can iterate over all the accessed slots and try to find the one that contains the
-        // allowance by overriding the slot and checking the `allowanceCall` result
-        for item in access_list.0 {
-            if item.address != token_address {
-                continue;
-            };
-            for slot in &item.storage_keys {
-                let account_override = AccountOverride::default()
-                    .with_state_diff(std::iter::once((*slot, B256::from(amount.to_be_bytes()))));
-
-                let state_override = StateOverridesBuilder::default()
-                    .append(token_address, account_override)
-                    .build();
-
-                let evm_override = EvmOverrides::state(Some(state_override));
+        let calldata = IERC20::allowanceCall { owner, spender }.abi_encode().into();
 
-                let Ok(result) =
-                    self.call(WithOtherFields::new(tx.clone()), None, evm_override).await
-                else {
-                    // overriding this slot failed
-                    continue;
-                };
+        // Find the storage slot that contains the allowance
+        let slot =
+            self.find_erc20_storage_slot(token_address, calldata, amount).await.map_err(|_| {
+                BlockchainError::Message("Unable to set ERC20 allowance, no slot found".to_string())
+            })?;
 
-                let Ok(result_allowance) = U256::abi_decode(&result) else {
-                    // response returned something other than a U256
-                    continue;
-                };
-
-                if result_allowance == amount {
-                    self.anvil_set_storage_at(
-                        token_address,
-                        U256::from_be_bytes(slot.0),
-                        B256::from(amount.to_be_bytes()),
-                    )
-                    .await?;
-                    return Ok(());
-                }
-            }
-        }
+        // Set the storage slot to the desired allowance
+        self.anvil_set_storage_at(
+            token_address,
+            U256::from_be_bytes(slot.0),
+            B256::from(amount.to_be_bytes()),
+        )
+        .await?;
 
-        // unable to set the allowance
-        Err(BlockchainError::Message("Unable to set ERC20 allowance, no slot found".to_string()))
+        Ok(())
     }
 
     /// Sets the code of a contract.

crates/cast/src/tx.rs

@@ -27,7 +27,6 @@ use serde_json::value::RawValue;
 use std::fmt::Write;
 
 /// Different sender kinds used by [`CastTxBuilder`].
-#[expect(clippy::large_enum_variant)]
 pub enum SenderKind<'a> {
     /// An address without signer. Used for read-only calls and transactions sent through unlocked
     /// accounts.