Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/*
        [....     [... [......  [.. ..
      [..    [..       [..    [..    [..
    [..        [..     [..     [..         [..       [..
    [..        [..     [..       [..     [.   [..  [..  [..
    [..        [..     [..          [.. [..... [..[..   [..
      [..     [..      [..    [..    [..[.        [..   [..
        [....          [..      [.. ..    [....     [.. [...

    Beta -> V1 Migration.

    https://otsea.io
    https://t.me/OTSeaPortal
    https://twitter.com/OTSeaERC20
*/

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "contracts/helpers/ListHelper.sol";
import "contracts/helpers/TransferHelper.sol";
import "contracts/libraries/OTSeaErrors.sol";
import "contracts/libraries/OTSeaLibrary.sol";

/**
 * @notice OTSea one-way beta -> v1 migration contract
 * @dev This contract facilitates the migration from the current (beta) token to the new v1 token.
 *
 * Migration steps:
 * 1. The team coordinate whales to approve the smart contract.
 * 2. The team will take a snapshot of the holder's balances of the beta token and generate a merkle tree. From this
 * merkle tree we can get the root.
 * 3. The root is uploaded into the contract (can only be done once).
 * 4. The team uses the smart contract to sell the approved tokens in Step 1, with the aim of gathering as much ETH
 *    as possible so that it can be used to fund the v1 liquidity pool. All whales participating receive a credit as
 *    opposed to receiving the v1 token straight away.
 * 5. The team deploys and adds the v1 token address in the contract. The purpose of not deploying the v1 contract in a
 *    prior step is because Etherscan will show that the OTSea deployer has deployed a new token which could affect the
 *    amount of ETH received in Step 4 (depending on if the community sees the new token deployed).
 * 6. Upon configuring the v1 token, users can then migrate their tokens from the beta token to the v1 token using
 *    a merkle proof via the migrate() function (on the dApp). The coordinated whales that received a credit in Step 4
 *    can claim their v1 tokens via the claimCredit() function. Also the team can claim tokens for addresses that can't
 *    claim for themselves, these are known as special addresses.
 *
 * The following addresses are special address:
 * - OTSeaERC20: 0x37DA9DE38c4094e090c014325f6eF4baEB302626
 * - Dead address: 0x000000000000000000000000000000000000dEaD
 * - OTSea (platform): 0x28A2F7849f0a2BCCf1F5D246cEf5a6867A5BFa23
 * - Uniswap V2 pair (OTSea/WETH): 0xd46934919D9138d3005C1f8Db794f03E7415bAbD
 *
 * Note: Any tokens in the current (beta) OTSea (platform) contract will be claimed by the team (as per Step 6) and
 * manually transferred to the relevant order creator(s).
 */
