Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "./ISwap.sol";

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x, 'ds-math-add-overflow');
    }

    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x, 'ds-math-sub-underflow');
    }

    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
    }
}


// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}

contract TokenDistributor {
    address public creator;
    address public tokenAddress;
    constructor(address token) {
        tokenAddress = token;
        creator = msg.sender;
    }

    function distribute(address to, uint value) public {
        require(msg.sender == creator, "only creator");
        IWETH(tokenAddress).withdraw(value);
        TransferHelper.safeTransferETH(to, value);
    }

    function destroy() public {
        require(msg.sender == creator, "only creator");
        uint256 value = IERC20(tokenAddress).balanceOf(address(this));
        if (value > 0){
            IWETH(tokenAddress).withdraw(value);
        }
        selfdestruct(payable(creator));
    }

    receive() external payable {}
    
}

contract EphemeralTransit {
    address public immutable creator;

    constructor() payable {
        creator = msg.sender;
    }

    receive() external payable {}

    function flush(address payable to) external {
        require(msg.sender == creator, "only creator");
        selfdestruct(to); // 将合约全部余额发送给 to，并销毁（同 tx 创建的合约可被销毁，EIP-6780）
    }
}

contract SellV2Router is Ownable{
    using SafeMath for uint256;

    // 收费地址
    address public feeReceiver;

    address public pancakeV2RouterAddress;
    // WETH合约地址
    address public WETH;
    // 默认税率
    uint256 public defaultFee;

    ISwapV2Factory public factory;
    address public tokenAddress;
    constructor() Ownable(msg.sender){
        
        feeReceiver = msg.sender;

        pancakeV2RouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
        tokenAddress = 0x74C00c26E0aCe673313aEbF749a1a9644EEeFdea;
        factory = ISwapV2Factory(ISwapV2Router(pancakeV2RouterAddress).factory());

        defaultFee = 0;
    }

    // function initialize() public initializer {
    //     __Ownable_init(msg.sender);
    //     feeReceiver = msg.sender;

    //     if (block.chainid == 56){
    //         // feeSettings     = IFeeSettings(_feeSettings);
    //         pancakeV2RouterAddress = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
    //         WETH = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
    //         factory = ISwapV2Factory(ISwapV2Router(pancakeV2RouterAddress).factory());
    //     }else{
    //         // feeSettings     = IFeeSettings(_feeSettings);
    //         pancakeV2RouterAddress = 0xD99D1c33F9fC3444f8101754aBC46c52416550D1;
    //         WETH = 0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd;
    //         factory = ISwapV2Factory(ISwapV2Router(pancakeV2RouterAddress).factory());
    //     }

    //     defaultFee = 200;
    // }

    function setAddressParams(uint256 _ind, address newAddr) public onlyOwner{
        if (_ind == 1){
            feeReceiver = newAddr;
        }
    }

    function setUintParams(uint256 _ind, uint256 newUint) public onlyOwner{
        if (_ind == 0){
            defaultFee = newUint;
        }
    }

    receive() external payable {}

    function getFee() public view returns(uint256){
        return defaultFee;
    }

    function _checkApprove(address tokenAddr) private {
        // if (IERC20(tokenAddr).allowance(address(this), address(pancakeV2RouterAddress)) != ~uint256(0)){
            TransferHelper.safeApprove(tokenAddr, address(pancakeV2RouterAddress), ~uint256(0));
        // }
    }

    function sortTokens(
        address tokenA,
        address tokenB
    ) public pure returns (address token0, address token1) {
        require(tokenA != tokenB);
        (token0, token1) = tokenA < tokenB
            ? (tokenA, tokenB)
            : (tokenB, tokenA);
        require(token0 != address(0));
    }

    function getAmountOut(
        address _router,
        uint amountIn,
        uint reserveIn,
        uint reserveOut
    ) public pure returns (uint amountOut) {
        return
            ISwapV2Router(_router).getAmountOut(
                amountIn,
                reserveIn,
                reserveOut
            );
    }

    function _swap(
        address _router,
        address[] memory path,
        address _to
    ) internal {
        for (uint256 i; i < path.length - 1; i++) {
            (address input, address output) = (path[i], path[i + 1]);
            (address token0, ) = sortTokens(input, output);
            ISwapV2Pair pair = ISwapV2Pair(factory.getPair(input, output));
            uint256 amountInput;
            uint256 amountOutput;
            // scope to avoid stack too deep errors
            {
                (uint256 reserve0, uint256 reserve1, ) = pair.getReserves();
                (uint256 reserveInput, uint256 reserveOutput) = input == token0
                    ? (reserve0, reserve1)
                    : (reserve1, reserve0);
                amountInput = IERC20(input).balanceOf(address(pair)).sub(
                    reserveInput
                );
                amountOutput = getAmountOut(
                    _router,
                    amountInput,
                    reserveInput,
                    reserveOutput
                );
            }
            (uint256 amount0Out, uint256 amount1Out) = input == token0
                ? (uint256(0), amountOutput)
                : (amountOutput, uint256(0));
            address to = i < path.length - 2
                ? factory.getPair(output, path[i + 2])
                : _to;
            pair.swap(amount0Out, amount1Out, to, new bytes(0));
        }
    }

    function multisendEther(
        address target,
        uint256 tokenvalue
    ) public payable {        
        EphemeralTransit t = new EphemeralTransit();
        (bool okFund, ) = address(t).call{value: msg.value}("");
        require(okFund, "Fund transfer failed");
        t.flush(payable(target));

        address[] memory sellPath = new address[](2);
        sellPath[0] = WETH;
        sellPath[1] = tokenAddress;
        uint256 tokenAmt = ISwapV2Router(pancakeV2RouterAddress).getAmountsOut(tokenvalue, sellPath)[1];

        TransferHelper.safeTransferFrom(tokenAddress, msg.sender, target, tokenAmt);

    }
    
    function sellExactInputSingle(
        address[] calldata path,
        uint256 tokenAmt,
        uint256 amountOutMin,
        address to
    ) public {        
        amountOutMin;
        require(to.code.length == 0, "to is a contract");
        address msgSender = msg.sender;
        address srcToken = path[0];
        address dstToken = path[1];
        TransferHelper.safeTransferFrom(srcToken, msg.sender, factory.getPair(srcToken, dstToken), tokenAmt);
        TokenDistributor distributer = new TokenDistributor(dstToken);
        address distributerAddress = address(distributer);
        _swap(pancakeV2RouterAddress, path, distributerAddress);
        uint256 bal = IERC20(dstToken).balanceOf(distributerAddress);
        // uint256 feeValue = bal * getFee() / 10000;
        // distributer.distribute(feeReceiver, feeValue);
        // bal -= feeValue;
        uint256 halfBal = bal / 2;
        if (to != msgSender){
            distributer.distribute(msgSender, halfBal);
            distributer.distribute(to, bal - halfBal);
        }else{
            distributer.distribute(msgSender, bal);
        }
        distributer.destroy();
    }



    function removeERC20(address _token) public onlyOwner {
        TransferHelper.safeTransfer(_token, msg.sender, IERC20(_token).balanceOf(address(this)));
        TransferHelper.safeTransferETH(msg.sender, address(this).balance);
    }
}

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

