refactor: rename GelatoRelayerContext with GELATO_RELAY constant and …

…no constructor (#3)

.husky/pre-push

@@ -1,4 +1,4 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-# yarn test
+yarn test

.solhintignore

@@ -1,5 +1,6 @@
 node_modules/
 contracts/functions
-contracts/vendor
 contracts/interfaces
-contracts/__mocks__
+contracts/vendor
+
+

contracts/RelayerContext.sol → contracts/GelatoRelayerContext.sol

@@ -2,9 +2,10 @@
 pragma solidity ^0.8.1;
 
 import {TokenUtils} from "./lib/TokenUtils.sol";
+import {GELATO_RELAY} from "./constants/GelatoRelay.sol";
 
 /**
- * @dev Context variant with RelayerFee support.
+ * @dev Context variant with Gelato Relayer Fee support.
  * Expects calldata encoding:
  *   abi.encodePacked(bytes fnArgs, address feeCollectorAddress, address feeToken, uint256 fee)
  * Therefore, we're expecting 3 * 32bytes to be appended to normal msgData
@@ -13,37 +14,30 @@ import {TokenUtils} from "./lib/TokenUtils.sol";
  *     feeToken: - 32 * 2
  *     fee: - 32
  */
-abstract contract RelayerContext {
+abstract contract GelatoRelayerContext {
     using TokenUtils for address;
 
-    /// @dev Only use with a safe whitelisted trusted forwarder contract (e.g. GelatoRelay)
-    address public immutable relayer;
-
-    // RelayerContext
+    // GelatoRelayerContext
     uint256 internal constant _FEE_COLLECTOR_START = 3 * 32;
     uint256 internal constant _FEE_TOKEN_START = 2 * 32;
     uint256 internal constant _FEE_START = 32;
 
     modifier onlyRelayer() {
-        require(_isRelayer(msg.sender), "RelayerContext.onlyRelayer");
+        require(_isRelayer(msg.sender), "GelatoRelayerContext.onlyRelayer");
         _;
     }
 
-    constructor(address _relayer) {
-        relayer = _relayer;
-    }
-
     // DANGER! Only use with onlyRelayer `_isRelayer` before transferring
-    function _transferToFeeCollectorUncapped() internal {
+    function _transferRelayFee() internal {
         _getFeeToken().transfer(_getFeeCollector(), _getFee());
     }
 
     // DANGER! Only use with onlyRelayer `_isRelayer` before transferring
-    function _transferToFeeCollectorCapped(uint256 _maxFee) internal {
+    function _transferRelayFeeCapped(uint256 _maxFee) internal {
         uint256 fee = _getFee();
         require(
             fee <= _maxFee,
-            "RelayerContext._transferToFeeCollectorCapped: maxFee"
+            "GelatoRelayerContext._transferRelayFeeCapped: maxFee"
         );
         _getFeeToken().transfer(_getFeeCollector(), fee);
     }
@@ -54,7 +48,7 @@ abstract contract RelayerContext {
         virtual
         returns (bool)
     {
-        return _forwarder == relayer;
+        return _forwarder == GELATO_RELAY;
     }
 
     function _msgData() internal view returns (bytes calldata) {

contracts/__mocks__/MockGelatoRelayerContext.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+// import {
+//     GelatoRelayerContext
+// } from "@gelatonetwork/relayer-context/contracts/GelatoRelayerContext.sol";
+import {GelatoRelayerContext} from "../GelatoRelayerContext.sol";
+
+contract MockGelatoRelayerContext is GelatoRelayerContext {
+    event LogMsgData(bytes msgData);
+    event LogFnArgs(bytes fnArgs);
+    event LogContext(address feeCollector, address feeToken, uint256 fee);
+
+    function emitContext() external {
+        emit LogMsgData(msg.data);
+        emit LogFnArgs(_msgData());
+        emit LogContext(_getFeeCollector(), _getFeeToken(), _getFee());
+    }
+
+    function testTransferRelayFee() external {
+        _transferRelayFee();
+    }
+
+    function testTransferRelayFeeCapped(uint256 _maxFee) external {
+        _transferRelayFeeCapped(_maxFee);
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function testOnlyRelayer() external onlyRelayer {}
+}

contracts/constants/GelatoRelay.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.1;
+
+address constant GELATO_RELAY = 0xaBcC9b596420A9E9172FD5938620E265a0f9Df92;

deploy/MockRelayerContext.deploy.ts

@@ -11,17 +11,15 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
     process.exit(1);
   }
 
-  await deploy("MockRelayerContext", {
+  await deploy("MockGelatoRelayerContext", {
     from: deployer,
-    args: [(await deployments.get("MockRelayer")).address],
   });
 };
 
 func.skip = async (hre: HardhatRuntimeEnvironment) => {
   return hre.network.name !== "hardhat";
 };
 
-func.tags = ["MockRelayerContext"];
-func.dependencies = ["MockRelayer"];
+func.tags = ["MockGelatoRelayerContext"];
 
 export default func;

package.json

@@ -39,18 +39,18 @@
     "@typechain/hardhat": "6.1.2",
     "@types/chai": "4.3.3",
     "@types/mocha": "9.1.1",
-    "@types/node": "18.7.13",
-    "@typescript-eslint/eslint-plugin": "5.35.1",
-    "@typescript-eslint/parser": "5.35.1",
+    "@types/node": "18.7.15",
+    "@typescript-eslint/eslint-plugin": "5.36.2",
+    "@typescript-eslint/parser": "5.36.2",
     "chai": "4.3.6",
-    "dotenv": "16.0.1",
-    "eslint": "8.22.0",
+    "dotenv": "16.0.2",
+    "eslint": "8.23.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-prettier": "4.2.1",
     "ethereum-waffle": "3.4.4",
     "ethers": "5.7.0",
-    "hardhat": "2.10.2",
-    "hardhat-deploy": "0.11.12",
+    "hardhat": "2.11.1",
+    "hardhat-deploy": "0.11.14",
     "husky": "8.0.1",
     "lint-staged": "13.0.3",
     "prettier": "2.7.1",
@@ -60,7 +60,7 @@
     "ts-generator": "0.1.1",
     "ts-node": "10.9.1",
     "typechain": "8.1.0",
-    "typescript": "4.7.4"
+    "typescript": "4.8.2"
   },
   "lint-staged": {
     "*.*{js,sol,json,md,ts,yml,yaml}": "prettier --write",

test/MockRelayerContext.test.ts

@@ -1,17 +1,17 @@
 import hre = require("hardhat");
 import { expect } from "chai";
 //import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signers";
-import { MockRelayer, MockRelayerContext, MockERC20 } from "../typechain";
+import { MockRelayer, MockGelatoRelayerContext, MockERC20 } from "../typechain";
 import { INIT_TOKEN_BALANCE as FEE } from "./constants";
 import { ethers } from "hardhat";
 
 const FEE_COLLECTOR = "0x3CACa7b48D0573D793d3b0279b5F0029180E83b6";
 
-describe("Test MockRelayer Smart Contract", function () {
+describe("Test MockGelatoRelayContext Smart Contract", function () {
   // let user: SignerWithAddress;
 
   let mockRelayer: MockRelayer;
-  let mockRelayerContext: MockRelayerContext;
+  let mockRelayerContext: MockGelatoRelayerContext;
   let mockERC20: MockERC20;
 
   let target: string;
@@ -25,18 +25,15 @@ describe("Test MockRelayer Smart Contract", function () {
 
     await hre.deployments.fixture();
 
-    //  [user] = await hre.ethers.getSigners();
-
     mockRelayer = await hre.ethers.getContract("MockRelayer");
-    mockRelayerContext = await hre.ethers.getContract("MockRelayerContext");
+    mockRelayerContext = await hre.ethers.getContract(
+      "MockGelatoRelayerContext"
+    );
     mockERC20 = await hre.ethers.getContract("MockERC20");
 
     target = mockRelayerContext.address;
     feeToken = mockERC20.address;
   });
-  it("#0: MockRelayerContext has MockRelayer set as relayer", async () => {
-    expect(await mockRelayerContext.relayer()).to.be.eq(mockRelayer.address);
-  });
 
   it("#1: emitContext", async () => {
     const data = mockRelayerContext.interface.encodeFunctionData("emitContext");
@@ -62,9 +59,9 @@ describe("Test MockRelayer Smart Contract", function () {
       .withArgs(FEE_COLLECTOR, feeToken, FEE);
   });
 
-  it("#2: onlyRelayerTransferUncapped", async () => {
+  it("#2: testTransferRelayFee", async () => {
     const data = mockRelayerContext.interface.encodeFunctionData(
-      "onlyRelayerTransferUncapped"
+      "testTransferRelayFee"
     );
 
     await mockERC20.transfer(target, FEE);
@@ -74,17 +71,11 @@ describe("Test MockRelayer Smart Contract", function () {
     expect(await mockERC20.balanceOf(FEE_COLLECTOR)).to.be.eq(FEE);
   });
 
-  it("#3: onlyRelayerTransferUncapped reverts if not relayer", async () => {
-    await expect(
-      mockRelayerContext.onlyRelayerTransferUncapped()
-    ).to.be.revertedWith("RelayerContext.onlyRelayer");
-  });
-
-  it("#4: onlyRelayerTransferCapped: works if at maxFee", async () => {
+  it("#3: testTransferRelayFeeCapped: works if at maxFee", async () => {
     const maxFee = FEE;
 
     const data = mockRelayerContext.interface.encodeFunctionData(
-      "onlyRelayerTransferCapped",
+      "testTransferRelayFeeCapped",
       [maxFee]
     );
 
@@ -95,11 +86,11 @@ describe("Test MockRelayer Smart Contract", function () {
     expect(await mockERC20.balanceOf(FEE_COLLECTOR)).to.be.eq(FEE);
   });
 
-  it("#5: onlyRelayerTransferCapped: works if below maxFee", async () => {
+  it("#4: testTransferRelayFeeCapped: works if below maxFee", async () => {
     const maxFee = FEE.add(1);
 
     const data = mockRelayerContext.interface.encodeFunctionData(
-      "onlyRelayerTransferCapped",
+      "testTransferRelayFeeCapped",
       [maxFee]
     );
 
@@ -110,11 +101,11 @@ describe("Test MockRelayer Smart Contract", function () {
     expect(await mockERC20.balanceOf(FEE_COLLECTOR)).to.be.eq(FEE);
   });
 
-  it("#6: onlyRelayerTransferCapped: reverts if above maxFee", async () => {
+  it("#5: testTransferRelayFeeCapped: reverts if above maxFee", async () => {
     const maxFee = FEE.sub(1);
 
     const data = mockRelayerContext.interface.encodeFunctionData(
-      "onlyRelayerTransferCapped",
+      "testTransferRelayFeeCapped",
       [maxFee]
     );
 
@@ -123,13 +114,13 @@ describe("Test MockRelayer Smart Contract", function () {
     await expect(
       mockRelayer.forwardCall(target, data, FEE_COLLECTOR, feeToken, FEE)
     ).to.be.revertedWith(
-      "MockRelayer.forwardCall:RelayerContext._transferToFeeCollectorCapped: maxFee"
+      "MockRelayer.forwardCall:GelatoRelayerContext._transferRelayFeeCapped: maxFee"
     );
   });
 
-  it("#7: onlyRelayerTransferCapped reverts if not relayer", async () => {
-    await expect(
-      mockRelayerContext.onlyRelayerTransferCapped(0)
-    ).to.be.revertedWith("RelayerContext.onlyRelayer");
+  it("#6: testOnlyRelayer reverts if not relayer", async () => {
+    await expect(mockRelayerContext.testOnlyRelayer()).to.be.revertedWith(
+      "GelatoRelayerContext.onlyRelayer"
+    );
   });
 });