Cryo Explorer Ethereum Mainnet

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

interface IWETH {
    function deposit() external payable;
    function withdraw(uint256) external;
    function transfer(address to, uint256 value) external returns (bool);
}

interface IUniswapV2Pair {
    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;
}

interface IERC20 {
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract Dealer {
    error OutputNotReceived();
    error NotAuthorized();
    error ZeroAddress();
    error TransferFailed();
    address public immutable owner;
    address public constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    // Packed calldata (fixed 88 bytes):
    // [0..19]   address pair
    // [20..39]  address token
    // [40..55]  uint128 amountIn
    // [56..71]  uint128 amountOut
    // [72..87]  uint128 minBalanceAfter
    //          BUY: msg.sender token balance must be >= minBalanceAfter
    //          SELL: msg.sender ETH balance must be >= minBalanceAfter
    uint256 private constant _PACKED_LEN = 88;

    /// @notice BUY (WETH -> Token): swap(0, amountOut).
    /// @dev Off-chain you choose whether token is token0 or token1 by selecting this vs buyTokenWeth.
    ///      Bribe = msg.value - amountIn (if positive), paid only after verification.
    function buyWethToken(bytes calldata data) external payable {
        if (data.length < _PACKED_LEN) revert();

        uint256 minBalanceAfter;
        uint256 bribe;
        uint256 afterBal;
        assembly {
            let o := data.offset
            let pair := shr(96, calldataload(o))
            let token := shr(96, calldataload(add(o, 20)))
            let amountIn := shr(128, calldataload(add(o, 40)))
            let amountOut := shr(128, calldataload(add(o, 56)))
            minBalanceAfter := shr(128, calldataload(add(o, 72)))

            // bribe = max(callvalue - amountIn, 0)
            bribe := 0
            if gt(callvalue(), amountIn) { bribe := sub(callvalue(), amountIn) }

            // Use free memory (don't clobber 0x40/0x60 scratch slots)
            let ptr := mload(0x40)

            // WETH.deposit() selector 0xd0e30db0, value = amountIn
            mstore(ptr, shl(224, 0xd0e30db0))
            if iszero(call(gas(), WETH, amountIn, ptr, 4, 0, 0)) { revert(0, 0) }

            // WETH.transfer(pair, amountIn) selector 0xa9059cbb
            mstore(ptr, shl(224, 0xa9059cbb))
            mstore(add(ptr, 4), pair)
            mstore(add(ptr, 36), amountIn)
            if iszero(call(gas(), WETH, 0, ptr, 68, 0, 0)) { revert(0, 0) }

            // pair.swap(0, amountOut, caller(), "") selector 0x022c0d9f
            mstore(ptr, shl(224, 0x022c0d9f))
            mstore(add(ptr, 4), 0)
            mstore(add(ptr, 36), amountOut)
            mstore(add(ptr, 68), caller())
            mstore(add(ptr, 100), 0x80)
            mstore(add(ptr, 132), 0)
            if iszero(call(gas(), pair, 0, ptr, 164, 0, 0)) { revert(0, 0) }

            // token.balanceOf(caller()) selector 0x70a08231
            mstore(ptr, shl(224, 0x70a08231))
            mstore(add(ptr, 4), caller())
            if iszero(staticcall(gas(), token, ptr, 36, ptr, 32)) { revert(0, 0) }
            afterBal := mload(ptr)
        }

        if (afterBal < minBalanceAfter) revert OutputNotReceived();

        if (bribe != 0) {
            assembly {
                // best-effort coinbase bribe
                pop(call(gas(), coinbase(), bribe, 0, 0, 0, 0))
            }
        }
    }

    /// @notice BUY (WETH -> Token): swap(amountOut, 0).
    function buyTokenWeth(bytes calldata data) external payable {
        if (data.length < _PACKED_LEN) revert();

        uint256 minBalanceAfter;
        uint256 bribe;
        uint256 afterBal;
        assembly {
            let o := data.offset
            let pair := shr(96, calldataload(o))
            let token := shr(96, calldataload(add(o, 20)))
            let amountIn := shr(128, calldataload(add(o, 40)))
            let amountOut := shr(128, calldataload(add(o, 56)))
            minBalanceAfter := shr(128, calldataload(add(o, 72)))

            bribe := 0
            if gt(callvalue(), amountIn) { bribe := sub(callvalue(), amountIn) }

            let ptr := mload(0x40)

            mstore(ptr, shl(224, 0xd0e30db0))
            if iszero(call(gas(), WETH, amountIn, ptr, 4, 0, 0)) { revert(0, 0) }

            mstore(ptr, shl(224, 0xa9059cbb))
            mstore(add(ptr, 4), pair)
            mstore(add(ptr, 36), amountIn)
            if iszero(call(gas(), WETH, 0, ptr, 68, 0, 0)) { revert(0, 0) }

            // pair.swap(amountOut, 0, caller(), "")
            mstore(ptr, shl(224, 0x022c0d9f))
            mstore(add(ptr, 4), amountOut)
            mstore(add(ptr, 36), 0)
            mstore(add(ptr, 68), caller())
            mstore(add(ptr, 100), 0x80)
            mstore(add(ptr, 132), 0)
            if iszero(call(gas(), pair, 0, ptr, 164, 0, 0)) { revert(0, 0) }

            mstore(ptr, shl(224, 0x70a08231))
            mstore(add(ptr, 4), caller())
            if iszero(staticcall(gas(), token, ptr, 36, ptr, 32)) { revert(0, 0) }
            afterBal := mload(ptr)
        }

        if (afterBal < minBalanceAfter) revert OutputNotReceived();

        if (bribe != 0) {
            assembly {
                pop(call(gas(), coinbase(), bribe, 0, 0, 0, 0))
            }
        }
    }

    /// @notice SELL (Token -> WETH -> ETH): swap(0, amountOut) to this, unwrap, send ETH to msg.sender.
    /// @dev Bribe = msg.value, paid only if msg.sender ETH balance >= minBalanceAfter.
    function sellTokenWeth(bytes calldata data) external payable {
        if (data.length < _PACKED_LEN) revert();
        assembly {
            let o := data.offset
            let pair := shr(96, calldataload(o))
            let token := shr(96, calldataload(add(o, 20)))
            let amountIn := shr(128, calldataload(add(o, 40)))
            let amountOut := shr(128, calldataload(add(o, 56)))
            let minBalanceAfter := shr(128, calldataload(add(o, 72)))

            let ptr := mload(0x40)

            // token.transferFrom(caller(), pair, amountIn) selector 0x23b872dd
            mstore(ptr, shl(224, 0x23b872dd))
            mstore(add(ptr, 4), caller())
            mstore(add(ptr, 36), pair)
            mstore(add(ptr, 68), amountIn)
            if iszero(call(gas(), token, 0, ptr, 100, 0, 32)) { revert(0, 0) }
            // ERC20 return handling (SafeERC20-style):
            // - no return data => assume success
            // - 32 bytes return data => must be nonzero
            // - other sizes => reject
            switch returndatasize()
            case 0 { }
            case 32 {
                if iszero(mload(0)) { revert(0, 0) }
            }
            default { revert(0, 0) }

            // pair.swap(0, amountOut, address(), "") selector 0x022c0d9f
            mstore(ptr, shl(224, 0x022c0d9f))
            mstore(add(ptr, 4), 0)
            mstore(add(ptr, 36), amountOut)
            mstore(add(ptr, 68), address())
            mstore(add(ptr, 100), 0x80)
            mstore(add(ptr, 132), 0)
            if iszero(call(gas(), pair, 0, ptr, 164, 0, 0)) { revert(0, 0) }

            // WETH.withdraw(amountOut) selector 0x2e1a7d4d
            mstore(ptr, shl(224, 0x2e1a7d4d))
            mstore(add(ptr, 4), amountOut)
            if iszero(call(gas(), WETH, 0, ptr, 36, 0, 0)) { revert(0, 0) }

            // send ETH to caller()
            if iszero(call(gas(), caller(), amountOut, 0, 0, 0, 0)) {
                revert(0, 0)
            }

            // verify caller ETH balance
            if lt(balance(caller()), minBalanceAfter) {
                revert(0, 0)
            }

            // best-effort coinbase bribe
            if gt(callvalue(), 0) {
                pop(call(gas(), coinbase(), callvalue(), 0, 0, 0, 0))
            }
        }
    }

    /// @notice SELL (Token -> WETH -> ETH): swap(amountOut, 0) to this, unwrap, send ETH to msg.sender.
    /// @dev Bribe = msg.value, paid only if msg.sender ETH balance >= minBalanceAfter.
    function sellWethToken(bytes calldata data) external payable {
        if (data.length < _PACKED_LEN) revert();
        assembly {
            let o := data.offset
            let pair := shr(96, calldataload(o))
            let token := shr(96, calldataload(add(o, 20)))
            let amountIn := shr(128, calldataload(add(o, 40)))
            let amountOut := shr(128, calldataload(add(o, 56)))
            let minBalanceAfter := shr(128, calldataload(add(o, 72)))

            let ptr := mload(0x40)

            // token.transferFrom(caller(), pair, amountIn) selector 0x23b872dd
            mstore(ptr, shl(224, 0x23b872dd))
            mstore(add(ptr, 4), caller())
            mstore(add(ptr, 36), pair)
            mstore(add(ptr, 68), amountIn)
            if iszero(call(gas(), token, 0, ptr, 100, 0, 32)) { revert(0, 0) }
            switch returndatasize()
            case 0 { }
            case 32 {
                if iszero(mload(0)) { revert(0, 0) }
            }
            default { revert(0, 0) }

            // pair.swap(amountOut, 0, address(), "") selector 0x022c0d9f
            mstore(ptr, shl(224, 0x022c0d9f))
            mstore(add(ptr, 4), amountOut)
            mstore(add(ptr, 36), 0)
            mstore(add(ptr, 68), address())
            mstore(add(ptr, 100), 0x80)
            mstore(add(ptr, 132), 0)
            if iszero(call(gas(), pair, 0, ptr, 164, 0, 0)) { revert(0, 0) }

            // WETH.withdraw(amountOut) selector 0x2e1a7d4d
            mstore(ptr, shl(224, 0x2e1a7d4d))
            mstore(add(ptr, 4), amountOut)
            if iszero(call(gas(), WETH, 0, ptr, 36, 0, 0)) { revert(0, 0) }

            // send ETH to caller()
            if iszero(call(gas(), caller(), amountOut, 0, 0, 0, 0)) {
                revert(0, 0)
            }

            // verify caller ETH balance
            if lt(balance(caller()), minBalanceAfter) {
                revert(0, 0)
            }

            // best-effort coinbase bribe
            if gt(callvalue(), 0) {
                pop(call(gas(), coinbase(), callvalue(), 0, 0, 0, 0))
            }
        }
    }
    constructor() {
        owner = msg.sender;
    }
    receive() external payable {}
    modifier onlyOwner() {
        if (msg.sender != owner) revert NotAuthorized();
        _;
    }
    function rescueETH(address payable to, uint256 amount) external onlyOwner {
        if (to == address(0)) revert ZeroAddress();
        uint256 sendAmount = amount == type(uint256).max
            ? address(this).balance
            : amount;
        (bool ok, ) = to.call{value: sendAmount}("");
        if (!ok) revert TransferFailed();
    }
    function rescueToken(
        address token,
        address to,
        uint256 amount
    ) external onlyOwner {
        if (token == address(0) || to == address(0)) revert ZeroAddress();
        IERC20 tokenContract = IERC20(token);
        uint256 sendAmount = amount == type(uint256).max
            ? tokenContract.balanceOf(address(this))
            : amount;
        bool success = tokenContract.transfer(to, sendAmount);
        if (!success) revert TransferFailed();
    }
}