Merge branch 'master' into mablr/tracing-spec-authority-master

Author: mablr

.changelog/slot-number-cheatcodes.md

@@ -0,0 +1,8 @@
+---
+forge: minor
+foundry-cheatcodes: minor
+foundry-cheatcodes-spec: minor
+foundry-evm-core: minor
+---
+
+Added `vm.getSlotNumber()` and `vm.rollSlot(uint64)` to read and set the Amsterdam block slot number.

crates/cheatcodes/assets/cheatcodes.json

@@ -591,6 +591,20 @@ interface Vm {
     #[cheatcode(group = Evm, safety = Safe)]
     function getBlockNumber() external view returns (uint256 height);
 
+    /// Sets `block.slotnum` without changing the block number or timestamp.
+    /// Not available on EVM versions before Amsterdam.
+    /// If used on unsupported EVM versions it will revert.
+    #[cheatcode(group = Evm, safety = Unsafe)]
+    function rollSlot(uint64 newSlotNumber) external;
+
+    /// Gets the current `block.slotnum`.
+    /// Use this instead of `block.slotnum` after `vm.rollSlot`, as the compiler assumes
+    /// `block.slotnum` is constant across a transaction and may optimize repeated reads away.
+    /// Not available on EVM versions before Amsterdam.
+    /// If used on unsupported EVM versions it will revert.
+    #[cheatcode(group = Evm, safety = Safe)]
+    function getSlotNumber() external view returns (uint64 slotNumber);
+
     /// Sets `tx.gasprice`.
     #[cheatcode(group = Evm, safety = Unsafe)]
     function txGasPrice(uint256 newGasPrice) external;

crates/cheatcodes/spec/src/vm.rs

@@ -707,6 +707,29 @@ impl Cheatcode for getBlockNumberCall {
     }
 }
 
