Merge pull request #6 from Uniswap/ERC7683Allocator

Erc7683 allocator

Author: mgretzke

.github/workflows/semgrep.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   semgrep:
     name: semgrep/ci
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     env:
       SEMGREP_APP_TOKEN: ${{ secrets.SEMGREP_APP_TOKEN }}
     container:

.github/workflows/test.yaml

@@ -24,7 +24,7 @@ jobs:
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1
         with:
-          version: nightly
+          version: stable
 
       - name: Run Forge build
         run: |

foundry.toml

@@ -5,14 +5,14 @@ libs = ["lib"]
 optimizer = true
 optimizer_runs = 999999
 via_ir = true
-solc = "0.8.27"
+solc = "0.8.28"
 verbosity = 2
 ffi = true
+evm_version = "cancun"
 fs_permissions = [
   { access = "read-write", path = ".forge-snapshots"},
   { access = "read", path = "script/" }
 ]
-
 remappings = [
   "forge-std=lib/forge-std/src",
   "@openzeppelin/contracts=lib/openzeppelin-contracts/contracts",
@@ -21,13 +21,15 @@ remappings = [
   "@solady=lib/solady/src",
 ]
 
-additional_compiler_profiles = [
-  { name = "test", via_ir = false }
-]
+[profile.ci]
+inherit = "default"
+optimizer_runs = 200  # Override optimizer runs to reduce the compact contract sizes
+bytecode_hash = 'none'
 
-compilation_restrictions = [
-  { paths = "test/**", via_ir = false }
-]
+[profile.pr]
+inherit = "default"
+optimizer_runs = 200  # Override optimizer runs to reduce the compact contract sizes
+bytecode_hash = 'none'
 
 [profile.default.fuzz]
 runs = 1000

src/allocators/ERC7683Allocator.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {Compact} from '@uniswap/the-compact/types/EIP712Types.sol';
+
+struct Claim {
+    uint256 chainId; // Claim processing chain ID
+    Compact compact;
+    bytes sponsorSignature; // Authorization from the sponsor
+    bytes allocatorSignature; // Authorization from the allocator
+}
+
+struct Mandate {
+    // uint256 chainId; // (implicit arg, included in EIP712 payload).
+    // address tribunal; // (implicit arg, included in EIP712 payload).
+    address recipient; // Recipient of filled tokens.
+    uint256 expires; // Mandate expiration timestamp.
+    address token; // Fill token (address(0) for native).
+    uint256 minimumAmount; // Minimum fill amount.
+    uint256 baselinePriorityFee; // Base fee threshold where scaling kicks in.
+    uint256 scalingFactor; // Fee scaling multiplier (1e18 baseline).
+    uint256[] decayCurve; // Block durations, fill increases, & claim decreases.
+    bytes32 salt; // Replay protection parameter.
+}

src/allocators/types/TribunalStructs.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/// @title IOriginSettler
+/// @notice Standard interface for settlement contracts on the origin chain
+interface IOriginSettler {
+    /// @title GaslessCrossChainOrder CrossChainOrder type
+    /// @notice Standard order struct to be signed by users, disseminated to fillers, and submitted to origin settler contracts
+    struct GaslessCrossChainOrder {
+        /// @dev The contract address that the order is meant to be settled by.
+        /// Fillers send this order to this contract address on the origin chain
+        address originSettler;
+        /// @dev The address of the user who is initiating the swap,
+        /// whose input tokens will be taken and escrowed
+        address user;
+        /// @dev Nonce to be used as replay protection for the order
+        uint256 nonce;
+        /// @dev The chainId of the origin chain
+        uint256 originChainId;
+        /// @dev The timestamp by which the order must be opened
+        uint32 openDeadline;
+        /// @dev The timestamp by which the order must be filled on the destination chain
+        uint32 fillDeadline;
+        /// @dev Type identifier for the order data. This is an EIP-712 typehash.
+        bytes32 orderDataType;
+        /// @dev Arbitrary implementation-specific data
+        /// Can be used to define tokens, amounts, destination chains, fees, settlement parameters,
+        /// or any other order-type specific information
+        bytes orderData;
+    }
+
+    /// @title OnchainCrossChainOrder CrossChainOrder type
+    /// @notice Standard order struct for user-opened orders, where the user is the msg.sender.
+    struct OnchainCrossChainOrder {
+        /// @dev The timestamp by which the order must be filled on the destination chain
+        uint32 fillDeadline;
+        /// @dev Type identifier for the order data. This is an EIP-712 typehash.
+        bytes32 orderDataType;
+        /// @dev Arbitrary implementation-specific data
+        /// Can be used to define tokens, amounts, destination chains, fees, settlement parameters,
+        /// or any other order-type specific information
+        bytes orderData;
+    }
+    /// @title ResolvedCrossChainOrder type
+    /// @notice An implementation-generic representation of an order intended for filler consumption
+    /// @dev Defines all requirements for filling an order by unbundling the implementation-specific orderData.
+    /// @dev Intended to improve integration generalization by allowing fillers to compute the exact input and output information of any order
+
+    struct ResolvedCrossChainOrder {
+        /// @dev The address of the user who is initiating the transfer
+        address user;
+        /// @dev The chainId of the origin chain
+        uint256 originChainId;
+        /// @dev The timestamp by which the order must be opened
+        uint32 openDeadline;
+        /// @dev The timestamp by which the order must be filled on the destination chain(s)
+        uint32 fillDeadline;
+        /// @dev The unique identifier for this order within this settlement system
+        bytes32 orderId;
+        /// @dev The max outputs that the filler will send. It's possible the actual amount depends on the state of the destination
+        ///      chain (destination dutch auction, for instance), so these outputs should be considered a cap on filler liabilities.
+        Output[] maxSpent;
+        /// @dev The minimum outputs that must be given to the filler as part of order settlement. Similar to maxSpent, it's possible
+        ///      that special order types may not be able to guarantee the exact amount at open time, so this should be considered
+        ///      a floor on filler receipts.
+        Output[] minReceived;
+        /// @dev Each instruction in this array is parameterizes a single leg of the fill. This provides the filler with the information
+        ///      necessary to perform the fill on the destination(s).
+        FillInstruction[] fillInstructions;
+    }
+
+    /// @notice Tokens that must be received for a valid order fulfillment
+    struct Output {
+        /// @dev The address of the ERC20 token on the destination chain
+        /// @dev address(0) used as a sentinel for the native token
+        bytes32 token;
+        /// @dev The amount of the token to be sent
+        uint256 amount;
+        /// @dev The address to receive the output tokens
+        bytes32 recipient;
+        /// @dev The destination chain for this output
+        uint256 chainId;
+    }
+
+    /// @title FillInstruction type
+    /// @notice Instructions to parameterize each leg of the fill
+    /// @dev Provides all the origin-generated information required to produce a valid fill leg
+    struct FillInstruction {
+        /// @dev The contract address that the order is meant to be settled by
+        uint256 destinationChainId;
+        /// @dev The contract address that the order is meant to be filled on
+        bytes32 destinationSettler;
+        /// @dev The data generated on the origin chain needed by the destinationSettler to process the fill
+        bytes originData;
+    }
+
+    /// @notice Signals that an order has been opened
+    /// @param orderId a unique order identifier within this settlement system
+    /// @param resolvedOrder resolved order that would be returned by resolve if called instead of Open
+    event Open(bytes32 indexed orderId, ResolvedCrossChainOrder resolvedOrder);
+
+    /// @notice Opens a gasless cross-chain order on behalf of a user.
+    /// @dev To be called by the filler.
+    /// @dev This method must emit the Open event
+    /// @param order The GaslessCrossChainOrder definition
+    /// @param signature The user's signature over the order
+    /// @param originFillerData Any filler-defined data required by the settler
+    function openFor(GaslessCrossChainOrder calldata order, bytes calldata signature, bytes calldata originFillerData)
+        external;
+
+    /// @notice Opens a cross-chain order
+    /// @dev To be called by the user
+    /// @dev This method must emit the Open event
+    /// @param order The OnchainCrossChainOrder definition
+    function open(OnchainCrossChainOrder calldata order) external;
+
+    /// @notice Resolves a specific GaslessCrossChainOrder into a generic ResolvedCrossChainOrder
+    /// @dev Intended to improve standardized integration of various order types and settlement contracts
+    /// @param order The GaslessCrossChainOrder definition
+    /// @param originFillerData Any filler-defined data required by the settler
+    /// @return ResolvedCrossChainOrder hydrated order data including the inputs and outputs of the order
+    function resolveFor(GaslessCrossChainOrder calldata order, bytes calldata originFillerData)
+        external
+        view
+        returns (ResolvedCrossChainOrder memory);
+
+    /// @notice Resolves a specific OnchainCrossChainOrder into a generic ResolvedCrossChainOrder
+    /// @dev Intended to improve standardized integration of various order types and settlement contracts
+    /// @param order The OnchainCrossChainOrder definition
+    /// @return ResolvedCrossChainOrder hydrated order data including the inputs and outputs of the order
+    function resolve(OnchainCrossChainOrder calldata order) external view returns (ResolvedCrossChainOrder memory);
+}

src/interfaces/ERC7683/IOriginSettler.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {IOriginSettler} from './ERC7683/IOriginSettler.sol';
+
+interface IERC7683Allocator is IOriginSettler {
+    struct OrderData {
+        // COMPACT
+        address arbiter; // The account tasked with verifying and submitting the claim.
+        address sponsor; // The account to source the tokens from.
+        uint256 nonce; // A parameter to enforce replay protection, scoped to allocator.
+        uint256 expires; // The time at which the claim expires.
+        uint256 id; // The token ID of the ERC6909 token to allocate.
+        uint256 amount; // The amount of ERC6909 tokens to allocate.
+        // MANDATE
+        uint256 chainId; // (implicit arg, included in EIP712 payload)
+        address tribunal; // (implicit arg, included in EIP712 payload)
+        address recipient; // Recipient of settled tokens
+        // uint256 expires; // Mandate expiration timestamp
+        address token; // Settlement token (address(0) for native)
+        uint256 minimumAmount; // Minimum settlement amount
+        uint256 baselinePriorityFee; // Base fee threshold where scaling kicks in
+        uint256 scalingFactor; // Fee scaling multiplier (1e18 baseline)
+        uint256[] decayCurve; // Block durations, fill increases, & claim decreases.
+        bytes32 salt; // Replay protection parameter
+        // ADDITIONAL INPUT
+        uint256 targetBlock; // The block number at the target chain on which the PGA is executed / the reverse dutch auction starts.
+        uint256 maximumBlocksAfterTarget; // Blocks after target block that are still fillable.
+    }
+
+    struct OrderDataGasless {
+        // COMPACT
+        address arbiter; // The account tasked with verifying and submitting the claim.
+        // address sponsor; // The account to source the tokens from.
+        // uint256 nonce; // A parameter to enforce replay protection, scoped to allocator.
+        // uint256 expires; // The time at which the claim expires.
+        uint256 id; // The token ID of the ERC6909 token to allocate.
+        uint256 amount; // The amount of ERC6909 tokens to allocate.
+        // MANDATE
+        uint256 chainId; // (implicit arg, included in EIP712 payload)
+        address tribunal; // (implicit arg, included in EIP712 payload)
+        address recipient; // Recipient of settled tokens
+        // uint256 expires; // Mandate expiration timestamp
+        address token; // Settlement token (address(0) for native)
+        uint256 minimumAmount; // Minimum settlement amount
+        uint256 baselinePriorityFee; // Base fee threshold where scaling kicks in
+        uint256 scalingFactor; // Fee scaling multiplier (1e18 baseline)
+        uint256[] decayCurve; // Block durations, fill increases, & claim decreases.
+        bytes32 salt; // Replay protection parameter
+    }
+
+    error InvalidOriginSettler(address originSettler, address expectedOriginSettler);
+    error InvalidOrderDataType(bytes32 orderDataType, bytes32 expectedOrderDataType);
+    error InvalidNonce(uint256 nonce);
+    error NonceAlreadyInUse(uint256 nonce);
+    error InvalidSignature(address signer, address expectedSigner);
+    error InvalidRegistration(address sponsor, bytes32 claimHash);
+    error InvalidSponsor(address sponsor, address expectedSponsor);
+
+    /// @inheritdoc IOriginSettler
+    function openFor(GaslessCrossChainOrder calldata order, bytes calldata signature, bytes calldata originFillerData)
+        external;
+
+    /// @inheritdoc IOriginSettler
+    /// @dev Requires the user to have previously registered the claim hash on the compact
+    function open(OnchainCrossChainOrder calldata order) external;
+
+    /// @inheritdoc IOriginSettler
+    function resolveFor(GaslessCrossChainOrder calldata order, bytes calldata originFillerData)
+        external
+        view
+        returns (ResolvedCrossChainOrder memory);
+
+    /// @inheritdoc IOriginSettler
+    function resolve(OnchainCrossChainOrder calldata order) external view returns (ResolvedCrossChainOrder memory);
+
+    /// @notice Returns the type string of the compact including the witness
+    function getCompactWitnessTypeString() external pure returns (string memory);
+
+    /// @notice Checks if a nonce is free to be used
+    /// @dev The nonce is the most significant 96 bits. The least significant 160 bits must be the sponsor address
+    function checkNonce(address sponsor_, uint256 nonce_) external view returns (bool nonceFree_);
+
+    /// @notice Creates the filler data for the open event to be used on the IDestinationSettler
+    /// @param claimant_ The address claiming the origin tokens after a successful fill (typically the address of the filler)
+    function createFillerData(address claimant_) external pure returns (bytes memory fillerData);
+}