feat: Treble calldata decoder and preOps hook done

Author: BenSparksCode

src/contracts/examples/trebleswap/TrebleSwapDAppControl.sol

@@ -16,10 +16,23 @@ import "src/contracts/types/SolverOperation.sol";
 // ODOS v2 Router on Base: https://basescan.org/address/0x19ceead7105607cd444f5ad10dd51356436095a1
 // Main function: swapCompact()
 
+struct SwapTokenInfo {
+    address inputToken;
+    uint256 inputAmount;
+    address outputToken;
+    uint256 outputMin;
+}
+
 contract TrebleSwapDAppControl is DAppControl {
+    address public constant ODOS_ROUTER = 0x19cEeAd7105607Cd444F5ad10dd51356436095a1;
+
     // TODO WETH on Base for now, change to TREB when token deployed
     address public constant TREB = address(0x4200000000000000000000000000000000000006);
-    address internal constant _NATIVE_TOKEN = address(0);
+    address internal constant _ETH = address(0);
+
+    error InvalidUserOpData();
+    error UserOpDappNotOdosRouter();
+    error InsufficientUserOpValue();
 
     constructor(
         address atlas
@@ -58,10 +71,24 @@ contract TrebleSwapDAppControl is DAppControl {
     // ---------------------------------------------------- //
 
     function _preOpsCall(UserOperation calldata userOp) internal virtual override returns (bytes memory) {
-        // User approves Atlas before tx, so pull tokens via Permit69 here, to be used in UserOperation.
-        // Use preOps hook to extract swap data (tokenIn, tokenOut, amounts)
-        // Validate userOp.data is correct format for UserOperation call to router
-        // Return extracted swap data for safety checks in allocateValue
+        if (userOp.dapp != ODOS_ROUTER) revert UserOpDappNotOdosRouter();
+
+        (bool success, bytes memory data) =
+            CONTROL.staticcall(abi.encodePacked(this.decodeUserOpData.selector, userOp.data));
+
+        if (!success) revert InvalidUserOpData();
+
+        SwapTokenInfo memory swapTokenInfo = abi.decode(data, (SwapTokenInfo));
+
+        // If inputToken is ERC20, transfer tokens from user to EE, and approve Odos router for swap
+        if (swapTokenInfo.inputToken != _ETH) {
+            _transferUserERC20(swapTokenInfo.inputToken, address(this), swapTokenInfo.inputAmount);
+            SafeTransferLib.safeApprove(swapTokenInfo.inputToken, ODOS_ROUTER, swapTokenInfo.inputAmount);
+        } else {
+            if (userOp.value < swapTokenInfo.inputAmount) revert InsufficientUserOpValue();
+        }
+
+        return data; // return SwapTokenInfo in bytes format, to be used in allocateValue.
     }
 
     // UserOperation happens here. EE calls router (userOp.dapp) with userOp.data as calldata.
@@ -83,4 +110,78 @@ contract TrebleSwapDAppControl is DAppControl {
     function getBidValue(SolverOperation calldata solverOp) public view virtual override returns (uint256) {
         return solverOp.bidAmount;
     }
+
+    // Call this helper with userOp.data appended as calldata, to decode swap info in the Odos calldata.
+    function decodeUserOpData() public view returns (SwapTokenInfo memory swapTokenInfo) {
+        assembly {
+            // helper function to get address either from calldata or Odos router addressList()
+            function getAddress(currPos) -> result, newPos {
+                let inputPos := shr(240, calldataload(currPos))
+
+                switch inputPos
+                // Reserve the null address as a special case that can be specified with 2 null bytes
+                case 0x0000 { newPos := add(currPos, 2) }
+                // This case means that the address is encoded in the calldata directly following the code
+                case 0x0001 {
+                    result := and(shr(80, calldataload(currPos)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
+                    newPos := add(currPos, 22)
+                }
+                // If not 0000 or 0001, call ODOS_ROUTER.addressList(inputPos - 2) to get address
+                default {
+                    // 0000 and 0001 are reserved for cases above, so offset by 2 for addressList index
+                    let arg := sub(inputPos, 2)
+                    let selector := 0xb810fb43 // function selector for "addressList(uint256)"
+                    let ptr := mload(0x40) // get the free memory pointer
+                    mstore(ptr, shl(224, selector)) // shift selector to left of slot and store
+                    mstore(add(ptr, 4), arg) // store the uint256 argument after the selector
+
+                    // Perform the external call
+                    let success :=
+                        staticcall(
+                            gas(), // gas remaining
+                            ODOS_ROUTER,
+                            ptr, // input location
+                            0x24, // input size (4 byte selector + uint256 arg)
+                            ptr, // output location
+                            0x20 // output size (32 bytes for the address)
+                        )
+
+                    if eq(success, 0) { revert(0, 0) }
+
+                    result := mload(ptr)
+                    newPos := add(currPos, 2)
+                }
+            }
+
+            let result := 0
+            let pos := 8 // skip Odos compactSwap selector and this helper selector (4 + 4 bytes)
+
+            // swapTokenInfo.inputToken (slot 0)
+            result, pos := getAddress(pos)
+            mstore(swapTokenInfo, result)
+
+            // swapTokenInfo.outputToken (slot 2)
+            result, pos := getAddress(pos)
+            mstore(add(swapTokenInfo, 0x40), result)
+
+            // swapTokenInfo.inputAmount (slot 1)
+            let inputAmountLength := shr(248, calldataload(pos))
+            pos := add(pos, 1)
+            if inputAmountLength {
+                mstore(add(swapTokenInfo, 0x20), shr(mul(sub(32, inputAmountLength), 8), calldataload(pos)))
+                pos := add(pos, inputAmountLength)
+            }
+
+            // swapTokenInfo.outputMin (slot 3)
+            // get outputQuote and slippageTolerance from calldata, then calculate outputMin
+            let quoteAmountLength := shr(248, calldataload(pos))
+            pos := add(pos, 1)
+            let outputQuote := shr(mul(sub(32, quoteAmountLength), 8), calldataload(pos))
+            pos := add(pos, quoteAmountLength)
+            {
+                let slippageTolerance := shr(232, calldataload(pos))
+                mstore(add(swapTokenInfo, 0x60), div(mul(outputQuote, sub(0xFFFFFF, slippageTolerance)), 0xFFFFFF))
+            }
+        }
+    }
 }

test/TrebleSwap.t.sol

@@ -91,7 +91,7 @@ contract TrebleSwapTest is BaseTest {
             hex"83bd37f9000400014da78059d97f155e18b37765e2e042270f4e0fc4040bc108800601d1d9f50a5a028f5c0001f73f77f9466da712590ae432a80f07fd50a7de600001616535324976f8dbcef19df0705b95ace86ebb480001736F6980876FDa51A610AB79E2856528a62Bf80e0000000006020207003401000001020180000005020a0004040500000301010003060119ff0000000000000000000000000000000000000000000000000000000000000000616535324976f8dbcef19df0705b95ace86ebb48833589fcd6edb6e08f4c7c32d4f71b54bda02913569d81c17b5b4ac08929dc1769b8e39668d3ae29f6c0a374a483101e04ef5f7ac9bd15d9142bac95d9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca42000000000000000000000000000000000000060000000000000000";
 
         bytes memory encodedCall = abi.encodePacked(this.decodeSwapCompactCalldata.selector, swapCompactCalldata);
-        (bool res, bytes memory returnData) = address(this).call(encodedCall);
+        (bool res, bytes memory returnData) = address(this).staticcall(encodedCall);
 
         console.log("res", res);
 
@@ -130,7 +130,7 @@ contract TrebleSwapTest is BaseTest {
     // }
 
     // TODO once this works, move to TrebleSwapDAppControl
-    function decodeSwapCompactCalldata() public returns (SwapTokenInfo memory swapTokenInfo) {
+    function decodeSwapCompactCalldata() public view returns (SwapTokenInfo memory swapTokenInfo) {
         assembly {
             // helper function to get address either from storage or calldata
             function getAddress(currPos) -> result, newPos {
@@ -156,7 +156,7 @@ contract TrebleSwapTest is BaseTest {
                     let success :=
                         staticcall(
                             gas(), // gas remaining
-                            0x19cEeAd7105607Cd444F5ad10dd51356436095a1, // Odos v2 Router on Base
+                            ODOS_ROUTER,
                             ptr, // input location
                             0x24, // input size (4 byte selector + uint256 arg)
                             ptr, // output location