MonkleRouter02

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

// ---- Minimal interfaces (single file) ----
interface IMonkleFactory {
    function getPair(address tokenA, address tokenB) external view returns (address);
    function createPairWith(address tokenA, address tokenB, bytes32 salt, bytes calldata pairCreationBytecode)
        external returns (address pair);
}
interface IMonklePair { function mint(address to) external returns (uint liquidity); }
interface IERC20 { function transferFrom(address src, address dst, uint amount) external returns (bool); }
interface IWETH { function deposit() external payable; function transfer(address to, uint amount) external returns (bool); }

// ---- Router ----
contract MonkleRouter02 {
    address public immutable factory;
    address public immutable WETH;

    event AddLiquidityETH(address indexed sender, address indexed token, uint amountToken, uint amountETH, uint liquidity, address pair);

    constructor(address _factory, address _WETH) {
        require(_factory != address(0) && _WETH != address(0), "zero");
        factory = _factory; WETH = _WETH;
    }

    function _sort(address a, address b) private pure returns (address token0, address token1) {
        require(a != b, "IDENTICAL");
        (token0, token1) = a < b ? (a, b) : (b, a);
        require(token0 != address(0), "ZERO_ADDR");
    }

    // NOTE: must be `bytes memory` for a private/internal function
    function _ensurePair(address a, address b, bytes32 salt, bytes memory bytecode) private returns (address p) {
        p = IMonkleFactory(factory).getPair(a, b);
        if (p == address(0)) {
            p = IMonkleFactory(factory).createPairWith(a, b, salt, bytecode);
        }
    }

    struct Args {
        address token;
        uint amountTokenDesired;
        uint amountTokenMin;
        uint amountETHMin;
        address to;
        uint deadline;
        bytes32 pairSalt;
        bytes pairBytecode;
    }

    function _addLiquidityETH(Args memory a)
        private
        returns (uint amountToken, uint amountETH, uint liquidity)
    {
        require(block.timestamp <= a.deadline, "EXPIRED");
        require(msg.value >= a.amountETHMin, "ETH_MIN");

        (address t0, address t1) = _sort(a.token, WETH);
        address pair = _ensurePair(t0, t1, a.pairSalt, a.pairBytecode);

        require(IERC20(a.token).transferFrom(msg.sender, pair, a.amountTokenDesired), "TOKEN_XFER");
        amountToken = a.amountTokenDesired;

        IWETH(WETH).deposit{value: msg.value}();
        require(IWETH(WETH).transfer(pair, msg.value), "WETH_XFER");
        amountETH = msg.value;

        require(amountToken >= a.amountTokenMin, "TOKEN_MIN");
        require(amountETH >= a.amountETHMin, "ETH_MIN2");

        liquidity = IMonklePair(pair).mint(a.to);

        emit AddLiquidityETH(msg.sender, a.token, amountToken, amountETH, liquidity, pair);
    }

    // Public entrypoint (signature your Adapter calls)
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bytes32 pairSalt,
        bytes calldata pairBytecode
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity) {
        Args memory a = Args({
            token: token,
            amountTokenDesired: amountTokenDesired,
            amountTokenMin: amountTokenMin,
            amountETHMin: amountETHMin,
            to: to,
            deadline: deadline,
            pairSalt: pairSalt,
            pairBytecode: pairBytecode
        });
        return _addLiquidityETH(a);
    }

    receive() external payable {}
}