Merge branch 'master' into adding_support_etherscan_v2

Author: grandizzy

.github/workflows/release.yml

@@ -14,7 +14,7 @@ env:
   CARGO_TERM_COLOR: always
   IS_NIGHTLY: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
   PROFILE: maxperf
-  STABLE_VERSION: "v0.3.0"
+  STABLE_VERSION: "v1.0.0"
 
 jobs:
   prepare:

Makefile

@@ -44,13 +44,13 @@ build-%:
 
 .PHONY: docker-build-push
 docker-build-push: docker-build-prepare ## Build and push a cross-arch Docker image tagged with DOCKER_IMAGE_NAME.
-	$(MAKE) build-x86_64-unknown-linux-gnu
+	FEATURES="jemalloc aws-kms cli asm-keccak" $(MAKE) build-x86_64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/amd64
 	for bin in anvil cast chisel forge; do \
 		cp $(CARGO_TARGET_DIR)/x86_64-unknown-linux-gnu/$(PROFILE)/$$bin $(BIN_DIR)/amd64/; \
 	done
 
-	$(MAKE) build-aarch64-unknown-linux-gnu
+	FEATURES="aws-kms cli asm-keccak" $(MAKE) build-aarch64-unknown-linux-gnu
 	mkdir -p $(BIN_DIR)/arm64
 	for bin in anvil cast chisel forge; do \
 		cp $(CARGO_TARGET_DIR)/aarch64-unknown-linux-gnu/$(PROFILE)/$$bin $(BIN_DIR)/arm64/; \

crates/cheatcodes/src/inspector.rs

