Contract Source Code (Solidity)Audit Report

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function _msgSender()    - function _msgData()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ...    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(address from, addr ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _spendAllowance(address owne ...    - function _beforeTokenTransfer(address ...    - function _afterTokenTransfer(address ...    - function cap()    - function _mint(address account, uint2 ...    - function paused()    - function _requireNotPaused()    - function _requirePaused()    - function _pause()    - function _unpause() interface IAccessControl    - function hasRole(bytes32 role, addres ...    - function getRoleAdmin(bytes32 role)    - function grantRole(bytes32 role, addr ...    - function revokeRole(bytes32 role, add ...    - function renounceRole(bytes32 role, a ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(uint256 x, uint256 y, ...    - function mulDiv(uint256 x, uint256 y, ...    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Strings    - function toString(uint256 value)    - function toString(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ... interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ...    - function hasRole(bytes32 role, addres ...    - function _checkRole(bytes32 role)    - function _checkRole(bytes32 role, add ...    - function getRoleAdmin(bytes32 role)    - function grantRole(bytes32 role, addr ...    - function revokeRole(bytes32 role, add ...    - function renounceRole(bytes32 role, a ...    - function _setupRole(bytes32 role, add ...    - function _setRoleAdmin(bytes32 role, ...    - function _grantRole(bytes32 role, add ...    - function _revokeRole(bytes32 role, ad ...  contract RootToken is ERC20Capped, ... *    - function init(address _peg)    - function decimals()    - function burn(uint128 _amount)    - function mint(address to, uint128 _am ...    - function _beforeTokenTransfer(    - function pause()    - function unpause()    - function addManager(address addr)    - function removeManager(address addr)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-11-14
*/

// SPDX-License-Identifier: Apache-2.0

pragma solidity 0.8.17;

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private immutable _cap;

    /**
     * @dev Sets the value of the `cap`. This value is immutable, it can only be
     * set once during construction.
     */
    constructor(uint256 cap_) {
        require(cap_ > 0, "ERC20Capped: cap is 0");
        _cap = cap_;
    }

    /**
     * @dev Returns the cap on the token's total supply.
     */
    function cap() public view virtual returns (uint256) {
        return _cap;
    }

    /**
     * @dev See {ERC20-_mint}.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        super._mint(account, amount);
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @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.
     */
    constructor() {
        _paused = false;
    }

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        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());
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)

// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

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

// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

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

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

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

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

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

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

uint128 constant TOTAL_SUPPLY = 12e15; // 12 billion tokens (6 decimals)
string constant NAME = "The Root Network";
string constant SYMBOL = "ROOT";
bytes32 constant MANAGER = keccak256("MANAGER");
bytes32 constant MULTISIG = keccak256("MULTISIG");

/**
 * @dev Futureverse ERC20 Root token
 */
contract RootToken is ERC20Capped, Pausable, AccessControl {
    bool private _initialized;

    constructor(
        address manager,
        address multisig
    ) ERC20Capped(TOTAL_SUPPLY) ERC20(NAME, SYMBOL) {
        _grantRole(MANAGER, manager);
        _grantRole(MULTISIG, multisig);
    }

    function init(address _peg) external onlyRole(MANAGER) {
        require(!_initialized, "Already initialized");
        _mint(_peg, TOTAL_SUPPLY);

        _initialized = true;
    }

    function decimals() public view virtual override returns (uint8) {
        return 6;
    }

    function burn(uint128 _amount) external onlyRole(MULTISIG) {
        _burn(_msgSender(), _amount);
    }

    function mint(address to, uint128 _amount) external onlyRole(MULTISIG) {
        _mint(to, _amount);
    }

    function _beforeTokenTransfer(
        address,
        address,
        uint256
    ) internal view override {
        require(!paused(), "Token transfers are paused");
    }

    function pause() external onlyRole(MANAGER) {
        _pause();
    }

    function unpause() external onlyRole(MULTISIG) {
        _unpause();
    }

    function addManager(address addr) external onlyRole(MANAGER) {
        _grantRole(MANAGER, addr);
    }

    function removeManager(address addr) external onlyRole(MANAGER) {
        _revokeRole(MANAGER, addr);
    }
}

• Hashlock - November, 2023 - Security Audit Report

[{"inputs":[{"internalType":"address","name":"manager","type":"address"},{"internalType":"address","name":"multisig","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"addManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"_amount","type":"uint128"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_peg","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint128","name":"_amount","type":"uint128"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"removeManager","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":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000379390ea58741bbe7a7973befa1e920e340a5b43000000000000000000000000b7b31f91e02c4ed804287fbea1b2b8e771266989

-----Decoded View---------------
Arg [0] : manager (address): 0x379390eA58741BBe7a7973BEFA1e920E340A5B43
Arg [1] : multisig (address): 0xb7b31f91e02c4eD804287fbea1b2B8E771266989

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000379390ea58741bbe7a7973befa1e920e340a5b43
Arg [1] : 000000000000000000000000b7b31f91e02c4ed804287fbea1b2b8e771266989

51144:1416:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45171:204;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;45171:204:0;;;;;;;;6394:100;;;:::i;:::-;;;;;;;:::i;8754:201::-;;;;;;:::i;:::-;;:::i;7523:108::-;7611:12;;7523:108;;;1736:25:1;;;1724:2;1709:18;7523:108:0;1590:177:1;51458:187:0;;;;;;:::i;:::-;;:::i;:::-;;9535:261;;;;;;:::i;:::-;;:::i;46994:131::-;;;;;;:::i;:::-;47068:7;47095:12;;;:6;:12;;;;;:22;;;;46994:131;52335:105;;;;;;:::i;:::-;;:::i;47435:147::-;;;;;;:::i;:::-;;:::i;51653:92::-;;;51736:1;3064:36:1;;3052:2;3037:18;51653:92:0;2922:184:1;17884:83:0;17955:4;17884:83;;48579:218;;;;;;:::i;:::-;;:::i;10205:238::-;;;;;;:::i;:::-;;:::i;52251:76::-;;;:::i;19823:86::-;19894:7;;;;19823:86;;7694:127;;;;;;:::i;:::-;-1:-1:-1;;;;;7795:18:0;7768:7;7795:18;;;;;;;;;;;;7694:127;52172:71;;;:::i;51753:106::-;;;;;;:::i;:::-;;:::i;45467:147::-;;;;;;:::i;:::-;;:::i;6613:104::-;;;:::i;44572:49::-;;44617:4;44572:49;;10946:436;;;;;;:::i;:::-;;:::i;8027:193::-;;;;;;:::i;:::-;;:::i;52448:109::-;;;;;;:::i;:::-;;:::i;51867:108::-;;;;;;:::i;:::-;;:::i;47875:149::-;;;;;;:::i;:::-;;:::i;8283:151::-;;;;;;:::i;:::-;;:::i;45171:204::-;45256:4;-1:-1:-1;;;;;;45280:47:0;;-1:-1:-1;;;45280:47:0;;:87;;-1:-1:-1;;;;;;;;;;42588:40:0;;;45331:36;45273:94;45171:204;-1:-1:-1;;45171:204:0:o;6394:100::-;6448:13;6481:5;6474:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6394:100;:::o;8754:201::-;8837:4;4280:10;8893:32;4280:10;8909:7;8918:6;8893:8;:32::i;:::-;-1:-1:-1;8943:4:0;;8754:201;-1:-1:-1;;;8754:201:0:o;51458:187::-;-1:-1:-1;;;;;;;;;;;45063:16:0;45074:4;45063:10;:16::i;:::-;51533:12:::1;::::0;::::1;;51532:13;51524:45;;;::::0;-1:-1:-1;;;51524:45:0;;4612:2:1;51524:45:0::1;::::0;::::1;4594:21:1::0;4651:2;4631:18;;;4624:30;-1:-1:-1;;;4670:18:1;;;4663:49;4729:18;;51524:45:0::1;;;;;;;;;51580:25;51586:4:::0;50872:5:::1;51580;:25::i;:::-;-1:-1:-1::0;;51618:12:0::1;:19:::0;;-1:-1:-1;;51618:19:0::1;51633:4;51618:19;::::0;;51458:187::o;9535:261::-;9632:4;4280:10;9690:38;9706:4;4280:10;9721:6;9690:15;:38::i;:::-;9739:27;9749:4;9755:2;9759:6;9739:9;:27::i;:::-;-1:-1:-1;9784:4:0;;9535:261;-1:-1:-1;;;;9535:261:0:o;52335:105::-;-1:-1:-1;;;;;;;;;;;45063:16:0;45074:4;45063:10;:16::i;:::-;52407:25:::1;-1:-1:-1::0;;;;;;;;;;;52427:4:0::1;52407:10;:25::i;:::-;52335:105:::0;;:::o;47435:147::-;47068:7;47095:12;;;:6;:12;;;;;:22;;;45063:16;45074:4;45063:10;:16::i;:::-;47549:25:::1;47560:4;47566:7;47549:10;:25::i;:::-;47435:147:::0;;;:::o;48579:218::-;-1:-1:-1;;;;;48675:23:0;;4280:10;48675:23;48667:83;;;;-1:-1:-1;;;48667:83:0;;4960:2:1;48667:83:0;;;4942:21:1;4999:2;4979:18;;;4972:30;5038:34;5018:18;;;5011:62;-1:-1:-1;;;5089:18:1;;;5082:45;5144:19;;48667:83:0;4758:411:1;48667:83:0;48763:26;48775:4;48781:7;48763:11;:26::i;10205:238::-;10293:4;4280:10;10349:64;4280:10;10365:7;10402:10;10374:25;4280:10;10365:7;10374:9;:25::i;:::-;:38;;;;:::i;:::-;10349:8;:64::i;52251:76::-;51070:21;45063:16;45074:4;45063:10;:16::i;:::-;52309:10:::1;:8;:10::i;:::-;52251:76:::0;:::o;52172:71::-;-1:-1:-1;;;;;;;;;;;45063:16:0;45074:4;45063:10;:16::i;:::-;52227:8:::1;:6;:8::i;51753:106::-:0;51070:21;45063:16;45074:4;45063:10;:16::i;:::-;51823:28:::1;4280:10:::0;51843:7:::1;-1:-1:-1::0;;;;;51823:28:0::1;:5;:28::i;45467:147::-:0;45553:4;45577:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;45577:29:0;;;;;;;;;;;;;;;45467:147::o;6613:104::-;6669:13;6702:7;6695:14;;;;;:::i;10946:436::-;11039:4;4280:10;11039:4;11122:25;4280:10;11139:7;11122:9;:25::i;:::-;11095:52;;11186:15;11166:16;:35;;11158:85;;;;-1:-1:-1;;;11158:85:0;;5638:2:1;11158:85:0;;;5620:21:1;5677:2;5657:18;;;5650:30;5716:34;5696:18;;;5689:62;-1:-1:-1;;;5767:18:1;;;5760:35;5812:19;;11158:85:0;5436:401:1;11158:85:0;11279:60;11288:5;11295:7;11323:15;11304:16;:34;11279:8;:60::i;8027:193::-;8106:4;4280:10;8162:28;4280:10;8179:2;8183:6;8162:9;:28::i;52448:109::-;-1:-1:-1;;;;;;;;;;;45063:16:0;45074:4;45063:10;:16::i;:::-;52523:26:::1;-1:-1:-1::0;;;;;;;;;;;52544:4:0::1;52523:11;:26::i;51867:108::-:0;51070:21;45063:16;45074:4;45063:10;:16::i;:::-;51949:18:::1;51955:2;51959:7;-1:-1:-1::0;;;;;51949:18:0::1;:5;:18::i;47875:149::-:0;47068:7;47095:12;;;:6;:12;;;;;:22;;;45063:16;45074:4;45063:10;:16::i;:::-;47990:26:::1;48002:4;48008:7;47990:11;:26::i;8283:151::-:0;-1:-1:-1;;;;;8399:18:0;;;8372:7;8399:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8283:151::o;14939:346::-;-1:-1:-1;;;;;15041:19:0;;15033:68;;;;-1:-1:-1;;;15033:68:0;;6044:2:1;15033:68:0;;;6026:21:1;6083:2;6063:18;;;6056:30;6122:34;6102:18;;;6095:62;-1:-1:-1;;;6173:18:1;;;6166:34;6217:19;;15033:68:0;5842:400:1;15033:68:0;-1:-1:-1;;;;;15120:21:0;;15112:68;;;;-1:-1:-1;;;15112:68:0;;6449:2:1;15112:68:0;;;6431:21:1;6488:2;6468:18;;;6461:30;6527:34;6507:18;;;6500:62;-1:-1:-1;;;6578:18:1;;;6571:32;6620:19;;15112:68:0;6247:398:1;15112:68:0;-1:-1:-1;;;;;15193:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15245:32;;1736:25:1;;;15245:32:0;;1709:18:1;15245:32:0;;;;;;;14939:346;;;:::o;45918:105::-;45985:30;45996:4;4280:10;45985;:30::i;18025:207::-;17955:4;18140:6;18118:19;7611:12;;;7523:108;18118:19;:28;;;;:::i;:::-;:37;;18110:75;;;;-1:-1:-1;;;18110:75:0;;6852:2:1;18110:75:0;;;6834:21:1;6891:2;6871:18;;;6864:30;6930:27;6910:18;;;6903:55;6975:18;;18110:75:0;6650:349:1;18110:75:0;18196:28;18208:7;18217:6;18196:11;:28::i;15576:419::-;15677:24;15704:25;15714:5;15721:7;15704:9;:25::i;:::-;15677:52;;-1:-1:-1;;15744:16:0;:37;15740:248;;15826:6;15806:16;:26;;15798:68;;;;-1:-1:-1;;;15798:68:0;;7206:2:1;15798:68:0;;;7188:21:1;7245:2;7225:18;;;7218:30;7284:31;7264:18;;;7257:59;7333:18;;15798:68:0;7004:353:1;15798:68:0;15910:51;15919:5;15926:7;15954:6;15935:16;:25;15910:8;:51::i;:::-;15666:329;15576:419;;;:::o;11852:806::-;-1:-1:-1;;;;;11949:18:0;;11941:68;;;;-1:-1:-1;;;11941:68:0;;7564:2:1;11941:68:0;;;7546:21:1;7603:2;7583:18;;;7576:30;7642:34;7622:18;;;7615:62;-1:-1:-1;;;7693:18:1;;;7686:35;7738:19;;11941:68:0;7362:401:1;11941:68:0;-1:-1:-1;;;;;12028:16:0;;12020:64;;;;-1:-1:-1;;;12020:64:0;;7970:2:1;12020:64:0;;;7952:21:1;8009:2;7989:18;;;7982:30;8048:34;8028:18;;;8021:62;-1:-1:-1;;;8099:18:1;;;8092:33;8142:19;;12020:64:0;7768:399:1;12020:64:0;12097:38;12118:4;12124:2;12128:6;12097:20;:38::i;:::-;-1:-1:-1;;;;;12170:15:0;;12148:19;12170:15;;;;;;;;;;;12204:21;;;;12196:72;;;;-1:-1:-1;;;12196:72:0;;8374:2:1;12196:72:0;;;8356:21:1;8413:2;8393:18;;;8386:30;8452:34;8432:18;;;8425:62;-1:-1:-1;;;8503:18:1;;;8496:36;8549:19;;12196:72:0;8172:402:1;12196:72:0;-1:-1:-1;;;;;12304:15:0;;;:9;:15;;;;;;;;;;;12322:20;;;12304:38;;12522:13;;;;;;;;;;:23;;;;;;12574:26;;1736:25:1;;;12522:13:0;;12574:26;;1709:18:1;12574:26:0;;;;;;;12613:37;47435:147;50176:238;50260:22;50268:4;50274:7;50260;:22::i;:::-;50255:152;;50299:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;50299:29:0;;;;;;;;;:36;;-1:-1:-1;;50299:36:0;50331:4;50299:36;;;50382:12;4280:10;;4200:98;50382:12;-1:-1:-1;;;;;50355:40:0;50373:7;-1:-1:-1;;;;;50355:40:0;50367:4;50355:40;;;;;;;;;;50176:238;;:::o;50594:239::-;50678:22;50686:4;50692:7;50678;:22::i;:::-;50674:152;;;50749:5;50717:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;50717:29:0;;;;;;;;;;:37;;-1:-1:-1;;50717:37:0;;;50774:40;4280:10;;50717:12;;50774:40;;50749:5;50774:40;50594:239;;:::o;20678:120::-;19687:16;:14;:16::i;:::-;20737:7:::1;:15:::0;;-1:-1:-1;;20737:15:0::1;::::0;;20768:22:::1;4280:10:::0;20777:12:::1;20768:22;::::0;-1:-1:-1;;;;;8743:32:1;;;8725:51;;8713:2;8698:18;20768:22:0::1;;;;;;;20678:120::o:0;20419:118::-;19428:19;:17;:19::i;:::-;20479:7:::1;:14:::0;;-1:-1:-1;;20479:14:0::1;20489:4;20479:14;::::0;;20509:20:::1;20516:12;4280:10:::0;;4200:98;13826:675;-1:-1:-1;;;;;13910:21:0;;13902:67;;;;-1:-1:-1;;;13902:67:0;;8989:2:1;13902:67:0;;;8971:21:1;9028:2;9008:18;;;9001:30;9067:34;9047:18;;;9040:62;-1:-1:-1;;;9118:18:1;;;9111:31;9159:19;;13902:67:0;8787:397:1;13902:67:0;13982:49;14003:7;14020:1;14024:6;13982:20;:49::i;:::-;-1:-1:-1;;;;;14069:18:0;;14044:22;14069:18;;;;;;;;;;;14106:24;;;;14098:71;;;;-1:-1:-1;;;14098:71:0;;9391:2:1;14098:71:0;;;9373:21:1;9430:2;9410:18;;;9403:30;9469:34;9449:18;;;9442:62;-1:-1:-1;;;9520:18:1;;;9513:32;9562:19;;14098:71:0;9189:398:1;14098:71:0;-1:-1:-1;;;;;14205:18:0;;:9;:18;;;;;;;;;;;14226:23;;;14205:44;;14344:12;:22;;;;;;;14395:37;1736:25:1;;;14205:9:0;;:18;14395:37;;1709:18:1;14395:37:0;;;;;;;47435:147;;;:::o;46313:492::-;46402:22;46410:4;46416:7;46402;:22::i;:::-;46397:401;;46590:28;46610:7;46590:19;:28::i;:::-;46691:38;46719:4;46726:2;46691:19;:38::i;:::-;46495:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;46495:257:0;;;;;;;;;;-1:-1:-1;;;46441:345:0;;;;;;;:::i;12945:548::-;-1:-1:-1;;;;;13029:21:0;;13021:65;;;;-1:-1:-1;;;13021:65:0;;10611:2:1;13021:65:0;;;10593:21:1;10650:2;10630:18;;;10623:30;10689:33;10669:18;;;10662:61;10740:18;;13021:65:0;10409:355:1;13021:65:0;13099:49;13128:1;13132:7;13141:6;13099:20;:49::i;:::-;13177:6;13161:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;13332:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;13387:37;1736:25:1;;;13387:37:0;;1709:18:1;13387:37:0;;;;;;;52335:105;;:::o;51983:181::-;19894:7;;;;52116:9;52108:48;;;;-1:-1:-1;;;52108:48:0;;10971:2:1;52108:48:0;;;10953:21:1;11010:2;10990:18;;;10983:30;11049:28;11029:18;;;11022:56;11095:18;;52108:48:0;10769:350:1;20167:108:0;19894:7;;;;20226:41;;;;-1:-1:-1;;;20226:41:0;;11326:2:1;20226:41:0;;;11308:21:1;11365:2;11345:18;;;11338:30;-1:-1:-1;;;11384:18:1;;;11377:50;11444:18;;20226:41:0;11124:344:1;20226:41:0;20167:108::o;19982:::-;19894:7;;;;20052:9;20044:38;;;;-1:-1:-1;;;20044:38:0;;11675:2:1;20044:38:0;;;11657:21:1;11714:2;11694:18;;;11687:30;-1:-1:-1;;;11733:18:1;;;11726:46;11789:18;;20044:38:0;11473:340:1;40506:151:0;40564:13;40597:52;-1:-1:-1;;;;;40609:22:0;;38381:2;39902:447;39977:13;40003:19;40035:10;40039:6;40035:1;:10;:::i;:::-;:14;;40048:1;40035:14;:::i;:::-;40025:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40025:25:0;;40003:47;;-1:-1:-1;;;40061:6:0;40068:1;40061:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;40061:15:0;;;;;;;;;-1:-1:-1;;;40087:6:0;40094:1;40087:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;40087:15:0;;;;;;;;-1:-1:-1;40118:9:0;40130:10;40134:6;40130:1;:10;:::i;:::-;:14;;40143:1;40130:14;:::i;:::-;40118:26;;40113:131;40150:1;40146;:5;40113:131;;;-1:-1:-1;;;40194:5:0;40202:3;40194:11;40185:21;;;;;;;:::i;:::-;;;;40173:6;40180:1;40173:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;40173:33:0;;;;;;;;-1:-1:-1;40231:1:0;40221:11;;;;;40153:3;;;:::i;:::-;;;40113:131;;;-1:-1:-1;40262:10:0;;40254:55;;;;-1:-1:-1;;;40254:55:0;;12598:2:1;40254:55:0;;;12580:21:1;;;12617:18;;;12610:30;12676:34;12656:18;;;12649:62;12728:18;;40254:55:0;12396:356:1;40254:55:0;40334:6;39902:447;-1:-1:-1;;;39902:447:0:o;14:286:1:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;497:250;582:1;592:113;606:6;603:1;600:13;592:113;;;682:11;;;676:18;663:11;;;656:39;628:2;621:10;592:113;;;-1:-1:-1;;739:1:1;721:16;;714:27;497:250::o;752:396::-;901:2;890:9;883:21;864:4;933:6;927:13;976:6;971:2;960:9;956:18;949:34;992:79;1064:6;1059:2;1048:9;1044:18;1039:2;1031:6;1027:15;992:79;:::i;:::-;1132:2;1111:15;-1:-1:-1;;1107:29:1;1092:45;;;;1139:2;1088:54;;752:396;-1:-1:-1;;752:396:1:o;1153:173::-;1221:20;;-1:-1:-1;;;;;1270:31:1;;1260:42;;1250:70;;1316:1;1313;1306:12;1250:70;1153:173;;;:::o;1331:254::-;1399:6;1407;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;1499:29;1518:9;1499:29;:::i;:::-;1489:39;1575:2;1560:18;;;;1547:32;;-1:-1:-1;;;1331:254:1:o;1772:186::-;1831:6;1884:2;1872:9;1863:7;1859:23;1855:32;1852:52;;;1900:1;1897;1890:12;1852:52;1923:29;1942:9;1923:29;:::i;1963:328::-;2040:6;2048;2056;2109:2;2097:9;2088:7;2084:23;2080:32;2077:52;;;2125:1;2122;2115:12;2077:52;2148:29;2167:9;2148:29;:::i;:::-;2138:39;;2196:38;2230:2;2219:9;2215:18;2196:38;:::i;:::-;2186:48;;2281:2;2270:9;2266:18;2253:32;2243:42;;1963:328;;;;;:::o;2296:180::-;2355:6;2408:2;2396:9;2387:7;2383:23;2379:32;2376:52;;;2424:1;2421;2414:12;2376:52;-1:-1:-1;2447:23:1;;2296:180;-1:-1:-1;2296:180:1:o;2663:254::-;2731:6;2739;2792:2;2780:9;2771:7;2767:23;2763:32;2760:52;;;2808:1;2805;2798:12;2760:52;2844:9;2831:23;2821:33;;2873:38;2907:2;2896:9;2892:18;2873:38;:::i;:::-;2863:48;;2663:254;;;;;:::o;3111:188::-;3179:20;;-1:-1:-1;;;;;3228:46:1;;3218:57;;3208:85;;3289:1;3286;3279:12;3304:186;3363:6;3416:2;3404:9;3395:7;3391:23;3387:32;3384:52;;;3432:1;3429;3422:12;3384:52;3455:29;3474:9;3455:29;:::i;3495:260::-;3563:6;3571;3624:2;3612:9;3603:7;3599:23;3595:32;3592:52;;;3640:1;3637;3630:12;3592:52;3663:29;3682:9;3663:29;:::i;:::-;3653:39;;3711:38;3745:2;3734:9;3730:18;3711:38;:::i;3760:260::-;3828:6;3836;3889:2;3877:9;3868:7;3864:23;3860:32;3857:52;;;3905:1;3902;3895:12;3857:52;3928:29;3947:9;3928:29;:::i;:::-;3918:39;;3976:38;4010:2;3999:9;3995:18;3976:38;:::i;4025:380::-;4104:1;4100:12;;;;4147;;;4168:61;;4222:4;4214:6;4210:17;4200:27;;4168:61;4275:2;4267:6;4264:14;4244:18;4241:38;4238:161;;4321:10;4316:3;4312:20;4309:1;4302:31;4356:4;4353:1;4346:15;4384:4;4381:1;4374:15;4238:161;;4025:380;;;:::o;5174:127::-;5235:10;5230:3;5226:20;5223:1;5216:31;5266:4;5263:1;5256:15;5290:4;5287:1;5280:15;5306:125;5371:9;;;5392:10;;;5389:36;;;5405:18;;:::i;9592:812::-;10003:25;9998:3;9991:38;9973:3;10058:6;10052:13;10074:75;10142:6;10137:2;10132:3;10128:12;10121:4;10113:6;10109:17;10074:75;:::i;:::-;-1:-1:-1;;;10208:2:1;10168:16;;;10200:11;;;10193:40;10258:13;;10280:76;10258:13;10342:2;10334:11;;10327:4;10315:17;;10280:76;:::i;:::-;10376:17;10395:2;10372:26;;9592:812;-1:-1:-1;;;;9592:812:1:o;11818:168::-;11891:9;;;11922;;11939:15;;;11933:22;;11919:37;11909:71;;11960:18;;:::i;11991:127::-;12052:10;12047:3;12043:20;12040:1;12033:31;12083:4;12080:1;12073:15;12107:4;12104:1;12097:15;12123:127;12184:10;12179:3;12175:20;12172:1;12165:31;12215:4;12212:1;12205:15;12239:4;12236:1;12229:15;12255:136;12294:3;12322:5;12312:39;;12331:18;;:::i;:::-;-1:-1:-1;;;12367:18:1;;12255:136::o

ipfs://127bf49bf414218af3e1bc7f3cbd09b5d5b5a0a96c18761a7d3509cca19aec15