hevm: enchanced control over blockchain context

nix/build-dapp-package.nix

@@ -23,8 +23,9 @@ in
   , deps ? []
   , solc ? "${pkgs.solc}/bin/solc"
   , shouldFail ? false
-  , dappFlags ? ""
   , doCheck ? true
+  , dapprc ? ""
+  , testFlags ? ""
   , ... }@args:
     pkgs.stdenv.mkDerivation ( rec {
       inherit doCheck;
@@ -48,6 +49,8 @@ in
           passthru.libPaths;
       buildPhase = ''
         mkdir -p out
+        export LANG=C.UTF-8
+        ln -s ${pkgs.writeText "dapprc" dapprc} ./.dapprc
         export DAPP_SOLC=${solc}
         export DAPP_REMAPPINGS="$REMAPPINGS"
         export DAPP_SRC=$src
@@ -59,7 +62,7 @@ in
       '';
 
       checkPhase = let
-        cmd = "DAPP_SKIP_BUILD=1 dapp test ${dappFlags}";
+        cmd = "DAPP_SKIP_BUILD=1 dapp test ${testFlags}";
       in
         if shouldFail
           then "${cmd} && exit 1 || echo 0"

src/dapp-tests/default.nix

@@ -114,11 +114,10 @@ let
     deps = [ ds-test ds-thing ];
   };
 
-  runTest = { dir, shouldFail, name, dappFlags?"" }: pkgs.buildDappPackage {
-    inherit name shouldFail;
+  runTest = { dir, shouldFail, name, dapprc ? "", testFlags ? "" }: pkgs.buildDappPackage {
+    inherit name shouldFail testFlags dapprc;
     solc=solc-0_6_7;
     src = dir;
-    dappFlags = "${dappFlags}";
     deps = [ ds-test ds-token ds-math ];
     checkInputs = with pkgs; [ hevm jq seth dapp solc ];
   };
@@ -128,15 +127,44 @@ in
       dir = ./pass;
       name = "dappTestsShouldPass";
       shouldFail = false;
-      dappFlags = "--max-iterations 50 --smttimeout 600000 --ffi";
+      testFlags = "--max-iterations 50 --smttimeout 600000 --ffi -v";
+    };
+
+    envVars = let
+      envVarTest = match : dapprc : runTest {
+        testFlags = "--match ${match}";
+        dir = ./env;
+        name = "dappTestEnvVar";
+        shouldFail = false;
+        inherit dapprc;
+      };
+      seth = "${pkgs.seth}/bin/seth";
+    in pkgs.recurseIntoAttrs {
+      # we get "hevm: insufficient balance for gas cost" if we run these together...
+      # maybe we need an env var to set the balance for the origin?
+      origin = envVarTest "origin.sol" "export DAPP_TEST_ORIGIN=$(${seth} --to-hex 256)";
+      rest = envVarTest "rest.sol" ''
+        export DAPP_TEST_BALANCE=$(${seth} --to-wei 998877665544 ether)
+        export DAPP_TEST_ADDRESS=$(${seth} --to-hex 256)
+        export DAPP_TEST_CALLER=$(${seth} --to-hex 100)
+        export DAPP_TEST_GAS_CREATE=$(${seth} --to-wei 4.20 ether)
+        export DAPP_TEST_GAS_CALL=$(${seth} --to-wei 0.69 ether)
+        export DAPP_TEST_NONCE=100
+        export DAPP_TEST_COINBASE=$(${seth} --to-hex 666)
+        export DAPP_TEST_NUMBER=420
+        export DAPP_TEST_TIMESTAMP=69
+        export DAPP_TEST_GAS_LIMIT=$(${seth} --to-wei 4206966 ether)
+        export DAPP_TEST_GAS_PRICE=100
+        export DAPP_TEST_DIFFICULTY=600
+      '';
     };
 
     shouldFail = let
       fail = match : runTest {
         dir = ./fail;
         shouldFail = true;
         name = "dappTestsShouldFail-${match}";
-        dappFlags = "--match ${match} --smttimeout 600000";
+        testFlags = "--match ${match} --smttimeout 600000";
       };
     in pkgs.recurseIntoAttrs {
       prove-add = fail "prove_add";
@@ -155,7 +183,7 @@ in
       solc = solc-0_6_7;
       src = dss-src;
       name = "dss";
-      dappFlags = "--match '[^dai].t.sol'";
+      testFlags = "--match '[^dai].t.sol'";
       deps = [ ds-test ds-token ds-value ];
     };
   }

