Contract Address Details

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

import "./libraries/upgrade/PauseUpgradeSafe.sol";
import "./libraries/upgrade/OwnerOperatorUpgradeSafe.sol";

import "./libraries/BytesLibrary.sol";
import "./libraries/StringLibrary.sol";

import "./interfaces/ITransporter.sol";

contract TokenGate is OwnerOperatorUpgradeSafe, PauseUpgradeSafe {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using StringLibrary for string;
    using BytesLibrary for bytes32;

    struct DepositData {
        address payable owner;
        address token;
        uint256 blockExpired;
        uint256 amount;
        string none;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }

    struct SavedDeposit {
        address owner;
        uint256 blockExpired;
        uint256 amount;
    }

    struct ClaimData {
        address payable owner;
        address token;
        uint256 blockExpired;
        uint256 amount;
        string none;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }

    struct SavedClaim {
        address owner;
        uint256 blockExpired;
        uint256 amount;
    }

    // Mapping from token address to token deposit balance
    mapping(address => uint256) public tokenBalance;
    // Mapping from token address to accept value
    mapping(address => bool) public tokenAccepted;
    // Mapping from token address, vault address to balance
    mapping(address => mapping(address => uint256)) public vaultBalance;

    // Mapping from token address, sign message to checking value
    mapping(address => mapping(bytes32 => bool)) public depositCompleted;
    // Mapping from token address, none to depositData
    mapping(address => mapping(string => SavedDeposit)) public depositData;
    // Mapping from token address, user address to deposit count
    mapping(address => mapping(address => uint256)) public depositCountOf;
    // Mapping from token address, user address and deposit index to deposit none
    mapping(address => mapping(address => mapping(uint256 => string))) public depositNoneOf;

    // Mapping from token address, sign message to checking value
    mapping(address => mapping(bytes32 => bool)) public claimCompleted;
    // Mapping from token address, none to claimData
    mapping(address => mapping(string => SavedClaim)) public claimData;
    // Mapping from token address, user address to claim count
    mapping(address => mapping(address => uint256)) public claimCountOf;
    // Mapping from token address, user address and claim index to claim none
    mapping(address => mapping(address => mapping(uint256 => string))) public claimNoneOf;

    address public tokenMARE;
    address public tokenEMAS;

    event Deposit(address indexed from, address indexed token, address indexed signer, uint256 amount, string none);
    event Claim(address indexed receiver, address indexed token, address indexed signer, uint256 amount, string none);
    event DepositVault(address indexed from, address indexed vault, address indexed token, uint256 amount);
    event WithdrawVault(address indexed vault, address indexed token, uint256 amount);

    ITransporter public transporter;

    function init() public initializer {
        __OwnerOperator_init();
        __Pause_init();
    }

    /**
     * @dev pauses all deposits, claims. See {Pausable-_pause}.
     */
    function pause() external virtual onlyOwner {
        _pause();
    }

    /**
     * @dev unpauses all deposits, claims. See {Pausable-_pause}.
     */
    function unpause() external virtual onlyOwner {
        _unpause();
    }

    function approveToken(address token, bool value) external virtual onlyOwner {
        tokenAccepted[token] = value;
    }

    function setTransporter(address _transporter) external virtual onlyOwner {
        transporter = ITransporter(_transporter);
    }

    function setToken(address _tokenMARE, address _tokenEMAS) external virtual onlyOwner {
        tokenMARE = _tokenMARE;
        tokenEMAS = _tokenEMAS;
    }

    /**
     * @dev withdraw tokens that do not belong to the vault.
     */
    function withdraw(address token) external virtual onlyOwner {
        uint256 amount = IERC20(token).balanceOf(address(this)).sub(tokenBalance[token]);
        require(amount > 0, "TokenGate: zero out amount");
        IERC20(token).safeTransfer(msg.sender, amount);
    }

    /**
     * @dev only operator can deposit token to vault.
     */
    function depositVault(
        address vault,
        address token,
        uint256 amount
    ) external virtual onlyOperator {
        require(tokenAccepted[token], "TokenGate: Not accept token");
        require(operators[vault], "TokenGate: invalid vault");
        require(amount > 0, "TokenGate: zero out amount");

        tokenBalance[token] = tokenBalance[token].add(amount);
        vaultBalance[token][vault] = vaultBalance[token][vault].add(amount);

        transporter.safeTransferTokenFrom(token, msg.sender, address(this), amount);
        emit DepositVault(msg.sender, vault, token, amount);
    }

    /**
     * @dev only vault owner can withdraw token of vault.
     */
    function withdrawVault(address token, uint256 amount) external virtual onlyOperator {
        require(tokenAccepted[token], "TokenGate: Not accept token");
        require(amount > 0, "TokenGate: zero out amount");
        require(vaultBalance[token][msg.sender] >= amount, "TokenGate: exceeded vault balance");

        tokenBalance[token] = tokenBalance[token].sub(amount);
        vaultBalance[token][msg.sender] = vaultBalance[token][msg.sender].sub(amount);

        IERC20(token).safeTransfer(msg.sender, amount);
        emit WithdrawVault(msg.sender, token, amount);
    }

    /**
     * @dev deposit token to vault by sign message from server.
     */
    function deposit(DepositData memory data) external virtual whenNotPaused {
        require(data.amount > 0, "TokenGate: zero out amount");
        require(tokenAccepted[data.token], "TokenGate: Not accept token");
        require(_msgSender() == data.owner, "TokenGate: sender is not owner");
        (bytes32 message, address signer) = _verifyDeposit(data);

        depositCompleted[data.token][message] = true;
        depositData[data.token][data.none] = SavedDeposit({
            owner: data.owner,
            blockExpired: block.number,
            amount: data.amount
        });
        depositNoneOf[data.token][data.owner][depositCountOf[data.token][data.owner]] = data.none;
        depositCountOf[data.token][data.owner] = depositCountOf[data.token][data.owner].add(1);

        tokenBalance[data.token] = tokenBalance[data.token].add(data.amount);
        vaultBalance[data.token][signer] = vaultBalance[data.token][signer].add(data.amount);

        transporter.safeTransferTokenFrom(data.token, msg.sender, address(this), data.amount);
        emit Deposit(msg.sender, data.token, signer, data.amount, data.none);
    }

    function _verifyDeposit(DepositData memory data) internal view returns (bytes32, address) {
        bytes32 message = keccak256(
            abi.encode(address(this), "Deposit", data.owner, data.token, data.blockExpired, data.amount, data.none)
        );
        address signer = message.toString().recover(data.v, data.r, data.s);

        require(operators[signer], "TokenGate: deposit not verify");
        require(block.number < data.blockExpired, "TokenGate: deposit expired");
        require(!depositCompleted[data.token][message], "TokenGate: deposit completed");
        require(depositData[data.token][data.none].owner == address(0), "TokenGate: none existed");

        return (message, signer);
    }

    /**
     * @dev claim token by sign message from server.
     */
    function claim(ClaimData memory data) external virtual whenNotPaused {
        require(data.amount > 0, "TokenGate: zero out amount");
        require(tokenAccepted[data.token], "TokenGate: Not accept token");
        require(_msgSender() == data.owner, "TokenGate: sender is not owner");
        (bytes32 message, address signer) = _verifyClaim(data);

        uint256 amount = data.amount;

        if (data.token == tokenEMAS && vaultBalance[tokenEMAS][signer] < amount) {
            // Claim EMAS
            // Caculate amount MARE in, amount EMAS out
            require(tokenAccepted[tokenMARE], "TokenGate: Not accept token");
            require(tokenAccepted[tokenEMAS], "TokenGate: Not accept token");
            require(amount > 0, "TokenGate: zero amount");
            require(vaultBalance[tokenMARE][signer] >= amount, "TokenGate: exceeded vault balance");

            tokenBalance[tokenMARE] = tokenBalance[tokenMARE].sub(amount);
            vaultBalance[tokenMARE][signer] = vaultBalance[tokenMARE][signer].sub(amount);

            tokenBalance[tokenEMAS] = tokenBalance[tokenEMAS].add(amount);
            vaultBalance[tokenEMAS][signer] = vaultBalance[tokenEMAS][signer].add(amount);

            IERC20(data.token).safeApprove(data.owner, amount);
            emit WithdrawVault(signer, tokenMARE, amount);
            emit DepositVault(signer, signer, tokenEMAS, amount);
        }
        require(vaultBalance[data.token][signer] >= amount, "TokenGate: exceeded vault balance");
        claimCompleted[data.token][message] = true;
        claimData[data.token][data.none] = SavedClaim({
            owner: data.owner,
            blockExpired: data.blockExpired,
            amount: amount
        });
        claimNoneOf[data.token][data.owner][claimCountOf[data.token][data.owner]] = data.none;
        claimCountOf[data.token][data.owner] = claimCountOf[data.token][data.owner].add(1);

        tokenBalance[data.token] = tokenBalance[data.token].sub(amount);
        vaultBalance[data.token][signer] = vaultBalance[data.token][signer].sub(amount);

        IERC20(tokenMARE).safeTransfer(data.owner, amount);

        emit Claim(data.owner, data.token, signer, amount, data.none);
    }

    function _verifyClaim(ClaimData memory data) internal view returns (bytes32, address) {
        bytes32 message = keccak256(
            abi.encode(address(this), "Claim", data.owner, data.token, data.blockExpired, data.amount, data.none)
        );
        address signer = message.toString().recover(data.v, data.r, data.s);

        require(operators[signer], "TokenGate: claim not verify");
        require(block.number < data.blockExpired, "TokenGate: claim expired");
        require(!claimCompleted[data.token][message], "TokenGate: claim completed");
        require(claimData[data.token][data.none].owner == address(0), "TokenGate: none existed");

        return (message, signer);
    }

}

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
// import "@openzeppelin/contracts/utils/math/SafeMath.sol";

