feat: added support for zksync work arounds (#24)

Author: PatrickAlphaC

.gitignore

@@ -18,3 +18,6 @@ docs/
 *report.md
 reports/*.*
 
+
+# zkSync
+zkout/

README.md

@@ -4,14 +4,21 @@ A repo to get the most recent deployment from a given environment in foundry. Th
 
 It will look through your `broadcast` folder at your most recent deployment.
 
+## Features
+- Get the most recent deployment of a contract in foundry
+- Checking if your on a zkSync based chain
+
 - [foundry-devops](#foundry-devops)
+  - [Features](#features)
 - [Getting Started](#getting-started)
   - [Requirements](#requirements)
   - [Installation](#installation)
-  - [Usage](#usage)
+  - [Usage - Getting the most recent deployment](#usage---getting-the-most-recent-deployment)
+  - [Usage - zkSync Checker](#usage---zksync-checker)
 - [Contributing](#contributing)
   - [Testing](#testing)
 
+
 # Getting Started
 
 ## Requirements
@@ -25,7 +32,7 @@ It will look through your `broadcast` folder at your most recent deployment.
 
 ## Installation
 
-```
+```bash
 forge install Cyfrin/foundry-devops --no-commit
 ```
 
@@ -37,15 +44,18 @@ git rm -rf lib/forge-std
  rm -rf lib/forge-std
 ```
 ```
- forge install foundry-rs/[email protected].0 --no-commit
+ forge install foundry-rs/[email protected].2 --no-commit
 ```
 
-## Usage
+## Usage - Getting the most recent deployment
 
 1. Update your `foundry.toml` to have read permissions on the `broadcast` folder.
 
-```
-fs_permissions = [{ access = "read", path = "./broadcast" }]
+```toml
+fs_permissions = [
+    { access = "read", path = "./broadcast" },
+    { access = "read", path = "./reports" },
+]
 ```
 
 2. Import the package, and call `DevOpsTools.get_most_recent_deployment("MyContract", chainid);`
@@ -65,6 +75,57 @@ function interactWithPreviouslyDeployedContracts() public {
 }
 ```
 
+## Usage - zkSync Checker
+
+### Prerequisites
+- [foundry-zksync](https://github.com/matter-labs/foundry-zksync)
+  - You'll know you did it right if you can run `foundryup-zksync --help` and you see a response like:
+```
+The installer for Foundry-zksync.
+
+Update or revert to a specific Foundry-zksync version with ease.
+.
+.
+.
+```
+
+### Usage - ZkSyncChecker
+
+In your contract, you can import and inherit the abstract contract `ZkSyncChecker` to check if you are on a zkSync based chain. And add the `skipZkSync` modifier to any function you want to skip if you are on a zkSync based chain.
+
+It will check both the precompiles or the `chainid` to determine if you are on a zkSync based chain.
+
+```javascript
+import {ZkSyncChecker} from "lib/foundry-devops/src/ZkSyncChecker.sol";
+
+contract MyContract is ZkSyncChecker {
+
+  function doStuff() skipZkSync {
+```
+
+### ZkSyncChecker modifiers:
+- `skipZkSync`: Skips the function if you are on a zkSync based chain.
+- `onlyZkSync`: Only allows the function if you are on a zkSync based chain.
+  
+### ZkSync Checker Functions:
+- `isZkSyncChain()`: Returns true if you are on a zkSync based chain.
+- `isOnZkSyncPrecompiles()`: Returns true if you are on a zkSync based chain using the precompiles.
+- `isOnZkSyncChainId()`: Returns true if you are on a zkSync based chain using the chainid.
+
+### Usage - FoundryZkSyncChecker
+
+In your contract, you can import and inherit the abstract contract `FoundryZkSyncChecker` to check if you are on the `foundry-zksync` fork of `foundry`. 
+
+> !Important: Functions and modifiers in `FoundryZkSyncChecker` are only available if you run `foundry-zksync` with the `--zksync` flag.
+
+```javascript
+import {FoundryZkSyncChecker} from "lib/foundry-devops/src/FoundryZkSyncChecker.sol";
+
+contract MyContract is FoundryZkSyncChecker {
+
+  function doStuff() onlyFoundryZkSync {
+```
+
 # Contributing
 
 PRs are welcome!
@@ -77,6 +138,14 @@ forge install
 
 ## Testing
 
+For testing on vanilla foundry, run:
+
+```bash
+make test
 ```
-forge test
-```
+
+For testing with `foundry-zksync`, run:
+
+```bash
+make test-zksync
+```

foundry.toml

@@ -6,5 +6,11 @@ fs_permissions = [
     { access = "read", path = "./broadcast" },
     { access = "read", path = "./reports" },
 ]
+ffi = true
 
-# See more config options https://github.com/foundry-rs/foundry/tree/master/config
+
+[rpc_endpoints]
+mainnet = "${MAINNET_RPC_URL}"
+zksync = "${ZKSYNC_RPC_URL}"
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

makefile

@@ -1,4 +1,4 @@
-.PHONY: update anvil deploy
+.PHONY: update anvil deploy test test-zksync
 
 DEFAULT_ANVIL_KEY := 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
 
@@ -8,4 +8,8 @@ anvil:;  anvil -m 'test test test test test test test test test test test junk'
 
 deploy:; forge script script/DeployStuff.s.sol:DeployStuff --broadcast --rpc-url http://localhost:8545  --private-key $(DEFAULT_ANVIL_KEY)   -vvvv 
 
-interact:; forge script script/InteractWithStuff.s.sol:InteractWithStuff --broadcast --rpc-url http://localhost:8545  --private-key $(DEFAULT_ANVIL_KEY)   -vvvv 
+interact:; forge script script/InteractWithStuff.s.sol:InteractWithStuff --broadcast --rpc-url http://localhost:8545  --private-key $(DEFAULT_ANVIL_KEY)   -vvvv 
+
+test-zksync :; foundryup-zksync && forge test --zksync
+
+test :; foundryup && forge test

src/FoundryZkSyncChecker.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {Script, console2} from "forge-std/Script.sol";
+
+abstract contract FoundryZkSyncChecker is Script {
+    /**
+     * @notice returns the current version of foundry.
+     */
+    function is_foundry_zksync() internal returns (bool) {
+        string[] memory command = new string[](2);
+        command[0] = "bash";
+        command[1] = "src/is_foundry_zksync.sh";
+        bytes memory retData = vm.ffi(command);
+        bool isFoundryZkSync = uint256(bytes32(retData)) > 0;
+        return isFoundryZkSync;
+    }
+
+    modifier onlyFoundryZkSync() {
+        if (!is_foundry_zksync()) {
+            console2.log("Only foundry-zksync works with this function");
+        } else {
+            _;
+        }
+    }
+
+    modifier onlyVanillaFoundry() {
+        if (is_foundry_zksync()) {
+            console2.log("Only foundry works with this function");
+        } else {
+            _;
+        }
+    }
+}