contract OTSeaMigration is Ownable, TransferHelper, ListHelper {
    using SafeERC20 for IERC20;

    struct Migration {
        address wallet;
        /// @dev amount to migrate
        uint256 amount;
        /// @dev amount recorded on snapshot (used to reconstruct the leaf)
        uint256 snapshot;
        bytes32[] proof;
    }

    IUniswapV2Router02 private constant _router =
        IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address private constant BETA_PAIR_ADDRESS = 0xd46934919D9138d3005C1f8Db794f03E7415bAbD;
    address private constant BETA_OTSEA_PLATFORM = 0x28A2F7849f0a2BCCf1F5D246cEf5a6867A5BFa23;
    IERC20 private constant _beta = IERC20(0x37DA9DE38c4094e090c014325f6eF4baEB302626);
    uint24 private constant MIGRATION_PERIOD = 90 days;
    address public immutable multiSigAdmin;
    IERC20 public v1;
    address public treasury;
    bool public hasLiquidityBeenExtracted;
    uint32 public migrationDeadline;
    bytes32 public merkleRoot;
    mapping(address => uint256) private _migrated;
    mapping(address => uint256) private _credit;

    error InvalidRoot();
    error InvalidProof();
    error InvalidMinETHAmount();
    error AmountExceedsSnapshot();
    error RootNotUploaded();

    event MerkleRootUploaded(bytes32 root);
    event Migrated(address indexed account, Migration migration);
    event CreditClaimed(address indexed account, uint256 credit);
    event V1TokenConfigured(address token, uint32 migrationDeadline);
    event ExtractedLiquidity(Migration[] migrations, uint256 amountSold, uint256 ethReceived);
    event SoldBetaTokens(uint256 amountSold, uint256 ethReceived);
    event ClaimedUnclaimedV1Tokens(uint256 amount);

    modifier canMigrate() {
        _checkCanMigrate();
        _;
    }

    modifier afterRootUploaded() {
        _checkRootUploaded();
        _;
    }

    /**
     * @param _multiSigAdmin Multi-sig admin
     * @param _migrationHandler Migration handler
     */
    constructor(address _multiSigAdmin, address _migrationHandler) Ownable(_migrationHandler) {
        if (_multiSigAdmin == address(0)) revert OTSeaErrors.InvalidAddress();
        multiSigAdmin = _multiSigAdmin;
    }

    /**
     * @notice Upload the merkle root, can only be uploaded once
     * @param _merkleRoot Merkle root
     */
    function uploadMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        if (_isRootUploaded()) revert OTSeaErrors.NotAvailable();
        if (_merkleRoot == bytes32(0)) revert InvalidRoot();
        merkleRoot = _merkleRoot;
        emit MerkleRootUploaded(_merkleRoot);
    }

    /**
     * @notice Extract liquidity by selling tokens from whales that have approved this contract
     * @param _migrations Migrations
     * @param _minETHAmount Minimum ETH to receive from selling
     * @dev this function can only be called once
     */
    function extractLiquidity(
        Migration[] calldata _migrations,
        uint256 _minETHAmount
    ) external onlyOwner afterRootUploaded {
        if (hasLiquidityBeenExtracted) revert OTSeaErrors.NotAvailable();
        uint256 length = _migrations.length;
        _validateListLength(length);
        if (_minETHAmount == 0) revert InvalidMinETHAmount();
        hasLiquidityBeenExtracted = true;
        uint256 betaBalanceBefore = _beta.balanceOf(address(this));
        for (uint256 i; i < length; ) {
            if (_migrations[i].wallet == address(0)) revert OTSeaErrors.InvalidAddressAtIndex(i);
            if (_credit[_migrations[i].wallet] != 0) revert OTSeaErrors.DuplicateAddressAtIndex(i);
            _validateMigration(_migrations[i]);
            _checkSufficientAmount(_migrations[i]);
            _credit[_migrations[i].wallet] = _migrations[i].amount;
            _beta.safeTransferFrom(_migrations[i].wallet, address(this), _migrations[i].amount);
            unchecked {
                i++;
            }
        }
        uint256 amountToSell = _beta.balanceOf(address(this)) - betaBalanceBefore;
        uint256 ethReceived = _sell(amountToSell, _minETHAmount);
        emit ExtractedLiquidity(_migrations, amountToSell, ethReceived);
    }

    /**
     * @notice Configure the contract to add the v1 token, doing so will allow users to migrate
     * @param _token Token Migrations
     * @dev this function can only be called once
     */
    function configureV1Token(IERC20 _token) external onlyOwner {
        /// @dev Liquidity has to have been extracted first, v1 cannot already be configured
        if (!hasLiquidityBeenExtracted || address(v1) != address(0))
            revert OTSeaErrors.NotAvailable();
        if (address(_token) == address(0)) revert OTSeaErrors.InvalidAddress();
        v1 = _token;
        /// @dev Set the deadline for migration to be 90 days after the v1 token has been configured
        migrationDeadline = uint32(block.timestamp + MIGRATION_PERIOD);
        emit V1TokenConfigured(address(_token), migrationDeadline);
    }

    /**
     * @notice Claim v1 tokens for special addresses
     * @param _specialMigrations Special migrations
     */
    function claimSpecialAddresses(
        Migration[] calldata _specialMigrations
    ) external onlyOwner canMigrate {
        uint256 length = _specialMigrations.length;
        _validateListLength(length);
        uint256 totalAmount;
        for (uint256 i; i < length; ) {
            Migration calldata migration = _specialMigrations[i];
            if (
                migration.wallet == address(_beta) ||
                migration.wallet == BETA_PAIR_ADDRESS ||
                migration.wallet == BETA_OTSEA_PLATFORM ||
                migration.wallet == OTSeaLibrary.DEAD_ADDRESS
            ) {
                _validateMigration(migration);
                _migrated[migration.wallet] += migration.amount;
                totalAmount += migration.amount;
                emit Migrated(migration.wallet, migration);
            } else {
                /// @dev revert due to _specialMigrations containing a migration for a non-special wallet
                revert OTSeaErrors.InvalidAddressAtIndex(i);
            }
            unchecked {
                i++;
            }
        }
        /// @dev special addresses do not receive their tokens and instead the multi-sig receives them
        v1.safeTransfer(multiSigAdmin, totalAmount);
    }

    /// @notice Claim v1 credit (only for users that took part in the liquidity extraction)
    function claimCredit() external canMigrate {
        uint256 credit = _credit[_msgSender()];
        if (credit == 0) revert OTSeaErrors.NotAvailable();
        _credit[_msgSender()] = 0;
        /// @dev update _migrated[_msgSender()] so that they cannot reclaim the credit amount using migrate()
        _migrated[_msgSender()] += credit;
        v1.safeTransfer(_msgSender(), credit);
        emit CreditClaimed(_msgSender(), credit);
    }

    /**
     * @notice Swap beta tokens for ETH, to be used by the owner
     * @param _amountToSell Amount of beta tokens to sell
     * @param _minETHAmount Minimum ETH to receive from selling
     */
    function sellBetaTokens(uint256 _amountToSell, uint256 _minETHAmount) external onlyOwner {
        if (_amountToSell == 0 || _beta.balanceOf(address(this)) < _amountToSell)
            revert OTSeaErrors.InvalidAmount();
        if (_minETHAmount == 0) revert InvalidMinETHAmount();
        uint256 ethReceived = _sell(_amountToSell, _minETHAmount);
        emit SoldBetaTokens(_amountToSell, ethReceived);
    }

    /// @notice After 90 days, any unclaimed tokens are available to be claimed by the multi-sig admin
    function claimUnclaimedV1Tokens() external {
        if (_msgSender() != multiSigAdmin) revert OTSeaErrors.Unauthorized();
        if (address(v1) == address(0)) revert OTSeaErrors.NotAvailable();
        uint256 amountToClaim = v1.balanceOf(address(this));
        /// @dev If the deadline has not been reached yet or it has but the amount to claim is 0, it reverts
        if (!_isDeadlineReached() || amountToClaim == 0) revert OTSeaErrors.NotAvailable();
        v1.safeTransfer(multiSigAdmin, amountToClaim);
        emit ClaimedUnclaimedV1Tokens(amountToClaim);
    }

    /**
     * @notice Migrate beta -> v1 tokens provided a valid merkle proof is present
     * @param _migration Migration
     */
    function migrate(Migration calldata _migration) external canMigrate {
        /// @dev if credit is owed it must first be claimed
        if (_credit[_msgSender()] != 0) revert OTSeaErrors.NotAvailable();
        if (_migration.wallet != _msgSender()) revert OTSeaErrors.Unauthorized();
        _validateMigration(_migration);
        _checkSufficientAmount(_migration);
        _migrate(_migration);
    }

    /**
     * @notice Get the amount migrated by an address
     * @param _account Account
     * @return uint256 Amount migrated by _account
     */
    function getMigratedAmountByAddress(address _account) external view returns (uint256) {
        return _migrated[_account];
    }

    /**
     * @notice Get the amount of v1 credit owed to an address
     * @param _account Account
     * @return uint256 Amount of credited owed to _account
     */
    function getCreditAmountByAddress(address _account) external view returns (uint256) {
        return _credit[_account];
    }

    /// @param _migration Migration
    function _migrate(Migration calldata _migration) private {
        _migrated[_migration.wallet] += _migration.amount;
        _beta.safeTransferFrom(_migration.wallet, address(this), _migration.amount);
        v1.safeTransfer(_migration.wallet, _migration.amount);
        emit Migrated(_migration.wallet, _migration);
    }

    /**
     * @param _amountToSell Amount of beta tokens to sell
     * @param _minETHAmount Minimum ETH to receive from selling
     * @return received Amount of ETH received for selling _amountToSell beta tokens
     */
    function _sell(uint _amountToSell, uint _minETHAmount) private returns (uint256 received) {
        address[] memory path = new address[](2);
        path[0] = address(_beta);
        path[1] = _router.WETH();
        _beta.forceApprove(address(_router), _amountToSell);
        uint256 ethBefore = multiSigAdmin.balance;
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            _amountToSell,
            _minETHAmount,
            path,
            multiSigAdmin,
            block.timestamp
        );
        received = multiSigAdmin.balance - ethBefore;
    }

    /// @param _migration Migration
    function _validateMigration(Migration calldata _migration) private view {
        if (_migration.proof.length == 0) revert InvalidProof();
        if (_migration.amount == 0 || _migration.snapshot == 0) revert OTSeaErrors.InvalidAmount();
        if (_migration.snapshot < _migrated[_migration.wallet] + _migration.amount)
            revert AmountExceedsSnapshot();
        bytes32 leaf = keccak256(abi.encodePacked(_migration.wallet, _migration.snapshot));
        bool isValidProof = MerkleProof.verifyCalldata(_migration.proof, merkleRoot, leaf);
        if (!isValidProof) revert InvalidProof();
    }

    /// @param _migration Migration
    function _checkSufficientAmount(Migration calldata _migration) private view {
        if (_beta.balanceOf(_migration.wallet) < _migration.amount)
            revert IERC20Errors.ERC20InsufficientBalance(
                _migration.wallet,
                _beta.balanceOf(_migration.wallet),
                _migration.amount
            );
        if (_beta.allowance(_migration.wallet, address(this)) < _migration.amount)
            revert IERC20Errors.ERC20InsufficientAllowance(
                address(this),
                _beta.allowance(_migration.wallet, address(this)),
                _migration.amount
            );
    }

    function _checkCanMigrate() private view {
        /// @dev check if the token has been configured and the deadline has not been reached
        if (address(v1) == address(0) || _isDeadlineReached()) revert OTSeaErrors.NotAvailable();
    }

    function _checkRootUploaded() private view {
        if (!_isRootUploaded()) revert RootNotUploaded();
    }

    /// @return bool true if the deadline has been reached, false if not
    function _isDeadlineReached() private view returns (bool) {
        return migrationDeadline < block.timestamp;
    }

    /// @return bool true if root has been uploaded, false if not
    function _isRootUploaded() private view returns (bool) {
        return merkleRoot != bytes32(0);
    }
}

