Smart Contract Integration

import { IMobulaRouter } from "./IMobulaRouter.sol";

import abi from "./MobulaRouter.abi.json" assert { type: "json" };
// or fetch from the gist:
// const abi = await fetch("https://gist.githubusercontent.com/NBMSacha/97628523b02dc9d4f05c0b79adf623a3/raw/MobulaRouter.abi.json").then(r => r.json());

interface IMobulaRouter {
    enum ProtocolType {
        UniswapV2, UniswapV3, SolidlyV2, LiquidityBookV2,
        UniswapV4, SolidlyV3, FourMeme, PCSInfinityCL
    }

    struct AggregatorSwapParams {
        address target;
        address sellToken;
        address buyToken;
        uint256 sellAmount;
        uint256 minBuyAmountToUser;
        address beneficiary;
        uint256 deadline;
        uint16  feeBps;
        address wethOverride;
        bytes   data;
    }

    struct RouteStep {
        address pool;
        address tokenIn;
        address tokenOut;
        ProtocolType protocol;
        uint24 v3Fee;
        int24  tickSpacing;
        address hooks;
    }

    struct SecureRoute {
        RouteStep[] steps;
        uint256 minBuyAmountToUser;
        address beneficiary;
        uint256 deadline;
        uint16  feeBps;
        address wethOverride;
        bool    unwrapOutput;
    }

    function executeAggregatorSwap(AggregatorSwapParams calldata params) external payable;
    function executeRoute(address sellToken, uint256 sellAmount, SecureRoute calldata route) external payable;
}

function executeAggregatorSwap(AggregatorSwapParams calldata params) external payable;

function executeRoute(
    address sellToken,
    uint256 sellAmount,
    SecureRoute calldata route
) external payable;

uint256 fee   = (amountOut * feeBps) / 10_000;
uint256 toUser = amountOut - fee;
require(toUser >= minBuyAmountToUser, NetOutputTooLow());

uint256 fee   = (amountOut * feeBps) / BPS_DENOMINATOR;
uint256 toUser = amountOut - fee;
if (toUser < minToUser) revert NetOutputTooLow();

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import { IMobulaRouter } from "./IMobulaRouter.sol";

interface IERC20 {
    function approve(address, uint256) external returns (bool);
}

contract Caller {
    IMobulaRouter immutable ROUTER;

    constructor(address router) { ROUTER = IMobulaRouter(router); }

    /// Native ETH → ERC-20 via a pre-built aggregator quote.
    function buy(
        address aggregator,    // 1inch / 0x / KyberSwap router
        address buyToken,
        uint256 minOut,        // post-fee minimum
        bytes calldata aggData
    ) external payable {
        IMobulaRouter.AggregatorSwapParams memory p = IMobulaRouter.AggregatorSwapParams({
            target:              aggregator,
            sellToken:           address(0),          // native
            buyToken:            buyToken,
            sellAmount:          msg.value,
            minBuyAmountToUser:  minOut,
            beneficiary:         msg.sender,
            deadline:            block.timestamp + 300,
            feeBps:              0,                    // no partner fee
            wethOverride:        address(0),           // default WETH
            data:                aggData
        });

        ROUTER.executeAggregatorSwap{ value: msg.value }(p);
    }

    /// ERC-20 → ERC-20 single-hop V3 via executeRoute.
    /// Caller MUST approve ROUTER for `amountIn` of `tokenIn` first.
    function swapV3(
        address pool,
        address tokenIn,
        address tokenOut,
        uint24  feeTier,
        uint256 amountIn,
        uint256 minOut
    ) external {
        IMobulaRouter.RouteStep[] memory steps = new IMobulaRouter.RouteStep[](1);
        steps[0] = IMobulaRouter.RouteStep({
            pool:        pool,
            tokenIn:     tokenIn,
            tokenOut:    tokenOut,
            protocol:    IMobulaRouter.ProtocolType.UniswapV3,
            v3Fee:       feeTier,
            tickSpacing: int24(0),
            hooks:       address(0)
        });

        IMobulaRouter.SecureRoute memory route = IMobulaRouter.SecureRoute({
            steps:               steps,
            minBuyAmountToUser:  minOut,
            beneficiary:         msg.sender,
            deadline:            block.timestamp + 300,
            feeBps:              0,
            wethOverride:        address(0),
            unwrapOutput:        false
        });

        ROUTER.executeRoute(tokenIn, amountIn, route);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "forge-std/Test.sol";
import { MobulaRouter } from "contracts/evm/src/MobulaRouter.sol";
import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";

interface IERC20 { function balanceOf(address) external view returns (uint256); }

contract MobulaRouterIntegrationFork is Test {
    MobulaRouter router;

    address constant WETH                = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
    address constant USDC                = 0xaf88d065e77c8cC2239327C5EDb3A432268e5831;
    address constant UNI_V3_ROUTER       = 0xE592427A0AEce92De3Edee1F18E0157C05861564;

    address user        = makeAddr("user");
    address feeRecipient = makeAddr("fees");

    function setUp() public {
        vm.createSelectFork(vm.envString("ARBITRUM_RPC"));

        MobulaRouter impl = new MobulaRouter();
        bytes memory init = abi.encodeWithSelector(
            MobulaRouter.initialize.selector, feeRecipient, address(this), WETH
        );
        router = MobulaRouter(payable(address(new ERC1967Proxy(address(impl), init))));

        router.setAllowedTarget(UNI_V3_ROUTER, true);
    }

    function test_AggregatorSwap_ETH_to_USDC() public {
        uint256 ethIn = 0.1 ether;
        vm.deal(user, ethIn);

        bytes memory data = abi.encodeWithSignature(
            "exactInputSingle((address,address,uint24,address,uint256,uint256,uint256,uint160))",
            WETH, USDC, uint24(500), address(router),
            block.timestamp, ethIn, uint256(0), uint160(0)
        );

        MobulaRouter.AggregatorSwapParams memory p = MobulaRouter.AggregatorSwapParams({
            target:              UNI_V3_ROUTER,
            sellToken:           address(0),
            buyToken:            USDC,
            sellAmount:          ethIn,
            minBuyAmountToUser:  0,
            beneficiary:         user,
            deadline:            block.timestamp + 300,
            feeBps:              50,            // 0.5%
            wethOverride:        address(0),
            data:                data
        });

        vm.prank(user);
        router.executeAggregatorSwap{ value: ethIn }(p);

        assertGt(IERC20(USDC).balanceOf(user),         0, "user got USDC");
        assertGt(IERC20(USDC).balanceOf(feeRecipient), 0, "fees collected");
    }
}

forge test --match-contract MobulaRouterIntegrationFork --fork-url $ARBITRUM_RPC -vvv