Contract 0x1f1df13c89feb23f8076a80c7767169697614d2e

pragma solidity ^0.8.0;

// SPDX-License-Identifier: MIT

import "ERC20.sol";
import "SafeMath.sol";
import "HasRoot.sol";

contract NuchainAraToken is ERC20, HasRoot {
    using SafeMath for uint256;

    address private _minter;

    event TransferFromNative(
        address indexed to,
        bytes32 indexed refID,
        uint256 value
    );
    event TransferToNative(
        address indexed from,
        bytes32 indexed to,
        uint256 value
    );

    event MinterSet(address indexed account);

    // Max cap of the token.
    function cap() public view returns (uint256) {
        return 1000_000_000 * 10 ** decimals(); // MAX 1000 million ARA
    }

    constructor(address minter) ERC20("Nuchain ARA Token", "ARA") {
        _setRoot(msg.sender);
        _setMinter(minter);

        // inital coin supply 3 million
        _mint(msg.sender, 3000_000 * 10**decimals());
    }

    modifier onlyMinter() {
        require(isMinter(msg.sender), "ARAToken: caller isn't minter");
        _;
    }

    function minter() external view returns (address) {
        return _minter;
    }

    function isMinter(address account) public view returns (bool) {
        return _minter == account;
    }

    function _mint(address account, uint256 value) internal override {
        require(totalSupply().add(value) <= cap(), "ARAToken: cap exceeded");
        super._mint(account, value);
    }

    function _setMinter(address account) internal {
        _minter = account;
        emit MinterSet(account);
    }

    function changeMinter(address newMinter) external onlyRoot {
        _setMinter(newMinter);
    }

    function changeRoot(address newRoot) external onlyRoot {
        _setRoot(newRoot);
    }

    /**
     * Mint new tokens (transfer from native token to ERC-20 token).
     */
    function transferFromNative(
        address to,
        uint256 value,
        bytes32 refID
    ) public onlyMinter returns (bool) {
        _mint(to, value);
        emit TransferFromNative(to, refID, value);
        return true;
    }

    /**
     * Burn tokens (transfer from ERC-20 token to native token).
     */
    function transferToNative(bytes32 to, uint256 value) public returns (bool) {
        _burn(msg.sender, value);
        emit TransferToNative(msg.sender, to, value);
        return true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "IERC20.sol";
import "IERC20Metadata.sol";
import "Context.sol";

/**
 * @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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * 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 value {ERC20} uses, unless this function is
     * 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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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;
        _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;
        }
        _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 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 {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "IERC20.sol";

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

// SPDX-License-Identifier: MIT

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

// SPDX-License-Identifier: MIT

contract HasRoot {
    address private _root;

    event RootChanged(address indexed newRoot);

    modifier onlyRoot {
        _onlyRoot();
        _;
    }

    function _onlyRoot() private view {
        require(_isRoot(msg.sender), "Only root may perform this action");
    }

    function root() public view returns(address) {
        return _root;
    }

    function _setRoot(address account) internal {
        _root = account;
        emit RootChanged(_root);
    }

    function _isRoot(address account) internal view returns(bool) {
        return account == _root;
    }

}

{
  "evmVersion": "istanbul",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "libraries": {
    "NuchainAraToken.sol": {}
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"minter","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":true,"internalType":"address","name":"account","type":"address"}],"name":"MinterSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRoot","type":"address"}],"name":"RootChanged","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":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"bytes32","name":"refID","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferFromNative","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"bytes32","name":"to","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferToNative","type":"event"},{"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":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newMinter","type":"address"}],"name":"changeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRoot","type":"address"}],"name":"changeRoot","outputs":[],"stateMutability":"nonpayable","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":"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":"account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes32","name":"refID","type":"bytes32"}],"name":"transferFromNative","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferToNative","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000008fff7f53a2311b7f7d4632c80e6ce33db6b8012a

-----Decoded View---------------
Arg [0] : minter (address): 0x8fff7f53a2311b7f7d4632c80e6ce33db6b8012a

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000008fff7f53a2311b7f7d4632c80e6ce33db6b8012a

124:2208:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2057:98:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1022:81:5;1089:7;;-1:-1:-1;;;;;1089:7:5;1022:81;;;-1:-1:-1;;;;;780:32:7;;;762:51;;750:2;735:18;1022:81:5;616:203:7;4154:166:1;;;;;;:::i;:::-;;:::i;:::-;;;1426:14:7;;1419:22;1401:41;;1389:2;1374:18;4154:166:1;1261:187:7;2139:191:5;;;;;;:::i;:::-;;:::i;3145:106:1:-;3232:12;;3145:106;;;1852:25:7;;;1840:2;1825:18;3145:106:1;1706:177:7;4787:478:1;;;;;;:::i;:::-;;:::i;1531:97:5:-;;;;;;:::i;:::-;;:::i;:::-;;2994:91:1;;;3076:2;2554:36:7;;2542:2;2527:18;2994:91:1;2412:184:7;546:124:5;;;:::i;5660:212:1:-;;;;;;:::i;:::-;;:::i;1634:89:5:-;;;;;;:::i;:::-;;:::i;3309:125:1:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3409:18:1;3383:7;3409:18;;;;;;;;;;;;3309:125;2268:102;;;:::i;6359:405::-;;;;;;:::i;:::-;;:::i;3637:172::-;;;;;;:::i;:::-;;:::i;1109:104:5:-;;;;;;:::i;:::-;1188:7;;-1:-1:-1;;;;;1188:7:5;;;:18;;;;1109:104;1814:238;;;;;;:::i;:::-;;:::i;3867:149:1:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3982:18:1;;;3956:7;3982:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3867:149;343:74:2;405:5;;-1:-1:-1;;;;;405:5:2;343:74;;2057:98:1;2111:13;2143:5;2136:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2057:98;:::o;4154:166::-;4237:4;4253:39;666:10:0;4276:7:1;4285:6;4253:8;:39::i;:::-;-1:-1:-1;4309:4:1;4154:166;;;;;:::o;2139:191:5:-;2208:4;2224:24;2230:10;2242:5;2224;:24::i;:::-;2263:39;;1852:25:7;;;2292:2:5;;2280:10;;2263:39;;1840:2:7;1825:18;2263:39:5;;;;;;;-1:-1:-1;2319:4:5;2139:191;;;;:::o;4787:478:1:-;4923:4;4939:36;4949:6;4957:9;4968:6;4939:9;:36::i;:::-;-1:-1:-1;;;;;5013:19:1;;4986:24;5013:19;;;:11;:19;;;;;;;;666:10:0;5013:33:1;;;;;;;;5064:26;;;;5056:79;;;;-1:-1:-1;;;5056:79:1;;3780:2:7;5056:79:1;;;3762:21:7;3819:2;3799:18;;;3792:30;3858:34;3838:18;;;3831:62;-1:-1:-1;;;3909:18:7;;;3902:38;3957:19;;5056:79:1;;;;;;;;;5169:57;5178:6;666:10:0;5219:6:1;5200:16;:25;5169:8;:57::i;:::-;-1:-1:-1;5254:4:1;;4787:478;-1:-1:-1;;;;4787:478:1:o;1531:97:5:-;186:11:2;:9;:11::i;:::-;1600:21:5::1;1611:9;1600:10;:21::i;:::-;1531:97:::0;:::o;546:124::-;582:7;623:16;3076:2:1;623::5;:16;:::i;:::-;608:31;;:12;:31;:::i;:::-;601:38;;546:124;:::o;5660:212:1:-;666:10:0;5748:4:1;5796:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;5796:34:1;;;;;;;;;;5748:4;;5764:80;;5787:7;;5796:47;;5833:10;;5796:47;:::i;:::-;5764:8;:80::i;1634:89:5:-;186:11:2;:9;:11::i;:::-;1699:17:5::1;1708:7;1699:8;:17::i;2268:102:1:-:0;2324:13;2356:7;2349:14;;;;;:::i;6359:405::-;666:10:0;6452:4:1;6495:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;6495:34:1;;;;;;;;;;6547:35;;;;6539:85;;;;-1:-1:-1;;;6539:85:1;;6010:2:7;6539:85:1;;;5992:21:7;6049:2;6029:18;;;6022:30;6088:34;6068:18;;;6061:62;-1:-1:-1;;;6139:18:7;;;6132:35;6184:19;;6539:85:1;5808:401:7;6539:85:1;6658:67;666:10:0;6681:7:1;6709:15;6690:16;:34;6658:8;:67::i;:::-;-1:-1:-1;6753:4:1;;6359:405;-1:-1:-1;;;6359:405:1:o;3637:172::-;3723:4;3739:42;666:10:0;3763:9:1;3774:6;3739:9;:42::i;1814:238:5:-;1188:7;;1941:4;;-1:-1:-1;;;;;1188:7:5;953:10;1188:18;936:62;;;;-1:-1:-1;;;936:62:5;;6416:2:7;936:62:5;;;6398:21:7;6455:2;6435:18;;;6428:30;6494:31;6474:18;;;6467:59;6543:18;;936:62:5;6214:353:7;936:62:5;1957:16:::1;1963:2;1967:5;1957;:16::i;:::-;2011:5;2007:2;-1:-1:-1::0;;;;;1988:36:5::1;;2018:5;1988:36;;;;1852:25:7::0;;1840:2;1825:18;;1706:177;1988:36:5::1;;;;;;;;-1:-1:-1::0;2041:4:5::1;1814:238:::0;;;;;:::o;2672:96:6:-;2730:7;2756:5;2760:1;2756;:5;:::i;:::-;2749:12;2672:96;-1:-1:-1;;;2672:96:6:o;8227:389:1:-;-1:-1:-1;;;;;8310:21:1;;8302:65;;;;-1:-1:-1;;;8302:65:1;;6774:2:7;8302:65:1;;;6756:21:7;6813:2;6793:18;;;6786:30;6852:33;6832:18;;;6825:61;6903:18;;8302:65:1;6572:355:7;8302:65:1;8454:6;8438:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8470:18:1;;:9;:18;;;;;;;;;;:28;;8492:6;;8470:9;:28;;8492:6;;8470:28;:::i;:::-;;;;-1:-1:-1;;8513:37:1;;1852:25:7;;;-1:-1:-1;;;;;8513:37:1;;;8530:1;;8513:37;;1840:2:7;1825:18;8513:37:1;;;;;;;8561:48;8227:389;;:::o;9935:370::-;-1:-1:-1;;;;;10066:19:1;;10058:68;;;;-1:-1:-1;;;10058:68:1;;7134:2:7;10058:68:1;;;7116:21:7;7173:2;7153:18;;;7146:30;7212:34;7192:18;;;7185:62;-1:-1:-1;;;7263:18:7;;;7256:34;7307:19;;10058:68:1;6932:400:7;10058:68:1;-1:-1:-1;;;;;10144:21:1;;10136:68;;;;-1:-1:-1;;;10136:68:1;;7539:2:7;10136:68:1;;;7521:21:7;7578:2;7558:18;;;7551:30;7617:34;7597:18;;;7590:62;-1:-1:-1;;;7668:18:7;;;7661:32;7710:19;;10136:68:1;7337:398:7;10136:68:1;-1:-1:-1;;;;;10215:18:1;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10266:32;;1852:25:7;;;10266:32:1;;1825:18:7;10266:32:1;;;;;;;;9935:370;;;:::o;8936:576::-;-1:-1:-1;;;;;9019:21:1;;9011:67;;;;-1:-1:-1;;;9011:67:1;;7942:2:7;9011:67:1;;;7924:21:7;7981:2;7961:18;;;7954:30;8020:34;8000:18;;;7993:62;-1:-1:-1;;;8071:18:7;;;8064:31;8112:19;;9011:67:1;7740:397:7;9011:67:1;-1:-1:-1;;;;;9174:18:1;;9149:22;9174:18;;;;;;;;;;;9210:24;;;;9202:71;;;;-1:-1:-1;;;9202:71:1;;8344:2:7;9202:71:1;;;8326:21:7;8383:2;8363:18;;;8356:30;8422:34;8402:18;;;8395:62;-1:-1:-1;;;8473:18:7;;;8466:32;8515:19;;9202:71:1;8142:398:7;9202:71:1;-1:-1:-1;;;;;9307:18:1;;:9;:18;;;;;;;;;;9328:23;;;9307:44;;9371:12;:22;;9345:6;;9307:9;9371:22;;9345:6;;9371:22;:::i;:::-;;;;-1:-1:-1;;9409:37:1;;1852:25:7;;;9435:1:1;;-1:-1:-1;;;;;9409:37:1;;;;;1840:2:7;1825:18;9409:37:1;1706:177:7;7238:713:1;-1:-1:-1;;;;;7373:20:1;;7365:70;;;;-1:-1:-1;;;7365:70:1;;8877:2:7;7365:70:1;;;8859:21:7;8916:2;8896:18;;;8889:30;8955:34;8935:18;;;8928:62;-1:-1:-1;;;9006:18:7;;;8999:35;9051:19;;7365:70:1;8675:401:7;7365:70:1;-1:-1:-1;;;;;7453:23:1;;7445:71;;;;-1:-1:-1;;;7445:71:1;;9283:2:7;7445:71:1;;;9265:21:7;9322:2;9302:18;;;9295:30;9361:34;9341:18;;;9334:62;-1:-1:-1;;;9412:18:7;;;9405:33;9455:19;;7445:71:1;9081:399:7;7445:71:1;-1:-1:-1;;;;;7609:17:1;;7585:21;7609:17;;;;;;;;;;;7644:23;;;;7636:74;;;;-1:-1:-1;;;7636:74:1;;9687:2:7;7636:74:1;;;9669:21:7;9726:2;9706:18;;;9699:30;9765:34;9745:18;;;9738:62;-1:-1:-1;;;9816:18:7;;;9809:36;9862:19;;7636:74:1;9485:402:7;7636:74:1;-1:-1:-1;;;;;7744:17:1;;;:9;:17;;;;;;;;;;;7764:22;;;7744:42;;7806:20;;;;;;;;:30;;7780:6;;7744:9;7806:30;;7780:6;;7806:30;:::i;:::-;;;;;;;;7869:9;-1:-1:-1;;;;;7852:35:1;7861:6;-1:-1:-1;;;;;7852:35:1;;7880:6;7852:35;;;;1852:25:7;;1840:2;1825:18;;1706:177;7852:35:1;;;;;;;;7355:596;7238:713;;;:::o;221:116:2:-;628:5;;-1:-1:-1;;;;;628:5:2;281:10;617:16;265:65;;;;-1:-1:-1;;;265:65:2;;10094:2:7;265:65:2;;;10076:21:7;10133:2;10113:18;;;10106:30;10172:34;10152:18;;;10145:62;-1:-1:-1;;;10223:18:7;;;10216:31;10264:19;;265:65:2;9892:397:7;265:65:2;221:116::o;1412:113:5:-;1468:7;:17;;-1:-1:-1;;;;;;1468:17:5;-1:-1:-1;;;;;1468:17:5;;;;;;;;1500:18;;;;-1:-1:-1;;1500:18:5;1412:113;:::o;423:109:2:-;477:5;:15;;-1:-1:-1;;;;;;477:15:2;-1:-1:-1;;;;;477:15:2;;;;;;;;507:18;;;;-1:-1:-1;;507:18:2;423:109;:::o;1219:187:5:-;1330:5;:3;:5::i;:::-;1302:24;1320:5;1302:13;3232:12:1;;;3145:106;1302:13:5;:17;;:24::i;:::-;:33;;1294:68;;;;-1:-1:-1;;;1294:68:5;;10496:2:7;1294:68:5;;;10478:21:7;10535:2;10515:18;;;10508:30;-1:-1:-1;;;10554:18:7;;;10547:52;10616:18;;1294:68:5;10294:346:7;1294:68:5;1372:27;1384:7;1393:5;1372:11;:27::i;14:597:7:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:7;574:15;-1:-1:-1;;570:29:7;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:7:o;824:173::-;892:20;;-1:-1:-1;;;;;941:31:7;;931:42;;921:70;;987:1;984;977:12;921:70;824:173;;;:::o;1002:254::-;1070:6;1078;1131:2;1119:9;1110:7;1106:23;1102:32;1099:52;;;1147:1;1144;1137:12;1099:52;1170:29;1189:9;1170:29;:::i;:::-;1160:39;1246:2;1231:18;;;;1218:32;;-1:-1:-1;;;1002:254:7:o;1453:248::-;1521:6;1529;1582:2;1570:9;1561:7;1557:23;1553:32;1550:52;;;1598:1;1595;1588:12;1550:52;-1:-1:-1;;1621:23:7;;;1691:2;1676:18;;;1663:32;;-1:-1:-1;1453:248:7:o;1888:328::-;1965:6;1973;1981;2034:2;2022:9;2013:7;2009:23;2005:32;2002:52;;;2050:1;2047;2040:12;2002:52;2073:29;2092:9;2073:29;:::i;:::-;2063:39;;2121:38;2155:2;2144:9;2140:18;2121:38;:::i;:::-;2111:48;;2206:2;2195:9;2191:18;2178:32;2168:42;;1888:328;;;;;:::o;2221:186::-;2280:6;2333:2;2321:9;2312:7;2308:23;2304:32;2301:52;;;2349:1;2346;2339:12;2301:52;2372:29;2391:9;2372:29;:::i;2601:322::-;2678:6;2686;2694;2747:2;2735:9;2726:7;2722:23;2718:32;2715:52;;;2763:1;2760;2753:12;2715:52;2786:29;2805:9;2786:29;:::i;:::-;2776:39;2862:2;2847:18;;2834:32;;-1:-1:-1;2913:2:7;2898:18;;;2885:32;;2601:322;-1:-1:-1;;;2601:322:7:o;2928:260::-;2996:6;3004;3057:2;3045:9;3036:7;3032:23;3028:32;3025:52;;;3073:1;3070;3063:12;3025:52;3096:29;3115:9;3096:29;:::i;:::-;3086:39;;3144:38;3178:2;3167:9;3163:18;3144:38;:::i;:::-;3134:48;;2928:260;;;;;:::o;3193:380::-;3272:1;3268:12;;;;3315;;;3336:61;;3390:4;3382:6;3378:17;3368:27;;3336:61;3443:2;3435:6;3432:14;3412:18;3409:38;3406:161;;;3489:10;3484:3;3480:20;3477:1;3470:31;3524:4;3521:1;3514:15;3552:4;3549:1;3542:15;3406:161;;3193:380;;;:::o;3987:127::-;4048:10;4043:3;4039:20;4036:1;4029:31;4079:4;4076:1;4069:15;4103:4;4100:1;4093:15;4119:422;4208:1;4251:5;4208:1;4265:270;4286:7;4276:8;4273:21;4265:270;;;4345:4;4341:1;4337:6;4333:17;4327:4;4324:27;4321:53;;;4354:18;;:::i;:::-;4404:7;4394:8;4390:22;4387:55;;;4424:16;;;;4387:55;4503:22;;;;4463:15;;;;4265:270;;;4269:3;4119:422;;;;;:::o;4546:806::-;4595:5;4625:8;4615:80;;-1:-1:-1;4666:1:7;4680:5;;4615:80;4714:4;4704:76;;-1:-1:-1;4751:1:7;4765:5;;4704:76;4796:4;4814:1;4809:59;;;;4882:1;4877:130;;;;4789:218;;4809:59;4839:1;4830:10;;4853:5;;;4877:130;4914:3;4904:8;4901:17;4898:43;;;4921:18;;:::i;:::-;-1:-1:-1;;4977:1:7;4963:16;;4992:5;;4789:218;;5091:2;5081:8;5078:16;5072:3;5066:4;5063:13;5059:36;5053:2;5043:8;5040:16;5035:2;5029:4;5026:12;5022:35;5019:77;5016:159;;;-1:-1:-1;5128:19:7;;;5160:5;;5016:159;5207:34;5232:8;5226:4;5207:34;:::i;:::-;5277:6;5273:1;5269:6;5265:19;5256:7;5253:32;5250:58;;;5288:18;;:::i;:::-;5326:20;;4546:806;-1:-1:-1;;;4546:806:7:o;5357:140::-;5415:5;5444:47;5485:4;5475:8;5471:19;5465:4;5444:47;:::i;5502:168::-;5542:7;5608:1;5604;5600:6;5596:14;5593:1;5590:21;5585:1;5578:9;5571:17;5567:45;5564:71;;;5615:18;;:::i;:::-;-1:-1:-1;5655:9:7;;5502:168::o;5675:128::-;5715:3;5746:1;5742:6;5739:1;5736:13;5733:39;;;5752:18;;:::i;:::-;-1:-1:-1;5788:9:7;;5675:128::o;8545:125::-;8585:4;8613:1;8610;8607:8;8604:34;;;8618:18;;:::i;:::-;-1:-1:-1;8655:9:7;;8545:125::o

ipfs://8ffecfaea4b65dcb068477b2fb05a70faaadc625ffa940670422cef38018c32a