// import "./libraries/upgrade/PauseUpgradeSafe.sol";
// import "./libraries/upgrade/OwnerOperatorUpgradeSafe.sol";

// import "./libraries/BytesLibrary.sol";
// import "./libraries/StringLibrary.sol";

// import "./interfaces/ITransporter.sol";
// import "./interfaces/ITokenize.sol";

// contract TokenGate is OwnerOperatorUpgradeSafe, PauseUpgradeSafe {
//     using SafeERC20 for IERC20;
//     using SafeMath for uint256;
//     using StringLibrary for string;
//     using BytesLibrary for bytes32;

//     struct DepositData {
//         address payable owner;
//         address token;
//         uint256 blockExpired;
//         uint256 amount;
//         string none;
//         uint8 v;
//         bytes32 r;
//         bytes32 s;
//     }

//     struct SavedDeposit {
//         address owner;
//         uint256 blockExpired;
//         uint256 amount;
//     }

//     struct ClaimData {
//         address payable owner;
//         address token;
//         uint256 blockExpired;
//         uint256 amount;
//         string none;
//         uint8 v;
//         bytes32 r;
//         bytes32 s;
//     }

//     struct SavedClaim {
//         address owner;
//         uint256 blockExpired;
//         uint256 amount;
//     }

//     // Mapping from token address to token deposit balance
//     mapping(address => uint256) public tokenBalance;
//     // Mapping from token address to accept value
//     mapping(address => bool) public tokenAccepted;
//     // Mapping from token address, vault address to balance
//     mapping(address => mapping(address => uint256)) public vaultBalance;