@@ -46,7 +46,7 @@ use proptest::test_runner::{RngAlgorithm, TestRng, TestRunner};
 use rand::Rng;
 use revm::{
     interpreter::{
-        opcode as op, CallInputs, CallOutcome, CallScheme, CallValue, CreateInputs, CreateOutcome,
+        opcode as op, CallInputs, CallOutcome, CallScheme, CreateInputs, CreateOutcome,
         EOFCreateInputs, EOFCreateKind, Gas, InstructionResult, Interpreter, InterpreterAction,
         InterpreterResult,
     },
@@ -1047,8 +1047,6 @@ where {
                 if let CallScheme::DelegateCall | CallScheme::ExtDelegateCall = call.scheme {
                     call.target_address = prank.new_caller;
                     call.caller = prank.new_caller;
-                    let acc = ecx.journaled_state.account(prank.new_caller);
-                    call.value = CallValue::Apparent(acc.info.balance);
                     if let Some(new_origin) = prank.new_origin {
                         ecx.env.tx.caller = new_origin;
                     }

crates/evm/core/src/backend/mod.rs

@@ -1102,6 +1102,14 @@ impl DatabaseExt for Backend {
             // update the shared state and track
             let mut fork = self.inner.take_fork(idx);
 
+            // Make sure all persistent accounts on the newly selected fork starts from the init
+            // state (from setup).
+            for addr in &self.inner.persistent_accounts {
+                if let Some(account) = self.fork_init_journaled_state.state.get(addr) {
+                    fork.journaled_state.state.insert(*addr, account.clone());
+                }
+            }
+
             // since all forks handle their state separately, the depth can drift
             // this is a handover where the target fork starts at the same depth where it was
             // selected. This ensures that there are no gaps in depth which would

crates/forge/tests/cli/test_cmd.rs

@@ -3521,3 +3521,82 @@ contract InterceptInitcodeTest is DSTest {
     .unwrap();
     cmd.args(["test", "-vvvvv"]).assert_success();
 });
+
+// <https://github.com/foundry-rs/foundry/issues/10296>
+forgetest_init!(should_preserve_fork_state_setup, |prj, cmd| {
+    prj.wipe_contracts();
+    prj.add_test(
+        "Counter.t.sol",
+        r#"
+import "forge-std/Test.sol";
+import {StdChains} from "forge-std/StdChains.sol";
+
+contract CounterTest is Test {
+    struct Domain {
+        StdChains.Chain chain;
+        uint256 forkId;
+    }
+
+    struct Bridge {
+        Domain source;
+        Domain destination;
+        uint256 someVal;
+    }
+
+    struct SomeStruct {
+        Domain domain;
+        Bridge[] bridges;
+    }
+
+    mapping(uint256 => SomeStruct) internal data;
+
+    function setUp() public {
+        StdChains.Chain memory chain1 = getChain("mainnet");
+        StdChains.Chain memory chain2 = getChain("base");
+        Domain memory domain1 = Domain(chain1, vm.createFork(chain1.rpcUrl, 22253716));
+        Domain memory domain2 = Domain(chain2, vm.createFork(chain2.rpcUrl, 28839981));
+        data[1].domain = domain1;
+        data[2].domain = domain2;
+
+        vm.selectFork(domain1.forkId);
+
+        data[2].bridges.push(Bridge(domain1, domain2, 123));
+        vm.selectFork(data[2].domain.forkId);
+        vm.selectFork(data[1].domain.forkId);
+        data[2].bridges.push(Bridge(domain1, domain2, 456));
+
+        assertEq(data[2].bridges.length, 2);
+    }
+
+    function test_assert_storage() public {
+        vm.selectFork(data[2].domain.forkId);
+        assertEq(data[2].bridges.length, 2);
+    }
+
+    function test_modify_and_storage() public {
+        data[3].domain = Domain(getChain("base"), vm.createFork(getChain("base").rpcUrl, 28839981));
+        data[3].bridges.push(Bridge(data[1].domain, data[2].domain, 123));
+        data[3].bridges.push(Bridge(data[1].domain, data[2].domain, 456));
+
+        vm.selectFork(data[2].domain.forkId);
+        assertEq(data[3].bridges.length, 2);
+    }
+}
+    "#,
+    )
+    .unwrap();
+
+    cmd.args(["test", "--mc", "CounterTest"]).assert_success().stdout_eq(str![[r#"
+[COMPILING_FILES] with [SOLC_VERSION]
+[SOLC_VERSION] [ELAPSED]
+Compiler run successful!
+
+Ran 2 tests for test/Counter.t.sol:CounterTest
+[PASS] test_assert_storage() ([GAS])
+[PASS] test_modify_and_storage() ([GAS])
+Suite result: ok. 2 passed; 0 failed; 0 skipped; [ELAPSED]
+
+Ran 1 test suite [ELAPSED]: 2 tests passed, 0 failed, 0 skipped (2 total tests)
+
+"#]]);
+});

crates/forge/tests/it/repros.rs

@@ -398,3 +398,6 @@ test_repro!(9643);
 
 // https://github.com/foundry-rs/foundry/issues/7238
 test_repro!(7238);
+
+// https://github.com/foundry-rs/foundry/issues/10302
+test_repro!(10302);

testdata/default/repros/Issue10302.t.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "ds-test/test.sol";
+import "cheats/Vm.sol";
+
+contract A {
+    function foo() public pure returns (bool) {
+        return true;
+    }
+}
+
+contract Issue10302Test is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function testDelegateFails() external {
+        vm.createSelectFork("sepolia");
+        A a = new A();
+        vm.startPrank(0x0fe884546476dDd290eC46318785046ef68a0BA9, true);
+        (bool success,) = address(a).delegatecall(abi.encodeWithSelector(A.foo.selector));
+        vm.stopPrank();
+        require(success, "Delegate call should succeed");
+    }
+
+    function testDelegatePassesWhenBalanceSetToZero() external {
+        vm.createSelectFork("sepolia");
+        A a = new A();
+        vm.startPrank(0x0fe884546476dDd290eC46318785046ef68a0BA9, true);
+        vm.deal(0x0fe884546476dDd290eC46318785046ef68a0BA9, 0 ether);
+        (bool success,) = address(a).delegatecall(abi.encodeWithSelector(A.foo.selector));
+        vm.stopPrank();
+        require(success, "Delegate call should succeed");
+    }
+
+    function testDelegateCallSucceeds() external {
+        vm.createSelectFork("sepolia");
+        A a = new A();
+        vm.startPrank(0xd363339eE47775888Df411A163c586a8BdEA9dbf, true);
+        (bool success,) = address(a).delegatecall(abi.encodeWithSelector(A.foo.selector));
+        vm.stopPrank();
+        require(success, "Delegate call should succeed");
+    }
+
+    function testDelegateFailsWhenBalanceGtZero() external {
+        vm.createSelectFork("sepolia");
+        A a = new A();
+        vm.startPrank(0xd363339eE47775888Df411A163c586a8BdEA9dbf, true);
+        vm.deal(0xd363339eE47775888Df411A163c586a8BdEA9dbf, 1 ether);
+        (bool success,) = address(a).delegatecall(abi.encodeWithSelector(A.foo.selector));
+        vm.stopPrank();
+        require(success, "Delegate call should succeed");
+    }
+}