// 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.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// 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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    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;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    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;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        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) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        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) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    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)
        }
    }
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    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);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

/*
        [....     [... [......  [.. ..
      [..    [..       [..    [..    [..
    [..        [..     [..     [..         [..       [..
    [..        [..     [..       [..     [.   [..  [..  [..
    [..        [..     [..          [.. [..... [..[..   [..
      [..     [..      [..    [..    [..[.        [..   [..
        [....          [..      [.. ..    [....     [.. [...

    https://otsea.io
    https://t.me/OTSeaPortal
    https://twitter.com/OTSeaERC20
*/

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

import "contracts/libraries/OTSeaErrors.sol";

/// @title A list helper contract
abstract contract ListHelper {
    uint16 internal constant LOOP_LIMIT = 500;
    bool internal constant ALLOW_ZERO = true;
    bool internal constant DISALLOW_ZERO = false;

    error InvalidStart();
    error InvalidEnd();
    error InvalidSequence();

    /**
     * @param _start Start
     * @param _end End
     * @param _total List total
     * @param _allowZero true - zero is a valid start or end, false - zero is an invalid start or end
     */
    modifier onlyValidSequence(
        uint256 _start,
        uint256 _end,
        uint256 _total,
        bool _allowZero
    ) {
        _checkSequence(_start, _end, _total, _allowZero);
        _;
    }

    /**
     * @param _start Start
     * @param _end End
     * @param _total Total
     * @param _allowZero true - zero is a valid start or end, false - zero is an invalid start or end
     * @dev check that a range of indexes is valid.
     */
    function _checkSequence(
        uint256 _start,
        uint256 _end,
        uint256 _total,
        bool _allowZero
    ) private pure {
        if (_allowZero) {
            if (_start >= _total) revert InvalidStart();
            if (_end >= _total) revert InvalidEnd();
        } else {
            if (_start == 0 || _start > _total) revert InvalidStart();
            if (_end == 0 || _end > _total) revert InvalidEnd();
        }
        if (_start > _end) revert InvalidStart();
        if (_end - _start + 1 > LOOP_LIMIT) revert InvalidSequence();
    }

    /// @dev _length List length
    function _validateListLength(uint256 _length) internal pure {
        if (_length == 0 || LOOP_LIMIT < _length) revert OTSeaErrors.InvalidArrayLength();
    }
}