//     // Mapping from token address, sign message to checking value
//     mapping(address => mapping(bytes32 => bool)) public depositCompleted;
//     // Mapping from token address, none to depositData
//     mapping(address => mapping(string => SavedDeposit)) public depositData;
//     // Mapping from token address, user address to deposit count
//     mapping(address => mapping(address => uint256)) public depositCountOf;
//     // Mapping from token address, user address and deposit index to deposit none
//     mapping(address => mapping(address => mapping(uint256 => string))) public depositNoneOf;

//     // Mapping from token address, sign message to checking value
//     mapping(address => mapping(bytes32 => bool)) public claimCompleted;
//     // Mapping from token address, none to claimData
//     mapping(address => mapping(string => SavedClaim)) public claimData;
//     // Mapping from token address, user address to claim count
//     mapping(address => mapping(address => uint256)) public claimCountOf;
//     // Mapping from token address, user address and claim index to claim none
//     mapping(address => mapping(address => mapping(uint256 => string))) public claimNoneOf;

//     address public tokenMARE;
//     address public tokenEMAS;

//     event Deposit(address indexed from, address indexed token, address indexed signer, uint256 amount, string none);
//     event Claim(address indexed receiver, address indexed token, address indexed signer, uint256 amount, string none);
//     event DepositVault(address indexed from, address indexed vault, address indexed token, uint256 amount);
//     event WithdrawVault(address indexed vault, address indexed token, uint256 amount);

