Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: None

pragma solidity =0.8.21;

interface newIERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

interface oldIERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

library MerkleProof {

    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    function processProof(
        bytes32[] memory proof,
        bytes32 leaf
    ) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    function processProofCalldata(
        bytes32[] calldata proof,
        bytes32 leaf
    ) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(
            leavesLen + proofLen - 1 == totalHashes,
            "MerkleProof: invalid multiproof"
        );

        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen
                ? leaves[leafPos++]
                : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        require(
            leavesLen + proofLen - 1 == totalHashes,
            "MerkleProof: invalid multiproof"
        );

        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen
                ? leaves[leafPos++]
                : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(
        bytes32 a,
        bytes32 b
    ) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

interface IUniswapV2Router02 {
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

error NoSwap4U();
error NotAuthorized();
error InvalidProof();
error AlreadyClaimed();
error TooEarly();

contract TokenSwap {
    uint256 public constant NEW_TOKEN_PER_OLD = 958;
    IUniswapV2Router02 public uniswapRouter;
    oldIERC20 public oldToken;
    newIERC20 public newToken;
    address private WETH;
    bytes32 public merkleRootHash;
    bool public isOpen;
    mapping(address => bool) public authorized;
    mapping(address => bool) public hasClaimed;
    mapping(address => bool) public noswap4u;

    constructor(address _oldToken, address _newToken) {
        if (block.chainid == 1) {
            WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
        } else if (block.chainid == 5) {
            WETH = 0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6;
        }
        uniswapRouter = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        oldToken = oldIERC20(_oldToken);
        newToken = newIERC20(_newToken);
        authorized[msg.sender] = true;
    }

    modifier onlyAuthorized() {
        if (!authorized[msg.sender]) {
            revert NotAuthorized();
        }
        _;
    }

    function verify(
        bytes32[] memory proof,
        uint256 amount
    ) public view returns (bool) {
        bytes32 leaf = keccak256(abi.encode(msg.sender, amount));
        return MerkleProof.verify(proof, merkleRootHash, leaf);
    }

    modifier onlyMerkleVerified(bytes32[] memory proof, uint256 amount) {
        if (!verify(proof, amount)) {
            revert InvalidProof();
        }
        if (hasClaimed[msg.sender]) {
            revert AlreadyClaimed();
        }
        if (noswap4u[msg.sender]) {
            revert NoSwap4U();
        }
        _;
    }

    function setOpen(bool _value) external onlyAuthorized {
        isOpen = _value;
    }

    function modifyAuthorized(
        address _address,
        bool _value
    ) public onlyAuthorized {
        authorized[_address] = _value;
    }

    function noswap4uAdd(address _address) external onlyAuthorized {
        noswap4u[_address] = true;
    }

    function okfineucanswap(address _address) external onlyAuthorized {
        noswap4u[_address] = false;
    }

    function modifyRoot(bytes32 _merkleRoot) external onlyAuthorized {
        merkleRootHash = _merkleRoot;
    }

    function swapExactTokensForTokens(
        uint256 amount,
        bytes32[] calldata proof
    ) external onlyMerkleVerified(proof, amount) {
        require(
            oldToken.transferFrom(msg.sender, address(this), amount),
            "Transfer failed"
        );
        if (!isOpen) {
            revert TooEarly();
        }

        migrateSwap(amount);
        uint256 newAmount = amount * NEW_TOKEN_PER_OLD;
        newToken.transfer(msg.sender, newAmount);

        hasClaimed[msg.sender] = true;
    }

    function migrateSwap(uint256 amount) internal returns (uint256) {
        address[] memory path = new address[](3);
        path[0] = address(oldToken);
        path[1] = WETH;
        path[2] = address(newToken);

        // Record balance before swap
        uint256 newTokenBalanceBefore = newToken.balanceOf(address(this));

        // Approve and swap
        oldToken.approve(address(uniswapRouter), amount);
        uniswapRouter.swapExactTokensForTokens(
            amount,
            0, // No slippage protection
            path,
            address(this),
            block.timestamp + 180
        );

        // Calculate received amount
        uint256 receivedNewToken = newToken.balanceOf(address(this)) - newTokenBalanceBefore;

        // Transfer to burn address
        newToken.transfer(address(0xdead), receivedNewToken);
        return receivedNewToken;
    }

    function withdrawOldToken(
        address receiver,
        uint256 amount
    ) external onlyAuthorized {
        oldToken.transfer(receiver, amount);
    }

    function withdrawNewToken(
        address receiver,
        uint256 amount
    ) external onlyAuthorized {
        newToken.transfer(receiver, amount);
    }

    function withdrawETH() external onlyAuthorized {
        (bool success, ) = payable(msg.sender).call{value: address(this).balance}(
            ""
        );
        require(success, "Transfer failed");
    }
}