/*
        [....     [... [......  [.. ..
      [..    [..       [..    [..    [..
    [..        [..     [..     [..         [..       [..
    [..        [..     [..       [..     [.   [..  [..  [..
    [..        [..     [..          [.. [..... [..[..   [..
      [..     [..      [..    [..    [..[.        [..   [..
        [....          [..      [.. ..    [....     [.. [...

    https://otsea.io
    https://t.me/OTSeaPortal
    https://twitter.com/OTSeaERC20
*/

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "contracts/libraries/OTSeaErrors.sol";

/// @title A transfer helper contract for ETH and tokens
contract TransferHelper is Context {
    using SafeERC20 for IERC20;

    /// @dev account -> Amount of ETH that failed to transfer
    mapping(address => uint256) private _maroonedETH;

    error NativeTransferFailed();

    event MaroonedETH(address account, uint256 amount);
    event MaroonedETHClaimed(address account, address receiver, uint256 amount);

    /**
     * @notice Claim marooned ETH
     * @param _receiver Address to receive the marooned ETH
     */
    function claimMaroonedETH(address _receiver) external {
        if (_receiver == address(0)) revert OTSeaErrors.InvalidAddress();
        uint256 amount = _maroonedETH[_msgSender()];
        if (amount == 0) revert OTSeaErrors.NotAvailable();
        _maroonedETH[_msgSender()] = 0;
        _transferETHOrRevert(_receiver, amount);
        emit MaroonedETHClaimed(_msgSender(), _receiver, amount);
    }

    /**
     * @notice Get the amount of marooned ETH for an account
     * @param _account Account to check
     * @return uint256 Marooned ETH
     */
    function getMaroonedETH(address _account) external view returns (uint256) {
        if (_account == address(0)) revert OTSeaErrors.InvalidAddress();
        return _maroonedETH[_account];
    }

    /**
     * @param _account Account to transfer ETH to
     * @param _amount Amount of ETH to transfer to _account
     * @dev Rather than reverting if the transfer fails, the _amount is stored for the _account to later claim
     */
    function _safeETHTransfer(address _account, uint256 _amount) internal {
        (bool success, ) = _account.call{value: _amount}("");
        if (!success) {
            _maroonedETH[_account] += _amount;
            emit MaroonedETH(_account, _amount);
        }
    }

    /**
     * @param _account Account to transfer ETH to
     * @param _amount Amount of ETH to transfer to _account
     * @dev The following will revert if the transfer fails
     */
    function _transferETHOrRevert(address _account, uint256 _amount) internal {
        (bool success, ) = _account.call{value: _amount}("");
        if (!success) revert NativeTransferFailed();
    }

    /**
     * @param _token Token to transfer into the contract from msg.sender
     * @param _amount Amount of _token to transfer
     * @return uint256 Actual amount transferred into the contract
     * @dev This function exists due to _token potentially having taxes
     */
    function _transferInTokens(IERC20 _token, uint256 _amount) internal returns (uint256) {
        uint256 balanceBefore = _token.balanceOf(address(this));
        _token.safeTransferFrom(_msgSender(), address(this), _amount);
        return _token.balanceOf(address(this)) - balanceBefore;
    }
}