src/ZkSyncChainChecker.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+pragma solidity ^0.8.18;
+
+import {console2} from "forge-std/console2.sol";
+
+abstract contract ZkSyncChainChecker {
+    uint256 zkSyncMainnetChainId = 324;
+    uint256 zkSyncSepoliaChainId = 300;
+    uint256 zkSyncInMemoryNodeChainId = 260;
+
+    function isOnZkSyncChainId() public view returns (bool) {
+        // We can make a "dummy" check by looking at the chainId, but this won't work for when working with foundry
+        return block.chainid == zkSyncMainnetChainId || block.chainid == zkSyncSepoliaChainId
+            || block.chainid == zkSyncInMemoryNodeChainId;
+    }
+
+    function isOnZkSyncPrecompiles() public returns (bool isZkSync) {
+        // https://docs.zksync.io/build/developer-reference/differences-with-ethereum.html#precompiles
+        // As of writing, at least 0x03, 0x04, 0x05, and 0x08 precompiles are not supported on zkSync
+        // So, we can call them to check if we are on zkSync or not
+        // This test may fail in the future if these precompiles become supported on zkSync
+        uint256 value = 1;
+        address ripemd = address(uint160(3));
+        address identity = address(uint160(4));
+        address modexp = address(uint160(5));
+        address ecPairing = address(uint160(8));
+
+        address[4] memory targets = [ripemd, identity, modexp, ecPairing];
+
+        for (uint256 i = 0; i < targets.length; i++) {
+            bool success;
+            address target = targets[i];
+            assembly {
+                success := call(gas(), target, value, 0, 0, 0, 0)
+            }
+            if (!success) {
+                isZkSync = true;
+                return isZkSync;
+            }
+        }
+        return isZkSync;
+    }
+
+    function isZkSyncChain() public returns (bool isZkSync) {
+        if (isOnZkSyncChainId()) {
+            return isZkSync;
+        }
+        return isOnZkSyncPrecompiles();
+    }
+
+    modifier skipZkSync() {
+        if (isZkSyncChain()) {
+            console2.log("Skipping test because we are on zkSync");
+            return;
+        } else {
+            _;
+        }
+    }
+
+    modifier onlyZkSync() {
+        if (!isZkSyncChain()) {
+            console2.log("Skipping test because we are not on zkSync");
+            return;
+        } else {
+            _;
+        }
+    }
+}

