Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20Capped.sol";


contract UhiveToken is ERC20Capped {

    event Burn(address indexed _from, uint256 _amount);

    constructor (string memory name_,
                string memory symbol_,
                uint256 cap)
                ERC20(name_, symbol_)
                ERC20Capped(cap) {

        _mint(msg.sender, cap);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
        _reduceCap(amount);
        emit Burn(msg.sender, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/*
 * @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 GSN 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";
import "./IERC20.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 guidelines: functions revert instead
 * of 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 {
    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 defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All three 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 returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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
     * overloaded;
     *
     * 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 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");
        _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");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(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:
     *
     * - `to` 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);
    }

    /**
     * @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");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(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 to 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 { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";

/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private _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-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - minted tokens must not cause the total supply to go over the cap.
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) { // When minting tokens
            require(totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        }
    }

    function _reduceCap(uint256 amount) internal {
        require(amount <= _cap, "ReduceCap: Amount specified is greater than current token cap.");
        _cap -= amount;
    }

}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"cap","type":"uint256"}],"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":"_from","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Burn","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"},{"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":"uint256","name":"amount","type":"uint256"}],"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":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000c1ded63574de0e4660000000000000000000000000000000000000000000000000000000000000000000000e556869766520546f6b656e20563200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044856453200000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Uhive Token V2
Arg [1] : symbol_ (string): HVE2
Arg [2] : cap (uint256): 60000000000000000000000000000

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000000000000000000000c1ded63574de0e4660000000
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [4] : 556869766520546f6b656e205632000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 4856453200000000000000000000000000000000000000000000000000000000

95:486:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:91:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4209:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3162:108::-;;;:::i;:::-;;;;;;;:::i;4860:422::-;;;;;;:::i;:::-;;:::i;3013:84::-;;;:::i;:::-;;;;;;;:::i;575:83:3:-;;;:::i;5691:215:2:-;;;;;;:::i;:::-;;:::i;426:152:5:-;;;;;;:::i;:::-;;:::i;:::-;;3333:127:2;;;;;;:::i;:::-;;:::i;2279:95::-;;;:::i;6409:377::-;;;;;;:::i;:::-;;:::i;3673:175::-;;;;;;:::i;:::-;;:::i;3911:151::-;;;;;;:::i;:::-;;:::i;2069:91::-;2114:13;2147:5;2140:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:91;:::o;4209:169::-;4292:4;4309:39;4318:12;:10;:12::i;:::-;4332:7;4341:6;4309:8;:39::i;:::-;-1:-1:-1;4366:4:2;4209:169;;;;:::o;3162:108::-;3250:12;;3162:108;:::o;4860:422::-;4966:4;4983:36;4993:6;5001:9;5012:6;4983:9;:36::i;:::-;-1:-1:-1;;;;;5059:19:2;;5032:24;5059:19;;;:11;:19;;;;;5032:24;5079:12;:10;:12::i;:::-;-1:-1:-1;;;;;5059:33:2;-1:-1:-1;;;;;5059:33:2;;;;;;;;;;;;;5032:60;;5131:6;5111:16;:26;;5103:79;;;;-1:-1:-1;;;5103:79:2;;;;;;;:::i;:::-;;;;;;;;;5193:57;5202:6;5210:12;:10;:12::i;:::-;5224:25;5243:6;5224:16;:25;:::i;:::-;5193:8;:57::i;:::-;-1:-1:-1;5270:4:2;;4860:422;-1:-1:-1;;;;4860:422:2:o;3013:84::-;3087:2;3013:84;:::o;575:83:3:-;646:4;;575:83;:::o;5691:215:2:-;5779:4;5796:80;5805:12;:10;:12::i;:::-;5819:7;5865:10;5828:11;:25;5840:12;:10;:12::i;:::-;-1:-1:-1;;;;;5828:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;5828:25:2;;;:34;;;;;;;;;;:47;;;;:::i;426:152:5:-;476:25;482:10;494:6;476:5;:25::i;:::-;512:18;523:6;512:10;:18::i;:::-;551:10;-1:-1:-1;;;;;546:24:5;;563:6;546:24;;;;;;:::i;:::-;;;;;;;;426:152;:::o;3333:127:2:-;-1:-1:-1;;;;;3434:18:2;;3407:7;3434:18;;;;;;;;;;;3333:127;;;;:::o;2279:95::-;2326:13;2359:7;2352:14;;;;;:::i;6409:377::-;6502:4;6519:24;6546:11;:25;6558:12;:10;:12::i;:::-;-1:-1:-1;;;;;6546:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;6546:25:2;;;:34;;;;;;;;;;;-1:-1:-1;6599:35:2;;;;6591:85;;;;-1:-1:-1;;;6591:85:2;;;;;;;:::i;:::-;6687:67;6696:12;:10;:12::i;:::-;6710:7;6719:34;6738:15;6719:16;:34;:::i;6687:67::-;-1:-1:-1;6774:4:2;;6409:377;-1:-1:-1;;;6409:377:2:o;3673:175::-;3759:4;3776:42;3786:12;:10;:12::i;:::-;3800:9;3811:6;3776:9;:42::i;3911:151::-;-1:-1:-1;;;;;4027:18:2;;;4000:7;4027:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3911:151::o;10714:92::-;;;;:::o;605:98:1:-;685:10;605:98;:::o;9765:346:2:-;-1:-1:-1;;;;;9867:19:2;;9859:68;;;;-1:-1:-1;;;9859:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;9946:21:2;;9938:68;;;;-1:-1:-1;;;9938:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;10019:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;10071:32;;;;;10049:6;;10071:32;:::i;:::-;;;;;;;;9765:346;;;:::o;7276:604::-;-1:-1:-1;;;;;7382:20:2;;7374:70;;;;-1:-1:-1;;;7374:70:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7463:23:2;;7455:71;;;;-1:-1:-1;;;7455:71:2;;;;;;;:::i;:::-;7539:47;7560:6;7568:9;7579:6;7539:20;:47::i;:::-;-1:-1:-1;;;;;7623:17:2;;7599:21;7623:17;;;;;;;;;;;7659:23;;;;7651:74;;;;-1:-1:-1;;;7651:74:2;;;;;;;:::i;:::-;7756:22;7772:6;7756:13;:22;:::i;:::-;-1:-1:-1;;;;;7736:17:2;;;:9;:17;;;;;;;;;;;:42;;;;7789:20;;;;;;;;:30;;7813:6;;7736:9;7789:30;;7813:6;;7789:30;:::i;:::-;;;;;;;;7854:9;-1:-1:-1;;;;;7837:35:2;7846:6;-1:-1:-1;;;;;7837:35:2;;7865:6;7837:35;;;;;;:::i;:::-;;;;;;;;7276:604;;;;:::o;8833:494::-;-1:-1:-1;;;;;8917:21:2;;8909:67;;;;-1:-1:-1;;;8909:67:2;;;;;;;:::i;:::-;8989:49;9010:7;9027:1;9031:6;8989:20;:49::i;:::-;-1:-1:-1;;;;;9076:18:2;;9051:22;9076:18;;;;;;;;;;;9113:24;;;;9105:71;;;;-1:-1:-1;;;9105:71:2;;;;;;;:::i;:::-;9208:23;9225:6;9208:14;:23;:::i;:::-;-1:-1:-1;;;;;9187:18:2;;:9;:18;;;;;;;;;;:44;;;;9242:12;:22;;9258:6;;9187:9;9242:22;;9258:6;;9242:22;:::i;:::-;;;;-1:-1:-1;;9282:37:2;;9308:1;;-1:-1:-1;;;;;9282:37:2;;;;;;;9312:6;;9282:37;:::i;1169:178:3:-;1243:4;;1233:6;:14;;1225:89;;;;-1:-1:-1;;;1225:89:3;;;;;;;:::i;:::-;1333:6;1325:4;;:14;;;;;;;:::i;:::-;;;;-1:-1:-1;;;1169:178:3:o;845:316::-;954:44;981:4;987:2;991:6;954:26;:44::i;:::-;-1:-1:-1;;;;;1015:18:3;;1011:143;;1107:5;:3;:5::i;:::-;1097:6;1081:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:31;;1073:69;;;;-1:-1:-1;;;1073:69:3;;;;;;;:::i;14:175:6:-;84:20;;-1:-1:-1;;;;;133:31:6;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;:::-;345:41;264:128;-1:-1:-1;;;264:128:6:o;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:6:o;1294:190::-;;1406:2;1394:9;1385:7;1381:23;1377:32;1374:2;;;1427:6;1419;1412:22;1374:2;-1:-1:-1;1455:23:6;;1364:120;-1:-1:-1;1364:120:6:o;1489:187::-;1654:14;;1647:22;1629:41;;1617:2;1602:18;;1584:92::o;1681:603::-;;1822:2;1851;1840:9;1833:21;1883:6;1877:13;1926:6;1921:2;1910:9;1906:18;1899:34;1951:4;1964:140;1978:6;1975:1;1972:13;1964:140;;;2073:14;;;2069:23;;2063:30;2039:17;;;2058:2;2035:26;2028:66;1993:10;;1964:140;;;2122:6;2119:1;2116:13;2113:2;;;2192:4;2187:2;2178:6;2167:9;2163:22;2159:31;2152:45;2113:2;-1:-1:-1;2268:2:6;2247:15;-1:-1:-1;;2243:29:6;2228:45;;;;2275:2;2224:54;;1802:482;-1:-1:-1;;;1802:482:6:o;2289:399::-;2491:2;2473:21;;;2530:2;2510:18;;;2503:30;2569:34;2564:2;2549:18;;2542:62;-1:-1:-1;;;2635:2:6;2620:18;;2613:33;2678:3;2663:19;;2463:225::o;2693:398::-;2895:2;2877:21;;;2934:2;2914:18;;;2907:30;2973:34;2968:2;2953:18;;2946:62;-1:-1:-1;;;3039:2:6;3024:18;;3017:32;3081:3;3066:19;;2867:224::o;3096:398::-;3298:2;3280:21;;;3337:2;3317:18;;;3310:30;3376:34;3371:2;3356:18;;3349:62;-1:-1:-1;;;3442:2:6;3427:18;;3420:32;3484:3;3469:19;;3270:224::o;3499:426::-;3701:2;3683:21;;;3740:2;3720:18;;;3713:30;3779:34;3774:2;3759:18;;3752:62;3850:32;3845:2;3830:18;;3823:60;3915:3;3900:19;;3673:252::o;3930:402::-;4132:2;4114:21;;;4171:2;4151:18;;;4144:30;4210:34;4205:2;4190:18;;4183:62;-1:-1:-1;;;4276:2:6;4261:18;;4254:36;4322:3;4307:19;;4104:228::o;4337:404::-;4539:2;4521:21;;;4578:2;4558:18;;;4551:30;4617:34;4612:2;4597:18;;4590:62;-1:-1:-1;;;4683:2:6;4668:18;;4661:38;4731:3;4716:19;;4511:230::o;4746:397::-;4948:2;4930:21;;;4987:2;4967:18;;;4960:30;5026:34;5021:2;5006:18;;4999:62;-1:-1:-1;;;5092:2:6;5077:18;;5070:31;5133:3;5118:19;;4920:223::o;5148:401::-;5350:2;5332:21;;;5389:2;5369:18;;;5362:30;5428:34;5423:2;5408:18;;5401:62;-1:-1:-1;;;5494:2:6;5479:18;;5472:35;5539:3;5524:19;;5322:227::o;5554:349::-;5756:2;5738:21;;;5795:2;5775:18;;;5768:30;5834:27;5829:2;5814:18;;5807:55;5894:2;5879:18;;5728:175::o;5908:400::-;6110:2;6092:21;;;6149:2;6129:18;;;6122:30;6188:34;6183:2;6168:18;;6161:62;-1:-1:-1;;;6254:2:6;6239:18;;6232:34;6298:3;6283:19;;6082:226::o;6313:401::-;6515:2;6497:21;;;6554:2;6534:18;;;6527:30;6593:34;6588:2;6573:18;;6566:62;-1:-1:-1;;;6659:2:6;6644:18;;6637:35;6704:3;6689:19;;6487:227::o;6719:177::-;6865:25;;;6853:2;6838:18;;6820:76::o;6901:184::-;7073:4;7061:17;;;;7043:36;;7031:2;7016:18;;6998:87::o;7090:128::-;;7161:1;7157:6;7154:1;7151:13;7148:2;;;7167:18;;:::i;:::-;-1:-1:-1;7203:9:6;;7138:80::o;7223:125::-;;7291:1;7288;7285:8;7282:2;;;7296:18;;:::i;:::-;-1:-1:-1;7333:9:6;;7272:76::o;7353:380::-;7438:1;7428:12;;7485:1;7475:12;;;7496:2;;7550:4;7542:6;7538:17;7528:27;;7496:2;7603;7595:6;7592:14;7572:18;7569:38;7566:2;;;7649:10;7644:3;7640:20;7637:1;7630:31;7684:4;7681:1;7674:15;7712:4;7709:1;7702:15;7566:2;;7408:325;;;:::o;7738:127::-;7799:10;7794:3;7790:20;7787:1;7780:31;7830:4;7827:1;7820:15;7854:4;7851:1;7844:15

ipfs://f5e9e84397d6f9909570f625b2e75c4bd8a1e2678f9f3a2b65533549cf22915c