feat: add SmarDex exact-in swap helper

Author: jpgonzalezra

script/SmardexSwapHelpersDeployer.s.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+import { SmardexSwapHelpers } from "../src/helpers/SmardexSwapHelpers.sol";
+import { Script } from "forge-std/Script.sol";
+
+contract SmardexSwapHelpersDeployer is Script {
+    function run() public returns (SmardexSwapHelpers smardexSwapHelpers) {
+        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        // Stateless pure encoder: router-agnostic, same address (CREATE2) on every chain.
+        smardexSwapHelpers = new SmardexSwapHelpers{ salt: "SmardexSwapHelpers" }();
+
+        vm.stopBroadcast();
+    }
+}

src/helpers/SmardexSwapHelpers.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+/// @notice Weiroll-friendly encoder for SmarDex UniPool exact-in swaps.
+/// @dev The SmarDex router's `execute(commands, inputs, deadline)` carries `amountIn` ABI-encoded
+/// inside the opaque `inputs[0]` blob, so the Weiroll VM cannot substitute a reference/placeholder
+/// amountIn there. This helper takes the swap params as plain (Weiroll-substitutable) arguments and
+/// returns the encoded `inputs` array, which the standard feeds straight into `router.execute(...)`.
+/// It never holds funds, pulls tokens, or approves: the wallet approves the router directly and the
+/// router pulls `tokenIn` from the wallet (payment = TransferFrom). Mirrors BalancerHelpers.
+contract SmardexSwapHelpers {
+    using SafeCast for uint256;
+
+    /// @dev SmarDex router payment mode: pull tokenIn from the execute caller via transferFrom.
+    uint8 private constant PAYMENT_TRANSFER_FROM = 2;
+
+    /// @notice Build the `inputs` array for a SmarDex UniPool exact-in single swap.
+    /// @param tokenIn ERC20 sold.
+    /// @param tokenOut ERC20 bought.
+    /// @param amountIn Exact input amount (Weiroll-substitutable; cast to uint128, reverts on overflow).
+    /// @param minAmountOut Slippage floor enforced by the router (cast to uint128).
+    /// @param to Recipient of the output (the executing wallet).
+    /// @return inputs The single-element `bytes[]` passed to `ISmardexRouter.execute`.
+    function encodeSwapInputs(
+        address tokenIn,
+        address tokenOut,
+        uint256 amountIn,
+        uint256 minAmountOut,
+        address to
+    )
+        external
+        pure
+        returns (bytes[] memory inputs)
+    {
+        address[] memory path = new address[](2);
+        path[0] = tokenIn;
+        path[1] = tokenOut;
+
+        inputs = new bytes[](1);
+        inputs[0] = abi.encode(amountIn.toUint128(), minAmountOut.toUint128(), path, to, PAYMENT_TRANSFER_FROM);
+    }
+}

test/unit/concrete/helpers/SmardexSwapHelpers.t.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+import { SmardexSwapHelpers } from "../../../../src/helpers/SmardexSwapHelpers.sol";
+import { Test } from "forge-std/Test.sol";
+
+contract SmardexSwapHelpersTest is Test {
+    SmardexSwapHelpers public helpers;
+
+    uint8 internal constant PAYMENT_TRANSFER_FROM = 2;
+
+    address internal constant TOKEN_IN = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0; // wstETH
+    address internal constant TOKEN_OUT = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // WETH
+    address internal constant TO = 0x00000000000000000000000000000000DeaDBeef;
+
+    function setUp() public {
+        helpers = new SmardexSwapHelpers();
+    }
+
+    function test_encodeSwapInputs_matchesRouterEncoding() public view {
+        uint256 amountIn = 1 ether;
+        uint256 minAmountOut = 0.9 ether;
+
+        bytes[] memory inputs = helpers.encodeSwapInputs(TOKEN_IN, TOKEN_OUT, amountIn, minAmountOut, TO);
+
+        assertEq(inputs.length, 1, "single input");
+
+        address[] memory path = new address[](2);
+        path[0] = TOKEN_IN;
+        path[1] = TOKEN_OUT;
+        bytes memory expected = abi.encode(uint128(amountIn), uint128(minAmountOut), path, TO, PAYMENT_TRANSFER_FROM);
+        assertEq(inputs[0], expected, "encoding must match the SmarDex swapInput layout");
+    }
+
+    function test_encodeSwapInputs_decodesRoundTrip() public view {
+        uint256 amountIn = 12_345;
+        uint256 minAmountOut = 678;
+
+        bytes[] memory inputs = helpers.encodeSwapInputs(TOKEN_IN, TOKEN_OUT, amountIn, minAmountOut, TO);
+
+        (uint128 dAmountIn, uint128 dMinAmountOut, address[] memory dPath, address dTo, uint8 dPayment) =
+            abi.decode(inputs[0], (uint128, uint128, address[], address, uint8));
+
+        assertEq(dAmountIn, uint128(amountIn), "amountIn");
+        assertEq(dMinAmountOut, uint128(minAmountOut), "minAmountOut");
+        assertEq(dPath.length, 2, "path length");
+        assertEq(dPath[0], TOKEN_IN, "path[0]");
+        assertEq(dPath[1], TOKEN_OUT, "path[1]");
+        assertEq(dTo, TO, "to");
+        assertEq(dPayment, PAYMENT_TRANSFER_FROM, "payment");
+    }
+
+    function test_encodeSwapInputs_revertsOnAmountInOverflow() public {
+        uint256 tooBig = uint256(type(uint128).max) + 1;
+        vm.expectRevert();
+        helpers.encodeSwapInputs(TOKEN_IN, TOKEN_OUT, tooBig, 0, TO);
+    }
+
+    function test_encodeSwapInputs_revertsOnMinAmountOutOverflow() public {
+        uint256 tooBig = uint256(type(uint128).max) + 1;
+        vm.expectRevert();
+        helpers.encodeSwapInputs(TOKEN_IN, TOKEN_OUT, 1 ether, tooBig, TO);
+    }
+}