Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function _msgSender()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _approve(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function cap()
•    - function _mint(address account, uint2 ...
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract Membership is Context
•    - function transferOwner(address newOwn ...
•    - function setMembership(address key, u ...
•    - function isOwner()
•    - function isAdmin()
•    - function isClaimant()
•    - function getMembership(address accoun ...
•  contract LOKA is ERC20Capped, Owna ...
•    - function mint(address addr, uint256 a ...
•    - function _allocate(address addr, uint ...
•    - function allocate(address addr, uint2 ...
•    - function allocateOf(address account)
•    - function take(address addr, uint256 a ...
•  contract Claimant is Membership *
•    - function initialize(uint256 strtd, ui ...
•    - function register(address m)
•    - function claimable()
•    - function claim()
•    - function totalClaimed()
•    - function getStarted()
•    - function getTerm()
•    - function getBlockTimestamp()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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


// OpenZeppelin Contracts v4.3.2 (token/ERC20/IERC20.sol)
/**
 * @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);
    
    event Mint(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);
}


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

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

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


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


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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

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

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

        _totalSupply += amount;
        _balances[account] += amount;
        
        emit Mint(account, amount);
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, 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 {}
}


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/ERC20Capped.sol)
/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private immutable _cap;

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

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

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


// OpenZeppelin Contracts v4.3.2 (access/Ownable.sol)
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


contract Membership is Context {
    address private owner;
    event MembershipChanged(address indexed owner, uint256 level);
    event OwnerTransferred(address indexed preOwner, address indexed newOwner);

    mapping(address => uint256) internal membership;

    constructor() {
        owner = _msgSender();
        setMembership(_msgSender(), 1);
    }

    function transferOwner(address newOwner) public onlyOwner {
        address preOwner = owner;
        setMembership(newOwner, 1);
        setMembership(preOwner, 0);
        owner = newOwner;
        emit OwnerTransferred(preOwner, newOwner);
    }

    function setMembership(address key, uint256 level) public onlyOwner {
        membership[key] = level;
        emit MembershipChanged(key, level);
    }

    modifier onlyOwner() {
        require(isOwner(), "Membership : caller is not the owner");
        _;
    }

    function isOwner() public view returns (bool) {
        return _msgSender() == owner;
    }


    modifier onlyAdmin() {
        require(isAdmin(), "Membership : caller is not a admin");
        _;
    }

    function isAdmin() public view returns (bool) {
        return membership[_msgSender()] == 1;
    }

    modifier onlyClaimant() {
        require(isClaimant(), "Memberhsip : caller is not a claimant");
        _;
    }

    function isClaimant() public view returns (bool) {
        return membership[_msgSender()] == 11;
    }
    
    function getMembership(address account) public view returns (uint256){
        return membership[account];
    }
}


contract LOKA is ERC20Capped, Ownable {
    constructor(
        string memory name,
        string memory symbol,
        uint256 cap
    ) ERC20(name, symbol) ERC20Capped(cap) {
        
    }

    function mint(address addr, uint256 amount) public onlyOwner {
        _mint(addr, amount);
    }
    
    // function retain(address addr, uint256 amount, uint256 strtd, uint256 trm, uint256 tms) public onlyOwner {
    //     _mint(addr, amount);
    //     Claimant(addr).initialize(strtd, trm, tms);
    // }

    mapping(address => uint256) private _allocates;
    function _allocate(address addr, uint256 amount) internal virtual {
        _allocates[addr] += amount;
    }
    function allocate(address addr, uint256 amount) public onlyOwner {
        _allocate(addr, amount);
    }
    function allocateOf(address account) public view virtual returns (uint256) {
        return _allocates[account];
    }
    function take(address addr, uint256 amount) public {
        address sender = _msgSender();
        require(_allocates[sender]>=amount, "TokenVesting: No takable amount");
        _allocates[sender] -= amount;
        _mint(addr, amount);
    }
}


contract Claimant is Membership {

    LOKA public token;

    uint256 public started;
    uint256 public claimed;
    uint256 public term;
    uint256[] public amounts;

    constructor(LOKA _token) Membership() {
        token = _token;
    }
    function initialize(uint256 strtd, uint256 trm, uint256[] calldata amnts) public onlyAdmin {
        started = strtd;
        term = trm;
        amounts = amnts;
    }

    function register(address m) public onlyAdmin {
        setMembership(m, 11);
    }

    function claimable() public view returns (uint256){
        require(block.timestamp > started, "TokenVesting: Not claimable");
        uint256 sequence = (block.timestamp - started) / term;
        if(sequence>=amounts.length)
            sequence = amounts.length-1;
        if(amounts[sequence]<=claimed)
            return 0;
        return amounts[sequence]-claimed;
    }

    function claim() public onlyClaimant {
        uint256 amount = claimable();
        require(amount > 0, "TokenVesting: No claimable amount");
        claimed += amount;
        token.transfer(_msgSender(), amount);
    }

    function totalClaimed() public view returns (uint256) {
        return claimed;
    }

    function getStarted() public view returns (uint256) {
        return started;
    }

    function getTerm() public view returns (uint256) {
        return term;
    }
    function getBlockTimestamp() public view returns (uint256) {
        return block.timestamp;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract LOKA","name":"_token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"level","type":"uint256"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"preOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"amounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBlockTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getMembership","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStarted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTerm","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"strtd","type":"uint256"},{"internalType":"uint256","name":"trm","type":"uint256"},{"internalType":"uint256[]","name":"amnts","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isClaimant","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"m","type":"address"}],"name":"register","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"level","type":"uint256"}],"name":"setMembership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"started","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"term","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract LOKA","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwner","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

21561:1536:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22909:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21628:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20236:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22002:85;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21712:24;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22487:226;;;:::i;:::-;;19123:254;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21822:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22994:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19385:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19666:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20119:105;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21686:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22816:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22095:384;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19885:101;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22721:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21657:22;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21602:17;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22909:79;22949:7;22976:4;;22969:11;;22909:79;:::o;21628:22::-;;;;:::o;20236:114::-;20297:7;20323:10;:19;20334:7;20323:19;;;;;;;;;;;;;;;;20316:26;;20236:114;;;:::o;22002:85::-;19809:9;:7;:9::i;:::-;19801:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;22059:20:::1;22073:1;22076:2;22059:13;:20::i;:::-;22002:85:::0;:::o;21712:24::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;22487:226::-;20037:12;:10;:12::i;:::-;20029:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;22535:14:::1;22552:11;:9;:11::i;:::-;22535:28;;22591:1;22582:6;:10;22574:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;22652:6;22641:7;;:17;;;;;;;:::i;:::-;;;;;;;;22669:5;;;;;;;;;;;:14;;;22684:12;:10;:12::i;:::-;22698:6;22669:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;22524:189;22487:226::o:0;19123:254::-;19588:9;:7;:9::i;:::-;19580:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;19192:16:::1;19211:5:::0;::::1;;;;;;;;;;19192:24;;19227:26;19241:8;19251:1;19227:13;:26::i;:::-;19264;19278:8;19288:1;19264:13;:26::i;:::-;19309:8;19301:5;::::0;:16:::1;;;;;;;;;;;;;;;;;;19360:8;19333:36;;19350:8;19333:36;;;;;;;;;;;;19181:196;19123:254:::0;:::o;21822:172::-;19809:9;:7;:9::i;:::-;19801:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;21934:5:::1;21924:7;:15;;;;21957:3;21950:4;:10;;;;21981:5;;21971:7;:15;;;;;;;:::i;:::-;;21822:172:::0;;;;:::o;22994:100::-;23044:7;23071:15;23064:22;;22994:100;:::o;19385:155::-;19588:9;:7;:9::i;:::-;19580:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;19482:5:::1;19464:10;:15;19475:3;19464:15;;;;;;;;;;;;;;;:23;;;;19521:3;19503:29;;;19526:5;19503:29;;;;;;:::i;:::-;;;;;;;;19385:155:::0;;:::o;19666:93::-;19706:4;19746:5;;;;;;;;;;;19730:21;;:12;:10;:12::i;:::-;:21;;;19723:28;;19666:93;:::o;20119:105::-;20162:4;20214:2;20186:10;:24;20197:12;:10;:12::i;:::-;20186:24;;;;;;;;;;;;;;;;:30;20179:37;;20119:105;:::o;21686:19::-;;;;:::o;22816:85::-;22859:7;22886;;22879:14;;22816:85;:::o;22095:384::-;22137:7;22182;;22164:15;:25;22156:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;22232:16;22281:4;;22270:7;;22252:15;:25;;;;:::i;:::-;22251:34;;;;:::i;:::-;22232:53;;22309:7;:14;;;;22299:8;:24;22296:69;;22364:1;22349:7;:14;;;;:16;;;;:::i;:::-;22338:27;;22296:69;22398:7;;22379;22387:8;22379:17;;;;;;;;:::i;:::-;;;;;;;;;;:26;22376:52;;22427:1;22420:8;;;;;22376:52;22464:7;;22446;22454:8;22446:17;;;;;;;;:::i;:::-;;;;;;;;;;:25;;;;:::i;:::-;22439:32;;;22095:384;;:::o;19885:101::-;19925:4;19977:1;19949:10;:24;19960:12;:10;:12::i;:::-;19949:24;;;;;;;;;;;;;;;;:29;19942:36;;19885:101;:::o;22721:87::-;22766:7;22793;;22786:14;;22721:87;:::o;21657:22::-;;;;:::o;21602:17::-;;;;;;;;;;;;;:::o;4146:98::-;4199:7;4226:10;4219:17;;4146:98;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:126;806:7;846:42;839:5;835:54;824:65;;769:126;;;:::o;901:96::-;938:7;967:24;985:5;967:24;:::i;:::-;956:35;;901:96;;;:::o;1003:122::-;1076:24;1094:5;1076:24;:::i;:::-;1069:5;1066:35;1056:63;;1115:1;1112;1105:12;1056:63;1003:122;:::o;1131:139::-;1177:5;1215:6;1202:20;1193:29;;1231:33;1258:5;1231:33;:::i;:::-;1131:139;;;;:::o;1276:329::-;1335:6;1384:2;1372:9;1363:7;1359:23;1355:32;1352:119;;;1390:79;;:::i;:::-;1352:119;1510:1;1535:53;1580:7;1571:6;1560:9;1556:22;1535:53;:::i;:::-;1525:63;;1481:117;1276:329;;;;:::o;1611:122::-;1684:24;1702:5;1684:24;:::i;:::-;1677:5;1674:35;1664:63;;1723:1;1720;1713:12;1664:63;1611:122;:::o;1739:139::-;1785:5;1823:6;1810:20;1801:29;;1839:33;1866:5;1839:33;:::i;:::-;1739:139;;;;:::o;1884:329::-;1943:6;1992:2;1980:9;1971:7;1967:23;1963:32;1960:119;;;1998:79;;:::i;:::-;1960:119;2118:1;2143:53;2188:7;2179:6;2168:9;2164:22;2143:53;:::i;:::-;2133:63;;2089:117;1884:329;;;;:::o;2219:117::-;2328:1;2325;2318:12;2342:117;2451:1;2448;2441:12;2465:117;2574:1;2571;2564:12;2605:568;2678:8;2688:6;2738:3;2731:4;2723:6;2719:17;2715:27;2705:122;;2746:79;;:::i;:::-;2705:122;2859:6;2846:20;2836:30;;2889:18;2881:6;2878:30;2875:117;;;2911:79;;:::i;:::-;2875:117;3025:4;3017:6;3013:17;3001:29;;3079:3;3071:4;3063:6;3059:17;3049:8;3045:32;3042:41;3039:128;;;3086:79;;:::i;:::-;3039:128;2605:568;;;;;:::o;3179:849::-;3283:6;3291;3299;3307;3356:2;3344:9;3335:7;3331:23;3327:32;3324:119;;;3362:79;;:::i;:::-;3324:119;3482:1;3507:53;3552:7;3543:6;3532:9;3528:22;3507:53;:::i;:::-;3497:63;;3453:117;3609:2;3635:53;3680:7;3671:6;3660:9;3656:22;3635:53;:::i;:::-;3625:63;;3580:118;3765:2;3754:9;3750:18;3737:32;3796:18;3788:6;3785:30;3782:117;;;3818:79;;:::i;:::-;3782:117;3931:80;4003:7;3994:6;3983:9;3979:22;3931:80;:::i;:::-;3913:98;;;;3708:313;3179:849;;;;;;;:::o;4034:474::-;4102:6;4110;4159:2;4147:9;4138:7;4134:23;4130:32;4127:119;;;4165:79;;:::i;:::-;4127:119;4285:1;4310:53;4355:7;4346:6;4335:9;4331:22;4310:53;:::i;:::-;4300:63;;4256:117;4412:2;4438:53;4483:7;4474:6;4463:9;4459:22;4438:53;:::i;:::-;4428:63;;4383:118;4034:474;;;;;:::o;4514:90::-;4548:7;4591:5;4584:13;4577:21;4566:32;;4514:90;;;:::o;4610:109::-;4691:21;4706:5;4691:21;:::i;:::-;4686:3;4679:34;4610:109;;:::o;4725:210::-;4812:4;4850:2;4839:9;4835:18;4827:26;;4863:65;4925:1;4914:9;4910:17;4901:6;4863:65;:::i;:::-;4725:210;;;;:::o;4941:60::-;4969:3;4990:5;4983:12;;4941:60;;;:::o;5007:142::-;5057:9;5090:53;5108:34;5117:24;5135:5;5117:24;:::i;:::-;5108:34;:::i;:::-;5090:53;:::i;:::-;5077:66;;5007:142;;;:::o;5155:126::-;5205:9;5238:37;5269:5;5238:37;:::i;:::-;5225:50;;5155:126;;;:::o;5287:139::-;5350:9;5383:37;5414:5;5383:37;:::i;:::-;5370:50;;5287:139;;;:::o;5432:157::-;5532:50;5576:5;5532:50;:::i;:::-;5527:3;5520:63;5432:157;;:::o;5595:248::-;5701:4;5739:2;5728:9;5724:18;5716:26;;5752:84;5833:1;5822:9;5818:17;5809:6;5752:84;:::i;:::-;5595:248;;;;:::o;5849:169::-;5933:11;5967:6;5962:3;5955:19;6007:4;6002:3;5998:14;5983:29;;5849:169;;;;:::o;6024:221::-;6164:34;6160:1;6152:6;6148:14;6141:58;6233:4;6228:2;6220:6;6216:15;6209:29;6024:221;:::o;6251:366::-;6393:3;6414:67;6478:2;6473:3;6414:67;:::i;:::-;6407:74;;6490:93;6579:3;6490:93;:::i;:::-;6608:2;6603:3;6599:12;6592:19;;6251:366;;;:::o;6623:419::-;6789:4;6827:2;6816:9;6812:18;6804:26;;6876:9;6870:4;6866:20;6862:1;6851:9;6847:17;6840:47;6904:131;7030:4;6904:131;:::i;:::-;6896:139;;6623:419;;;:::o;7048:224::-;7188:34;7184:1;7176:6;7172:14;7165:58;7257:7;7252:2;7244:6;7240:15;7233:32;7048:224;:::o;7278:366::-;7420:3;7441:67;7505:2;7500:3;7441:67;:::i;:::-;7434:74;;7517:93;7606:3;7517:93;:::i;:::-;7635:2;7630:3;7626:12;7619:19;;7278:366;;;:::o;7650:419::-;7816:4;7854:2;7843:9;7839:18;7831:26;;7903:9;7897:4;7893:20;7889:1;7878:9;7874:17;7867:47;7931:131;8057:4;7931:131;:::i;:::-;7923:139;;7650:419;;;:::o;8075:220::-;8215:34;8211:1;8203:6;8199:14;8192:58;8284:3;8279:2;8271:6;8267:15;8260:28;8075:220;:::o;8301:366::-;8443:3;8464:67;8528:2;8523:3;8464:67;:::i;:::-;8457:74;;8540:93;8629:3;8540:93;:::i;:::-;8658:2;8653:3;8649:12;8642:19;;8301:366;;;:::o;8673:419::-;8839:4;8877:2;8866:9;8862:18;8854:26;;8926:9;8920:4;8916:20;8912:1;8901:9;8897:17;8890:47;8954:131;9080:4;8954:131;:::i;:::-;8946:139;;8673:419;;;:::o;9098:180::-;9146:77;9143:1;9136:88;9243:4;9240:1;9233:15;9267:4;9264:1;9257:15;9284:305;9324:3;9343:20;9361:1;9343:20;:::i;:::-;9338:25;;9377:20;9395:1;9377:20;:::i;:::-;9372:25;;9531:1;9463:66;9459:74;9456:1;9453:81;9450:107;;;9537:18;;:::i;:::-;9450:107;9581:1;9578;9574:9;9567:16;;9284:305;;;;:::o;9595:118::-;9682:24;9700:5;9682:24;:::i;:::-;9677:3;9670:37;9595:118;;:::o;9719:332::-;9840:4;9878:2;9867:9;9863:18;9855:26;;9891:71;9959:1;9948:9;9944:17;9935:6;9891:71;:::i;:::-;9972:72;10040:2;10029:9;10025:18;10016:6;9972:72;:::i;:::-;9719:332;;;;;:::o;10057:116::-;10127:21;10142:5;10127:21;:::i;:::-;10120:5;10117:32;10107:60;;10163:1;10160;10153:12;10107:60;10057:116;:::o;10179:137::-;10233:5;10264:6;10258:13;10249:22;;10280:30;10304:5;10280:30;:::i;:::-;10179:137;;;;:::o;10322:345::-;10389:6;10438:2;10426:9;10417:7;10413:23;10409:32;10406:119;;;10444:79;;:::i;:::-;10406:119;10564:1;10589:61;10642:7;10633:6;10622:9;10618:22;10589:61;:::i;:::-;10579:71;;10535:125;10322:345;;;;:::o;10673:223::-;10813:34;10809:1;10801:6;10797:14;10790:58;10882:6;10877:2;10869:6;10865:15;10858:31;10673:223;:::o;10902:366::-;11044:3;11065:67;11129:2;11124:3;11065:67;:::i;:::-;11058:74;;11141:93;11230:3;11141:93;:::i;:::-;11259:2;11254:3;11250:12;11243:19;;10902:366;;;:::o;11274:419::-;11440:4;11478:2;11467:9;11463:18;11455:26;;11527:9;11521:4;11517:20;11513:1;11502:9;11498:17;11491:47;11555:131;11681:4;11555:131;:::i;:::-;11547:139;;11274:419;;;:::o;11699:177::-;11839:29;11835:1;11827:6;11823:14;11816:53;11699:177;:::o;11882:366::-;12024:3;12045:67;12109:2;12104:3;12045:67;:::i;:::-;12038:74;;12121:93;12210:3;12121:93;:::i;:::-;12239:2;12234:3;12230:12;12223:19;;11882:366;;;:::o;12254:419::-;12420:4;12458:2;12447:9;12443:18;12435:26;;12507:9;12501:4;12497:20;12493:1;12482:9;12478:17;12471:47;12535:131;12661:4;12535:131;:::i;:::-;12527:139;;12254:419;;;:::o;12679:191::-;12719:4;12739:20;12757:1;12739:20;:::i;:::-;12734:25;;12773:20;12791:1;12773:20;:::i;:::-;12768:25;;12812:1;12809;12806:8;12803:34;;;12817:18;;:::i;:::-;12803:34;12862:1;12859;12855:9;12847:17;;12679:191;;;;:::o;12876:180::-;12924:77;12921:1;12914:88;13021:4;13018:1;13011:15;13045:4;13042:1;13035:15;13062:185;13102:1;13119:20;13137:1;13119:20;:::i;:::-;13114:25;;13153:20;13171:1;13153:20;:::i;:::-;13148:25;;13192:1;13182:35;;13197:18;;:::i;:::-;13182:35;13239:1;13236;13232:9;13227:14;;13062:185;;;;:::o;13253:180::-;13301:77;13298:1;13291:88;13398:4;13395:1;13388:15;13422:4;13419:1;13412:15

ipfs://d3a9134fd1165ce03736b1b89dd10aaa47800a0212c0baec24722d58832de079