Polygon Sponsored slots available. Book your slot here!
ERC-721
Overview
Max Total Supply
8 star-Cl-57
Holders
8
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 star-Cl-57Loading...
Loading
Loading...
Loading
Loading...
Loading
Minimal Proxy Contract for 0x2172758ebb894c43e0be01e37d065118317d7eec
Contract Name:
CollectNFT
Compiler Version
v0.8.10+commit.fc410830
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; import {ICollectNFT} from '../interfaces/ICollectNFT.sol'; import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol'; import {ILensHub} from '../interfaces/ILensHub.sol'; import {Errors} from '../libraries/Errors.sol'; import {Events} from '../libraries/Events.sol'; import {LensNFTBase} from './base/LensNFTBase.sol'; import {ERC721Enumerable} from './base/ERC721Enumerable.sol'; /** * @title CollectNFT * @author Lens Protocol * * @notice This is the NFT contract that is minted upon collecting a given publication. It is cloned upon * the first collect for a given publication, and the token URI points to the original publication's contentURI. */ contract CollectNFT is LensNFTBase, ICollectNFT { address public immutable HUB; uint256 internal _profileId; uint256 internal _pubId; uint256 internal _tokenIdCounter; bool private _initialized; uint256 internal _royaltyBasisPoints; // bytes4(keccak256('royaltyInfo(uint256,uint256)')) == 0x2a55205a bytes4 internal constant INTERFACE_ID_ERC2981 = 0x2a55205a; uint16 internal constant BASIS_POINTS = 10000; // We create the CollectNFT with the pre-computed HUB address before deploying the hub proxy in order // to initialize the hub proxy at construction. constructor(address hub) { if (hub == address(0)) revert Errors.InitParamsInvalid(); HUB = hub; _initialized = true; } /// @inheritdoc ICollectNFT function initialize( uint256 profileId, uint256 pubId, string calldata name, string calldata symbol ) external override { if (_initialized) revert Errors.Initialized(); _initialized = true; _royaltyBasisPoints = 1000; // 10% of royalties _profileId = profileId; _pubId = pubId; super._initialize(name, symbol); emit Events.CollectNFTInitialized(profileId, pubId, block.timestamp); } /// @inheritdoc ICollectNFT function mint(address to) external override returns (uint256) { if (msg.sender != HUB) revert Errors.NotHub(); unchecked { uint256 tokenId = ++_tokenIdCounter; _mint(to, tokenId); return tokenId; } } /// @inheritdoc ICollectNFT function getSourcePublicationPointer() external view override returns (uint256, uint256) { return (_profileId, _pubId); } function tokenURI(uint256 tokenId) public view override returns (string memory) { if (!_exists(tokenId)) revert Errors.TokenDoesNotExist(); return ILensHub(HUB).getContentURI(_profileId, _pubId); } /** * @notice Changes the royalty percentage for secondary sales. Can only be called publication's * profile owner. * * @param royaltyBasisPoints The royalty percentage meassured in basis points. Each basis point * represents 0.01%. */ function setRoyalty(uint256 royaltyBasisPoints) external { if (IERC721(HUB).ownerOf(_profileId) == msg.sender) { if (royaltyBasisPoints > BASIS_POINTS) { revert Errors.InvalidParameter(); } else { _royaltyBasisPoints = royaltyBasisPoints; } } else { revert Errors.NotProfileOwner(); } } /** * @notice Called with the sale price to determine how much royalty * is owed and to whom. * * @param tokenId The token ID of the NFT queried for royalty information. * @param salePrice The sale price of the NFT specified. * @return A tuple with the address who should receive the royalties and the royalty * payment amount for the given sale price. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address, uint256) { return (IERC721(HUB).ownerOf(_profileId), (salePrice * _royaltyBasisPoints) / BASIS_POINTS); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Enumerable) returns (bool) { return interfaceId == INTERFACE_ID_ERC2981 || super.supportsInterface(interfaceId); } /** * @dev Upon transfers, we emit the transfer event in the hub. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal override { super._beforeTokenTransfer(from, to, tokenId); ILensHub(HUB).emitCollectNFTTransferEvent(_profileId, _pubId, tokenId, from, to); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; /** * @title ICollectNFT * @author Lens Protocol * * @notice This is the interface for the CollectNFT contract. Which is cloned upon the first collect for any given * publication. */ interface ICollectNFT { /** * @notice Initializes the collect NFT, setting the feed as the privileged minter, storing the collected publication pointer * and initializing the name and symbol in the LensNFTBase contract. * * @param profileId The token ID of the profile in the hub that this collectNFT points to. * @param pubId The profile publication ID in the hub that this collectNFT points to. * @param name The name to set for this NFT. * @param symbol The symbol to set for this NFT. */ function initialize( uint256 profileId, uint256 pubId, string calldata name, string calldata symbol ) external; /** * @notice Mints a collect NFT to the specified address. This can only be called by the hub, and is called * upon collection. * * @param to The address to mint the NFT to. * * @return uint256 An interger representing the minted token ID. */ function mint(address to) external returns (uint256); /** * @notice Returns the source publication pointer mapped to this collect NFT. * * @return tuple First the profile ID uint256, and second the pubId uint256. */ function getSourcePublicationPointer() external view returns (uint256, uint256); }
// 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 pragma solidity 0.8.10; import {DataTypes} from '../libraries/DataTypes.sol'; /** * @title ILensHub * @author Lens Protocol * * @notice This is the interface for the LensHub contract, the main entry point for the Lens Protocol. * You'll find all the events and external functions, as well as the reasoning behind them here. */ interface ILensHub { /** * @notice Initializes the LensHub NFT, setting the initial governance address as well as the name and symbol in * the LensNFTBase contract. * * @param name The name to set for the hub NFT. * @param symbol The symbol to set for the hub NFT. * @param newGovernance The governance address to set. */ function initialize( string calldata name, string calldata symbol, address newGovernance ) external; /** * @notice Sets the privileged governance role. This function can only be called by the current governance * address. * * @param newGovernance The new governance address to set. */ function setGovernance(address newGovernance) external; /** * @notice Sets the emergency admin, which is a permissioned role able to set the protocol state. This function * can only be called by the governance address. * * @param newEmergencyAdmin The new emergency admin address to set. */ function setEmergencyAdmin(address newEmergencyAdmin) external; /** * @notice Sets the protocol state to either a global pause, a publishing pause or an unpaused state. This function * can only be called by the governance address or the emergency admin address. * * Note that this reverts if the emergency admin calls it if: * 1. The emergency admin is attempting to unpause. * 2. The emergency admin is calling while the protocol is already paused. * * @param newState The state to set, as a member of the ProtocolState enum. */ function setState(DataTypes.ProtocolState newState) external; /** * @notice Adds or removes a profile creator from the whitelist. This function can only be called by the current * governance address. * * @param profileCreator The profile creator address to add or remove from the whitelist. * @param whitelist Whether or not the profile creator should be whitelisted. */ function whitelistProfileCreator(address profileCreator, bool whitelist) external; /** * @notice Adds or removes a follow module from the whitelist. This function can only be called by the current * governance address. * * @param followModule The follow module contract address to add or remove from the whitelist. * @param whitelist Whether or not the follow module should be whitelisted. */ function whitelistFollowModule(address followModule, bool whitelist) external; /** * @notice Adds or removes a reference module from the whitelist. This function can only be called by the current * governance address. * * @param referenceModule The reference module contract to add or remove from the whitelist. * @param whitelist Whether or not the reference module should be whitelisted. */ function whitelistReferenceModule(address referenceModule, bool whitelist) external; /** * @notice Adds or removes a collect module from the whitelist. This function can only be called by the current * governance address. * * @param collectModule The collect module contract address to add or remove from the whitelist. * @param whitelist Whether or not the collect module should be whitelisted. */ function whitelistCollectModule(address collectModule, bool whitelist) external; /** * @notice Creates a profile with the specified parameters, minting a profile NFT to the given recipient. This * function must be called by a whitelisted profile creator. * * @param vars A CreateProfileData struct containing the following params: * to: The address receiving the profile. * handle: The handle to set for the profile, must be unique and non-empty. * imageURI: The URI to set for the profile image. * followModule: The follow module to use, can be the zero address. * followModuleInitData: The follow module initialization data, if any. */ function createProfile(DataTypes.CreateProfileData calldata vars) external returns (uint256); /** * @notice Sets the mapping between wallet and its main profile identity. * * @param profileId The token ID of the profile to set as the main profile identity. */ function setDefaultProfile(uint256 profileId) external; /** * @notice Sets the mapping between wallet and its main profile identity via signature with the specified parameters. * * @param vars A SetDefaultProfileWithSigData struct, including the regular parameters and an EIP712Signature struct. */ function setDefaultProfileWithSig(DataTypes.SetDefaultProfileWithSigData calldata vars) external; /** * @notice Sets a profile's follow module, must be called by the profile owner. * * @param profileId The token ID of the profile to set the follow module for. * @param followModule The follow module to set for the given profile, must be whitelisted. * @param followModuleInitData The data to be passed to the follow module for initialization. */ function setFollowModule( uint256 profileId, address followModule, bytes calldata followModuleInitData ) external; /** * @notice Sets a profile's follow module via signature with the specified parameters. * * @param vars A SetFollowModuleWithSigData struct, including the regular parameters and an EIP712Signature struct. */ function setFollowModuleWithSig(DataTypes.SetFollowModuleWithSigData calldata vars) external; /** * @notice Sets a profile's dispatcher, giving that dispatcher rights to publish to that profile. * * @param profileId The token ID of the profile of the profile to set the dispatcher for. * @param dispatcher The dispatcher address to set for the given profile ID. */ function setDispatcher(uint256 profileId, address dispatcher) external; /** * @notice Sets a profile's dispatcher via signature with the specified parameters. * * @param vars A SetDispatcherWithSigData struct, including the regular parameters and an EIP712Signature struct. */ function setDispatcherWithSig(DataTypes.SetDispatcherWithSigData calldata vars) external; /** * @notice Sets a profile's URI, which is reflected in the `tokenURI()` function. * * @param profileId The token ID of the profile of the profile to set the URI for. * @param imageURI The URI to set for the given profile. */ function setProfileImageURI(uint256 profileId, string calldata imageURI) external; /** * @notice Sets a profile's URI via signature with the specified parameters. * * @param vars A SetProfileImageURIWithSigData struct, including the regular parameters and an EIP712Signature struct. */ function setProfileImageURIWithSig(DataTypes.SetProfileImageURIWithSigData calldata vars) external; /** * @notice Sets a followNFT URI for a given profile's follow NFT. * * @param profileId The token ID of the profile for which to set the followNFT URI. * @param followNFTURI The follow NFT URI to set. */ function setFollowNFTURI(uint256 profileId, string calldata followNFTURI) external; /** * @notice Sets a followNFT URI via signature with the specified parameters. * * @param vars A SetFollowNFTURIWithSigData struct, including the regular parameters and an EIP712Signature struct. */ function setFollowNFTURIWithSig(DataTypes.SetFollowNFTURIWithSigData calldata vars) external; /** * @notice Publishes a post to a given profile, must be called by the profile owner. * * @param vars A PostData struct containing the needed parameters. * * @return uint256 An integer representing the post's publication ID. */ function post(DataTypes.PostData calldata vars) external returns (uint256); /** * @notice Publishes a post to a given profile via signature with the specified parameters. * * @param vars A PostWithSigData struct containing the regular parameters and an EIP712Signature struct. * * @return uint256 An integer representing the post's publication ID. */ function postWithSig(DataTypes.PostWithSigData calldata vars) external returns (uint256); /** * @notice Publishes a comment to a given profile, must be called by the profile owner. * * @param vars A CommentData struct containing the needed parameters. * * @return uint256 An integer representing the comment's publication ID. */ function comment(DataTypes.CommentData calldata vars) external returns (uint256); /** * @notice Publishes a comment to a given profile via signature with the specified parameters. * * @param vars A CommentWithSigData struct containing the regular parameters and an EIP712Signature struct. * * @return uint256 An integer representing the comment's publication ID. */ function commentWithSig(DataTypes.CommentWithSigData calldata vars) external returns (uint256); /** * @notice Publishes a mirror to a given profile, must be called by the profile owner. * * @param vars A MirrorData struct containing the necessary parameters. * * @return uint256 An integer representing the mirror's publication ID. */ function mirror(DataTypes.MirrorData calldata vars) external returns (uint256); /** * @notice Publishes a mirror to a given profile via signature with the specified parameters. * * @param vars A MirrorWithSigData struct containing the regular parameters and an EIP712Signature struct. * * @return uint256 An integer representing the mirror's publication ID. */ function mirrorWithSig(DataTypes.MirrorWithSigData calldata vars) external returns (uint256); /** * @notice Follows the given profiles, executing each profile's follow module logic (if any) and minting followNFTs to the caller. * * NOTE: Both the `profileIds` and `datas` arrays must be of the same length, regardless if the profiles do not have a follow module set. * * @param profileIds The token ID array of the profiles to follow. * @param datas The arbitrary data array to pass to the follow module for each profile if needed. * * @return uint256[] An array of integers representing the minted follow NFTs token IDs. */ function follow(uint256[] calldata profileIds, bytes[] calldata datas) external returns (uint256[] memory); /** * @notice Follows a given profile via signature with the specified parameters. * * @param vars A FollowWithSigData struct containing the regular parameters as well as the signing follower's address * and an EIP712Signature struct. * * @return uint256[] An array of integers representing the minted follow NFTs token IDs. */ function followWithSig(DataTypes.FollowWithSigData calldata vars) external returns (uint256[] memory); /** * @notice Collects a given publication, executing collect module logic and minting a collectNFT to the caller. * * @param profileId The token ID of the profile that published the publication to collect. * @param pubId The publication to collect's publication ID. * @param data The arbitrary data to pass to the collect module if needed. * * @return uint256 An integer representing the minted token ID. */ function collect( uint256 profileId, uint256 pubId, bytes calldata data ) external returns (uint256); /** * @notice Collects a given publication via signature with the specified parameters. * * @param vars A CollectWithSigData struct containing the regular parameters as well as the collector's address and * an EIP712Signature struct. * * @return uint256 An integer representing the minted token ID. */ function collectWithSig(DataTypes.CollectWithSigData calldata vars) external returns (uint256); /** * @dev Helper function to emit a detailed followNFT transfer event from the hub, to be consumed by frontends to track * followNFT transfers. * * @param profileId The token ID of the profile associated with the followNFT being transferred. * @param followNFTId The followNFT being transferred's token ID. * @param from The address the followNFT is being transferred from. * @param to The address the followNFT is being transferred to. */ function emitFollowNFTTransferEvent( uint256 profileId, uint256 followNFTId, address from, address to ) external; /** * @dev Helper function to emit a detailed collectNFT transfer event from the hub, to be consumed by frontends to track * collectNFT transfers. * * @param profileId The token ID of the profile associated with the collect NFT being transferred. * @param pubId The publication ID associated with the collect NFT being transferred. * @param collectNFTId The collectNFT being transferred's token ID. * @param from The address the collectNFT is being transferred from. * @param to The address the collectNFT is being transferred to. */ function emitCollectNFTTransferEvent( uint256 profileId, uint256 pubId, uint256 collectNFTId, address from, address to ) external; /// ************************ /// *****VIEW FUNCTIONS***** /// ************************ /** * @notice Returns whether or not a profile creator is whitelisted. * * @param profileCreator The address of the profile creator to check. * * @return bool True if the profile creator is whitelisted, false otherwise. */ function isProfileCreatorWhitelisted(address profileCreator) external view returns (bool); /** * @notice Returns default profile for a given wallet address * * @param wallet The address to find the default mapping * * @return uint256 The default profile id, which will be 0 if not mapped. */ function defaultProfile(address wallet) external view returns (uint256); /** * @notice Returns whether or not a follow module is whitelisted. * * @param followModule The address of the follow module to check. * * @return bool True if the the follow module is whitelisted, false otherwise. */ function isFollowModuleWhitelisted(address followModule) external view returns (bool); /** * @notice Returns whether or not a reference module is whitelisted. * * @param referenceModule The address of the reference module to check. * * @return bool True if the the reference module is whitelisted, false otherwise. */ function isReferenceModuleWhitelisted(address referenceModule) external view returns (bool); /** * @notice Returns whether or not a collect module is whitelisted. * * @param collectModule The address of the collect module to check. * * @return bool True if the the collect module is whitelisted, false otherwise. */ function isCollectModuleWhitelisted(address collectModule) external view returns (bool); /** * @notice Returns the currently configured governance address. * * @return address The address of the currently configured governance. */ function getGovernance() external view returns (address); /** * @notice Returns the dispatcher associated with a profile. * * @param profileId The token ID of the profile to query the dispatcher for. * * @return address The dispatcher address associated with the profile. */ function getDispatcher(uint256 profileId) external view returns (address); /** * @notice Returns the publication count for a given profile. * * @param profileId The token ID of the profile to query. * * @return uint256 The number of publications associated with the queried profile. */ function getPubCount(uint256 profileId) external view returns (uint256); /** * @notice Returns the followNFT associated with a given profile, if any. * * @param profileId The token ID of the profile to query the followNFT for. * * @return address The followNFT associated with the given profile. */ function getFollowNFT(uint256 profileId) external view returns (address); /** * @notice Returns the followNFT URI associated with a given profile. * * @param profileId The token ID of the profile to query the followNFT URI for. * * @return string The followNFT URI associated with the given profile. */ function getFollowNFTURI(uint256 profileId) external view returns (string memory); /** * @notice Returns the collectNFT associated with a given publication, if any. * * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * * @return address The address of the collectNFT associated with the queried publication. */ function getCollectNFT(uint256 profileId, uint256 pubId) external view returns (address); /** * @notice Returns the follow module associated witha given profile, if any. * * @param profileId The token ID of the profile to query the follow module for. * * @return address The address of the follow module associated with the given profile. */ function getFollowModule(uint256 profileId) external view returns (address); /** * @notice Returns the collect module associated with a given publication. * * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * * @return address The address of the collect module associated with the queried publication. */ function getCollectModule(uint256 profileId, uint256 pubId) external view returns (address); /** * @notice Returns the reference module associated witha given profile, if any. * * @param profileId The token ID of the profile that published the publication to querythe reference module for. * @param pubId The publication ID of the publication to query the reference module for. * * @return address The address of the reference module associated with the given profile. */ function getReferenceModule(uint256 profileId, uint256 pubId) external view returns (address); /** * @notice Returns the handle associated with a profile. * * @param profileId The token ID of the profile to query the handle for. * * @return string The handle associated with the profile. */ function getHandle(uint256 profileId) external view returns (string memory); /** * @notice Returns the publication pointer (profileId & pubId) associated with a given publication. * * @param profileId The token ID of the profile that published the publication to query the pointer for. * @param pubId The publication ID of the publication to query the pointer for. * * @return tuple First, the profile ID of the profile the current publication is pointing to, second, the * publication ID of the publication the current publication is pointing to. */ function getPubPointer(uint256 profileId, uint256 pubId) external view returns (uint256, uint256); /** * @notice Returns the URI associated with a given publication. * * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * * @return string The URI associated with a given publication. */ function getContentURI(uint256 profileId, uint256 pubId) external view returns (string memory); /** * @notice Returns the profile token ID according to a given handle. * * @param handle The handle to resolve the profile token ID with. * * @return uint256 The profile ID the passed handle points to. */ function getProfileIdByHandle(string calldata handle) external view returns (uint256); /** * @notice Returns the full profile struct associated with a given profile token ID. * * @param profileId The token ID of the profile to query. * * @return ProfileStruct The profile struct of the given profile. */ function getProfile(uint256 profileId) external view returns (DataTypes.ProfileStruct memory); /** * @notice Returns the full publication struct for a given publication. * * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * * @return PublicationStruct The publication struct associated with the queried publication. */ function getPub(uint256 profileId, uint256 pubId) external view returns (DataTypes.PublicationStruct memory); /** * @notice Returns the publication type associated with a given publication. * * @param profileId The token ID of the profile that published the publication to query. * @param pubId The publication ID of the publication to query. * * @return PubType The publication type, as a member of an enum (either "post," "comment" or "mirror"). */ function getPubType(uint256 profileId, uint256 pubId) external view returns (DataTypes.PubType); /** * @notice Returns the follow NFT implementation address. * * @return address The follow NFT implementation address. */ function getFollowNFTImpl() external view returns (address); /** * @notice Returns the collect NFT implementation address. * * @return address The collect NFT implementation address. */ function getCollectNFTImpl() external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; library Errors { error CannotInitImplementation(); error Initialized(); error SignatureExpired(); error ZeroSpender(); error SignatureInvalid(); error NotOwnerOrApproved(); error NotHub(); error TokenDoesNotExist(); error NotGovernance(); error NotGovernanceOrEmergencyAdmin(); error EmergencyAdminCannotUnpause(); error CallerNotWhitelistedModule(); error CollectModuleNotWhitelisted(); error FollowModuleNotWhitelisted(); error ReferenceModuleNotWhitelisted(); error ProfileCreatorNotWhitelisted(); error NotProfileOwner(); error NotProfileOwnerOrDispatcher(); error NotDispatcher(); error PublicationDoesNotExist(); error HandleTaken(); error HandleLengthInvalid(); error HandleContainsInvalidCharacters(); error HandleFirstCharInvalid(); error ProfileImageURILengthInvalid(); error CallerNotFollowNFT(); error CallerNotCollectNFT(); error BlockNumberInvalid(); error ArrayMismatch(); error CannotCommentOnSelf(); error NotWhitelisted(); error InvalidParameter(); // Module Errors error InitParamsInvalid(); error CollectExpired(); error FollowInvalid(); error ModuleDataMismatch(); error FollowNotApproved(); error MintLimitExceeded(); error CollectNotAllowed(); // MultiState Errors error Paused(); error PublishingPaused(); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; import {DataTypes} from './DataTypes.sol'; library Events { /** * @dev Emitted when the NFT contract's name and symbol are set at initialization. * * @param name The NFT name set. * @param symbol The NFT symbol set. * @param timestamp The current block timestamp. */ event BaseInitialized(string name, string symbol, uint256 timestamp); /** * @dev Emitted when the hub state is set. * * @param caller The caller who set the state. * @param prevState The previous protocol state, an enum of either `Paused`, `PublishingPaused` or `Unpaused`. * @param newState The newly set state, an enum of either `Paused`, `PublishingPaused` or `Unpaused`. * @param timestamp The current block timestamp. */ event StateSet( address indexed caller, DataTypes.ProtocolState indexed prevState, DataTypes.ProtocolState indexed newState, uint256 timestamp ); /** * @dev Emitted when the governance address is changed. We emit the caller even though it should be the previous * governance address, as we cannot guarantee this will always be the case due to upgradeability. * * @param caller The caller who set the governance address. * @param prevGovernance The previous governance address. * @param newGovernance The new governance address set. * @param timestamp The current block timestamp. */ event GovernanceSet( address indexed caller, address indexed prevGovernance, address indexed newGovernance, uint256 timestamp ); /** * @dev Emitted when the emergency admin is changed. We emit the caller even though it should be the previous * governance address, as we cannot guarantee this will always be the case due to upgradeability. * * @param caller The caller who set the emergency admin address. * @param oldEmergencyAdmin The previous emergency admin address. * @param newEmergencyAdmin The new emergency admin address set. * @param timestamp The current block timestamp. */ event EmergencyAdminSet( address indexed caller, address indexed oldEmergencyAdmin, address indexed newEmergencyAdmin, uint256 timestamp ); /** * @dev Emitted when a profile creator is added to or removed from the whitelist. * * @param profileCreator The address of the profile creator. * @param whitelisted Whether or not the profile creator is being added to the whitelist. * @param timestamp The current block timestamp. */ event ProfileCreatorWhitelisted( address indexed profileCreator, bool indexed whitelisted, uint256 timestamp ); /** * @dev Emitted when a follow module is added to or removed from the whitelist. * * @param followModule The address of the follow module. * @param whitelisted Whether or not the follow module is being added to the whitelist. * @param timestamp The current block timestamp. */ event FollowModuleWhitelisted( address indexed followModule, bool indexed whitelisted, uint256 timestamp ); /** * @dev Emitted when a reference module is added to or removed from the whitelist. * * @param referenceModule The address of the reference module. * @param whitelisted Whether or not the reference module is being added to the whitelist. * @param timestamp The current block timestamp. */ event ReferenceModuleWhitelisted( address indexed referenceModule, bool indexed whitelisted, uint256 timestamp ); /** * @dev Emitted when a collect module is added to or removed from the whitelist. * * @param collectModule The address of the collect module. * @param whitelisted Whether or not the collect module is being added to the whitelist. * @param timestamp The current block timestamp. */ event CollectModuleWhitelisted( address indexed collectModule, bool indexed whitelisted, uint256 timestamp ); /** * @dev Emitted when a profile is created. * * @param profileId The newly created profile's token ID. * @param creator The profile creator, who created the token with the given profile ID. * @param to The address receiving the profile with the given profile ID. * @param handle The handle set for the profile. * @param imageURI The image uri set for the profile. * @param followModule The profile's newly set follow module. This CAN be the zero address. * @param followModuleReturnData The data returned from the follow module's initialization. This is abi encoded * and totally depends on the follow module chosen. * @param followNFTURI The URI set for the profile's follow NFT. * @param timestamp The current block timestamp. */ event ProfileCreated( uint256 indexed profileId, address indexed creator, address indexed to, string handle, string imageURI, address followModule, bytes followModuleReturnData, string followNFTURI, uint256 timestamp ); /** * @dev Emitted when a a default profile is set for a wallet as its main identity * * @param wallet The wallet which set or unset its default profile. * @param profileId The token ID of the profile being set as default, or zero. * @param timestamp The current block timestamp. */ event DefaultProfileSet(address indexed wallet, uint256 indexed profileId, uint256 timestamp); /** * @dev Emitted when a dispatcher is set for a specific profile. * * @param profileId The token ID of the profile for which the dispatcher is set. * @param dispatcher The dispatcher set for the given profile. * @param timestamp The current block timestamp. */ event DispatcherSet(uint256 indexed profileId, address indexed dispatcher, uint256 timestamp); /** * @dev Emitted when a profile's URI is set. * * @param profileId The token ID of the profile for which the URI is set. * @param imageURI The URI set for the given profile. * @param timestamp The current block timestamp. */ event ProfileImageURISet(uint256 indexed profileId, string imageURI, uint256 timestamp); /** * @dev Emitted when a follow NFT's URI is set. * * @param profileId The token ID of the profile for which the followNFT URI is set. * @param followNFTURI The follow NFT URI set. * @param timestamp The current block timestamp. */ event FollowNFTURISet(uint256 indexed profileId, string followNFTURI, uint256 timestamp); /** * @dev Emitted when a profile's follow module is set. * * @param profileId The profile's token ID. * @param followModule The profile's newly set follow module. This CAN be the zero address. * @param followModuleReturnData The data returned from the follow module's initialization. This is abi encoded * and totally depends on the follow module chosen. * @param timestamp The current block timestamp. */ event FollowModuleSet( uint256 indexed profileId, address followModule, bytes followModuleReturnData, uint256 timestamp ); /** * @dev Emitted when a "post" is published. * * @param profileId The profile's token ID. * @param pubId The new publication's ID. * @param contentURI The URI mapped to this new publication. * @param collectModule The collect module mapped to this new publication. This CANNOT be the zero address. * @param collectModuleReturnData The data returned from the collect module's initialization for this given * publication. This is abi encoded and totally depends on the collect module chosen. * @param referenceModule The reference module set for this publication. * @param referenceModuleReturnData The data returned from the reference module at initialization. This is abi * encoded and totally depends on the reference module chosen. * @param timestamp The current block timestamp. */ event PostCreated( uint256 indexed profileId, uint256 indexed pubId, string contentURI, address collectModule, bytes collectModuleReturnData, address referenceModule, bytes referenceModuleReturnData, uint256 timestamp ); /** * @dev Emitted when a "comment" is published. * * @param profileId The profile's token ID. * @param pubId The new publication's ID. * @param contentURI The URI mapped to this new publication. * @param profileIdPointed The profile token ID that this comment points to. * @param pubIdPointed The publication ID that this comment points to. * @param referenceModuleData The data passed to the reference module. * @param collectModule The collect module mapped to this new publication. This CANNOT be the zero address. * @param collectModuleReturnData The data returned from the collect module's initialization for this given * publication. This is abi encoded and totally depends on the collect module chosen. * @param referenceModule The reference module set for this publication. * @param referenceModuleReturnData The data returned from the reference module at initialization. This is abi * encoded and totally depends on the reference module chosen. * @param timestamp The current block timestamp. */ event CommentCreated( uint256 indexed profileId, uint256 indexed pubId, string contentURI, uint256 profileIdPointed, uint256 pubIdPointed, bytes referenceModuleData, address collectModule, bytes collectModuleReturnData, address referenceModule, bytes referenceModuleReturnData, uint256 timestamp ); /** * @dev Emitted when a "mirror" is published. * * @param profileId The profile's token ID. * @param pubId The new publication's ID. * @param profileIdPointed The profile token ID that this mirror points to. * @param pubIdPointed The publication ID that this mirror points to. * @param referenceModuleData The data passed to the reference module. * @param referenceModule The reference module set for this publication. * @param referenceModuleReturnData The data returned from the reference module at initialization. This is abi * encoded and totally depends on the reference module chosen. * @param timestamp The current block timestamp. */ event MirrorCreated( uint256 indexed profileId, uint256 indexed pubId, uint256 profileIdPointed, uint256 pubIdPointed, bytes referenceModuleData, address referenceModule, bytes referenceModuleReturnData, uint256 timestamp ); /** * @dev Emitted when a followNFT clone is deployed using a lazy deployment pattern. * * @param profileId The token ID of the profile to which this followNFT is associated. * @param followNFT The address of the newly deployed followNFT clone. * @param timestamp The current block timestamp. */ event FollowNFTDeployed( uint256 indexed profileId, address indexed followNFT, uint256 timestamp ); /** * @dev Emitted when a collectNFT clone is deployed using a lazy deployment pattern. * * @param profileId The publisher's profile token ID. * @param pubId The publication associated with the newly deployed collectNFT clone's ID. * @param collectNFT The address of the newly deployed collectNFT clone. * @param timestamp The current block timestamp. */ event CollectNFTDeployed( uint256 indexed profileId, uint256 indexed pubId, address indexed collectNFT, uint256 timestamp ); /** * @dev Emitted upon a successful collect action. * * @param collector The address collecting the publication. * @param profileId The token ID of the profile that the collect was initiated towards, useful to differentiate mirrors. * @param pubId The publication ID that the collect was initiated towards, useful to differentiate mirrors. * @param rootProfileId The profile token ID of the profile whose publication is being collected. * @param rootPubId The publication ID of the publication being collected. * @param collectModuleData The data passed to the collect module. * @param timestamp The current block timestamp. */ event Collected( address indexed collector, uint256 indexed profileId, uint256 indexed pubId, uint256 rootProfileId, uint256 rootPubId, bytes collectModuleData, uint256 timestamp ); /** * @dev Emitted upon a successful follow action. * * @param follower The address following the given profiles. * @param profileIds The token ID array of the profiles being followed. * @param followModuleDatas The array of data parameters passed to each follow module. * @param timestamp The current block timestamp. */ event Followed( address indexed follower, uint256[] profileIds, bytes[] followModuleDatas, uint256 timestamp ); /** * @dev Emitted via callback when a followNFT is transferred. * * @param profileId The token ID of the profile associated with the followNFT being transferred. * @param followNFTId The followNFT being transferred's token ID. * @param from The address the followNFT is being transferred from. * @param to The address the followNFT is being transferred to. * @param timestamp The current block timestamp. */ event FollowNFTTransferred( uint256 indexed profileId, uint256 indexed followNFTId, address from, address to, uint256 timestamp ); /** * @dev Emitted via callback when a collectNFT is transferred. * * @param profileId The token ID of the profile associated with the collectNFT being transferred. * @param pubId The publication ID associated with the collectNFT being transferred. * @param collectNFTId The collectNFT being transferred's token ID. * @param from The address the collectNFT is being transferred from. * @param to The address the collectNFT is being transferred to. * @param timestamp The current block timestamp. */ event CollectNFTTransferred( uint256 indexed profileId, uint256 indexed pubId, uint256 indexed collectNFTId, address from, address to, uint256 timestamp ); // Collect/Follow NFT-Specific /** * @dev Emitted when a newly deployed follow NFT is initialized. * * @param profileId The token ID of the profile connected to this follow NFT. * @param timestamp The current block timestamp. */ event FollowNFTInitialized(uint256 indexed profileId, uint256 timestamp); /** * @dev Emitted when delegation power in a FollowNFT is changed. * * @param delegate The delegate whose power has been changed. * @param newPower The new governance power mapped to the delegate. * @param timestamp The current block timestamp. */ event FollowNFTDelegatedPowerChanged( address indexed delegate, uint256 indexed newPower, uint256 timestamp ); /** * @dev Emitted when a newly deployed collect NFT is initialized. * * @param profileId The token ID of the profile connected to the publication mapped to this collect NFT. * @param pubId The publication ID connected to the publication mapped to this collect NFT. * @param timestamp The current block timestamp. */ event CollectNFTInitialized( uint256 indexed profileId, uint256 indexed pubId, uint256 timestamp ); // Module-Specific /** * @notice Emitted when the ModuleGlobals governance address is set. * * @param prevGovernance The previous governance address. * @param newGovernance The new governance address set. * @param timestamp The current block timestamp. */ event ModuleGlobalsGovernanceSet( address indexed prevGovernance, address indexed newGovernance, uint256 timestamp ); /** * @notice Emitted when the ModuleGlobals treasury address is set. * * @param prevTreasury The previous treasury address. * @param newTreasury The new treasury address set. * @param timestamp The current block timestamp. */ event ModuleGlobalsTreasurySet( address indexed prevTreasury, address indexed newTreasury, uint256 timestamp ); /** * @notice Emitted when the ModuleGlobals treasury fee is set. * * @param prevTreasuryFee The previous treasury fee in BPS. * @param newTreasuryFee The new treasury fee in BPS. * @param timestamp The current block timestamp. */ event ModuleGlobalsTreasuryFeeSet( uint16 indexed prevTreasuryFee, uint16 indexed newTreasuryFee, uint256 timestamp ); /** * @notice Emitted when a currency is added to or removed from the ModuleGlobals whitelist. * * @param currency The currency address. * @param prevWhitelisted Whether or not the currency was previously whitelisted. * @param whitelisted Whether or not the currency is whitelisted. * @param timestamp The current block timestamp. */ event ModuleGlobalsCurrencyWhitelisted( address indexed currency, bool indexed prevWhitelisted, bool indexed whitelisted, uint256 timestamp ); /** * @notice Emitted when a module inheriting from the `FeeModuleBase` is constructed. * * @param moduleGlobals The ModuleGlobals contract address used. * @param timestamp The current block timestamp. */ event FeeModuleBaseConstructed(address indexed moduleGlobals, uint256 timestamp); /** * @notice Emitted when a module inheriting from the `ModuleBase` is constructed. * * @param hub The LensHub contract address used. * @param timestamp The current block timestamp. */ event ModuleBaseConstructed(address indexed hub, uint256 timestamp); /** * @notice Emitted when one or multiple addresses are approved (or disapproved) for following in * the `ApprovalFollowModule`. * * @param owner The profile owner who executed the approval. * @param profileId The profile ID that the follow approvals are granted/revoked for. * @param addresses The addresses that have had the follow approvals grnated/revoked. * @param approved Whether each corresponding address is now approved or disapproved. * @param timestamp The current block timestamp. */ event FollowsApproved( address indexed owner, uint256 indexed profileId, address[] addresses, bool[] approved, uint256 timestamp ); /** * @dev Emitted when the user wants to enable or disable follows in the `LensPeriphery`. * * @param owner The profile owner who executed the toggle. * @param profileIds The array of token IDs of the profiles each followNFT is associated with. * @param enabled The array of whether each FollowNFT's follow is enabled/disabled. * @param timestamp The current block timestamp. */ event FollowsToggled( address indexed owner, uint256[] profileIds, bool[] enabled, uint256 timestamp ); /** * @dev Emitted when the metadata associated with a profile is set in the `LensPeriphery`. * * @param profileId The profile ID the metadata is set for. * @param metadata The metadata set for the profile and user. * @param timestamp The current block timestamp. */ event ProfileMetadataSet(uint256 indexed profileId, string metadata, uint256 timestamp); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; import {ILensNFTBase} from '../../interfaces/ILensNFTBase.sol'; import {Errors} from '../../libraries/Errors.sol'; import {DataTypes} from '../../libraries/DataTypes.sol'; import {Events} from '../../libraries/Events.sol'; import {ERC721Time} from './ERC721Time.sol'; import {ERC721Enumerable} from './ERC721Enumerable.sol'; /** * @title LensNFTBase * @author Lens Protocol * * @notice This is an abstract base contract to be inherited by other Lens Protocol NFTs, it includes * the slightly modified ERC721Enumerable, which itself inherits from the ERC721Time-- which adds an * internal operator approval setter, stores the mint timestamp for each token, and replaces the * constructor with an initializer. */ abstract contract LensNFTBase is ERC721Enumerable, ILensNFTBase { bytes32 internal constant EIP712_REVISION_HASH = keccak256('1'); bytes32 internal constant PERMIT_TYPEHASH = keccak256('Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)'); bytes32 internal constant PERMIT_FOR_ALL_TYPEHASH = keccak256( 'PermitForAll(address owner,address operator,bool approved,uint256 nonce,uint256 deadline)' ); bytes32 internal constant BURN_WITH_SIG_TYPEHASH = keccak256('BurnWithSig(uint256 tokenId,uint256 nonce,uint256 deadline)'); bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256( 'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)' ); mapping(address => uint256) public sigNonces; /** * @notice Initializer sets the name, symbol and the cached domain separator. * * NOTE: Inheritor contracts *must* call this function to initialize the name & symbol in the * inherited ERC721 contract. * * @param name The name to set in the ERC721 contract. * @param symbol The symbol to set in the ERC721 contract. */ function _initialize(string calldata name, string calldata symbol) internal { ERC721Time.__ERC721_Init(name, symbol); emit Events.BaseInitialized(name, symbol, block.timestamp); } /// @inheritdoc ILensNFTBase function permit( address spender, uint256 tokenId, DataTypes.EIP712Signature calldata sig ) external override { if (spender == address(0)) revert Errors.ZeroSpender(); address owner = ownerOf(tokenId); unchecked { _validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( PERMIT_TYPEHASH, spender, tokenId, sigNonces[owner]++, sig.deadline ) ) ), owner, sig ); } _approve(spender, tokenId); } /// @inheritdoc ILensNFTBase function permitForAll( address owner, address operator, bool approved, DataTypes.EIP712Signature calldata sig ) external override { if (operator == address(0)) revert Errors.ZeroSpender(); unchecked { _validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( PERMIT_FOR_ALL_TYPEHASH, owner, operator, approved, sigNonces[owner]++, sig.deadline ) ) ), owner, sig ); } _setOperatorApproval(owner, operator, approved); } /// @inheritdoc ILensNFTBase function getDomainSeparator() external view override returns (bytes32) { return _calculateDomainSeparator(); } /// @inheritdoc ILensNFTBase function burn(uint256 tokenId) public virtual override { if (!_isApprovedOrOwner(msg.sender, tokenId)) revert Errors.NotOwnerOrApproved(); _burn(tokenId); } /// @inheritdoc ILensNFTBase function burnWithSig(uint256 tokenId, DataTypes.EIP712Signature calldata sig) public virtual override { address owner = ownerOf(tokenId); unchecked { _validateRecoveredAddress( _calculateDigest( keccak256( abi.encode( BURN_WITH_SIG_TYPEHASH, tokenId, sigNonces[owner]++, sig.deadline ) ) ), owner, sig ); } _burn(tokenId); } /** * @dev Wrapper for ecrecover to reduce code size, used in meta-tx specific functions. */ function _validateRecoveredAddress( bytes32 digest, address expectedAddress, DataTypes.EIP712Signature calldata sig ) internal view { if (sig.deadline < block.timestamp) revert Errors.SignatureExpired(); address recoveredAddress = ecrecover(digest, sig.v, sig.r, sig.s); if (recoveredAddress == address(0) || recoveredAddress != expectedAddress) revert Errors.SignatureInvalid(); } /** * @dev Calculates EIP712 DOMAIN_SEPARATOR based on the current contract and chain ID. */ function _calculateDomainSeparator() internal view returns (bytes32) { return keccak256( abi.encode( EIP712_DOMAIN_TYPEHASH, keccak256(bytes(name())), EIP712_REVISION_HASH, block.chainid, address(this) ) ); } /** * @dev Calculates EIP712 digest based on the current DOMAIN_SEPARATOR. * * @param hashedMessage The message hash from which the digest should be calculated. * * @return bytes32 A 32-byte output representing the EIP712 digest. */ function _calculateDigest(bytes32 hashedMessage) internal view returns (bytes32) { bytes32 digest; unchecked { digest = keccak256( abi.encodePacked('\x19\x01', _calculateDomainSeparator(), hashedMessage) ); } return digest; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import './ERC721Time.sol'; import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.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. * * NOTE: Modified from Openzeppelin to inherit from a modified ERC721 contract. */ abstract contract ERC721Enumerable is ERC721Time, IERC721Enumerable { // 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(IERC165, ERC721Time) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721Time.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 < ERC721Enumerable.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 = ERC721Time.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 = ERC721Time.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(); } }
// 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 pragma solidity 0.8.10; /** * @title DataTypes * @author Lens Protocol * * @notice A standard library of data types used throughout the Lens Protocol. */ library DataTypes { /** * @notice An enum containing the different states the protocol can be in, limiting certain actions. * * @param Unpaused The fully unpaused state. * @param PublishingPaused The state where only publication creation functions are paused. * @param Paused The fully paused state. */ enum ProtocolState { Unpaused, PublishingPaused, Paused } /** * @notice An enum specifically used in a helper function to easily retrieve the publication type for integrations. * * @param Post A standard post, having a URI, a collect module but no pointer to another publication. * @param Comment A comment, having a URI, a collect module and a pointer to another publication. * @param Mirror A mirror, having a pointer to another publication, but no URI or collect module. * @param Nonexistent An indicator showing the queried publication does not exist. */ enum PubType { Post, Comment, Mirror, Nonexistent } /** * @notice A struct containing the necessary information to reconstruct an EIP-712 typed data signature. * * @param v The signature's recovery parameter. * @param r The signature's r parameter. * @param s The signature's s parameter * @param deadline The signature's deadline */ struct EIP712Signature { uint8 v; bytes32 r; bytes32 s; uint256 deadline; } /** * @notice A struct containing profile data. * * @param pubCount The number of publications made to this profile. * @param followModule The address of the current follow module in use by this profile, can be empty. * @param followNFT The address of the followNFT associated with this profile, can be empty.. * @param handle The profile's associated handle. * @param imageURI The URI to be used for the profile's image. * @param followNFTURI The URI to be used for the follow NFT. */ struct ProfileStruct { uint256 pubCount; address followModule; address followNFT; string handle; string imageURI; string followNFTURI; } /** * @notice A struct containing data associated with each new publication. * * @param profileIdPointed The profile token ID this publication points to, for mirrors and comments. * @param pubIdPointed The publication ID this publication points to, for mirrors and comments. * @param contentURI The URI associated with this publication. * @param referenceModule The address of the current reference module in use by this profile, can be empty. * @param collectModule The address of the collect module associated with this publication, this exists for all publication. * @param collectNFT The address of the collectNFT associated with this publication, if any. */ struct PublicationStruct { uint256 profileIdPointed; uint256 pubIdPointed; string contentURI; address referenceModule; address collectModule; address collectNFT; } /** * @notice A struct containing the parameters required for the `createProfile()` function. * * @param to The address receiving the profile. * @param handle The handle to set for the profile, must be unique and non-empty. * @param imageURI The URI to set for the profile image. * @param followModule The follow module to use, can be the zero address. * @param followModuleInitData The follow module initialization data, if any. * @param followNFTURI The URI to use for the follow NFT. */ struct CreateProfileData { address to; string handle; string imageURI; address followModule; bytes followModuleInitData; string followNFTURI; } /** * @notice A struct containing the parameters required for the `setDefaultProfileWithSig()` function. Parameters are * the same as the regular `setDefaultProfile()` function, with an added EIP712Signature. * * @param wallet The address of the wallet setting the default profile. * @param profileId The token ID of the profile which will be set as default, or zero. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetDefaultProfileWithSigData { address wallet; uint256 profileId; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `setFollowModuleWithSig()` function. Parameters are * the same as the regular `setFollowModule()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to change the followModule for. * @param followModule The followModule to set for the given profile, must be whitelisted. * @param followModuleInitData The data to be passed to the followModule for initialization. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetFollowModuleWithSigData { uint256 profileId; address followModule; bytes followModuleInitData; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `setDispatcherWithSig()` function. Parameters are the same * as the regular `setDispatcher()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to set the dispatcher for. * @param dispatcher The dispatcher address to set for the profile. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetDispatcherWithSigData { uint256 profileId; address dispatcher; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `setProfileImageURIWithSig()` function. Parameters are the same * as the regular `setProfileImageURI()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to set the URI for. * @param imageURI The URI to set for the given profile image. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct SetProfileImageURIWithSigData { uint256 profileId; string imageURI; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `setFollowNFTURIWithSig()` function. Parameters are the same * as the regular `setFollowNFTURI()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile for which to set the followNFT URI. * @param followNFTURI The follow NFT URI to set. * @param sig The EIP712Signature struct containing the followNFT's associated profile owner's signature. */ struct SetFollowNFTURIWithSigData { uint256 profileId; string followNFTURI; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `post()` function. * * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param collectModule The collect module to set for this new publication. * @param collectModuleInitData The data to pass to the collect module's initialization. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. */ struct PostData { uint256 profileId; string contentURI; address collectModule; bytes collectModuleInitData; address referenceModule; bytes referenceModuleInitData; } /** * @notice A struct containing the parameters required for the `postWithSig()` function. Parameters are the same as * the regular `post()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param collectModule The collectModule to set for this new publication. * @param collectModuleInitData The data to pass to the collectModule's initialization. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct PostWithSigData { uint256 profileId; string contentURI; address collectModule; bytes collectModuleInitData; address referenceModule; bytes referenceModuleInitData; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `comment()` function. * * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param profileIdPointed The profile token ID to point the comment to. * @param pubIdPointed The publication ID to point the comment to. * @param referenceModuleData The data passed to the reference module. * @param collectModule The collect module to set for this new publication. * @param collectModuleInitData The data to pass to the collect module's initialization. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. */ struct CommentData { uint256 profileId; string contentURI; uint256 profileIdPointed; uint256 pubIdPointed; bytes referenceModuleData; address collectModule; bytes collectModuleInitData; address referenceModule; bytes referenceModuleInitData; } /** * @notice A struct containing the parameters required for the `commentWithSig()` function. Parameters are the same as * the regular `comment()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to publish to. * @param contentURI The URI to set for this new publication. * @param profileIdPointed The profile token ID to point the comment to. * @param pubIdPointed The publication ID to point the comment to. * @param referenceModuleData The data passed to the reference module. * @param collectModule The collectModule to set for this new publication. * @param collectModuleInitData The data to pass to the collectModule's initialization. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct CommentWithSigData { uint256 profileId; string contentURI; uint256 profileIdPointed; uint256 pubIdPointed; bytes referenceModuleData; address collectModule; bytes collectModuleInitData; address referenceModule; bytes referenceModuleInitData; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `mirror()` function. * * @param profileId The token ID of the profile to publish to. * @param profileIdPointed The profile token ID to point the mirror to. * @param pubIdPointed The publication ID to point the mirror to. * @param referenceModuleData The data passed to the reference module. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. */ struct MirrorData { uint256 profileId; uint256 profileIdPointed; uint256 pubIdPointed; bytes referenceModuleData; address referenceModule; bytes referenceModuleInitData; } /** * @notice A struct containing the parameters required for the `mirrorWithSig()` function. Parameters are the same as * the regular `mirror()` function, with an added EIP712Signature. * * @param profileId The token ID of the profile to publish to. * @param profileIdPointed The profile token ID to point the mirror to. * @param pubIdPointed The publication ID to point the mirror to. * @param referenceModuleData The data passed to the reference module. * @param referenceModule The reference module to set for the given publication, must be whitelisted. * @param referenceModuleInitData The data to be passed to the reference module for initialization. * @param sig The EIP712Signature struct containing the profile owner's signature. */ struct MirrorWithSigData { uint256 profileId; uint256 profileIdPointed; uint256 pubIdPointed; bytes referenceModuleData; address referenceModule; bytes referenceModuleInitData; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `followWithSig()` function. Parameters are the same * as the regular `follow()` function, with the follower's (signer) address and an EIP712Signature added. * * @param follower The follower which is the message signer. * @param profileIds The array of token IDs of the profiles to follow. * @param datas The array of arbitrary data to pass to the followModules if needed. * @param sig The EIP712Signature struct containing the follower's signature. */ struct FollowWithSigData { address follower; uint256[] profileIds; bytes[] datas; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `collectWithSig()` function. Parameters are the same as * the regular `collect()` function, with the collector's (signer) address and an EIP712Signature added. * * @param collector The collector which is the message signer. * @param profileId The token ID of the profile that published the publication to collect. * @param pubId The publication to collect's publication ID. * @param data The arbitrary data to pass to the collectModule if needed. * @param sig The EIP712Signature struct containing the collector's signature. */ struct CollectWithSigData { address collector; uint256 profileId; uint256 pubId; bytes data; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `setProfileMetadataWithSig()` function. * * @param profileId The profile ID for which to set the metadata. * @param metadata The metadata string to set for the profile and user. * @param sig The EIP712Signature struct containing the user's signature. */ struct SetProfileMetadataWithSigData { uint256 profileId; string metadata; EIP712Signature sig; } /** * @notice A struct containing the parameters required for the `toggleFollowWithSig()` function. * * @param follower The follower which is the message signer. * @param profileIds The token ID array of the profiles. * @param enables The array of booleans to enable/disable follows. * @param sig The EIP712Signature struct containing the follower's signature. */ struct ToggleFollowWithSigData { address follower; uint256[] profileIds; bool[] enables; EIP712Signature sig; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.10; import {DataTypes} from '../libraries/DataTypes.sol'; /** * @title ILensNFTBase * @author Lens Protocol * * @notice This is the interface for the LensNFTBase contract, from which all Lens NFTs inherit. * It is an expansion of a very slightly modified ERC721Enumerable contract, which allows expanded * meta-transaction functionality. */ interface ILensNFTBase { /** * @notice Implementation of an EIP-712 permit function for an ERC-721 NFT. We don't need to check * if the tokenId exists, since the function calls ownerOf(tokenId), which reverts if the tokenId does * not exist. * * @param spender The NFT spender. * @param tokenId The NFT token ID to approve. * @param sig The EIP712 signature struct. */ function permit( address spender, uint256 tokenId, DataTypes.EIP712Signature calldata sig ) external; /** * @notice Implementation of an EIP-712 permit-style function for ERC-721 operator approvals. Allows * an operator address to control all NFTs a given owner owns. * * @param owner The owner to set operator approvals for. * @param operator The operator to approve. * @param approved Whether to approve or revoke approval from the operator. * @param sig The EIP712 signature struct. */ function permitForAll( address owner, address operator, bool approved, DataTypes.EIP712Signature calldata sig ) external; /** * @notice Burns an NFT, removing it from circulation and essentially destroying it. This function can only * be called by the NFT to burn's owner. * * @param tokenId The token ID of the token to burn. */ function burn(uint256 tokenId) external; /** * @notice Implementation of an EIP-712 permit-style function for token burning. Allows anyone to burn * a token on behalf of the owner with a signature. * * @param tokenId The token ID of the token to burn. * @param sig The EIP712 signature struct. */ function burnWithSig(uint256 tokenId, DataTypes.EIP712Signature calldata sig) external; /** * @notice Returns the domain separator for this NFT contract. * * @return bytes32 The domain separator. */ function getDomainSeparator() external view returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import './IERC721Time.sol'; import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol'; import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol'; import '@openzeppelin/contracts/utils/Address.sol'; import '@openzeppelin/contracts/utils/Context.sol'; import '@openzeppelin/contracts/utils/Strings.sol'; import '@openzeppelin/contracts/utils/introspection/ERC165.sol'; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. * * Modifications: * 1. Refactored _operatorApprovals setter into an internal function to allow meta-transactions. * 2. Constructor replaced with an initializer. * 3. Mint timestamp is now stored in a TokenData struct alongside the owner address. */ abstract contract ERC721Time is Context, ERC165, IERC721Time, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to token Data (owner address and mint timestamp uint96), this // replaces the original mapping(uint256 => address) private _owners; mapping(uint256 => IERC721Time.TokenData) private _tokenData; // 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 ERC721 name and symbol. * * @param name The name to set. * @param symbol The symbol to set. */ function __ERC721_Init(string calldata name, string calldata symbol) internal { _name = name; _symbol = symbol; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), 'ERC721: 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 = _tokenData[tokenId].owner; require(owner != address(0), 'ERC721: owner query for nonexistent token'); return owner; } /** * @dev See {IERC721Time-mintTimestampOf} */ function mintTimestampOf(uint256 tokenId) public view virtual override returns (uint256) { uint96 mintTimestamp = _tokenData[tokenId].mintTimestamp; require(mintTimestamp != 0, 'ERC721: mint timestamp query for nonexistent token'); return mintTimestamp; } /** * @dev See {IERC721Time-mintTimestampOf} */ function tokenDataOf(uint256 tokenId) public view virtual override returns (IERC721Time.TokenData memory) { require(_exists(tokenId), 'ERC721: token data query for nonexistent token'); return _tokenData[tokenId]; } /** * @dev See {IERC721Time-exists} */ function exists(uint256 tokenId) public view virtual override returns (bool) { return _exists(tokenId); } /** * @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 overriden 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 = ERC721Time.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 { require(operator != _msgSender(), 'ERC721: approve to caller'); _setOperatorApproval(_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 _tokenData[tokenId].owner != 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 = ERC721Time.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, 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; _tokenData[tokenId].owner = to; _tokenData[tokenId].mintTimestamp = uint96(block.timestamp); emit Transfer(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 = ERC721Time.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _tokenData[tokenId]; emit Transfer(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(ERC721Time.ownerOf(tokenId) == from, 'ERC721: transfer of token that is not own'); 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; _tokenData[tokenId].owner = to; emit Transfer(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(ERC721Time.ownerOf(tokenId), to, tokenId); } /** * @dev Refactored from the original OZ ERC721 implementation: approve or revoke approval from * `operator` to operate on all tokens owned by `owner`. * * Emits a {ApprovalForAll} event. */ function _setOperatorApproval( address owner, address operator, bool approved ) internal virtual { _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns ( bytes4 retval ) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert('ERC721: transfer to non ERC721Receiver implementer'); } else { 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 {} }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import '@openzeppelin/contracts/token/ERC721/IERC721.sol'; /** * @title IERC721Time * @author Lens Protocol * * @notice This is an expansion of the IERC721 interface that includes a struct for token data, * which contains the token owner and the mint timestamp as well as associated getters. */ interface IERC721Time is IERC721 { /** * @notice Contains the owner address and the mint timestamp for every NFT. * * Note: Instead of the owner address in the _tokenOwners private mapping, we now store it in the * _tokenData mapping, alongside the unchanging mintTimestamp. * * @param owner The token owner. * @param mintTimestamp The mint timestamp. */ struct TokenData { address owner; uint96 mintTimestamp; } /** * @notice Returns the mint timestamp associated with a given NFT, stored only once upon initial mint. * * @param tokenId The token ID of the NFT to query the mint timestamp for. * * @return uint256 mint timestamp, this is stored as a uint96 but returned as a uint256 to reduce unnecessary * padding. */ function mintTimestampOf(uint256 tokenId) external view returns (uint256); /** * @notice Returns the token data associated with a given NFT. This allows fetching the token owner and * mint timestamp in a single call. * * @param tokenId The token ID of the NFT to query the token data for. * * @return TokenData token data struct containing both the owner address and the mint timestamp. */ function tokenDataOf(uint256 tokenId) external view returns (TokenData memory); /** * @notice Returns whether a token with the given token ID exists. * * @param tokenId The token ID of the NFT to check existence for. * * @return bool True if the token exists. */ function exists(uint256 tokenId) external view returns (bool); }
// 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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly 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/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { 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 "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @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); }
{ "optimizer": { "enabled": true, "runs": 200, "details": { "yul": true } }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
[{"inputs":[{"internalType":"address","name":"hub","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InitParamsInvalid","type":"error"},{"inputs":[],"name":"Initialized","type":"error"},{"inputs":[],"name":"InvalidParameter","type":"error"},{"inputs":[],"name":"NotHub","type":"error"},{"inputs":[],"name":"NotOwnerOrApproved","type":"error"},{"inputs":[],"name":"NotProfileOwner","type":"error"},{"inputs":[],"name":"SignatureExpired","type":"error"},{"inputs":[],"name":"SignatureInvalid","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"ZeroSpender","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"HUB","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct DataTypes.EIP712Signature","name":"sig","type":"tuple"}],"name":"burnWithSig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSourcePublicationPointer","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"profileId","type":"uint256"},{"internalType":"uint256","name":"pubId","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","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":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mintTimestampOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct DataTypes.EIP712Signature","name":"sig","type":"tuple"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"internalType":"struct DataTypes.EIP712Signature","name":"sig","type":"tuple"}],"name":"permitForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"royaltyBasisPoints","type":"uint256"}],"name":"setRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"sigNonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenDataOf","outputs":[{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint96","name":"mintTimestamp","type":"uint96"}],"internalType":"struct IERC721Time.TokenData","name":"","type":"tuple"}],"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"}]
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.