src/is_foundry_zksync.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+output=$(forge --version)
+
+if [[ $output == forge\ 0.2.0* ]]; then
+    echo 0x00 # This is false
+else
+    echo 0x01 # This is true
+fi

test/DevOpsToolsTest.t.sol

@@ -3,34 +3,36 @@ pragma solidity >=0.8.0 <0.9.0;
 
 import {Test} from "forge-std/Test.sol";
 import {DevOpsTools} from "../src/DevOpsTools.sol";
+import {ZkSyncChainChecker} from "../src/ZkSyncChainChecker.sol";
+import {FoundryZkSyncChecker} from "../src/FoundryZkSyncChecker.sol";
 
-contract DevOpsToolsTest is Test {
+contract DevOpsToolsTest is Test, ZkSyncChainChecker, FoundryZkSyncChecker {
     string public constant SEARCH_PATH = "broadcast";
 
-    function testGetMostRecentlyDeployedContract() public view {
+    function testGetMostRecentlyDeployedContract() public skipZkSync onlyVanillaFoundry {
         string memory contractName = "Stuff";
         uint256 chainId = 31337;
         address expectedAddress = 0x5FbDB2315678afecb367f032d93F642f64180aa3;
         address mostRecentDeployment = DevOpsTools.get_most_recent_deployment(contractName, chainId, SEARCH_PATH);
         assertEq(mostRecentDeployment, expectedAddress);
     }
 
-    function testGetMostRecentlyDeployedEvenWhenMultipleAreDeployed() public view {
+    function testGetMostRecentlyDeployedEvenWhenMultipleAreDeployed() public skipZkSync onlyVanillaFoundry {
         string memory contractName = "FundMe";
         uint256 chainId = 1234;
         address expectedAddress = 0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9;
         address mostRecentDeployment = DevOpsTools.get_most_recent_deployment(contractName, chainId, SEARCH_PATH);
         assertEq(mostRecentDeployment, expectedAddress);
     }
 
-    function testExpectRevertIfNoRun() public {
+    function testExpectRevertIfNoRun() public onlyVanillaFoundry {
         string memory contractName = "FundMe";
         uint256 chainId = 9999;
         vm.expectRevert("No deployment artifacts were found for specified chain");
         DevOpsTools.get_most_recent_deployment(contractName, chainId, SEARCH_PATH);
     }
 
-    function testExpectRevertIfNoDeployment() public {
+    function testExpectRevertIfNoDeployment() public skipZkSync onlyVanillaFoundry {
         string memory contractName = "MissingContract";
         uint256 chainId = 1234;
         vm.expectRevert("No contract deployed");
@@ -39,7 +41,7 @@ contract DevOpsToolsTest is Test {
 
     // All other tests use what appear to be legacy broadcast files
     // This one uses the newer type with no rpc property
-    function testNonLegacyBroadcast() public view {
+    function testNonLegacyBroadcast() public skipZkSync onlyVanillaFoundry {
         string memory contractName = "NewStuff";
         uint256 chainId = 31337;
         address expectedAddress = 0x5FbDB2315678afecb367f032d93F642f64180aa3;

test/ZkSyncChainCheckerLocalTest.t.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIt
+pragma solidity ^0.8.18;
+
+import {ZkSyncChainChecker} from "src/ZkSyncChainChecker.sol";
+import {FoundryZkSyncChecker} from "src/FoundryZkSyncChecker.sol";
+import {Test, console2} from "forge-std/Test.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+contract Checker is ZkSyncChainChecker {}
+
+/**
+ * @title ZkSyncChainCheckerLocalTest
+ * @author Patrick Collins
+ * @notice We need to test the local zkSync edition separately, because we cannot do
+ * vm.selectFork on foundry-zksync
+ */
+contract ZkSyncChainCheckerLocalTest is Test, FoundryZkSyncChecker {
+    Checker checkerLocal;
+    uint256 AMOUNT = 1e18;
+
+    function setUp() public {
+        checkerLocal = new Checker();
+        vm.deal(address(checkerLocal), AMOUNT);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               BY CHAINID
+    //////////////////////////////////////////////////////////////*/
+    function testIsOnZkSyncChainByChainId_local() public onlyVanillaFoundry {
+        assertEq(checkerLocal.isOnZkSyncChainId(), false);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                             BY PRECOMPILES
+    //////////////////////////////////////////////////////////////*/
+    function testIsOnZkSyncByPrecompiles_local() public onlyFoundryZkSync {
+        assertEq(checkerLocal.isOnZkSyncPrecompiles(), true);
+    }
+}