[SC-1213] Add support for new matcha contracts

contracts/interfaces/IEIP712.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IEIP712 {
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+}

contracts/interfaces/ISignatureTransfer.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import { IEIP712 } from "./IEIP712.sol";
+
+/// @title SignatureTransfer
+/// @notice Handles ERC20 token transfers through signature based actions
+/// @dev Requires user's token approval on the Permit2 contract
+interface ISignatureTransfer is IEIP712 {
+    /// @notice Thrown when the requested amount for a transfer is larger than the permissioned amount
+    /// @param maxAmount The maximum amount a spender can request to transfer
+    error InvalidAmount(uint256 maxAmount);
+
+    /// @notice Thrown when the number of tokens permissioned to a spender does not match the number of tokens being transferred
+    /// @dev If the spender does not need to transfer the number of tokens permitted, the spender can request amount 0 to be transferred
+    error LengthMismatch();
+
+    /// @notice Emits an event when the owner successfully invalidates an unordered nonce.
+    event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);
+
+    /// @notice The token and amount details for a transfer signed in the permit transfer signature
+    struct TokenPermissions {
+        // ERC20 token address
+        address token;
+        // the maximum amount that can be spent
+        uint256 amount;
+    }
+
+    /// @notice The signed permit message for a single token transfer
+    struct PermitTransferFrom {
+        TokenPermissions permitted;
+        // a unique value for every token owner's signature to prevent signature replays
+        uint256 nonce;
+        // deadline on the permit signature
+        uint256 deadline;
+    }
+
+    /// @notice Specifies the recipient address and amount for batched transfers.
+    /// @dev Recipients and amounts correspond to the index of the signed token permissions array.
+    /// @dev Reverts if the requested amount is greater than the permitted signed amount.
+    struct SignatureTransferDetails {
+        // recipient address
+        address to;
+        // spender requested amount
+        uint256 requestedAmount;
+    }
+
+    /// @notice Used to reconstruct the signed permit message for multiple token transfers
+    /// @dev Do not need to pass in spender address as it is required that it is msg.sender
+    /// @dev Note that a user still signs over a spender address
+    struct PermitBatchTransferFrom {
+        // the tokens and corresponding amounts permitted for a transfer
+        TokenPermissions[] permitted;
+        // a unique value for every token owner's signature to prevent signature replays
+        uint256 nonce;
+        // deadline on the permit signature
+        uint256 deadline;
+    }
+
+    /// @notice A map from token owner address and a caller specified word index to a bitmap. Used to set bits in the bitmap to prevent against signature replay protection
+    /// @dev Uses unordered nonces so that permit messages do not need to be spent in a certain order
+    /// @dev The mapping is indexed first by the token owner, then by an index specified in the nonce
+    /// @dev It returns a uint256 bitmap
+    /// @dev The index, or wordPosition is capped at type(uint248).max
+    function nonceBitmap(address, uint256) external view returns (uint256);
+
+    /// @notice Transfers a token using a signed permit message
+    /// @dev Reverts if the requested amount is greater than the permitted signed amount
+    /// @param permit The permit data signed over by the owner
+    /// @param owner The owner of the tokens to transfer
+    /// @param transferDetails The spender's requested transfer details for the permitted token
+    /// @param signature The signature to verify
+    function permitTransferFrom(
+        PermitTransferFrom memory permit,
+        SignatureTransferDetails calldata transferDetails,
+        address owner,
+        bytes calldata signature
+    ) external;
+
+    /// @notice Transfers a token using a signed permit message
+    /// @notice Includes extra data provided by the caller to verify signature over
+    /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition
+    /// @dev Reverts if the requested amount is greater than the permitted signed amount
+    /// @param permit The permit data signed over by the owner
+    /// @param owner The owner of the tokens to transfer
+    /// @param transferDetails The spender's requested transfer details for the permitted token
+    /// @param witness Extra data to include when checking the user signature
+    /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash
+    /// @param signature The signature to verify
+    function permitWitnessTransferFrom(
+        PermitTransferFrom memory permit,
+        SignatureTransferDetails calldata transferDetails,
+        address owner,
+        bytes32 witness,
+        string calldata witnessTypeString,
+        bytes calldata signature
+    ) external;
+
+    /// @notice Transfers multiple tokens using a signed permit message
+    /// @param permit The permit data signed over by the owner
+    /// @param owner The owner of the tokens to transfer
+    /// @param transferDetails Specifies the recipient and requested amount for the token transfer
+    /// @param signature The signature to verify
+    function permitTransferFrom(
+        PermitBatchTransferFrom memory permit,
+        SignatureTransferDetails[] calldata transferDetails,
+        address owner,
+        bytes calldata signature
+    ) external;
+
+    /// @notice Transfers multiple tokens using a signed permit message
+    /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition
+    /// @notice Includes extra data provided by the caller to verify signature over
+    /// @param permit The permit data signed over by the owner
+    /// @param owner The owner of the tokens to transfer
+    /// @param transferDetails Specifies the recipient and requested amount for the token transfer
+    /// @param witness Extra data to include when checking the user signature
+    /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash
+    /// @param signature The signature to verify
+    function permitWitnessTransferFrom(
+        PermitBatchTransferFrom memory permit,
+        SignatureTransferDetails[] calldata transferDetails,
+        address owner,
+        bytes32 witness,
+        string calldata witnessTypeString,
+        bytes calldata signature
+    ) external;
+
+    /// @notice Invalidates the bits specified in mask for the bitmap at the word position
+    /// @dev The wordPos is maxed at type(uint248).max
+    /// @param wordPos A number to index the nonceBitmap at
+    /// @param mask A bitmap masked against msg.sender's current bitmap at the word position
+    function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;
+}