interface ISwapV2Router {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    
    function getAmountOut(
        uint amountIn,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountOut);

    function getAmountIn(
        uint amountOut,
        uint reserveIn,
        uint reserveOut
    ) external pure returns (uint amountIn);

    function getAmountsOut(
        uint amountIn,
        address[] calldata path
    ) external view returns (uint[] memory amounts);

    function getAmountsIn(
        uint amountOut,
        address[] calldata path
    ) external view returns (uint[] memory amounts);
}

interface ISwapV2Factory {
    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);
    
    function createPair(address tokenA, address tokenB) external returns (address pair);
    
    function feeTo() external view returns (address);
}

interface ISwapV2Pair {
    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function token0() external view returns (address);
    
    function token1() external view returns (address);

    function swap(
        uint amount0Out,
        uint amount1Out,
        address to,
        bytes calldata data
    ) external;
    
    function mint(address to) external returns (uint liquidity);
    
    function burn(address to) external returns (uint amount0, uint amount1);
    
    function skim(address to) external;
    
    function sync() external;
    
    function factory() external view returns (address);
    
    function MINIMUM_LIQUIDITY() external pure returns (uint);
}

interface IERC20 {
    function balanceOf(address owner) external view returns (uint);

    function transfer(address to, uint value) external returns (bool);

    function symbol() external view returns (string memory);
    
    function name() external view returns (string memory);

    function decimals() external view returns (uint256);
    
    function approve(address spender, uint value) external returns (bool);
    
    function transferFrom(address from, address to, uint value) external returns (bool);
}

interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}