Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IWTON } from "../../dao/interfaces/IWTON.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../../proxy/ProxyStorage.sol";
import { AccessibleCommon } from "../../common/AccessibleCommon.sol";
import { DepositManagerStorage } from "./DepositManagerStorage.sol";

interface IOnApprove {
  function onApprove(address owner, address spender, uint256 amount, bytes calldata data) external returns (bool);
}

interface ILayer2Registry {
  function layer2s(address layer2) external view returns (bool);
}

interface ILayer2 {
  function operator() external view returns (address);
}

interface ISeigManager {
  function stakeOf(address layer2, address account) external view returns (uint256);
  function onDeposit(address layer2, address account, uint256 amount) external returns (bool);
  function onWithdraw(address layer2, address account, uint256 amount) external returns (bool);
}

/**
 * @dev DepositManager manages WTON deposit and withdrawal from operator and WTON holders.
 */
//ERC165
contract DepositManager is ProxyStorage, AccessibleCommon, DepositManagerStorage {
  using SafeERC20 for IERC20;

  ////////////////////
  // Modifiers
  ////////////////////

  modifier onlyLayer2(address layer2) {
    require(ILayer2Registry(_registry).layer2s(layer2));
    _;
  }

  modifier onlySeigManager() {
    require(msg.sender == _seigManager);
    _;
  }

  ////////////////////
  // Events
  ////////////////////

  event Deposited(address indexed layer2, address depositor, uint256 amount);
  event WithdrawalRequested(address indexed layer2, address depositor, uint256 amount);
  event WithdrawalProcessed(address indexed layer2, address depositor, uint256 amount);

  function initialize (
    address wton_,
    address registry_,
    address seigManager_,
    uint256 globalWithdrawalDelay_,
    address oldDepositManager_
  ) external {
    require(_wton == address(0), "already initialized");

    _wton = wton_;
    _registry = registry_;
    _seigManager = seigManager_;
    globalWithdrawalDelay = globalWithdrawalDelay_;
    oldDepositManager = oldDepositManager_;
    _registerInterface(IOnApprove.onApprove.selector);
  }

  ////////////////////
  // SeiManager function
  ////////////////////

  function setSeigManager(address seigManager_) external onlyOwner {
    _seigManager = seigManager_;
  }

  ////////////////////
  // ERC20 Approve callback
  ////////////////////

  function onApprove(
    address owner,
    address spender,
    uint256 amount,
    bytes calldata data
  ) external returns (bool) {
    require(msg.sender == _wton, "DepositManager: only accept WTON approve callback");

    address layer2 = _decodeDepositManagerOnApproveData(data);
    require(_deposit(layer2, owner, amount, owner));

    return true;
  }

  function _decodeDepositManagerOnApproveData(
    bytes memory data
  ) internal pure returns (address layer2) {
    require(data.length == 0x20);

    assembly {
      layer2 := mload(add(data, 0x20))
    }
  }

  ////////////////////
  // Deposit function
  ////////////////////

  /**
   * @dev deposit `amount` WTON in RAY
   */

  function deposit(address layer2, uint256 amount) external returns (bool) {
    require(_deposit(layer2, msg.sender, amount, msg.sender));
    return true;
  }

  function deposit(address layer2, address account, uint256 amount) external returns (bool) {
    require(_deposit(layer2, account, amount, msg.sender));
    return true;
  }

  function deposit(address layer2, address[] memory accounts, uint256[] memory amounts) external returns (bool) {
    require(accounts.length != 0, 'no account');
    require(accounts.length == amounts.length, 'wrong lenth');

    for (uint256 i = 0; i < accounts.length; i++){
      require(_deposit(layer2, accounts[i], amounts[i], msg.sender));
    }

    return true;
  }

  function _deposit(address layer2, address account, uint256 amount, address payer) internal onlyLayer2(layer2) returns (bool) {
    require(account != address(0) && amount != 0, "zero amount or zero address");
    _accStaked[layer2][account] = _accStaked[layer2][account] + amount;
    _accStakedLayer2[layer2] = _accStakedLayer2[layer2] + amount;
    _accStakedAccount[account] = _accStakedAccount[account] + amount;

    IERC20(_wton).safeTransferFrom(payer, address(this), amount);

    emit Deposited(layer2, account, amount);

    require(ISeigManager(_seigManager).onDeposit(layer2, account, amount));

    return true;
  }

  ////////////////////
  // Re-deposit function
  ////////////////////

  /**
   * @dev re-deposit pending requests in the pending queue
   */

  function redeposit(address layer2) external returns (bool) {
    uint256 i = _withdrawalRequestIndex[layer2][msg.sender];
    require(_redeposit(layer2, i, 1));
    return true;
  }

  function redepositMulti(address layer2, uint256 n) external returns (bool) {
    uint256 i = _withdrawalRequestIndex[layer2][msg.sender];
    require(_redeposit(layer2, i, n));
    return true;
  }

  function _redeposit(address layer2, uint256 i, uint256 n) internal onlyLayer2(layer2) returns (bool) {
    uint256 accAmount;

    require(_withdrawalRequests[layer2][msg.sender].length > 0, "DepositManager: no request");
    require(_withdrawalRequests[layer2][msg.sender].length - i >= n, "DepositManager: n exceeds num of pending requests");

    uint256 e = i + n;
    for (; i < e; i++) {
      WithdrawalReqeust storage r = _withdrawalRequests[layer2][msg.sender][i];
      uint256 amount = r.amount;

      require(!r.processed, "DepositManager: pending request already processed");
      require(amount > 0, "DepositManager: no valid pending request");

      accAmount = accAmount + amount;
      r.processed = true;
    }


    // deposit-related storages
    _accStaked[layer2][msg.sender] = _accStaked[layer2][msg.sender] + accAmount;
    _accStakedLayer2[layer2] = _accStakedLayer2[layer2] + accAmount;
    _accStakedAccount[msg.sender] = _accStakedAccount[msg.sender] + accAmount;

    // withdrawal-related storages
    _pendingUnstaked[layer2][msg.sender] = _pendingUnstaked[layer2][msg.sender] - accAmount;
    _pendingUnstakedLayer2[layer2] = _pendingUnstakedLayer2[layer2] - accAmount;
    _pendingUnstakedAccount[msg.sender] = _pendingUnstakedAccount[msg.sender] - accAmount;

    _withdrawalRequestIndex[layer2][msg.sender] += n;

    emit Deposited(layer2, msg.sender, accAmount);

    require(ISeigManager(_seigManager).onDeposit(layer2, msg.sender, accAmount));

    return true;
  }

  ////////////////////
  // Slash functions
  ////////////////////

  function slash(address layer2, address recipient, uint256 amount) external onlySeigManager returns (bool) {
    //return _wton.transferFrom(owner, recipient, amount);
  }

  ////////////////////
  // Setter
  ////////////////////

  function setGlobalWithdrawalDelay(uint256 globalWithdrawalDelay_) external onlyOwner {
    globalWithdrawalDelay = globalWithdrawalDelay_;
  }

  function setWithdrawalDelay(address l2chain, uint256 withdrawalDelay_) external {
    require(_isOperator(l2chain, msg.sender));
    withdrawalDelay[l2chain] = withdrawalDelay_;
  }

  ////////////////////
  // Withdrawal functions
  ////////////////////

  function requestWithdrawal(address layer2, uint256 amount) external returns (bool) {
    return _requestWithdrawal(layer2, amount, getDelayBlocks(layer2));
  }

  function _requestWithdrawal(address layer2, uint256 amount, uint256 delay) internal onlyLayer2(layer2) returns (bool) {
    require(amount > 0, "DepositManager: amount must not be zero");
    // uint256 delay = globalWithdrawalDelay > withdrawalDelay[layer2] ? globalWithdrawalDelay : withdrawalDelay[layer2];
    _withdrawalRequests[layer2][msg.sender].push(WithdrawalReqeust({
      withdrawableBlockNumber: uint128(block.number + delay),
      amount: uint128(amount),
      processed: false
    }));

    _pendingUnstaked[layer2][msg.sender] = _pendingUnstaked[layer2][msg.sender] + amount;
    _pendingUnstakedLayer2[layer2] = _pendingUnstakedLayer2[layer2] + amount;
    _pendingUnstakedAccount[msg.sender] = _pendingUnstakedAccount[msg.sender] + amount;

    emit WithdrawalRequested(layer2, msg.sender, amount);

    require(ISeigManager(_seigManager).onWithdraw(layer2, msg.sender, amount));

    return true;
  }

  function processRequest(address layer2, bool receiveTON) external returns (bool) {
    return _processRequest(layer2, receiveTON);
  }

  function _processRequest(address layer2, bool receiveTON) internal returns (bool) {
    uint256 index = _withdrawalRequestIndex[layer2][msg.sender];
    require(_withdrawalRequests[layer2][msg.sender].length > index, "DepositManager: no request to process");

    WithdrawalReqeust storage r = _withdrawalRequests[layer2][msg.sender][index];

    require(r.withdrawableBlockNumber <= block.number, "DepositManager: wait for withdrawal delay");
    r.processed = true;

    _withdrawalRequestIndex[layer2][msg.sender] += 1;

    uint256 amount = r.amount;

    _pendingUnstaked[layer2][msg.sender] = _pendingUnstaked[layer2][msg.sender] - amount;
    _pendingUnstakedLayer2[layer2] = _pendingUnstakedLayer2[layer2] - amount;
    _pendingUnstakedAccount[msg.sender] = _pendingUnstakedAccount[msg.sender] - amount;

    _accUnstaked[layer2][msg.sender] = _accUnstaked[layer2][msg.sender] + amount;
    _accUnstakedLayer2[layer2] = _accUnstakedLayer2[layer2] + amount;
    _accUnstakedAccount[msg.sender] = _accUnstakedAccount[msg.sender] + amount;

    if (receiveTON) {
      require(IWTON(_wton).swapToTONAndTransfer(msg.sender, amount));
    } else {
      IERC20(_wton).safeTransfer(msg.sender, amount);
    }

    emit WithdrawalProcessed(layer2, msg.sender, amount);
    return true;
  }

  function requestWithdrawalAll(address layer2) external onlyLayer2(layer2) returns (bool) {
    uint256 amount = ISeigManager(_seigManager).stakeOf(layer2, msg.sender);
    return _requestWithdrawal(layer2, amount, getDelayBlocks(layer2));
  }

  function processRequests(address layer2, uint256 n, bool receiveTON) external returns (bool) {
    for (uint256 i = 0; i < n; i++) {
      require(_processRequest(layer2, receiveTON));
    }
    return true;
  }

  function numRequests(address layer2, address account) external view returns (uint256) {
    return _withdrawalRequests[layer2][account].length;
  }

  function numPendingRequests(address layer2, address account) external view returns (uint256) {
    uint256 numRequests_ = _withdrawalRequests[layer2][account].length;
    uint256 index = _withdrawalRequestIndex[layer2][account];

    if (numRequests_ == 0) return 0;

    return numRequests_ - index;
  }

  function _isOperator(address layer2, address operator) internal view returns (bool) {
    return operator == ILayer2(layer2).operator();
  }

  function getDelayBlocks(address layer2) public view returns (uint256){
    return  globalWithdrawalDelay > withdrawalDelay[layer2] ? globalWithdrawalDelay : withdrawalDelay[layer2];
  }

  ////////////////////
  // Storage getters
  ////////////////////

  // solium-disable
  function wton() external view returns (address) { return _wton; }
  function registry() external view returns (address) { return _registry; }
  function seigManager() external view returns (address) { return _seigManager; }

  function accStaked(address layer2, address account) external view returns (uint256 wtonAmount) { return _accStaked[layer2][account]; }
  function accStakedLayer2(address layer2) external view returns (uint256 wtonAmount) { return _accStakedLayer2[layer2]; }
  function accStakedAccount(address account) external view returns (uint256 wtonAmount) { return _accStakedAccount[account]; }

  function pendingUnstaked(address layer2, address account) external view returns (uint256 wtonAmount) { return _pendingUnstaked[layer2][account]; }
  function pendingUnstakedLayer2(address layer2) external view returns (uint256 wtonAmount) { return _pendingUnstakedLayer2[layer2]; }
  function pendingUnstakedAccount(address account) external view returns (uint256 wtonAmount) { return _pendingUnstakedAccount[account]; }

  function accUnstaked(address layer2, address account) external view returns (uint256 wtonAmount) { return _accUnstaked[layer2][account]; }
  function accUnstakedLayer2(address layer2) external view returns (uint256 wtonAmount) { return _accUnstakedLayer2[layer2]; }
  function accUnstakedAccount(address account) external view returns (uint256 wtonAmount) { return _accUnstakedAccount[account]; }

  function withdrawalRequestIndex(address layer2, address account) external view returns (uint256 index) { return _withdrawalRequestIndex[layer2][account]; }
  function withdrawalRequest(address layer2, address account, uint256 index) external view returns (uint128 withdrawableBlockNumber, uint128 amount, bool processed ) {
    withdrawableBlockNumber = _withdrawalRequests[layer2][account][index].withdrawableBlockNumber;
    amount = _withdrawalRequests[layer2][account][index].amount;
    processed = _withdrawalRequests[layer2][account][index].processed;
  }

  // solium-enable
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;

/**
 * @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.
 */
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].
     */
    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 v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

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

    /**
     * @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.encodeWithSelector(token.transfer.selector, 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.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));
    }

    /**
     * @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);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @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.encodeWithSelector(token.approve.selector, spender, value);

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

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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.isContract(address(token));
    }
}

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

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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://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.0/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)

pragma solidity ^0.8.0;

import "./ERC165.sol";

/**
 * @dev Storage based implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165Storage is ERC165 {
    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

contract AccessRoleCommon {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER");
}

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

import { ERC165Storage } from "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./AccessRoleCommon.sol";

contract AccessibleCommon is AccessRoleCommon, ERC165Storage, AccessControl {
    modifier onlyOwner() {
        require(isAdmin(msg.sender), "Accessible: Caller is not an admin");
        _;
    }

    /// @dev add admin
    /// @param account  address to add
    function addAdmin(address account) public virtual onlyOwner {
        grantRole(DEFAULT_ADMIN_ROLE, account);
    }

    /// @dev remove admin
    /// @param account  address to remove
    function removeAdmin(address account) public virtual onlyOwner {
        renounceRole(DEFAULT_ADMIN_ROLE, account);
    }

    /// @dev transfer admin
    /// @param newAdmin new admin address
    function transferAdmin(address newAdmin) public virtual onlyOwner {
        require(newAdmin != address(0), "Accessible: zero address");
        require(msg.sender != newAdmin, "Accessible: same admin");

        grantRole(DEFAULT_ADMIN_ROLE, newAdmin);
        renounceRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function transferOwnership(address newAdmin) public virtual onlyOwner {
        transferAdmin(newAdmin);
    }

    function renounceOwnership() public onlyOwner {
        renounceRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    /// @dev whether admin
    /// @param account  address to check
    function isAdmin(address account) public view virtual returns (bool) {
        return hasRole(DEFAULT_ADMIN_ROLE, account);
    }

    function isOwner() public view virtual returns (bool) {
        return hasRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Storage, AccessControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

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

interface IWTON {

    function onApprove(
        address owner,
        address spender,
        uint256 tonAmount,
        bytes calldata data
    ) external returns (bool);

    function swapToTON(uint256 wtonAmount) external returns (bool);
    function swapToTONAndTransfer(address to, uint256 wtonAmount) external returns (bool);
    function swapFromTONAndTransfer(address to, uint256 tonAmount) external returns (bool);
    function renounceTonMinter() external;
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function renounceMinter() external ;
    function mint(address account, uint256 amount) external returns (bool);

}

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.4;

contract ProxyStorage  {

    bool public pauseProxy;

    mapping(uint256 => address) public proxyImplementation;
    mapping(address => bool) public aliveImplementation;
    mapping(bytes4 => address) public selectorImplementation;

}

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

/// @title
/// @notice
contract DepositManagerStorage   {
    ////////////////////
    // Storage - contracts
    ////////////////////

    address internal _wton;
    address internal _registry;
    address internal _seigManager;
    address public oldDepositManager;

    ////////////////////
    // Storage - token amount
    ////////////////////

    // accumulated staked amount
    // layer2 => msg.sender => wton amount
    mapping (address => mapping (address => uint256)) internal _accStaked;
    // layer2 => wton amount
    mapping (address => uint256) internal _accStakedLayer2;
    // msg.sender => wton amount
    mapping (address => uint256) internal _accStakedAccount;

    // pending unstaked amount
    // layer2 => msg.sender => wton amount
    mapping (address => mapping (address => uint256)) internal _pendingUnstaked;
    // layer2 => wton amount
    mapping (address => uint256) internal _pendingUnstakedLayer2;
    // msg.sender => wton amount
    mapping (address => uint256) internal _pendingUnstakedAccount;

    // accumulated unstaked amount
    // layer2 => msg.sender => wton amount
    mapping (address => mapping (address => uint256)) internal _accUnstaked;
    // layer2 => wton amount
    mapping (address => uint256) internal _accUnstakedLayer2;
    // msg.sender => wton amount
    mapping (address => uint256) internal _accUnstakedAccount;

    // layer2 => msg.sender => withdrawal requests
    mapping (address => mapping (address => WithdrawalReqeust[])) internal _withdrawalRequests;

    // layer2 => msg.sender => index
    mapping (address => mapping (address => uint256)) internal _withdrawalRequestIndex;

    ////////////////////
    // Storage - configuration / ERC165 interfaces
    ////////////////////

    // withdrawal delay in block number
    // @TODO: change delay unit to CYCLE?
    uint256 public globalWithdrawalDelay;
    mapping (address => uint256) public withdrawalDelay;

    struct WithdrawalReqeust {
        uint128 withdrawableBlockNumber;
        uint128 amount;
        bool processed;
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"layer2","type":"address"},{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"layer2","type":"address"},{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawalProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"layer2","type":"address"},{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawalRequested","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"accStaked","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"accStakedAccount","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"accStakedLayer2","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"accUnstaked","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"accUnstakedAccount","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"accUnstakedLayer2","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"aliveImplementation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"getDelayBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"globalWithdrawalDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wton_","type":"address"},{"internalType":"address","name":"registry_","type":"address"},{"internalType":"address","name":"seigManager_","type":"address"},{"internalType":"uint256","name":"globalWithdrawalDelay_","type":"uint256"},{"internalType":"address","name":"oldDepositManager_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"numPendingRequests","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"numRequests","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oldDepositManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onApprove","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseProxy","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"pendingUnstaked","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"pendingUnstakedAccount","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"pendingUnstakedLayer2","outputs":[{"internalType":"uint256","name":"wtonAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"bool","name":"receiveTON","type":"bool"}],"name":"processRequest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"uint256","name":"n","type":"uint256"},{"internalType":"bool","name":"receiveTON","type":"bool"}],"name":"processRequests","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"proxyImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"redeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"uint256","name":"n","type":"uint256"}],"name":"redepositMulti","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"requestWithdrawal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"}],"name":"requestWithdrawalAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seigManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"name":"selectorImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"globalWithdrawalDelay_","type":"uint256"}],"name":"setGlobalWithdrawalDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"seigManager_","type":"address"}],"name":"setSeigManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"l2chain","type":"address"},{"internalType":"uint256","name":"withdrawalDelay_","type":"uint256"}],"name":"setWithdrawalDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"slash","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"withdrawalDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"withdrawalRequest","outputs":[{"internalType":"uint128","name":"withdrawableBlockNumber","type":"uint128"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"bool","name":"processed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"layer2","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"withdrawalRequestIndex","outputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wton","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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