/*
        [....     [... [......  [.. ..
      [..    [..       [..    [..    [..
    [..        [..     [..     [..         [..       [..
    [..        [..     [..       [..     [.   [..  [..  [..
    [..        [..     [..          [.. [..... [..[..   [..
      [..     [..      [..    [..    [..[.        [..   [..
        [....          [..      [.. ..    [....     [.. [...

    https://otsea.io
    https://t.me/OTSeaPortal
    https://twitter.com/OTSeaERC20
*/

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

/// @title Common OTSea errors
library OTSeaErrors {
    error InvalidAmount();
    error InvalidAddress();
    error InvalidIndex(uint256 index);
    error InvalidAmountAtIndex(uint256 index);
    error InvalidAddressAtIndex(uint256 index);
    error DuplicateAddressAtIndex(uint256 index);
    error AddressNotFoundAtIndex(uint256 index);
    error Unauthorized();
    error ExpectationMismatch();
    error InvalidArrayLength();
    error InvalidFee();
    error NotAvailable();
    error InvalidPurchase();
    error InvalidETH(uint256 expected);
    error Unchanged();
}

/*
        [....     [... [......  [.. ..
      [..    [..       [..    [..    [..
    [..        [..     [..     [..         [..       [..
    [..        [..     [..       [..     [.   [..  [..  [..
    [..        [..     [..          [.. [..... [..[..   [..
      [..     [..      [..    [..    [..[.        [..   [..
        [....          [..      [.. ..    [....     [.. [...

    https://otsea.io
    https://t.me/OTSeaPortal
    https://twitter.com/OTSeaERC20
*/

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