+impl Cheatcode for rollSlotCall {
+    fn apply_stateful<FEN: FoundryEvmNetwork>(&self, ccx: &mut CheatsCtxt<'_, '_, FEN>) -> Result {
+        ensure!(
+            ccx.ecx.cfg().spec().into() >= SpecId::AMSTERDAM,
+            "`rollSlot` is not supported before the Amsterdam hard fork; \
+             see EIP-7843: https://eips.ethereum.org/EIPS/eip-7843"
+        );
+        ccx.ecx.block_mut().set_slot_num(self.newSlotNumber);
+        Ok(Default::default())
+    }
+}
+
+impl Cheatcode for getSlotNumberCall {
+    fn apply_stateful<FEN: FoundryEvmNetwork>(&self, ccx: &mut CheatsCtxt<'_, '_, FEN>) -> Result {
+        ensure!(
+            ccx.ecx.cfg().spec().into() >= SpecId::AMSTERDAM,
+            "`getSlotNumber` is not supported before the Amsterdam hard fork; \
+             see EIP-7843: https://eips.ethereum.org/EIPS/eip-7843"
+        );
+        Ok(ccx.ecx.block().slot_num().abi_encode())
+    }
+}
+
 impl Cheatcode for txGasPriceCall {
     fn apply_stateful<FEN: FoundryEvmNetwork>(&self, ccx: &mut CheatsCtxt<'_, '_, FEN>) -> Result {
         let Self { newGasPrice } = self;

crates/cheatcodes/src/evm.rs

@@ -3209,6 +3209,7 @@ fn update_env_block<N: Network, SPEC: Into<SpecId> + Copy, BLOCK: FoundryBlock>(
     block_env.set_basefee(header.base_fee_per_gas().unwrap_or_default());
     block_env.set_gas_limit(header.gas_limit());
     block_env.set_number(U256::from(header.number()));
+    block_env.set_slot_num(header.slot_number().unwrap_or_default());
 
     if let Some(excess_blob_gas) = header.excess_blob_gas() {
         evm_env.block_env.set_blob_excess_gas_and_price(
@@ -3898,6 +3899,29 @@ mod tests {
         assert_eq!(parent.after_transaction(block, parent_block.hash, 0, 0), None);
     }
 
+    #[test]
+    fn fork_block_env_updates_slot_number() {
+        let mut evm_env =
+            EvmEnv::new(revm::context::CfgEnv::<SpecId>::default(), BlockEnv::default());
+        for slot_number in [Some(42), Some(u64::MAX), None, Some(0)] {
+            let header = AnyHeader { slot_number, ..Default::default() };
+            let block = AnyRpcBlock::new(
+                Block::new(
+                    AnyRpcHeader::from_sealed(header.seal(B256::ZERO)),
+                    BlockTransactions::Full(Vec::new()),
+                )
+                .into(),
+            );
+            update_env_block::<AnyNetwork, _, _>(
+                &mut evm_env,
+                &block,
+                NamedChain::Mainnet as u64,
+                NetworkConfigs::default(),
+            );
+            assert_eq!(evm_env.block_env.slot_num, slot_number.unwrap_or_default());
+        }
+    }
+
     #[test]
     fn fork_replay_block_env_preserves_arbitrum_l1_number() {
         let header = AnyHeader { number: 75_219_831, ..Default::default() };

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

@@ -29,6 +29,9 @@ pub trait FoundryBlock: Block {
     /// Sets the block number.
     fn set_number(&mut self, number: U256);
 
+    /// Sets the slot number.
+    fn set_slot_num(&mut self, slot_num: u64);
+
     /// Sets the beneficiary (coinbase) address.
     fn set_beneficiary(&mut self, beneficiary: Address);
 
@@ -70,6 +73,10 @@ impl FoundryBlock for BlockEnv {
         self.number = number;
     }
 
+    fn set_slot_num(&mut self, slot_num: u64) {
+        self.slot_num = slot_num;
+    }
+
     fn set_beneficiary(&mut self, beneficiary: Address) {
         self.beneficiary = beneficiary;
     }
@@ -108,6 +115,10 @@ impl FoundryBlock for TempoBlockEnv {
         self.inner.set_number(number);
     }
 
+    fn set_slot_num(&mut self, slot_num: u64) {
+        self.inner.set_slot_num(slot_num);
+    }
+
     fn set_beneficiary(&mut self, beneficiary: Address) {
         self.inner.set_beneficiary(beneficiary);
     }

crates/evm/core/src/env.rs

@@ -21,6 +21,7 @@ pub const fn cold_path() {
 pub fn block_env_from_header<BLOCK: FoundryBlock + Default>(header: &impl BlockHeader) -> BLOCK {
     let mut block = BLOCK::default();
     block.set_number(U256::from(header.number()));
+    block.set_slot_num(header.slot_number().unwrap_or_default());
     block.set_beneficiary(header.beneficiary());
     block.set_timestamp(U256::from(header.timestamp()));
     block.set_difficulty(header.difficulty());
@@ -235,6 +236,15 @@ mod tests {
     use alloy_rpc_types::{Block, BlockTransactions};
     use revm::context::{BlockEnv, CfgEnv};
 
+    #[test]
+    fn block_env_preserves_slot_number() {
+        for slot_number in [None, Some(0), Some(42), Some(u64::MAX)] {
+            let header = AnyHeader { slot_number, ..Default::default() };
+            let block = block_env_from_header::<BlockEnv>(&header);
+            assert_eq!(block.slot_num, slot_number.unwrap_or_default());
+        }
+    }
+
     #[test]
     fn block_normalization_uses_source_chain() {
         let header = AnyHeader { number: 500, ..Default::default() };

crates/evm/core/src/utils.rs

@@ -227,3 +227,44 @@ contract StateGasTest is Test {
     });
     cmd.forge_fuse().args(args).assert_success();
 });
+
+forgetest_init!(can_test_slot_number_amsterdam, |prj, cmd| {
+    prj.add_test(
+        "SlotNumber.t.sol",
+        r#"
+pragma solidity =0.8.37;
+
+import "forge-std/Test.sol";
+
+interface VmSlot {
+    function getSlotNumber() external view returns (uint64);
+    function rollSlot(uint64 newSlotNumber) external;
+}
+
+contract SlotNumberTest is Test {
+    VmSlot constant slots = VmSlot(address(vm));
+
+    function readSlot() external view returns (uint256) {
+        return block.slotnum;
+    }
+
+    function testSlotNumber(uint64 first, uint64 second) public {
+        uint256 number = vm.getBlockNumber();
+        uint256 timestamp = vm.getBlockTimestamp();
+        slots.rollSlot(first);
+        assertEq(slots.getSlotNumber(), first);
+        assertEq(this.readSlot(), first);
+        slots.rollSlot(second);
+        assertEq(slots.getSlotNumber(), second);
+        assertEq(this.readSlot(), second);
+        assertEq(vm.getBlockNumber(), number);
+        assertEq(vm.getBlockTimestamp(), timestamp);
+    }
+}
+"#,
+    );
+    let args = ["test", "--use", "0.8.37", "--evm-version", "amsterdam", "--experimental"];
+    cmd.args(args).assert_success();
+    cmd.forge_fuse().args(args).args(["--optimize", "--via-ir"]).assert_success();
+    cmd.forge_fuse().args(args).arg("--isolate").assert_success();
+});

crates/forge/tests/cli/svm.rs

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "utils/Test.sol";
+
+contract SlotNumberTest is Test {
+    address constant SLOT_READER = address(0x1234);
+
+    function setUp() public {
+        vm.setEvmVersion("amsterdam");
+        // SLOTNUM; MSTORE(0); RETURN(0, 32).
+        vm.etch(SLOT_READER, hex"4b60005260206000f3");
+    }
+
+    function readSlotNumber() internal view returns (uint256) {
+        (bool success, bytes memory result) = SLOT_READER.staticcall("");
+        require(success, "SLOTNUM failed");
+        return abi.decode(result, (uint256));
+    }
+
+    function testRollSlot() public {
+        uint256 number = vm.getBlockNumber();
+        uint256 timestamp = vm.getBlockTimestamp();
+        assertEq(vm.getSlotNumber(), readSlotNumber());
+        vm.rollSlot(100);
+        assertEq(vm.getSlotNumber(), 100);
+        assertEq(readSlotNumber(), 100);
+        vm.rollSlot(0);
+        assertEq(vm.getSlotNumber(), 0);
+        assertEq(readSlotNumber(), 0);
+        vm.rollSlot(type(uint64).max);
+        assertEq(vm.getSlotNumber(), type(uint64).max);
+        assertEq(readSlotNumber(), type(uint64).max);
+        assertEq(vm.getBlockNumber(), number);
+        assertEq(vm.getBlockTimestamp(), timestamp);
+    }
+
+    function testRollSlotFuzzed(uint64 first, uint64 second) public {
+        vm.rollSlot(first);
+        assertEq(vm.getSlotNumber(), first);
+        assertEq(readSlotNumber(), first);
+        vm.rollSlot(second);
+        assertEq(vm.getSlotNumber(), second);
+        assertEq(readSlotNumber(), second);
+    }
+
+    function testRollSlotSnapshot() public {
+        vm.rollSlot(42);
+        uint256 snapshot = vm.snapshotState();
+        vm.rollSlot(100);
+        assertTrue(vm.revertToState(snapshot));
+        assertEq(vm.getSlotNumber(), 42);
+        assertEq(readSlotNumber(), 42);
+    }
+
+    function testSlotNumberBeforeAmsterdam() public {
+        vm.setEvmVersion("osaka");
+        vm._expectCheatcodeRevert(
+            "vm.rollSlot: `rollSlot` is not supported before the Amsterdam hard fork; see EIP-7843: https://eips.ethereum.org/EIPS/eip-7843"
+        );
+        vm.rollSlot(1);
+        vm._expectCheatcodeRevert(
+            "vm.getSlotNumber: `getSlotNumber` is not supported before the Amsterdam hard fork; see EIP-7843: https://eips.ethereum.org/EIPS/eip-7843"
+        );
+        vm.getSlotNumber();
+    }
+}

testdata/default/cheats/SlotNumber.t.sol

@@ -339,6 +339,7 @@ interface Vm {
     function getRecordedLogs() external view returns (Log[] memory logs);
     function getRecordedLogsJson() external view returns (string memory logsJson);
     function getSelectors(string calldata artifactPath) external view returns (bytes4[] memory selectors);
+    function getSlotNumber() external view returns (uint64 slotNumber);
     function getStateDiff() external view returns (string memory diff);
     function getStateDiffJson() external view returns (string memory diff);
     function getStorageAccesses() external view returns (StorageAccess[] memory storageAccesses);
@@ -513,6 +514,7 @@ interface Vm {
     function rollFork(bytes32 txHash) external;
     function rollFork(uint256 forkId, uint256 blockNumber) external;
     function rollFork(uint256 forkId, bytes32 txHash) external;
+    function rollSlot(uint64 newSlotNumber) external;
     function rpcJson(string calldata method, string calldata params) external returns (string memory data);
     function rpcJson(string calldata urlOrAlias, string calldata method, string calldata params) external returns (string memory data);
     function rpcUrl(string calldata rpcAlias) external view returns (string memory json);