Bumped Foundry version to support parseJsonKeys

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
-	url = https://github.com/bowd/forge-std
+	url = https://github.com/foundry-rs/forge-std

remappings.txt

@@ -1,2 +1,2 @@
 ds-test/=lib/forge-std/lib/ds-test/src/
-forge-std/=lib/forge-std/src/
+forge-std-8/=lib/forge-std/src/

script/Helper.s.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.5.13;
+pragma solidity >=0.5.13 <0.8.20;
 
-import "forge-std/Script.sol";
+import "forge-std-8/Script.sol";
 import "../src/PrecompileHandler.sol";
 
 contract Helper is Script, PrecompileHandler {

src/PrecompileHandler.sol

@@ -1,15 +1,15 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.5.13;
+pragma solidity >=0.5.13 <0.8.20;
 
-import "forge-std/Vm.sol";
-import "forge-std/console2.sol";
+import "forge-std-8/Vm.sol";
+import "forge-std-8/console2.sol";
 import "./Precompiles.sol";
 
 contract PrecompileHandler is Precompiles {
   address constant private VM_ADDRESS =
     address(bytes20(uint160(uint256(keccak256('hevm cheat code')))));
 
-  Vm public constant vm = Vm(VM_ADDRESS);
+  Vm public constant _vm = Vm(VM_ADDRESS);
 
   bytes4 constant TRANSFER_SIG = bytes4(keccak256("transfer(address,address,uint256)"));
   bytes4 constant EPOCH_SIZE_SIG = bytes4(keccak256("epochSize()"));
@@ -30,41 +30,41 @@ contract PrecompileHandler is Precompiles {
   Mock private revertMock = Mock(true, _empty, true);
 
   constructor() public {
-    vm.etch(TRANSFER, proxyTo(TRANSFER_SIG));
-    vm.label(TRANSFER, "TRANSFER");
+    _vm.etch(TRANSFER, proxyTo(TRANSFER_SIG));
+    _vm.label(TRANSFER, "TRANSFER");
 
-    vm.etch(EPOCH_SIZE, proxyTo(EPOCH_SIZE_SIG));
-    vm.label(EPOCH_SIZE, "EPOCH_SIZE");
+    _vm.etch(EPOCH_SIZE, proxyTo(EPOCH_SIZE_SIG));
+    _vm.label(EPOCH_SIZE, "EPOCH_SIZE");
 
     bytes memory catchAllProxy = proxyTo(CATCHALL_SIG);
-    vm.etch(FRACTION_MUL, catchAllProxy);
-    vm.label(FRACTION_MUL, "FRACTION_MUL");
+    _vm.etch(FRACTION_MUL, catchAllProxy);
+    _vm.label(FRACTION_MUL, "FRACTION_MUL");
 
-    vm.etch(PROOF_OF_POSSESSION, catchAllProxy);
-    vm.label(PROOF_OF_POSSESSION, "PROOF_OF_POSSESSION");
+    _vm.etch(PROOF_OF_POSSESSION, catchAllProxy);
+    _vm.label(PROOF_OF_POSSESSION, "PROOF_OF_POSSESSION");
 
-    vm.etch(GET_VALIDATOR, catchAllProxy);
-    vm.label(GET_VALIDATOR, "GET_VALIDATOR");
+    _vm.etch(GET_VALIDATOR, catchAllProxy);
+    _vm.label(GET_VALIDATOR, "GET_VALIDATOR");
 
-    vm.etch(NUMBER_VALIDATORS, catchAllProxy);
-    vm.label(NUMBER_VALIDATORS, "NUMBER_VALIDATORS");
+    _vm.etch(NUMBER_VALIDATORS, catchAllProxy);
+    _vm.label(NUMBER_VALIDATORS, "NUMBER_VALIDATORS");
 
-    vm.etch(BLOCK_NUMBER_FROM_HEADER, catchAllProxy);
-    vm.label(BLOCK_NUMBER_FROM_HEADER, "BLOCK_NUMBER_FROM_HEADER");
+    _vm.etch(BLOCK_NUMBER_FROM_HEADER, catchAllProxy);
+    _vm.label(BLOCK_NUMBER_FROM_HEADER, "BLOCK_NUMBER_FROM_HEADER");
 
-    vm.etch(HASH_HEADER, catchAllProxy);
-    vm.label(HASH_HEADER, "HASH_HEADER");
+    _vm.etch(HASH_HEADER, catchAllProxy);
+    _vm.label(HASH_HEADER, "HASH_HEADER");
 
-    vm.etch(GET_PARENT_SEAL_BITMAP, catchAllProxy);
-    vm.label(GET_PARENT_SEAL_BITMAP, "GET_PARENT_SEAL_BITMAP");
+    _vm.etch(GET_PARENT_SEAL_BITMAP, catchAllProxy);
+    _vm.label(GET_PARENT_SEAL_BITMAP, "GET_PARENT_SEAL_BITMAP");
 
-    vm.etch(GET_VERIFIED_SEAL_BITMAP, catchAllProxy);
-    vm.label(GET_VERIFIED_SEAL_BITMAP, "GET_VERIFIED_SEAL_BITMAP");
+    _vm.etch(GET_VERIFIED_SEAL_BITMAP, catchAllProxy);
+    _vm.label(GET_VERIFIED_SEAL_BITMAP, "GET_VERIFIED_SEAL_BITMAP");
   }
 
   function transfer(address from, address to, uint256 amount) public returns (bool) {
-    vm.deal(from, from.balance - amount);
-    vm.deal(to, to.balance + amount);
+    _vm.deal(from, from.balance - amount);
+    _vm.deal(to, to.balance + amount);
     return true;
   }
 

src/Precompiles.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.5.13;
+pragma solidity >=0.5.13 <0.8.20;
 
 contract Precompiles {
   address public constant TRANSFER = address(0xff - 2);

src/Test.sol

@@ -1,56 +1,101 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.5.13;
+pragma solidity >=0.5.13 <0.8.20;
 
-import {Test as ForgeTest} from "forge-std/Test.sol";
+import { Test as ForgeTest } from "forge-std-8/Test.sol";
 import "./Precompiles.sol";
 import "./PrecompileHandler.sol";
 
 contract Test is ForgeTest, Precompiles {
-    PrecompileHandler public ph;
-    address currentPrank;
+  PrecompileHandler public ph;
+  address currentPrank;
 
-    event log_named_array(string key, address[] val);
-    event log_named_array(string key, bytes32[] val);
-    event log_array(string key, address[] val);
-    event log_array(string key, bytes32[] val);
+  event log_named_array(string key, bytes32[] val);
+  event log_array(string key, address[] val);
+  event log_array(string key, bytes32[] val);
 
-    constructor() ForgeTest() public {
-        ph = new PrecompileHandler();
-    }
+  constructor() public ForgeTest() {
+    ph = new PrecompileHandler();
+  }
 
-    /* Utility functions */
+  /* Utility functions */
 
-    function changePrank(address who) internal {
-      // Record current prank so helper functions can revert
-      // if they need to prank
-      currentPrank = who;
-      super.changePrank(who);
-    }
+  function changePrank(address who) internal virtual override {
+    // Record current prank so helper functions can revert
+    // if they need to prank
+    currentPrank = who;
+    super.changePrank(who);
+  }
 
-    function actor(string memory name) public returns (address) {
-      uint256 pk = uint256(keccak256(bytes(name)));
-      address addr = vm.addr(pk);
-      vm.label(addr, name);
-      return addr;
-    }
+  function actor(string memory name) public returns (address) {
+    uint256 pk = uint256(keccak256(bytes(name)));
+    address addr = vm.addr(pk);
+    vm.label(addr, name);
+    return addr;
+  }
 
-    /* Extra assertions, extends forge-std/Test.sol */
+  function actorWithPK(string memory name) public returns (address, uint256) {
+    uint256 pk = uint256(keccak256(bytes(name)));
+    address addr = vm.addr(pk);
+    vm.label(addr, name);
+    return (addr, pk);
+  }
 
-    function assertEq(address[] memory a, address[] memory b) internal {
-        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
-            emit log("Error: a == b not satisfied [address[]]");
-            emit log_named_array("  Expected", b);
-            emit log_named_array("    Actual", a);
-            fail();
-        }
+  /* Extra assertions, extends forge-std/Test.sol */
+
+  function assertEq(address[] memory a, address[] memory b) internal virtual override {
+    if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+      emit log("Error: a == b not satisfied [address[]]");
+      emit log_named_array("  Expected", b);
+      emit log_named_array("    Actual", a);
+      fail();
     }
+  }
 
-    function assertEq(bytes32[] memory a, bytes32[] memory b) internal {
-        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
-            emit log("Error: a == b not satisfied [bytes32[]]");
-            emit log_named_array("  Expected", b);
-            emit log_named_array("    Actual", a);
-            fail();
-        }
+  function assertEq(
+    address[] memory a,
+    address[] memory b,
+    string memory err
+  ) internal virtual override {
+    if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+      emit log_named_string("Error", err);
+      assertEq(a, b);
     }
-}
+  }
+
+  function assertEq(bytes32[] memory a, bytes32[] memory b) internal {
+    if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+      emit log("Error: a == b not satisfied [bytes32[]]");
+      emit log_named_array("  Expected", b);
+      emit log_named_array("    Actual", a);
+      fail();
+    }
+  }
+
+  function deployCodeTo(string memory what, address where) internal virtual override {
+    deployCodeTo(what, "", 0, where);
+  }
+
+  function deployCodeTo(
+    string memory what,
+    bytes memory args,
+    address where
+  ) internal virtual override {
+    deployCodeTo(what, args, 0, where);
+  }
+
+  function deployCodeTo(
+    string memory what,
+    bytes memory args,
+    uint256 value,
+    address where
+  ) internal virtual override {
+    bytes memory creationCode = vm.getCode(what);
+    vm.etch(where, abi.encodePacked(creationCode, args));
+    (bool success, bytes memory runtimeBytecode) = where.call{ value: value }("");
+    require(
+      success,
+      "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode."
+    );
+    vm.etch(where, runtimeBytecode);
+  }
+}