Add blockhash cheatcode

Author: smiasojed

.github/workflows/nextest.yml

@@ -43,7 +43,7 @@ jobs:
   test:
     name: test ${{ matrix.name }}
     runs-on: ${{ matrix.runner_label }}
-    timeout-minutes: 90
+    timeout-minutes: 120
     needs: [matrices]
     strategy:
       fail-fast: false

crates/forge/tests/it/revive/cheats_individual.rs

@@ -41,3 +41,6 @@ macro_rules! revive_cheat_test_original {
 
 revive_cheat_test!(test_custom_nonce, "Nonce");
 revive_cheat_test_original!(test_nonce, "Nonce");
+revive_cheat_test!(test_coinbase, "CoinBase");
+revive_cheat_test!(test_set_custom_blockhash, "SetBlockhash");
+revive_cheat_test_original!(test_set_blockhash, "SetBlockhash");

crates/revive-strategy/src/cheatcodes/mod.rs

@@ -10,7 +10,7 @@ use foundry_cheatcodes::{
     Vm::{
         chainIdCall, coinbaseCall, dealCall, etchCall, getNonce_0Call, loadCall, polkadotSkipCall,
         pvmCall, resetNonceCall, revertToStateAndDeleteCall, revertToStateCall, rollCall,
-        setNonceCall, setNonceUnsafeCall, snapshotStateCall, storeCall, warpCall,
+        setBlockhashCall, setNonceCall, setNonceUnsafeCall, snapshotStateCall, storeCall, warpCall,
     },
     journaled_account, precompile_error,
 };
@@ -380,6 +380,25 @@ impl CheatcodeInspectorStrategyRunner for PvmCheatcodeInspectorStrategyRunner {
 
                 cheatcode.dyn_apply(ccx, executor)
             }
+            t if is::<setBlockhashCall>(t) => {
+                let &setBlockhashCall { blockNumber, blockHash } =
+                    cheatcode.as_any().downcast_ref().unwrap();
+
+                tracing::info!(cheatcode = ?cheatcode.as_debug(), using_pvm = ?using_pvm);
+
+                // Validate blockNumber is not in the future
+                let current_block = ctx.externalities.get_block_number();
+                if blockNumber > current_block {
+                    return Err(foundry_cheatcodes::Error::from(
+                        "block number must be less than or equal to the current block number",
+                    ));
+                }
+
+                let block_num_u64 = blockNumber.to::<u64>();
+                ctx.externalities.set_blockhash(block_num_u64, blockHash);
+
+                cheatcode.dyn_apply(ccx, executor)
+            }
             t if using_pvm && is::<etchCall>(t) => {
                 let etchCall { target, newRuntimeBytecode } =
                     cheatcode.as_any().downcast_ref().unwrap();

crates/revive-strategy/src/state.rs

@@ -109,6 +109,11 @@ impl TestEnv {
         });
     }
 
+    pub fn get_block_number(&mut self) -> U256 {
+        // Get block number in pallet-revive runtime.
+        self.0.lock().unwrap().externalities.execute_with(|| U256::from(System::block_number()))
+    }
+
     pub fn set_timestamp(&mut self, new_timestamp: U256) {
         // Set timestamp in pallet-revive runtime (milliseconds).
         self.0.lock().unwrap().externalities.execute_with(|| {
@@ -239,4 +244,19 @@ impl TestEnv {
             BlockAuthor::set(&account_id32);
         });
     }
+
+    pub fn set_blockhash(&mut self, block_number: u64, block_hash: FixedBytes<32>) {
+        self.0.lock().unwrap().externalities.execute_with(|| {
+            use polkadot_sdk::frame_system::BlockHash;
+
+            let hash = sp_core::H256::from_slice(block_hash.as_slice());
+            BlockHash::<Runtime>::insert(block_number, hash);
+        });
+    }
+
+    pub fn is_contract(&self, address: Address) -> bool {
+        self.0.lock().unwrap().externalities.execute_with(|| {
+            AccountInfo::<Runtime>::load_contract(&H160::from_slice(address.as_slice())).is_some()
+        })
+    }
 }

testdata/default/revive/CoinBase.t.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "ds-test/test.sol";
+import "../../cheats/Vm.sol";
+
+contract BlockCoinBase {
+    function coinbase() public view returns (address) {
+        return block.coinbase;
+    }
+}
+
+contract CoinbaseTest is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function testCoinbase() public {
+        vm.pvm(true);
+        BlockCoinBase coinbase = new BlockCoinBase();
+        vm.coinbase(0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8);
+        assertEq(coinbase.coinbase(), 0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8, "coinbase failed");
+    }
+
+    function testCoinbaseFuzzed(address who) public {
+        vm.coinbase(who);
+        BlockCoinBase coinbase = new BlockCoinBase();
+        assertEq(coinbase.coinbase(), who, "coinbase failed");
+    }
+}

testdata/default/revive/SetBlockhash.t.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "ds-test/test.sol";
+import "cheats/Vm.sol";
+
+contract BlockHash {
+    function getBlockhash(uint256 blockNumber) public view returns (bytes32) {
+        return blockhash(blockNumber);
+    }
+}
+
+contract SetBlockhash is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function testSetBlockhash() public {
+        vm.pvm(true);
+        vm.roll(10);
+        BlockHash blockHash = new BlockHash();
+        bytes32 expectedHash = 0x1234567890123456789012345678901234567890123456789012345678901234;
+        vm.setBlockhash(9, expectedHash);
+        assertEq(blockHash.getBlockhash(9), expectedHash);
+    }
+}