Deploy exactly ONE standalone contract, IMDLaunchSwapRouter, on Ethereum mainnet (chainId 1), using the supplied router source below. Use evm_contracts: no new token, distributor, hook, pool, liquidity position or website. Existing IMPEPE and its locked-liquidity bootstrap remain unchanged. Do not use evm_project or univ4_hook. Halt if contracts-only deployment is unavailable.

Constructor arguments in order: poolManager address 0x000000000004444c5dc75cB358380D2e3dE08A90; fees/hook address 0x5108c5507dA225a4582E8629661b5D83d476aaCc. Use these literal static addresses, not $owner and not $contract placeholders. The router has no owner, upgrade or administrative roles. The paying wallet is 0x61aEFdAAa5FA9ac74AA0051238Fd4a37B1d24148. Deploy only IMDLaunchSwapRouter; the IMDLaunchHook file below is an interface and must never be deployed.

Use Solidity 0.8.26, optimizer enabled with 200 runs, EVM cancun, Foundry bytecode_hash = "none", OpenZeppelin contracts 5.4.0 and @uniswap/v4-core 1.0.2. The two-function hook interface replaces an implementation import only; do not modify the router function bodies. This standalone build was checked locally to have identical executable runtime bytecode to the tested project router after compiler metadata is removed.

Existing token 0x5018f7d89e1433dbc0c64e29092e2fa16192905d; IMD 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7; fee router 0x42a02182432b7de815085efdbed8a0173f813f28. These are context, not constructor arguments and must not be redeployed. Official key uses token addresses in ascending order, fee=0, tickSpacing=60, hooks=0x5108c5507dA225a4582E8629661b5D83d476aaCc. The existing hook applies total 4%: 3% creation/rewards and 1% protocol. Preserve swapExactInput, payer-only ERC20 output, exact full-input consumption, minimumOut and deadline enforcement, manager-only unlock callback, nonReentrant guard and post-swap hook.flushFees(). No native ETH support, approvals, funding, swaps, rule sealing or other post-deployment calls.

Publish the router Foundry project and deployment record, test slippage/deadline/callback access and both swap directions, run the mandatory deployment review, then return the chainId, router address, deployment transaction, source repository commit, compiler settings, constructor arguments, ABI and runtime code hash. The local project will independently verify the result before website integration.

FILE contracts/IMDLaunchHook.sol

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";

interface IMDLaunchHook { function manager() external view returns(IPoolManager); function flushFees() external; }

FILE contracts/IMDLaunchSwapRouter.sol

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";

import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";

import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";

import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";

import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";

import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";

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

// ERC20 IMD/IMPEPE exact-input router. Native ETH routing requires a separately reviewed adapter.

contract IMDLaunchSwapRouter is ReentrancyGuard {

using SafeERC20 for IERC20;

using BalanceDeltaLibrary for BalanceDelta;

IPoolManager public immutable manager;

IMDLaunchHook public immutable hook;

bool private swapping;

constructor(IPoolManager poolManager, IMDLaunchHook fees) {

    require(address(poolManager) == address(fees.manager()), "manager");

    manager = poolManager;

    hook = fees;

}

function swapExactInput(

    PoolKey calldata key,

    bool zeroForOne,

    uint128 amountIn,

    uint256 minimumOut,

    uint256 deadline

) external nonReentrant returns (uint256 amountOut) {

    require(

        block.timestamp <= deadline && amountIn > 0 && address(key.hooks) == address(hook),

        "swap configuration"

    );

    swapping = true;

    bytes memory result = manager.unlock(

        abi.encode(key, zeroForOne, amountIn, minimumOut, msg.sender)

    );

    swapping = false;

    amountOut = abi.decode(result, (uint256));

    hook.flushFees();

}

function unlockCallback(bytes calldata data) external returns (bytes memory) {

    require(msg.sender == address(manager) && swapping, "router callback");

    (PoolKey memory key, bool direction, uint128 amount, uint256 minOut, address payer) = abi

        .decode(data, (PoolKey, bool, uint128, uint256, address));

    BalanceDelta delta = manager.swap(

        key,

        SwapParams(

            direction,

            -int256(uint256(amount)),

            direction ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1

        ),

        ""

    );

    int128 input = direction ? delta.amount0() : delta.amount1();

    int128 output = direction ? delta.amount1() : delta.amount0();

    require(

        input < 0 &&

            uint256(uint128(-input)) == amount &&

            output >= 0 &&

            uint256(uint128(output)) >= minOut,

        "amount or slippage"

    );

    Currency inputCurrency = direction ? key.currency0 : key.currency1;

    Currency outputCurrency = direction ? key.currency1 : key.currency0;

    manager.sync(inputCurrency);

    IERC20(Currency.unwrap(inputCurrency)).safeTransferFrom(payer, address(manager), amount);

    manager.settle();

    manager.take(outputCurrency, payer, uint256(uint128(output)));

    return abi.encode(uint256(uint128(output)));

}

}