Merge branch 'feat/specialized-wrappers' of https://github.com/cowprotocol/euler-integration-contracts into feat/specialized-wrappers

Author: kaze-cow

src/vendor/CowWrapperHelpers.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
@@ -82,9 +87,10 @@ contract CowWrapperHelpers {
 
         // 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));
-            }
+            require(
+                WRAPPER_AUTHENTICATOR.isSolver(wrapperCalls[i].target),
+                NotAWrapper(i, wrapperCalls[i].target, address(WRAPPER_AUTHENTICATOR))
+            );
         }
 
         // Get the expected settlement from the first wrapper
@@ -93,9 +99,10 @@ contract CowWrapperHelpers {
         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 (
@@ -114,13 +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;

test/CowWrapperHelpers.t.sol

@@ -246,8 +246,78 @@ contract CowWrapperHelpersTest is Test {
         assertEq(result, expected);
     }
 
+    function test_verifyAndBuildWrapperData_RevertsOnSettlementMismatch() public {
+        MockSettlement differentSettlement = new MockSettlement(CowAuthentication(address(wrapperAuth)));
+        MockWrapper differentWrapper = new MockWrapper(CowSettlement(address(differentSettlement)), 4);
+        wrapperAuth.addSolver(address(differentWrapper));
+
+        CowWrapperHelpers.WrapperCall[] memory wrapperCalls = new CowWrapperHelpers.WrapperCall[](2);
+        wrapperCalls[0] = CowWrapperHelpers.WrapperCall({target: address(wrapper1), data: hex"deadbeef"});
+        wrapperCalls[1] = CowWrapperHelpers.WrapperCall({target: address(differentWrapper), data: hex"cafebabe"});
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                CowWrapperHelpers.SettlementMismatch.selector, 1, address(mockSettlement), address(differentSettlement)
+            )
+        );
+        helpers.verifyAndBuildWrapperData(wrapperCalls);
+    }
+
     function test_immutableAuthenticators() public view {
         assertEq(address(helpers.WRAPPER_AUTHENTICATOR()), address(wrapperAuth));
         assertEq(address(helpers.SOLVER_AUTHENTICATOR()), address(solverAuth));
     }
+
+    function test_verifyAndBuildWrapperData_RevertsOnWrapperDataTooLong_FirstWrapper() public {
+        // Create data that's exactly 65536 bytes (exceeds uint16 max of 65535)
+        bytes memory tooLongData = new bytes(65536);
+
+        // Create a wrapper that consumes all bytes passed to it
+        MockWrapper largeWrapper = new MockWrapper(CowSettlement(address(mockSettlement)), 65536);
+        wrapperAuth.addSolver(address(largeWrapper));
+
+        CowWrapperHelpers.WrapperCall[] memory wrapperCalls = new CowWrapperHelpers.WrapperCall[](1);
+        wrapperCalls[0] = CowWrapperHelpers.WrapperCall({target: address(largeWrapper), data: tooLongData});
+
+        vm.expectRevert(abi.encodeWithSelector(CowWrapperHelpers.WrapperDataTooLong.selector, 0, 65536));
+        helpers.verifyAndBuildWrapperData(wrapperCalls);
+    }
+
+    function test_verifyAndBuildWrapperData_RevertsOnWrapperDataTooLong_SecondWrapper() public {
+        // Create data that's exactly 65536 bytes for the second wrapper
+        bytes memory tooLongData = new bytes(65536);
+
+        // Create a wrapper that consumes all bytes passed to it
+        MockWrapper largeWrapper = new MockWrapper(CowSettlement(address(mockSettlement)), 65536);
+        wrapperAuth.addSolver(address(largeWrapper));
+
+        CowWrapperHelpers.WrapperCall[] memory wrapperCalls = new CowWrapperHelpers.WrapperCall[](2);
+        wrapperCalls[0] = CowWrapperHelpers.WrapperCall({target: address(wrapper1), data: hex"deadbeef"});
+        wrapperCalls[1] = CowWrapperHelpers.WrapperCall({target: address(largeWrapper), data: tooLongData});
+
+        vm.expectRevert(abi.encodeWithSelector(CowWrapperHelpers.WrapperDataTooLong.selector, 1, 65536));
+        helpers.verifyAndBuildWrapperData(wrapperCalls);
+    }
+
+    function test_verifyAndBuildWrapperData_SucceedsWithMaxLengthData() public {
+        // Create data that's exactly 65535 bytes (max valid uint16)
+        bytes memory maxLengthData = new bytes(65535);
+
+        // Create a wrapper that consumes all bytes
+        MockWrapper largeWrapper = new MockWrapper(CowSettlement(address(mockSettlement)), 65535);
+        wrapperAuth.addSolver(address(largeWrapper));
+
+        CowWrapperHelpers.WrapperCall[] memory wrapperCalls = new CowWrapperHelpers.WrapperCall[](1);
+        wrapperCalls[0] = CowWrapperHelpers.WrapperCall({target: address(largeWrapper), data: maxLengthData});
+
+        // Should not revert - 65535 is the max valid length
+        bytes memory result = helpers.verifyAndBuildWrapperData(wrapperCalls);
+
+        // Verify the length prefix is correct (first 2 bytes)
+        bytes2 lengthPrefix;
+        assembly {
+            lengthPrefix := mload(add(result, 32))
+        }
+        assertEq(uint16(lengthPrefix), 65535);
+    }
 }