/// @title Common OTSea variables
library OTSeaLibrary {
    enum FeeType {
        Fish,
        Whale
    }

    uint16 internal constant PERCENT_DENOMINATOR = 10000;
    address internal constant DEAD_ADDRESS = address(0xdead);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_multiSigAdmin","type":"address"},{"internalType":"address","name":"_migrationHandler","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AmountExceedsSnapshot","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"DuplicateAddressAtIndex","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"InvalidAddressAtIndex","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidArrayLength","type":"error"},{"inputs":[],"name":"InvalidEnd","type":"error"},{"inputs":[],"name":"InvalidMinETHAmount","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"InvalidRoot","type":"error"},{"inputs":[],"name":"InvalidSequence","type":"error"},{"inputs":[],"name":"InvalidStart","type":"error"},{"inputs":[],"name":"NativeTransferFailed","type":"error"},{"inputs":[],"name":"NotAvailable","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"RootNotUploaded","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ClaimedUnclaimedV1Tokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"credit","type":"uint256"}],"name":"CreditClaimed","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"snapshot","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"indexed":false,"internalType":"struct OTSeaMigration.Migration[]","name":"migrations","type":"tuple[]"},{"indexed":false,"internalType":"uint256","name":"amountSold","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"}],"name":"ExtractedLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MaroonedETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MaroonedETHClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"MerkleRootUploaded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"snapshot","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"indexed":false,"internalType":"struct OTSeaMigration.Migration","name":"migration","type":"tuple"}],"name":"Migrated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountSold","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"}],"name":"SoldBetaTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint32","name":"migrationDeadline","type":"uint32"}],"name":"V1TokenConfigured","type":"event"},{"inputs":[],"name":"claimCredit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"}],"name":"claimMaroonedETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"snapshot","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct OTSeaMigration.Migration[]","name":"_specialMigrations","type":"tuple[]"}],"name":"claimSpecialAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimUnclaimedV1Tokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"}],"name":"configureV1Token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"snapshot","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct OTSeaMigration.Migration[]","name":"_migrations","type":"tuple[]"},{"internalType":"uint256","name":"_minETHAmount","type":"uint256"}],"name":"extractLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getCreditAmountByAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getMaroonedETH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getMigratedAmountByAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasLiquidityBeenExtracted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"snapshot","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct OTSeaMigration.Migration","name":"_migration","type":"tuple"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrationDeadline","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiSigAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountToSell","type":"uint256"},{"internalType":"uint256","name":"_minETHAmount","type":"uint256"}],"name":"sellBetaTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"uploadMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"v1","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000000adedc7487c59ece60178cf69b8df7e3c4730d9000000000000000000000000013a2d9e789f4a7bc92cb0fc22fc5ff8f03e14d98

-----Decoded View---------------
Arg [0] : _multiSigAdmin (address): 0x0adEDC7487c59eCe60178Cf69b8DF7E3c4730d90
Arg [1] : _migrationHandler (address): 0x13A2d9E789F4a7bC92CB0fC22fc5fF8F03E14D98

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000adedc7487c59ece60178cf69b8df7e3c4730d90
Arg [1] : 00000000000000000000000013a2d9e789f4a7bc92cb0fc22fc5ff8f03e14d98