//     ITransporter public transporter;
//     ITokenize public tokenize;

//     function init() public initializer {
//         __OwnerOperator_init();
//         __Pause_init();
//     }

//     /**
//      * @dev pauses all deposits, claims. See {Pausable-_pause}.
//      */
//     function pause() external virtual onlyOwner {
//         _pause();
//     }

//     /**
//      * @dev unpauses all deposits, claims. See {Pausable-_pause}.
//      */
//     function unpause() external virtual onlyOwner {
//         _unpause();
//     }

//     function approveToken(address token, bool value) external virtual onlyOwner {
//         tokenAccepted[token] = value;
//     }

//     function setTransporter(address _transporter) external virtual onlyOwner {
//         transporter = ITransporter(_transporter);
//     }

//     function setTokenize(address _tokenize) external virtual onlyOwner {
//         tokenize = ITokenize(_tokenize);
//     }

//     function setToken(address _tokenMARE, address _tokenEMAS) external virtual onlyOwner {
//         tokenMARE = _tokenMARE;
//         tokenEMAS = _tokenEMAS;
//     }

//     /**
//      * @dev withdraw tokens that do not belong to the vault.
//      */
//     function withdraw(address token) external virtual onlyOwner {
//         uint256 amount = IERC20(token).balanceOf(address(this)).sub(tokenBalance[token]);
//         require(amount > 0, "TokenGate: zero out amount");
//         IERC20(token).safeTransfer(msg.sender, amount);
//     }

//     /**
//      * @dev only operator can deposit token to vault.
//      */
//     function depositVault(
//         address vault,
//         address token,
//         uint256 amount
//     ) external virtual onlyOperator {
//         require(tokenAccepted[token], "TokenGate: Not accept token");
//         require(operators[vault], "TokenGate: invalid vault");
//         require(amount > 0, "TokenGate: zero out amount");

//         tokenBalance[token] = tokenBalance[token].add(amount);
//         vaultBalance[token][vault] = vaultBalance[token][vault].add(amount);

//         transporter.safeTransferTokenFrom(token, msg.sender, address(this), amount);
//         emit DepositVault(msg.sender, vault, token, amount);
//     }

//     /**
//      * @dev only vault owner can withdraw token of vault.
//      */
//     function withdrawVault(address token, uint256 amount) external virtual onlyOperator {
//         require(tokenAccepted[token], "TokenGate: Not accept token");
//         require(amount > 0, "TokenGate: zero out amount");
//         require(vaultBalance[token][msg.sender] >= amount, "TokenGate: exceeded vault balance");

//         tokenBalance[token] = tokenBalance[token].sub(amount);
//         vaultBalance[token][msg.sender] = vaultBalance[token][msg.sender].sub(amount);

//         IERC20(token).safeTransfer(msg.sender, amount);
//         emit WithdrawVault(msg.sender, token, amount);
//     }

//     /**
//      * @dev deposit token to vault by sign message from server.
//      */
//     function deposit(DepositData memory data) external virtual whenNotPaused {
//         require(data.amount > 0, "TokenGate: zero out amount");
//         require(tokenAccepted[data.token], "TokenGate: Not accept token");
//         require(_msgSender() == data.owner, "TokenGate: sender is not owner");
//         (bytes32 message, address signer) = _verifyDeposit(data);

