chore: Bump 1.3.5, backport state overrides fix (#11577)

* fix(cast): allow comma-separated values for overrides (#11553)

* fix(cast): allow comma sepparated values for overrides

* Fix multiple slots

* Tests with traces

* chore: bump v1.3.5 (#11576)

Author: grandizzy

Cargo.lock

@@ -29,7 +29,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "1.3.4"
+version = "1.3.5"
 edition = "2024"
 # Remember to update clippy.toml as well
 rust-version = "1.88"

Cargo.toml

@@ -1,10 +1,11 @@
+use super::run::fetch_contracts_bytecode_from_trace;
 use crate::{
     Cast,
     traces::TraceKind,
     tx::{CastTxBuilder, SenderKind},
 };
 use alloy_ens::NameOrAddress;
-use alloy_primitives::{Address, Bytes, TxKind, U256};
+use alloy_primitives::{Address, B256, Bytes, TxKind, U256, map::HashMap};
 use alloy_provider::Provider;
 use alloy_rpc_types::{
     BlockId, BlockNumberOrTag, BlockOverrides,
@@ -34,8 +35,6 @@ use regex::Regex;
 use revm::context::TransactionType;
 use std::{str::FromStr, sync::LazyLock};
 
-use super::run::fetch_contracts_bytecode_from_trace;
-
 // matches override pattern <address>:<slot>:<value>
 // e.g. 0x123:0x1:0x1234
 static OVERRIDE_PATTERN: LazyLock<Regex> =
@@ -131,29 +130,29 @@ pub struct CallArgs {
     #[arg(long, visible_alias = "la")]
     pub with_local_artifacts: bool,
 
-    /// Override the balance of an account.
-    /// Format: address:balance
-    #[arg(long = "override-balance", value_name = "ADDRESS:BALANCE")]
+    /// Override the accounts balance.
+    /// Format: "address:balance,address:balance"
+    #[arg(long = "override-balance", value_name = "ADDRESS:BALANCE", value_delimiter = ',')]
     pub balance_overrides: Option<Vec<String>>,
 
-    /// Override the nonce of an account.
-    /// Format: address:nonce
-    #[arg(long = "override-nonce", value_name = "ADDRESS:NONCE")]
+    /// Override the accounts nonce.
+    /// Format: "address:nonce,address:nonce"
+    #[arg(long = "override-nonce", value_name = "ADDRESS:NONCE", value_delimiter = ',')]
     pub nonce_overrides: Option<Vec<String>>,
 
-    /// Override the code of an account.
-    /// Format: address:code
-    #[arg(long = "override-code", value_name = "ADDRESS:CODE")]
+    /// Override the accounts code.
+    /// Format: "address:code,address:code"
+    #[arg(long = "override-code", value_name = "ADDRESS:CODE", value_delimiter = ',')]
     pub code_overrides: Option<Vec<String>>,
 
-    /// Override the state of an account.
-    /// Format: address:slot:value
-    #[arg(long = "override-state", value_name = "ADDRESS:SLOT:VALUE")]
+    /// Override the accounts state and replace the current state entirely with the new one.
+    /// Format: "address:slot:value,address:slot:value"
+    #[arg(long = "override-state", value_name = "ADDRESS:SLOT:VALUE", value_delimiter = ',')]
     pub state_overrides: Option<Vec<String>>,
 
-    /// Override the state diff of an account.
-    /// Format: address:slot:value
-    #[arg(long = "override-state-diff", value_name = "ADDRESS:SLOT:VALUE")]
+    /// Override the accounts state specific slots and preserve the rest of the state.
+    /// Format: "address:slot:value,address:slot:value"
+    #[arg(long = "override-state-diff", value_name = "ADDRESS:SLOT:VALUE", value_delimiter = ',')]
     pub state_diff_overrides: Option<Vec<String>>,
 
     /// Override the block timestamp.
@@ -393,18 +392,29 @@ impl CallArgs {
                 state_overrides_builder.with_code(addr.parse()?, Bytes::from_str(code_str)?);
         }
 
-        // Parse state overrides
-        for override_str in self.state_overrides.iter().flatten() {
-            let (addr, slot, value) = address_slot_value_override(override_str)?;
-            state_overrides_builder =
-                state_overrides_builder.with_state(addr, [(slot.into(), value.into())]);
+        type StateOverrides = HashMap<Address, HashMap<B256, B256>>;
+        let parse_state_overrides =
+            |overrides: &Option<Vec<String>>| -> Result<StateOverrides, eyre::Report> {
+                let mut state_overrides: StateOverrides = StateOverrides::default();
+
+                overrides.iter().flatten().try_for_each(|s| -> Result<(), eyre::Report> {
+                    let (addr, slot, value) = address_slot_value_override(s)?;
+                    state_overrides.entry(addr).or_default().insert(slot.into(), value.into());
+                    Ok(())
+                })?;
+
+                Ok(state_overrides)
+            };
+
+        // Parse and apply state overrides
+        for (addr, entries) in parse_state_overrides(&self.state_overrides)? {
+            state_overrides_builder = state_overrides_builder.with_state(addr, entries.into_iter());
         }
 
-        // Parse state diff overrides
-        for override_str in self.state_diff_overrides.iter().flatten() {
-            let (addr, slot, value) = address_slot_value_override(override_str)?;
+        // Parse and apply state diff overrides
+        for (addr, entries) in parse_state_overrides(&self.state_diff_overrides)? {
             state_overrides_builder =
-                state_overrides_builder.with_state_diff(addr, [(slot.into(), value.into())]);
+                state_overrides_builder.with_state_diff(addr, entries.into_iter())
         }
 
         Ok(Some(state_overrides_builder.build()))