Token
XEN Torrent (fmXENT)
ERC-721
Overview
Max Total Supply
0 fmXENT
Holders
25
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Balance
1 fmXENTLoading...
Loading
Loading...
Loading
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
XENTorrent
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/**
*Submitted for verification at testnet.ftmscan.com on 2023-02-25
*/
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (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);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
/**
* @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`.
*
* 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;
/**
* @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 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 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 the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @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);
}
// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol
// OpenZeppelin Contracts (last updated v4.6.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 `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.0;
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// File: @openzeppelin/contracts/utils/Address.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// File: @openzeppelin/contracts/utils/introspection/ERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner nor approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_safeTransfer(from, to, tokenId, data);
}
/**
* @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.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
// Clear approvals
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
// Clear approvals from the previous owner
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` 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 tokenId
) 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.
* - `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 tokenId
) internal virtual {}
}
// File: @openzeppelin/contracts/interfaces/IERC2981.sol
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface for the NFT Royalty Standard.
*
* A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
* support for royalty payments across all NFT marketplaces and ecosystem participants.
*
* _Available since v4.5._
*/
interface IERC2981 is IERC165 {
/**
* @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
* exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
// File: @openzeppelin/contracts/utils/Base64.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides a set of functions to operate with Base64 strings.
*
* _Available since v4.5._
*/
library Base64 {
/**
* @dev Base64 Encoding/Decoding Table
*/
string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* @dev Converts a `bytes` to its Bytes64 `string` representation.
*/
function encode(bytes memory data) internal pure returns (string memory) {
/**
* Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
* https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
*/
if (data.length == 0) return "";
// Loads the table into memory
string memory table = _TABLE;
// Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
// and split into 4 numbers of 6 bits.
// The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
// - `data.length + 2` -> Round up
// - `/ 3` -> Number of 3-bytes chunks
// - `4 *` -> 4 characters for each chunk
string memory result = new string(4 * ((data.length + 2) / 3));
/// @solidity memory-safe-assembly
assembly {
// Prepare the lookup table (skip the first "length" byte)
let tablePtr := add(table, 1)
// Prepare result pointer, jump over length
let resultPtr := add(result, 32)
// Run over the input, 3 bytes at a time
for {
let dataPtr := data
let endPtr := add(data, mload(data))
} lt(dataPtr, endPtr) {
} {
// Advance 3 bytes
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
// To write each character, shift the 3 bytes (18 bits) chunk
// 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
// and apply logical AND with 0x3F which is the number of
// the previous character in the ASCII table prior to the Base64 Table
// The result is then added to the table to get the character to write,
// and finally write it in the result pointer but with a left shift
// of 256 (1 byte) - 8 (1 ASCII char) = 248 bits
mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
resultPtr := add(resultPtr, 1) // Advance
}
// When data `bytes` is not exactly 3 bytes long
// it is padded with `=` characters at the end
switch mod(mload(data), 3)
case 1 {
mstore8(sub(resultPtr, 1), 0x3d)
mstore8(sub(resultPtr, 2), 0x3d)
}
case 2 {
mstore8(sub(resultPtr, 1), 0x3d)
}
}
return result;
}
}
// File: abdk-libraries-solidity/ABDKMath64x64.sol
/*
* ABDK Math 64.64 Smart Contract Library. Copyright © 2019 by ABDK Consulting.
* Author: Mikhail Vladimirov <[email protected]>
*/
pragma solidity ^0.8.0;
/**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
* represented by int128 type holding only the numerator.
*/
library ABDKMath64x64 {
/*
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/*
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Convert signed 256-bit integer number into signed 64.64-bit fixed point
* number. Revert on overflow.
*
* @param x signed 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function fromInt (int256 x) internal pure returns (int128) {
unchecked {
require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
return int128 (x << 64);
}
}
/**
* Convert signed 64.64 fixed point number into signed 64-bit integer number
* rounding down.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64-bit integer number
*/
function toInt (int128 x) internal pure returns (int64) {
unchecked {
return int64 (x >> 64);
}
}
/**
* Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
* number. Revert on overflow.
*
* @param x unsigned 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function fromUInt (uint256 x) internal pure returns (int128) {
unchecked {
require (x <= 0x7FFFFFFFFFFFFFFF);
return int128 (int256 (x << 64));
}
}
/**
* Convert signed 64.64 fixed point number into unsigned 64-bit integer
* number rounding down. Revert on underflow.
*
* @param x signed 64.64-bit fixed point number
* @return unsigned 64-bit integer number
*/
function toUInt (int128 x) internal pure returns (uint64) {
unchecked {
require (x >= 0);
return uint64 (uint128 (x >> 64));
}
}
/**
* Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
* number rounding down. Revert on overflow.
*
* @param x signed 128.128-bin fixed point number
* @return signed 64.64-bit fixed point number
*/
function from128x128 (int256 x) internal pure returns (int128) {
unchecked {
int256 result = x >> 64;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Convert signed 64.64 fixed point number into signed 128.128 fixed point
* number.
*
* @param x signed 64.64-bit fixed point number
* @return signed 128.128 fixed point number
*/
function to128x128 (int128 x) internal pure returns (int256) {
unchecked {
return int256 (x) << 64;
}
}
/**
* Calculate x + y. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function add (int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) + y;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate x - y. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function sub (int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) - y;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate x * y rounding down. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function mul (int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) * y >> 64;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
* number and y is signed 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64 fixed point number
* @param y signed 256-bit integer number
* @return signed 256-bit integer number
*/
function muli (int128 x, int256 y) internal pure returns (int256) {
unchecked {
if (x == MIN_64x64) {
require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
y <= 0x1000000000000000000000000000000000000000000000000);
return -y << 63;
} else {
bool negativeResult = false;
if (x < 0) {
x = -x;
negativeResult = true;
}
if (y < 0) {
y = -y; // We rely on overflow behavior here
negativeResult = !negativeResult;
}
uint256 absoluteResult = mulu (x, uint256 (y));
if (negativeResult) {
require (absoluteResult <=
0x8000000000000000000000000000000000000000000000000000000000000000);
return -int256 (absoluteResult); // We rely on overflow behavior here
} else {
require (absoluteResult <=
0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return int256 (absoluteResult);
}
}
}
}
/**
* Calculate x * y rounding down, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64 fixed point number
* @param y unsigned 256-bit integer number
* @return unsigned 256-bit integer number
*/
function mulu (int128 x, uint256 y) internal pure returns (uint256) {
unchecked {
if (y == 0) return 0;
require (x >= 0);
uint256 lo = (uint256 (int256 (x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
uint256 hi = uint256 (int256 (x)) * (y >> 128);
require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
hi <<= 64;
require (hi <=
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
return hi + lo;
}
}
/**
* Calculate x / y rounding towards zero. Revert on overflow or when y is
* zero.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function div (int128 x, int128 y) internal pure returns (int128) {
unchecked {
require (y != 0);
int256 result = (int256 (x) << 64) / y;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate x / y rounding towards zero, where x and y are signed 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x signed 256-bit integer number
* @param y signed 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function divi (int256 x, int256 y) internal pure returns (int128) {
unchecked {
require (y != 0);
bool negativeResult = false;
if (x < 0) {
x = -x; // We rely on overflow behavior here
negativeResult = true;
}
if (y < 0) {
y = -y; // We rely on overflow behavior here
negativeResult = !negativeResult;
}
uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
if (negativeResult) {
require (absoluteResult <= 0x80000000000000000000000000000000);
return -int128 (absoluteResult); // We rely on overflow behavior here
} else {
require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return int128 (absoluteResult); // We rely on overflow behavior here
}
}
}
/**
* Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x unsigned 256-bit integer number
* @param y unsigned 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function divu (uint256 x, uint256 y) internal pure returns (int128) {
unchecked {
require (y != 0);
uint128 result = divuu (x, y);
require (result <= uint128 (MAX_64x64));
return int128 (result);
}
}
/**
* Calculate -x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function neg (int128 x) internal pure returns (int128) {
unchecked {
require (x != MIN_64x64);
return -x;
}
}
/**
* Calculate |x|. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function abs (int128 x) internal pure returns (int128) {
unchecked {
require (x != MIN_64x64);
return x < 0 ? -x : x;
}
}
/**
* Calculate 1 / x rounding towards zero. Revert on overflow or when x is
* zero.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function inv (int128 x) internal pure returns (int128) {
unchecked {
require (x != 0);
int256 result = int256 (0x100000000000000000000000000000000) / x;
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function avg (int128 x, int128 y) internal pure returns (int128) {
unchecked {
return int128 ((int256 (x) + int256 (y)) >> 1);
}
}
/**
* Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
* Revert on overflow or in case x * y is negative.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function gavg (int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 m = int256 (x) * int256 (y);
require (m >= 0);
require (m <
0x4000000000000000000000000000000000000000000000000000000000000000);
return int128 (sqrtu (uint256 (m)));
}
}
/**
* Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y uint256 value
* @return signed 64.64-bit fixed point number
*/
function pow (int128 x, uint256 y) internal pure returns (int128) {
unchecked {
bool negative = x < 0 && y & 1 == 1;
uint256 absX = uint128 (x < 0 ? -x : x);
uint256 absResult;
absResult = 0x100000000000000000000000000000000;
if (absX <= 0x10000000000000000) {
absX <<= 63;
while (y != 0) {
if (y & 0x1 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x2 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x4 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x8 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
y >>= 4;
}
absResult >>= 64;
} else {
uint256 absXShift = 63;
if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }
uint256 resultShift = 0;
while (y != 0) {
require (absXShift < 64);
if (y & 0x1 != 0) {
absResult = absResult * absX >> 127;
resultShift += absXShift;
if (absResult > 0x100000000000000000000000000000000) {
absResult >>= 1;
resultShift += 1;
}
}
absX = absX * absX >> 127;
absXShift <<= 1;
if (absX >= 0x100000000000000000000000000000000) {
absX >>= 1;
absXShift += 1;
}
y >>= 1;
}
require (resultShift < 64);
absResult >>= 64 - resultShift;
}
int256 result = negative ? -int256 (absResult) : int256 (absResult);
require (result >= MIN_64x64 && result <= MAX_64x64);
return int128 (result);
}
}
/**
* Calculate sqrt (x) rounding down. Revert if x < 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function sqrt (int128 x) internal pure returns (int128) {
unchecked {
require (x >= 0);
return int128 (sqrtu (uint256 (int256 (x)) << 64));
}
}
/**
* Calculate binary logarithm of x. Revert if x <= 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function log_2 (int128 x) internal pure returns (int128) {
unchecked {
require (x > 0);
int256 msb = 0;
int256 xc = x;
if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
if (xc >= 0x10000) { xc >>= 16; msb += 16; }
if (xc >= 0x100) { xc >>= 8; msb += 8; }
if (xc >= 0x10) { xc >>= 4; msb += 4; }
if (xc >= 0x4) { xc >>= 2; msb += 2; }
if (xc >= 0x2) msb += 1; // No need to shift xc anymore
int256 result = msb - 64 << 64;
uint256 ux = uint256 (int256 (x)) << uint256 (127 - msb);
for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
ux *= ux;
uint256 b = ux >> 255;
ux >>= 127 + b;
result += bit * int256 (b);
}
return int128 (result);
}
}
/**
* Calculate natural logarithm of x. Revert if x <= 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function ln (int128 x) internal pure returns (int128) {
unchecked {
require (x > 0);
return int128 (int256 (
uint256 (int256 (log_2 (x))) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128));
}
}
/**
* Calculate binary exponent of x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function exp_2 (int128 x) internal pure returns (int128) {
unchecked {
require (x < 0x400000000000000000); // Overflow
if (x < -0x400000000000000000) return 0; // Underflow
uint256 result = 0x80000000000000000000000000000000;
if (x & 0x8000000000000000 > 0)
result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
if (x & 0x4000000000000000 > 0)
result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
if (x & 0x2000000000000000 > 0)
result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
if (x & 0x1000000000000000 > 0)
result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
if (x & 0x800000000000000 > 0)
result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
if (x & 0x400000000000000 > 0)
result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
if (x & 0x200000000000000 > 0)
result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
if (x & 0x100000000000000 > 0)
result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
if (x & 0x80000000000000 > 0)
result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
if (x & 0x40000000000000 > 0)
result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
if (x & 0x20000000000000 > 0)
result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
if (x & 0x10000000000000 > 0)
result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
if (x & 0x8000000000000 > 0)
result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
if (x & 0x4000000000000 > 0)
result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
if (x & 0x2000000000000 > 0)
result = result * 0x1000162E525EE054754457D5995292026 >> 128;
if (x & 0x1000000000000 > 0)
result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
if (x & 0x800000000000 > 0)
result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
if (x & 0x400000000000 > 0)
result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
if (x & 0x200000000000 > 0)
result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
if (x & 0x100000000000 > 0)
result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
if (x & 0x80000000000 > 0)
result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
if (x & 0x40000000000 > 0)
result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
if (x & 0x20000000000 > 0)
result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
if (x & 0x10000000000 > 0)
result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
if (x & 0x8000000000 > 0)
result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
if (x & 0x4000000000 > 0)
result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
if (x & 0x2000000000 > 0)
result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
if (x & 0x1000000000 > 0)
result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
if (x & 0x800000000 > 0)
result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
if (x & 0x400000000 > 0)
result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
if (x & 0x200000000 > 0)
result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
if (x & 0x100000000 > 0)
result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
if (x & 0x80000000 > 0)
result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
if (x & 0x40000000 > 0)
result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
if (x & 0x20000000 > 0)
result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
if (x & 0x10000000 > 0)
result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
if (x & 0x8000000 > 0)
result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
if (x & 0x4000000 > 0)
result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
if (x & 0x2000000 > 0)
result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
if (x & 0x1000000 > 0)
result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
if (x & 0x800000 > 0)
result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
if (x & 0x400000 > 0)
result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
if (x & 0x200000 > 0)
result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
if (x & 0x100000 > 0)
result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
if (x & 0x80000 > 0)
result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
if (x & 0x40000 > 0)
result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
if (x & 0x20000 > 0)
result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
if (x & 0x10000 > 0)
result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
if (x & 0x8000 > 0)
result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
if (x & 0x4000 > 0)
result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
if (x & 0x2000 > 0)
result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
if (x & 0x1000 > 0)
result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
if (x & 0x800 > 0)
result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
if (x & 0x400 > 0)
result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
if (x & 0x200 > 0)
result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
if (x & 0x100 > 0)
result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
if (x & 0x80 > 0)
result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
if (x & 0x40 > 0)
result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
if (x & 0x20 > 0)
result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
if (x & 0x10 > 0)
result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
if (x & 0x8 > 0)
result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
if (x & 0x4 > 0)
result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
if (x & 0x2 > 0)
result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
if (x & 0x1 > 0)
result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;
result >>= uint256 (int256 (63 - (x >> 64)));
require (result <= uint256 (int256 (MAX_64x64)));
return int128 (int256 (result));
}
}
/**
* Calculate natural exponent of x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function exp (int128 x) internal pure returns (int128) {
unchecked {
require (x < 0x400000000000000000); // Overflow
if (x < -0x400000000000000000) return 0; // Underflow
return exp_2 (
int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
}
}
/**
* Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x unsigned 256-bit integer number
* @param y unsigned 256-bit integer number
* @return unsigned 64.64-bit fixed point number
*/
function divuu (uint256 x, uint256 y) private pure returns (uint128) {
unchecked {
require (y != 0);
uint256 result;
if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
result = (x << 64) / y;
else {
uint256 msb = 192;
uint256 xc = x >> 192;
if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
if (xc >= 0x10000) { xc >>= 16; msb += 16; }
if (xc >= 0x100) { xc >>= 8; msb += 8; }
if (xc >= 0x10) { xc >>= 4; msb += 4; }
if (xc >= 0x4) { xc >>= 2; msb += 2; }
if (xc >= 0x2) msb += 1; // No need to shift xc anymore
result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
uint256 hi = result * (y >> 128);
uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
uint256 xh = x >> 192;
uint256 xl = x << 64;
if (xl < lo) xh -= 1;
xl -= lo; // We rely on overflow behavior here
lo = hi << 128;
if (xl < lo) xh -= 1;
xl -= lo; // We rely on overflow behavior here
assert (xh == hi >> 128);
result += xl / y;
}
require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return uint128 (result);
}
}
/**
* Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
* number.
*
* @param x unsigned 256-bit integer number
* @return unsigned 128-bit integer number
*/
function sqrtu (uint256 x) private pure returns (uint128) {
unchecked {
if (x == 0) return 0;
else {
uint256 xx = x;
uint256 r = 1;
if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
if (xx >= 0x100) { xx >>= 8; r <<= 4; }
if (xx >= 0x10) { xx >>= 4; r <<= 2; }
if (xx >= 0x4) { r <<= 1; }
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1; // Seven iterations should be enough
uint256 r1 = x / r;
return uint128 (r < r1 ? r : r1);
}
}
}
}
// File: @faircrypto/xen-crypto/contracts/Math.sol
pragma solidity ^0.8.10;
library Math {
function min(uint256 a, uint256 b) external pure returns (uint256) {
if (a > b) return b;
return a;
}
function max(uint256 a, uint256 b) external pure returns (uint256) {
if (a > b) return a;
return b;
}
function logX64(uint256 x) external pure returns (int128) {
return ABDKMath64x64.log_2(ABDKMath64x64.fromUInt(x));
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @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);
/**
* @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 `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, 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 `from` to `to` 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 from,
address to,
uint256 amount
) external returns (bool);
}
// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, 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}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, 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) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, 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) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* 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:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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 Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
// File: @openzeppelin/contracts/interfaces/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)
pragma solidity ^0.8.0;
// File: @faircrypto/xen-crypto/contracts/interfaces/IStakingToken.sol
pragma solidity ^0.8.10;
interface IStakingToken {
event Staked(address indexed user, uint256 amount, uint256 term);
event Withdrawn(address indexed user, uint256 amount, uint256 reward);
function stake(uint256 amount, uint256 term) external;
function withdraw() external;
}
// File: @faircrypto/xen-crypto/contracts/interfaces/IRankedMintingToken.sol
pragma solidity ^0.8.10;
interface IRankedMintingToken {
event RankClaimed(address indexed user, uint256 term, uint256 rank);
event MintClaimed(address indexed user, uint256 rewardAmount);
function claimRank(uint256 term) external;
function claimMintReward() external;
}
// File: @faircrypto/xen-crypto/contracts/interfaces/IBurnableToken.sol
pragma solidity ^0.8.10;
interface IBurnableToken {
function burn(address user, uint256 amount) external;
}
// File: @faircrypto/xen-crypto/contracts/interfaces/IBurnRedeemable.sol
pragma solidity ^0.8.10;
interface IBurnRedeemable {
event Redeemed(
address indexed user,
address indexed xenContract,
address indexed tokenContract,
uint256 xenAmount,
uint256 tokenAmount
);
function onTokenBurned(address user, uint256 amount) external;
}
// File: @faircrypto/xen-crypto/contracts/XENCrypto.sol
pragma solidity ^0.8.10;
contract XENCrypto is Context, IRankedMintingToken, IStakingToken, IBurnableToken, ERC20("XEN Crypto", "XEN") {
using Math for uint256;
using ABDKMath64x64 for int128;
using ABDKMath64x64 for uint256;
// INTERNAL TYPE TO DESCRIBE A XEN MINT INFO
struct MintInfo {
address user;
uint256 term;
uint256 maturityTs;
uint256 rank;
uint256 amplifier;
uint256 eaaRate;
}
// INTERNAL TYPE TO DESCRIBE A XEN STAKE
struct StakeInfo {
uint256 term;
uint256 maturityTs;
uint256 amount;
uint256 apy;
}
// PUBLIC CONSTANTS
uint256 public constant SECONDS_IN_DAY = 3_600 * 24;
uint256 public constant DAYS_IN_YEAR = 365;
uint256 public constant GENESIS_RANK = 1;
uint256 public constant MIN_TERM = 1 * SECONDS_IN_DAY - 1;
uint256 public constant MAX_TERM_START = 100 * SECONDS_IN_DAY;
uint256 public constant MAX_TERM_END = 1_000 * SECONDS_IN_DAY;
uint256 public constant TERM_AMPLIFIER = 15;
uint256 public constant TERM_AMPLIFIER_THRESHOLD = 5_000;
uint256 public constant REWARD_AMPLIFIER_START = 3_000;
uint256 public constant REWARD_AMPLIFIER_END = 1;
uint256 public constant EAA_PM_START = 100;
uint256 public constant EAA_PM_STEP = 1;
uint256 public constant EAA_RANK_STEP = 100_000;
uint256 public constant WITHDRAWAL_WINDOW_DAYS = 7;
uint256 public constant MAX_PENALTY_PCT = 99;
uint256 public constant XEN_MIN_STAKE = 0;
uint256 public constant XEN_MIN_BURN = 0;
uint256 public constant XEN_APY_START = 20;
uint256 public constant XEN_APY_DAYS_STEP = 90;
uint256 public constant XEN_APY_END = 2;
string public constant AUTHORS = "@MrJackLevin @lbelyaev faircrypto.org";
// PUBLIC STATE, READABLE VIA NAMESAKE GETTERS
uint256 public immutable genesisTs;
uint256 public globalRank = GENESIS_RANK;
uint256 public activeMinters;
uint256 public activeStakes;
uint256 public totalXenStaked;
// user address => XEN mint info
mapping(address => MintInfo) public userMints;
// user address => XEN stake info
mapping(address => StakeInfo) public userStakes;
// user address => XEN burn amount
mapping(address => uint256) public userBurns;
// CONSTRUCTOR
constructor() {
genesisTs = block.timestamp;
}
// PRIVATE METHODS
/**
* @dev calculates current MaxTerm based on Global Rank
* (if Global Rank crosses over TERM_AMPLIFIER_THRESHOLD)
*/
function _calculateMaxTerm() private view returns (uint256) {
if (globalRank > TERM_AMPLIFIER_THRESHOLD) {
uint256 delta = globalRank.fromUInt().log_2().mul(TERM_AMPLIFIER.fromUInt()).toUInt();
uint256 newMax = MAX_TERM_START + delta * SECONDS_IN_DAY;
return Math.min(newMax, MAX_TERM_END);
}
return MAX_TERM_START;
}
/**
* @dev calculates Withdrawal Penalty depending on lateness
*/
function _penalty(uint256 secsLate) private pure returns (uint256) {
// =MIN(2^(daysLate+3)/window-1,99)
uint256 daysLate = secsLate / SECONDS_IN_DAY;
if (daysLate > WITHDRAWAL_WINDOW_DAYS - 1) return MAX_PENALTY_PCT;
uint256 penalty = (uint256(1) << (daysLate + 3)) / WITHDRAWAL_WINDOW_DAYS - 1;
return Math.min(penalty, MAX_PENALTY_PCT);
}
/**
* @dev calculates net Mint Reward (adjusted for Penalty)
*/
function _calculateMintReward(
uint256 cRank,
uint256 term,
uint256 maturityTs,
uint256 amplifier,
uint256 eeaRate
) private view returns (uint256) {
uint256 secsLate = block.timestamp - maturityTs;
uint256 penalty = _penalty(secsLate);
uint256 rankDelta = Math.max(globalRank - cRank, 2);
uint256 EAA = (1_000 + eeaRate);
uint256 reward = getGrossReward(rankDelta, amplifier, term, EAA);
return (reward * (100 - penalty)) / 100;
}
/**
* @dev cleans up User Mint storage (gets some Gas credit;))
*/
function _cleanUpUserMint() private {
delete userMints[_msgSender()];
activeMinters--;
}
/**
* @dev calculates XEN Stake Reward
*/
function _calculateStakeReward(
uint256 amount,
uint256 term,
uint256 maturityTs,
uint256 apy
) private view returns (uint256) {
if (block.timestamp > maturityTs) {
uint256 rate = (apy * term * 1_000_000) / DAYS_IN_YEAR;
return (amount * rate) / 100_000_000;
}
return 0;
}
/**
* @dev calculates Reward Amplifier
*/
function _calculateRewardAmplifier() private view returns (uint256) {
uint256 amplifierDecrease = (block.timestamp - genesisTs) / SECONDS_IN_DAY;
if (amplifierDecrease < REWARD_AMPLIFIER_START) {
return Math.max(REWARD_AMPLIFIER_START - amplifierDecrease, REWARD_AMPLIFIER_END);
} else {
return REWARD_AMPLIFIER_END;
}
}
/**
* @dev calculates Early Adopter Amplifier Rate (in 1/000ths)
* actual EAA is (1_000 + EAAR) / 1_000
*/
function _calculateEAARate() private view returns (uint256) {
uint256 decrease = (EAA_PM_STEP * globalRank) / EAA_RANK_STEP;
if (decrease > EAA_PM_START) return 0;
return EAA_PM_START - decrease;
}
/**
* @dev calculates APY (in %)
*/
function _calculateAPY() private view returns (uint256) {
uint256 decrease = (block.timestamp - genesisTs) / (SECONDS_IN_DAY * XEN_APY_DAYS_STEP);
if (XEN_APY_START - XEN_APY_END < decrease) return XEN_APY_END;
return XEN_APY_START - decrease;
}
/**
* @dev creates User Stake
*/
function _createStake(uint256 amount, uint256 term) private {
userStakes[_msgSender()] = StakeInfo({
term: term,
maturityTs: block.timestamp + term * SECONDS_IN_DAY,
amount: amount,
apy: _calculateAPY()
});
activeStakes++;
totalXenStaked += amount;
}
// PUBLIC CONVENIENCE GETTERS
/**
* @dev calculates gross Mint Reward
*/
function getGrossReward(
uint256 rankDelta,
uint256 amplifier,
uint256 term,
uint256 eaa
) public pure returns (uint256) {
int128 log128 = rankDelta.fromUInt().log_2();
int128 reward128 = log128.mul(amplifier.fromUInt()).mul(term.fromUInt()).mul(eaa.fromUInt());
return reward128.div(uint256(1_000).fromUInt()).toUInt();
}
/**
* @dev returns User Mint object associated with User account address
*/
function getUserMint() external view returns (MintInfo memory) {
return userMints[_msgSender()];
}
/**
* @dev returns XEN Stake object associated with User account address
*/
function getUserStake() external view returns (StakeInfo memory) {
return userStakes[_msgSender()];
}
/**
* @dev returns current AMP
*/
function getCurrentAMP() external view returns (uint256) {
return _calculateRewardAmplifier();
}
/**
* @dev returns current EAA Rate
*/
function getCurrentEAAR() external view returns (uint256) {
return _calculateEAARate();
}
/**
* @dev returns current APY
*/
function getCurrentAPY() external view returns (uint256) {
return _calculateAPY();
}
/**
* @dev returns current MaxTerm
*/
function getCurrentMaxTerm() external view returns (uint256) {
return _calculateMaxTerm();
}
// PUBLIC STATE-CHANGING METHODS
/**
* @dev accepts User cRank claim provided all checks pass (incl. no current claim exists)
*/
function claimRank(uint256 term) external {
uint256 termSec = term * SECONDS_IN_DAY;
require(termSec > MIN_TERM, "CRank: Term less than min");
require(termSec < _calculateMaxTerm() + 1, "CRank: Term more than current max term");
require(userMints[_msgSender()].rank == 0, "CRank: Mint already in progress");
// create and store new MintInfo
MintInfo memory mintInfo = MintInfo({
user: _msgSender(),
term: term,
maturityTs: block.timestamp + termSec,
rank: globalRank,
amplifier: _calculateRewardAmplifier(),
eaaRate: _calculateEAARate()
});
userMints[_msgSender()] = mintInfo;
activeMinters++;
emit RankClaimed(_msgSender(), term, globalRank++);
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal Time Window), gets minted XEN
*/
function claimMintReward() external {
MintInfo memory mintInfo = userMints[_msgSender()];
require(mintInfo.rank > 0, "CRank: No mint exists");
require(block.timestamp > mintInfo.maturityTs, "CRank: Mint maturity not reached");
// calculate reward and mint tokens
uint256 rewardAmount = _calculateMintReward(
mintInfo.rank,
mintInfo.term,
mintInfo.maturityTs,
mintInfo.amplifier,
mintInfo.eaaRate
) * 1 ether;
_mint(_msgSender(), rewardAmount);
_cleanUpUserMint();
emit MintClaimed(_msgSender(), rewardAmount);
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal time Window)
* mints XEN coins and splits them between User and designated other address
*/
function claimMintRewardAndShare(address other, uint256 pct) external {
MintInfo memory mintInfo = userMints[_msgSender()];
require(other != address(0), "CRank: Cannot share with zero address");
require(pct > 0, "CRank: Cannot share zero percent");
require(pct < 101, "CRank: Cannot share 100+ percent");
require(mintInfo.rank > 0, "CRank: No mint exists");
require(block.timestamp > mintInfo.maturityTs, "CRank: Mint maturity not reached");
// calculate reward
uint256 rewardAmount = _calculateMintReward(
mintInfo.rank,
mintInfo.term,
mintInfo.maturityTs,
mintInfo.amplifier,
mintInfo.eaaRate
) * 1 ether;
uint256 sharedReward = (rewardAmount * pct) / 100;
uint256 ownReward = rewardAmount - sharedReward;
// mint reward tokens
_mint(_msgSender(), ownReward);
_mint(other, sharedReward);
_cleanUpUserMint();
emit MintClaimed(_msgSender(), rewardAmount);
}
/**
* @dev ends minting upon maturity (and within permitted Withdrawal time Window)
* mints XEN coins and stakes 'pct' of it for 'term'
*/
function claimMintRewardAndStake(uint256 pct, uint256 term) external {
MintInfo memory mintInfo = userMints[_msgSender()];
// require(pct > 0, "CRank: Cannot share zero percent");
require(pct < 101, "CRank: Cannot share >100 percent");
require(mintInfo.rank > 0, "CRank: No mint exists");
require(block.timestamp > mintInfo.maturityTs, "CRank: Mint maturity not reached");
// calculate reward
uint256 rewardAmount = _calculateMintReward(
mintInfo.rank,
mintInfo.term,
mintInfo.maturityTs,
mintInfo.amplifier,
mintInfo.eaaRate
) * 1 ether;
uint256 stakedReward = (rewardAmount * pct) / 100;
uint256 ownReward = rewardAmount - stakedReward;
// mint reward tokens part
_mint(_msgSender(), ownReward);
_cleanUpUserMint();
emit MintClaimed(_msgSender(), rewardAmount);
// nothing to burn since we haven't minted this part yet
// stake extra tokens part
require(stakedReward > XEN_MIN_STAKE, "XEN: Below min stake");
require(term * SECONDS_IN_DAY > MIN_TERM, "XEN: Below min stake term");
require(term * SECONDS_IN_DAY < MAX_TERM_END + 1, "XEN: Above max stake term");
require(userStakes[_msgSender()].amount == 0, "XEN: stake exists");
_createStake(stakedReward, term);
emit Staked(_msgSender(), stakedReward, term);
}
/**
* @dev initiates XEN Stake in amount for a term (days)
*/
function stake(uint256 amount, uint256 term) external {
require(balanceOf(_msgSender()) >= amount, "XEN: not enough balance");
require(amount > XEN_MIN_STAKE, "XEN: Below min stake");
require(term * SECONDS_IN_DAY > MIN_TERM, "XEN: Below min stake term");
require(term * SECONDS_IN_DAY < MAX_TERM_END + 1, "XEN: Above max stake term");
require(userStakes[_msgSender()].amount == 0, "XEN: stake exists");
// burn staked XEN
_burn(_msgSender(), amount);
// create XEN Stake
_createStake(amount, term);
emit Staked(_msgSender(), amount, term);
}
/**
* @dev ends XEN Stake and gets reward if the Stake is mature
*/
function withdraw() external {
StakeInfo memory userStake = userStakes[_msgSender()];
require(userStake.amount > 0, "XEN: no stake exists");
uint256 xenReward = _calculateStakeReward(
userStake.amount,
userStake.term,
userStake.maturityTs,
userStake.apy
);
activeStakes--;
totalXenStaked -= userStake.amount;
// mint staked XEN (+ reward)
_mint(_msgSender(), userStake.amount + xenReward);
emit Withdrawn(_msgSender(), userStake.amount, xenReward);
delete userStakes[_msgSender()];
}
/**
* @dev burns XEN tokens and creates Proof-Of-Burn record to be used by connected DeFi services
*/
function burn(address user, uint256 amount) public {
require(amount > XEN_MIN_BURN, "Burn: Below min limit");
require(
IERC165(_msgSender()).supportsInterface(type(IBurnRedeemable).interfaceId),
"Burn: not a supported contract"
);
_spendAllowance(user, _msgSender(), amount);
_burn(user, amount);
userBurns[user] += amount;
IBurnRedeemable(_msgSender()).onTokenBurned(user, amount);
}
}
// File: operator-filter-registry/src/IOperatorFilterRegistry.sol
pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
// File: operator-filter-registry/src/OperatorFilterer.sol
pragma solidity ^0.8.13;
/**
* @title OperatorFilterer
* @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
* registrant's entries in the OperatorFilterRegistry.
* @dev This smart contract is meant to be inherited by token contracts so they can use the following:
* - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
* - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
*/
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
// If an inheriting token contract is deployed to a network without the registry deployed, the modifier
// will not revert, but the contract will need to be registered with the registry once it is deployed in
// order for the modifier to filter addresses.
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (subscribe) {
OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
OPERATOR_FILTER_REGISTRY.register(address(this));
}
}
}
}
modifier onlyAllowedOperator(address from) virtual {
// Allow spending tokens from addresses with balance
// Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
// from an EOA.
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function _checkFilterOperator(address operator) internal view virtual {
// Check registry code length to facilitate testing in environments without a deployed registry.
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
// File: operator-filter-registry/src/DefaultOperatorFilterer.sol
pragma solidity ^0.8.13;
/**
* @title DefaultOperatorFilterer
* @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
*/
abstract contract DefaultOperatorFilterer is OperatorFilterer {
address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: contracts/libs/ERC2771Context.sol
// OpenZeppelin Contracts (last updated v4.7.0) (metatx/ERC2771Context.sol)
pragma solidity ^0.8.10;
/**
* @dev Context variant with ERC2771 support.
*/
abstract contract ERC2771Context is Context {
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
// one-time settable var
address internal _trustedForwarder;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address trustedForwarder) {
_trustedForwarder = trustedForwarder;
}
function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
return forwarder == _trustedForwarder;
}
function _msgSender() internal view virtual override returns (address sender) {
if (isTrustedForwarder(msg.sender)) {
// The assembly code is more direct than the Solidity version using `abi.decode`.
/// @solidity memory-safe-assembly
assembly {
sender := shr(96, calldataload(sub(calldatasize(), 20)))
}
} else {
return super._msgSender();
}
}
function _msgData() internal view virtual override returns (bytes calldata) {
if (isTrustedForwarder(msg.sender)) {
return msg.data[:msg.data.length - 20];
} else {
return super._msgData();
}
}
}
// File: contracts/interfaces/IERC2771.sol
pragma solidity ^0.8.10;
interface IERC2771 {
function isTrustedForwarder(address forwarder) external;
}
// File: contracts/interfaces/IXENTorrent.sol
pragma solidity ^0.8.10;
interface IXENTorrent {
event StartTorrent(address indexed user, uint256 count, uint256 term);
event EndTorrent(address indexed user, uint256 tokenId, address to);
function bulkClaimRank(uint256 count, uint256 term) external returns (uint256);
function bulkClaimMintReward(uint256 tokenId, address to) external;
}
// File: contracts/interfaces/IXENProxying.sol
pragma solidity ^0.8.10;
interface IXENProxying {
function callClaimRank(uint256 term) external;
function callClaimMintReward(address to) external;
function powerDown() external;
}
// File: contracts/libs/MintInfo.sol
pragma solidity ^0.8.10;
// mapping: NFT tokenId => MintInfo (used in tokenURI generation)
// MintInfo encoded as:
// term (uint16)
// | maturityTs (uint64)
// | rank (uint128)
// | amp (uint16)
// | eaa (uint16)
// | class (uint8):
// [7] isApex
// [6] isLimited
// [0-5] powerGroupIdx
// | redeemed (uint8)
library MintInfo {
/**
@dev helper to convert Bool to U256 type and make compiler happy
*/
function toU256(bool x) internal pure returns (uint256 r) {
assembly {
r := x
}
}
/**
@dev encodes MintInfo record from its props
*/
function encodeMintInfo(
uint256 term,
uint256 maturityTs,
uint256 rank,
uint256 amp,
uint256 eaa,
uint256 class_,
bool redeemed
) public pure returns (uint256 info) {
info = info | (toU256(redeemed) & 0xFF);
info = info | ((class_ & 0xFF) << 8);
info = info | ((eaa & 0xFFFF) << 16);
info = info | ((amp & 0xFFFF) << 32);
info = info | ((rank & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) << 48);
info = info | ((maturityTs & 0xFFFFFFFFFFFFFFFF) << 176);
info = info | ((term & 0xFFFF) << 240);
}
/**
@dev decodes MintInfo record and extracts all of its props
*/
function decodeMintInfo(uint256 info)
public
pure
returns (
uint256 term,
uint256 maturityTs,
uint256 rank,
uint256 amp,
uint256 eaa,
uint256 class,
bool apex,
bool limited,
bool redeemed
)
{
term = uint16(info >> 240);
maturityTs = uint64(info >> 176);
rank = uint128(info >> 48);
amp = uint16(info >> 32);
eaa = uint16(info >> 16);
class = uint8(info >> 8) & 0x3F;
apex = (uint8(info >> 8) & 0x80) > 0;
limited = (uint8(info >> 8) & 0x40) > 0;
redeemed = uint8(info) == 1;
}
/**
@dev extracts `term` prop from encoded MintInfo
*/
function getTerm(uint256 info) public pure returns (uint256 term) {
(term, , , , , , , , ) = decodeMintInfo(info);
}
/**
@dev extracts `maturityTs` prop from encoded MintInfo
*/
function getMaturityTs(uint256 info) public pure returns (uint256 maturityTs) {
(, maturityTs, , , , , , , ) = decodeMintInfo(info);
}
/**
@dev extracts `rank` prop from encoded MintInfo
*/
function getRank(uint256 info) public pure returns (uint256 rank) {
(, , rank, , , , , , ) = decodeMintInfo(info);
}
/**
@dev extracts `AMP` prop from encoded MintInfo
*/
function getAMP(uint256 info) public pure returns (uint256 amp) {
(, , , amp, , , , , ) = decodeMintInfo(info);
}
/**
@dev extracts `EAA` prop from encoded MintInfo
*/
function getEAA(uint256 info) public pure returns (uint256 eaa) {
(, , , , eaa, , , , ) = decodeMintInfo(info);
}
/**
@dev extracts `redeemed` prop from encoded MintInfo
*/
function getClass(uint256 info)
public
pure
returns (
uint256 class_,
bool apex,
bool limited
)
{
(, , , , , class_, apex, limited, ) = decodeMintInfo(info);
}
/**
@dev extracts `redeemed` prop from encoded MintInfo
*/
function getRedeemed(uint256 info) public pure returns (bool redeemed) {
(, , , , , , , , redeemed) = decodeMintInfo(info);
}
}
// File: contracts/libs/BokkyPooBahsDateTimeLibrary.sol
pragma solidity ^0.8.10;
// ----------------------------------------------------------------------------
// BokkyPooBah's DateTime Library v1.01
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library BokkyPooBahsDateTimeLibrary {
uint256 constant _SECONDS_PER_DAY = 24 * 60 * 60;
uint256 constant _SECONDS_PER_HOUR = 60 * 60;
uint256 constant _SECONDS_PER_MINUTE = 60;
int256 constant _OFFSET19700101 = 2440588;
uint256 constant _DOW_FRI = 5;
uint256 constant _DOW_SAT = 6;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// https://aa.usno.navy.mil/faq/JD_formula.html
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(
uint256 year,
uint256 month,
uint256 day
) private pure returns (uint256 _days) {
require(year >= 1970);
int256 _year = int256(year);
int256 _month = int256(month);
int256 _day = int256(day);
int256 __days = _day -
32075 +
(1461 * (_year + 4800 + (_month - 14) / 12)) /
4 +
(367 * (_month - 2 - ((_month - 14) / 12) * 12)) /
12 -
(3 * ((_year + 4900 + (_month - 14) / 12) / 100)) /
4 -
_OFFSET19700101;
_days = uint256(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint256 _days)
private
pure
returns (
uint256 year,
uint256 month,
uint256 day
)
{
int256 __days = int256(_days);
int256 L = __days + 68569 + _OFFSET19700101;
int256 N = (4 * L) / 146097;
L = L - (146097 * N + 3) / 4;
int256 _year = (4000 * (L + 1)) / 1461001;
L = L - (1461 * _year) / 4 + 31;
int256 _month = (80 * L) / 2447;
int256 _day = L - (2447 * _month) / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint256(_year);
month = uint256(_month);
day = uint256(_day);
}
function timestampFromDate(
uint256 year,
uint256 month,
uint256 day
) internal pure returns (uint256 timestamp) {
timestamp = _daysFromDate(year, month, day) * _SECONDS_PER_DAY;
}
function timestampFromDateTime(
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
) internal pure returns (uint256 timestamp) {
timestamp =
_daysFromDate(year, month, day) *
_SECONDS_PER_DAY +
hour *
_SECONDS_PER_HOUR +
minute *
_SECONDS_PER_MINUTE +
second;
}
function timestampToDate(uint256 timestamp)
internal
pure
returns (
uint256 year,
uint256 month,
uint256 day
)
{
(year, month, day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
}
function timestampToDateTime(uint256 timestamp)
internal
pure
returns (
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
)
{
(year, month, day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
uint256 secs = timestamp % _SECONDS_PER_DAY;
hour = secs / _SECONDS_PER_HOUR;
secs = secs % _SECONDS_PER_HOUR;
minute = secs / _SECONDS_PER_MINUTE;
second = secs % _SECONDS_PER_MINUTE;
}
function isValidDate(
uint256 year,
uint256 month,
uint256 day
) internal pure returns (bool valid) {
if (year >= 1970 && month > 0 && month <= 12) {
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(
uint256 year,
uint256 month,
uint256 day,
uint256 hour,
uint256 minute,
uint256 second
) internal pure returns (bool valid) {
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint256 timestamp) internal pure returns (bool leapYear) {
(uint256 year, , ) = _daysToDate(timestamp / _SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint256 year) private pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint256 timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= _DOW_FRI;
}
function isWeekEnd(uint256 timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= _DOW_SAT;
}
function getDaysInMonth(uint256 timestamp) internal pure returns (uint256 daysInMonth) {
(uint256 year, uint256 month, ) = _daysToDate(timestamp / _SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint256 year, uint256 month) private pure returns (uint256 daysInMonth) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint256 timestamp) internal pure returns (uint256 dayOfWeek) {
uint256 _days = timestamp / _SECONDS_PER_DAY;
dayOfWeek = ((_days + 3) % 7) + 1;
}
function getYear(uint256 timestamp) internal pure returns (uint256 year) {
(year, , ) = _daysToDate(timestamp / _SECONDS_PER_DAY);
}
function getMonth(uint256 timestamp) internal pure returns (uint256 month) {
(, month, ) = _daysToDate(timestamp / _SECONDS_PER_DAY);
}
function getDay(uint256 timestamp) internal pure returns (uint256 day) {
(, , day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
}
function getHour(uint256 timestamp) internal pure returns (uint256 hour) {
uint256 secs = timestamp % _SECONDS_PER_DAY;
hour = secs / _SECONDS_PER_HOUR;
}
function getMinute(uint256 timestamp) internal pure returns (uint256 minute) {
uint256 secs = timestamp % _SECONDS_PER_HOUR;
minute = secs / _SECONDS_PER_MINUTE;
}
function getSecond(uint256 timestamp) internal pure returns (uint256 second) {
second = timestamp % _SECONDS_PER_MINUTE;
}
function addYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
year += _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * _SECONDS_PER_DAY + (timestamp % _SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = ((month - 1) % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * _SECONDS_PER_DAY + (timestamp % _SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _days * _SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _hours * _SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _minutes * _SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
year -= _years;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * _SECONDS_PER_DAY + (timestamp % _SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
(uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / _SECONDS_PER_DAY);
uint256 yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = (yearMonth % 12) + 1;
uint256 daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * _SECONDS_PER_DAY + (timestamp % _SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _days * _SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _hours * _SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _minutes * _SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _years) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, , ) = _daysToDate(fromTimestamp / _SECONDS_PER_DAY);
(uint256 toYear, , ) = _daysToDate(toTimestamp / _SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _months) {
require(fromTimestamp <= toTimestamp);
(uint256 fromYear, uint256 fromMonth, ) = _daysToDate(fromTimestamp / _SECONDS_PER_DAY);
(uint256 toYear, uint256 toMonth, ) = _daysToDate(toTimestamp / _SECONDS_PER_DAY);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _days) {
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / _SECONDS_PER_DAY;
}
function diffHours(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _hours) {
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / _SECONDS_PER_HOUR;
}
function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _minutes) {
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / _SECONDS_PER_MINUTE;
}
function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _seconds) {
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}
// File: contracts/libs/DateTime.sol
pragma solidity ^0.8.10;
/*
@dev Library to convert epoch timestamp to a human-readable Date-Time string
@dependency uses BokkyPooBahsDateTimeLibrary.sol library internally
*/
library DateTime {
using Strings for uint256;
bytes public constant MONTHS = bytes("JanFebMarAprMayJunJulAugSepOctNovDec");
/**
* @dev returns month as short (3-letter) string
*/
function monthAsString(uint256 idx) internal pure returns (string memory) {
require(idx > 0, "bad idx");
bytes memory str = new bytes(3);
uint256 offset = (idx - 1) * 3;
str[0] = bytes1(MONTHS[offset]);
str[1] = bytes1(MONTHS[offset + 1]);
str[2] = bytes1(MONTHS[offset + 2]);
return string(str);
}
/**
* @dev returns string representation of number left-padded for 2 symbols
*/
function asPaddedString(uint256 n) internal pure returns (string memory) {
if (n == 0) return "00";
if (n < 10) return string.concat("0", n.toString());
return n.toString();
}
/**
* @dev returns string of format 'Jan 01, 2022 18:00 UTC' for a given timestamp
*/
function asString(uint256 ts) external pure returns (string memory) {
(uint256 year, uint256 month, uint256 day, uint256 hour, uint256 minute, ) = BokkyPooBahsDateTimeLibrary
.timestampToDateTime(ts);
return
string(
abi.encodePacked(
monthAsString(month),
" ",
day.toString(),
", ",
year.toString(),
" ",
asPaddedString(hour),
":",
asPaddedString(minute),
" UTC"
)
);
}
/**
* @dev returns (year, month as string) components of a date by timestamp
*/
function yearAndMonth(uint256 ts) external pure returns (uint256, string memory) {
(uint256 year, uint256 month, , , , ) = BokkyPooBahsDateTimeLibrary.timestampToDateTime(ts);
return (year, monthAsString(month));
}
}
// File: contracts/libs/FormattedStrings.sol
pragma solidity ^0.8.10;
library FormattedStrings {
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
Base on OpenZeppelin `toString` method from `String` library
*/
function toFormattedString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
uint256 pos;
uint256 comas = digits / 3;
digits = digits + (digits % 3 == 0 ? comas - 1 : comas);
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
if (pos == 3) {
buffer[digits] = ",";
pos = 0;
} else {
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
pos++;
}
}
return string(buffer);
}
}
// File: contracts/libs/StringData.sol
pragma solidity ^0.8.10;
/*
Extra XEN quotes:
"When you realize nothing is lacking, the whole world belongs to you." - Lao Tzu
"Each morning, we are born again. What we do today is what matters most." - Buddha
"If you are depressed, you are living in the past." - Lao Tzu
"In true dialogue, both sides are willing to change." - Thich Nhat Hanh
"The spirit of the individual is determined by his domination thought habits." - Bruce Lee
"Be the path. Do not seek it." - Yara Tschallener
"Bow to no one but your own divinity." - Satya
"With insight there is hope for awareness, and with awareness there can be change." - Tom Kenyon
"The opposite of depression isn't happiness, it is purpose." - Derek Sivers
"If you can't, you must." - Tony Robbins
“When you are grateful, fear disappears and abundance appears.” - Lao Tzu
“It is in your moments of decision that your destiny is shaped.” - Tony Robbins
"Surmounting difficulty is the crucible that forms character." - Tony Robbins
"Three things cannot be long hidden: the sun, the moon, and the truth." - Buddha
"What you are is what you have been. What you’ll be is what you do now." - Buddha
"The best way to take care of our future is to take care of the present moment." - Thich Nhat Hanh
*/
/**
@dev a library to supply a XEN string data based on params
*/
library StringData {
uint256 public constant QUOTES_COUNT = 12;
uint256 public constant QUOTE_LENGTH = 66;
bytes public constant QUOTES =
bytes(
'"If you realize you have enough, you are truly rich." - Lao Tzu '
'"The real meditation is how you live your life." - Jon Kabat-Zinn '
'"To know that you do not know is the best." - Lao Tzu '
'"An over-sharpened sword cannot last long." - Lao Tzu '
'"When you accept yourself, the whole world accepts you." - Lao Tzu'
'"Music in the soul can be heard by the universe." - Lao Tzu '
'"As soon as you have made a thought, laugh at it." - Lao Tzu '
'"The further one goes, the less one knows." - Lao Tzu '
'"Stop thinking, and end your problems." - Lao Tzu '
'"Reliability is the foundation of commitment." - Unknown '
'"Your past does not equal your future." - Tony Robbins '
'"Be the path. Do not seek it." - Yara Tschallener '
);
uint256 public constant CLASSES_COUNT = 14;
uint256 public constant CLASSES_NAME_LENGTH = 10;
bytes public constant CLASSES =
bytes(
"Ruby "
"Opal "
"Topaz "
"Emerald "
"Aquamarine"
"Sapphire "
"Amethyst "
"Xenturion "
"Limited "
"Rare "
"Epic "
"Legendary "
"Exotic "
"Xunicorn "
);
/**
@dev Solidity doesn't yet support slicing of byte arrays anywhere outside of calldata,
therefore we make a hack by supplying our local constant packed string array as calldata
*/
function getQuote(bytes calldata quotes, uint256 index) external pure returns (string memory) {
if (index > QUOTES_COUNT - 1) return string(quotes[0:QUOTE_LENGTH]);
return string(quotes[index * QUOTE_LENGTH:(index + 1) * QUOTE_LENGTH]);
}
function getClassName(bytes calldata names, uint256 index) external pure returns (string memory) {
if (index < CLASSES_COUNT) return string(names[index * CLASSES_NAME_LENGTH:(index + 1) * CLASSES_NAME_LENGTH]);
return "";
}
}
// File: contracts/libs/SVG.sol
pragma solidity ^0.8.10;
/*
@dev Library to create SVG image for XENFT metadata
@dependency depends on DataTime.sol and StringData.sol libraries
*/
library SVG {
// Type to encode all data params for SVG image generation
struct SvgParams {
string symbol;
address xenAddress;
uint256 tokenId;
uint256 term;
uint256 rank;
uint256 count;
uint256 maturityTs;
uint256 amp;
uint256 eaa;
uint256 xenBurned;
bool redeemed;
string series;
}
// Type to encode SVG gradient stop color on HSL color scale
struct Color {
uint256 h;
uint256 s;
uint256 l;
uint256 a;
uint256 off;
}
// Type to encode SVG gradient
struct Gradient {
Color[] colors;
uint256 id;
uint256[4] coords;
}
using DateTime for uint256;
using Strings for uint256;
using FormattedStrings for uint256;
using Strings for address;
string private constant _STYLE =
"<style> "
".base {fill: #ededed;font-family:Montserrat,arial,sans-serif;font-size:30px;font-weight:400;} "
".series {text-transform: uppercase} "
".logo {font-size:200px;font-weight:100;} "
".meta {font-size:12px;} "
".small {font-size:8px;} "
".burn {font-weight:500;font-size:16px;} }"
"</style>";
string private constant _COLLECTOR =
"<g>"
"<path "
'stroke="#ededed" '
'fill="none" '
'transform="translate(265,418)" '
'd="m 0 0 L -20 -30 L -12.5 -38.5 l 6.5 7 L 0 -38.5 L 6.56 -31.32 L 12.5 -38.5 L 20 -30 L 0 0 L -7.345 -29.955 L 0 -38.5 L 7.67 -30.04 L 0 0 Z M 0 0 L -20.055 -29.955 l 7.555 -8.545 l 24.965 -0.015 L 20 -30 L -20.055 -29.955"/>'
"</g>";
string private constant _LIMITED =
"<g> "
'<path fill="#ededed" '
'transform="scale(0.4) translate(600, 940)" '
'd="M66,38.09q.06.9.18,1.71v.05c1,7.08,4.63,11.39,9.59,13.81,5.18,2.53,11.83,3.09,18.48,2.61,1.49-.11,3-.27,4.39-.47l1.59-.2c4.78-.61,11.47-1.48,13.35-5.06,1.16-2.2,1-5,0-8a38.85,38.85,0,0,0-6.89-11.73A32.24,32.24,0,0,0,95,21.46,21.2,21.2,0,0,0,82.3,20a23.53,23.53,0,0,0-12.75,7,15.66,15.66,0,0,0-2.35,3.46h0a20.83,20.83,0,0,0-1,2.83l-.06.2,0,.12A12,12,0,0,0,66,37.9l0,.19Zm26.9-3.63a5.51,5.51,0,0,1,2.53-4.39,14.19,14.19,0,0,0-5.77-.59h-.16l.06.51a5.57,5.57,0,0,0,2.89,4.22,4.92,4.92,0,0,0,.45.24ZM88.62,28l.94-.09a13.8,13.8,0,0,1,8,1.43,7.88,7.88,0,0,1,3.92,6.19l0,.43a.78.78,0,0,1-.66.84A19.23,19.23,0,0,1,98,37a12.92,12.92,0,0,1-6.31-1.44A7.08,7.08,0,0,1,88,30.23a10.85,10.85,0,0,1-.1-1.44.8.8,0,0,1,.69-.78ZM14.15,10c-.06-5.86,3.44-8.49,8-9.49C26.26-.44,31.24.16,34.73.7A111.14,111.14,0,0,1,56.55,6.4a130.26,130.26,0,0,1,22,10.8,26.25,26.25,0,0,1,3-.78,24.72,24.72,0,0,1,14.83,1.69,36,36,0,0,1,13.09,10.42,42.42,42.42,0,0,1,7.54,12.92c1.25,3.81,1.45,7.6-.23,10.79-2.77,5.25-10.56,6.27-16.12,7l-1.23.16a54.53,54.53,0,0,1-2.81,12.06A108.62,108.62,0,0,1,91.3,84v25.29a9.67,9.67,0,0,1,9.25,10.49c0,.41,0,.81,0,1.18a1.84,1.84,0,0,1-1.84,1.81H86.12a8.8,8.8,0,0,1-5.1-1.56,10.82,10.82,0,0,1-3.35-4,2.13,2.13,0,0,1-.2-.46L73.53,103q-2.73,2.13-5.76,4.16c-1.2.8-2.43,1.59-3.69,2.35l.6.16a8.28,8.28,0,0,1,5.07,4,15.38,15.38,0,0,1,1.71,7.11V121a1.83,1.83,0,0,1-1.83,1.83h-53c-2.58.09-4.47-.52-5.75-1.73A6.49,6.49,0,0,1,9.11,116v-11.2a42.61,42.61,0,0,1-6.34-11A38.79,38.79,0,0,1,1.11,70.29,37,37,0,0,1,13.6,50.54l.1-.09a41.08,41.08,0,0,1,11-6.38c7.39-2.9,17.93-2.77,26-2.68,5.21.06,9.34.11,10.19-.49a4.8,4.8,0,0,0,1-.91,5.11,5.11,0,0,0,.56-.84c0-.26,0-.52-.07-.78a16,16,0,0,1-.06-4.2,98.51,98.51,0,0,0-18.76-3.68c-7.48-.83-15.44-1.19-23.47-1.41l-1.35,0c-2.59,0-4.86,0-7.46-1.67A9,9,0,0,1,8,23.68a9.67,9.67,0,0,1-.91-5A10.91,10.91,0,0,1,8.49,14a8.74,8.74,0,0,1,3.37-3.29A8.2,8.2,0,0,1,14.15,10ZM69.14,22a54.75,54.75,0,0,1,4.94-3.24,124.88,124.88,0,0,0-18.8-9A106.89,106.89,0,0,0,34.17,4.31C31,3.81,26.44,3.25,22.89,4c-2.55.56-4.59,1.92-5,4.79a134.49,134.49,0,0,1,26.3,3.8,115.69,115.69,0,0,1,25,9.4ZM64,28.65c.21-.44.42-.86.66-1.28a15.26,15.26,0,0,1,1.73-2.47,146.24,146.24,0,0,0-14.92-6.2,97.69,97.69,0,0,0-15.34-4A123.57,123.57,0,0,0,21.07,13.2c-3.39-.08-6.3.08-7.47.72a5.21,5.21,0,0,0-2,1.94,7.3,7.3,0,0,0-1,3.12,6.1,6.1,0,0,0,.55,3.11,5.43,5.43,0,0,0,2,2.21c1.73,1.09,3.5,1.1,5.51,1.12h1.43c8.16.23,16.23.59,23.78,1.42a103.41,103.41,0,0,1,19.22,3.76,17.84,17.84,0,0,1,.85-2Zm-.76,15.06-.21.16c-1.82,1.3-6.48,1.24-12.35,1.17C42.91,45,32.79,44.83,26,47.47a37.41,37.41,0,0,0-10,5.81l-.1.08A33.44,33.44,0,0,0,4.66,71.17a35.14,35.14,0,0,0,1.5,21.32A39.47,39.47,0,0,0,12.35,103a1.82,1.82,0,0,1,.42,1.16v12a3.05,3.05,0,0,0,.68,2.37,4.28,4.28,0,0,0,3.16.73H67.68a10,10,0,0,0-1.11-3.69,4.7,4.7,0,0,0-2.87-2.32,15.08,15.08,0,0,0-4.4-.38h-26a1.83,1.83,0,0,1-.15-3.65c5.73-.72,10.35-2.74,13.57-6.25,3.06-3.34,4.91-8.1,5.33-14.45v-.13A18.88,18.88,0,0,0,46.35,75a20.22,20.22,0,0,0-7.41-4.42,23.54,23.54,0,0,0-8.52-1.25c-4.7.19-9.11,1.83-12,4.83a1.83,1.83,0,0,1-2.65-2.52c3.53-3.71,8.86-5.73,14.47-6a27.05,27.05,0,0,1,9.85,1.44,24,24,0,0,1,8.74,5.23,22.48,22.48,0,0,1,6.85,15.82v.08a2.17,2.17,0,0,1,0,.36c-.47,7.25-2.66,12.77-6.3,16.75a21.24,21.24,0,0,1-4.62,3.77H57.35q4.44-2.39,8.39-5c2.68-1.79,5.22-3.69,7.63-5.67a1.82,1.82,0,0,1,2.57.24,1.69,1.69,0,0,1,.35.66L81,115.62a7,7,0,0,0,2.16,2.62,5.06,5.06,0,0,0,3,.9H96.88a6.56,6.56,0,0,0-1.68-4.38,7.19,7.19,0,0,0-4.74-1.83c-.36,0-.69,0-1,0a1.83,1.83,0,0,1-1.83-1.83V83.6a1.75,1.75,0,0,1,.23-.88,105.11,105.11,0,0,0,5.34-12.46,52,52,0,0,0,2.55-10.44l-1.23.1c-7.23.52-14.52-.12-20.34-3A20,20,0,0,1,63.26,43.71Z"/>'
"</g>";
string private constant _APEX =
'<g transform="scale(0.5) translate(533, 790)">'
'<circle r="39" stroke="#ededed" fill="transparent"/>'
'<path fill="#ededed" '
'd="M0,38 a38,38 0 0 1 0,-76 a19,19 0 0 1 0,38 a19,19 0 0 0 0,38 z m -5 -57 a 5,5 0 1,0 10,0 a 5,5 0 1,0 -10,0 z" '
'fill-rule="evenodd"/>'
'<path fill="#ededed" '
'd="m -5, 19 a 5,5 0 1,0 10,0 a 5,5 0 1,0 -10,0"/>'
"</g>";
string private constant _LOGO =
'<path fill="#ededed" '
'd="M122.7,227.1 l-4.8,0l55.8,-74l0,3.2l-51.8,-69.2l5,0l48.8,65.4l-1.2,0l48.8,-65.4l4.8,0l-51.2,68.4l0,-1.6l55.2,73.2l-5,0l-52.8,-70.2l1.2,0l-52.8,70.2z" '
'vector-effect="non-scaling-stroke" />';
/**
@dev internal helper to create HSL-encoded color prop for SVG tags
*/
function colorHSL(Color memory c) internal pure returns (bytes memory) {
return abi.encodePacked("hsl(", c.h.toString(), ", ", c.s.toString(), "%, ", c.l.toString(), "%)");
}
/**
@dev internal helper to create `stop` SVG tag
*/
function colorStop(Color memory c) internal pure returns (bytes memory) {
return
abi.encodePacked(
'<stop stop-color="',
colorHSL(c),
'" stop-opacity="',
c.a.toString(),
'" offset="',
c.off.toString(),
'%"/>'
);
}
/**
@dev internal helper to encode position for `Gradient` SVG tag
*/
function pos(uint256[4] memory coords) internal pure returns (bytes memory) {
return
abi.encodePacked(
'x1="',
coords[0].toString(),
'%" '
'y1="',
coords[1].toString(),
'%" '
'x2="',
coords[2].toString(),
'%" '
'y2="',
coords[3].toString(),
'%" '
);
}
/**
@dev internal helper to create `Gradient` SVG tag
*/
function linearGradient(
Color[] memory colors,
uint256 id,
uint256[4] memory coords
) internal pure returns (bytes memory) {
string memory stops = "";
for (uint256 i = 0; i < colors.length; i++) {
if (colors[i].h != 0) {
stops = string.concat(stops, string(colorStop(colors[i])));
}
}
return
abi.encodePacked(
"<linearGradient ",
pos(coords),
'id="g',
id.toString(),
'">',
stops,
"</linearGradient>"
);
}
/**
@dev internal helper to create `Defs` SVG tag
*/
function defs(Gradient memory grad) internal pure returns (bytes memory) {
return abi.encodePacked("<defs>", linearGradient(grad.colors, 0, grad.coords), "</defs>");
}
/**
@dev internal helper to create `Rect` SVG tag
*/
function rect(uint256 id) internal pure returns (bytes memory) {
return
abi.encodePacked(
"<rect "
'width="100%" '
'height="100%" '
'fill="url(#g',
id.toString(),
')" '
'rx="10px" '
'ry="10px" '
'stroke-linejoin="round" '
"/>"
);
}
/**
@dev internal helper to create border `Rect` SVG tag
*/
function border() internal pure returns (string memory) {
return
"<rect "
'width="94%" '
'height="96%" '
'fill="transparent" '
'rx="10px" '
'ry="10px" '
'stroke-linejoin="round" '
'x="3%" '
'y="2%" '
'stroke-dasharray="1,6" '
'stroke="white" '
"/>";
}
/**
@dev internal helper to create group `G` SVG tag
*/
function g(uint256 gradientsCount) internal pure returns (bytes memory) {
string memory background = "";
for (uint256 i = 0; i < gradientsCount; i++) {
background = string.concat(background, string(rect(i)));
}
return abi.encodePacked("<g>", background, border(), "</g>");
}
/**
@dev internal helper to create XEN logo line pattern with 2 SVG `lines`
*/
function logo() internal pure returns (bytes memory) {
return abi.encodePacked();
}
/**
@dev internal helper to create `Text` SVG tag with XEN Crypto contract data
*/
function contractData(string memory symbol, address xenAddress) internal pure returns (bytes memory) {
return
abi.encodePacked(
"<text "
'x="50%" '
'y="5%" '
'class="base small" '
'dominant-baseline="middle" '
'text-anchor="middle">',
symbol,
unicode"・",
xenAddress.toHexString(),
"</text>"
);
}
/**
@dev internal helper to create cRank range string
*/
function rankAndCount(uint256 rank, uint256 count) internal pure returns (bytes memory) {
if (count == 1) return abi.encodePacked(rank.toString());
return abi.encodePacked(rank.toString(), "..", (rank + count - 1).toString());
}
/**
@dev internal helper to create 1st part of metadata section of SVG
*/
function meta1(
uint256 tokenId,
uint256 count,
uint256 eaa,
string memory series,
uint256 xenBurned
) internal pure returns (bytes memory) {
bytes memory part1 = abi.encodePacked(
"<text "
'x="50%" '
'y="50%" '
'class="base " '
'dominant-baseline="middle" '
'text-anchor="middle">'
"XEN CRYPTO"
"</text>"
"<text "
'x="50%" '
'y="56%" '
'class="base burn" '
'text-anchor="middle" '
'dominant-baseline="middle"> ',
xenBurned > 0 ? string.concat((xenBurned / 10**18).toFormattedString(), " X") : "",
"</text>"
"<text "
'x="18%" '
'y="62%" '
'class="base meta" '
'dominant-baseline="middle"> '
"#",
tokenId.toString(),
"</text>"
"<text "
'x="82%" '
'y="62%" '
'class="base meta series" '
'dominant-baseline="middle" '
'text-anchor="end" >',
series,
"</text>"
);
bytes memory part2 = abi.encodePacked(
"<text "
'x="18%" '
'y="68%" '
'class="base meta" '
'dominant-baseline="middle" >'
"VMU: ",
count.toString(),
"</text>"
"<text "
'x="18%" '
'y="72%" '
'class="base meta" '
'dominant-baseline="middle" >'
"EAA: ",
(eaa / 10).toString(),
"%"
"</text>"
);
return abi.encodePacked(part1, part2);
}
/**
@dev internal helper to create 2nd part of metadata section of SVG
*/
function meta2(
uint256 maturityTs,
uint256 amp,
uint256 term,
uint256 rank,
uint256 count
) internal pure returns (bytes memory) {
bytes memory part3 = abi.encodePacked(
"<text "
'x="18%" '
'y="76%" '
'class="base meta" '
'dominant-baseline="middle" >'
"AMP: ",
amp.toString(),
"</text>"
"<text "
'x="18%" '
'y="80%" '
'class="base meta" '
'dominant-baseline="middle" >'
"Term: ",
term.toString()
);
bytes memory part4 = abi.encodePacked(
" days"
"</text>"
"<text "
'x="18%" '
'y="84%" '
'class="base meta" '
'dominant-baseline="middle" >'
"cRank: ",
rankAndCount(rank, count),
"</text>"
"<text "
'x="18%" '
'y="88%" '
'class="base meta" '
'dominant-baseline="middle" >'
"Maturity: ",
maturityTs.asString(),
"</text>"
);
return abi.encodePacked(part3, part4);
}
/**
@dev internal helper to create `Text` SVG tag for XEN quote
*/
function quote(uint256 idx) internal pure returns (bytes memory) {
return
abi.encodePacked(
"<text "
'x="50%" '
'y="95%" '
'class="base small" '
'dominant-baseline="middle" '
'text-anchor="middle" >',
StringData.getQuote(StringData.QUOTES, idx),
"</text>"
);
}
/**
@dev internal helper to generate `Redeemed` stamp
*/
function stamp(bool redeemed) internal pure returns (bytes memory) {
if (!redeemed) return "";
return
abi.encodePacked(
"<rect "
'x="50%" '
'y="77.5%" '
'width="100" '
'height="40" '
'stroke="black" '
'stroke-width="1" '
'fill="none" '
'rx="5px" '
'ry="5px" '
'transform="translate(-50,-20) '
'rotate(-20,0,400)" />',
"<text "
'x="50%" '
'y="77.5%" '
'stroke="black" '
'class="base meta" '
'dominant-baseline="middle" '
'text-anchor="middle" '
'transform="translate(0,0) rotate(-20,-45,380)" >'
"Redeemed"
"</text>"
);
}
/**
@dev main internal helper to create SVG file representing XENFT
*/
function image(
SvgParams memory params,
Gradient[] memory gradients,
uint256 idx,
bool apex,
bool limited
) internal pure returns (bytes memory) {
string memory mark = limited ? _LIMITED : apex ? _APEX : _COLLECTOR;
bytes memory graphics = abi.encodePacked(defs(gradients[0]), _STYLE, g(gradients.length), _LOGO, mark);
bytes memory metadata = abi.encodePacked(
contractData(params.symbol, params.xenAddress),
meta1(params.tokenId, params.count, params.eaa, params.series, params.xenBurned),
meta2(params.maturityTs, params.amp, params.term, params.rank, params.count),
quote(idx),
stamp(params.redeemed)
);
return
abi.encodePacked(
"<svg "
'xmlns="http://www.w3.org/2000/svg" '
'preserveAspectRatio="xMinYMin meet" '
'viewBox="0 0 350 566">',
graphics,
metadata,
"</svg>"
);
}
}
// File: contracts/libs/Metadata.sol
pragma solidity ^0.8.10;
/**
@dev Library contains methods to generate on-chain NFT metadata
*/
library Metadata {
using DateTime for uint256;
using MintInfo for uint256;
using Strings for uint256;
uint256 public constant POWER_GROUP_SIZE = 7_500;
uint256 public constant MAX_POWER = 52_500;
uint256 public constant COLORS_FULL_SCALE = 300;
uint256 public constant SPECIAL_LUMINOSITY = 45;
uint256 public constant BASE_SATURATION = 75;
uint256 public constant BASE_LUMINOSITY = 38;
uint256 public constant GROUP_SATURATION = 100;
uint256 public constant GROUP_LUMINOSITY = 50;
uint256 public constant DEFAULT_OPACITY = 1;
uint256 public constant NO_COLOR = 360;
// PRIVATE HELPERS
// The following pure methods returning arrays are workaround to use array constants,
// not yet available in Solidity
function _powerGroupColors() private pure returns (uint256[8] memory) {
return [uint256(360), 1, 30, 60, 120, 180, 240, 300];
}
function _huesApex() private pure returns (uint256[3] memory) {
return [uint256(169), 210, 305];
}
function _huesLimited() private pure returns (uint256[3] memory) {
return [uint256(263), 0, 42];
}
function _stopOffsets() private pure returns (uint256[3] memory) {
return [uint256(10), 50, 90];
}
function _gradColorsRegular() private pure returns (uint256[4] memory) {
return [uint256(150), 150, 20, 20];
}
function _gradColorsBlack() private pure returns (uint256[4] memory) {
return [uint256(100), 100, 20, 20];
}
function _gradColorsSpecial() private pure returns (uint256[4] memory) {
return [uint256(100), 100, 0, 0];
}
/**
@dev private helper to determine XENFT group index by its power
(power = count of VMUs * mint term in days)
*/
function _powerGroup(uint256 vmus, uint256 term) private pure returns (uint256) {
return (vmus * term) / POWER_GROUP_SIZE;
}
/**
@dev private helper to generate SVG gradients for special XENFT categories
*/
function _specialClassGradients(bool rare) private pure returns (SVG.Gradient[] memory gradients) {
uint256[3] memory specialColors = rare ? _huesApex() : _huesLimited();
SVG.Color[] memory colors = new SVG.Color[](3);
for (uint256 i = 0; i < colors.length; i++) {
colors[i] = SVG.Color({
h: specialColors[i],
s: BASE_SATURATION,
l: SPECIAL_LUMINOSITY,
a: DEFAULT_OPACITY,
off: _stopOffsets()[i]
});
}
gradients = new SVG.Gradient[](1);
gradients[0] = SVG.Gradient({colors: colors, id: 0, coords: _gradColorsSpecial()});
}
/**
@dev private helper to generate SVG gradients for common XENFT category
*/
function _commonCategoryGradients(uint256 vmus, uint256 term)
private
pure
returns (SVG.Gradient[] memory gradients)
{
SVG.Color[] memory colors = new SVG.Color[](2);
uint256 powerHue = term * vmus > MAX_POWER ? NO_COLOR : 1 + (term * vmus * COLORS_FULL_SCALE) / MAX_POWER;
// group
uint256 groupHue = _powerGroupColors()[_powerGroup(vmus, term) > 7 ? 7 : _powerGroup(vmus, term)];
colors[0] = SVG.Color({
h: groupHue,
s: groupHue == NO_COLOR ? 0 : GROUP_SATURATION,
l: groupHue == NO_COLOR ? 0 : GROUP_LUMINOSITY,
a: DEFAULT_OPACITY,
off: _stopOffsets()[0]
});
// power
colors[1] = SVG.Color({
h: powerHue,
s: powerHue == NO_COLOR ? 0 : BASE_SATURATION,
l: powerHue == NO_COLOR ? 0 : BASE_LUMINOSITY,
a: DEFAULT_OPACITY,
off: _stopOffsets()[2]
});
gradients = new SVG.Gradient[](1);
gradients[0] = SVG.Gradient({
colors: colors,
id: 0,
coords: groupHue == NO_COLOR ? _gradColorsBlack() : _gradColorsRegular()
});
}
// PUBLIC INTERFACE
/**
@dev public interface to generate SVG image based on XENFT params
*/
function svgData(
uint256 tokenId,
uint256 count,
uint256 info,
address token,
uint256 burned
) external view returns (bytes memory) {
string memory symbol = IERC20Metadata(token).symbol();
(uint256 classIds, bool rare, bool limited) = info.getClass();
SVG.SvgParams memory params = SVG.SvgParams({
symbol: symbol,
xenAddress: token,
tokenId: tokenId,
term: info.getTerm(),
rank: info.getRank(),
count: count,
maturityTs: info.getMaturityTs(),
amp: info.getAMP(),
eaa: info.getEAA(),
xenBurned: burned,
series: StringData.getClassName(StringData.CLASSES, classIds),
redeemed: info.getRedeemed()
});
uint256 quoteIdx = uint256(keccak256(abi.encode(info))) % StringData.QUOTES_COUNT;
if (rare || limited) {
return SVG.image(params, _specialClassGradients(rare), quoteIdx, rare, limited);
}
return SVG.image(params, _commonCategoryGradients(count, info.getTerm()), quoteIdx, rare, limited);
}
function _attr1(
uint256 count,
uint256 rank,
uint256 class_
) private pure returns (bytes memory) {
return
abi.encodePacked(
'{"trait_type":"Class","value":"',
StringData.getClassName(StringData.CLASSES, class_),
'"},'
'{"trait_type":"VMUs","value":"',
count.toString(),
'"},'
'{"trait_type":"cRank","value":"',
rank.toString(),
'"},'
);
}
function _attr2(
uint256 amp,
uint256 eaa,
uint256 maturityTs
) private pure returns (bytes memory) {
(uint256 year, string memory month) = DateTime.yearAndMonth(maturityTs);
return
abi.encodePacked(
'{"trait_type":"AMP","value":"',
amp.toString(),
'"},'
'{"trait_type":"EAA (%)","value":"',
(eaa / 10).toString(),
'"},'
'{"trait_type":"Maturity Year","value":"',
year.toString(),
'"},'
'{"trait_type":"Maturity Month","value":"',
month,
'"},'
);
}
function _attr3(
uint256 maturityTs,
uint256 term,
uint256 burned
) private pure returns (bytes memory) {
return
abi.encodePacked(
'{"trait_type":"Maturity DateTime","value":"',
maturityTs.asString(),
'"},'
'{"trait_type":"Term","value":"',
term.toString(),
'"},'
'{"trait_type":"XEN Burned","value":"',
(burned / 10**18).toString(),
'"},'
);
}
function _attr4(bool apex, bool limited) private pure returns (bytes memory) {
string memory category = "Collector";
if (limited) category = "Limited";
if (apex) category = "Apex";
return abi.encodePacked('{"trait_type":"Category","value":"', category, '"}');
}
/**
@dev private helper to construct attributes portion of NFT metadata
*/
function attributes(
uint256 count,
uint256 burned,
uint256 mintInfo
) external pure returns (bytes memory) {
(
uint256 term,
uint256 maturityTs,
uint256 rank,
uint256 amp,
uint256 eaa,
uint256 series,
bool apex,
bool limited,
) = MintInfo.decodeMintInfo(mintInfo);
return
abi.encodePacked(
"[",
_attr1(count, rank, series),
_attr2(amp, eaa, maturityTs),
_attr3(maturityTs, term, burned),
_attr4(apex, limited),
"]"
);
}
function formattedString(uint256 n) public pure returns (string memory) {
return FormattedStrings.toFormattedString(n);
}
}
// File: contracts/libs/Array.sol
pragma solidity ^0.8.10;
library Array {
function idx(uint256[] memory arr, uint256 item) internal pure returns (uint256 i) {
for (i = 1; i <= arr.length; i++) {
if (arr[i - 1] == item) {
return i;
}
}
i = 0;
}
function addItem(uint256[] storage arr, uint256 item) internal {
if (idx(arr, item) == 0) {
arr.push(item);
}
}
function removeItem(uint256[] storage arr, uint256 item) internal {
uint256 i = idx(arr, item);
if (i > 0) {
arr[i - 1] = arr[arr.length - 1];
arr.pop();
}
}
function contains(uint256[] memory container, uint256[] memory items) internal pure returns (bool) {
if (items.length == 0) return true;
for (uint256 i = 0; i < items.length; i++) {
bool itemIsContained = false;
for (uint256 j = 0; j < container.length; j++) {
itemIsContained = items[i] == container[j];
}
if (!itemIsContained) return false;
}
return true;
}
function asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
function hasDuplicatesOrZeros(uint256[] memory array) internal pure returns (bool) {
for (uint256 i = 0; i < array.length; i++) {
if (array[i] == 0) return true;
for (uint256 j = 0; j < array.length; j++) {
if (array[i] == array[j] && i != j) return true;
}
}
return false;
}
function hasRoguesOrZeros(uint256[] memory array) internal pure returns (bool) {
uint256 _first = array[0];
for (uint256 i = 0; i < array.length; i++) {
if (array[i] == 0 || array[i] != _first) return true;
}
return false;
}
}
// File: contracts/XENFT.sol
pragma solidity ^0.8.10;
/*
\\ // ||||||||||| |\ || A CRYPTOCURRENCY FOR THE MASSES
\\ // || |\\ ||
\\ // || ||\\ || PRINCIPLES OF XEN:
\\// || || \\ || - No pre-mint; starts with zero supply
XX |||||||| || \\ || - No admin keys
//\\ || || \\ || - Immutable contract
// \\ || || \\||
// \\ || || \\|
// \\ ||||||||||| || \| Copyright (C) FairCrypto Foundation 2022
XENFT XEN Torrent props:
- count: number of VMUs
- mintInfo: (term, maturityTs, cRank start, AMP, EAA, apex, limited, group, redeemed)
*/
contract XENTorrent is
DefaultOperatorFilterer, // required to support OpenSea royalties
IXENTorrent,
IXENProxying,
IBurnableToken,
IBurnRedeemable,
ERC2771Context, // required to support meta transactions
IERC2981, // required to support NFT royalties
ERC721("XEN Torrent", "fmXENT")
{
// HELPER LIBRARIES
using Strings for uint256;
using MintInfo for uint256;
using Array for uint256[];
// PUBLIC CONSTANTS
// XENFT common business logic
uint256 public constant BLACKOUT_TERM = 7 * 24 * 3600; /* 7 days in sec */
// XENFT categories' params
uint256 public constant COMMON_CATEGORY_COUNTER = 10_001;
uint256 public constant SPECIAL_CATEGORIES_VMU_THRESHOLD = 39;
uint256 public constant LIMITED_CATEGORY_TIME_THRESHOLD = 3_600 * 24 * 365;
uint256 public constant POWER_GROUP_SIZE = 3_000;
string public constant AUTHORS = "@MrJackLevin @lbelyaev faircrypto.org";
uint256 public constant ROYALTY_BP = 500;
// PUBLIC MUTABLE STATE
// increasing counters for NFT tokenIds, also used as salt for proxies' spinning
uint256 public tokenIdCounter = COMMON_CATEGORY_COUNTER;
// Indexing of params by categories and classes:
// 0: Collector
// 1: Limited
// 2: Rare
// 3: Epic
// 4: Legendary
// 5: Exotic
// 6: Xunicorn
// [0, B1, B2, B3, B4, B5, B6]
uint256[] public specialClassesBurnRates;
// [0, 0, R1, R2, R3, R4, R5]
uint256[] public specialClassesTokenLimits;
// [0, 0, 0 + 1, R1+1, R2+1, R3+1, R4+1]
uint256[] public specialClassesCounters;
// mapping: NFT tokenId => count of Virtual Mining Units
mapping(uint256 => uint256) public vmuCount;
// mapping: NFT tokenId => burned XEN
mapping(uint256 => uint256) public xenBurned;
// mapping: NFT tokenId => MintInfo (used in tokenURI generation)
// MintInfo encoded as:
// term (uint16)
// | maturityTs (uint64)
// | rank (uint128)
// | amp (uint16)
// | eaa (uint16)
// | class (uint8):
// [7] isApex
// [6] isLimited
// [0-5] powerGroupIdx
// | redeemed (uint8)
mapping(uint256 => uint256) public mintInfo;
// PUBLIC IMMUTABLE STATE
// pointer to XEN Crypto contract
XENCrypto public immutable xenCrypto;
// genesisTs for the contract
uint256 public immutable genesisTs;
// start of operations block number
uint256 public immutable startBlockNumber;
// PRIVATE STATE
// original contract marking to distinguish from proxy copies
address private immutable _original;
// original deployer address to be used for setting trusted forwarder
address private immutable _deployer;
// address to be used for royalties' tracking
address private immutable _royaltyReceiver;
// reentrancy guard constants and state
// using non-zero constants to save gas avoiding repeated initialization
uint256 private constant _NOT_USED = 2**256 - 1; // 0xFF..FF
uint256 private constant _USED = _NOT_USED - 1; // 0xFF..FE
// used as both
// - reentrancy guard (_NOT_USED > _USED > _NOT_USED)
// - for keeping state while awaiting for OnTokenBurned callback (_NOT_USED > tokenId > _NOT_USED)
uint256 private _tokenId;
// mapping Address => tokenId[]
mapping(address => uint256[]) private _ownedTokens;
/**
@dev Constructor. Creates XEN Torrent contract, setting immutable parameters
*/
constructor(
address xenCrypto_,
uint256[] memory burnRates_,
uint256[] memory tokenLimits_,
uint256 startBlockNumber_,
address forwarder_,
address royaltyReceiver_
) ERC2771Context(forwarder_) {
require(xenCrypto_ != address(0), "bad address");
require(burnRates_.length == tokenLimits_.length && burnRates_.length > 0, "params mismatch");
_tokenId = _NOT_USED;
_original = address(this);
_deployer = msg.sender;
_royaltyReceiver = royaltyReceiver_ == address(0) ? msg.sender : royaltyReceiver_;
startBlockNumber = startBlockNumber_;
genesisTs = block.timestamp;
xenCrypto = XENCrypto(xenCrypto_);
specialClassesBurnRates = burnRates_;
specialClassesTokenLimits = tokenLimits_;
specialClassesCounters = new uint256[](tokenLimits_.length);
for (uint256 i = 2; i < specialClassesBurnRates.length - 1; i++) {
specialClassesCounters[i] = specialClassesTokenLimits[i + 1] + 1;
}
specialClassesCounters[specialClassesBurnRates.length - 1] = 1;
}
/**
@dev Call Reentrancy Guard
*/
modifier nonReentrant() {
require(_tokenId == _NOT_USED, "XENFT: Reentrancy detected");
_tokenId = _USED;
_;
_tokenId = _NOT_USED;
}
/**
@dev Start of Operations Guard
*/
modifier notBeforeStart() {
require(block.number > startBlockNumber, "XENFT: Not active yet");
_;
}
// INTERFACES & STANDARDS
// IERC165 IMPLEMENTATION
/**
@dev confirms support for IERC-165, IERC-721, IERC2981, IERC2771 and IBurnRedeemable interfaces
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return
interfaceId == type(IBurnRedeemable).interfaceId ||
interfaceId == type(IERC2981).interfaceId ||
interfaceId == type(IERC2771).interfaceId ||
super.supportsInterface(interfaceId);
}
// ERC2771 IMPLEMENTATION
/**
@dev use ERC2771Context implementation of _msgSender()
*/
function _msgSender() internal view virtual override(Context, ERC2771Context) returns (address) {
return ERC2771Context._msgSender();
}
/**
@dev use ERC2771Context implementation of _msgData()
*/
function _msgData() internal view virtual override(Context, ERC2771Context) returns (bytes calldata) {
return ERC2771Context._msgData();
}
// OWNABLE IMPLEMENTATION
/**
@dev public getter to check for deployer / owner (Opensea, etc.)
*/
function owner() external view returns (address) {
return _deployer;
}
// ERC-721 METADATA IMPLEMENTATION
/**
@dev compliance with ERC-721 standard (NFT); returns NFT metadata, including SVG-encoded image
*/
function tokenURI(uint256 tokenId) public view override returns (string memory) {
uint256 count = vmuCount[tokenId];
uint256 info = mintInfo[tokenId];
uint256 burned = xenBurned[tokenId];
require(count > 0);
bytes memory dataURI = abi.encodePacked(
"{",
'"name": "XEN Torrent #',
tokenId.toString(),
'",',
'"description": "XENFT: XEN Crypto Minting Torrent",',
'"image": "',
"data:image/svg+xml;base64,",
Base64.encode(Metadata.svgData(tokenId, count, info, address(xenCrypto), burned)),
'",',
'"attributes": ',
Metadata.attributes(count, burned, info),
"}"
);
return string(abi.encodePacked("data:application/json;base64,", Base64.encode(dataURI)));
}
// IMPLEMENTATION OF XENProxying INTERFACE
// FUNCTIONS IN PROXY COPY CONTRACTS (VMUs), CALLING ORIGINAL XEN CRYPTO CONTRACT
/**
@dev function callable only in proxy contracts from the original one => XENCrypto.claimRank(term)
*/
function callClaimRank(uint256 term) external {
require(msg.sender == _original, "XEN Proxy: unauthorized");
bytes memory callData = abi.encodeWithSignature("claimRank(uint256)", term);
(bool success, ) = address(xenCrypto).call(callData);
require(success, "call failed");
}
/**
@dev function callable only in proxy contracts from the original one => XENCrypto.claimMintRewardAndShare()
*/
function callClaimMintReward(address to) external {
require(msg.sender == _original, "XEN Proxy: unauthorized");
bytes memory callData = abi.encodeWithSignature("claimMintRewardAndShare(address,uint256)", to, uint256(100));
(bool success, ) = address(xenCrypto).call(callData);
require(success, "call failed");
}
/**
@dev function callable only in proxy contracts from the original one => destroys the proxy contract
*/
function powerDown() external {
require(msg.sender == _original, "XEN Proxy: unauthorized");
selfdestruct(payable(address(0)));
}
// OVERRIDING OF ERC-721 IMPLEMENTATION
// ENFORCEMENT OF TRANSFER BLACKOUT PERIOD
/**
@dev overrides OZ ERC-721 before transfer hook to check if there's no blackout period
*/
function _beforeTokenTransfer(
address from,
address,
uint256 tokenId
) internal virtual override {
if (from != address(0)) {
uint256 maturityTs = mintInfo[tokenId].getMaturityTs();
uint256 delta = maturityTs > block.timestamp ? maturityTs - block.timestamp : block.timestamp - maturityTs;
require(delta > BLACKOUT_TERM, "XENFT: transfer prohibited in blackout period");
}
}
/**
@dev overrides OZ ERC-721 after transfer hook to allow token enumeration for owner
*/
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
_ownedTokens[from].removeItem(tokenId);
_ownedTokens[to].addItem(tokenId);
}
// IBurnRedeemable IMPLEMENTATION
/**
@dev implements IBurnRedeemable interface for burning XEN and completing Bulk Mint for limited series
*/
function onTokenBurned(address user, uint256 burned) external {
require(_tokenId != _NOT_USED, "XENFT: illegal callback state");
require(msg.sender == address(xenCrypto), "XENFT: illegal callback caller");
_ownedTokens[user].addItem(_tokenId);
xenBurned[_tokenId] = burned;
_safeMint(user, _tokenId);
emit StartTorrent(user, vmuCount[_tokenId], mintInfo[_tokenId].getTerm());
_tokenId = _NOT_USED;
}
// IBurnableToken IMPLEMENTATION
/**
@dev burns XENTorrent XENFT which can be used by connected contracts services
*/
function burn(address user, uint256 tokenId) public notBeforeStart nonReentrant {
require(
IERC165(_msgSender()).supportsInterface(type(IBurnRedeemable).interfaceId),
"XENFT burn: not a supported contract"
);
require(user != address(0), "XENFT burn: illegal owner address");
require(tokenId > 0, "XENFT burn: illegal tokenId");
require(_isApprovedOrOwner(_msgSender(), tokenId), "XENFT burn: not an approved operator");
require(ownerOf(tokenId) == user, "XENFT burn: user is not tokenId owner");
_ownedTokens[user].removeItem(tokenId);
_burn(tokenId);
IBurnRedeemable(_msgSender()).onTokenBurned(user, tokenId);
}
// OVERRIDING ERC-721 IMPLEMENTATION TO ALLOW OPENSEA ROYALTIES ENFORCEMENT PROTOCOL
/**
@dev implements `setApprovalForAll` with additional approved Operator checking
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
super.setApprovalForAll(operator, approved);
}
/**
@dev implements `approve` with additional approved Operator checking
*/
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
super.approve(operator, tokenId);
}
/**
@dev implements `transferFrom` with additional approved Operator checking
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
super.transferFrom(from, to, tokenId);
}
/**
@dev implements `safeTransferFrom` with additional approved Operator checking
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId);
}
/**
@dev implements `safeTransferFrom` with additional approved Operator checking
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public override onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId, data);
}
// SUPPORT FOR ERC2771 META-TRANSACTIONS
/**
@dev Implements setting a `Trusted Forwarder` for meta-txs. Settable only once
*/
function addForwarder(address trustedForwarder) external {
require(msg.sender == _deployer, "XENFT: not an deployer");
require(_trustedForwarder == address(0), "XENFT: Forwarder is already set");
_trustedForwarder = trustedForwarder;
}
// SUPPORT FOR ERC2981 ROYALTY INFO
/**
@dev Implements getting Royalty Info by supported operators. ROYALTY_BP is expressed in basis points
*/
function royaltyInfo(uint256, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount) {
receiver = _royaltyReceiver;
royaltyAmount = (salePrice * ROYALTY_BP) / 10_000;
}
// XEN TORRENT PRIVATE / INTERNAL HELPERS
/**
@dev Sets specified XENFT as redeemed
*/
function _setRedeemed(uint256 tokenId) private {
mintInfo[tokenId] = mintInfo[tokenId] | uint256(1);
}
/**
@dev Determines power group index for Collector Category
*/
function _powerGroup(uint256 vmus, uint256 term) private pure returns (uint256) {
return (vmus * term) / POWER_GROUP_SIZE;
}
/**
@dev calculates Collector Class index
*/
function _classIdx(uint256 count, uint256 term) private pure returns (uint256 index) {
if (_powerGroup(count, term) > 7) return 7;
return _powerGroup(count, term);
}
/**
@dev internal helper to determine special class tier based on XEN to be burned
*/
function _specialTier(uint256 burning) private view returns (uint256) {
for (uint256 i = specialClassesBurnRates.length - 1; i > 0; i--) {
if (specialClassesBurnRates[i] == 0) {
return 0;
}
if (burning > specialClassesBurnRates[i] - 1) {
return i;
}
}
return 0;
}
/**
@dev internal helper to collect params and encode MintInfo
*/
function _mintInfo(
address proxy,
uint256 count,
uint256 term,
uint256 burning,
uint256 tokenId
) private view returns (uint256) {
bool apex = isApex(tokenId);
uint256 _class = _classIdx(count, term);
if (apex) _class = uint8(7 + _specialTier(burning)) | 0x80; // Apex Class
if (burning > 0 && !apex) _class = uint8(8) | 0x40; // Limited Class
(, , uint256 maturityTs, uint256 rank, uint256 amp, uint256 eaa) = xenCrypto.userMints(proxy);
return MintInfo.encodeMintInfo(term, maturityTs, rank, amp, eaa, _class, false);
}
/**
@dev internal torrent interface. initiates Bulk Mint (Torrent) Operation
*/
function _bulkClaimRank(
uint256 count,
uint256 term,
uint256 tokenId,
uint256 burning
) private {
bytes memory bytecode = bytes.concat(
bytes20(0x3D602d80600A3D3981F3363d3d373d3D3D363d73),
bytes20(address(this)),
bytes15(0x5af43d82803e903d91602b57fd5bf3)
);
bytes memory callData = abi.encodeWithSignature("callClaimRank(uint256)", term);
address proxy;
bool succeeded;
for (uint256 i = 1; i < count + 1; i++) {
bytes32 salt = keccak256(abi.encodePacked(i, tokenId));
assembly {
proxy := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
succeeded := call(gas(), proxy, 0, add(callData, 0x20), mload(callData), 0, 0)
}
require(succeeded, "XENFT: Error while claiming rank");
if (i == 1) {
mintInfo[tokenId] = _mintInfo(proxy, count, term, burning, tokenId);
}
}
vmuCount[tokenId] = count;
}
/**
@dev internal helper to claim tokenId (limited / ordinary)
*/
function _getTokenId(uint256 count, uint256 burning) private returns (uint256) {
// burn possibility has already been verified
uint256 tier = _specialTier(burning);
if (tier == 1) {
require(count > SPECIAL_CATEGORIES_VMU_THRESHOLD, "XENFT: under req VMU count");
require(block.timestamp < genesisTs + LIMITED_CATEGORY_TIME_THRESHOLD, "XENFT: limited time expired");
return tokenIdCounter++;
}
if (tier > 1) {
require(_msgSender() == tx.origin, "XENFT: only EOA allowed for this category");
require(count > SPECIAL_CATEGORIES_VMU_THRESHOLD, "XENFT: under req VMU count");
require(specialClassesCounters[tier] < specialClassesTokenLimits[tier] + 1, "XENFT: class sold out");
return specialClassesCounters[tier]++;
}
return tokenIdCounter++;
}
// PUBLIC GETTERS
/**
@dev public getter for tokens owned by address
*/
function ownedTokens() external view returns (uint256[] memory) {
return _ownedTokens[_msgSender()];
}
/**
@dev determines if tokenId corresponds to Limited Category
*/
function isApex(uint256 tokenId) public pure returns (bool apex) {
apex = tokenId < COMMON_CATEGORY_COUNTER;
}
// PUBLIC TRANSACTIONAL INTERFACE
/**
@dev public XEN Torrent interface
initiates Bulk Mint (Torrent) Operation (Common Category)
*/
function bulkClaimRank(uint256 count, uint256 term) public notBeforeStart returns (uint256 tokenId) {
require(_tokenId == _NOT_USED, "XENFT: reentrancy detected");
require(count > 0, "XENFT: Illegal count");
require(term > 0, "XENFT: Illegal term");
_tokenId = _getTokenId(count, 0);
_bulkClaimRank(count, term, _tokenId, 0);
_ownedTokens[_msgSender()].addItem(_tokenId);
_safeMint(_msgSender(), _tokenId);
emit StartTorrent(_msgSender(), count, term);
tokenId = _tokenId;
_tokenId = _NOT_USED;
}
/**
@dev public torrent interface. initiates Bulk Mint (Torrent) Operation (Special Category)
*/
function bulkClaimRankLimited(
uint256 count,
uint256 term,
uint256 burning
) public notBeforeStart returns (uint256) {
require(_tokenId == _NOT_USED, "XENFT: reentrancy detected");
require(count > 0, "XENFT: Illegal count");
require(term > 0, "XENFT: Illegal term");
require(burning > specialClassesBurnRates[1] - 1, "XENFT: not enough burn amount");
uint256 balance = IERC20(xenCrypto).balanceOf(_msgSender());
require(balance > burning - 1, "XENFT: not enough XEN balance");
uint256 approved = IERC20(xenCrypto).allowance(_msgSender(), address(this));
require(approved > burning - 1, "XENFT: not enough XEN balance approved for burn");
_tokenId = _getTokenId(count, burning);
_bulkClaimRank(count, term, _tokenId, burning);
IBurnableToken(xenCrypto).burn(_msgSender(), burning);
return _tokenId;
}
/**
@dev public torrent interface. initiates Mint Reward claim and collection and terminates Torrent Operation
*/
function bulkClaimMintReward(uint256 tokenId, address to) external notBeforeStart nonReentrant {
require(ownerOf(tokenId) == _msgSender(), "XENFT: Incorrect owner");
require(to != address(0), "XENFT: Illegal address");
require(!mintInfo[tokenId].getRedeemed(), "XENFT: Already redeemed");
bytes memory bytecode = bytes.concat(
bytes20(0x3D602d80600A3D3981F3363d3d373d3D3D363d73),
bytes20(address(this)),
bytes15(0x5af43d82803e903d91602b57fd5bf3)
);
uint256 end = vmuCount[tokenId] + 1;
bytes memory callData = abi.encodeWithSignature("callClaimMintReward(address)", to);
bytes memory callData1 = abi.encodeWithSignature("powerDown()");
for (uint256 i = 1; i < end; i++) {
bytes32 salt = keccak256(abi.encodePacked(i, tokenId));
bool succeeded;
bytes32 hash = keccak256(abi.encodePacked(hex"ff", address(this), salt, keccak256(bytecode)));
address proxy = address(uint160(uint256(hash)));
assembly {
succeeded := call(gas(), proxy, 0, add(callData, 0x20), mload(callData), 0, 0)
}
require(succeeded, "XENFT: Error while claiming rewards");
assembly {
succeeded := call(gas(), proxy, 0, add(callData1, 0x20), mload(callData1), 0, 0)
}
require(succeeded, "XENFT: Error while powering down");
}
_setRedeemed(tokenId);
emit EndTorrent(_msgSender(), tokenId, to);
}
}[{"inputs":[{"internalType":"address","name":"xenCrypto_","type":"address"},{"internalType":"uint256[]","name":"burnRates_","type":"uint256[]"},{"internalType":"uint256[]","name":"tokenLimits_","type":"uint256[]"},{"internalType":"uint256","name":"startBlockNumber_","type":"uint256"},{"internalType":"address","name":"forwarder_","type":"address"},{"internalType":"address","name":"royaltyReceiver_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"to","type":"address"}],"name":"EndTorrent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"xenContract","type":"address"},{"indexed":true,"internalType":"address","name":"tokenContract","type":"address"},{"indexed":false,"internalType":"uint256","name":"xenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"Redeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"count","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"term","type":"uint256"}],"name":"StartTorrent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"AUTHORS","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BLACKOUT_TERM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COMMON_CATEGORY_COUNTER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LIMITED_CATEGORY_TIME_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POWER_GROUP_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROYALTY_BP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SPECIAL_CATEGORIES_VMU_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"trustedForwarder","type":"address"}],"name":"addForwarder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"bulkClaimMintReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"}],"name":"bulkClaimRank","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"},{"internalType":"uint256","name":"burning","type":"uint256"}],"name":"bulkClaimRankLimited","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"callClaimMintReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"term","type":"uint256"}],"name":"callClaimRank","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"genesisTs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isApex","outputs":[{"internalType":"bool","name":"apex","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"burned","type":"uint256"}],"name":"onTokenBurned","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ownedTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"powerDown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"specialClassesBurnRates","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"specialClassesCounters","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"specialClassesTokenLimits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIdCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"vmuCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"xenBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xenCrypto","outputs":[{"internalType":"contract XENCrypto","name":"","type":"address"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000044c5776735f6def0aeb2cc76a526f2128ef68aa500000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c73fc08c931efe3fce850c09278472e8a81c2e0500000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000cecb8f27f4200f3a0000000000000000000000000000000000000000000000019d971e4fe8401e740000000000000000000000000000000000000000000000033b2e3c9fd0803ce800000000000000000000000000000000000000000000000813f3978f8940984400000000000000000000000000000000000000000000001027e72f1f128130880000000000000000000000000000000000000000000000204fce5e3e25026110000000000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000017700000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000000003e80000000000000000000000000000000000000000000000000000000000000064
-----Decoded View---------------
Arg [0] : xenCrypto_ (address): 0x44c5776735F6DEf0AEb2cC76a526f2128ef68Aa5
Arg [1] : burnRates_ (uint256[]): 0,250000000000000000000000000,500000000000000000000000000,1000000000000000000000000000,2500000000000000000000000000,5000000000000000000000000000,10000000000000000000000000000
Arg [2] : tokenLimits_ (uint256[]): 0,0,10000,6000,3000,1000,100
Arg [3] : startBlockNumber_ (uint256): 0
Arg [4] : forwarder_ (address): 0x0000000000000000000000000000000000000000
Arg [5] : royaltyReceiver_ (address): 0xC73Fc08C931Efe3FCE850C09278472e8a81c2e05
-----Encoded View---------------
22 Constructor Arguments found :
Arg [0] : 00000000000000000000000044c5776735f6def0aeb2cc76a526f2128ef68aa5
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [5] : 000000000000000000000000c73fc08c931efe3fce850c09278472e8a81c2e05
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [8] : 000000000000000000000000000000000000000000cecb8f27f4200f3a000000
Arg [9] : 0000000000000000000000000000000000000000019d971e4fe8401e74000000
Arg [10] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Arg [11] : 00000000000000000000000000000000000000000813f3978f89409844000000
Arg [12] : 00000000000000000000000000000000000000001027e72f1f12813088000000
Arg [13] : 0000000000000000000000000000000000000000204fce5e3e25026110000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [16] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [17] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [18] : 0000000000000000000000000000000000000000000000000000000000001770
Arg [19] : 0000000000000000000000000000000000000000000000000000000000000bb8
Arg [20] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000064
Library Used
Metadata : 0xa632ff9a3005a00cf5a66c198d82377f1a018cfdUnverifiedMintInfo : 0xfa1a995cf05bc5538801d1987f8eebc3e1dfd2a4Unverified
Deployed Bytecode Sourcemap
162480:22061:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;170298:315;;;;;;:::i;:::-;;:::i;:::-;;167891:364;;;;;;:::i;:::-;;:::i;:::-;;;750:14:1;;743:22;725:41;;713:2;698:18;167891:364:0;;;;;;;;163469:40;;163506:3;163469:40;;;;;923:25:1;;;911:2;896:18;163469:40:0;777:177:1;22938:100:0;;;:::i;:::-;;;;;;;:::i;24451:171::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;174440:157::-;;;;;;:::i;:::-;;:::i;180638:116::-;;;:::i;:::-;;;;;;;:::i;174706:197::-;;;;;;:::i;:::-;;:::i;176181:219::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;163331:48::-;;163374:5;163331:48;;102331:143;;102431:42;102331:143;;175016:205;;;;;;:::i;:::-;;:::i;164757:43::-;;;;;;:::i;:::-;;;;;;;;;;;;;;165041:41;;;;;163117:56;;163167:6;163117:56;;181876:945;;;;;;:::i;:::-;;:::i;172609:467::-;;;;;;:::i;:::-;;:::i;163180:61::-;;163239:2;163180:61;;105381:138;;;;;;:::i;:::-;;:::i;175735:267::-;;;;;;:::i;:::-;;:::i;22649:222::-;;;;;;:::i;:::-;;:::i;163248:74::-;;163306:16;163248:74;;22380:207;;;;;;:::i;:::-;;:::i;164881:36::-;;;;;164002:42;;;;;;:::i;:::-;;:::i;164097:39::-;;;;;;:::i;:::-;;:::i;168900:84::-;168967:9;168900:84;;171244:152;;;:::i;23107:104::-;;;:::i;163635:55::-;;;;;;173229:725;;;;;;:::i;:::-;;:::i;163002:53::-;;163042:13;163002:53;;164207:43;;;;;;:::i;:::-;;;;;;;;;;;;;;174160:176;;;;;;:::i;:::-;;:::i;175334:239::-;;;;;;:::i;:::-;;:::i;163388:72::-;;;:::i;164300:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;169154:876;;;;;;:::i;:::-;;:::i;163920:40::-;;;;;;:::i;:::-;;:::i;170756:353::-;;;;;;:::i;:::-;;:::i;164959:34::-;;;;;24920:164;;;;;;:::i;:::-;;:::i;181160:591::-;;;;;;:::i;:::-;;:::i;180848:124::-;;;;;;:::i;:::-;163167:6;-1:-1:-1;180931:33:0;180848:124;182963:1575;;;;;;:::i;:::-;;:::i;170298:315::-;170363:10;-1:-1:-1;;;;;170377:9:0;170363:23;;170355:59;;;;-1:-1:-1;;;170355:59:0;;;;;;;:::i;:::-;;;;;;;;;170425:21;170495:4;170449:51;;;;;;923:25:1;;911:2;896:18;;777:177;170449:51:0;;;;-1:-1:-1;;170449:51:0;;;;;;;;;;;;;;-1:-1:-1;;;;;170449:51:0;-1:-1:-1;;;170449:51:0;;;170530:33;170449:51;;-1:-1:-1;;;;;;;;170538:9:0;170530:23;;:33;;170449:51;;170530:33;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;170511:52;;;170582:7;170574:31;;;;-1:-1:-1;;;170574:31:0;;8943:2:1;170574:31:0;;;8925:21:1;8982:2;8962:18;;;8955:30;-1:-1:-1;;;9001:18:1;;;8994:41;9052:18;;170574:31:0;8741:335:1;170574:31:0;170344:269;;170298:315;:::o;167891:364::-;167993:4;-1:-1:-1;;;;;;168030:48:0;;-1:-1:-1;;;168030:48:0;;:106;;-1:-1:-1;;;;;;;168095:41:0;;-1:-1:-1;;;168095:41:0;168030:106;:164;;;-1:-1:-1;;;;;;;168153:41:0;;-1:-1:-1;;;168153:41:0;168030:164;:217;;;;168211:36;168235:11;168211:23;:36::i;:::-;168010:237;167891:364;-1:-1:-1;;167891:364:0:o;22938:100::-;22992:13;23025:5;23018:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22938:100;:::o;24451:171::-;24527:7;24547:23;24562:7;24547:14;:23::i;:::-;-1:-1:-1;24590:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24590:24:0;;24451:171::o;174440:157::-;174536:8;103852:30;103873:8;103852:20;:30::i;:::-;174557:32:::1;174571:8;174581:7;174557:13;:32::i;180638:116::-:0;180684:16;180720:12;:26;180733:12;:10;:12::i;:::-;-1:-1:-1;;;;;180720:26:0;-1:-1:-1;;;;;180720:26:0;;;;;;;;;;;;180713:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;180638:116;:::o;174706:197::-;174841:4;-1:-1:-1;;;;;103672:18:0;;103680:10;103672:18;103668:83;;103707:32;103728:10;103707:20;:32::i;:::-;174858:37:::1;174877:4;174883:2;174887:7;174858:18;:37::i;:::-;174706:197:::0;;;;:::o;176181:219::-;176316:16;176253;176386:6;176360:22;163506:3;176360:9;:22;:::i;:::-;176359:33;;;;:::i;:::-;176343:49;;176181:219;;;;;:::o;175016:205::-;175155:4;-1:-1:-1;;;;;103672:18:0;;103680:10;103672:18;103668:83;;103707:32;103728:10;103707:20;:32::i;:::-;175172:41:::1;175195:4;175201:2;175205:7;175172:22;:41::i;181876:945::-:0;182017:7;167634:16;167619:12;:31;167611:65;;;;-1:-1:-1;;;167611:65:0;;;;;;;:::i;:::-;-1:-1:-1;;182045:8:0::1;;:21;182037:60;;;;-1:-1:-1::0;;;182037:60:0::1;;;;;;;:::i;:::-;182124:1;182116:5;:9;182108:42;;;;-1:-1:-1::0;;;182108:42:0::1;;;;;;;:::i;:::-;182176:1;182169:4;:8;182161:40;;;;-1:-1:-1::0;;;182161:40:0::1;;;;;;;:::i;:::-;182259:1;182230:23;182254:1;182230:26;;;;;;;;:::i;:::-;;;;;;;;;:30;;;;:::i;:::-;182220:7;:40;182212:82;;;::::0;-1:-1:-1;;;182212:82:0;;11897:2:1;182212:82:0::1;::::0;::::1;11879:21:1::0;11936:2;11916:18;;;11909:30;11975:31;11955:18;;;11948:59;12024:18;;182212:82:0::1;11695:353:1::0;182212:82:0::1;182305:15;182330:9;-1:-1:-1::0;;;;;182323:27:0::1;;182351:12;:10;:12::i;:::-;182323:41;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;182305:59:::0;-1:-1:-1;182393:11:0::1;182403:1;182393:7:::0;:11:::1;:::i;:::-;182383:7;:21;182375:63;;;::::0;-1:-1:-1;;;182375:63:0;;12444:2:1;182375:63:0::1;::::0;::::1;12426:21:1::0;12483:2;12463:18;;;12456:30;12522:31;12502:18;;;12495:59;12571:18;;182375:63:0::1;12242:353:1::0;182375:63:0::1;182449:16;182475:9;-1:-1:-1::0;;;;;182468:27:0::1;;182496:12;:10;:12::i;:::-;182518:4;182468:56;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;182449:75:::0;-1:-1:-1;182554:11:0::1;182564:1;182554:7:::0;:11:::1;:::i;:::-;182543:8;:22;182535:82;;;::::0;-1:-1:-1;;;182535:82:0;;13111:2:1;182535:82:0::1;::::0;::::1;13093:21:1::0;13150:2;13130:18;;;13123:30;13189:34;13169:18;;;13162:62;-1:-1:-1;;;13240:18:1;;;13233:45;13295:19;;182535:82:0::1;12909:411:1::0;182535:82:0::1;182639:27;182651:5;182658:7;182639:11;:27::i;:::-;182628:8;:38;;;;182677:46;182692:5;182699:4;182705:8;;182715:7;182677:14;:46::i;:::-;182749:9;-1:-1:-1::0;;;;;182734:30:0::1;;182765:12;:10;:12::i;:::-;182779:7;182734:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;182805:8:0::1;::::0;;181876:945;-1:-1:-1;;;;;;;;181876:945:0:o;172609:467::-;-1:-1:-1;;172690:8:0;;:21;172682:63;;;;-1:-1:-1;;;172682:63:0;;13527:2:1;172682:63:0;;;13509:21:1;13566:2;13546:18;;;13539:30;13605:31;13585:18;;;13578:59;13654:18;;172682:63:0;13325:353:1;172682:63:0;172764:10;-1:-1:-1;;;;;172786:9:0;172764:32;;172756:75;;;;-1:-1:-1;;;172756:75:0;;13885:2:1;172756:75:0;;;13867:21:1;13924:2;13904:18;;;13897:30;13963:32;13943:18;;;13936:60;14013:18;;172756:75:0;13683:354:1;172756:75:0;172869:8;;-1:-1:-1;;;;;172842:18:0;;;;;;:12;:18;;;;;:36;;:26;:36::i;:::-;172899:8;;;172889:19;;;;:9;:19;;;;;:28;;;172944:8;172928:25;;172938:4;;172928:9;:25::i;:::-;172997:8;;172988:18;;;;:8;:18;;;;;;;;;173008:8;:18;;;;;;;;:28;;-1:-1:-1;;;173008:28:0;;;;;923:25:1;;;;-1:-1:-1;;;;;172969:68:0;;;;;172988:18;173008:26;;;;896:18:1;;173008:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;172969:68;;;14406:25:1;;;14462:2;14447:18;;14440:34;;;;14379:18;172969:68:0;;;;;;;-1:-1:-1;;;;173048:8:0;:20;172609:467::o;105381:138::-;105457:4;105494:17;-1:-1:-1;;;;;105481:30:0;;;105494:17;;105481:30;;105381:138::o;175735:267::-;175811:10;-1:-1:-1;;;;;175825:9:0;175811:23;;175803:58;;;;-1:-1:-1;;;175803:58:0;;14687:2:1;175803:58:0;;;14669:21:1;14726:2;14706:18;;;14699:30;-1:-1:-1;;;14745:18:1;;;14738:52;14807:18;;175803:58:0;14485:346:1;175803:58:0;175909:1;175880:17;-1:-1:-1;;;;;175880:17:0;:31;175872:75;;;;-1:-1:-1;;;175872:75:0;;15038:2:1;175872:75:0;;;15020:21:1;15077:2;15057:18;;;15050:30;15116:33;15096:18;;;15089:61;15167:18;;175872:75:0;14836:355:1;175872:75:0;175958:17;:36;;-1:-1:-1;;;;;;175958:36:0;-1:-1:-1;;;;;175958:36:0;;;;;;;;;;175735:267::o;22649:222::-;22721:7;22757:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22757:16:0;;22784:56;;;;-1:-1:-1;;;22784:56:0;;;;;;;:::i;22380:207::-;22452:7;-1:-1:-1;;;;;22480:19:0;;22472:73;;;;-1:-1:-1;;;22472:73:0;;15751:2:1;22472:73:0;;;15733:21:1;15790:2;15770:18;;;15763:30;15829:34;15809:18;;;15802:62;-1:-1:-1;;;15880:18:1;;;15873:39;15929:19;;22472:73:0;15549:405:1;22472:73:0;-1:-1:-1;;;;;;22563:16:0;;;;;:9;:16;;;;;;;22380:207::o;164002:42::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;164002:42:0;:::o;164097:39::-;;;;;;;;;;;;171244:152;171293:10;-1:-1:-1;;;;;171307:9:0;171293:23;;171285:59;;;;-1:-1:-1;;;171285:59:0;;;;;;;:::i;:::-;171384:1;171355:33;23107:104;23163:13;23196:7;23189:14;;;;;:::i;173229:725::-;167634:16;167619:12;:31;167611:65;;;;-1:-1:-1;;;167611:65:0;;;;;;;:::i;:::-;-1:-1:-1;;167376:8:0::1;;:21;167368:60;;;;-1:-1:-1::0;;;167368:60:0::1;;;;;;;:::i;:::-;165665:13;165677:1;-1:-1:-1::0;;165665:13:0::1;:::i;:::-;167439:8;:16:::0;173350:12:::2;:10;:12::i;:::-;173342:74;::::0;-1:-1:-1;;;173342:74:0;;-1:-1:-1;;;173342:74:0::2;::::0;::::2;16458:52:1::0;-1:-1:-1;;;;;173342:39:0;;;::::2;::::0;::::2;::::0;16431:18:1;;173342:74:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;173320:160;;;::::0;-1:-1:-1;;;173320:160:0;;16973:2:1;173320:160:0::2;::::0;::::2;16955:21:1::0;17012:2;16992:18;;;16985:30;17051:34;17031:18;;;17024:62;-1:-1:-1;;;17102:18:1;;;17095:34;17146:19;;173320:160:0::2;16771:400:1::0;173320:160:0::2;-1:-1:-1::0;;;;;173499:18:0;::::2;173491:64;;;::::0;-1:-1:-1;;;173491:64:0;;17378:2:1;173491:64:0::2;::::0;::::2;17360:21:1::0;17417:2;17397:18;;;17390:30;17456:34;17436:18;;;17429:62;-1:-1:-1;;;17507:18:1;;;17500:31;17548:19;;173491:64:0::2;17176:397:1::0;173491:64:0::2;173584:1;173574:7;:11;173566:51;;;::::0;-1:-1:-1;;;173566:51:0;;17780:2:1;173566:51:0::2;::::0;::::2;17762:21:1::0;17819:2;17799:18;;;17792:30;-1:-1:-1;;;17838:18:1;;;17831:57;17905:18;;173566:51:0::2;17578:351:1::0;173566:51:0::2;173636:41;173655:12;:10;:12::i;:::-;173669:7;173636:18;:41::i;:::-;173628:90;;;::::0;-1:-1:-1;;;173628:90:0;;18136:2:1;173628:90:0::2;::::0;::::2;18118:21:1::0;18175:2;18155:18;;;18148:30;18214:34;18194:18;;;18187:62;-1:-1:-1;;;18265:18:1;;;18258:34;18309:19;;173628:90:0::2;17934:400:1::0;173628:90:0::2;173757:4;-1:-1:-1::0;;;;;173737:24:0::2;:16;173745:7;173737;:16::i;:::-;-1:-1:-1::0;;;;;173737:24:0::2;;173729:74;;;::::0;-1:-1:-1;;;173729:74:0;;18541:2:1;173729:74:0::2;::::0;::::2;18523:21:1::0;18580:2;18560:18;;;18553:30;18619:34;18599:18;;;18592:62;-1:-1:-1;;;18670:18:1;;;18663:35;18715:19;;173729:74:0::2;18339:401:1::0;173729:74:0::2;-1:-1:-1::0;;;;;173814:18:0;::::2;;::::0;;;:12:::2;:18;::::0;;;;:38:::2;::::0;173844:7;173814:29:::2;:38::i;:::-;173863:14;173869:7;173863:5;:14::i;:::-;173904:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;173888:43:0::2;;173932:4;173938:7;173888:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;;;167478:8:0::1;:20:::0;-1:-1:-1;;;;173229:725:0:o;174160:176::-;174264:8;103852:30;103873:8;103852:20;:30::i;:::-;174285:43:::1;174309:8;174319;174285:23;:43::i;175334:239::-:0;175501:4;-1:-1:-1;;;;;103672:18:0;;103680:10;103672:18;103668:83;;103707:32;103728:10;103707:20;:32::i;:::-;175518:47:::1;175541:4;175547:2;175551:7;175560:4;175518:22;:47::i;:::-;175334:239:::0;;;;;:::o;163388:72::-;;;;;;;;;;;;;;;;;;;:::o;169154:876::-;169245:13;169261:17;;;:8;:17;;;;;;;;;169304:8;:17;;;;;;169349:9;:18;;;;;;169219:13;;169261:17;169304;169386:9;169378:18;;;;;;169407:20;169518:18;:7;:16;:18::i;:::-;169722:66;;-1:-1:-1;;;169722:66:0;;;;;19012:25:1;;;19053:18;;;19046:34;;;19096:18;;;19089:34;;;-1:-1:-1;;;;;169769:9:0;19159:32:1;19139:18;;;19132:60;19208:19;;;19201:35;;;169708:81:0;;169722:8;;:16;;18984:19:1;;169722:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;169722:66:0;;;;;;;;;;;;:::i;:::-;169708:13;:81::i;:::-;169854:40;;-1:-1:-1;;;169854:40:0;;;;;20109:25:1;;;20150:18;;;20143:34;;;20193:18;;;20186:34;;;169854:8:0;;:19;;20082:18:1;;169854:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;169854:40:0;;;;;;;;;;;;:::i;:::-;169430:493;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;169407:516;;169998:22;170012:7;169998:13;:22::i;:::-;169948:73;;;;;;;;:::i;:::-;;;;;;;;;;;;;169934:88;;;;;;169154:876;;;:::o;163920:40::-;;;;;;;;;;;;170756:353;170825:10;-1:-1:-1;;;;;170839:9:0;170825:23;;170817:59;;;;-1:-1:-1;;;170817:59:0;;;;;;;:::i;:::-;170887:21;170979:2;170991:3;170911:85;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;170911:85:0;;;;;;;;;;;;;;-1:-1:-1;;;;;170911:85:0;-1:-1:-1;;;170911:85:0;;;171026:33;170911:85;;-1:-1:-1;;;;;;;;171034:9:0;171026:23;;:33;;170911:85;;171026:33;:::i;24920:164::-;-1:-1:-1;;;;;25041:25:0;;;25017:4;25041:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24920:164::o;181160:591::-;181243:15;167634:16;167619:12;:31;167611:65;;;;-1:-1:-1;;;167611:65:0;;;;;;;:::i;:::-;-1:-1:-1;;181279:8:0::1;;:21;181271:60;;;;-1:-1:-1::0;;;181271:60:0::1;;;;;;;:::i;:::-;181358:1;181350:5;:9;181342:42;;;;-1:-1:-1::0;;;181342:42:0::1;;;;;;;:::i;:::-;181410:1;181403:4;:8;181395:40;;;;-1:-1:-1::0;;;181395:40:0::1;;;;;;;:::i;:::-;181457:21;181469:5;181476:1;181457:11;:21::i;:::-;181446:8;:32;;;;181489:40;181504:5;181511:4;181517:8;;181527:1;181489:14;:40::i;:::-;181540:44;181575:8;;181540:12;:26;181553:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;181540:26:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;181540:26:0;;:34:::1;:44::i;:::-;181595:33;181605:12;:10;:12::i;:::-;181619:8;;181595:9;:33::i;:::-;181657:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;181644:39:0::1;;181671:5;181678:4;181644:39;;;;;;14406:25:1::0;;;14462:2;14447:18;;14440:34;14394:2;14379:18;;14232:248;181644:39:0::1;;;;;;;;-1:-1:-1::0;;181704:8:0::1;::::0;;-1:-1:-1;;181723:20:0;;;181704:8;181160:591;-1:-1:-1;181160:591:0:o;182963:1575::-;167634:16;167619:12;:31;167611:65;;;;-1:-1:-1;;;167611:65:0;;;;;;;:::i;:::-;-1:-1:-1;;167376:8:0::1;;:21;167368:60;;;;-1:-1:-1::0;;;167368:60:0::1;;;;;;;:::i;:::-;165665:13;165677:1;-1:-1:-1::0;;165665:13:0::1;:::i;:::-;167439:8;:16:::0;183097:12:::2;:10;:12::i;:::-;-1:-1:-1::0;;;;;183077:32:0::2;:16;183085:7;183077;:16::i;:::-;-1:-1:-1::0;;;;;183077:32:0::2;;183069:67;;;::::0;-1:-1:-1;;;183069:67:0;;23147:2:1;183069:67:0::2;::::0;::::2;23129:21:1::0;23186:2;23166:18;;;23159:30;-1:-1:-1;;;23205:18:1;;;23198:52;23267:18;;183069:67:0::2;22945:346:1::0;183069:67:0::2;-1:-1:-1::0;;;;;183155:16:0;::::2;183147:51;;;::::0;-1:-1:-1;;;183147:51:0;;23498:2:1;183147:51:0::2;::::0;::::2;23480:21:1::0;23537:2;23517:18;;;23510:30;-1:-1:-1;;;23556:18:1;;;23549:52;23618:18;;183147:51:0::2;23296:346:1::0;183147:51:0::2;183218:17;::::0;;;:8:::2;:17;::::0;;;;;;;:31;;-1:-1:-1;;;183218:31:0;;::::2;::::0;::::2;923:25:1::0;;;;183218:29:0::2;::::0;::::2;::::0;896:18:1;;183218:31:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;183217:32;183209:68;;;::::0;-1:-1:-1;;;183209:68:0;;23849:2:1;183209:68:0::2;::::0;::::2;23831:21:1::0;23888:2;23868:18;;;23861:30;-1:-1:-1;;;23907:18:1;;;23900:53;23970:18;;183209:68:0::2;23647:347:1::0;183209:68:0::2;183312:182;::::0;183288:21:::2;::::0;183312:182:::2;::::0;-1:-1:-1;;;183339:51:0;183421:4:::2;183339:51;183405:22;::::0;-1:-1:-1;;;183442:41:0;183312:182:::2;;;:::i;:::-;;::::0;;-1:-1:-1;;183312:182:0;;::::2;::::0;;;;;;183505:11:::2;183519:17:::0;;;:8:::2;183312:182;183519:17:::0;;;;;183312:182;;-1:-1:-1;183505:11:0;183519:21:::2;::::0;183539:1:::2;183519:21;:::i;:::-;183505:35;;183551:21;183631:2;183575:59;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;183575:59:0;;::::2;::::0;;;;;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;183575:59:0;;::::2;-1:-1:-1::0;;;183575:59:0::2;::::0;;;183670:38;;;;;::::2;::::0;::::2;::::0;;;;;::::2;::::0;;;;::::2;-1:-1:-1::0;;;183670:38:0::2;::::0;;183575:59;;-1:-1:-1;183736:1:0::2;183719:727;183743:3;183739:1;:7;183719:727;;;183793:28;::::0;;::::2;::::0;;::::2;24694:19:1::0;;;24729:12;;;24722:28;;;183793::0;;;;;;;;;24766:12:1;;;;183793:28:0;;183783:39;;;;::::2;::::0;;;;183938:19;;;;::::2;::::0;-1:-1:-1;;;;;;183891:67:0;;;25075:26:1;183925:4:0::2;25134:15:1::0;;;-1:-1:-1;;;;;;25130:45:1;25117:11;;;25110:66;25192:12;;;25185:28;;;25229:12;;;;25222:28;;;;183891:67:0;;;;;;;;;;25266:12:1;;;;183891:67:0;;;183881:78;;;;::::2;::::0;;;;184120:15;;183783:39;;-1:-1:-1;;183881:78:0;;-1:-1:-1;;;;184099:19:0;::::2;-1:-1:-1::0;183881:78:0;184082:5:::2;184077:65;184064:78;;184179:9;184171:57;;;::::0;-1:-1:-1;;;184171:57:0;;25491:2:1;184171:57:0::2;::::0;::::2;25473:21:1::0;25530:2;25510:18;;;25503:30;25569:34;25549:18;;;25542:62;-1:-1:-1;;;25620:18:1;;;25613:33;25663:19;;184171:57:0::2;25289:399:1::0;184171:57:0::2;184349:1;184346::::0;184334:9:::2;184328:16;184321:4;184310:9;184306:20;184303:1;184296:5;184289;184284:67;184271:80;;184388:9;184380:54;;;::::0;-1:-1:-1;;;184380:54:0;;25895:2:1;184380:54:0::2;::::0;::::2;25877:21:1::0;;;25914:18;;;25907:30;25973:34;25953:18;;;25946:62;26025:18;;184380:54:0::2;25693:356:1::0;184380:54:0::2;183753:693;;;;183748:3;;;;;:::i;:::-;;;;183719:727;;;-1:-1:-1::0;176600:17:0;;;;:8;:17;;;;;;;176628:1;176600:30;176580:50;;184504:12:::2;:10;:12::i;:::-;-1:-1:-1::0;;;;;184493:37:0::2;;184518:7;184527:2;184493:37;;;;;;26368:25:1::0;;;-1:-1:-1;;;;;26429:32:1;26424:2;26409:18;;26402:60;26356:2;26341:18;;26194:274;184493:37:0::2;;;;;;;;-1:-1:-1::0;;;;167478:8:0::1;:20:::0;-1:-1:-1;;;;182963:1575:0:o;22011:305::-;22113:4;-1:-1:-1;;;;;;22150:40:0;;-1:-1:-1;;;22150:40:0;;:105;;-1:-1:-1;;;;;;;22207:48:0;;-1:-1:-1;;;22207:48:0;22150:105;:158;;;-1:-1:-1;;;;;;;;;;20553:40:0;;;22272:36;20444:157;32426:135;32508:16;32516:7;32508;:16::i;:::-;32500:53;;;;-1:-1:-1;;;32500:53:0;;;;;;;:::i;:::-;32426:135;:::o;103910:419::-;102431:42;104101:45;:49;104097:225;;104172:67;;-1:-1:-1;;;104172:67:0;;102431:42;;104172;;:67;;104223:4;;104230:8;;104172:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;104167:144;;104286:8;104267:28;;-1:-1:-1;;;104267:28:0;;;;;;;;:::i;23968:417::-;24049:13;24065:23;24080:7;24065:14;:23::i;:::-;24049:39;;24113:5;-1:-1:-1;;;;;24107:11:0;:2;-1:-1:-1;;;;;24107:11:0;;24099:57;;;;-1:-1:-1;;;24099:57:0;;26675:2:1;24099:57:0;;;26657:21:1;26714:2;26694:18;;;26687:30;26753:34;26733:18;;;26726:62;-1:-1:-1;;;26804:18:1;;;26797:31;26845:19;;24099:57:0;26473:397:1;24099:57:0;24207:5;-1:-1:-1;;;;;24191:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;24191:21:0;;:62;;;;24216:37;24233:5;24240:12;:10;:12::i;24216:37::-;24169:174;;;;-1:-1:-1;;;24169:174:0;;27077:2:1;24169:174:0;;;27059:21:1;27116:2;27096:18;;;27089:30;27155:34;27135:18;;;27128:62;27226:32;27206:18;;;27199:60;27276:19;;24169:174:0;26875:426:1;24169:174:0;24356:21;24365:2;24369:7;24356:8;:21::i;168378:149::-;168465:7;168492:27;:25;:27::i;:::-;168485:34;;168378:149;:::o;25151:336::-;25346:41;25365:12;:10;:12::i;25346:41::-;25338:100;;;;-1:-1:-1;;;25338:100:0;;;;;;;:::i;:::-;25451:28;25461:4;25467:2;25471:7;25451:9;:28::i;25558:185::-;25696:39;25713:4;25719:2;25723:7;25696:39;;;;;;;;;;;;:16;:39::i;179632:899::-;179702:7;179777:12;179792:21;179805:7;179792:12;:21::i;:::-;179777:36;;179828:4;179836:1;179828:9;179824:275;;163239:2;179862:5;:40;179854:79;;;;-1:-1:-1;;;179854:79:0;;;;;;;:::i;:::-;179974:43;163306:16;179974:9;:43;:::i;:::-;179956:15;:61;179948:101;;;;-1:-1:-1;;;179948:101:0;;28278:2:1;179948:101:0;;;28260:21:1;28317:2;28297:18;;;28290:30;-1:-1:-1;;;28336:18:1;;;28329:57;28403:18;;179948:101:0;28076:351:1;179948:101:0;180071:14;:16;;;:14;:16;;;:::i;:::-;;;;;180064:23;;;;;179824:275;180120:1;180113:4;:8;180109:381;;;180162:9;180146:12;:10;:12::i;:::-;-1:-1:-1;;;;;180146:25:0;;180138:79;;;;-1:-1:-1;;;180138:79:0;;28634:2:1;180138:79:0;;;28616:21:1;28673:2;28653:18;;;28646:30;28712:34;28692:18;;;28685:62;-1:-1:-1;;;28763:18:1;;;28756:39;28812:19;;180138:79:0;28432:405:1;180138:79:0;163239:2;180240:5;:40;180232:79;;;;-1:-1:-1;;;180232:79:0;;;;;;;:::i;:::-;180365:25;180391:4;180365:31;;;;;;;;:::i;:::-;;;;;;;;;180399:1;180365:35;;;;:::i;:::-;180334:22;180357:4;180334:28;;;;;;;;:::i;:::-;;;;;;;;;:66;180326:100;;;;-1:-1:-1;;;180326:100:0;;29044:2:1;180326:100:0;;;29026:21:1;29083:2;29063:18;;;29056:30;-1:-1:-1;;;29102:18:1;;;29095:51;29163:18;;180326:100:0;28842:345:1;180326:100:0;180448:22;180471:4;180448:28;;;;;;;;:::i;:::-;;;;;;;;;:30;;;;;;:::i;180109:381::-;180507:14;:16;;;:14;:16;;;:::i;:::-;;;;-1:-1:-1;180500:23:0;179632:899;-1:-1:-1;;;;179632:899:0:o;178456:1082::-;178629:182;;178605:21;;178629:182;;-1:-1:-1;;;178656:51:0;178738:4;178656:51;178722:22;;-1:-1:-1;;;178759:41:0;178629:182;;;:::i;:::-;;;;;;;;;;;;;178605:206;;178822:21;178896:4;178846:55;;;;;;923:25:1;;911:2;896:18;;777:177;178846:55:0;;;;-1:-1:-1;;178846:55:0;;;;;;;;;;;;;;-1:-1:-1;;;;;178846:55:0;-1:-1:-1;;;178846:55:0;;;;-1:-1:-1;;;178978:1:0;178961:534;178985:9;:5;178993:1;178985:9;:::i;:::-;178981:1;:13;178961:534;;;179041:28;;;;;;24694:19:1;;;24729:12;;;24722:28;;;179016:12:0;;24766::1;;179041:28:0;;;;;;;;;;;;179031:39;;;;;;179016:54;;179171:4;179160:8;179154:15;179147:4;179137:8;179133:19;179130:1;179122:54;179113:63;;179270:1;179267;179256:8;179250:15;179243:4;179233:8;179229:19;179226:1;179219:5;179212;179207:65;179194:78;;179309:9;179301:54;;;;-1:-1:-1;;;179301:54:0;;29394:2:1;179301:54:0;;;29376:21:1;;;29413:18;;;29406:30;29472:34;29452:18;;;29445:62;29524:18;;179301:54:0;29192:356:1;179301:54:0;179374:1;179379;179374:6;179370:114;;179421:47;179431:5;179438;179445:4;179451:7;179460;179421:9;:47::i;:::-;179401:17;;;;:8;:17;;;;;:67;179370:114;-1:-1:-1;178996:3:0;;;;:::i;:::-;;;;178961:534;;;-1:-1:-1;;;179505:17:0;;;;-1:-1:-1;;179505:8:0;:17;;-1:-1:-1;179505:17:0;;;:25;;;;-1:-1:-1;178456:1082:0:o;159884:147::-;159962:14;159966:3;159962:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;159971:4;159962:3;:14::i;:::-;159980:1;159962:19;159958:66;;159998:14;;;;;;;-1:-1:-1;159998:14:0;;;;;;;;;;159958:66;159884:147;;:::o;28544:110::-;28620:26;28630:2;28634:7;28620:26;;;;;;;;;;;;:9;:26::i;27938:264::-;28031:4;28048:13;28064:23;28079:7;28064:14;:23::i;:::-;28048:39;;28117:5;-1:-1:-1;;;;;28106:16:0;:7;-1:-1:-1;;;;;28106:16:0;;:52;;;;28126:32;28143:5;28150:7;28126:16;:32::i;:::-;28106:87;;;;28186:7;-1:-1:-1;;;;;28162:31:0;:20;28174:7;28162:11;:20::i;:::-;-1:-1:-1;;;;;28162:31:0;;28106:87;28098:96;27938:264;-1:-1:-1;;;;27938:264:0:o;160039:215::-;160116:9;160128:14;160132:3;160128:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;160137:4;160128:3;:14::i;:::-;160116:26;-1:-1:-1;160157:5:0;;160153:94;;160196:10;;160192:3;;160196:14;;160209:1;;160196:14;:::i;:::-;160192:19;;;;;;;;:::i;:::-;;;;;;;;;160179:3;160187:1;160183;:5;;;;:::i;:::-;160179:10;;;;;;;;:::i;:::-;;;;;;;;:32;;;;160226:3;:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;160105:149;160039:215;;:::o;30204:420::-;30264:13;30280:23;30295:7;30280:14;:23::i;:::-;30264:39;;30316:48;30337:5;30352:1;30356:7;30316:20;:48::i;:::-;30405:29;30422:1;30426:7;30405:8;:29::i;:::-;-1:-1:-1;;;;;30447:16:0;;;;;;:9;:16;;;;;:21;;30467:1;;30447:16;:21;;30467:1;;30447:21;:::i;:::-;;;;-1:-1:-1;;30486:16:0;;;;:7;:16;;;;;;30479:23;;-1:-1:-1;;;;;;30479:23:0;;;30520:36;30494:7;;30486:16;-1:-1:-1;;;;;30520:36:0;;;-1:-1:-1;;;;;;;;;;;30520:36:0;30486:16;;30520:36;30569:47;30589:5;30604:1;30608:7;30569:19;:47::i;24694:155::-;24789:52;24808:12;:10;:12::i;:::-;24822:8;24832;24789:18;:52::i;25814:323::-;25988:41;26007:12;:10;:12::i;:::-;26021:7;25988:18;:41::i;:::-;25980:100;;;;-1:-1:-1;;;25980:100:0;;;;;;;:::i;:::-;26091:38;26105:4;26111:2;26115:7;26124:4;26091:13;:38::i;17516:723::-;17572:13;17793:5;17802:1;17793:10;17789:53;;-1:-1:-1;;17820:10:0;;;;;;;;;;;;-1:-1:-1;;;17820:10:0;;;;;17516:723::o;17789:53::-;17867:5;17852:12;17908:78;17915:9;;17908:78;;17941:8;;;;:::i;:::-;;-1:-1:-1;17964:10:0;;-1:-1:-1;17972:2:0;17964:10;;:::i;:::-;;;17908:78;;;17996:19;18028:6;-1:-1:-1;;;;;18018:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18018:17:0;;17996:39;;18046:154;18053:10;;18046:154;;18080:11;18090:1;18080:11;;:::i;:::-;;-1:-1:-1;18149:10:0;18157:2;18149:5;:10;:::i;:::-;18136:24;;:2;:24;:::i;:::-;18123:39;;18106:6;18113;18106:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;18106:56:0;;;;;;;;-1:-1:-1;18177:11:0;18186:2;18177:11;;:::i;:::-;;;18046:154;;36631:3097;36689:13;36926:4;:11;36941:1;36926:16;36922:31;;-1:-1:-1;;36944:9:0;;;;;;;;;-1:-1:-1;36944:9:0;;;36631:3097::o;36922:31::-;37006:19;37028:6;;;;;;;;;;;;;;;;;37006:28;;37445:20;37504:1;37485:4;:11;37499:1;37485:15;;;;:::i;:::-;37484:21;;;;:::i;:::-;37479:27;;:1;:27;:::i;:::-;-1:-1:-1;;;;;37468:39:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37468:39:0;;37445:62;;37687:1;37680:5;37676:13;37791:2;37783:6;37779:15;37902:4;37954;37948:11;37942:4;37938:22;37864:1432;37988:6;37979:7;37976:19;37864:1432;;;38094:1;38085:7;38081:15;38070:26;;38133:7;38127:14;38786:4;38778:5;38774:2;38770:14;38766:25;38756:8;38752:40;38746:47;38735:9;38727:67;38840:1;38829:9;38825:17;38812:30;;38932:4;38924:5;38920:2;38916:14;38912:25;38902:8;38898:40;38892:47;38881:9;38873:67;38986:1;38975:9;38971:17;38958:30;;39077:4;39069:5;39066:1;39062:13;39058:24;39048:8;39044:39;39038:46;39027:9;39019:66;39131:1;39120:9;39116:17;39103:30;;39214:4;39207:5;39203:16;39193:8;39189:31;39183:38;39172:9;39164:58;;39268:1;39257:9;39253:17;39240:30;;37864:1432;;;37868:107;;39458:1;39451:4;39445:11;39441:19;39479:1;39474:123;;;;39616:1;39611:73;;;;39434:250;;39474:123;39527:4;39523:1;39512:9;39508:17;39500:32;39577:4;39573:1;39562:9;39558:17;39550:32;39474:123;;39611:73;39664:4;39660:1;39649:9;39645:17;39637:32;39434:250;-1:-1:-1;39714:6:0;;36631:3097;-1:-1:-1;;;;;36631:3097:0:o;27644:127::-;27709:4;27733:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27733:16:0;:30;;;27644:127::o;31705:174::-;31780:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;31780:29:0;-1:-1:-1;;;;;31780:29:0;;;;;;;;:24;;31834:23;31780:24;31834:14;:23::i;:::-;-1:-1:-1;;;;;31825:46:0;;;;;;;;;;;31705:174;;:::o;105527:458::-;105589:14;105620:30;105639:10;105620:18;:30::i;:::-;105616:362;;;-1:-1:-1;;;105873:14:0;105869:23;105856:37;105852:2;105848:46;105527:458;:::o;105616:362::-;-1:-1:-1;16954:10:0;;168378:149::o;30961:625::-;31120:4;-1:-1:-1;;;;;31093:31:0;:23;31108:7;31093:14;:23::i;:::-;-1:-1:-1;;;;;31093:31:0;;31085:81;;;;-1:-1:-1;;;31085:81:0;;30004:2:1;31085:81:0;;;29986:21:1;30043:2;30023:18;;;30016:30;30082:34;30062:18;;;30055:62;-1:-1:-1;;;30133:18:1;;;30126:35;30178:19;;31085:81:0;29802:401:1;31085:81:0;-1:-1:-1;;;;;31185:16:0;;31177:65;;;;-1:-1:-1;;;31177:65:0;;30410:2:1;31177:65:0;;;30392:21:1;30449:2;30429:18;;;30422:30;30488:34;30468:18;;;30461:62;-1:-1:-1;;;30539:18:1;;;30532:34;30583:19;;31177:65:0;30208:400:1;31177:65:0;31255:39;31276:4;31282:2;31286:7;31255:20;:39::i;:::-;31359:29;31376:1;31380:7;31359:8;:29::i;:::-;-1:-1:-1;;;;;31401:15:0;;;;;;:9;:15;;;;;:20;;31420:1;;31401:15;:20;;31420:1;;31401:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31432:13:0;;;;;;:9;:13;;;;;:18;;31449:1;;31432:13;:18;;31449:1;;31432:18;:::i;:::-;;;;-1:-1:-1;;31461:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31461:21:0;-1:-1:-1;;;;;31461:21:0;;;;;;;;;31500:27;;31461:16;;31500:27;;;;-1:-1:-1;;;;;;;;;;;31500:27:0;;31540:38;31560:4;31566:2;31570:7;31540:19;:38::i;177242:381::-;177340:23;:30;177303:7;;;;177340:34;;177373:1;;177340:34;:::i;:::-;177328:46;;177323:274;177376:5;;177323:274;;177407:23;177431:1;177407:26;;;;;;;;:::i;:::-;;;;;;;;;177437:1;177407:31;177403:80;;-1:-1:-1;177466:1:0;;177242:381;-1:-1:-1;;177242:381:0:o;177403:80::-;177540:1;177511:23;177535:1;177511:26;;;;;;;;:::i;:::-;;;;;;;;;:30;;;;:::i;:::-;177501:7;:40;177497:89;;;177569:1;177242:381;-1:-1:-1;;177242:381:0:o;177497:89::-;177383:3;;;;:::i;:::-;;;;177323:274;;;-1:-1:-1;177614:1:0;;177242:381;-1:-1:-1;;177242:381:0:o;177717:631::-;177888:7;177908:9;177920:15;177927:7;163167:6;-1:-1:-1;180931:33:0;180848:124;177920:15;177908:27;;177946:14;177963:22;177973:5;177980:4;177963:9;:22::i;:::-;177946:39;;178000:4;177996:58;;;178025:21;178038:7;178025:12;:21::i;:::-;178021:25;;:1;:25;:::i;:::-;178050:4;178015:39;178006:48;;;;177996:58;178093:1;178083:7;:11;:20;;;;;178099:4;178098:5;178083:20;178079:50;;;-1:-1:-1;178114:15:0;178079:50;178162:18;178182:12;178196:11;178209;178224:9;-1:-1:-1;;;;;178224:19:0;;178244:5;178224:26;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;178157:93;;;;;;;;;;178268:8;:23;178292:4;178298:10;178310:4;178316:3;178321;178326:6;178334:5;178268:72;;;;;;;;;;;;;;;;;;;;31635:25:1;;;31691:2;31676:18;;31669:34;;;;31734:2;31719:18;;31712:34;;;;31777:2;31762:18;;31755:34;;;;31820:3;31805:19;;31798:35;31864:3;31849:19;;31842:35;31921:14;31914:22;31908:3;31893:19;;31886:51;31622:3;31607:19;;31318:625;178268:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;178261:79;177717:631;-1:-1:-1;;;;;;;;;;;;177717:631:0:o;159632:244::-;159735:1;159726:127;159743:3;:10;159738:1;:15;159726:127;;159793:4;159779:3;159783:5;159787:1;159783;:5;:::i;:::-;159779:10;;;;;;;;:::i;:::-;;;;;;;:18;159775:67;159818:8;159775:67;159755:3;;;;:::i;:::-;;;;159726:127;;28881:319;29010:18;29016:2;29020:7;29010:5;:18::i;:::-;29061:53;29092:1;29096:2;29100:7;29109:4;29061:22;:53::i;:::-;29039:153;;;;-1:-1:-1;;;29039:153:0;;;;;;;:::i;171612:468::-;-1:-1:-1;;;;;171757:18:0;;;171753:320;;171792:18;171813:17;;;:8;:17;;;;;;;:33;;-1:-1:-1;;;171813:33:0;;;;;923:25:1;;;;171813:31:0;;;;896:18:1;;171813:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;171792:54;;171861:13;171890:15;171877:10;:28;:90;;171939:28;171957:10;171939:15;:28;:::i;:::-;171877:90;;;171908:28;171921:15;171908:10;:28;:::i;:::-;171861:106;;163042:13;171990:5;:21;171982:79;;;;-1:-1:-1;;;171982:79:0;;32569:2:1;171982:79:0;;;32551:21:1;32608:2;32588:18;;;32581:30;32647:34;32627:18;;;32620:62;-1:-1:-1;;;32698:18:1;;;32691:43;32751:19;;171982:79:0;32367:409:1;172198:233:0;-1:-1:-1;;;;;172341:18:0;;;;;;:12;:18;;;;;:38;;172371:7;172341:29;:38::i;:::-;-1:-1:-1;;;;;172390:16:0;;;;;;:12;:16;;;;;:33;;172415:7;172390:24;:33::i;32022:315::-;32177:8;-1:-1:-1;;;;;32168:17:0;:5;-1:-1:-1;;;;;32168:17:0;;32160:55;;;;-1:-1:-1;;;32160:55:0;;32983:2:1;32160:55:0;;;32965:21:1;33022:2;33002:18;;;32995:30;-1:-1:-1;;;33041:18:1;;;33034:55;33106:18;;32160:55:0;32781:349:1;32160:55:0;-1:-1:-1;;;;;32226:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;32226:46:0;;;;;;;;;;32288:41;;725::1;;;32288::0;;698:18:1;32288:41:0;;;;;;;32022:315;;;:::o;27018:313::-;27174:28;27184:4;27190:2;27194:7;27174:9;:28::i;:::-;27221:47;27244:4;27250:2;27254:7;27263:4;27221:22;:47::i;:::-;27213:110;;;;-1:-1:-1;;;27213:110:0;;;;;;;:::i;176940:188::-;177010:13;177067:1;177040:24;177052:5;177059:4;177040:11;:24::i;:::-;:28;177036:42;;;-1:-1:-1;177077:1:0;177070:8;;177036:42;177096:24;177108:5;177115:4;177096:11;:24::i;:::-;177089:31;176940:188;-1:-1:-1;;;176940:188:0:o;29536:439::-;-1:-1:-1;;;;;29616:16:0;;29608:61;;;;-1:-1:-1;;;29608:61:0;;33337:2:1;29608:61:0;;;33319:21:1;;;33356:18;;;33349:30;33415:34;33395:18;;;33388:62;33467:18;;29608:61:0;33135:356:1;29608:61:0;29689:16;29697:7;29689;:16::i;:::-;29688:17;29680:58;;;;-1:-1:-1;;;29680:58:0;;33698:2:1;29680:58:0;;;33680:21:1;33737:2;33717:18;;;33710:30;-1:-1:-1;;;33756:18:1;;;33749:58;33824:18;;29680:58:0;33496:352:1;29680:58:0;29751:45;29780:1;29784:2;29788:7;29751:20;:45::i;:::-;-1:-1:-1;;;;;29809:13:0;;;;;;:9;:13;;;;;:18;;29826:1;;29809:13;:18;;29826:1;;29809:18;:::i;:::-;;;;-1:-1:-1;;29838:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29838:21:0;-1:-1:-1;;;;;29838:21:0;;;;;;;;29877:33;;29838:16;;;-1:-1:-1;;;;;;;;;;;29877:33:0;29838:16;;29877:33;29923:44;29951:1;29955:2;29959:7;29923:19;:44::i;33125:853::-;33279:4;-1:-1:-1;;;;;33300:13:0;;9172:19;:23;33296:675;;33352:2;-1:-1:-1;;;;;33336:36:0;;33373:12;:10;:12::i;:::-;33387:4;33393:7;33402:4;33336:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33336:71:0;;;;;;;;-1:-1:-1;;33336:71:0;;;;;;;;;;;;:::i;:::-;;;33332:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33577:6;:13;33594:1;33577:18;33573:328;;33620:60;;-1:-1:-1;;;33620:60:0;;;;;;;:::i;33573:328::-;33851:6;33845:13;33836:6;33832:2;33828:15;33821:38;33332:584;-1:-1:-1;;;;;;33458:51:0;-1:-1:-1;;;33458:51:0;;-1:-1:-1;33451:58:0;;33296:675;-1:-1:-1;33955:4:0;33125:853;;;;;;:::o;176730:138::-;176801:7;163374:5;176829:11;176836:4;176829;:11;:::i;:::-;176828:32;;;;:::i;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:131::-;-1:-1:-1;;;;;;273:32:1;;263:43;;253:71;;320:1;317;310:12;335:245;393:6;446:2;434:9;425:7;421:23;417:32;414:52;;;462:1;459;452:12;414:52;501:9;488:23;520:30;544:5;520:30;:::i;959:250::-;1044:1;1054:113;1068:6;1065:1;1062:13;1054:113;;;1144:11;;;1138:18;1125:11;;;1118:39;1090:2;1083:10;1054:113;;;-1:-1:-1;;1201:1:1;1183:16;;1176:27;959:250::o;1214:271::-;1256:3;1294:5;1288:12;1321:6;1316:3;1309:19;1337:76;1406:6;1399:4;1394:3;1390:14;1383:4;1376:5;1372:16;1337:76;:::i;:::-;1467:2;1446:15;-1:-1:-1;;1442:29:1;1433:39;;;;1474:4;1429:50;;1214:271;-1:-1:-1;;1214:271:1:o;1490:220::-;1639:2;1628:9;1621:21;1602:4;1659:45;1700:2;1689:9;1685:18;1677:6;1659:45;:::i;1715:203::-;-1:-1:-1;;;;;1879:32:1;;;;1861:51;;1849:2;1834:18;;1715:203::o;1923:131::-;-1:-1:-1;;;;;1998:31:1;;1988:42;;1978:70;;2044:1;2041;2034:12;2059:315;2127:6;2135;2188:2;2176:9;2167:7;2163:23;2159:32;2156:52;;;2204:1;2201;2194:12;2156:52;2243:9;2230:23;2262:31;2287:5;2262:31;:::i;:::-;2312:5;2364:2;2349:18;;;;2336:32;;-1:-1:-1;;;2059:315:1:o;2379:632::-;2550:2;2602:21;;;2672:13;;2575:18;;;2694:22;;;2521:4;;2550:2;2773:15;;;;2747:2;2732:18;;;2521:4;2816:169;2830:6;2827:1;2824:13;2816:169;;;2891:13;;2879:26;;2960:15;;;;2925:12;;;;2852:1;2845:9;2816:169;;;-1:-1:-1;3002:3:1;;2379:632;-1:-1:-1;;;;;;2379:632:1:o;3016:456::-;3093:6;3101;3109;3162:2;3150:9;3141:7;3137:23;3133:32;3130:52;;;3178:1;3175;3168:12;3130:52;3217:9;3204:23;3236:31;3261:5;3236:31;:::i;:::-;3286:5;-1:-1:-1;3343:2:1;3328:18;;3315:32;3356:33;3315:32;3356:33;:::i;:::-;3016:456;;3408:7;;-1:-1:-1;;;3462:2:1;3447:18;;;;3434:32;;3016:456::o;3477:248::-;3545:6;3553;3606:2;3594:9;3585:7;3581:23;3577:32;3574:52;;;3622:1;3619;3612:12;3574:52;-1:-1:-1;;3645:23:1;;;3715:2;3700:18;;;3687:32;;-1:-1:-1;3477:248:1:o;3730:274::-;-1:-1:-1;;;;;3922:32:1;;;;3904:51;;3986:2;3971:18;;3964:34;3892:2;3877:18;;3730:274::o;4249:316::-;4326:6;4334;4342;4395:2;4383:9;4374:7;4370:23;4366:32;4363:52;;;4411:1;4408;4401:12;4363:52;-1:-1:-1;;4434:23:1;;;4504:2;4489:18;;4476:32;;-1:-1:-1;4555:2:1;4540:18;;;4527:32;;4249:316;-1:-1:-1;4249:316:1:o;4570:247::-;4629:6;4682:2;4670:9;4661:7;4657:23;4653:32;4650:52;;;4698:1;4695;4688:12;4650:52;4737:9;4724:23;4756:31;4781:5;4756:31;:::i;5048:118::-;5134:5;5127:13;5120:21;5113:5;5110:32;5100:60;;5156:1;5153;5146:12;5171:382;5236:6;5244;5297:2;5285:9;5276:7;5272:23;5268:32;5265:52;;;5313:1;5310;5303:12;5265:52;5352:9;5339:23;5371:31;5396:5;5371:31;:::i;:::-;5421:5;-1:-1:-1;5478:2:1;5463:18;;5450:32;5491:30;5450:32;5491:30;:::i;:::-;5540:7;5530:17;;;5171:382;;;;;:::o;5558:127::-;5619:10;5614:3;5610:20;5607:1;5600:31;5650:4;5647:1;5640:15;5674:4;5671:1;5664:15;5690:275;5761:2;5755:9;5826:2;5807:13;;-1:-1:-1;;5803:27:1;5791:40;;-1:-1:-1;;;;;5846:34:1;;5882:22;;;5843:62;5840:88;;;5908:18;;:::i;:::-;5944:2;5937:22;5690:275;;-1:-1:-1;5690:275:1:o;5970:186::-;6018:4;-1:-1:-1;;;;;6043:6:1;6040:30;6037:56;;;6073:18;;:::i;:::-;-1:-1:-1;6139:2:1;6118:15;-1:-1:-1;;6114:29:1;6145:4;6110:40;;5970:186::o;6161:1016::-;6256:6;6264;6272;6280;6333:3;6321:9;6312:7;6308:23;6304:33;6301:53;;;6350:1;6347;6340:12;6301:53;6389:9;6376:23;6408:31;6433:5;6408:31;:::i;:::-;6458:5;-1:-1:-1;6515:2:1;6500:18;;6487:32;6528:33;6487:32;6528:33;:::i;:::-;6580:7;-1:-1:-1;6634:2:1;6619:18;;6606:32;;-1:-1:-1;6689:2:1;6674:18;;6661:32;-1:-1:-1;;;;;6705:30:1;;6702:50;;;6748:1;6745;6738:12;6702:50;6771:22;;6824:4;6816:13;;6812:27;-1:-1:-1;6802:55:1;;6853:1;6850;6843:12;6802:55;6889:2;6876:16;6914:48;6930:31;6958:2;6930:31;:::i;:::-;6914:48;:::i;:::-;6985:2;6978:5;6971:17;7025:7;7020:2;7015;7011;7007:11;7003:20;7000:33;6997:53;;;7046:1;7043;7036:12;6997:53;7101:2;7096;7092;7088:11;7083:2;7076:5;7072:14;7059:45;7145:1;7140:2;7135;7128:5;7124:14;7120:23;7113:34;7166:5;7156:15;;;;;6161:1016;;;;;;;:::o;7182:388::-;7250:6;7258;7311:2;7299:9;7290:7;7286:23;7282:32;7279:52;;;7327:1;7324;7317:12;7279:52;7366:9;7353:23;7385:31;7410:5;7385:31;:::i;:::-;7435:5;-1:-1:-1;7492:2:1;7477:18;;7464:32;7505:33;7464:32;7505:33;:::i;7575:315::-;7643:6;7651;7704:2;7692:9;7683:7;7679:23;7675:32;7672:52;;;7720:1;7717;7710:12;7672:52;7756:9;7743:23;7733:33;;7816:2;7805:9;7801:18;7788:32;7829:31;7854:5;7829:31;:::i;7895:347::-;8097:2;8079:21;;;8136:2;8116:18;;;8109:30;-1:-1:-1;;;8170:2:1;8155:18;;8148:53;8233:2;8218:18;;7895:347::o;8247:197::-;8288:3;8326:5;8320:12;8341:65;8399:6;8394:3;8387:4;8380:5;8376:16;8341:65;:::i;:::-;8422:16;;;;;8247:197;-1:-1:-1;;8247:197:1:o;8449:287::-;8578:3;8616:6;8610:13;8632:66;8691:6;8686:3;8679:4;8671:6;8667:17;8632:66;:::i;:::-;8714:16;;;;;8449:287;-1:-1:-1;;8449:287:1:o;9081:380::-;9160:1;9156:12;;;;9203;;;9224:61;;9278:4;9270:6;9266:17;9256:27;;9224:61;9331:2;9323:6;9320:14;9300:18;9297:38;9294:161;;9377:10;9372:3;9368:20;9365:1;9358:31;9412:4;9409:1;9402:15;9440:4;9437:1;9430:15;9294:161;;9081:380;;;:::o;9466:127::-;9527:10;9522:3;9518:20;9515:1;9508:31;9558:4;9555:1;9548:15;9582:4;9579:1;9572:15;9598:168;9671:9;;;9702;;9719:15;;;9713:22;;9699:37;9689:71;;9740:18;;:::i;9771:127::-;9832:10;9827:3;9823:20;9820:1;9813:31;9863:4;9860:1;9853:15;9887:4;9884:1;9877:15;9903:120;9943:1;9969;9959:35;;9974:18;;:::i;:::-;-1:-1:-1;10008:9:1;;9903:120::o;10028:345::-;10230:2;10212:21;;;10269:2;10249:18;;;10242:30;-1:-1:-1;;;10303:2:1;10288:18;;10281:51;10364:2;10349:18;;10028:345::o;10378:350::-;10580:2;10562:21;;;10619:2;10599:18;;;10592:30;-1:-1:-1;;;10653:2:1;10638:18;;10631:56;10719:2;10704:18;;10378:350::o;10733:344::-;10935:2;10917:21;;;10974:2;10954:18;;;10947:30;-1:-1:-1;;;11008:2:1;10993:18;;10986:50;11068:2;11053:18;;10733:344::o;11082:343::-;11284:2;11266:21;;;11323:2;11303:18;;;11296:30;-1:-1:-1;;;11357:2:1;11342:18;;11335:49;11416:2;11401:18;;11082:343::o;11430:127::-;11491:10;11486:3;11482:20;11479:1;11472:31;11522:4;11519:1;11512:15;11546:4;11543:1;11536:15;11562:128;11629:9;;;11650:11;;;11647:37;;;11664:18;;:::i;12053:184::-;12123:6;12176:2;12164:9;12155:7;12151:23;12147:32;12144:52;;;12192:1;12189;12182:12;12144:52;-1:-1:-1;12215:16:1;;12053:184;-1:-1:-1;12053:184:1:o;12600:304::-;-1:-1:-1;;;;;12830:15:1;;;12812:34;;12882:15;;12877:2;12862:18;;12855:43;12762:2;12747:18;;12600:304::o;15196:348::-;15398:2;15380:21;;;15437:2;15417:18;;;15410:30;-1:-1:-1;;;15471:2:1;15456:18;;15449:54;15535:2;15520:18;;15196:348::o;15959:350::-;16161:2;16143:21;;;16200:2;16180:18;;;16173:30;-1:-1:-1;;;16234:2:1;16219:18;;16212:56;16300:2;16285:18;;15959:350::o;16521:245::-;16588:6;16641:2;16629:9;16620:7;16616:23;16612:32;16609:52;;;16657:1;16654;16647:12;16609:52;16689:9;16683:16;16708:28;16730:5;16708:28;:::i;19247:647::-;19326:6;19379:2;19367:9;19358:7;19354:23;19350:32;19347:52;;;19395:1;19392;19385:12;19347:52;19428:9;19422:16;-1:-1:-1;;;;;19453:6:1;19450:30;19447:50;;;19493:1;19490;19483:12;19447:50;19516:22;;19569:4;19561:13;;19557:27;-1:-1:-1;19547:55:1;;19598:1;19595;19588:12;19547:55;19627:2;19621:9;19652:48;19668:31;19696:2;19668:31;:::i;19652:48::-;19723:2;19716:5;19709:17;19763:7;19758:2;19753;19749;19745:11;19741:20;19738:33;19735:53;;;19784:1;19781;19774:12;19735:53;19797:67;19861:2;19856;19849:5;19845:14;19840:2;19836;19832:11;19797:67;:::i;:::-;19883:5;19247:647;-1:-1:-1;;;;;19247:647:1:o;20350:2124::-;-1:-1:-1;;;21502:16:1;;-1:-1:-1;;;21543:1:1;21534:11;;21527:76;21626:13;;-1:-1:-1;;21648:75:1;21626:13;21711:2;21702:12;;21695:4;21683:17;;21648:75;:::i;:::-;-1:-1:-1;;;21815:2:1;21742:16;;;21807:11;;;21800:23;;;21852:66;21847:2;21839:11;;21832:87;-1:-1:-1;;;21943:2:1;21935:11;;21928:71;-1:-1:-1;;;22023:2:1;22015:11;;22008:53;-1:-1:-1;;;22085:2:1;22077:11;;22070:49;22144:13;;22166:77;22144:13;22228:3;22220:12;;22213:4;22201:17;;22166:77;:::i;:::-;22303:3;22262:17;;22295:12;;;22288:24;-1:-1:-1;;;22336:3:1;22328:12;;22321:62;22399:69;22429:38;22462:3;22454:12;;22446:6;22429:38;:::i;:::-;-1:-1:-1;;;20296:16:1;;20337:1;20328:11;;20231:114;22399:69;22392:76;20350:2124;-1:-1:-1;;;;;;20350:2124:1:o;22479:461::-;22741:31;22736:3;22729:44;22711:3;22802:6;22796:13;22818:75;22886:6;22881:2;22876:3;22872:12;22865:4;22857:6;22853:17;22818:75;:::i;:::-;22913:16;;;;22931:2;22909:25;;22479:461;-1:-1:-1;;22479:461:1:o;23999:403::-;-1:-1:-1;;;;;;24238:15:1;;;24226:28;;24284:15;;;;24279:2;24270:12;;24263:37;-1:-1:-1;;;;;;24330:37:1;;;24325:2;24316:12;;24309:59;24393:2;24384:12;;23999:403::o;24407:125::-;24472:9;;;24493:10;;;24490:36;;;24506:18;;:::i;26054:135::-;26093:3;26114:17;;;26111:43;;26134:18;;:::i;:::-;-1:-1:-1;26181:1:1;26170:13;;26054:135::o;27306:410::-;27508:2;27490:21;;;27547:2;27527:18;;;27520:30;27586:34;27581:2;27566:18;;27559:62;-1:-1:-1;;;27652:2:1;27637:18;;27630:44;27706:3;27691:19;;27306:410::o;27721:350::-;27923:2;27905:21;;;27962:2;27942:18;;;27935:30;-1:-1:-1;;;27996:2:1;27981:18;;27974:56;28062:2;28047:18;;27721:350::o;29553:127::-;29614:10;29609:3;29605:20;29602:1;29595:31;29645:4;29642:1;29635:15;29669:4;29666:1;29659:15;29685:112;29717:1;29743;29733:35;;29748:18;;:::i;:::-;-1:-1:-1;29782:9:1;;29685:112::o;30613:136::-;30652:3;30680:5;30670:39;;30689:18;;:::i;:::-;-1:-1:-1;;;30725:18:1;;30613:136::o;30754:559::-;30869:6;30877;30885;30893;30901;30909;30962:3;30950:9;30941:7;30937:23;30933:33;30930:53;;;30979:1;30976;30969:12;30930:53;31011:9;31005:16;31030:31;31055:5;31030:31;:::i;:::-;31125:2;31110:18;;31104:25;31169:2;31154:18;;31148:25;31213:2;31198:18;;31192:25;31257:3;31242:19;;31236:26;31302:3;31287:19;;;31281:26;31080:5;;31104:25;;-1:-1:-1;31148:25:1;;31192;;-1:-1:-1;31236:26:1;-1:-1:-1;31281:26:1;;-1:-1:-1;30754:559:1;-1:-1:-1;;;30754:559:1:o;31948:414::-;32150:2;32132:21;;;32189:2;32169:18;;;32162:30;32228:34;32223:2;32208:18;;32201:62;-1:-1:-1;;;32294:2:1;32279:18;;32272:48;32352:3;32337:19;;31948:414::o;33853:489::-;-1:-1:-1;;;;;34122:15:1;;;34104:34;;34174:15;;34169:2;34154:18;;34147:43;34221:2;34206:18;;34199:34;;;34269:3;34264:2;34249:18;;34242:31;;;34047:4;;34290:46;;34316:19;;34308:6;34290:46;:::i;34347:249::-;34416:6;34469:2;34457:9;34448:7;34444:23;34440:32;34437:52;;;34485:1;34482;34475:12;34437:52;34517:9;34511:16;34536:30;34560:5;34536:30;:::i
Swarm Source
ipfs://1d02bb53b67cfbc2509efa1a74c59d4bbdc45f9bf3d83a6c6af7d0b19c2ea06c
[ 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.