//         depositCompleted[data.token][message] = true;
//         depositData[data.token][data.none] = SavedDeposit({
//             owner: data.owner,
//             blockExpired: block.number,
//             amount: data.amount
//         });
//         depositNoneOf[data.token][data.owner][depositCountOf[data.token][data.owner]] = data.none;
//         depositCountOf[data.token][data.owner] = depositCountOf[data.token][data.owner].add(1);

//         tokenBalance[data.token] = tokenBalance[data.token].add(data.amount);
//         vaultBalance[data.token][signer] = vaultBalance[data.token][signer].add(data.amount);

//         transporter.safeTransferTokenFrom(data.token, msg.sender, address(this), data.amount);
//         emit Deposit(msg.sender, data.token, signer, data.amount, data.none);
//     }

//     function _verifyDeposit(DepositData memory data) internal view returns (bytes32, address) {
//         bytes32 message = keccak256(
//             abi.encode(address(this), "Deposit", data.owner, data.token, data.blockExpired, data.amount, data.none)
//         );
//         address signer = message.toString().recover(data.v, data.r, data.s);

//         require(operators[signer], "TokenGate: deposit not verify");
//         require(block.number < data.blockExpired, "TokenGate: deposit expired");
//         require(!depositCompleted[data.token][message], "TokenGate: deposit completed");
//         require(depositData[data.token][data.none].owner == address(0), "TokenGate: none existed");

//         return (message, signer);
//     }

//     /**
//      * @dev claim token by sign message from server.
//      */
//     function claim(ClaimData memory data) external virtual whenNotPaused {
//         require(data.amount > 0, "TokenGate: zero out amount");
//         require(tokenAccepted[data.token], "TokenGate: Not accept token");
//         require(_msgSender() == data.owner, "TokenGate: sender is not owner");
//         (bytes32 message, address signer) = _verifyClaim(data);

//         uint256 amount = data.amount;

//         if (data.token == tokenEMAS && vaultBalance[tokenEMAS][signer] < amount) {
//             // Claim EMAS
//             // Caculate amount MARE in, amount EMAS out
//             require(tokenAccepted[tokenMARE], "TokenGate: Not accept token");
//             require(tokenAccepted[tokenEMAS], "TokenGate: Not accept token");

//             uint256 amountIn = tokenize.calcAmountIn(tokenMARE, tokenEMAS, amount);
//             amount = tokenize.calcAmountOut(tokenMARE, amountIn, tokenEMAS);

//             require(amountIn > 0, "TokenGate: zero amount");
//             require(vaultBalance[tokenMARE][signer] >= amountIn, "TokenGate: exceeded vault balance");

//             tokenBalance[tokenMARE] = tokenBalance[tokenMARE].sub(amountIn);
//             vaultBalance[tokenMARE][signer] = vaultBalance[tokenMARE][signer].sub(amountIn);

//             tokenBalance[tokenEMAS] = tokenBalance[tokenEMAS].add(amount);
//             vaultBalance[tokenEMAS][signer] = vaultBalance[tokenEMAS][signer].add(amount);

//             IERC20(data.token).safeApprove(data.owner, amountIn);

//             emit WithdrawVault(signer, tokenMARE, amountIn);
//             emit DepositVault(signer, signer, tokenEMAS, amount);
//         }

//         require(vaultBalance[data.token][signer] >= amount, "TokenGate: exceeded vault balance");

//         claimCompleted[data.token][message] = true;
//         claimData[data.token][data.none] = SavedClaim({
//             owner: data.owner,
//             blockExpired: data.blockExpired,
//             amount: amount
//         });
//         claimNoneOf[data.token][data.owner][claimCountOf[data.token][data.owner]] = data.none;
//         claimCountOf[data.token][data.owner] = claimCountOf[data.token][data.owner].add(1);

//         tokenBalance[data.token] = tokenBalance[data.token].sub(amount);
//         vaultBalance[data.token][signer] = vaultBalance[data.token][signer].sub(amount);

//         IERC20(tokenMARE).safeTransfer(data.owner, amount);

//         emit Claim(data.owner, data.token, signer, amount, data.none);
//     }