contracts/interfaces/router/IMatchaRouter.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-pragma solidity 0.8.23;
+pragma solidity 0.8.25;
 
 interface IMatchaRouter {
     function sellToUniswap(address[] calldata tokens, uint256 sellAmount, uint256 minBuyAmount, bool isSushi) external payable;

contracts/interfaces/router/ISettler.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import { ISignatureTransfer } from "../ISignatureTransfer.sol";
+
+interface ISettler {
+    struct AllowedSlippage {
+        address recipient;
+        IERC20 buyToken;
+        uint256 minAmountOut;
+    }
+
+    function execute(
+        AllowedSlippage calldata slippage,
+        bytes[] calldata actions,
+        bytes32 affiliate
+    ) external payable returns (bool);
+
+    function _hasMetaTxn() external pure returns (bool);
+
+    function _msgSender() external view returns (address);
+
+    function _isRestrictedTarget(address target) external pure returns (bool);
+
+    function _dispatchVIP(bytes4 action, bytes calldata data) external returns (bool);
+}

contracts/interfaces/router/ISettlerActions.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import { ISignatureTransfer } from "../ISignatureTransfer.sol";
+
+interface ISettlerActions {
+    /// @dev Transfer funds from msg.sender Permit2.
+    function TRANSFER_FROM(address recipient, ISignatureTransfer.PermitTransferFrom memory permit, bytes memory sig)
+        external;
+
+    /// @dev Transfer funds from metatransaction requestor into the Settler contract using Permit2. Only for use in `Settler.executeMetaTxn` where the signature is provided as calldata
+    function METATXN_TRANSFER_FROM(address recipient, ISignatureTransfer.PermitTransferFrom memory permit) external;
+
+    /// @dev Settle an RfqOrder between maker and taker transfering funds directly between the parties
+    // Post-req: Payout if recipient != taker
+    function RFQ_VIP(
+        address recipient,
+        ISignatureTransfer.PermitTransferFrom memory makerPermit,
+        address maker,
+        bytes memory makerSig,
+        ISignatureTransfer.PermitTransferFrom memory takerPermit,
+        bytes memory takerSig
+    ) external;
+
+    /// @dev Settle an RfqOrder between maker and taker transfering funds directly between the parties for the entire amount
+    function METATXN_RFQ_VIP(
+        address recipient,
+        ISignatureTransfer.PermitTransferFrom memory makerPermit,
+        address maker,
+        bytes memory makerSig,
+        ISignatureTransfer.PermitTransferFrom memory takerPermit
+    ) external;
+
+    /// @dev Settle an RfqOrder between Maker and Settler. Transfering funds from the Settler contract to maker.
+    /// Retaining funds in the settler contract.
+    // Pre-req: Funded
+    // Post-req: Payout
+    function RFQ(
+        address recipient,
+        ISignatureTransfer.PermitTransferFrom memory permit,
+        address maker,
+        bytes memory makerSig,
+        address takerToken,
+        uint256 maxTakerAmount
+    ) external;
+
+    /// @dev Trades against UniswapV3 using the contracts balance for funding
+    // Pre-req: Funded
+    // Post-req: Payout
+    function UNISWAPV3(address recipient, uint256 bps, bytes memory path, uint256 amountOutMin) external;
+
+    /// @dev Trades against UniswapV3 using user funds via Permit2 for funding
+    function UNISWAPV3_VIP(
+        address recipient,
+        bytes memory path,
+        ISignatureTransfer.PermitTransferFrom memory permit,
+        bytes memory sig,
+        uint256 amountOutMin
+    ) external;
+
+    function MAKERPSM(address recipient, address gemToken, uint256 bps, address psm, bool buyGem) external;
+
+    function CURVE_TRICRYPTO_VIP(
+        address recipient,
+        uint80 poolInfo,
+        ISignatureTransfer.PermitTransferFrom memory permit,
+        bytes memory sig,
+        uint256 minBuyAmount
+    ) external;
+    function METATXN_CURVE_TRICRYPTO_VIP(
+        address recipient,
+        uint80 poolInfo,
+        ISignatureTransfer.PermitTransferFrom memory permit,
+        uint256 minBuyAmount
+    ) external;
+
+    function DODOV1(address sellToken, uint256 bps, address pool, bool quoteForBase, uint256 minBuyAmount) external;
+
+    function VELODROME(address recipient, uint256 bps, address pool, uint24 swapInfo, uint256 minBuyAmount) external;
+
+    /// @dev Trades against UniswapV3 using user funds via Permit2 for funding. Metatransaction variant. Signature is over all actions.
+    function METATXN_UNISWAPV3_VIP(
+        address recipient,
+        bytes memory path,
+        ISignatureTransfer.PermitTransferFrom memory permit,
+        uint256 amountOutMin
+    ) external;
+
+    /// @dev Trades against UniswapV2 using the contracts balance for funding
+    /// @param swapInfo is encoded as the upper 16 bits as the fee of the pool in bps, the second
+    ///                 lowest bit as "sell token has transfer fee", and the lowest bit as the
+    ///                 "token0 for token1" flag.
+    function UNISWAPV2(
+        address recipient,
+        address sellToken,
+        uint256 bps,
+        address pool,
+        uint24 swapInfo,
+        uint256 amountOutMin
+    ) external;
+
+    function POSITIVE_SLIPPAGE(address recipient, address token, uint256 expectedAmount) external;
+
+    /// @dev Trades against a basic AMM which follows the approval, transferFrom(msg.sender) interaction
+    // Pre-req: Funded
+    // Post-req: Payout
+    function BASIC(address sellToken, uint256 bps, address pool, uint256 offset, bytes calldata data) external;
+}

hardhat.config.js

@@ -26,6 +26,17 @@ module.exports = {
                     viaIR: true,
                 },
             },
+            {
+                version: '0.8.25',
+                settings: {
+                    optimizer: {
+                        enabled: true,
+                        runs: 1000000,
+                    },
+                    evmVersion: (networks[getNetwork()])?.hardfork || 'cancun',
+                    viaIR: true,
+                },
+            },
         ],
     },
     namedAccounts: {

package.json

@@ -12,7 +12,6 @@
     "@1inch/limit-order-settlement": "2.0.1",
     "@1inch/solidity-utils": "5.2.2",
     "@openzeppelin/contracts": "5.0.2",
-    "@uniswap/universal-router": "1.6.0",
     "@uniswap/universal-router-sdk": "2.2.2",
     "solmate": "6.2.0"
   },
@@ -33,7 +32,7 @@
     "eslint-plugin-n": "17.7.0",
     "eslint-plugin-promise": "6.1.1",
     "ethers": "6.12.1",
-    "hardhat": "2.19.5",
+    "hardhat": "2.22.10",
     "hardhat-dependency-compiler": "1.1.4",
     "hardhat-deploy": "0.12.4",
     "hardhat-gas-reporter": "2.1.1",