Feature Tip: Add private address tag to any address under My Name Tag !
ERC-20
Gaming
Overview
Max Total Supply
500,000,000 LORDS
Holders
2,036 (0.00%)
Market
Price
$0.05 @ 0.000019 ETH (+0.64%)
Onchain Market Cap
$23,896,580.00
Circulating Supply Market Cap
$7,107,624.00
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|---|---|---|---|---|
1 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7 | $0.0479 0.0000190 Eth | $5,267.04 109,993.273 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 72.9932% |
2 | ![]() | LORDS-USDT | $0.0449 0.0000178 Eth | $4,037.50 88,639.501 LORDS | 58.8225% |
3 | ![]() | 0X686F2404E77AB0D9070A46CDFB0B7FECDD2318B0-0XC02AAA39B223FE8D0A0E5C4F27EAD9083C756CC2 | $0.0505 0.0000201 Eth | $2,764.73 55,256.566 0X686F2404E77AB0D9070A46CDFB0B7FECDD2318B0 | 36.6691% |
4 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7 | $0.0476 0.0000188 Eth | $1,054.24 22,087.811 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 14.6578% |
5 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X4718F5A0FC34CC1AF16A1CDEE98FFB20C31F5CD61D6AB07201858F4287C938D | $0.0475 0.0000189 Eth | $408.39 8,385.665 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 5.5649% |
6 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7 | $0.0473 0.0000187 Eth | $401.51 8,404.287 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 5.5772% |
7 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X53C91253BC9682C04929CA02ED00B3E423F6710D2EE7E0D5EBB06F3ECF368A8 | $0.0471 0.0000187 Eth | $46.09 987.764 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 0.6555% |
8 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X4718F5A0FC34CC1AF16A1CDEE98FFB20C31F5CD61D6AB07201858F4287C938D | $0.0477 0.0000189 Eth | $35.99 736.310 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 0.4886% |
9 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7 | $0.0471 0.0000187 Eth | $2.86 59.904 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 0.0398% |
10 | ![]() | 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49-0X49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7 | $0.0475 0.0000189 Eth | $1.66 34.652 0X124AEB495B947201F5FAC96FD1138E326AD86195B98DF6DEC9009158A533B49 | 0.0230% |
Contract Name:
TheLordsToken
Compiler Version
v0.8.10+commit.fc410830
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/security/Pausable.sol"; contract TheLordsToken is ERC20, ERC20Burnable, ERC20Snapshot, ERC20Capped, Ownable, Pausable { constructor(uint256 _cap) ERC20("Lords", "LORDS") ERC20Capped(_cap) {} function snapshot() public onlyOwner { _snapshot(); } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); } function mint(address to, uint256 amount) public onlyOwner { _mint(to, amount); } function _mint(address account, uint256 amount) internal override(ERC20, ERC20Capped) whenNotPaused { super._mint(account, amount); } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal override(ERC20, ERC20Snapshot) whenNotPaused { super._beforeTokenTransfer(from, to, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; import "../ERC20.sol"; import "../../../utils/Context.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 currentAllowance = allowance(account, _msgSender()); require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance"); unchecked { _approve(account, _msgSender(), currentAllowance - amount); } _burn(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/ERC20Snapshot.sol) pragma solidity ^0.8.0; import "../ERC20.sol"; import "../../../utils/Arrays.sol"; import "../../../utils/Counters.sol"; /** * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and * total supply at the time are recorded for later access. * * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting. * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be * used to create an efficient ERC20 forking mechanism. * * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id * and the account address. * * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it * return `block.number` will trigger the creation of snapshot at the begining of each new block. When overridding this * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract. * * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient * alternative consider {ERC20Votes}. * * ==== Gas Costs * * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much * smaller since identical balances in subsequent snapshots are stored as a single entry. * * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent * transfers will have normal cost until the next snapshot, and so on. */ abstract contract ERC20Snapshot is ERC20 { // Inspired by Jordi Baylina's MiniMeToken to record historical balances: // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol using Arrays for uint256[]; using Counters for Counters.Counter; // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a // Snapshot struct, but that would impede usage of functions that work on an array. struct Snapshots { uint256[] ids; uint256[] values; } mapping(address => Snapshots) private _accountBalanceSnapshots; Snapshots private _totalSupplySnapshots; // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid. Counters.Counter private _currentSnapshotId; /** * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created. */ event Snapshot(uint256 id); /** * @dev Creates a new snapshot and returns its snapshot id. * * Emits a {Snapshot} event that contains the same id. * * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a * set of accounts, for example using {AccessControl}, or it may be open to the public. * * [WARNING] * ==== * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking, * you must consider that it can potentially be used by attackers in two ways. * * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs * section above. * * We haven't measured the actual numbers; if this is something you're interested in please reach out to us. * ==== */ function _snapshot() internal virtual returns (uint256) { _currentSnapshotId.increment(); uint256 currentId = _getCurrentSnapshotId(); emit Snapshot(currentId); return currentId; } /** * @dev Get the current snapshotId */ function _getCurrentSnapshotId() internal view virtual returns (uint256) { return _currentSnapshotId.current(); } /** * @dev Retrieves the balance of `account` at the time `snapshotId` was created. */ function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) { (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]); return snapshotted ? value : balanceOf(account); } /** * @dev Retrieves the total supply at the time `snapshotId` was created. */ function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) { (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots); return snapshotted ? value : totalSupply(); } // Update balance and/or total supply snapshots before the values are modified. This is implemented // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations. function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._beforeTokenTransfer(from, to, amount); if (from == address(0)) { // mint _updateAccountSnapshot(to); _updateTotalSupplySnapshot(); } else if (to == address(0)) { // burn _updateAccountSnapshot(from); _updateTotalSupplySnapshot(); } else { // transfer _updateAccountSnapshot(from); _updateAccountSnapshot(to); } } function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) { require(snapshotId > 0, "ERC20Snapshot: id is 0"); require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id"); // When a valid snapshot is queried, there are three possibilities: // a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never // created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds // to this id is the current one. // b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the // requested id, and its value is the one to return. // c) More snapshots were created after the requested one, and the queried value was later modified. There will be // no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is // larger than the requested one. // // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does // exactly this. uint256 index = snapshots.ids.findUpperBound(snapshotId); if (index == snapshots.ids.length) { return (false, 0); } else { return (true, snapshots.values[index]); } } function _updateAccountSnapshot(address account) private { _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account)); } function _updateTotalSupplySnapshot() private { _updateSnapshot(_totalSupplySnapshots, totalSupply()); } function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private { uint256 currentId = _getCurrentSnapshotId(); if (_lastSnapshotId(snapshots.ids) < currentId) { snapshots.ids.push(currentId); snapshots.values.push(currentValue); } } function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) { if (ids.length == 0) { return 0; } else { return ids[ids.length - 1]; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/ERC20Capped.sol) pragma solidity ^0.8.0; import "../ERC20.sol"; /** * @dev Extension of {ERC20} that adds a cap to the supply of tokens. */ abstract contract ERC20Capped is ERC20 { uint256 private 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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (security/Pausable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
// 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // 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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/Arrays.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @dev Collection of functions related to array types. */ library Arrays { /** * @dev Searches a sorted `array` and returns the first index that contains * a value greater or equal to `element`. If no such index exists (i.e. all * values in the array are strictly less than `element`), the array length is * returned. Time complexity O(log n). * * `array` is expected to be sorted in ascending order, and to contain no * repeated elements. */ function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { if (array.length == 0) { return 0; } uint256 low = 0; uint256 high = array.length; while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds down (it does integer division with truncation). if (array[mid] > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && array[low - 1] == element) { return low - 1; } else { return low; } } }
// SPDX-License-Identifier: MIT // 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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "../shared/interfaces/RealmsToken.sol"; import "../shared/interfaces/LordsToken.sol"; contract Journey is ERC721Holder, Ownable, ReentrancyGuard { event StakeRealms(uint256[] tokenIds, address player); event UnStakeRealms(uint256[] tokenIds, address player); mapping(address => uint256) epochClaimed; mapping(uint256 => address) ownership; mapping(address => mapping(uint256 => uint256)) public realmsStaked; LordsToken lordsToken; RealmsToken realmsToken; // contracts address bridge; // consts uint256 lordsPerRealm; uint256 genesis; uint256 epoch; bool paused; constructor( uint256 _lordsPerRealm, uint256 _epoch, address _realmsAddress, address _lordsToken ) { genesis = block.timestamp; lordsPerRealm = _lordsPerRealm; epoch = _epoch; lordsToken = LordsToken(_lordsToken); realmsToken = RealmsToken(_realmsAddress); paused = false; } /** * @notice Set's Lords issurance in gwei per staked realm */ function lordsIssurance(uint256 _new) external onlyOwner { lordsPerRealm = _new * 10**18; // converted into decimals } function updateRealmsAddress(address _newRealms) external onlyOwner { realmsToken = RealmsToken(_newRealms); } function updateLordsAddress(address _newLords) external onlyOwner { lordsToken = LordsToken(_newLords); } function updateEpochLength(uint256 _newEpoch) external onlyOwner { epoch = _newEpoch; } function setBridge(address _newBridge) external onlyOwner { bridge = _newBridge; } function pauseContract(bool _state) external onlyOwner { paused = _state; } /** * @notice Set's epoch to epoch * 1 hour. */ function _epochNum() internal view returns (uint256) { return (block.timestamp - genesis) / (epoch * 3600); // hours // return 5; } /** * @notice Boards the Ship (Stakes). Sets ownership of Token to Staker. Transfers NFT to Contract. Set's epoch date, Set's number of Realms staked in the Epoch. * @param _tokenIds Ids of Realms */ function boardShip(uint256[] memory _tokenIds) external notPaused nonReentrant { for (uint256 i = 0; i < _tokenIds.length; i++) { require( realmsToken.ownerOf(_tokenIds[i]) == msg.sender, "NOT_OWNER" ); ownership[_tokenIds[i]] = msg.sender; realmsToken.safeTransferFrom( msg.sender, address(this), _tokenIds[i] ); } if (lordsAvailable(msg.sender) == 0) { epochClaimed[msg.sender] = _epochNum(); } realmsStaked[msg.sender][_epochNum()] = realmsStaked[msg.sender][_epochNum()] + uint256(_tokenIds.length); emit StakeRealms(_tokenIds, msg.sender); } /** * @notice Exits Ship, and transfers all Realms back to owner. * @param _tokenIds Ids of Realms */ function exitShip(uint256[] memory _tokenIds) external notPaused nonReentrant { for (uint256 i = 0; i < _tokenIds.length; i++) { require(ownership[_tokenIds[i]] == msg.sender, "NOT_OWNER"); ownership[_tokenIds[i]] = address(0); realmsToken.safeTransferFrom( address(this), msg.sender, _tokenIds[i] ); } realmsStaked[msg.sender][_epochNum()] = realmsStaked[msg.sender][_epochNum()] - uint256(_tokenIds.length); emit UnStakeRealms(_tokenIds, msg.sender); } /** * @notice Claims all available Lords for Owner. */ function claimLords() external notPaused nonReentrant { uint256 totalClaimable; uint256 totalRealms; require(_epochNum() > 1, "GENESIS_epochNum"); // loop over epochs, sum up total claimable staked lords per epoch for (uint256 i = epochClaimed[msg.sender]; i < _epochNum(); i++) { totalRealms += realmsStaked[msg.sender][i]; totalClaimable = totalClaimable + realmsStaked[msg.sender][i] * (_epochNum() - i); } // set totalRealms staked in latest epoch so loop doesn't have to iterate again realmsStaked[msg.sender][_epochNum()] = totalRealms; // set epoch claimed to current epochClaimed[msg.sender] = _epochNum(); require(totalClaimable > 0, "NOTHING_TO_CLAIM"); // available lords * total realms staked per period uint256 lords = lordsPerRealm * totalClaimable; lordsToken.approve(address(this), lords); lordsToken.transferFrom(address(this), msg.sender, lords); } /** * @notice Lords available for the player. */ function lordsAvailable(address _player) public view returns (uint256 lords) { uint256 totalClaimable; for (uint256 i = epochClaimed[_player]; i < _epochNum(); i++) { totalClaimable = totalClaimable + realmsStaked[_player][i] * (_epochNum() - i); } lords = lordsPerRealm * totalClaimable; } /** * @notice Called only by future Bridge contract to withdraw the Realms * @param _tokenIds Ids of Realms */ function bridgeWithdraw(address _player, uint256[] memory _tokenIds) public onlyBridge nonReentrant { for (uint256 i = 0; i < _tokenIds.length; i++) { ownership[_tokenIds[i]] = address(0); realmsToken.safeTransferFrom(address(this), _player, _tokenIds[i]); } realmsStaked[_player][_epochNum()] = realmsStaked[_player][_epochNum()] - uint256(_tokenIds.length); emit UnStakeRealms(_tokenIds, _player); } function withdrawAllLords(address _destination) public onlyOwner { uint256 balance = lordsToken.balanceOf(address(this)); lordsToken.approve(address(this), balance); lordsToken.transferFrom(address(this), _destination, balance); } modifier onlyBridge() { require(msg.sender == bridge, "NOT_THE_BRIDGE"); _; } modifier notPaused() { require(!paused, "PAUSED"); _; } function checkOwner(uint256 _tokenId) public view returns (address) { return ownership[_tokenId]; } function getEpoch() public view returns (uint256) { return _epochNum(); } function getLordsAddress() public view returns (address) { return address(lordsToken); } function getRealmsAddress() public view returns (address) { return address(realmsToken); } function getEpochLength() public view returns (uint256) { return epoch; } function getLordsIssurance() public view returns (uint256) { return lordsPerRealm; } function getNumberRealms(address _player) public view returns (uint256) { uint256 totalRealms; for (uint256 i = epochClaimed[_player]; i <= _epochNum(); i++) { totalRealms += realmsStaked[_player][i]; } return totalRealms; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.0; import "../IERC721Receiver.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}. */ contract ERC721Holder is IERC721Receiver { /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address, address, uint256, bytes memory ) public virtual override returns (bytes4) { return this.onERC721Received.selector; } }
// SPDX-License-Identifier: MIT // 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; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.2; import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface RealmsToken is IERC721Enumerable { }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.2; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; interface LordsToken is IERC20 { function mint(address to, uint256 amount) external; function getAgeDistribution(uint256 _age) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "optimizer": { "enabled": false, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "metadata": { "useLiteralContent": true } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"_cap","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x608060405234801561001057600080fd5b50600436106101585760003560e01c806370a08231116100c35780639711715a1161007c5780639711715a14610391578063981b24d01461039b578063a457c2d7146103cb578063a9059cbb146103fb578063dd62ed3e1461042b578063f2fde38b1461045b57610158565b806370a08231146102f5578063715018a61461032557806379cc67901461032f5780638456cb591461034b5780638da5cb5b1461035557806395d89b411461037357610158565b8063395093511161011557806339509351146102355780633f4ba83a1461026557806340c10f191461026f57806342966c681461028b5780634ee2cd7e146102a75780635c975abb146102d757610158565b806306fdde031461015d578063095ea7b31461017b57806318160ddd146101ab57806323b872dd146101c9578063313ce567146101f9578063355274ea14610217575b600080fd5b610165610477565b6040516101729190611e39565b60405180910390f35b61019560048036038101906101909190611ef4565b610509565b6040516101a29190611f4f565b60405180910390f35b6101b3610527565b6040516101c09190611f79565b60405180910390f35b6101e360048036038101906101de9190611f94565b610531565b6040516101f09190611f4f565b60405180910390f35b610201610629565b60405161020e9190612003565b60405180910390f35b61021f610632565b60405161022c9190611f79565b60405180910390f35b61024f600480360381019061024a9190611ef4565b61065a565b60405161025c9190611f4f565b60405180910390f35b61026d610706565b005b61028960048036038101906102849190611ef4565b61078c565b005b6102a560048036038101906102a0919061201e565b610816565b005b6102c160048036038101906102bc9190611ef4565b61082a565b6040516102ce9190611f79565b60405180910390f35b6102df61089a565b6040516102ec9190611f4f565b60405180910390f35b61030f600480360381019061030a919061204b565b6108b1565b60405161031c9190611f79565b60405180910390f35b61032d6108f9565b005b61034960048036038101906103449190611ef4565b610981565b005b6103536109fc565b005b61035d610a82565b60405161036a9190612087565b60405180910390f35b61037b610aac565b6040516103889190611e39565b60405180910390f35b610399610b3e565b005b6103b560048036038101906103b0919061201e565b610bc5565b6040516103c29190611f79565b60405180910390f35b6103e560048036038101906103e09190611ef4565b610bf6565b6040516103f29190611f4f565b60405180910390f35b61041560048036038101906104109190611ef4565b610ce1565b6040516104229190611f4f565b60405180910390f35b610445600480360381019061044091906120a2565b610cff565b6040516104529190611f79565b60405180910390f35b6104756004803603810190610470919061204b565b610d86565b005b60606003805461048690612111565b80601f01602080910402602001604051908101604052809291908181526020018280546104b290612111565b80156104ff5780601f106104d4576101008083540402835291602001916104ff565b820191906000526020600020905b8154815290600101906020018083116104e257829003601f168201915b5050505050905090565b600061051d610516610e7e565b8484610e86565b6001905092915050565b6000600254905090565b600061053e848484611051565b6000600160008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000610589610e7e565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905082811015610609576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610600906121b5565b60405180910390fd5b61061d85610615610e7e565b858403610e86565b60019150509392505050565b60006012905090565b60007f0000000000000000000000000000000000000000019d971e4fe8401e74000000905090565b60006106fc610667610e7e565b848460016000610675610e7e565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546106f79190612204565b610e86565b6001905092915050565b61070e610e7e565b73ffffffffffffffffffffffffffffffffffffffff1661072c610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610782576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610779906122a6565b60405180910390fd5b61078a6112d2565b565b610794610e7e565b73ffffffffffffffffffffffffffffffffffffffff166107b2610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610808576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ff906122a6565b60405180910390fd5b6108128282611374565b5050565b610827610821610e7e565b826113ca565b50565b600080600061087784600560008873ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206115a1565b915091508161088e57610889856108b1565b610890565b805b9250505092915050565b6000600960149054906101000a900460ff16905090565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b610901610e7e565b73ffffffffffffffffffffffffffffffffffffffff1661091f610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610975576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161096c906122a6565b60405180910390fd5b61097f6000611697565b565b60006109948361098f610e7e565b610cff565b9050818110156109d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109d090612338565b60405180910390fd5b6109ed836109e5610e7e565b848403610e86565b6109f783836113ca565b505050565b610a04610e7e565b73ffffffffffffffffffffffffffffffffffffffff16610a22610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610a78576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a6f906122a6565b60405180910390fd5b610a8061175d565b565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b606060048054610abb90612111565b80601f0160208091040260200160405190810160405280929190818152602001828054610ae790612111565b8015610b345780601f10610b0957610100808354040283529160200191610b34565b820191906000526020600020905b815481529060010190602001808311610b1757829003601f168201915b5050505050905090565b610b46610e7e565b73ffffffffffffffffffffffffffffffffffffffff16610b64610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610bba576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bb1906122a6565b60405180910390fd5b610bc2611800565b50565b6000806000610bd58460066115a1565b9150915081610beb57610be6610527565b610bed565b805b92505050919050565b60008060016000610c05610e7e565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905082811015610cc2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cb9906123ca565b60405180910390fd5b610cd6610ccd610e7e565b85858403610e86565b600191505092915050565b6000610cf5610cee610e7e565b8484611051565b6001905092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b610d8e610e7e565b73ffffffffffffffffffffffffffffffffffffffff16610dac610a82565b73ffffffffffffffffffffffffffffffffffffffff1614610e02576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610df9906122a6565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610e72576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e699061245c565b60405180910390fd5b610e7b81611697565b50565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610ef6576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eed906124ee565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610f66576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f5d90612580565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516110449190611f79565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156110c1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110b890612612565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611131576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611128906126a4565b60405180910390fd5b61113c838383611856565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156111c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111b990612736565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546112559190612204565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516112b99190611f79565b60405180910390a36112cc8484846118ae565b50505050565b6112da61089a565b611319576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611310906127a2565b60405180910390fd5b6000600960146101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa61135d610e7e565b60405161136a9190612087565b60405180910390a1565b61137c61089a565b156113bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113b39061280e565b60405180910390fd5b6113c682826118b3565b5050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561143a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611431906128a0565b60405180910390fd5b61144682600083611856565b60008060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156114cc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114c390612932565b60405180910390fd5b8181036000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600260008282546115239190612952565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516115889190611f79565b60405180910390a361159c836000846118ae565b505050565b600080600084116115e7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115de906129d2565b60405180910390fd5b6115ef61191d565b841115611631576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161162890612a3e565b60405180910390fd5b6000611649858560000161192e90919063ffffffff16565b90508360000180549050811415611667576000809250925050611690565b600184600101828154811061167f5761167e612a5e565b5b906000526020600020015492509250505b9250929050565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61176561089a565b156117a5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161179c9061280e565b60405180910390fd5b6001600960146101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586117e9610e7e565b6040516117f69190612087565b60405180910390a1565b600061180c6008611a08565b600061181661191d565b90507f8030e83b04d87bef53480e26263266d6ca66863aa8506aca6f2559d18aa1cb67816040516118479190611f79565b60405180910390a18091505090565b61185e61089a565b1561189e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118959061280e565b60405180910390fd5b6118a9838383611a1e565b505050565b505050565b6118bb610632565b816118c4610527565b6118ce9190612204565b111561190f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161190690612ad9565b60405180910390fd5b6119198282611ad8565b5050565b60006119296008611c38565b905090565b600080838054905014156119455760009050611a02565b600080848054905090505b808210156119a95760006119648383611c46565b90508486828154811061197a57611979612a5e565b5b90600052602060002001541115611993578091506119a3565b6001816119a09190612204565b92505b50611950565b6000821180156119e1575083856001846119c39190612952565b815481106119d4576119d3612a5e565b5b9060005260206000200154145b156119fc576001826119f39190612952565b92505050611a02565b81925050505b92915050565b6001816000016000828254019250508190555050565b611a29838383611c6c565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611a7457611a6782611c71565b611a6f611cc4565b611ad3565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611abf57611ab283611c71565b611aba611cc4565b611ad2565b611ac883611c71565b611ad182611c71565b5b5b505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611b48576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b3f90612b45565b60405180910390fd5b611b5460008383611856565b8060026000828254611b669190612204565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254611bbb9190612204565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051611c209190611f79565b60405180910390a3611c34600083836118ae565b5050565b600081600001549050919050565b60006002828418611c579190612b94565b828416611c649190612204565b905092915050565b505050565b611cc1600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020611cbc836108b1565b611cd8565b50565b611cd66006611cd1610527565b611cd8565b565b6000611ce261191d565b905080611cf184600001611d53565b1015611d4e5782600001819080600181540180825580915050600190039060005260206000200160009091909190915055826001018290806001815401808255809150506001900390600052602060002001600090919091909150555b505050565b60008082805490501415611d6a5760009050611d9b565b8160018380549050611d7c9190612952565b81548110611d8d57611d8c612a5e565b5b906000526020600020015490505b919050565b600081519050919050565b600082825260208201905092915050565b60005b83811015611dda578082015181840152602081019050611dbf565b83811115611de9576000848401525b50505050565b6000601f19601f8301169050919050565b6000611e0b82611da0565b611e158185611dab565b9350611e25818560208601611dbc565b611e2e81611def565b840191505092915050565b60006020820190508181036000830152611e538184611e00565b905092915050565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000611e8b82611e60565b9050919050565b611e9b81611e80565b8114611ea657600080fd5b50565b600081359050611eb881611e92565b92915050565b6000819050919050565b611ed181611ebe565b8114611edc57600080fd5b50565b600081359050611eee81611ec8565b92915050565b60008060408385031215611f0b57611f0a611e5b565b5b6000611f1985828601611ea9565b9250506020611f2a85828601611edf565b9150509250929050565b60008115159050919050565b611f4981611f34565b82525050565b6000602082019050611f646000830184611f40565b92915050565b611f7381611ebe565b82525050565b6000602082019050611f8e6000830184611f6a565b92915050565b600080600060608486031215611fad57611fac611e5b565b5b6000611fbb86828701611ea9565b9350506020611fcc86828701611ea9565b9250506040611fdd86828701611edf565b9150509250925092565b600060ff82169050919050565b611ffd81611fe7565b82525050565b60006020820190506120186000830184611ff4565b92915050565b60006020828403121561203457612033611e5b565b5b600061204284828501611edf565b91505092915050565b60006020828403121561206157612060611e5b565b5b600061206f84828501611ea9565b91505092915050565b61208181611e80565b82525050565b600060208201905061209c6000830184612078565b92915050565b600080604083850312156120b9576120b8611e5b565b5b60006120c785828601611ea9565b92505060206120d885828601611ea9565b9150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6000600282049050600182168061212957607f821691505b6020821081141561213d5761213c6120e2565b5b50919050565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206160008201527f6c6c6f77616e6365000000000000000000000000000000000000000000000000602082015250565b600061219f602883611dab565b91506121aa82612143565b604082019050919050565b600060208201905081810360008301526121ce81612192565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061220f82611ebe565b915061221a83611ebe565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561224f5761224e6121d5565b5b828201905092915050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000612290602083611dab565b915061229b8261225a565b602082019050919050565b600060208201905081810360008301526122bf81612283565b9050919050565b7f45524332303a206275726e20616d6f756e74206578636565647320616c6c6f7760008201527f616e636500000000000000000000000000000000000000000000000000000000602082015250565b6000612322602483611dab565b915061232d826122c6565b604082019050919050565b6000602082019050818103600083015261235181612315565b9050919050565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b60006123b4602583611dab565b91506123bf82612358565b604082019050919050565b600060208201905081810360008301526123e3816123a7565b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b6000612446602683611dab565b9150612451826123ea565b604082019050919050565b6000602082019050818103600083015261247581612439565b9050919050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b60006124d8602483611dab565b91506124e38261247c565b604082019050919050565b60006020820190508181036000830152612507816124cb565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b600061256a602283611dab565b91506125758261250e565b604082019050919050565b600060208201905081810360008301526125998161255d565b9050919050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b60006125fc602583611dab565b9150612607826125a0565b604082019050919050565b6000602082019050818103600083015261262b816125ef565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b600061268e602383611dab565b915061269982612632565b604082019050919050565b600060208201905081810360008301526126bd81612681565b9050919050565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b6000612720602683611dab565b915061272b826126c4565b604082019050919050565b6000602082019050818103600083015261274f81612713565b9050919050565b7f5061757361626c653a206e6f7420706175736564000000000000000000000000600082015250565b600061278c601483611dab565b915061279782612756565b602082019050919050565b600060208201905081810360008301526127bb8161277f565b9050919050565b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b60006127f8601083611dab565b9150612803826127c2565b602082019050919050565b60006020820190508181036000830152612827816127eb565b9050919050565b7f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360008201527f7300000000000000000000000000000000000000000000000000000000000000602082015250565b600061288a602183611dab565b91506128958261282e565b604082019050919050565b600060208201905081810360008301526128b98161287d565b9050919050565b7f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60008201527f6365000000000000000000000000000000000000000000000000000000000000602082015250565b600061291c602283611dab565b9150612927826128c0565b604082019050919050565b6000602082019050818103600083015261294b8161290f565b9050919050565b600061295d82611ebe565b915061296883611ebe565b92508282101561297b5761297a6121d5565b5b828203905092915050565b7f4552433230536e617073686f743a206964206973203000000000000000000000600082015250565b60006129bc601683611dab565b91506129c782612986565b602082019050919050565b600060208201905081810360008301526129eb816129af565b9050919050565b7f4552433230536e617073686f743a206e6f6e6578697374656e74206964000000600082015250565b6000612a28601d83611dab565b9150612a33826129f2565b602082019050919050565b60006020820190508181036000830152612a5781612a1b565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f45524332304361707065643a2063617020657863656564656400000000000000600082015250565b6000612ac3601983611dab565b9150612ace82612a8d565b602082019050919050565b60006020820190508181036000830152612af281612ab6565b9050919050565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6000612b2f601f83611dab565b9150612b3a82612af9565b602082019050919050565b60006020820190508181036000830152612b5e81612b22565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000612b9f82611ebe565b9150612baa83611ebe565b925082612bba57612bb9612b65565b5b82820490509291505056fea2646970667358221220094cfd4abee7d7daa66b1155fd9cf92945f3ae521d7a46decb6f9d8e2721f53164736f6c634300080a0033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000019d971e4fe8401e74000000
-----Decoded View---------------
Arg [0] : _cap (uint256): 500000000000000000000000000
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000019d971e4fe8401e74000000
Deployed Bytecode Sourcemap
447:902:21:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2141:98:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4238:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3229:106;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4871:478;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3078:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;635:81:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5744:212:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;783:63:21;;;:::i;:::-;;852:93;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;563:89:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4983:262:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1098:84:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3393:125:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1668:101:0;;;:::i;:::-;;958:361:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;718:59:21;;;:::i;:::-;;1036:85:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2352:102:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;647:65:21;;;:::i;:::-;;5344:230:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6443:405:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3721:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3951:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1918:198:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2141:98:3;2195:13;2227:5;2220:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2141:98;:::o;4238:166::-;4321:4;4337:39;4346:12;:10;:12::i;:::-;4360:7;4369:6;4337:8;:39::i;:::-;4393:4;4386:11;;4238:166;;;;:::o;3229:106::-;3290:7;3316:12;;3309:19;;3229:106;:::o;4871:478::-;5007:4;5023:36;5033:6;5041:9;5052:6;5023:9;:36::i;:::-;5070:24;5097:11;:19;5109:6;5097:19;;;;;;;;;;;;;;;:33;5117:12;:10;:12::i;:::-;5097:33;;;;;;;;;;;;;;;;5070:60;;5168:6;5148:16;:26;;5140:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;5253:57;5262:6;5270:12;:10;:12::i;:::-;5303:6;5284:16;:25;5253:8;:57::i;:::-;5338:4;5331:11;;;4871:478;;;;;:::o;3078:91::-;3136:5;3160:2;3153:9;;3078:91;:::o;635:81:6:-;679:7;705:4;698:11;;635:81;:::o;5744:212:3:-;5832:4;5848:80;5857:12;:10;:12::i;:::-;5871:7;5917:10;5880:11;:25;5892:12;:10;:12::i;:::-;5880:25;;;;;;;;;;;;;;;:34;5906:7;5880:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5848:8;:80::i;:::-;5945:4;5938:11;;5744:212;;;;:::o;783:63:21:-;1259:12:0;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;829:10:21::1;:8;:10::i;:::-;783:63::o:0;852:93::-;1259:12:0;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;921:17:21::1;927:2;931:6;921:5;:17::i;:::-;852:93:::0;;:::o;563:89:5:-;618:27;624:12;:10;:12::i;:::-;638:6;618:5;:27::i;:::-;563:89;:::o;4983:262:7:-;5070:7;5090:16;5108:13;5125:55;5134:10;5146:24;:33;5171:7;5146:33;;;;;;;;;;;;;;;5125:8;:55::i;:::-;5089:91;;;;5198:11;:40;;5220:18;5230:7;5220:9;:18::i;:::-;5198:40;;;5212:5;5198:40;5191:47;;;;4983:262;;;;:::o;1098:84:1:-;1145:4;1168:7;;;;;;;;;;;1161:14;;1098:84;:::o;3393:125:3:-;3467:7;3493:9;:18;3503:7;3493:18;;;;;;;;;;;;;;;;3486:25;;3393:125;;;:::o;1668:101:0:-;1259:12;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1732:30:::1;1759:1;1732:18;:30::i;:::-;1668:101::o:0;958:361:5:-;1034:24;1061:32;1071:7;1080:12;:10;:12::i;:::-;1061:9;:32::i;:::-;1034:59;;1131:6;1111:16;:26;;1103:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;1212:58;1221:7;1230:12;:10;:12::i;:::-;1263:6;1244:16;:25;1212:8;:58::i;:::-;1290:22;1296:7;1305:6;1290:5;:22::i;:::-;1024:295;958:361;;:::o;718:59:21:-;1259:12:0;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;762:8:21::1;:6;:8::i;:::-;718:59::o:0;1036:85:0:-;1082:7;1108:6;;;;;;;;;;;1101:13;;1036:85;:::o;2352:102:3:-;2408:13;2440:7;2433:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2352:102;:::o;647:65:21:-;1259:12:0;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;694:11:21::1;:9;:11::i;:::-;;647:65::o:0;5344:230:7:-;5416:7;5436:16;5454:13;5471:43;5480:10;5492:21;5471:8;:43::i;:::-;5435:79;;;;5532:11;:35;;5554:13;:11;:13::i;:::-;5532:35;;;5546:5;5532:35;5525:42;;;;5344:230;;;:::o;6443:405:3:-;6536:4;6552:24;6579:11;:25;6591:12;:10;:12::i;:::-;6579:25;;;;;;;;;;;;;;;:34;6605:7;6579:34;;;;;;;;;;;;;;;;6552:61;;6651:15;6631:16;:35;;6623:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;6742:67;6751:12;:10;:12::i;:::-;6765:7;6793:15;6774:16;:34;6742:8;:67::i;:::-;6837:4;6830:11;;;6443:405;;;;:::o;3721:172::-;3807:4;3823:42;3833:12;:10;:12::i;:::-;3847:9;3858:6;3823:9;:42::i;:::-;3882:4;3875:11;;3721:172;;;;:::o;3951:149::-;4040:7;4066:11;:18;4078:5;4066:18;;;;;;;;;;;;;;;:27;4085:7;4066:27;;;;;;;;;;;;;;;;4059:34;;3951:149;;;;:::o;1918:198:0:-;1259:12;:10;:12::i;:::-;1248:23;;:7;:5;:7::i;:::-;:23;;;1240:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2026:1:::1;2006:22;;:8;:22;;;;1998:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2081:28;2100:8;2081:18;:28::i;:::-;1918:198:::0;:::o;640:96:14:-;693:7;719:10;712:17;;640:96;:::o;10019:370:3:-;10167:1;10150:19;;:5;:19;;;;10142:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10247:1;10228:21;;:7;:21;;;;10220:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10329:6;10299:11;:18;10311:5;10299:18;;;;;;;;;;;;;;;:27;10318:7;10299:27;;;;;;;;;;;;;;;:36;;;;10366:7;10350:32;;10359:5;10350:32;;;10375:6;10350:32;;;;;;:::i;:::-;;;;;;;;10019:370;;;:::o;7322:713::-;7475:1;7457:20;;:6;:20;;;;7449:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;7558:1;7537:23;;:9;:23;;;;7529:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;7611:47;7632:6;7640:9;7651:6;7611:20;:47::i;:::-;7669:21;7693:9;:17;7703:6;7693:17;;;;;;;;;;;;;;;;7669:41;;7745:6;7728:13;:23;;7720:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7864:6;7848:13;:22;7828:9;:17;7838:6;7828:17;;;;;;;;;;;;;;;:42;;;;7914:6;7890:9;:20;7900:9;7890:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;7953:9;7936:35;;7945:6;7936:35;;;7964:6;7936:35;;;;;;:::i;:::-;;;;;;;;7982:46;8002:6;8010:9;8021:6;7982:19;:46::i;:::-;7439:596;7322:713;;;:::o;2110:117:1:-;1677:8;:6;:8::i;:::-;1669:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;2178:5:::1;2168:7;;:15;;;;;;;;;;;;;;;;;;2198:22;2207:12;:10;:12::i;:::-;2198:22;;;;;;:::i;:::-;;;;;;;;2110:117::o:0;951:173:21:-;1412:8:1;:6;:8::i;:::-;1411:9;1403:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1089:28:21::1;1101:7;1110:6;1089:11;:28::i;:::-;951:173:::0;;:::o;9020:576:3:-;9122:1;9103:21;;:7;:21;;;;9095:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;9173:49;9194:7;9211:1;9215:6;9173:20;:49::i;:::-;9233:22;9258:9;:18;9268:7;9258:18;;;;;;;;;;;;;;;;9233:43;;9312:6;9294:14;:24;;9286:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;9429:6;9412:14;:23;9391:9;:18;9401:7;9391:18;;;;;;;;;;;;;;;:44;;;;9471:6;9455:12;;:22;;;;;;;:::i;:::-;;;;;;;;9519:1;9493:37;;9502:7;9493:37;;;9523:6;9493:37;;;;;;:::i;:::-;;;;;;;;9541:48;9561:7;9578:1;9582:6;9541:19;:48::i;:::-;9085:511;9020:576;;:::o;6395:1594:7:-;6484:4;6490:7;6530:1;6517:10;:14;6509:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;6590:23;:21;:23::i;:::-;6576:10;:37;;6568:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;7770:13;7786:40;7815:10;7786:9;:13;;:28;;:40;;;;:::i;:::-;7770:56;;7850:9;:13;;:20;;;;7841:5;:29;7837:146;;;7894:5;7901:1;7886:17;;;;;;;7837:146;7942:4;7948:9;:16;;7965:5;7948:23;;;;;;;;:::i;:::-;;;;;;;;;;7934:38;;;;;6395:1594;;;;;;:::o;2270:187:0:-;2343:16;2362:6;;;;;;;;;;;2343:25;;2387:8;2378:6;;:17;;;;;;;;;;;;;;;;;;2441:8;2410:40;;2431:8;2410:40;;;;;;;;;;;;2333:124;2270:187;:::o;1863:115:1:-;1412:8;:6;:8::i;:::-;1411:9;1403:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1932:4:::1;1922:7;;:14;;;;;;;;;;;;;;;;;;1951:20;1958:12;:10;:12::i;:::-;1951:20;;;;;;:::i;:::-;;;;;;;;1863:115::o:0;4473:217:7:-;4520:7;4539:30;:18;:28;:30::i;:::-;4580:17;4600:23;:21;:23::i;:::-;4580:43;;4638:19;4647:9;4638:19;;;;;;:::i;:::-;;;;;;;;4674:9;4667:16;;;4473:217;:::o;1130::21:-;1412:8:1;:6;:8::i;:::-;1411:9;1403:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1296:44:21::1;1323:4;1329:2;1333:6;1296:26;:44::i;:::-;1130:217:::0;;;:::o;11682:120:3:-;;;;:::o;769:204:6:-;893:5;:3;:5::i;:::-;883:6;861:19;:17;:19::i;:::-;:28;;;;:::i;:::-;:37;;853:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;938:28;950:7;959:6;938:11;:28::i;:::-;769:204;;:::o;4751:125:7:-;4815:7;4841:28;:18;:26;:28::i;:::-;4834:35;;4751:125;:::o;634:892:13:-;723:7;762:1;746:5;:12;;;;:17;742:56;;;786:1;779:8;;;;742:56;808:11;833:12;848:5;:12;;;;833:27;;871:414;884:4;878:3;:10;871:414;;;904:11;918:23;931:3;936:4;918:12;:23::i;:::-;904:37;;1171:7;1158:5;1164:3;1158:10;;;;;;;;:::i;:::-;;;;;;;;;;:20;1154:121;;;1205:3;1198:10;;1154:121;;;1259:1;1253:3;:7;;;;:::i;:::-;1247:13;;1154:121;890:395;871:414;;;1408:1;1402:3;:7;:36;;;;;1431:7;1413:5;1425:1;1419:3;:7;;;;:::i;:::-;1413:14;;;;;;;;:::i;:::-;;;;;;;;;;:25;1402:36;1398:122;;;1467:1;1461:3;:7;;;;:::i;:::-;1454:14;;;;;;1398:122;1506:3;1499:10;;;;634:892;;;;;:::o;945:123:15:-;1050:1;1032:7;:14;;;:19;;;;;;;;;;;945:123;:::o;5787:602:7:-;5925:44;5952:4;5958:2;5962:6;5925:26;:44::i;:::-;6000:1;5984:18;;:4;:18;;;5980:403;;;6038:26;6061:2;6038:22;:26::i;:::-;6078:28;:26;:28::i;:::-;5980:403;;;6141:1;6127:16;;:2;:16;;;6123:260;;;6179:28;6202:4;6179:22;:28::i;:::-;6221;:26;:28::i;:::-;6123:260;;;6304:28;6327:4;6304:22;:28::i;:::-;6346:26;6369:2;6346:22;:26::i;:::-;6123:260;5980:403;5787:602;;;:::o;8311:389:3:-;8413:1;8394:21;;:7;:21;;;;8386:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;8462:49;8491:1;8495:7;8504:6;8462:20;:49::i;:::-;8538:6;8522:12;;:22;;;;;;;:::i;:::-;;;;;;;;8576:6;8554:9;:18;8564:7;8554:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;8618:7;8597:37;;8614:1;8597:37;;;8627:6;8597:37;;;;;;:::i;:::-;;;;;;;;8645:48;8673:1;8677:7;8686:6;8645:19;:48::i;:::-;8311:389;;:::o;827:112:15:-;892:7;918;:14;;;911:21;;827:112;;;:::o;663:153:17:-;725:7;808:1;803;799;:5;798:11;;;;:::i;:::-;793:1;789;:5;788:21;;;;:::i;:::-;781:28;;663:153;;;;:::o;10973:121:3:-;;;;:::o;7995:144:7:-;8062:70;8078:24;:33;8103:7;8078:33;;;;;;;;;;;;;;;8113:18;8123:7;8113:9;:18::i;:::-;8062:15;:70::i;:::-;7995:144;:::o;8145:116::-;8201:53;8217:21;8240:13;:11;:13::i;:::-;8201:15;:53::i;:::-;8145:116::o;8267:304::-;8361:17;8381:23;:21;:23::i;:::-;8361:43;;8451:9;8418:30;8434:9;:13;;8418:15;:30::i;:::-;:42;8414:151;;;8476:9;:13;;8495:9;8476:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8519:9;:16;;8541:12;8519:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8414:151;8351:220;8267:304;;:::o;8577:206::-;8647:7;8684:1;8670:3;:10;;;;:15;8666:111;;;8708:1;8701:8;;;;8666:111;8747:3;8764:1;8751:3;:10;;;;:14;;;;:::i;:::-;8747:19;;;;;;;;:::i;:::-;;;;;;;;;;8740:26;;8577:206;;;;:::o;7:99:22:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:307::-;355:1;365:113;379:6;376:1;373:13;365:113;;;464:1;459:3;455:11;449:18;445:1;440:3;436:11;429:39;401:2;398:1;394:10;389:15;;365:113;;;496:6;493:1;490:13;487:101;;;576:1;567:6;562:3;558:16;551:27;487:101;336:258;287:307;;;:::o;600:102::-;641:6;692:2;688:7;683:2;676:5;672:14;668:28;658:38;;600:102;;;:::o;708:364::-;796:3;824:39;857:5;824:39;:::i;:::-;879:71;943:6;938:3;879:71;:::i;:::-;872:78;;959:52;1004:6;999:3;992:4;985:5;981:16;959:52;:::i;:::-;1036:29;1058:6;1036:29;:::i;:::-;1031:3;1027:39;1020:46;;800:272;708:364;;;;:::o;1078:313::-;1191:4;1229:2;1218:9;1214:18;1206:26;;1278:9;1272:4;1268:20;1264:1;1253:9;1249:17;1242:47;1306:78;1379:4;1370:6;1306:78;:::i;:::-;1298:86;;1078:313;;;;:::o;1478:117::-;1587:1;1584;1577:12;1724:126;1761:7;1801:42;1794:5;1790:54;1779:65;;1724:126;;;:::o;1856:96::-;1893:7;1922:24;1940:5;1922:24;:::i;:::-;1911:35;;1856:96;;;:::o;1958:122::-;2031:24;2049:5;2031:24;:::i;:::-;2024:5;2021:35;2011:63;;2070:1;2067;2060:12;2011:63;1958:122;:::o;2086:139::-;2132:5;2170:6;2157:20;2148:29;;2186:33;2213:5;2186:33;:::i;:::-;2086:139;;;;:::o;2231:77::-;2268:7;2297:5;2286:16;;2231:77;;;:::o;2314:122::-;2387:24;2405:5;2387:24;:::i;:::-;2380:5;2377:35;2367:63;;2426:1;2423;2416:12;2367:63;2314:122;:::o;2442:139::-;2488:5;2526:6;2513:20;2504:29;;2542:33;2569:5;2542:33;:::i;:::-;2442:139;;;;:::o;2587:474::-;2655:6;2663;2712:2;2700:9;2691:7;2687:23;2683:32;2680:119;;;2718:79;;:::i;:::-;2680:119;2838:1;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;:::i;:::-;2853:63;;2809:117;2965:2;2991:53;3036:7;3027:6;3016:9;3012:22;2991:53;:::i;:::-;2981:63;;2936:118;2587:474;;;;;:::o;3067:90::-;3101:7;3144:5;3137:13;3130:21;3119:32;;3067:90;;;:::o;3163:109::-;3244:21;3259:5;3244:21;:::i;:::-;3239:3;3232:34;3163:109;;:::o;3278:210::-;3365:4;3403:2;3392:9;3388:18;3380:26;;3416:65;3478:1;3467:9;3463:17;3454:6;3416:65;:::i;:::-;3278:210;;;;:::o;3494:118::-;3581:24;3599:5;3581:24;:::i;:::-;3576:3;3569:37;3494:118;;:::o;3618:222::-;3711:4;3749:2;3738:9;3734:18;3726:26;;3762:71;3830:1;3819:9;3815:17;3806:6;3762:71;:::i;:::-;3618:222;;;;:::o;3846:619::-;3923:6;3931;3939;3988:2;3976:9;3967:7;3963:23;3959:32;3956:119;;;3994:79;;:::i;:::-;3956:119;4114:1;4139:53;4184:7;4175:6;4164:9;4160:22;4139:53;:::i;:::-;4129:63;;4085:117;4241:2;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4212:118;4369:2;4395:53;4440:7;4431:6;4420:9;4416:22;4395:53;:::i;:::-;4385:63;;4340:118;3846:619;;;;;:::o;4471:86::-;4506:7;4546:4;4539:5;4535:16;4524:27;;4471:86;;;:::o;4563:112::-;4646:22;4662:5;4646:22;:::i;:::-;4641:3;4634:35;4563:112;;:::o;4681:214::-;4770:4;4808:2;4797:9;4793:18;4785:26;;4821:67;4885:1;4874:9;4870:17;4861:6;4821:67;:::i;:::-;4681:214;;;;:::o;4901:329::-;4960:6;5009:2;4997:9;4988:7;4984:23;4980:32;4977:119;;;5015:79;;:::i;:::-;4977:119;5135:1;5160:53;5205:7;5196:6;5185:9;5181:22;5160:53;:::i;:::-;5150:63;;5106:117;4901:329;;;;:::o;5236:::-;5295:6;5344:2;5332:9;5323:7;5319:23;5315:32;5312:119;;;5350:79;;:::i;:::-;5312:119;5470:1;5495:53;5540:7;5531:6;5520:9;5516:22;5495:53;:::i;:::-;5485:63;;5441:117;5236:329;;;;:::o;5571:118::-;5658:24;5676:5;5658:24;:::i;:::-;5653:3;5646:37;5571:118;;:::o;5695:222::-;5788:4;5826:2;5815:9;5811:18;5803:26;;5839:71;5907:1;5896:9;5892:17;5883:6;5839:71;:::i;:::-;5695:222;;;;:::o;5923:474::-;5991:6;5999;6048:2;6036:9;6027:7;6023:23;6019:32;6016:119;;;6054:79;;:::i;:::-;6016:119;6174:1;6199:53;6244:7;6235:6;6224:9;6220:22;6199:53;:::i;:::-;6189:63;;6145:117;6301:2;6327:53;6372:7;6363:6;6352:9;6348:22;6327:53;:::i;:::-;6317:63;;6272:118;5923:474;;;;;:::o;6403:180::-;6451:77;6448:1;6441:88;6548:4;6545:1;6538:15;6572:4;6569:1;6562:15;6589:320;6633:6;6670:1;6664:4;6660:12;6650:22;;6717:1;6711:4;6707:12;6738:18;6728:81;;6794:4;6786:6;6782:17;6772:27;;6728:81;6856:2;6848:6;6845:14;6825:18;6822:38;6819:84;;;6875:18;;:::i;:::-;6819:84;6640:269;6589:320;;;:::o;6915:227::-;7055:34;7051:1;7043:6;7039:14;7032:58;7124:10;7119:2;7111:6;7107:15;7100:35;6915:227;:::o;7148:366::-;7290:3;7311:67;7375:2;7370:3;7311:67;:::i;:::-;7304:74;;7387:93;7476:3;7387:93;:::i;:::-;7505:2;7500:3;7496:12;7489:19;;7148:366;;;:::o;7520:419::-;7686:4;7724:2;7713:9;7709:18;7701:26;;7773:9;7767:4;7763:20;7759:1;7748:9;7744:17;7737:47;7801:131;7927:4;7801:131;:::i;:::-;7793:139;;7520:419;;;:::o;7945:180::-;7993:77;7990:1;7983:88;8090:4;8087:1;8080:15;8114:4;8111:1;8104:15;8131:305;8171:3;8190:20;8208:1;8190:20;:::i;:::-;8185:25;;8224:20;8242:1;8224:20;:::i;:::-;8219:25;;8378:1;8310:66;8306:74;8303:1;8300:81;8297:107;;;8384:18;;:::i;:::-;8297:107;8428:1;8425;8421:9;8414:16;;8131:305;;;;:::o;8442:182::-;8582:34;8578:1;8570:6;8566:14;8559:58;8442:182;:::o;8630:366::-;8772:3;8793:67;8857:2;8852:3;8793:67;:::i;:::-;8786:74;;8869:93;8958:3;8869:93;:::i;:::-;8987:2;8982:3;8978:12;8971:19;;8630:366;;;:::o;9002:419::-;9168:4;9206:2;9195:9;9191:18;9183:26;;9255:9;9249:4;9245:20;9241:1;9230:9;9226:17;9219:47;9283:131;9409:4;9283:131;:::i;:::-;9275:139;;9002:419;;;:::o;9427:223::-;9567:34;9563:1;9555:6;9551:14;9544:58;9636:6;9631:2;9623:6;9619:15;9612:31;9427:223;:::o;9656:366::-;9798:3;9819:67;9883:2;9878:3;9819:67;:::i;:::-;9812:74;;9895:93;9984:3;9895:93;:::i;:::-;10013:2;10008:3;10004:12;9997:19;;9656:366;;;:::o;10028:419::-;10194:4;10232:2;10221:9;10217:18;10209:26;;10281:9;10275:4;10271:20;10267:1;10256:9;10252:17;10245:47;10309:131;10435:4;10309:131;:::i;:::-;10301:139;;10028:419;;;:::o;10453:224::-;10593:34;10589:1;10581:6;10577:14;10570:58;10662:7;10657:2;10649:6;10645:15;10638:32;10453:224;:::o;10683:366::-;10825:3;10846:67;10910:2;10905:3;10846:67;:::i;:::-;10839:74;;10922:93;11011:3;10922:93;:::i;:::-;11040:2;11035:3;11031:12;11024:19;;10683:366;;;:::o;11055:419::-;11221:4;11259:2;11248:9;11244:18;11236:26;;11308:9;11302:4;11298:20;11294:1;11283:9;11279:17;11272:47;11336:131;11462:4;11336:131;:::i;:::-;11328:139;;11055:419;;;:::o;11480:225::-;11620:34;11616:1;11608:6;11604:14;11597:58;11689:8;11684:2;11676:6;11672:15;11665:33;11480:225;:::o;11711:366::-;11853:3;11874:67;11938:2;11933:3;11874:67;:::i;:::-;11867:74;;11950:93;12039:3;11950:93;:::i;:::-;12068:2;12063:3;12059:12;12052:19;;11711:366;;;:::o;12083:419::-;12249:4;12287:2;12276:9;12272:18;12264:26;;12336:9;12330:4;12326:20;12322:1;12311:9;12307:17;12300:47;12364:131;12490:4;12364:131;:::i;:::-;12356:139;;12083:419;;;:::o;12508:223::-;12648:34;12644:1;12636:6;12632:14;12625:58;12717:6;12712:2;12704:6;12700:15;12693:31;12508:223;:::o;12737:366::-;12879:3;12900:67;12964:2;12959:3;12900:67;:::i;:::-;12893:74;;12976:93;13065:3;12976:93;:::i;:::-;13094:2;13089:3;13085:12;13078:19;;12737:366;;;:::o;13109:419::-;13275:4;13313:2;13302:9;13298:18;13290:26;;13362:9;13356:4;13352:20;13348:1;13337:9;13333:17;13326:47;13390:131;13516:4;13390:131;:::i;:::-;13382:139;;13109:419;;;:::o;13534:221::-;13674:34;13670:1;13662:6;13658:14;13651:58;13743:4;13738:2;13730:6;13726:15;13719:29;13534:221;:::o;13761:366::-;13903:3;13924:67;13988:2;13983:3;13924:67;:::i;:::-;13917:74;;14000:93;14089:3;14000:93;:::i;:::-;14118:2;14113:3;14109:12;14102:19;;13761:366;;;:::o;14133:419::-;14299:4;14337:2;14326:9;14322:18;14314:26;;14386:9;14380:4;14376:20;14372:1;14361:9;14357:17;14350:47;14414:131;14540:4;14414:131;:::i;:::-;14406:139;;14133:419;;;:::o;14558:224::-;14698:34;14694:1;14686:6;14682:14;14675:58;14767:7;14762:2;14754:6;14750:15;14743:32;14558:224;:::o;14788:366::-;14930:3;14951:67;15015:2;15010:3;14951:67;:::i;:::-;14944:74;;15027:93;15116:3;15027:93;:::i;:::-;15145:2;15140:3;15136:12;15129:19;;14788:366;;;:::o;15160:419::-;15326:4;15364:2;15353:9;15349:18;15341:26;;15413:9;15407:4;15403:20;15399:1;15388:9;15384:17;15377:47;15441:131;15567:4;15441:131;:::i;:::-;15433:139;;15160:419;;;:::o;15585:222::-;15725:34;15721:1;15713:6;15709:14;15702:58;15794:5;15789:2;15781:6;15777:15;15770:30;15585:222;:::o;15813:366::-;15955:3;15976:67;16040:2;16035:3;15976:67;:::i;:::-;15969:74;;16052:93;16141:3;16052:93;:::i;:::-;16170:2;16165:3;16161:12;16154:19;;15813:366;;;:::o;16185:419::-;16351:4;16389:2;16378:9;16374:18;16366:26;;16438:9;16432:4;16428:20;16424:1;16413:9;16409:17;16402:47;16466:131;16592:4;16466:131;:::i;:::-;16458:139;;16185:419;;;:::o;16610:225::-;16750:34;16746:1;16738:6;16734:14;16727:58;16819:8;16814:2;16806:6;16802:15;16795:33;16610:225;:::o;16841:366::-;16983:3;17004:67;17068:2;17063:3;17004:67;:::i;:::-;16997:74;;17080:93;17169:3;17080:93;:::i;:::-;17198:2;17193:3;17189:12;17182:19;;16841:366;;;:::o;17213:419::-;17379:4;17417:2;17406:9;17402:18;17394:26;;17466:9;17460:4;17456:20;17452:1;17441:9;17437:17;17430:47;17494:131;17620:4;17494:131;:::i;:::-;17486:139;;17213:419;;;:::o;17638:170::-;17778:22;17774:1;17766:6;17762:14;17755:46;17638:170;:::o;17814:366::-;17956:3;17977:67;18041:2;18036:3;17977:67;:::i;:::-;17970:74;;18053:93;18142:3;18053:93;:::i;:::-;18171:2;18166:3;18162:12;18155:19;;17814:366;;;:::o;18186:419::-;18352:4;18390:2;18379:9;18375:18;18367:26;;18439:9;18433:4;18429:20;18425:1;18414:9;18410:17;18403:47;18467:131;18593:4;18467:131;:::i;:::-;18459:139;;18186:419;;;:::o;18611:166::-;18751:18;18747:1;18739:6;18735:14;18728:42;18611:166;:::o;18783:366::-;18925:3;18946:67;19010:2;19005:3;18946:67;:::i;:::-;18939:74;;19022:93;19111:3;19022:93;:::i;:::-;19140:2;19135:3;19131:12;19124:19;;18783:366;;;:::o;19155:419::-;19321:4;19359:2;19348:9;19344:18;19336:26;;19408:9;19402:4;19398:20;19394:1;19383:9;19379:17;19372:47;19436:131;19562:4;19436:131;:::i;:::-;19428:139;;19155:419;;;:::o;19580:220::-;19720:34;19716:1;19708:6;19704:14;19697:58;19789:3;19784:2;19776:6;19772:15;19765:28;19580:220;:::o;19806:366::-;19948:3;19969:67;20033:2;20028:3;19969:67;:::i;:::-;19962:74;;20045:93;20134:3;20045:93;:::i;:::-;20163:2;20158:3;20154:12;20147:19;;19806:366;;;:::o;20178:419::-;20344:4;20382:2;20371:9;20367:18;20359:26;;20431:9;20425:4;20421:20;20417:1;20406:9;20402:17;20395:47;20459:131;20585:4;20459:131;:::i;:::-;20451:139;;20178:419;;;:::o;20603:221::-;20743:34;20739:1;20731:6;20727:14;20720:58;20812:4;20807:2;20799:6;20795:15;20788:29;20603:221;:::o;20830:366::-;20972:3;20993:67;21057:2;21052:3;20993:67;:::i;:::-;20986:74;;21069:93;21158:3;21069:93;:::i;:::-;21187:2;21182:3;21178:12;21171:19;;20830:366;;;:::o;21202:419::-;21368:4;21406:2;21395:9;21391:18;21383:26;;21455:9;21449:4;21445:20;21441:1;21430:9;21426:17;21419:47;21483:131;21609:4;21483:131;:::i;:::-;21475:139;;21202:419;;;:::o;21627:191::-;21667:4;21687:20;21705:1;21687:20;:::i;:::-;21682:25;;21721:20;21739:1;21721:20;:::i;:::-;21716:25;;21760:1;21757;21754:8;21751:34;;;21765:18;;:::i;:::-;21751:34;21810:1;21807;21803:9;21795:17;;21627:191;;;;:::o;21824:172::-;21964:24;21960:1;21952:6;21948:14;21941:48;21824:172;:::o;22002:366::-;22144:3;22165:67;22229:2;22224:3;22165:67;:::i;:::-;22158:74;;22241:93;22330:3;22241:93;:::i;:::-;22359:2;22354:3;22350:12;22343:19;;22002:366;;;:::o;22374:419::-;22540:4;22578:2;22567:9;22563:18;22555:26;;22627:9;22621:4;22617:20;22613:1;22602:9;22598:17;22591:47;22655:131;22781:4;22655:131;:::i;:::-;22647:139;;22374:419;;;:::o;22799:179::-;22939:31;22935:1;22927:6;22923:14;22916:55;22799:179;:::o;22984:366::-;23126:3;23147:67;23211:2;23206:3;23147:67;:::i;:::-;23140:74;;23223:93;23312:3;23223:93;:::i;:::-;23341:2;23336:3;23332:12;23325:19;;22984:366;;;:::o;23356:419::-;23522:4;23560:2;23549:9;23545:18;23537:26;;23609:9;23603:4;23599:20;23595:1;23584:9;23580:17;23573:47;23637:131;23763:4;23637:131;:::i;:::-;23629:139;;23356:419;;;:::o;23781:180::-;23829:77;23826:1;23819:88;23926:4;23923:1;23916:15;23950:4;23947:1;23940:15;23967:175;24107:27;24103:1;24095:6;24091:14;24084:51;23967:175;:::o;24148:366::-;24290:3;24311:67;24375:2;24370:3;24311:67;:::i;:::-;24304:74;;24387:93;24476:3;24387:93;:::i;:::-;24505:2;24500:3;24496:12;24489:19;;24148:366;;;:::o;24520:419::-;24686:4;24724:2;24713:9;24709:18;24701:26;;24773:9;24767:4;24763:20;24759:1;24748:9;24744:17;24737:47;24801:131;24927:4;24801:131;:::i;:::-;24793:139;;24520:419;;;:::o;24945:181::-;25085:33;25081:1;25073:6;25069:14;25062:57;24945:181;:::o;25132:366::-;25274:3;25295:67;25359:2;25354:3;25295:67;:::i;:::-;25288:74;;25371:93;25460:3;25371:93;:::i;:::-;25489:2;25484:3;25480:12;25473:19;;25132:366;;;:::o;25504:419::-;25670:4;25708:2;25697:9;25693:18;25685:26;;25757:9;25751:4;25747:20;25743:1;25732:9;25728:17;25721:47;25785:131;25911:4;25785:131;:::i;:::-;25777:139;;25504:419;;;:::o;25929:180::-;25977:77;25974:1;25967:88;26074:4;26071:1;26064:15;26098:4;26095:1;26088:15;26115:185;26155:1;26172:20;26190:1;26172:20;:::i;:::-;26167:25;;26206:20;26224:1;26206:20;:::i;:::-;26201:25;;26245:1;26235:35;;26250:18;;:::i;:::-;26235:35;26292:1;26289;26285:9;26280:14;;26115:185;;;;:::o
Swarm Source
ipfs://094cfd4abee7d7daa66b1155fd9cf92945f3ae521d7a46decb6f9d8e2721f531
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.