feat: add backend signature verification to the swapper

kkirka · Exef · commit 09d41448409a · 2025-11-05T12:01:48.000+01:00
diff --git a/contracts/SwapHelper/SwapHelper.sol b/contracts/SwapHelper/SwapHelper.sol
@@ -3,25 +3,37 @@ pragma solidity 0.8.25;
 
 import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
 import { AddressUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
+import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
 import { IWBNB } from "../Interfaces.sol";
 
-contract SwapHelper {
+contract SwapHelper is EIP712 {
     using SafeERC20Upgradeable for IERC20Upgradeable;
     using AddressUpgradeable for address;
 
     uint256 internal constant REENTRANCY_LOCK_UNLOCKED = 1;
     uint256 internal constant REENTRANCY_LOCK_LOCKED = 2;
+    bytes32 internal constant MULTICALL_TYPEHASH = keccak256("Multicall(bytes[] calls,uint256 deadline)");
 
     /// @notice Wrapped native asset
     IWBNB public immutable WRAPPED_NATIVE;
 
+    /// @notice Venus backend signer
+    address public immutable BACKEND_SIGNER;
+
     /// @dev Reentrancy lock to prevent reentrancy attacks
     uint256 private reentrancyLock;
 
     /// @notice Error thrown when reentrancy is detected
     error Reentrancy();
 
+    /// @notice Error thrown when deadline is reached
+    error DeadlineReached();
+
+    /// @notice Error thrown when caller is not the authorized backend signer
+    error Unauthorized();
+
     /// @notice In the locked state, allow contract to call itself, but block all external calls
     modifier externalLock() {
         bool isExternal = msg.sender != address(this);
@@ -36,15 +48,37 @@ contract SwapHelper {
         if (isExternal) reentrancyLock = REENTRANCY_LOCK_UNLOCKED;
     }
 
-    constructor(address wrappedNative_) {
+    /// @notice Constructor
+    /// @param wrappedNative_ Address of the wrapped native asset
+    /// @param backendSigner_ Address of the backend signer
+    constructor(address wrappedNative_, address backendSigner_) EIP712("VenusSwap", "1") {
         WRAPPED_NATIVE = IWBNB(wrappedNative_);
+        BACKEND_SIGNER = backendSigner_;
     }
 
     /// @notice Multicall function to execute multiple calls in a single transaction
-    /// @param data Array of calldata to execute
-    function multicall(bytes[] calldata data) external payable {
-        for (uint256 i = 0; i < data.length; i++) {
-            address(this).functionCall(data[i]);
+    /// @param calls Array of calldata to execute
+    /// @param deadline Deadline for the transaction
+    /// @param signature Backend signature
+    function multicall(
+        bytes[] calldata calls,
+        uint256 deadline,
+        bytes calldata signature
+    ) external payable externalLock {
+        if (block.timestamp > deadline) {
+            revert DeadlineReached();
+        }
+
+        if (signature.length != 0) {
+            bytes32 digest = _hashMulticall(calls, deadline);
+            address signer = ECDSA.recover(digest, signature);
+            if (signer != BACKEND_SIGNER) {
+                revert Unauthorized();
+            }
+        }
+
+        for (uint256 i = 0; i < calls.length; i++) {
+            address(this).functionCall(calls[i]);
         }
     }
 
@@ -75,4 +109,19 @@ contract SwapHelper {
         token.forceApprove(spender, 0);
         token.forceApprove(spender, type(uint256).max);
     }
+
+    /// @notice Produces an EIP-712 digest of the multicall data
+    /// @param calls Array of calldata to execute
+    /// @param deadline Deadline for the transaction
+    /// @return Digest of the multicall data
+    function _hashMulticall(bytes[] calldata calls, uint256 deadline) internal view returns (bytes32) {
+        bytes32[] memory callHashes = new bytes32[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            callHashes[i] = keccak256(calls[i]);
+        }
+        return
+            _hashTypedDataV4(
+                keccak256(abi.encode(MULTICALL_TYPEHASH, keccak256(abi.encodePacked(callHashes)), deadline))
+            );
+    }
 }
diff --git a/contracts/test/Imports.sol b/contracts/test/Imports.sol
@@ -1,8 +1,11 @@
+// SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.5.16;
+
 import { ComptrollerMock } from "@venusprotocol/venus-protocol/contracts/test/ComptrollerMock.sol";
 import { VBNB } from "@venusprotocol/venus-protocol/contracts/Tokens/VTokens/VBNB.sol";
 import { Diamond } from "@venusprotocol/venus-protocol/contracts/Comptroller/Diamond/Diamond.sol";
 import { InterestRateModelHarness } from "@venusprotocol/venus-protocol/contracts/test/InterestRateModelHarness.sol";
 import { MockVBNB } from "@venusprotocol/venus-protocol/contracts/test/MockVBNB.sol";
 import { VBep20Harness } from "@venusprotocol/venus-protocol/contracts/test/VBep20Harness.sol";
 import { ComptrollerLens } from "@venusprotocol/venus-protocol/contracts/Lens/ComptrollerLens.sol";
+import { FaucetToken } from "@venusprotocol/venus-protocol/contracts/test/FaucetToken.sol";
diff --git a/contracts/test/ImportsV8.sol b/contracts/test/ImportsV8.sol
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.25;
 
 import { IAccessControlManagerV8 } from "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol";
diff --git a/tests/hardhat/SwapHelper/SwapHelper.ts b/tests/hardhat/SwapHelper/SwapHelper.ts
@@ -1,42 +1,152 @@
 import { expect } from "chai";
 import { Signer } from "ethers";
-import { parseUnits } from "ethers/lib/utils";
-import { ethers } from "hardhat";
+import { _TypedDataEncoder, parseUnits } from "ethers/lib/utils";
+import { ethers, network } from "hardhat";
 
-import { SwapHelper, WBNB } from "../../../typechain";
+import { FaucetToken, SwapHelper, WBNB } from "../../../typechain";
 
 describe("SwapHelper", () => {
+  const maxUint256 = ethers.constants.MaxUint256;
+  let owner: Signer;
   let user1: Signer;
+  let user2: Signer;
   let userAddress: string;
+  let user2Address: string;
   let swapHelper: SwapHelper;
   let wBNB: WBNB;
+  let erc20: FaucetToken;
 
   beforeEach(async () => {
-    [user1] = await ethers.getSigners();
+    [owner, user1, user2] = await ethers.getSigners();
     userAddress = await user1.getAddress();
+    user2Address = await user2.getAddress();
 
     const WBNBFactory = await ethers.getContractFactory("WBNB");
     wBNB = await WBNBFactory.deploy();
 
+    const ERC20Factory = await ethers.getContractFactory("FaucetToken");
+    erc20 = await ERC20Factory.deploy(parseUnits("10000", 18), "Test Token", 18, "TEST");
+
     const SwapHelperFactory = await ethers.getContractFactory("SwapHelper");
-    swapHelper = await SwapHelperFactory.deploy(wBNB.address);
+    swapHelper = await SwapHelperFactory.deploy(wBNB.address, await owner.getAddress());
+  });
+
+  describe("wrap", () => {
+    it("should only work within multicall", async () => {
+      const amount = parseUnits("1", 18);
+      expect(await wBNB.balanceOf(userAddress)).to.equal(0);
+      const wrapData = await swapHelper.populateTransaction.wrap(amount);
+      await swapHelper.connect(user1).multicall([wrapData.data!], maxUint256, "0x", { value: amount });
+      expect(await wBNB.balanceOf(swapHelper.address)).to.equal(amount);
+    });
+  });
+
+  describe("sweep", () => {
+    it("should sweep ERC20 tokens to specified address", async () => {
+      const amount = parseUnits("1000", 18);
+      await erc20.connect(owner).transfer(swapHelper.address, amount);
+      expect(await erc20.balanceOf(swapHelper.address)).to.equal(amount);
+      expect(await erc20.balanceOf(userAddress)).to.equal(0);
+
+      await swapHelper.connect(user1).sweep(erc20.address, userAddress);
+      expect(await erc20.balanceOf(swapHelper.address)).to.equal(0);
+      expect(await erc20.balanceOf(userAddress)).to.equal(amount);
+    });
+
+    it("should work within multicall", async () => {
+      const amount = parseUnits("1000", 18);
+      await erc20.connect(owner).transfer(swapHelper.address, amount);
+      const sweepData = await swapHelper.populateTransaction.sweep(erc20.address, userAddress);
+      await swapHelper.connect(user1).multicall([sweepData.data!], maxUint256, "0x");
+      expect(await erc20.balanceOf(swapHelper.address)).to.equal(0);
+      expect(await erc20.balanceOf(userAddress)).to.equal(amount);
+    });
+
+    it("should wrap and transfer all in a single call", async () => {
+      const amount = parseUnits("1", 18);
+      expect(await wBNB.balanceOf(userAddress)).to.equal(0);
+      const wrapData = await swapHelper.populateTransaction.wrap(amount);
+      const sweepData = await swapHelper.populateTransaction.sweep(wBNB.address, userAddress);
+      await swapHelper.connect(user1).multicall([wrapData.data!, sweepData.data!], maxUint256, "0x", { value: amount });
+      expect(await wBNB.balanceOf(swapHelper.address)).to.equal(0);
+      expect(await wBNB.balanceOf(userAddress)).to.equal(amount);
+    });
   });
 
-  it("should wrap native BNB into WBNB", async () => {
-    const amount = parseUnits("1", 18);
-    expect(await wBNB.balanceOf(userAddress)).to.equal(0);
-    const wrapData = await swapHelper.populateTransaction.wrap(amount);
-    expect(await swapHelper.connect(user1).multicall([wrapData.data!], { value: amount }));
-    expect(await wBNB.balanceOf(swapHelper.address)).to.equal(amount);
+  describe("approveMax", () => {
+    it("should approve maximum amount to a spender", async () => {
+      const spender = user2Address;
+      expect(await erc20.allowance(swapHelper.address, spender)).to.equal(0);
+      await swapHelper.connect(user1).approveMax(erc20.address, spender);
+      expect(await erc20.allowance(swapHelper.address, spender)).to.equal(maxUint256);
+    });
+
+    it("should work within multicall", async () => {
+      const spender = user2Address;
+      const approveData = await swapHelper.populateTransaction.approveMax(erc20.address, spender);
+      await swapHelper.connect(user1).multicall([approveData.data!], maxUint256, "0x");
+      expect(await erc20.allowance(swapHelper.address, spender)).to.equal(maxUint256);
+    });
   });
 
-  it("should wrap and transfer all in a single call", async () => {
-    const amount = parseUnits("1", 18);
-    expect(await wBNB.balanceOf(userAddress)).to.equal(0);
-    const wrapData = await swapHelper.populateTransaction.wrap(amount);
-    const sweepData = await swapHelper.populateTransaction.sweep(wBNB.address, userAddress);
-    expect(await swapHelper.connect(user1).multicall([wrapData.data!, sweepData.data!], { value: amount }));
-    expect(await wBNB.balanceOf(swapHelper.address)).to.equal(0);
-    expect(await wBNB.balanceOf(userAddress)).to.equal(amount);
+  describe("multicall", () => {
+    const types = {
+      Multicall: [
+        { name: "calls", type: "bytes[]" },
+        { name: "deadline", type: "uint256" },
+      ],
+    };
+
+    it("should revert if deadline is in the past", async () => {
+      const amount = parseUnits("1", 18);
+      const wrapData = await swapHelper.populateTransaction.wrap(amount);
+      await expect(
+        swapHelper.connect(user1).multicall([wrapData.data!], 1234, "0x", { value: amount }),
+      ).to.be.revertedWithCustomError(swapHelper, "DeadlineReached");
+    });
+
+    it("should check signature if provided", async () => {
+      const domain = {
+        chainId: network.config.chainId,
+        name: "VenusSwap",
+        verifyingContract: swapHelper.address,
+        version: "1",
+      };
+      const singleAmount = parseUnits("1", 18);
+      const totalAmount = singleAmount.mul(3);
+      const wrapData = await swapHelper.populateTransaction.wrap(singleAmount);
+      const calls = [wrapData.data!, wrapData.data!, wrapData.data!];
+      const deadline = maxUint256;
+      const signature = await owner._signTypedData(domain, types, { calls, deadline });
+      await swapHelper.connect(user1).multicall(calls, deadline, signature, { value: totalAmount });
+      expect(await wBNB.balanceOf(swapHelper.address)).to.equal(totalAmount);
+    });
+
+    it("should revert if the signature is invalid", async () => {
+      const domain = {
+        chainId: network.config.chainId,
+        name: "VenusSwap",
+        verifyingContract: swapHelper.address,
+        version: "1",
+      };
+      const singleAmount = parseUnits("1", 18);
+      const totalAmount = singleAmount.mul(3);
+      const wrapData = await swapHelper.populateTransaction.wrap(singleAmount);
+      const deadline = maxUint256;
+      const signature = await owner._signTypedData(domain, types, {
+        // authorizing just one call, not 3
+        calls: [wrapData.data!],
+        deadline,
+      });
+      await expect(
+        swapHelper.connect(user1).multicall(
+          // trying to execute 3 txs, but only 1 is authorized
+          [wrapData.data!, wrapData.data!, wrapData.data!],
+          deadline,
+          signature,
+          { value: totalAmount },
+        ),
+      ).to.be.revertedWithCustomError(swapHelper, "Unauthorized");
+    });
   });
 });

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+// SPDX-License-Identifier: BSD-3-Clause`
`1`	`2`	`pragma solidity 0.8.25;`
`2`	`3`
`3`	`4`	`import { IAccessControlManagerV8 } from "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol";`