src/dapp-tests/env/origin.sol

@@ -0,0 +1,8 @@
+import "ds-test/test.sol";
+
+contract Env is DSTest {
+    // DAPP_TEST_ORIGIN
+    function testOrigin() public {
+        assertEq(tx.origin, address(256));
+    }
+}

src/dapp-tests/env/rest.sol

@@ -0,0 +1,72 @@
+import "ds-test/test.sol";
+
+contract Env is DSTest {
+    uint creationGas;
+    constructor() public {
+        creationGas = gasleft();
+    }
+
+    // TODO: why does this fail when address == 0?
+    // DAPP_TEST_BALANCE
+    function testBalance() public {
+        assertEq(address(this).balance, 998877665544 ether);
+    }
+    // DAPP_TEST_ADDRESS
+    function testAddress() public {
+        assertEq(address(this), address(256));
+    }
+    // DAPP_TEST_NONCE
+    // we can't test the nonce directly, but can instead check the address of a newly deployed contract
+    function testNonce() public {
+        uint8 nonce = 100;
+        bytes memory payload = abi.encodePacked(hex"d694", address(this), nonce);
+
+        address expected = address(uint160(uint256(keccak256(payload))));
+        address actual = address(new Trivial());
+        assertEq(actual, expected);
+
+    }
+    // DAPP_TEST_CALLER
+    function testCaller() public {
+        assertEq(msg.sender, address(100));
+    }
+    // DAPP_TEST_GAS_CREATE
+    function testGasCreate() public {
+        // we can't be exact since we had to spend some gas to write to storage...
+        assertLt(creationGas, 4.20 ether);
+        assertGt(creationGas, 4.1999999999999 ether);
+    }
+    // DAPP_TEST_GAS_CALL
+    function testGasCall() public {
+        uint gas = gasleft();
+        // we can't be exact since we had to spend some gas to get here...
+        assertLt(gas, 0.69 ether);
+        assertGt(gas, 0.689999999999999 ether);
+    }
+    // DAPP_TEST_COINBASE
+    function testCoinbase() public {
+        assertEq(block.coinbase, address(666));
+    }
+    // DAPP_TEST_NUMBER
+    function testBlockNumber() public {
+        assertEq(block.number, 420);
+    }
+    // DAPP_TEST_TIMESTAMP
+    function testTimestamp() public {
+        assertEq(block.timestamp, 69);
+    }
+    // DAPP_TEST_GAS_LIMIT
+    function testGasLimit() public {
+        assertEq(block.gaslimit, 4206966 ether);
+    }
+    // DAPP_TEST_GAS_PRICE
+    function testGasPrice() public {
+        assertEq(tx.gasprice, 100);
+    }
+    // DAPP_TEST_DIFFICULTY
+    function testDifficulty() public {
+        assertEq(block.difficulty, 600);
+    }
+}
+
+contract Trivial {}

src/dapp-tests/pass/cheatCodes.sol

@@ -11,14 +11,29 @@ interface Hevm {
     function sign(uint256,bytes32) external returns (uint8,bytes32,bytes32);
     function addr(uint256) external returns (address);
     function ffi(string[] calldata) external returns (bytes memory);
+    function file(bytes32,uint) external;
+    function file(bytes32,address) external;
+    function file(bytes32,address,uint) external;
+    function look(bytes32) external returns (uint);
+    function look(bytes32,address) external returns (uint);
+    function replace(address,bytes calldata) external;
 }
 
 contract HasStorage {
     uint slot0 = 10;
 }
 
