ERC-20
Overview
Max Total Supply
1,000,000,000 XONE
Holders
13,529
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
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:
XONE
Compiler Version
v0.8.20+commit.a1b79de6
Optimization Enabled:
Yes with 20 runs
Other Settings:
london EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@faircrypto/xen-crypto/contracts/XENCrypto.sol"; import "@faircrypto/xen-crypto/contracts/interfaces/IBurnableToken.sol"; import "@faircrypto/xen-crypto/contracts/interfaces/IBurnRedeemable.sol"; import "@faircrypto/xenft/contracts/XENFT.sol"; import "@faircrypto/xen-stake/contracts/XENStake.sol"; import "@faircrypto/vmpx/contracts/VMPX.sol"; import "./libs/MintInfo_.sol"; import "./libs/StakeInfo_.sol"; contract XONE is Ownable, IBurnableToken, ERC20("XONE", "XONE"), ERC20Capped(1_000_000_000 ether) { using MintInfo_ for uint256; using StakeInfo_ for uint256; uint256 public constant BATCH_FLOOR = 1_000 ether; uint256 public constant BATCH_XEN = 10_000 ether; uint256 public constant BATCH_XEN_STAKE = 10_000 ether; uint256 public constant BATCH_STAKE_XENFT = 10_000 ether; uint256 public constant BATCH_VMPX = 10_000 ether; uint256 public constant BATCH_XEN_BURN = 12_000 ether; uint256 public constant BATCH_COLLECTOR_XENFT = 12_000 ether; uint256 public constant BATCH_LIMITED_XENFT = 15_000 ether; uint256 public constant BATCH_APEX_RARE_XENFT = 20_000 ether; uint256 public constant BATCH_APEX_EPIC_XENFT = 30_000 ether; uint256 public constant BATCH_APEX_LEGENDARY_XENFT = 50_000 ether; uint256 public constant BATCH_APEX_EXOTIC_XENFT = 100_000 ether; uint256 public constant BATCH_APEX_XUNICORN_XENFT = 1_000_000 ether; uint256 public constant START_TRANSFER_MARGIN = 100_000 ether; uint256 public constant XEN_THRESHOLD = 1_000_000 ether - 1 ether; uint256 public constant VMPX_THRESHOLD = 10 ether - 1 ether; uint256 public constant XONE_MIN_BURN = 0; string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org"; XENCrypto public immutable xenCrypto; XENTorrent public immutable xenTorrent; XENStake public immutable xenStake; VMPX public immutable vmpx; uint256 public immutable startBlockNumber; bool public mintingFinished; // user address => XONE mint amount mapping(address => uint256) public userMints; // tokenId => user address mapping(uint256 => address) public torrentTokensUsed; // tokenId => user address mapping(uint256 => address) public stakeTokensUsed; // user address => XEN burn amount mapping(address => uint256) public userBurns; constructor( address xenCryptoAddress, address xenTorrentAddress, address xenStakeAddress, address vmpxAddress, uint256 startBlockNumber_ ) { xenCrypto = XENCrypto(xenCryptoAddress); xenTorrent = XENTorrent(xenTorrentAddress); xenStake = XENStake(xenStakeAddress); vmpx = VMPX(vmpxAddress); startBlockNumber = startBlockNumber_; _mint(owner(), cap() / 2); } modifier notBeforeStart() { require(block.number > startBlockNumber, "XONE: Not active yet"); _; } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual override { require(mintingFinished || from == address(0), "XONE: minting not finished"); super._beforeTokenTransfer(from, to, amount); } function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual override { super._afterTokenTransfer(from, to, amount); if (from == address(0) && !mintingFinished && cap() - totalSupply() < START_TRANSFER_MARGIN) { mintingFinished = true; } } function _hasXEN() internal view returns (bool) { return ERC20(address(xenCrypto)).balanceOf(_msgSender()) > XEN_THRESHOLD; } function _hasXENStake() internal view returns (bool) { (, , uint256 amount, ) = xenCrypto.userStakes(_msgSender()); return amount > XEN_THRESHOLD; } function _hasXENBurns() internal view returns (bool) { return xenCrypto.userBurns(_msgSender()) > XEN_THRESHOLD; } function _hasVMPX() internal view returns (bool) { return ERC20(address(vmpx)).balanceOf(_msgSender()) > VMPX_THRESHOLD; } function _hasXeNFT() internal view returns (bool) { return ERC721(address(xenTorrent)).balanceOf(_msgSender()) > 0; } function _hasStakeXeNFT() internal view returns (bool) { return ERC721(address(xenStake)).balanceOf(_msgSender()) > 0; } function _getXenftBatch(uint256 tokenId) internal view returns (uint256 batch) { require(xenTorrent.ownerOf(tokenId) == _msgSender(), "XONE: not a XENFT owner"); uint256 mintInfo = xenTorrent.mintInfo(tokenId); batch = BATCH_COLLECTOR_XENFT; (, bool apex, bool limited) = mintInfo.getClass(); if (apex) { if (tokenId < xenTorrent.specialClassesTokenLimits(6)) { if (BATCH_APEX_XUNICORN_XENFT > batch) { batch = BATCH_APEX_XUNICORN_XENFT; } } else if (tokenId < xenTorrent.specialClassesTokenLimits(5)) { if (BATCH_APEX_EXOTIC_XENFT > batch) { batch = BATCH_APEX_EXOTIC_XENFT; } } else if (tokenId < xenTorrent.specialClassesTokenLimits(4)) { if (BATCH_APEX_LEGENDARY_XENFT > batch) { batch = BATCH_APEX_LEGENDARY_XENFT; } } else if (tokenId < xenTorrent.specialClassesTokenLimits(3)) { if (BATCH_APEX_EPIC_XENFT > batch) { batch = BATCH_APEX_EPIC_XENFT; } } else if (tokenId < xenTorrent.specialClassesTokenLimits(2)) { if (BATCH_APEX_RARE_XENFT > batch) { batch = BATCH_APEX_RARE_XENFT; } } } else if (limited && BATCH_LIMITED_XENFT > batch) { batch = BATCH_LIMITED_XENFT; } } function _getStakeXenftBatch(uint256 tokenId) internal view returns (uint256 batch) { require(xenStake.ownerOf(tokenId) == _msgSender(), "XONE: not a Stake XENFT owner"); uint256 stakeInfo = xenStake.stakeInfo(tokenId); uint256 amount = stakeInfo.getAmount() * 10 ** 18; if (amount > XEN_THRESHOLD) { batch = BATCH_STAKE_XENFT; } else { batch = BATCH_FLOOR; } } function _getBatch(uint256 tokenId, bool iStake) internal view returns (uint256 batch) { if (tokenId > 0 && _hasXeNFT() && !iStake) { batch = _getXenftBatch(tokenId); } else if (_hasXENBurns()) { batch = BATCH_XEN_BURN; } else if (tokenId > 0 && _hasStakeXeNFT() && iStake) { batch = _getStakeXenftBatch(tokenId); } else if (_hasXENStake()) { batch = BATCH_XEN_STAKE; } else if (_hasXEN()) { batch = BATCH_XEN; } else if (_hasVMPX()) { batch = BATCH_VMPX; } else { batch = BATCH_FLOOR; } } function _mint(address account, uint256 amount) internal virtual override (ERC20, ERC20Capped) { super._mint(account, amount); } function mint(uint256 tokenId, bool isStake) public notBeforeStart { require(msg.sender == tx.origin, "XONE: no contract calls"); require(userMints[_msgSender()] == 0, "XONE: already minted to this address"); if (tokenId != 0 && !isStake) { require(torrentTokensUsed[tokenId] == address(0), "XONE: XENFT already used"); } else if (tokenId != 0 && isStake) { require(stakeTokensUsed[tokenId] == address(0), "XONE: Stake XENFT already used"); } uint256 batch = BATCH_FLOOR; batch = _getBatch(tokenId, isStake); require(totalSupply() + batch <= cap(), "XONE: minting exceeds cap"); userMints[_msgSender()] = batch; if (tokenId != 0 && !isStake) { torrentTokensUsed[tokenId] = _msgSender(); } else if (tokenId != 0 && isStake) { stakeTokensUsed[tokenId] = _msgSender(); } _mint(_msgSender(), batch); } function burn(address user, uint256 amount) public { require(amount > XONE_MIN_BURN, "XONE: Below min limit"); require( IERC165(_msgSender()).supportsInterface(type(IBurnRedeemable).interfaceId), "XONE: not a supported contract" ); _spendAllowance(user, _msgSender(), amount); _burn(user, amount); userBurns[user] += amount; IBurnRedeemable(_msgSender()).onTokenBurned(user, amount); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; // mapping: NFT tokenId => StakeInfo_.sol (used in tokenURI generation + other contracts) // StakeInfo_.sol encoded as: // term (uint16) // | maturityTs (uint64) // | amount (uint128) TODO: storing here vs. separately as full uint256 ??? // | apy (uint16) // | rarityScore (uint16) // | rarityBits (uint16): // [15] tokenIdIsPrime // [14] tokenIdIsFib // [14] blockIdIsPrime // [13] blockIdIsFib // [0-13] ... library StakeInfo_ { /** @dev helper to convert Bool to U256 type and make compiler happy */ // TODO: remove if not needed ??? function toU256(bool x) internal pure returns (uint256 r) { assembly { r := x } } /** @dev encodes StakeInfo_.sol record from its props */ function encodeStakeInfo( uint256 term, uint256 maturityTs, uint256 amount, uint256 apy, uint256 rarityScore, uint256 rarityBits ) public pure returns (uint256 info) { info = info | (rarityBits & 0xFFFF); info = info | ((rarityScore & 0xFFFF) << 16); info = info | ((apy & 0xFFFF) << 32); info = info | ((amount & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) << 48); info = info | ((maturityTs & 0xFFFFFFFFFFFFFFFF) << 176); info = info | ((term & 0xFFFF) << 240); } /** @dev decodes StakeInfo_.sol record and extracts all of its props */ function decodeStakeInfo( uint256 info ) public pure returns (uint256 term, uint256 maturityTs, uint256 amount, uint256 apy, uint256 rarityScore, uint256 rarityBits) { term = uint16(info >> 240); maturityTs = uint64(info >> 176); amount = uint128(info >> 48); apy = uint16(info >> 32); rarityScore = uint16(info >> 16); rarityBits = uint16(info); } /** @dev extracts `term` prop from encoded StakeInfo_.sol */ function getTerm(uint256 info) public pure returns (uint256 term) { (term, , , , , ) = decodeStakeInfo(info); } /** @dev extracts `maturityTs` prop from encoded StakeInfo_.sol */ function getMaturityTs(uint256 info) public pure returns (uint256 maturityTs) { (, maturityTs, , , , ) = decodeStakeInfo(info); } /** @dev extracts `amount` prop from encoded StakeInfo_.sol */ function getAmount(uint256 info) public pure returns (uint256 amount) { (, , amount, , , ) = decodeStakeInfo(info); } /** @dev extracts `APY` prop from encoded StakeInfo_.sol */ function getAPY(uint256 info) public pure returns (uint256 apy) { (, , , apy, , ) = decodeStakeInfo(info); } /** @dev extracts `rarityScore` prop from encoded StakeInfo_.sol */ function getRarityScore(uint256 info) public pure returns (uint256 rarityScore) { (, , , , rarityScore, ) = decodeStakeInfo(info); } /** @dev extracts `rarityBits` prop from encoded StakeInfo_.sol */ function getRarityBits(uint256 info) public pure returns (uint256 rarityBits) { (, , , , , rarityBits) = decodeStakeInfo(info); } /** @dev decodes boolean flags from `rarityBits` prop */ function decodeRarityBits( uint256 rarityBits ) public pure returns (bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib) { isPrime = rarityBits & 0x0008 > 0; isFib = rarityBits & 0x0004 > 0; blockIsPrime = rarityBits & 0x0002 > 0; blockIsFib = rarityBits & 0x0001 > 0; } /** @dev encodes boolean flags to `rarityBits` prop */ function encodeRarityBits( bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib ) public pure returns (uint256 rarityBits) { rarityBits = rarityBits | ((toU256(isPrime) << 3) & 0xFFFF); rarityBits = rarityBits | ((toU256(isFib) << 2) & 0xFFFF); rarityBits = rarityBits | ((toU256(blockIsPrime) << 1) & 0xFFFF); rarityBits = rarityBits | ((toU256(blockIsFib)) & 0xFFFF); } /** @dev extracts `rarityBits` prop from encoded StakeInfo_.sol */ function getRarityBitsDecoded( uint256 info ) public pure returns (bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib) { (, , , , , uint256 rarityBits) = decodeStakeInfo(info); (isPrime, isFib, blockIsPrime, blockIsFib) = decodeRarityBits(rarityBits); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; // mapping: NFT tokenId => MintInfo_.sol (used in tokenURI generation) // MintInfo_.sol 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_.sol 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_.sol 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_.sol */ function getTerm(uint256 info) public pure returns (uint256 term) { (term, , , , , , , , ) = decodeMintInfo(info); } /** @dev extracts `maturityTs` prop from encoded MintInfo_.sol */ function getMaturityTs(uint256 info) public pure returns (uint256 maturityTs) { (, maturityTs, , , , , , , ) = decodeMintInfo(info); } /** @dev extracts `rank` prop from encoded MintInfo_.sol */ function getRank(uint256 info) public pure returns (uint256 rank) { (, , rank, , , , , , ) = decodeMintInfo(info); } /** @dev extracts `AMP` prop from encoded MintInfo_.sol */ function getAMP(uint256 info) public pure returns (uint256 amp) { (, , , amp, , , , , ) = decodeMintInfo(info); } /** @dev extracts `EAA` prop from encoded MintInfo_.sol */ function getEAA(uint256 info) public pure returns (uint256 eaa) { (, , , , eaa, , , , ) = decodeMintInfo(info); } /** @dev extracts `redeemed` prop from encoded MintInfo_.sol */ 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_.sol */ function getRedeemed(uint256 info) public pure returns (bool redeemed) { (, , , , , , , , redeemed) = decodeMintInfo(info); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E; address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol"; import {CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS} from "./lib/Constants.sol"; /** * @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. * Please note that if your token contract does not provide an owner with EIP-173, it must provide * administration methods on the contract itself to interact with the registry otherwise the subscription * will be locked to the options set during construction. */ abstract contract OperatorFilterer { /// @dev Emitted when an operator is not allowed. error OperatorNotAllowed(address operator); IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS); /// @dev The constructor that is called when the contract is being deployed. 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)); } } } } /** * @dev A helper function to check if an operator is allowed. */ 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); } _; } /** * @dev A helper function to check if an operator approval is allowed. */ modifier onlyAllowedOperatorApproval(address operator) virtual { _checkFilterOperator(operator); _; } /** * @dev A helper function to check if an operator is allowed. */ 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) { // under normal circumstances, this function will revert rather than return false, but inheriting contracts // may specify their own OperatorFilterRegistry implementations, which may behave differently if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; interface IOperatorFilterRegistry { /** * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns * true if supplied registrant address is not registered. */ function isOperatorAllowed(address registrant, address operator) external view returns (bool); /** * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner. */ function register(address registrant) external; /** * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes. */ function registerAndSubscribe(address registrant, address subscription) external; /** * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another * address without subscribing. */ function registerAndCopyEntries(address registrant, address registrantToCopy) external; /** * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner. * Note that this does not remove any filtered addresses or codeHashes. * Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes. */ function unregister(address addr) external; /** * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered. */ function updateOperator(address registrant, address operator, bool filtered) external; /** * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates. */ function updateOperators(address registrant, address[] calldata operators, bool filtered) external; /** * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered. */ function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; /** * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates. */ function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; /** * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous * subscription if present. * Note that accounts with subscriptions may go on to subscribe to other accounts - in this case, * subscriptions will not be forwarded. Instead the former subscription's existing entries will still be * used. */ function subscribe(address registrant, address registrantToSubscribe) external; /** * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes. */ function unsubscribe(address registrant, bool copyExistingEntries) external; /** * @notice Get the subscription address of a given registrant, if any. */ function subscriptionOf(address addr) external returns (address registrant); /** * @notice Get the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscribers(address registrant) external returns (address[] memory); /** * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscriberAt(address registrant, uint256 index) external returns (address); /** * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr. */ function copyEntriesOf(address registrant, address registrantToCopy) external; /** * @notice Returns true if operator is filtered by a given address or its subscription. */ function isOperatorFiltered(address registrant, address operator) external returns (bool); /** * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription. */ function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); /** * @notice Returns true if a codeHash is filtered by a given address or its subscription. */ function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); /** * @notice Returns a list of filtered operators for a given address or its subscription. */ function filteredOperators(address addr) external returns (address[] memory); /** * @notice Returns the set of filtered codeHashes for a given address or its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashes(address addr) external returns (bytes32[] memory); /** * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredOperatorAt(address registrant, uint256 index) external returns (address); /** * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); /** * @notice Returns true if an address has registered */ function isRegistered(address addr) external returns (bool); /** * @dev Convenience method to compute the code hash of an arbitrary contract */ function codeHashOf(address addr) external returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; import {OperatorFilterer} from "./OperatorFilterer.sol"; import {CANONICAL_CORI_SUBSCRIPTION} from "./lib/Constants.sol"; /** * @title DefaultOperatorFilterer * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription. * @dev Please note that if your token contract does not provide an owner with EIP-173, it must provide * administration methods on the contract itself to interact with the registry otherwise the subscription * will be locked to the options set during construction. */ abstract contract DefaultOperatorFilterer is OperatorFilterer { /// @dev The constructor that is called when the contract is being deployed. constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {} }
// SPDX-License-Identifier: BSD-4-Clause /* * 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 result += xh == hi >> 128 ? xl / y : 1; } 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); } } } }
// SPDX-License-Identifier: MIT // 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @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; } }
// SPDX-License-Identifier: MIT // 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); } }
// SPDX-License-Identifier: MIT // 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; } }
// SPDX-License-Identifier: MIT // 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; } }
// SPDX-License-Identifier: MIT // 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); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @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); }
// SPDX-License-Identifier: MIT // 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; import "./IERC721Receiver.sol"; import "./extensions/IERC721Metadata.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/Strings.sol"; import "../../utils/introspection/ERC165.sol"; /** * @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 {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol) pragma solidity ^0.8.0; import "../ERC20.sol"; /** * @dev Extension of {ERC20} that adds a cap to the supply of tokens. */ abstract contract ERC20Capped is ERC20 { uint256 private immutable _cap; /** * @dev Sets the value of the `cap`. This value is immutable, it can only be * set once during construction. */ constructor(uint256 cap_) { require(cap_ > 0, "ERC20Capped: cap is 0"); _cap = cap_; } /** * @dev Returns the cap on the token's total supply. */ function cap() public view virtual returns (uint256) { return _cap; } /** * @dev See {ERC20-_mint}. */ function _mint(address account, uint256 amount) internal virtual override { require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded"); super._mint(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `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 {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.0; import "../utils/introspection/IERC165.sol"; /** * @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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol) pragma solidity ^0.8.0; import "../utils/introspection/IERC165.sol";
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT 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 ""; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-libs/contracts/DateTime.sol"; import "@faircrypto/xen-libs/contracts/FormattedStrings.sol"; import "./StringData.sol"; /* @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>" ); } }
// SPDX-License-Identifier: MIT 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); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-libs/contracts/DateTime.sol"; import "@faircrypto/xen-libs/contracts/FormattedStrings.sol"; import "./MintInfo.sol"; import "./SVG.sol"; /** @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); } }
// SPDX-License-Identifier: MIT 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; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface IXENProxying { function callClaimRank(uint256 term) external; function callClaimMintReward(address to) external; function powerDown() external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/interfaces/IERC2981.sol"; import "@openzeppelin/contracts/utils/Base64.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-crypto/contracts/XENCrypto.sol"; import "@faircrypto/xen-crypto/contracts/interfaces/IBurnableToken.sol"; import "@faircrypto/xen-crypto/contracts/interfaces/IBurnRedeemable.sol"; import "operator-filter-registry/src/DefaultOperatorFilterer.sol"; import "@faircrypto/xen-libs/contracts/ERC2771Context.sol"; import "@faircrypto/xen-libs/contracts/interfaces/IERC2771.sol"; import "@faircrypto/xen-libs/contracts/Array.sol"; import "./interfaces/IXENTorrent.sol"; import "./interfaces/IXENProxying.sol"; import "./libs/MintInfo.sol"; import "./libs/Metadata.sol"; /* \\ // ||||||||||| |\ || 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", "XENT") { // 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 = 99; uint256 public constant LIMITED_CATEGORY_TIME_THRESHOLD = 3_600 * 24 * 365; uint256 public constant POWER_GROUP_SIZE = 7_500; 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 // uint256 ) 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 // uint256 ) 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); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-libs/contracts/DateTime.sol"; import "@faircrypto/xen-libs/contracts/FormattedStrings.sol"; /* @dev Library to create SVG image for XENFT metadata @dependency depends on DataTime.sol and StringData.sol libraries */ library StakeSVG { // Type to encode all data params for SVG image generation struct SvgParams { string symbol; address xenAddress; uint256 tokenId; uint256 term; uint256 maturityTs; uint256 amount; uint256 apy; uint256 rarityScore; uint256 rarityBits; } // 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 _STAKE = "<g>" "<path " 'stroke="#ededed" ' 'fill="none" ' 'transform="translate(250,379), scale(0.7)" ' 'd="m 0 5 a 5 5 0 0 1 5 -5 l 40 0 a 5 5 0 0 1 5 5 l 0 40 a 5 5 0 0 1 -5 5 l -40 0 a 5 5 0 0 1 -5 -5 l 0 -40z m 25 0 l 20 10 l -20 10 l -20 -10 l 20 -10 m 10 15 l 10 5 l -20 10 l -20 -10 l 10 -5 m 20 10 l 10 5 l -20 10 l -20 -10 l 10 -5"/>' "</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 1st part of metadata section of SVG */ function meta1( uint256 tokenId, uint256 amount, uint256 apy, uint256 rarityScore ) 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"> ', amount > 0 ? string.concat(amount.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" >STAKE</text>' ); bytes memory part2 = abi.encodePacked( "<text " 'x="18%" ' 'y="68%" ' 'class="base meta" ' 'dominant-baseline="middle" >' "APY: ", apy.toString(), "%" "</text>" "<text " 'x="18%" ' 'y="72%" ' 'class="base meta" ' 'dominant-baseline="middle" >' "Rarity: ", rarityScore.toString(), "</text>" ); return abi.encodePacked(part1, part2); } /** @dev internal helper to create 2nd part of metadata section of SVG */ function meta2(uint256 term, uint256 maturityTs) internal pure returns (bytes memory) { bytes memory part3 = abi.encodePacked( "<text " 'x="18%" ' 'y="76%" ' 'class="base meta" ' 'dominant-baseline="middle" >' "Term: ", term.toString(), " days" "</text>" "<text " 'x="18%" ' 'y="80%" ' 'class="base meta" ' 'dominant-baseline="middle" >' "Maturity: ", maturityTs.asString(), "</text>" ); return abi.encodePacked(part3); } /** @dev main internal helper to create SVG file representing XENFT */ function image(SvgParams memory params, Gradient[] memory gradients) internal pure returns (bytes memory) { string memory mark = _STAKE; 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.amount, params.apy, params.rarityScore), meta2(params.term, params.maturityTs) ); return abi.encodePacked( "<svg " 'xmlns="http://www.w3.org/2000/svg" ' 'preserveAspectRatio="xMinYMin meet" ' 'viewBox="0 0 350 566">', graphics, metadata, "</svg>" ); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-libs/contracts/DateTime.sol"; import "@faircrypto/xen-libs/contracts/FormattedStrings.sol"; import "./StakeSVG.sol"; import "./StakeInfo.sol"; /** @dev Library contains methods to generate on-chain NFT metadata */ library StakeMetadata { using DateTime for uint256; using StakeInfo for uint256; using Strings for uint256; // PRIVATE HELPERS // The following pure methods returning arrays are workaround to use array constants, // not yet available in Solidity /** @dev private helper to generate SVG gradients */ function _commonCategoryGradients() private pure returns (StakeSVG.Gradient[] memory gradients) { StakeSVG.Color[] memory colors = new StakeSVG.Color[](3); colors[0] = StakeSVG.Color({h: 50, s: 10, l: 36, a: 1, off: 0}); colors[1] = StakeSVG.Color({h: 50, s: 10, l: 12, a: 1, off: 50}); colors[2] = StakeSVG.Color({h: 50, s: 10, l: 5, a: 1, off: 100}); gradients = new StakeSVG.Gradient[](1); gradients[0] = StakeSVG.Gradient({colors: colors, id: 0, coords: [uint256(50), 0, 50, 100]}); } // PUBLIC INTERFACE /** @dev public interface to generate SVG image based on XENFT params */ function svgData(uint256 tokenId, uint256 info, address token) external view returns (bytes memory) { string memory symbol = IERC20Metadata(token).symbol(); StakeSVG.SvgParams memory params = StakeSVG.SvgParams({ symbol: symbol, xenAddress: token, tokenId: tokenId, term: info.getTerm(), maturityTs: info.getMaturityTs(), amount: info.getAmount(), apy: info.getAPY(), rarityScore: info.getRarityScore(), rarityBits: info.getRarityBits() }); return StakeSVG.image(params, _commonCategoryGradients()); } function _attr1(uint256 amount, uint256 apy) private pure returns (bytes memory) { return abi.encodePacked( '{"trait_type":"Amount","value":"', amount.toString(), '"},' '{"trait_type":"APY","value":"', apy.toString(), '%"},' ); } function _attr2(uint256 term, uint256 maturityTs) private pure returns (bytes memory) { (uint256 year, string memory month) = DateTime.yearAndMonth(maturityTs); return abi.encodePacked( '{"trait_type":"Maturity DateTime","value":"', maturityTs.asString(), '"},' '{"trait_type":"Term","value":"', term.toString(), '"},' '{"trait_type":"Maturity Year","value":"', year.toString(), '"},' '{"trait_type":"Maturity Month","value":"', month, '"},' ); } function _attr3(uint256 rarityScore, uint256) private pure returns (bytes memory) { return abi.encodePacked('{"trait_type":"Rarity","value":"', rarityScore.toString(), '"}'); } /** @dev private helper to construct attributes portion of NFT metadata */ function attributes(uint256 stakeInfo) external pure returns (bytes memory) { ( uint256 term, uint256 maturityTs, uint256 amount, uint256 apy, uint256 rarityScore, uint256 rarityBits ) = StakeInfo.decodeStakeInfo(stakeInfo); return abi.encodePacked("[", _attr1(amount, apy), _attr2(term, maturityTs), _attr3(rarityScore, rarityBits), "]"); } function formattedString(uint256 n) public pure returns (string memory) { return FormattedStrings.toFormattedString(n); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; // mapping: NFT tokenId => StakeInfo (used in tokenURI generation + other contracts) // StakeInfo encoded as: // term (uint16) // | maturityTs (uint64) // | amount (uint128) TODO: storing here vs. separately as full uint256 ??? // | apy (uint16) // | rarityScore (uint16) // | rarityBits (uint16): // [15] tokenIdIsPrime // [14] tokenIdIsFib // [14] blockIdIsPrime // [13] blockIdIsFib // [0-13] ... library StakeInfo { /** @dev helper to convert Bool to U256 type and make compiler happy */ // TODO: remove if not needed ??? function toU256(bool x) internal pure returns (uint256 r) { assembly { r := x } } /** @dev encodes StakeInfo record from its props */ function encodeStakeInfo( uint256 term, uint256 maturityTs, uint256 amount, uint256 apy, uint256 rarityScore, uint256 rarityBits ) public pure returns (uint256 info) { info = info | (rarityBits & 0xFFFF); info = info | ((rarityScore & 0xFFFF) << 16); info = info | ((apy & 0xFFFF) << 32); info = info | ((amount & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) << 48); info = info | ((maturityTs & 0xFFFFFFFFFFFFFFFF) << 176); info = info | ((term & 0xFFFF) << 240); } /** @dev decodes StakeInfo record and extracts all of its props */ function decodeStakeInfo( uint256 info ) public pure returns (uint256 term, uint256 maturityTs, uint256 amount, uint256 apy, uint256 rarityScore, uint256 rarityBits) { term = uint16(info >> 240); maturityTs = uint64(info >> 176); amount = uint128(info >> 48); apy = uint16(info >> 32); rarityScore = uint16(info >> 16); rarityBits = uint16(info); } /** @dev extracts `term` prop from encoded StakeInfo */ function getTerm(uint256 info) public pure returns (uint256 term) { (term, , , , , ) = decodeStakeInfo(info); } /** @dev extracts `maturityTs` prop from encoded StakeInfo */ function getMaturityTs(uint256 info) public pure returns (uint256 maturityTs) { (, maturityTs, , , , ) = decodeStakeInfo(info); } /** @dev extracts `amount` prop from encoded StakeInfo */ function getAmount(uint256 info) public pure returns (uint256 amount) { (, , amount, , , ) = decodeStakeInfo(info); } /** @dev extracts `APY` prop from encoded StakeInfo */ function getAPY(uint256 info) public pure returns (uint256 apy) { (, , , apy, , ) = decodeStakeInfo(info); } /** @dev extracts `rarityScore` prop from encoded StakeInfo */ function getRarityScore(uint256 info) public pure returns (uint256 rarityScore) { (, , , , rarityScore, ) = decodeStakeInfo(info); } /** @dev extracts `rarityBits` prop from encoded StakeInfo */ function getRarityBits(uint256 info) public pure returns (uint256 rarityBits) { (, , , , , rarityBits) = decodeStakeInfo(info); } /** @dev decodes boolean flags from `rarityBits` prop */ function decodeRarityBits( uint256 rarityBits ) public pure returns (bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib) { isPrime = rarityBits & 0x0008 > 0; isFib = rarityBits & 0x0004 > 0; blockIsPrime = rarityBits & 0x0002 > 0; blockIsFib = rarityBits & 0x0001 > 0; } /** @dev encodes boolean flags to `rarityBits` prop */ function encodeRarityBits( bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib ) public pure returns (uint256 rarityBits) { rarityBits = rarityBits | ((toU256(isPrime) << 3) & 0xFFFF); rarityBits = rarityBits | ((toU256(isFib) << 2) & 0xFFFF); rarityBits = rarityBits | ((toU256(blockIsPrime) << 1) & 0xFFFF); rarityBits = rarityBits | ((toU256(blockIsFib)) & 0xFFFF); } /** @dev extracts `rarityBits` prop from encoded StakeInfo */ function getRarityBitsDecoded( uint256 info ) public pure returns (bool isPrime, bool isFib, bool blockIsPrime, bool blockIsFib) { (, , , , , uint256 rarityBits) = decodeStakeInfo(info); (isPrime, isFib, blockIsPrime, blockIsFib) = decodeRarityBits(rarityBits); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface IXENStakeProxying { function callStake(uint256 amount, uint256 term) external; function callTransfer(address to) external; function callWithdraw() external; function powerDown() external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface IXENStake { event CreateStake(address indexed user, uint256 indexed tokenId, uint256 amount, uint256 term); event EndStake(address indexed user, uint256 indexed tokenId); function createStake(uint256 amount, uint256 term) external returns (uint256); function endStake(uint256 tokenId) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/interfaces/IERC2981.sol"; import "@openzeppelin/contracts/utils/Base64.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "@faircrypto/xen-crypto/contracts/XENCrypto.sol"; import "@faircrypto/xen-crypto/contracts/interfaces/IBurnableToken.sol"; import "@faircrypto/magic-numbers/contracts/MagicNumbers.sol"; import "operator-filter-registry/src/DefaultOperatorFilterer.sol"; import "@faircrypto/xen-libs/contracts/ERC2771Context.sol"; import "@faircrypto/xen-libs/contracts/interfaces/IERC2771.sol"; import "@faircrypto/xen-libs/contracts/Array.sol"; import "./libs/StakeInfo.sol"; import "./libs/StakeMetadata.sol"; import "./interfaces/IXENStake.sol"; import "./interfaces/IXENStakeProxying.sol"; /* \\ // ||||||||||| |\ || 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-23 XENFT XEN Stake props: - amount, term, maturityTs, APY, rarityScore */ contract XENStake is DefaultOperatorFilterer, // required to support OpenSea royalties IXENStake, IXENStakeProxying, IBurnableToken, ERC2771Context, // required to support meta transactions IERC2981, // required to support NFT royalties ERC721("XEN Stake", "opXENS") { using Strings for uint256; using StakeInfo for uint256; using MagicNumbers for uint256; using Array for uint256[]; // PUBLIC CONSTANTS // XENFT common business logic uint256 public constant SECONDS_IN_DAY = 24 * 3_600; uint256 public constant BLACKOUT_TERM = 7 * SECONDS_IN_DAY; string public constant AUTHORS = "@MrJackLevin @lbelyaev faircrypto.org"; uint256 public constant ROYALTY_BP = 500; // PUBLIC MUTABLE STATE // increasing counter for NFT tokenIds, also used as salt for proxies' spinning uint256 public tokenIdCounter = 1; // tokenId => stakeInfo mapping(uint256 => uint256) public stakeInfo; // PUBLIC IMMUTABLE STATE // pointer to XEN Crypto contract XENCrypto public immutable xenCrypto; // 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; // mapping Address => tokenId[] mapping(address => uint256[]) private _ownedTokens; constructor(address xenCrypto_, address forwarder_, address royaltyReceiver_) ERC2771Context(forwarder_) { require(xenCrypto_ != address(0), "bad address"); _original = address(this); _deployer = msg.sender; _royaltyReceiver = royaltyReceiver_ == address(0) ? msg.sender : royaltyReceiver_; xenCrypto = XENCrypto(xenCrypto_); } // 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 info = stakeInfo[tokenId]; bytes memory dataURI = abi.encodePacked( "{", '"name": "XEN Stake #', tokenId.toString(), '",', '"description": "XENFT: XEN Crypto Proof Of Stake",', '"image": "', "data:image/svg+xml;base64,", Base64.encode(StakeMetadata.svgData(tokenId, info, address(xenCrypto))), '",', '"attributes": ', StakeMetadata.attributes(info), "}" ); return string(abi.encodePacked("data:application/json;base64,", Base64.encode(dataURI))); } // IMPLEMENTATION OF XENStakeProxying INTERFACE // FUNCTIONS IN PROXY COPY CONTRACTS (VMU), CALLING ORIGINAL XEN CRYPTO CONTRACT /** @dev function callable only in proxy contracts from the original one => XENCrypto.stake(amount, term) */ function callStake(uint256 amount, uint256 term) external { require(msg.sender == _original, "XEN Proxy: unauthorized"); bytes memory callData = abi.encodeWithSignature("stake(uint256,uint256)", amount, term); (bool success, ) = address(xenCrypto).call(callData); require(success, "stake call failed"); } /** @dev function callable only in proxy contracts from the original one => XENCrypto.withdraw() */ function callWithdraw() external { require(msg.sender == _original, "XEN Proxy: unauthorized"); bytes memory callData = abi.encodeWithSignature("withdraw()"); (bool success, ) = address(xenCrypto).call(callData); require(success, "withdraw call failed"); } /** @dev function callable only in proxy contracts from the original one => XENCrypto.transfer(to, amount) */ function callTransfer(address to) external { require(msg.sender == _original, "XEN Proxy: unauthorized"); uint256 balance = xenCrypto.balanceOf(address(this)); bytes memory callData = abi.encodeWithSignature("transfer(address,uint256)", to, balance); (bool success, ) = address(xenCrypto).call(callData); require(success, "transfer 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 = StakeInfo.getMaturityTs(stakeInfo[tokenId]); 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); } // IBurnableToken IMPLEMENTATION /** @dev burns XENTorrent XENFT which can be used by connected contracts services */ function burn(address user, uint256 tokenId) public { 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 internal torrent interface. calculates rarityBits and rarityScore */ function _calcRarity(uint256 tokenId) private view returns (uint256 rarityScore, uint256 rarityBits) { bool isPrime = tokenId.isPrime(); bool isFib = tokenId.isFib(); bool blockIsPrime = block.number.isPrime(); bool blockIsFib = block.number.isFib(); rarityScore += (isPrime ? 500 : 0); rarityScore += (blockIsPrime ? 1_000 : 0); rarityScore += (isFib ? 5_000 : 0); rarityScore += (blockIsFib ? 10_000 : 0); rarityBits = StakeInfo.encodeRarityBits(isPrime, isFib, blockIsPrime, blockIsFib); } /** @dev internal torrent interface. composes StakeInfo */ function _stakeInfo( address proxy, uint256 tokenId, uint256 amount, uint256 term ) private view returns (uint256 info) { (, uint256 maturityTs, , uint256 apy) = xenCrypto.userStakes(proxy); (uint256 rarityScore, uint256 rarityBits) = _calcRarity(tokenId); info = StakeInfo.encodeStakeInfo(term, maturityTs, amount / 10 ** 18, apy, rarityScore, rarityBits); } /** @dev internal helper. Creates bytecode for minimal proxy contract */ function _bytecode() private view returns (bytes memory) { return bytes.concat( bytes20(0x3D602d80600A3D3981F3363d3d373d3D3D363d73), bytes20(address(this)), bytes15(0x5af43d82803e903d91602b57fd5bf3) ); } /** @dev internal torrent interface. initiates Stake Operation */ function _createStake(uint256 amount, uint256 term, uint256 tokenId) private { bytes memory bytecode = _bytecode(); bytes memory callData = abi.encodeWithSignature("callStake(uint256,uint256)", amount, term); address proxy; bool succeeded; bytes32 salt = keccak256(abi.encodePacked(tokenId)); assembly { proxy := create2(0, add(bytecode, 0x20), mload(bytecode), salt) } require(proxy != address(0), "XENFT: Error creating VSU"); require(xenCrypto.transferFrom(_msgSender(), proxy, amount), "XENFT: Error transferring XEN to VSU"); assembly { succeeded := call(gas(), proxy, 0, add(callData, 0x20), mload(callData), 0, 0) } require(succeeded, "XENFT: Error while staking"); stakeInfo[tokenId] = _stakeInfo(proxy, tokenId, amount, term); } /** @dev internal torrent interface. initiates Stake Operation */ function _endStake(uint256 tokenId) private { bytes memory bytecode = _bytecode(); bytes memory callData = abi.encodeWithSignature("callWithdraw()"); bytes memory callData1 = abi.encodeWithSignature("callTransfer(address)", _msgSender()); bytes memory callData2 = abi.encodeWithSignature("powerDown()"); bytes32 salt = keccak256(abi.encodePacked(tokenId)); bytes32 hash = keccak256(abi.encodePacked(hex"ff", address(this), salt, keccak256(bytecode))); address proxy = address(uint160(uint256(hash))); bool succeeded; assembly { succeeded := call(gas(), proxy, 0, add(callData, 0x20), mload(callData), 0, 0) } require(succeeded, "XENFT: Error while withdrawing"); assembly { succeeded := call(gas(), proxy, 0, add(callData1, 0x20), mload(callData1), 0, 0) } require(succeeded, "XENFT: Error while transferring"); assembly { succeeded := call(gas(), proxy, 0, add(callData2, 0x20), mload(callData2), 0, 0) } require(succeeded, "XENFT: Error while powering down"); delete stakeInfo[tokenId]; } // PUBLIC GETTERS /** @dev public getter for tokens owned by address */ function ownedTokens() external view returns (uint256[] memory) { return _ownedTokens[_msgSender()]; } // PUBLIC TRANSACTIONAL INTERFACE /** @dev public XEN Stake interface initiates XEN Crypto Stake */ function createStake(uint256 amount, uint256 term) public returns (uint256 tokenId) { require(amount > 0, "XENFT: Illegal amount"); require(term > 0, "XENFT: Illegal term"); _createStake(amount, term, tokenIdCounter); _ownedTokens[_msgSender()].addItem(tokenIdCounter); _safeMint(_msgSender(), tokenIdCounter); tokenId = tokenIdCounter; tokenIdCounter++; emit CreateStake(_msgSender(), tokenId, amount, term); } /** @dev public XEN Stake interface ends XEN Crypto Stake, withdraws principal and reward amounts */ function endStake(uint256 tokenId) public { require(tokenId > 0, "XENFT: Illegal tokenId"); require(ownerOf(tokenId) == _msgSender(), "XENFT: Incorrect owner"); uint256 maturityTs = StakeInfo.getMaturityTs(stakeInfo[tokenId]); require(block.timestamp > maturityTs, "XENFT: Maturity not reached"); _endStake(tokenId); _ownedTokens[_msgSender()].removeItem(tokenId); _burn(tokenId); emit EndStake(_msgSender(), tokenId); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface IERC2771 { function isTrustedForwarder(address forwarder) external; }
// SPDX-License-Identifier: MIT 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); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (metatx/ERC2771Context.sol) pragma solidity ^0.8.10; import "@openzeppelin/contracts/utils/Context.sol"; /** * @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(); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/utils/Strings.sol"; import "./BokkyPooBahsDateTimeLibrary.sol"; /* @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)); } }
// SPDX-License-Identifier: MIT 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; } }
// SPDX-License-Identifier: MIT 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; } }
// SPDX-License-Identifier: MIT 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; }
// SPDX-License-Identifier: MIT 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; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface IBurnableToken { function burn(address user, uint256 amount) external; }
// SPDX-License-Identifier: MIT 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; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "abdk-libraries-solidity/ABDKMath64x64.sol"; library XENMath { 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)); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "./XENMath.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/interfaces/IERC165.sol"; import "abdk-libraries-solidity/ABDKMath64x64.sol"; import "./interfaces/IStakingToken.sol"; import "./interfaces/IRankedMintingToken.sol"; import "./interfaces/IBurnableToken.sol"; import "./interfaces/IBurnRedeemable.sol"; contract XENCrypto is Context, IRankedMintingToken, IStakingToken, IBurnableToken, ERC20("XEN Crypto", "XEN") { using XENMath 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 XENMath.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 XENMath.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 = XENMath.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 XENMath.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); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.10; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol"; contract VMPX is ERC20("VMPX", "VMPX"), ERC20Capped(108_624_000 ether) { string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev @JammaBeans faircrypto.org"; uint256 public constant BATCH = 200 ether; uint256 public immutable cycles; // depends on a network block side, set in constructor uint256 public immutable startBlockNumber; uint256 public counter; mapping(uint256 => bool) private _work; /** @dev Start of Operations Guard */ modifier notBeforeStart() { require(block.number > startBlockNumber, "mint not active yet"); _; } constructor(uint256 cycles_, uint256 startBlockNumber_) { require(cycles_ > 0, 'bad limit'); startBlockNumber = startBlockNumber_; cycles = cycles_; } function _doWork(uint256 power) internal { for(uint i = 0; i < cycles * power; i++) { _work[++counter] = true; } } function _mint(address account, uint256 amount) internal override (ERC20, ERC20Capped) { super._mint(account, amount); } function mint(uint256 power) external notBeforeStart { require(power > 0 && power < 196, 'power out of bounds'); require(tx.origin == msg.sender, 'only EOAs allowed'); require(totalSupply() + (BATCH * power) <= cap(), "minting would exceed cap"); _doWork(power); _mint(msg.sender, BATCH * power); } }
// SPDX-License-Identifier: MIT 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-2023 */ library MagicNumbers { uint256 constant VERSION = 1; string public constant AUTHORS = "@MrJackLevin @lbelyaev faircrypto.org"; // There's 370 fibs that fit in uint256 number uint256 constant MAX_UINT256_FIB_IDX = 370; // Max fib number that fits into uint256 size uint256 constant MAX_UINT256_FIB = 94611056096305838013295371573764256526437182762229865607320618320601813254535; // Max fib index supported by this Library uint256 constant MAX_FIB_IDX = 90; // Max number that could be safely tested by this Library uint256 constant MAX_SUPPORTED_FIB_CANDIDATE = 2 ** 62 - 1; /** @dev First 60 Fibonacci numbers, which fit into uint64 */ function fibs64() internal pure returns (uint64[60] memory) { return [ uint64(0), 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041 ]; } /** @dev Tests if number is a fib via a linear lookup in the table above */ function isFibs64(uint256 n) internal pure returns (bool) { for(uint i = 0; i < 60; i++) if (fibs64()[i] == n) return true; return false; } /** @dev Next 38 Fibonacci numbers, which fit into uint128 */ function fibs128() internal pure returns (uint128[39] memory) { return [ uint128(1548008755920),2504730781961, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44945570212853, 72723460248141, 117669030460994, 190392490709135, 308061521170129, 498454011879264, 806515533049393, 1304969544928657, 2111485077978050, 3416454622906707, 5527939700884757, 8944394323791464, 14472334024676221, 23416728348467685, 37889062373143906, 61305790721611591, 99194853094755497, 160500643816367088, 259695496911122585, 420196140727489673, 679891637638612258, 1100087778366101931, 1779979416004714189, 2880067194370816120, 4660046610375530309, 7540113804746346429, 12200160415121876738, 19740274219868223167, 31940434634990099905, 51680708854858323072, 83621143489848422977, 135301852344706746049 ]; } /** @dev Tests if number is a fib via a linear lookup in the table above */ function isFibs128(uint256 n) internal pure returns (bool) { for(uint i = 0; i < 39; i++) if (fibs128()[i] == n) return true; return false; } /** @dev Helper for Miller-Rabin probabilistic primality test */ // Write (n - 1) as 2^s * d function getValues(uint256 n) internal pure returns (uint256[2] memory) { uint256 s = 0; uint256 d = n - 1; while (d % 2 == 0) { d = d / 2; s++; } uint256[2] memory ret; ret[0] = s; ret[1] = d; return ret; } /** @dev Wrapper around EVM precompiled function for modular exponentiation, deployed at 0x05 address */ function modExp(uint256 base, uint256 e, uint256 m) internal view returns (uint o) { assembly { // define pointer let p := mload(0x40) // store data assembly-favouring ways mstore(p, 0x20) // Length of Base mstore(add(p, 0x20), 0x20) // Length of Exponent mstore(add(p, 0x40), 0x20) // Length of Modulus mstore(add(p, 0x60), base) // Base mstore(add(p, 0x80), e) // Exponent mstore(add(p, 0xa0), m) // Modulus if iszero(staticcall(sub(gas(), 2000), 0x05, p, 0xc0, p, 0x20)) { revert(0, 0) } // data o := mload(p) } } /** @dev Miller-Rabin test probabilistic primality test see https://en.wikipedia.org/wiki/Miller–Rabin_primality_test */ function probablyPrime(uint256 n, uint256 prime) internal view returns (bool) { if (n == 2 || n == 3) { return true; } if (n % 2 == 0 || n < 2) { return false; } uint256[2] memory values = getValues(n); uint256 s = values[0]; uint256 d = values[1]; uint256 x = modExp(prime, d, n); if (x == 1 || x == n - 1) { return true; } for (uint256 i = s - 1; i > 0; i--) { x = modExp(x, 2, n); if (x == 1) { return false; } if (x == n - 1) { return true; } } return false; } /** @dev Determines if a number is prime, using Miller-Rabin test probabilistic primality test plus deterministic checking to sift out pseudo-primes see https://en.wikipedia.org/wiki/Miller–Rabin_primality_test */ function isPrime(uint256 n) public view returns (bool) { if (n < 2_047) return probablyPrime(n, 2); else if (n < 1_373_653) return probablyPrime(n, 2) && probablyPrime(n, 3); else if (n < 9_080_191) return probablyPrime(n, 31) && probablyPrime(n, 73); else if (n < 25_326_001) return probablyPrime(n, 2) && probablyPrime(n, 3) && probablyPrime(n, 5); else if (n < 3_215_031_751) return probablyPrime(n, 2) && probablyPrime(n, 3) && probablyPrime(n, 5) && probablyPrime(n, 7); else if (n < 4_759_123_141) return probablyPrime(n, 2) && probablyPrime(n, 7) && probablyPrime(n, 61); else if (n < 1_122_004_669_633) return probablyPrime(n, 2) && probablyPrime(n, 13) && probablyPrime(n, 23) && probablyPrime(n, 1662803); else if (n < 2_152_302_898_747) return probablyPrime(n, 2) && probablyPrime(n, 3) && probablyPrime(n, 5) && probablyPrime(n, 7) && probablyPrime(n, 11); else if (n < 3_474_749_660_383) return probablyPrime(n, 2) && probablyPrime(n, 3) && probablyPrime(n, 5) && probablyPrime(n, 7) && probablyPrime(n, 11) && probablyPrime(n, 13); else if (n < 341_550_071_728_321) return probablyPrime(n, 2) && probablyPrime(n, 3) && probablyPrime(n, 5) && probablyPrime(n, 7) && probablyPrime(n, 11) && probablyPrime(n, 13) && probablyPrime(n, 17); return false; // TODO: consider reverting ??? // revert('number too big'); } /** @dev Count prime numbers occurring between `from` and `to` numbers */ function findPrimes(uint256 from, uint256 to) external view returns (uint256 count) { require(to > 0, "findPrimes: to should be natural"); require(to > from, "findPrimes: to should be larger than from"); count = 0; for(uint i = from; i < to; i++) { if (isPrime(i)) count++; } } /** @dev Helper to get N-th Fibonacci number (0 returns 0) */ function getFib(uint256 n) internal pure returns (uint256 a) { if (n == 0) { return 0; } uint256 h = n / 2; uint256 mask = 1; // find highest set bit in n while(mask <= h) { mask <<= 1; } mask >>= 1; a = 1; uint256 b = 1; uint256 c; while(mask > 0) { c = a * a+b * b; if (n & mask > 0) { b = b * (b + 2 * a); a = c; } else { a = a * (2 * b - a); b = c; } mask >>= 1; } return a; } /** @dev Helper to check if a number is a perfect square */ function isPerfectSquare(uint256 n) internal pure returns (bool) { uint256 low = 0; uint256 high = n; while (low <= high) { uint mid = (low + high) / 2; uint square = mid * mid; if (square == n) { return true; } else if (square > n) { high = mid - 1; } else { low = mid + 1; } } return false; } /** @dev Test if the number is a fib note the upper limit of 2 ** 62 - 1, to avoid overflow while preforming tests */ function isFib(uint256 n) public pure returns (bool) { if (n == 0) return false; require(n < MAX_SUPPORTED_FIB_CANDIDATE, 'isFib: number too big'); uint256 base = n * n * 5; uint256 p1 = base + 4; uint256 p2 = base - 4; return (isPerfectSquare(p1) || isPerfectSquare(p2)); } }
{ "remappings": [], "optimizer": { "enabled": true, "runs": 20 }, "evmVersion": "london", "libraries": { "/contracts/libs/MintInfo_.sol": { "MintInfo_": "0xa4d7cDE8eC8623787f320555b97677B94164BF3d" }, "/contracts/libs/StakeInfo_.sol": { "StakeInfo_": "0x9ecc4B3BeA685821Ee9EA8c22a660be289587aa7" } }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"xenCryptoAddress","type":"address"},{"internalType":"address","name":"xenTorrentAddress","type":"address"},{"internalType":"address","name":"xenStakeAddress","type":"address"},{"internalType":"address","name":"vmpxAddress","type":"address"},{"internalType":"uint256","name":"startBlockNumber_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"AUTHORS","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_APEX_EPIC_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_APEX_EXOTIC_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_APEX_LEGENDARY_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_APEX_RARE_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_APEX_XUNICORN_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_COLLECTOR_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_FLOOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_LIMITED_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_STAKE_XENFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_VMPX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_XEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_XEN_BURN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BATCH_XEN_STAKE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_TRANSFER_MARGIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VMPX_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"XEN_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"XONE_MIN_BURN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bool","name":"isStake","type":"bool"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakeTokensUsed","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"torrentTokensUsed","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userBurns","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vmpx","outputs":[{"internalType":"contract VMPX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xenCrypto","outputs":[{"internalType":"contract XENCrypto","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xenStake","outputs":[{"internalType":"contract XENStake","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xenTorrent","outputs":[{"internalType":"contract XENTorrent","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)
00000000000000000000000006450dee7fd2fb8e39061434babcfc05599a6fb80000000000000000000000000a252663dbcc0b073063d6420a40319e438cfa59000000000000000000000000feda03b91514d31b435d4e1519fd9e699c29bbfc000000000000000000000000b48eb8368c9c6e9b0734de1ef4ceb9f484b80b9c00000000000000000000000000000000000000000000000000000000011bf9ea
-----Decoded View---------------
Arg [0] : xenCryptoAddress (address): 0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8
Arg [1] : xenTorrentAddress (address): 0x0a252663DBCc0b073063D6420a40319e438Cfa59
Arg [2] : xenStakeAddress (address): 0xfEdA03b91514D31b435d4E1519Fd9e699C29BbFC
Arg [3] : vmpxAddress (address): 0xb48Eb8368c9C6e9b0734de1Ef4ceB9f484B80b9C
Arg [4] : startBlockNumber_ (uint256): 18610666
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000006450dee7fd2fb8e39061434babcfc05599a6fb8
Arg [1] : 0000000000000000000000000a252663dbcc0b073063d6420a40319e438cfa59
Arg [2] : 000000000000000000000000feda03b91514d31b435d4e1519fd9e699c29bbfc
Arg [3] : 000000000000000000000000b48eb8368c9c6e9b0734de1ef4ceb9f484b80b9c
Arg [4] : 00000000000000000000000000000000000000000000000000000000011bf9ea
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.