Token Beamshare Token

Overview ERC20

Price
$0.00 @ 0.000000 GLMR
Fully Diluted Market Cap
Total Supply:
612,732,717.174483 SHARE

Holders:
4,875 addresses
Filtered by Token Holder (Null Address: 0x000…000)

Balance
0 SHARE

Value
$0.00
0x0000000000000000000000000000000000000000
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Decentralized exchange (DEX) with an automated market maker (AMM), providing liquidity and peer-to-peer transactions, built on the Moonbeam network.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
BeamShare

Compiler Version
v0.8.11+commit.d7f03943

Optimization Enabled:
Yes with 1000 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-01-16
*/

// Sources flattened with hardhat v2.7.1 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



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


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

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 generally not needed starting with Solidity 0.8, since 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;
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ├╖ 2 + 1, and for v in (302): v Γêê {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.0 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]


// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;





/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}


// File @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts v4.4.0 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/BeamShare.sol



pragma solidity 0.8.11;
contract BeamShare is ERC20("Beamshare Token", "SHARE"), ERC20Permit, ReentrancyGuard {
    using SafeMath for uint256;
    IERC20 public immutable beam;

    constructor(IERC20 _beam) ERC20Permit("BeamShare") {
        beam = _beam;
    }

    /// @notice enter BeamShare using a signature
    /// @dev enter BeamShare using a signature
    /// @param amount amount of BEAM
    /// @param deadline deadline for signature
    /// @param v recovery id
    /// @param r output of ECDSA signature
    /// @param s output of ECDSA signature
    function enterWithPermit(
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        IERC20Permit beamToken = IERC20Permit(address(beam));
        beamToken.permit(msg.sender, address(this), amount, deadline, v, r, s);
        enter(amount);
    }

    /// @notice Locks BEAM and mints SHARE to the user
    /// @dev Locks BEAM and mints SHARE to the user
    /// @param _amount BEAM amount
    function enter(uint256 _amount) public nonReentrant {
        uint256 totalBeam = beam.balanceOf(address(this));
        uint256 totalShares = totalSupply();
        if (totalShares == 0 || totalBeam == 0) {
            _mint(msg.sender, _amount);
        } else {
            uint256 what = _amount.mul(totalShares).div(totalBeam);
            _mint(msg.sender, what);
        }
        beam.transferFrom(msg.sender, address(this), _amount);
    }

    /// @notice Unlocks staked BEAM + rewards and burns SHARE
    /// @dev Unlocks staked BEAM + rewards and burns SHARE.
    /// @param _share SHARE amount
    function leave(uint256 _share) public nonReentrant{
        uint256 totalShares = totalSupply();
        uint256 what = _share.mul(beam.balanceOf(address(this))).div(
            totalShares
        );
        _burn(msg.sender, _share);
        beam.transfer(msg.sender, what);
    }

    /// @notice returns accounts staked and reward BEAM balance
    /// @dev returns accounts staked and reward BEAM balance
    /// @param _account users account
    function BEAMBalance(address _account)
        external
        view
        returns (uint256 beamAmount_)
    {
        uint256 xBEAMAmount = balanceOf(_account);
        uint256 totalxBEAM = totalSupply();
        beamAmount_ = xBEAMAmount.mul(beam.balanceOf(address(this))).div(
            totalxBEAM
        );
    }

    /// @notice returns how much BEAM user gets by redeeming SHARE
    /// @dev returns how much BEAM user gets by redeeming SHARE
    /// @param _xBEAMAmount SHARE amount
    function xBEAMForBEAM(uint256 _xBEAMAmount)
        external
        view
        returns (uint256 beamAmount_)
    {
        uint256 totalxBEAM = totalSupply();
        beamAmount_ = _xBEAMAmount.mul(beam.balanceOf(address(this))).div(
            totalxBEAM
        );
    }

    /// @notice returns how much SHARE user gets by depositing BEAM
    /// @dev returns how much SHARE user gets by depositing BEAM
    /// @param _beamAmount SHARE amount
    function BEAMForxBEAM(uint256 _beamAmount)
        external
        view
        returns (uint256 xBEAMAmount_)
    {
        uint256 totalBeam = beam.balanceOf(address(this));
        uint256 totalxBEAM = totalSupply();
        if (totalxBEAM == 0 || totalBeam == 0) {
            xBEAMAmount_ = _beamAmount;
        } else {
            xBEAMAmount_ = _beamAmount.mul(totalxBEAM).div(totalBeam);
        }
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IERC20","name":"_beam","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":"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":"_account","type":"address"}],"name":"BEAMBalance","outputs":[{"internalType":"uint256","name":"beamAmount_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_beamAmount","type":"uint256"}],"name":"BEAMForxBEAM","outputs":[{"internalType":"uint256","name":"xBEAMAmount_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","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":[],"name":"beam","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"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":"uint256","name":"_amount","type":"uint256"}],"name":"enter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"enterWithPermit","outputs":[],"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":"uint256","name":"_share","type":"uint256"}],"name":"leave","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"_xBEAMAmount","type":"uint256"}],"name":"xBEAMForBEAM","outputs":[{"internalType":"uint256","name":"beamAmount_","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000cd3b51d98478d53f4515a306be565c6eebef1d58

-----Decoded View---------------
Arg [0] : _beam (address): 0xcd3b51d98478d53f4515a306be565c6eebef1d58

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000cd3b51d98478d53f4515a306be565c6eebef1d58


Deployed ByteCode Sourcemap

49704:3537:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6776:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49830:28;;;;;;;;-1:-1:-1;;;;;793:55:1;;;775:74;;763:2;748:18;49830:28:0;616:239:1;8943:169:0;;;;;;:::i;:::-;;:::i;:::-;;;1485:14:1;;1478:22;1460:41;;1448:2;1433:18;8943:169:0;1320:187:1;7896:108:0;7984:12;;7896:108;;;1658:25:1;;;1646:2;1631:18;7896:108:0;1512:177:1;9594:492:0;;;;;;:::i;:::-;;:::i;7738:93::-;;;7821:2;2169:36:1;;2157:2;2142:18;7738:93:0;2027:184:1;46404:115:0;;;:::i;10495:215::-;;;;;;:::i;:::-;;:::i;51366:290::-;;;;;;:::i;:::-;;:::i;:::-;;8067:127;;;;;;:::i;:::-;-1:-1:-1;;;;;8168:18:0;8141:7;8168:18;;;;;;;;;;;;8067:127;51830:331;;;;;;:::i;:::-;;:::i;46146:128::-;;;;;;:::i;:::-;;:::i;6995:104::-;;;:::i;11213:413::-;;;;;;:::i;:::-;;:::i;50740:458::-;;;;;;:::i;:::-;;:::i;8407:175::-;;;;;;:::i;:::-;;:::i;52813:425::-;;;;;;:::i;:::-;;:::i;52344:285::-;;;;;;:::i;:::-;;:::i;50260:327::-;;;;;;:::i;:::-;;:::i;45435:645::-;;;;;;:::i;:::-;;:::i;8645:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;8761:18:0;;;8734:7;8761:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8645:151;6776:100;6830:13;6863:5;6856:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6776:100;:::o;8943:169::-;9026:4;9043:39;4505:10;9066:7;9075:6;9043:8;:39::i;:::-;-1:-1:-1;9100:4:0;8943:169;;;;:::o;9594:492::-;9734:4;9751:36;9761:6;9769:9;9780:6;9751:9;:36::i;:::-;-1:-1:-1;;;;;9827:19:0;;9800:24;9827:19;;;:11;:19;;;;;;;;4505:10;9827:33;;;;;;;;9879:26;;;;9871:79;;;;-1:-1:-1;;;9871:79:0;;4916:2:1;9871:79:0;;;4898:21:1;4955:2;4935:18;;;4928:30;4994:34;4974:18;;;4967:62;5065:10;5045:18;;;5038:38;5093:19;;9871:79:0;;;;;;;;;9986:57;9995:6;4505:10;10036:6;10017:16;:25;9986:8;:57::i;:::-;-1:-1:-1;10074:4:0;;9594:492;-1:-1:-1;;;;9594:492:0:o;46404:115::-;46464:7;46491:20;:18;:20::i;:::-;46484:27;;46404:115;:::o;10495:215::-;4505:10;10583:4;10632:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10632:34:0;;;;;;;;;;10583:4;;10600:80;;10623:7;;10632:47;;10669:10;;10632:47;:::i;:::-;10600:8;:80::i;51366:290::-;48691:1;49289:7;;:19;;49281:63;;;;-1:-1:-1;;;49281:63:0;;5647:2:1;49281:63:0;;;5629:21:1;5686:2;5666:18;;;5659:30;5725:33;5705:18;;;5698:61;5776:18;;49281:63:0;5445:355:1;49281:63:0;48691:1;49422:7;:18;51427:19:::1;51449:13;7984:12:::0;;;7896:108;51449:13:::1;51499:29;::::0;-1:-1:-1;;;51499:29:0;;51522:4:::1;51499:29;::::0;::::1;775:74:1::0;51427:35:0;;-1:-1:-1;51473:12:0::1;::::0;51488:82:::1;::::0;51427:35;;51488:41:::1;::::0;-1:-1:-1;;;;;51499:4:0::1;:14;::::0;::::1;::::0;748:18:1;;51499:29:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51488:6:::0;;:10:::1;:41::i;:::-;:45:::0;::::1;:82::i;:::-;51473:97;;51581:25;51587:10;51599:6;51581:5;:25::i;:::-;51617:31;::::0;;;;51631:10:::1;51617:31;::::0;::::1;6399:74:1::0;6489:18;;;6482:34;;;51617:4:0::1;-1:-1:-1::0;;;;;51617:13:0::1;::::0;::::1;::::0;6372:18:1;;51617:31:0::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;48647:1:0;49601:7;:22;-1:-1:-1;;51366:290:0:o;51830:331::-;-1:-1:-1;;;;;8168:18:0;;51919:19;8168:18;;;;;;;;;;;52008;52029:13;7984:12;;;7896:108;52029:13;52083:29;;-1:-1:-1;;;52083:29:0;;52106:4;52083:29;;;775:74:1;52008:34:0;;-1:-1:-1;52067:86:0;;52008:34;;52067:46;;-1:-1:-1;;;;;52083:4:0;:14;;;;748:18:1;;52083:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52067:11;;:15;:46::i;:86::-;52053:100;51830:331;-1:-1:-1;;;;51830:331:0:o;46146:128::-;-1:-1:-1;;;;;46242:14:0;;46215:7;46242:14;;;:7;:14;;;;;43465;46242:24;46235:31;46146:128;-1:-1:-1;;46146:128:0:o;6995:104::-;7051:13;7084:7;7077:14;;;;;:::i;11213:413::-;4505:10;11306:4;11350:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11350:34:0;;;;;;;;;;11403:35;;;;11395:85;;;;-1:-1:-1;;;11395:85:0;;7011:2:1;11395:85:0;;;6993:21:1;7050:2;7030:18;;;7023:30;7089:34;7069:18;;;7062:62;7160:7;7140:18;;;7133:35;7185:19;;11395:85:0;6809:401:1;11395:85:0;11516:67;4505:10;11539:7;11567:15;11548:16;:34;11516:8;:67::i;:::-;-1:-1:-1;11614:4:0;;11213:413;-1:-1:-1;;;11213:413:0:o;50740:458::-;48691:1;49289:7;;:19;;49281:63;;;;-1:-1:-1;;;49281:63:0;;5647:2:1;49281:63:0;;;5629:21:1;5686:2;5666:18;;;5659:30;5725:33;5705:18;;;5698:61;5776:18;;49281:63:0;5445:355:1;49281:63:0;48691:1;49422:7;:18;50823:29:::1;::::0;-1:-1:-1;;;50823:29:0;;50846:4:::1;50823:29;::::0;::::1;775:74:1::0;50803:17:0::1;::::0;50823:4:::1;-1:-1:-1::0;;;;;50823:14:0::1;::::0;::::1;::::0;748:18:1;;50823:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50803:49;;50863:19;50885:13;7984:12:::0;;;7896:108;50885:13:::1;50863:35:::0;-1:-1:-1;50913:16:0;;;:34:::1;;-1:-1:-1::0;50933:14:0;;50913:34:::1;50909:218;;;50964:26;50970:10;50982:7;50964:5;:26::i;:::-;50909:218;;;51023:12;51038:39;51067:9:::0;51038:24:::1;:7:::0;51050:11;51038::::1;:24::i;:39::-;51023:54;;51092:23;51098:10;51110:4;51092:5;:23::i;:::-;51008:119;50909:218;51137:53;::::0;;;;51155:10:::1;51137:53;::::0;::::1;7478:34:1::0;51175:4:0::1;7528:18:1::0;;;7521:43;7580:18;;;7573:34;;;51137:4:0::1;-1:-1:-1::0;;;;;51137:17:0::1;::::0;::::1;::::0;7390:18:1;;51137:53:0::1;7215:398:1::0;8407:175:0;8493:4;8510:42;4505:10;8534:9;8545:6;8510:9;:42::i;52813:425::-;52964:29;;-1:-1:-1;;;52964:29:0;;52987:4;52964:29;;;775:74:1;52906:20:0;;;;-1:-1:-1;;;;;52964:4:0;:14;;;;748:18:1;;52964:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52944:49;;53004:18;53025:13;7984:12;;;7896:108;53025:13;53004:34;-1:-1:-1;53053:15:0;;;:33;;-1:-1:-1;53072:14:0;;53053:33;53049:182;;;53118:11;53103:26;;53049:182;;;53177:42;53209:9;53177:27;:11;53193:10;53177:15;:27::i;53049:182::-;52933:305;;52813:425;;;:::o;52344:285::-;52438:19;52475:18;52496:13;7984:12;;;7896:108;52496:13;52551:29;;-1:-1:-1;;;52551:29:0;;52574:4;52551:29;;;775:74:1;52475:34:0;;-1:-1:-1;52534:87:0;;52475:34;;52534:47;;-1:-1:-1;;;;;52551:4:0;:14;;;;748:18:1;;52551:29:0;616:239:1;52534:87:0;52520:101;52344:285;-1:-1:-1;;;52344:285:0:o;50260:327::-;50485:70;;;;;50502:10;50485:70;;;7990:34:1;50522:4:0;8040:18:1;;;8033:43;8092:18;;;8085:34;;;8135:18;;;8128:34;;;8211:4;8199:17;;8178:19;;;8171:46;8233:19;;;8226:35;;;8277:19;;;8270:35;;;50468:4:0;;-1:-1:-1;;;;;50485:16:0;;;;;7901:19:1;;50485:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50566:13;50572:6;50566:5;:13::i;:::-;50411:176;50260:327;;;;;:::o;45435:645::-;45679:8;45660:15;:27;;45652:69;;;;-1:-1:-1;;;45652:69:0;;8518:2:1;45652:69:0;;;8500:21:1;8557:2;8537:18;;;8530:30;8596:31;8576:18;;;8569:59;8645:18;;45652:69:0;8316:353:1;45652:69:0;45734:18;45776:16;45794:5;45801:7;45810:5;45817:16;45827:5;45817:9;:16::i;:::-;45765:79;;;;;;8961:25:1;;;;-1:-1:-1;;;;;9083:15:1;;;9063:18;;;9056:43;9135:15;;;;9115:18;;;9108:43;9167:18;;;9160:34;9210:19;;;9203:35;9254:19;;;9247:35;;;8933:19;;45765:79:0;;;;;;;;;;;;45755:90;;;;;;45734:111;;45858:12;45873:28;45890:10;45873:16;:28::i;:::-;45858:43;;45914:14;45931:28;45945:4;45951:1;45954;45957;45931:13;:28::i;:::-;45914:45;;45988:5;-1:-1:-1;;;;;45978:15:0;:6;-1:-1:-1;;;;;45978:15:0;;45970:58;;;;-1:-1:-1;;;45970:58:0;;9495:2:1;45970:58:0;;;9477:21:1;9534:2;9514:18;;;9507:30;9573:32;9553:18;;;9546:60;9623:18;;45970:58:0;9293:354:1;45970:58:0;46041:31;46050:5;46057:7;46066:5;46041:8;:31::i;:::-;45641:439;;;45435:645;;;;;;;:::o;14897:380::-;-1:-1:-1;;;;;15033:19:0;;15025:68;;;;-1:-1:-1;;;15025:68:0;;9854:2:1;15025:68:0;;;9836:21:1;9893:2;9873:18;;;9866:30;9932:34;9912:18;;;9905:62;10003:6;9983:18;;;9976:34;10027:19;;15025:68:0;9652:400:1;15025:68:0;-1:-1:-1;;;;;15112:21:0;;15104:68;;;;-1:-1:-1;;;15104:68:0;;10259:2:1;15104:68:0;;;10241:21:1;10298:2;10278:18;;;10271:30;10337:34;10317:18;;;10310:62;10408:4;10388:18;;;10381:32;10430:19;;15104:68:0;10057:398:1;15104:68:0;-1:-1:-1;;;;;15185:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15237:32;;1658:25:1;;;15237:32:0;;1631:18:1;15237:32:0;;;;;;;;14897:380;;;:::o;12116:733::-;-1:-1:-1;;;;;12256:20:0;;12248:70;;;;-1:-1:-1;;;12248:70:0;;10662:2:1;12248:70:0;;;10644:21:1;10701:2;10681:18;;;10674:30;10740:34;10720:18;;;10713:62;10811:7;10791:18;;;10784:35;10836:19;;12248:70:0;10460:401:1;12248:70:0;-1:-1:-1;;;;;12337:23:0;;12329:71;;;;-1:-1:-1;;;12329:71:0;;11068:2:1;12329:71:0;;;11050:21:1;11107:2;11087:18;;;11080:30;11146:34;11126:18;;;11119:62;11217:5;11197:18;;;11190:33;11240:19;;12329:71:0;10866:399:1;12329:71:0;-1:-1:-1;;;;;12497:17:0;;12473:21;12497:17;;;;;;;;;;;12533:23;;;;12525:74;;;;-1:-1:-1;;;12525:74:0;;11472:2:1;12525:74:0;;;11454:21:1;11511:2;11491:18;;;11484:30;11550:34;11530:18;;;11523:62;11621:8;11601:18;;;11594:36;11647:19;;12525:74:0;11270:402:1;12525:74:0;-1:-1:-1;;;;;12635:17:0;;;:9;:17;;;;;;;;;;;12655:22;;;12635:42;;12699:20;;;;;;;;:30;;12671:6;;12635:9;12699:30;;12671:6;;12699:30;:::i;:::-;;;;;;;;12764:9;-1:-1:-1;;;;;12747:35:0;12756:6;-1:-1:-1;;;;;12747:35:0;;12775:6;12747:35;;;;1658:25:1;;1646:2;1631:18;;1512:177;12747:35:0;;;;;;;;12237:612;12116:733;;;:::o;41092:314::-;41145:7;41177:4;-1:-1:-1;;;;;41186:12:0;41169:29;;:66;;;;;41219:16;41202:13;:33;41169:66;41165:234;;;-1:-1:-1;41259:24:0;;41092:314::o;41165:234::-;-1:-1:-1;41595:73:0;;;41345:10;41595:73;;;;13683:25:1;;;;41357:12:0;13724:18:1;;;13717:34;41371:15:0;13767:18:1;;;13760:34;41639:13:0;13810:18:1;;;13803:34;41662:4:0;13853:19:1;;;;13846:84;;;;41595:73:0;;;;;;;;;;13655:19:1;;;;41595:73:0;;;41585:84;;;;;;46404:115::o;20345:98::-;20403:7;20430:5;20434:1;20430;:5;:::i;20744:98::-;20802:7;20829:5;20833:1;20829;:5;:::i;13868:591::-;-1:-1:-1;;;;;13952:21:0;;13944:67;;;;-1:-1:-1;;;13944:67:0;;12331:2:1;13944:67:0;;;12313:21:1;12370:2;12350:18;;;12343:30;12409:34;12389:18;;;12382:62;12480:3;12460:18;;;12453:31;12501:19;;13944:67:0;12129:397:1;13944:67:0;-1:-1:-1;;;;;14111:18:0;;14086:22;14111:18;;;;;;;;;;;14148:24;;;;14140:71;;;;-1:-1:-1;;;14140:71:0;;12733:2:1;14140:71:0;;;12715:21:1;12772:2;12752:18;;;12745:30;12811:34;12791:18;;;12784:62;12882:4;12862:18;;;12855:32;12904:19;;14140:71:0;12531:398:1;14140:71:0;-1:-1:-1;;;;;14247:18:0;;:9;:18;;;;;;;;;;14268:23;;;14247:44;;14313:12;:22;;14285:6;;14247:9;14313:22;;14285:6;;14313:22;:::i;:::-;;;;-1:-1:-1;;14353:37:0;;1658:25:1;;;14379:1:0;;-1:-1:-1;;;;;14353:37:0;;;;;1646:2:1;1631:18;14353:37:0;1512:177:1;13136:399:0;-1:-1:-1;;;;;13220:21:0;;13212:65;;;;-1:-1:-1;;;13212:65:0;;13266:2:1;13212:65:0;;;13248:21:1;13305:2;13285:18;;;13278:30;13344:33;13324:18;;;13317:61;13395:18;;13212:65:0;13064:355:1;13212:65:0;13368:6;13352:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;13385:18:0;;:9;:18;;;;;;;;;;:28;;13407:6;;13385:9;:28;;13407:6;;13385:28;:::i;:::-;;;;-1:-1:-1;;13429:37:0;;1658:25:1;;;-1:-1:-1;;;;;13429:37:0;;;13446:1;;13429:37;;1646:2:1;1631:18;13429:37:0;;;;;;;13136:399;;:::o;46657:207::-;-1:-1:-1;;;;;46778:14:0;;46717:15;46778:14;;;:7;:14;;;;;43465;;43602:1;43584:19;;;;43465:14;46839:17;46734:130;46657:207;;;:::o;42319:167::-;42396:7;42423:55;42445:20;:18;:20::i;:::-;42467:10;37783:57;;14211:66:1;37783:57:0;;;14199:79:1;14294:11;;;14287:27;;;14330:12;;;14323:28;;;37746:7:0;;14367:12:1;;37783:57:0;;;;;;;;;;;;37773:68;;;;;;37766:75;;37653:196;;;;;35962:279;36090:7;36111:17;36130:18;36152:25;36163:4;36169:1;36172;36175;36152:10;:25::i;:::-;36110:67;;;;36188:18;36200:5;36188:11;:18::i;:::-;-1:-1:-1;36224:9:0;35962:279;-1:-1:-1;;;;;35962:279:0:o;34184:1639::-;34315:7;;35256:66;35243:79;;35239:163;;;-1:-1:-1;35355:1:0;;-1:-1:-1;35359:30:0;35339:51;;35239:163;35416:1;:7;;35421:2;35416:7;;:18;;;;;35427:1;:7;;35432:2;35427:7;;35416:18;35412:102;;;-1:-1:-1;35467:1:0;;-1:-1:-1;35471:30:0;35451:51;;35412:102;35628:24;;;35611:14;35628:24;;;;;;;;;14617:25:1;;;14690:4;14678:17;;14658:18;;;14651:45;;;;14712:18;;;14705:34;;;14755:18;;;14748:34;;;35628:24:0;;14589:19:1;;35628:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;35628:24:0;;-1:-1:-1;;35628:24:0;;;-1:-1:-1;;;;;;;35667:20:0;;35663:103;;35720:1;35724:29;35704:50;;;;;;;35663:103;35786:6;-1:-1:-1;35794:20:0;;-1:-1:-1;34184:1639:0;;;;;;;;:::o;28846:643::-;28924:20;28915:5;:29;;;;;;;;:::i;:::-;;28911:571;;;28846:643;:::o;28911:571::-;29022:29;29013:5;:38;;;;;;;;:::i;:::-;;29009:473;;;29068:34;;-1:-1:-1;;;29068:34:0;;15184:2:1;29068:34:0;;;15166:21:1;15223:2;15203:18;;;15196:30;15262:26;15242:18;;;15235:54;15306:18;;29068:34:0;14982:348:1;29009:473:0;29133:35;29124:5;:44;;;;;;;;:::i;:::-;;29120:362;;;29185:41;;-1:-1:-1;;;29185:41:0;;15537:2:1;29185:41:0;;;15519:21:1;15576:2;15556:18;;;15549:30;15615:33;15595:18;;;15588:61;15666:18;;29185:41:0;15335:355:1;29120:362:0;29257:30;29248:5;:39;;;;;;;;:::i;:::-;;29244:238;;;29304:44;;-1:-1:-1;;;29304:44:0;;15897:2:1;29304:44:0;;;15879:21:1;15936:2;15916:18;;;15909:30;15975:34;15955:18;;;15948:62;-1:-1:-1;;;16026:18:1;;;16019:32;16068:19;;29304:44:0;15695:398:1;29244:238:0;29379:30;29370:5;:39;;;;;;;;:::i;:::-;;29366:116;;;29426:44;;-1:-1:-1;;;29426:44:0;;16300:2:1;29426:44:0;;;16282:21:1;16339:2;16319:18;;;16312:30;16378:34;16358:18;;;16351:62;-1:-1:-1;;;16429:18:1;;;16422:32;16471:19;;29426:44:0;16098:398:1;29366:116:0;28846:643;:::o;14:597:1:-;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:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;860:196::-;928:20;;-1:-1:-1;;;;;977:54:1;;967:65;;957:93;;1046:1;1043;1036:12;957:93;860:196;;;:::o;1061:254::-;1129:6;1137;1190:2;1178:9;1169:7;1165:23;1161:32;1158:52;;;1206:1;1203;1196:12;1158:52;1229:29;1248:9;1229:29;:::i;:::-;1219:39;1305:2;1290:18;;;;1277:32;;-1:-1:-1;;;1061:254:1:o;1694:328::-;1771:6;1779;1787;1840:2;1828:9;1819:7;1815:23;1811:32;1808:52;;;1856:1;1853;1846:12;1808:52;1879:29;1898:9;1879:29;:::i;:::-;1869:39;;1927:38;1961:2;1950:9;1946:18;1927:38;:::i;:::-;1917:48;;2012:2;2001:9;1997:18;1984:32;1974:42;;1694:328;;;;;:::o;2398:180::-;2457:6;2510:2;2498:9;2489:7;2485:23;2481:32;2478:52;;;2526:1;2523;2516:12;2478:52;-1:-1:-1;2549:23:1;;2398:180;-1:-1:-1;2398:180:1:o;2583:186::-;2642:6;2695:2;2683:9;2674:7;2670:23;2666:32;2663:52;;;2711:1;2708;2701:12;2663:52;2734:29;2753:9;2734:29;:::i;2774:156::-;2840:20;;2900:4;2889:16;;2879:27;;2869:55;;2920:1;2917;2910:12;2935:456;3028:6;3036;3044;3052;3060;3113:3;3101:9;3092:7;3088:23;3084:33;3081:53;;;3130:1;3127;3120:12;3081:53;3166:9;3153:23;3143:33;;3223:2;3212:9;3208:18;3195:32;3185:42;;3246:36;3278:2;3267:9;3263:18;3246:36;:::i;:::-;2935:456;;;;-1:-1:-1;3236:46:1;;3329:2;3314:18;;3301:32;;-1:-1:-1;3380:3:1;3365:19;3352:33;;2935:456;-1:-1:-1;;2935:456:1:o;3396:606::-;3507:6;3515;3523;3531;3539;3547;3555;3608:3;3596:9;3587:7;3583:23;3579:33;3576:53;;;3625:1;3622;3615:12;3576:53;3648:29;3667:9;3648:29;:::i;:::-;3638:39;;3696:38;3730:2;3719:9;3715:18;3696:38;:::i;:::-;3686:48;;3781:2;3770:9;3766:18;3753:32;3743:42;;3832:2;3821:9;3817:18;3804:32;3794:42;;3855:37;3887:3;3876:9;3872:19;3855:37;:::i;:::-;3845:47;;3939:3;3928:9;3924:19;3911:33;3901:43;;3991:3;3980:9;3976:19;3963:33;3953:43;;3396:606;;;;;;;;;;:::o;4007:260::-;4075:6;4083;4136:2;4124:9;4115:7;4111:23;4107:32;4104:52;;;4152:1;4149;4142:12;4104:52;4175:29;4194:9;4175:29;:::i;:::-;4165:39;;4223:38;4257:2;4246:9;4242:18;4223:38;:::i;:::-;4213:48;;4007:260;;;;;:::o;4272:437::-;4351:1;4347:12;;;;4394;;;4415:61;;4469:4;4461:6;4457:17;4447:27;;4415:61;4522:2;4514:6;4511:14;4491:18;4488:38;4485:218;;;-1:-1:-1;;;4556:1:1;4549:88;4660:4;4657:1;4650:15;4688:4;4685:1;4678:15;5123:184;-1:-1:-1;;;5172:1:1;5165:88;5272:4;5269:1;5262:15;5296:4;5293:1;5286:15;5312:128;5352:3;5383:1;5379:6;5376:1;5373:13;5370:39;;;5389:18;;:::i;:::-;-1:-1:-1;5425:9:1;;5312:128::o;6036:184::-;6106:6;6159:2;6147:9;6138:7;6134:23;6130:32;6127:52;;;6175:1;6172;6165:12;6127:52;-1:-1:-1;6198:16:1;;6036:184;-1:-1:-1;6036:184:1:o;6527:277::-;6594:6;6647:2;6635:9;6626:7;6622:23;6618:32;6615:52;;;6663:1;6660;6653:12;6615:52;6695:9;6689:16;6748:5;6741:13;6734:21;6727:5;6724:32;6714:60;;6770:1;6767;6760:12;11677:168;11717:7;11783:1;11779;11775:6;11771:14;11768:1;11765:21;11760:1;11753:9;11746:17;11742:45;11739:71;;;11790:18;;:::i;:::-;-1:-1:-1;11830:9:1;;11677:168::o;11850:274::-;11890:1;11916;11906:189;;-1:-1:-1;;;11948:1:1;11941:88;12052:4;12049:1;12042:15;12080:4;12077:1;12070:15;11906:189;-1:-1:-1;12109:9:1;;11850:274::o;12934:125::-;12974:4;13002:1;12999;12996:8;12993:34;;;13007:18;;:::i;:::-;-1:-1:-1;13044:9:1;;12934:125::o;14793:184::-;-1:-1:-1;;;14842:1:1;14835:88;14942:4;14939:1;14932:15;14966:4;14963:1;14956:15

Swarm Source

ipfs://30033bb71b40d7b0eb225a7fc0903be41acebd132eb91dbdef0cdf8a63831cd7
Loading