+contract Old {
+    uint constant public x = 10;
+}
+
+contract New {
+    uint constant public x = 100;
+}
+
 contract CheatCodes is DSTest {
     address store = address(new HasStorage());
+    Old target = new Old();
     Hevm hevm = Hevm(HEVM_ADDRESS);
 
     function test_warp_concrete(uint128 jump) public {
@@ -87,4 +102,54 @@ contract CheatCodes is DSTest {
         (string memory output) = abi.decode(hevm.ffi(inputs), (string));
         assertEq(output, "acab");
     }
+
+    function testNonce(address who, uint n) public {
+        hevm.file("nonce", who, n);
+        assertEq(hevm.look("nonce", who), n);
+    }
+
+    function testBalance(address who, uint bal) public {
+        hevm.file("balance", who, bal);
+        assertEq(who.balance, bal);
+    }
+
+    function testReplace() public {
+        hevm.replace(address(target), type(New).runtimeCode);
+        assertEq(New(address(target)).x(), 100);
+    }
+
+    function proveCaller(address who) public {
+        hevm.file("caller", who);
+        assertEq(msg.sender, who);
+    }
+
+    function testOrigin(address who) public {
+        hevm.file("origin", who);
+        assertEq(tx.origin, who);
+    }
+
+    function testCoinbase(address who) public {
+        hevm.file("coinbase", who);
+        assertEq(block.coinbase, who);
+    }
+
+    function testGasPrice(uint price) public {
+        hevm.file("gasPrice", price);
+        assertEq(tx.gasprice, price);
+    }
+
+    function testTxGasLimit(uint limit) public {
+        hevm.file("txGasLimit", limit);
+        assertEq(hevm.look("txGasLimit"), limit);
+    }
+
+    function testBlockGasLimit(uint limit) public {
+        hevm.file("blockGasLimit", limit);
+        assertEq(block.gaslimit, limit);
+    }
+
+    function testDifficulty(uint difficulty) public {
+        hevm.file(bytes32("difficulty"), difficulty);
+        assertEq(block.difficulty, difficulty);
+    }
 }

src/hevm/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Added
+
+- A new configuration variable `DAPP_TEST_NONCE` has been added that allows control over the nonce of the testing contract
+
 ### Changed
 
 - The configuration variable `DAPP_TEST_BALANCE_CREATE` has been renamed to `DAPP_TEST_BALANCE`

src/hevm/README.md

@@ -239,6 +239,7 @@ These environment variables can be used to control block parameters:
 | `DAPP_TEST_GAS_CREATE` | `0xffffffffffff`                             | The gas to provide when creating the testing contract                                                         |
 | `DAPP_TEST_GAS_CALL`   | `0xffffffffffff`                             | The gas to provide to each call made to the testing contract                                                  |
 | `DAPP_TEST_BALANCE`    | `0xffffffffffffffffffffffff`                 | The balance to provide to `DAPP_TEST_ADDRESS`                                                                 |
+| `DAPP_TEST_NONCE  `    | `1`                                          | The initial nonce to use for `DAPP_TEST_ADDRESS`                                                              |
 | `DAPP_TEST_COINBASE`   | `0x0000000000000000000000000000000000000000` | The coinbase address. Will be set to the coinbase for the block at `DAPP_TEST_NUMBER` if rpc is enabled       |
 | `DAPP_TEST_NUMBER`     | `0`                                          | The block number. Will be set to the latest block if rpc is enabled                                           |
 | `DAPP_TEST_TIMESTAMP`  | `0`                                          | The block timestamp. Will be set to the timestamp for the block at `DAPP_TEST_NUMBER` if rpc is enabled       |