//     function _verifyClaim(ClaimData memory data) internal view returns (bytes32, address) {
//         bytes32 message = keccak256(
//             abi.encode(address(this), "Claim", data.owner, data.token, data.blockExpired, data.amount, data.none)
//         );
//         address signer = message.toString().recover(data.v, data.r, data.s);

//         require(operators[signer], "TokenGate: claim not verify");
//         require(block.number < data.blockExpired, "TokenGate: claim expired");
//         require(!claimCompleted[data.token][message], "TokenGate: claim completed");
//         require(claimData[data.token][data.none].owner == address(0), "TokenGate: none existed");

//         return (message, signer);
//     }

//     function swapVaultMAREtoEMAS(
//         address tokenIn,
//         address tokenOut,
//         uint256 amountIn
//     ) external virtual onlyOperator {
//         require(tokenAccepted[tokenIn], "TokenGate: Not accept token");
//         require(amountIn > 0, "TokenGate: zero out amount");
//         require(vaultBalance[tokenIn][msg.sender] >= amountIn, "TokenGate: exceeded vault balance");

//         uint256 amoutOut = tokenize.calcAmountOut(tokenIn, amountIn, tokenOut);

//         tokenBalance[tokenIn] = tokenBalance[tokenIn].sub(amountIn);
//         vaultBalance[tokenIn][msg.sender] = vaultBalance[tokenIn][msg.sender].sub(amountIn);

//         tokenBalance[tokenOut] = tokenBalance[tokenOut].add(amoutOut);
//         vaultBalance[tokenOut][msg.sender] = vaultBalance[tokenOut][msg.sender].add(amoutOut);

//         IERC20(tokenIn).safeApprove(address(tokenize), amountIn);
//         tokenize.swap(tokenIn, amountIn, tokenOut, amoutOut);

//         emit WithdrawVault(msg.sender, tokenIn, amountIn);
//         emit DepositVault(msg.sender, msg.sender, tokenOut, amoutOut);
//     }
// }
        

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev BytesLibrary operations.
 */
