Merge branch 'feat/specialized-wrappers' into feat/collateral-swap-wrapper

Author: kaze-cow

.github/pull_request_template.md

@@ -0,0 +1,20 @@
+## Description
+Summarize what this PR does and why in a single, clear sentence.  
+A reader should understand the purpose and scope of the change just from this line.
+
+## Context
+Explain the motivation or problem this PR addresses.  
+Include links to any relevant documentation, tickets, or discussions.
+
+Provide background that helps reviewers understand *why* the change is needed.  
+Highlight any important design decisions, dependencies, or related components.
+
+## Out of Scope
+Specify what is *not* covered in this PR.  
+This helps reviewers focus on the intended scope and prevents scope creep.
+
+## Testing Instructions
+Provide clear, step-by-step instructions for verifying this change locally.  
+Assume the reviewer has no prior context about your setup.
+
+This section reinforces the scope of the PR by outlining what should be tested and what the expected outcomes are.

.github/workflows/test.yml

@@ -20,6 +20,8 @@ jobs:
 
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: v1.4.3
 
       - name: Show Forge version
         run: |

CLAUDE.md

@@ -50,7 +50,7 @@ This repository contains **Euler-CoW Protocol integration contracts** that enabl
 
 ### Build
 ```bash
-forge build
+forge build --deny notes
 ```
 
 ### Test
@@ -100,6 +100,7 @@ forge snapshot
 ### Security Considerations
 
 - It is generally assumed that the `solvers` (aka, an address for which `CowAuthentication.isSolver()` returns true) is a trusted actor within the system. Only in the case that a solver could steal an entire user's deposit or funds, or steal funds beyond what the user specified as their minimum out/minimum buy amount, assume there is incentive for a solver to provide the best rate/user outcome possible. To be clear, a solver cannot steal funds simply by setting arbitrary `clearingPrices` (as documented a bit later).
+  - For a solver to be able to steal an entire user's deposit or funds, they must be able to withdraw the users token to an address of their choosing or otherwise in their control (therefore, a "nuisance" transfer between two wallets that the user effectively owns does not count).
 - If a user takes on debt, that debt position must be sufficiently collateralized above a set collateralization ratio higher than liquidation ratio before the EVC batch transaction concludes. If it is not, the transaction reverts and nothing can happen. Therefore, there is no risk of undercollateralization to the system due to a user opening a position because the transaction would revert.
 - anyone can call the `EVC.batch()` function to initialize a batched call through the EVC. This call is allowed to be reentrant. Therefore, simply checking that a caller is the `address(EVC)` doesn't really offer any added security benefit.
 - The parameters supplied by a solver to the settlement contract are all indirectly bounded from within the settlement contract by ceratin restrictions:

foundry.toml

@@ -2,7 +2,7 @@
 src = "src"
 out = "out"
 libs = ["lib"]
-optimize = true
+optimizer = true
 via_ir = true
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

src/CowEvcClosePositionWrapper.sol

@@ -24,9 +24,7 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
     /// @dev The EIP-712 domain type hash used for computing the domain
     /// separator.
     bytes32 private constant DOMAIN_TYPE_HASH =
-        keccak256(
-            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
-        );
+        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
 
     /// @dev The EIP-712 domain name used for computing the domain separator.
     bytes32 private constant DOMAIN_NAME = keccak256("CowEvcOpenPositionWrapper");
@@ -39,28 +37,26 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
     /// separator is computed following the EIP-712 standard and has replay
     /// protection mixed in so that signed orders are only valid for specific
     /// this contract.
-    bytes32 public immutable domainSeparator;
+    bytes32 public immutable DOMAIN_SEPARATOR;
 
-    string public constant name = "Euler EVC - Open Position";
+    //// @dev The EVC nonce namespace to use when calling `EVC.permit` to authorize this contract.
+    uint256 public immutable NONCE_NAMESPACE;
 
-    uint256 public immutable nonceNamespace;
+    /// @dev A descriptive label for this contract, as required by CowWrapper
+    string public override name = "Euler EVC - Open Position";
 
+    /// @dev Indicates that the current operation cannot be completed with the given msgSender
     error Unauthorized(address msgSender);
