Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60a06040 | 14964143 | 841 days ago | IN | 0 ETH | 0.10329272 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
StakedNetvrkLand
Compiler Version
v0.8.11+commit.d7f03943
Optimization Enabled:
Yes with 300 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.11; import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/math/SafeCastUpgradeable.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "./Interfaces/INFTStaking.sol"; import "./Interfaces/INFTRental.sol"; contract StakedNetvrkLand is Initializable, ContextUpgradeable, INFTStaking, UUPSUpgradeable, OwnableUpgradeable, ReentrancyGuardUpgradeable, ERC721EnumerableUpgradeable { using SafeCastUpgradeable for uint256; // NFT base URI string internal _baseTokenURI; IERC721 private NFT_ERC721; INFTRental private NFT_RENTAL; mapping(uint256 => StakeInformation) private stakeInformation; /** //////////////////////////////////////////////////// // Admin Functions /////////////////////////////////////////////////// */ function initialize(address _nftAddress, string memory baseURI) public initializer { require(_nftAddress != address(0), "INVALID_NFT_ADDRESS"); __UUPSUpgradeable_init(); __ERC721_init("StakedNetvrkLand", "SNVKLAND"); __Context_init_unchained(); __Ownable_init_unchained(); __ReentrancyGuard_init_unchained(); NFT_ERC721 = IERC721(_nftAddress); _baseTokenURI = baseURI; } function setRentalContract(INFTRental _rentalAddress) external onlyOwner { require( _rentalAddress.supportsInterface(type(INFTRental).interfaceId), "INVALID_RENTAL_ADDRESS" ); NFT_RENTAL = _rentalAddress; } /** //////////////////////////////////////////////////// // Public Functions /////////////////////////////////////////////////// */ // Stake the NFT token function stake( uint256[] calldata _tokenIds, address _stakeTo, uint256 _deposit, uint256 _rentalPerDay, uint16 _minRentDays, uint32 _rentableUntil, bool _enableRenting ) external virtual override nonReentrant { require( _deposit <= _rentalPerDay * (uint256(_minRentDays) + 1), "INVALID_RATE" ); _ensureEOAorERC721Receiver(_stakeTo); require(_stakeTo != address(this), "INVALID_STAKE_TO"); require( uint256(_rentableUntil) >= block.timestamp + (uint256(_minRentDays) * 1 days), "INVALID_RENTABLE_UNTIL" ); for (uint256 i = 0; i < _tokenIds.length; i++) { uint256 tokenId = _tokenIds[i]; require( NFT_ERC721.ownerOf(tokenId) == _msgSender(), "NFT_NOT_OWNED" ); NFT_ERC721.safeTransferFrom(_msgSender(), address(this), tokenId); stakeInformation[tokenId] = StakeInformation( _stakeTo, _deposit, _rentalPerDay, _minRentDays, _rentableUntil, uint32(block.timestamp), uint32(block.timestamp + 30 days), _enableRenting ); _safeMint(_stakeTo, tokenId); emit Staked(tokenId, _stakeTo); } } // Update rental conditions as long as therer's no ongoing rent. // setting rentableUntil to 0 makes the world unrentable. function updateRent( uint256[] calldata _tokenIds, uint256 _deposit, uint256 _rentalPerDay, uint16 _minRentDays, uint32 _rentableUntil, bool _enableRenting ) external virtual override { require( _deposit <= _rentalPerDay * (uint256(_minRentDays) + 1), "INVALID_RATE" ); require( uint256(_rentableUntil) >= block.timestamp + (uint256(_minRentDays) * 1 days), "INVALID_RENTABLE_UNTIL" ); for (uint256 i = 0; i < _tokenIds.length; i++) { uint256 tokenId = _tokenIds[i]; StakeInformation storage stakeInfo_ = stakeInformation[tokenId]; require( NFT_ERC721.ownerOf(tokenId) == address(this) && stakeInfo_.owner == _msgSender(), "NFT_NOT_OWNED" ); if (address(NFT_RENTAL) != address(0)) { require(!NFT_RENTAL.isRentActive(tokenId), "ACTIVE_RENT"); // EB: Ongoing rent } stakeInfo_.deposit = _deposit; stakeInfo_.rentalPerDay = _rentalPerDay; stakeInfo_.minRentDays = _minRentDays; stakeInfo_.rentableUntil = _rentableUntil; stakeInfo_.enableRenting = _enableRenting; } } // Extend rental period of ongoing rent function extendRentalPeriod(uint256 _tokenId, uint32 _rentableUntil) external virtual override { StakeInformation storage stakeInfo_ = stakeInformation[_tokenId]; require( NFT_ERC721.ownerOf(_tokenId) == address(this) && stakeInfo_.owner == _msgSender(), "NFT_NOT_OWNED" ); // E9: Not your world require( _rentableUntil >= block.timestamp + (uint256(stakeInfo_.minRentDays) * 1 days), "INVALID_RENTABLE_UNTIL" ); stakeInfo_.rentableUntil = _rentableUntil; } // Unstake tokens and remove rental function unstake(uint256[] calldata _tokenIds, address _unstakeTo) external virtual override nonReentrant { _ensureEOAorERC721Receiver(_unstakeTo); require(_unstakeTo != address(this), "INVALID_STAKE_TO"); for (uint256 i = 0; i < _tokenIds.length; i++) { uint256 tokenId = _tokenIds[i]; require( stakeInformation[tokenId].owner == _msgSender(), "NFT_NOT_OWNED" ); require( block.timestamp >= stakeInformation[tokenId].lockUntil, "STAKE_LOCKED_30_DAYS" ); if (address(NFT_RENTAL) != address(0)) { require(!NFT_RENTAL.isRentActive(tokenId), "ACTIVE_RENT"); // EB: Ongoing rent } NFT_ERC721.safeTransferFrom(address(this), _unstakeTo, tokenId); stakeInformation[tokenId] = StakeInformation( address(0), 0, 0, 0, 0, 0, 0, false ); _burn(tokenId); emit Unstaked(tokenId, _msgSender()); } } /** //////////////////////////////////////////////////// // NFT functions /////////////////////////////////////////////////// */ // Set base URI function setBaseURI(string memory baseTokenURI) external onlyOwner { _baseTokenURI = baseTokenURI; } // Get base URI function _baseURI() internal view virtual override returns (string memory) { return _baseTokenURI; } /** //////////////////////////////////////////////////// // View only functions /////////////////////////////////////////////////// */ // Get NFT Address function getNFTAddress() external view override returns (address) { return address(NFT_ERC721); } // Get Rental contract address function getRentalContractAddress() external view override returns (address) { return address(NFT_RENTAL); } // Get stake information function getStakeInformation(uint256 _tokenId) external view override returns (StakeInformation memory) { return stakeInformation[_tokenId]; } // Get owner of the staking tokens function getOriginalOwner(uint256 _tokenId) external view override returns (address) { if (NFT_ERC721.ownerOf(_tokenId) == address(this)) { return stakeInformation[_tokenId].owner; } return NFT_ERC721.ownerOf(_tokenId); } // Get stake duration information function getStakingDuration(uint256 _tokenId) external view override returns (uint256) { if (stakeInformation[_tokenId].stakedFrom == 0) { return 0; } return block.timestamp - stakeInformation[_tokenId].stakedFrom; } // Get if the stake is active or inactive function isStakeActive(uint256 _tokenId) public view override returns (bool) { return stakeInformation[_tokenId].owner != address(0) && ownerOf(_tokenId) != address(0); } /** //////////////////////////////////////////////////// // Internal Functions /////////////////////////////////////////////////// */ // UUPS proxy function function _authorizeUpgrade(address) internal override onlyOwner {} function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external view override returns (bytes4) { from; tokenId; data; // supress solidity warnings if (operator == address(this)) { return this.onERC721Received.selector; } else { return 0x00000000; } } function _ensureEOAorERC721Receiver(address to) internal virtual { uint32 size; assembly { size := extcodesize(to) } if (size > 0) { try IERC721Receiver(to).onERC721Received( address(this), address(this), 0, "" ) returns (bytes4 retval) { require( retval == IERC721Receiver.onERC721Received.selector, "INVALID_RECEIVER" ); } catch (bytes memory) { revert("INVALID_RECEIVER"); } } } function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal override { require(from == address(0) || to == address(0), "TRANSFER_LOCKED"); super._beforeTokenTransfer(from, to, tokenId); } function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721EnumerableUpgradeable, IERC165) returns (bool) { return interfaceId == type(INFTStaking).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; import "../proxy/utils/Initializable.sol"; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/ContextUpgradeable.sol"; import "../proxy/utils/Initializable.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 OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; import "../proxy/utils/Initializable.sol"; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol) pragma solidity ^0.8.0; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCastUpgradeable { /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); return uint224(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); return uint128(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); return uint96(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); return uint64(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); return uint32(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits. */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128) { require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits"); return int128(value); } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64) { require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits"); return int64(value); } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32) { require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits"); return int32(value); } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16) { require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits"); return int16(value); } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits. * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8) { require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits"); return int8(value); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; import "../ERC721Upgradeable.sol"; import "./IERC721EnumerableUpgradeable.sol"; import "../../../proxy/utils/Initializable.sol"; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721EnumerableUpgradeable is Initializable, ERC721Upgradeable, IERC721EnumerableUpgradeable { function __ERC721Enumerable_init() internal onlyInitializing { } function __ERC721Enumerable_init_unchained() internal onlyInitializing { } // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165Upgradeable, ERC721Upgradeable) returns (bool) { return interfaceId == type(IERC721EnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721Upgradeable.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721EnumerableUpgradeable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @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` cannot be the zero address. * - `to` cannot be the zero address. * * 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 override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721Upgradeable.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721Upgradeable.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[46] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.sol"; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`. */ modifier initializer() { bool isTopLevelCall = _setInitializedVersion(1); if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original * initialization step. This is essential to configure modules that are added through upgrades and that require * initialization. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. */ modifier reinitializer(uint8 version) { bool isTopLevelCall = _setInitializedVersion(version); if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(version); } } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. */ function _disableInitializers() internal virtual { _setInitializedVersion(type(uint8).max); } function _setInitializedVersion(uint8 version) private returns (bool) { // If the contract is initializing we ignore whether _initialized is set in order to support multiple // inheritance patterns, but we only do this in the context of a constructor, and for the lowest level // of initializers, because in other contexts the contract may have been reentered. if (_initializing) { require( version == 1 && !AddressUpgradeable.isContract(address(this)), "Initializable: contract is already initialized" ); return false; } else { require(_initialized < version, "Initializable: contract is already initialized"); _initialized = version; return true; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.0; import "../../interfaces/draft-IERC1822Upgradeable.sol"; import "../ERC1967/ERC1967UpgradeUpgradeable.sol"; import "./Initializable.sol"; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. * * _Available since v4.1._ */ abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable { function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment address private immutable __self = address(this); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { require(address(this) != __self, "Function must be called through delegatecall"); require(_getImplementation() == __self, "Function must be called through active proxy"); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); _; } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate that the this implementation remains valid after an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual override notDelegated returns (bytes32) { return _IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeTo(address newImplementation) external virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data, true); } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeTo} and {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal override onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.11; import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol"; import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; interface INFTStaking is IERC165, IERC721Receiver { event Staked(uint256 indexed tokenId, address indexed user); event Unstaked(uint256 indexed tokenId, address indexed user); struct StakeInformation { address owner; // staked to, otherwise owner == 0 uint256 deposit; // unit is ether, paid in NRGY. The deposit is deducted from the last payment(s) since the deposit is non-custodial uint256 rentalPerDay; // unit is ether, paid in NRGY. Total is deposit + rentalPerDay * days uint16 minRentDays; // must rent for at least min rent days, otherwise deposit is forfeited up to this amount uint32 rentableUntil; // timestamp in unix epoch uint32 stakedFrom; // staked from timestamp uint32 lockUntil; // lock staking bool enableRenting; // enable/disable renting } function getOriginalOwner(uint256 _tokenId) external view returns (address); // view functions function getNFTAddress() external view returns (address); function getRentalContractAddress() external view returns (address); function getStakeInformation(uint256 _tokenId) external view returns (StakeInformation memory); function getStakingDuration(uint256 _tokenId) external view returns (uint256); function isStakeActive(uint256 _tokenId) external view returns (bool); function onERC721Received( address, address, uint256, bytes calldata ) external view override returns (bytes4); function stake( uint256[] calldata _tokenIds, address _stakeTo, uint256 _deposit, uint256 _rentalPerDay, uint16 _minRentDays, uint32 _rentableUntil, bool _enableRent ) external; function updateRent( uint256[] calldata _tokenIds, uint256 _deposit, uint256 _rentalPerDay, uint16 _minRentDays, uint32 _rentableUntil, bool _enableRent ) external; function extendRentalPeriod(uint256 _tokenId, uint32 _rentableUntil) external; function unstake(uint256[] calldata _tokenIds, address _unstakeTo) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.11; import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; interface INFTRental is IERC165 { event Rented( uint256 indexed tokenId, address indexed tenant, uint256 payment ); event RentPaid( uint256 indexed tokenId, address indexed tenant, uint256 payment ); event RentTerminated(uint256 indexed tokenId, address indexed tenant); struct RentInformation { address tenant; // rented to, otherwise tenant == 0 uint32 rentStartTime; // timestamp in unix epoch uint256 rentalPaid; // total rental paid since the beginning including the deposit } function isRentActive(uint256 _tokenId) external view returns (bool); function getRentInformation(uint256 _tokenId) external view returns (RentInformation memory); function isRentable(uint256 _tokenId) external view returns (bool state); function rentalPaidUntil(uint256 _tokenId) external view returns (uint256 paidUntil); function startRent(uint256 _tokenId, uint256 _initialPayment) external; function payRent(uint256 _tokenId, uint256 _payment) external; function terminateRent(uint256 _tokenId) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @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 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// 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 (last updated v4.6.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721Upgradeable.sol"; import "./IERC721ReceiverUpgradeable.sol"; import "./extensions/IERC721MetadataUpgradeable.sol"; import "../../utils/AddressUpgradeable.sol"; import "../../utils/ContextUpgradeable.sol"; import "../../utils/StringsUpgradeable.sol"; import "../../utils/introspection/ERC165Upgradeable.sol"; import "../../proxy/utils/Initializable.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 ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable 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. */ function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing { __ERC721_init_unchained(name_, symbol_); } function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC721Upgradeable).interfaceId || interfaceId == type(IERC721MetadataUpgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); 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: owner query for nonexistent token"); 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) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); 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 = ERC721Upgradeable.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); 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: transfer caller is not 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: transfer caller is not 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) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721Upgradeable.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 = ERC721Upgradeable.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(ERC721Upgradeable.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 a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721Upgradeable.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits a {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 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 IERC721ReceiverUpgradeable(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721ReceiverUpgradeable.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { 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 {} /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[44] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; import "../IERC721Upgradeable.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721EnumerableUpgradeable is IERC721Upgradeable { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165Upgradeable.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721Upgradeable is IERC165Upgradeable { /** * @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 be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev 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.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 IERC721ReceiverUpgradeable { /** * @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 v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721Upgradeable.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721MetadataUpgradeable is IERC721Upgradeable { /** * @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 v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library StringsUpgradeable { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165Upgradeable.sol"; import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// 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 IERC165Upgradeable { /** * @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 (last updated v4.5.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.0; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822ProxiableUpgradeable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol) pragma solidity ^0.8.2; import "../beacon/IBeaconUpgradeable.sol"; import "../../interfaces/draft-IERC1822Upgradeable.sol"; import "../../utils/AddressUpgradeable.sol"; import "../../utils/StorageSlotUpgradeable.sol"; import "../utils/Initializable.sol"; /** * @dev This abstract contract provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. * * _Available since v4.1._ * * @custom:oz-upgrades-unsafe-allow delegatecall */ abstract contract ERC1967UpgradeUpgradeable is Initializable { function __ERC1967Upgrade_init() internal onlyInitializing { } function __ERC1967Upgrade_init_unchained() internal onlyInitializing { } // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Returns the current implementation address. */ function _getImplementation() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the EIP1967 implementation slot. */ function _setImplementation(address newImplementation) private { require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall( address newImplementation, bytes memory data, bool forceCall ) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { _functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS( address newImplementation, bytes memory data, bool forceCall ) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Emitted when the beacon is upgraded. */ event BeaconUpgraded(address indexed beacon); /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall( address newBeacon, bytes memory data, bool forceCall ) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); } } /** * @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) private returns (bytes memory) { require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed"); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeaconUpgradeable { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function implementation() external view returns (address); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol) pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ``` * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ */ library StorageSlotUpgradeable { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
{ "optimizer": { "enabled": true, "runs": 300 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","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":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint32","name":"_rentableUntil","type":"uint32"}],"name":"extendRentalPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNFTAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getOriginalOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRentalContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getStakeInformation","outputs":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"deposit","type":"uint256"},{"internalType":"uint256","name":"rentalPerDay","type":"uint256"},{"internalType":"uint16","name":"minRentDays","type":"uint16"},{"internalType":"uint32","name":"rentableUntil","type":"uint32"},{"internalType":"uint32","name":"stakedFrom","type":"uint32"},{"internalType":"uint32","name":"lockUntil","type":"uint32"},{"internalType":"bool","name":"enableRenting","type":"bool"}],"internalType":"struct INFTStaking.StakeInformation","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getStakingDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"string","name":"baseURI","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isStakeActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseTokenURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract INFTRental","name":"_rentalAddress","type":"address"}],"name":"setRentalContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"address","name":"_stakeTo","type":"address"},{"internalType":"uint256","name":"_deposit","type":"uint256"},{"internalType":"uint256","name":"_rentalPerDay","type":"uint256"},{"internalType":"uint16","name":"_minRentDays","type":"uint16"},{"internalType":"uint32","name":"_rentableUntil","type":"uint32"},{"internalType":"bool","name":"_enableRenting","type":"bool"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"address","name":"_unstakeTo","type":"address"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256","name":"_deposit","type":"uint256"},{"internalType":"uint256","name":"_rentalPerDay","type":"uint256"},{"internalType":"uint16","name":"_minRentDays","type":"uint16"},{"internalType":"uint32","name":"_rentableUntil","type":"uint32"},{"internalType":"bool","name":"_enableRenting","type":"bool"}],"name":"updateRent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.