library BytesLibrary {
    function toString(bytes32 value) internal pure returns (string memory) {
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(64);
        for (uint256 i = 0; i < 32; i++) {
            str[i * 2] = alphabet[uint8(value[i] >> 4)];
            str[1 + i * 2] = alphabet[uint8(value[i] & 0x0f)];
        }
        return string(str);
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./UintLibrary.sol";

library StringLibrary {
    using UintLibrary for uint256;

    function append(string memory a, string memory b) internal pure returns (string memory) {
        bytes memory ba = bytes(a);
        bytes memory bb = bytes(b);
        bytes memory bab = new bytes(ba.length + bb.length);
        uint256 k = 0;
        for (uint256 i = 0; i < ba.length; i++) bab[k++] = ba[i];
        for (uint256 i = 0; i < bb.length; i++) bab[k++] = bb[i];
        return string(bab);
    }

    function append(
        string memory a,
        string memory b,
        string memory c
    ) internal pure returns (string memory) {
        bytes memory ba = bytes(a);
        bytes memory bb = bytes(b);
        bytes memory bc = bytes(c);
        bytes memory bbb = new bytes(ba.length + bb.length + bc.length);
        uint256 k = 0;
        for (uint256 i = 0; i < ba.length; i++) bbb[k++] = ba[i];
        for (uint256 i = 0; i < bb.length; i++) bbb[k++] = bb[i];
        for (uint256 i = 0; i < bc.length; i++) bbb[k++] = bc[i];
        return string(bbb);
    }

    function recover(
        string memory message,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        bytes memory msgBytes = bytes(message);
        bytes memory fullMessage = concat(
            bytes("\x19Ethereum Signed Message:\n"),
            bytes(msgBytes.length.toString()),
            msgBytes,
            new bytes(0),
            new bytes(0),
            new bytes(0),
            new bytes(0)
        );
        return ecrecover(keccak256(fullMessage), v, r, s);
    }

    function concat(
        bytes memory ba,
        bytes memory bb,
        bytes memory bc,
        bytes memory bd,
        bytes memory be,
        bytes memory bf,
        bytes memory bg
    ) internal pure returns (bytes memory) {
        bytes memory resultBytes = new bytes(ba.length + bb.length + bc.length + bd.length + be.length + bf.length + bg.length);
        uint256 k = 0;
        for (uint256 i = 0; i < ba.length; i++) resultBytes[k++] = ba[i];
        for (uint256 i = 0; i < bb.length; i++) resultBytes[k++] = bb[i];
        for (uint256 i = 0; i < bc.length; i++) resultBytes[k++] = bc[i];
        for (uint256 i = 0; i < bd.length; i++) resultBytes[k++] = bd[i];
        for (uint256 i = 0; i < be.length; i++) resultBytes[k++] = be[i];
        for (uint256 i = 0; i < bf.length; i++) resultBytes[k++] = bf[i];
        for (uint256 i = 0; i < bg.length; i++) resultBytes[k++] = bg[i];
        return resultBytes;
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @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);
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../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;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @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, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ITransporter {
    function safeTransferTokenFrom(
        address token_,
        address from_,
        address to_,
        uint256 amount_
    ) external;

    function safeTransferNFT721From(
        address token_,
        address from_,
        address to_,
        uint256 tokenId_
    ) external;

    function safeBurnNFT721From(address token_, uint256 tokenId_) external;

    function safeTransferNFT1155From(
        address token_,
        address from_,
        address to_,
        uint256 tokenId_,
        uint256 amount_
    ) external;

    function safeBurnNFT1155From(
        address token_,
        address from_,
        uint256 tokenId_,
        uint256 amount_
    ) external;

    function safeBurnBatchNFT1155From(
        address token_,
        address from_,
        uint256[] memory tokenId_,
        uint256[] memory amount_
    ) external;
}
          

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

library UintLibrary {
    using SafeMath for uint256;

    function toString(uint256 i) internal pure returns (string memory) {
        if (i == 0) {
            return "0";
        }

        uint256 j = i;
        uint256 len;

        while (j != 0) {
            len++;
            j /= 10;
        }

        bytes memory bstr = new bytes(len);

        for (uint256 k = len; k > 0; k--) {
            bstr[k - 1] = bytes1(uint8(48 + (i % 10)));
            i /= 10;
        }

        return string(bstr);
    }

    function bp(uint256 value, uint256 bpValue) internal pure returns (uint256) {
        return value.mul(bpValue).div(10000);
    }
}
          

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

import "@openzeppelin/contracts/proxy/utils/Initializable.sol";

abstract contract ContextUpgradeSafe is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    // Reserved storage space to allow for layout changes in the future.
    uint256[50] private __gap;
}
          

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

import "./ContextUpgradeSafe.sol";

abstract contract OwnableUpgradeSafe is ContextUpgradeSafe {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
          

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

import "./OwnableUpgradeSafe.sol";

abstract contract OwnerOperatorUpgradeSafe is OwnableUpgradeSafe {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    mapping(address => bool) public operators;
    event AddOperator(address indexed operator);
    event RemoveOperator(address indexed operator);

    function __OwnerOperator_init() internal initializer {
        __Ownable_init();
    }

    modifier operatorOrOwner() {
        require(operators[msg.sender] || owner() == msg.sender, "OwnerOperator: !operator, !owner");
        _;
    }

    modifier onlyOperator() {
        require(operators[msg.sender], "OwnerOperator: !operator");
        _;
    }

    function addOperator(address operator) external virtual onlyOwner {
        require(operator != address(0), "OwnerOperator: operator is the zero address");
        require(!operators[operator], "OwnerOperator: operator existed");
        operators[operator] = true;
        emit AddOperator(operator);
    }

    function removeOperator(address operator) external virtual onlyOwner {
        require(operator != address(0), "OwnerOperator: operator is the zero address");
        require(operators[operator], "OwnerOperator: operator not exist");
        operators[operator] = false;
        emit RemoveOperator(operator);
    }
}
          

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

import "./ContextUpgradeSafe.sol";

abstract contract PauseUpgradeSafe is ContextUpgradeSafe {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pause_init() internal initializer {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}