+
+    /// @dev Indicates that the pre-approved hash is no longer able to be executed because the block timestamp is too old
     error OperationDeadlineExceeded(uint256 validToTimestamp, uint256 currentTimestamp);
 
     constructor(address _evc, CowSettlement _settlement) CowWrapper(_settlement) {
         EVC = IEVC(_evc);
-        nonceNamespace = uint256(uint160(address(this)));
-
-        domainSeparator = keccak256(
-            abi.encode(
-                DOMAIN_TYPE_HASH,
-                DOMAIN_NAME,
-                DOMAIN_VERSION,
-                block.chainid,
-                address(this)
-            )
-        );
+        NONCE_NAMESPACE = uint256(uint160(address(this)));
+
+        DOMAIN_SEPARATOR =
+            keccak256(abi.encode(DOMAIN_TYPE_HASH, DOMAIN_NAME, DOMAIN_VERSION, block.chainid, address(this)));
     }
 
     /**
@@ -73,7 +69,7 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
          * @dev The ethereum address that has permission to operate upon the account
          */
         address owner;
-        
+
         /**
          * @dev The subaccount to open the position on. Learn more about Euler subaccounts https://evc.wtf/docs/concepts/internals/sub-accounts
          */
@@ -133,9 +129,10 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
     }
 
     function _getApprovalHash(OpenPositionParams memory params) internal view returns (bytes32 digest) {
-        bytes32 structHash = keccak256(abi.encode(params));
-        bytes32 separator = domainSeparator;
+        bytes32 structHash;
+        bytes32 separator = DOMAIN_SEPARATOR;
         assembly ("memory-safe") {
+            structHash := keccak256(params, 224)
             let ptr := mload(0x40)
             mstore(ptr, "\x19\x01")
             mstore(add(ptr, 0x02), separator)
@@ -156,15 +153,18 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
     /// @notice Implementation of GPv2Wrapper._wrap - executes EVC operations to open a position
     /// @param settleData Data which will be used for the parameters in a call to `CowSettlement.settle`
     /// @param wrapperData Additional data containing OpenPositionParams
-    function _wrap(bytes calldata settleData, bytes calldata wrapperData, bytes calldata remainingWrapperData) internal override {
+    function _wrap(bytes calldata settleData, bytes calldata wrapperData, bytes calldata remainingWrapperData)
+        internal
+        override
+    {
         // Decode wrapper data into OpenPositionParams
         OpenPositionParams memory params;
         bytes memory signature;
-        (params, signature, ) = _parseOpenPositionParams(wrapperData);
+        (params, signature,) = _parseOpenPositionParams(wrapperData);
 
         // Check if the signed calldata hash is pre-approved
         IEVC.BatchItem[] memory signedItems = _getSignedCalldata(params);
-        bool isPreApproved = _consumePreApprovedHash(params.owner, _getApprovalHash(params));
+        bool isPreApproved = signature.length == 0 && _consumePreApprovedHash(params.owner, _getApprovalHash(params));
 
         // Build the EVC batch items for opening a position
         IEVC.BatchItem[] memory items = new IEVC.BatchItem[](isPreApproved ? signedItems.length + 1 : 2);
@@ -184,8 +184,8 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
                     (
                         params.owner,
                         address(this),
-                        uint256(nonceNamespace),
-                        EVC.getNonce(bytes19(bytes20(params.owner)), nonceNamespace),
+                        uint256(NONCE_NAMESPACE),
+                        EVC.getNonce(bytes19(bytes20(params.owner)), NONCE_NAMESPACE),
                         params.deadline,
                         0,
                         abi.encodeCall(EVC.batch, signedItems),
@@ -264,6 +264,8 @@ contract CowEvcOpenPositionWrapper is CowWrapper, PreApprovedHashes {
     /// @notice Internal settlement function called by EVC
     function evcInternalSettle(bytes calldata settleData, bytes calldata remainingWrapperData) external payable {
         require(msg.sender == address(EVC), Unauthorized(msg.sender));
+        (address onBehalfOfAccount,) = EVC.getCurrentOnBehalfOfAccount(address(0));
+        require(onBehalfOfAccount == address(this), Unauthorized(onBehalfOfAccount));
 
         // Use GPv2Wrapper's _internalSettle to call the settlement contract
         // wrapperData is empty since we've already processed it in _wrap

src/CowEvcOpenPositionWrapper.sol

@@ -27,7 +27,7 @@ abstract contract PreApprovedHashes {
     /// @param hash The keccak256 hash of the signed calldata
     /// @param approved True to approve the hash, false to revoke approval
     function setPreApprovedHash(bytes32 hash, bool approved) external {
-        require(preApprovedHashes[msg.sender][hash] != CONSUMED_PRE_APPROVED, AlreadyConsumed(msg.sender, hash)); 
+        require(preApprovedHashes[msg.sender][hash] != CONSUMED_PRE_APPROVED, AlreadyConsumed(msg.sender, hash));
 
         if (approved) {
             preApprovedHashes[msg.sender][hash] = PRE_APPROVED;

src/PreApprovedHashes.sol

@@ -43,7 +43,7 @@ interface CowSettlement {
     /// @notice Returns the address of the vaultRelayer, the target for approvals for funds entering the settlement contract.
     function vaultRelayer() external view returns (address);
 
-    /// @notice Returns the domain separator for EIP-712 signing 
+    /// @notice Returns the domain separator for EIP-712 signing
     function domainSeparator() external view returns (bytes32);
 
     /// @notice Allows for approval of orders by submitting an authorized hash on-chain prior to order execution.
@@ -135,23 +135,29 @@ abstract contract CowWrapper is ICowWrapper {
         uint16 nextWrapperDataLen = uint16(bytes2(wrapperData[0:2]));
 
         // Delegate to the wrapper's custom logic
-        _wrap(settleData, wrapperData[2:2+nextWrapperDataLen], wrapperData[2+nextWrapperDataLen:]);
+        _wrap(settleData, wrapperData[2:2 + nextWrapperDataLen], wrapperData[2 + nextWrapperDataLen:]);
     }
 
     /// @notice Parses and validates wrapper-specific data
     /// @dev Must be implemented by concrete wrapper contracts. Used for pre-execution validation.
     ///      The implementation should consume its wrapper-specific data and return the remainder.
     /// @param wrapperData The full wrapper data to parse
     /// @return remainingWrapperData The portion of wrapper data not consumed by this wrapper
-    function parseWrapperData(bytes calldata wrapperData) external virtual view returns (bytes calldata remainingWrapperData);
+    function parseWrapperData(bytes calldata wrapperData)
+        external
+        view
+        virtual
+        returns (bytes calldata remainingWrapperData);
 
     /// @notice Internal function containing the wrapper's custom logic
     /// @dev Must be implemented by concrete wrapper contracts. Should execute custom logic
     ///      then eventually call _internalSettle() to continue the settlement chain.
     /// @param settleData ABI-encoded call to CowSettlement.settle()
     /// @param wrapperData The wrapper data which should be consumed by this wrapper
     /// @param remainingWrapperData Additional wrapper data needed by future wrappers. This should be passed unaltered to _internalSettle
-    function _wrap(bytes calldata settleData, bytes calldata wrapperData, bytes calldata remainingWrapperData) internal virtual;
+    function _wrap(bytes calldata settleData, bytes calldata wrapperData, bytes calldata remainingWrapperData)
+        internal
+        virtual;
 
     /// @notice Continues the settlement chain by calling the next wrapper or settlement contract
     /// @dev Extracts the next target address from wrapperData and either:

src/vendor/CowWrapper.sol

@@ -24,6 +24,11 @@ contract CowWrapperHelpers {
     /// @param wrapperError The error returned by the wrapper's parseWrapperData
     error WrapperDataMalformed(uint256 wrapperIndex, bytes wrapperError);
 
+    /// @notice Thrown when the data for the wrapper is too long. Its limited to 65535 bytes.
+    /// @param wrapperIndex The index of the wrapper with data that is too long
+    /// @param exceedingLength The observed length of the data
+    error WrapperDataTooLong(uint256 wrapperIndex, uint256 exceedingLength);
+
     /// @notice Thrown when the settlement contract is authenticated as a solver
     /// @dev The settlement contract should not be a solver to prevent direct settlement calls bypassing wrappers
     /// @param settlementContract The settlement contract address
@@ -71,31 +76,38 @@ contract CowWrapperHelpers {
     ///      Note: No settlement address is appended as wrappers now use a static SETTLEMENT.
     /// @param wrapperCalls Array of calls in execution order
     /// @return wrapperData The encoded wrapper data ready to be passed to the first wrapper's wrappedSettle
-    function verifyAndBuildWrapperData(WrapperCall[] memory wrapperCalls) external view returns (bytes memory wrapperData) {
+    function verifyAndBuildWrapperData(WrapperCall[] memory wrapperCalls)
+        external
+        view
+        returns (bytes memory wrapperData)
+    {
         if (wrapperCalls.length == 0) {
             return wrapperData;
         }
 
         // First pass: verify all wrappers are authenticated
-        for (uint256 i = 0;i < wrapperCalls.length;i++) {
-            if (!WRAPPER_AUTHENTICATOR.isSolver(wrapperCalls[i].target)) {
-                revert NotAWrapper(i, wrapperCalls[i].target, address(WRAPPER_AUTHENTICATOR));
-            }
+        for (uint256 i = 0; i < wrapperCalls.length; i++) {
+            require(
+                WRAPPER_AUTHENTICATOR.isSolver(wrapperCalls[i].target),
+                NotAWrapper(i, wrapperCalls[i].target, address(WRAPPER_AUTHENTICATOR))
+            );
         }
 
         // Get the expected settlement from the first wrapper
         address expectedSettlement = address(ICowWrapper(wrapperCalls[0].target).SETTLEMENT());
 
-        for (uint256 i = 0;i < wrapperCalls.length;i++) {
-
+        for (uint256 i = 0; i < wrapperCalls.length; i++) {
             // All wrappers must use the same settlement contract
             address wrapperSettlement = address(ICowWrapper(wrapperCalls[i].target).SETTLEMENT());
-            if (wrapperSettlement != expectedSettlement) {
-                revert SettlementMismatch(i, expectedSettlement, wrapperSettlement);
-            }
+
+            require(
+                wrapperSettlement == expectedSettlement, SettlementMismatch(i, expectedSettlement, wrapperSettlement)
+            );
 
             // The wrapper data must be parsable and fully consumed
-            try ICowWrapper(wrapperCalls[i].target).parseWrapperData(wrapperCalls[i].data) returns (bytes memory remainingWrapperData) {
+            try ICowWrapper(wrapperCalls[i].target).parseWrapperData(wrapperCalls[i].data) returns (
+                bytes memory remainingWrapperData
+            ) {
                 if (remainingWrapperData.length > 0) {
                     revert WrapperDataNotFullyConsumed(i, remainingWrapperData);
                 }
@@ -109,11 +121,14 @@ contract CowWrapperHelpers {
             revert SettlementContractShouldNotBeSolver(expectedSettlement, address(SOLVER_AUTHENTICATOR));
         }
 
-        // Build wrapper data without settlement address at the end
-        wrapperData = abi.encodePacked(uint16(wrapperCalls[0].data.length), wrapperCalls[0].data);
+        // Build wrapper data
+        for (uint256 i = 0; i < wrapperCalls.length; i++) {
+            if (i > 0) {
+                wrapperData = abi.encodePacked(wrapperData, wrapperCalls[i].target);
+            }
 
-        for (uint256 i = 1;i < wrapperCalls.length;i++) {
-            wrapperData = abi.encodePacked(wrapperData, wrapperCalls[i].target, uint16(wrapperCalls[i].data.length), wrapperCalls[i].data);
+            require(wrapperCalls[i].data.length < 65536, WrapperDataTooLong(i, wrapperCalls[i].data.length));
+            wrapperData = abi.encodePacked(wrapperData, uint16(wrapperCalls[i].data.length), wrapperCalls[i].data);
         }
 
         return wrapperData;

src/vendor/CowWrapperHelpers.sol

@@ -44,10 +44,7 @@ interface IERC20 {
      *
      * Emits a {Transfer} event.
      */
-    function transfer(
-        address recipient,
-        uint256 amount
-    ) external returns (bool);
+    function transfer(address recipient, uint256 amount) external returns (bool);
 
     /**
      * @dev Returns the remaining number of tokens that `spender` will be
@@ -56,10 +53,7 @@ interface IERC20 {
      *
      * This value changes when {approve} or {transferFrom} are called.
      */
-    function allowance(
-        address owner,
-        address spender
-    ) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
 
     /**
      * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
@@ -86,11 +80,7 @@ interface IERC20 {
      *
      * Emits a {Transfer} event.
      */
-    function transferFrom(
-        address sender,
-        address recipient,
-        uint256 amount
-    ) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 
     /**
      * @dev Emitted when `value` tokens are moved from one account (`from`) to
@@ -104,9 +94,5 @@ interface IERC20 {
      * @dev Emitted when the allowance of a `spender` for an `owner` is set by
      * a call to {approve}. `value` is the new allowance.
      */
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint256 value
-    );
+    event Approval(address indexed owner, address indexed spender, uint256 value);
 }