Shulou(Shulou.com)06/01 Report--

This article mainly explains "how to realize the ERC721 collection contract". The content of the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to realize the ERC721 collection contract".

ERC721 prescribes some interface functions to make it conform to the ERC20 token standard to some extent. This is done to make it easier for existing wallets to display basic information about tokens. These functions allow ERC721-compliant smart contracts like bitcoin or common digital cryptocoins such as ethercoin to define functions that allow users to send tokens to others or check account balances through smart contract programming.

This is a concise ERC721 Smart contract statement:

Contract ERC721 {/ / ERC20 compatible interfaces function name () constant returns (string name); function symbol () constant returns (string symbol); function totalSupply () constant returns (uint256 totalSupply); function balanceOf (address _ owner) constant returns (uint balance); / / ownership-related interfaces function ownerOf (uint256 _ tokenId) constant returns (address owner); function approve (address _ to, uint256 _ tokenId); function takeOwnership (uint256 _ tokenId); function transfer (address _ to, uint256 _ tokenId) Function tokenOfOwnerByIndex (address _ owner, uint256 _ index) constant returns (uint tokenId); / / Certificate metadata interface function tokenMetadata (uint256 _ tokenId) constant returns (string infoUrl); / / event event Transfer (address indexed _ from, address indexed _ to, uint256 _ tokenId); event Approval (address indexed _ owner, address indexed _ approved, uint256 _ tokenId);} name-name

This function should return the name of the pass. For example:

Contract MyNFT {function name () constant returns (string name) {return "My Non-FungibleToken";}} Symbol-symbol

This function should return the symbol of the certificate, which helps to improve compatibility with ERC20. For example:

Contract MyNFT {function symbol () constant returns (string symbol) {return "MNFT";}}

TotalSupply-Total circulation

This function should return the total number of passes supplied on the blockchain, which is not necessarily fixed. For example:

Contract MyNFT {/ / how much you want to issue depends on you;) uint256 private totalSupply = 100000000000; function totalSupply () constant returns (uint256supply) {return totalSupply;}} balanceOf-balance

This function is used to query the balance of the pass in an address. For example:

Contract MyNFT {mapping (address = > uint) privatebalances; function balanceOf (address _ owner) constant returns (uint balance) {return balances [_ owner];}}

The following functions define how the contract handles the ownership of the pass and how to transfer the ownership. The two most important functions are takeOwnership and transfer, which are used to transfer certificates between users, just like bank withdrawals and remittances.

OwnerOf-money holder

This function returns the address of the pass holder. Because each ERC721 pass is irreplaceable, it can be found at the unique address on the block chain, and we can use the ID of the pass to determine its holder.

Contract MyNFT {mapping (uint256 = > address) privatetokenOwners; mapping (uint256 = > bool) private tokenExists; function ownerOf (uint256 _ tokenId) constant returns (address owner) {require (tokenExists [_ tokenId]); return tokenOwners [_ tokenId];} approve-authorization

This function is used to authorize another subject to perform a pass transfer operation on behalf of the holder. For example, suppose Alice has an ERC721 pass, she can call the approve function to authorize her friend Bob, and then Bob can exercise the rights of the pass holder on behalf of Alice.

Contract MyNFT {mapping (address= > mapping (address= > uint256)) allowed; function approve (address _ to, uint256 _ tokenId) {require (msg.sender = = ownerOf (_ tokenId)); require (msg.sender! = _ to); allowedding [msg.sender] [_ to] = _ tokenId; Approval (msg.sender, _ to, _ tokenId);} takeOwnership-get

This function is similar to the withdrawal function, where an external subject invokes the takeOwnership function to extract an ERC721 certificate from another user's account.

Therefore, when a user is authorized by (others) to have a certain number of passes, this part of the pass can be extracted from another user's account through this function.

Contract MyNFT {function takeOwnership (uint256_tokenId) {require (tokenExists [_ tokenId]); address oldOwner = ownerOf (_ tokenId); address newOwner = msg.sender; require (newOwner! = oldOwner); require (allowed[ oldOwner] [newOwner] = = _ tokenId); balances [oldOwner]-= 1; tokenOwners [_ tokenId] = newOwner; balances [oldOwner] + = 1; Transfer (oldOwner, newOwner,_tokenId);} transfer-transfer

Another way to transfer a pass is to use the transfer function. The transfer function allows a user to send a pass to another user, similar to operating an encrypted digital currency such as bitcoin. However, transfers can only be made if the remittance account has been authorized to hold its permit prior to the remittance account.

Contract MyNFT {mapping (address = > mapping (uint256 = > uint256)) private ownerTokens; function removeFromTokenList (address owner, uint256 _ tokenId) private {for (uint256 I = 0 × ownerTokens [owner] [I]! = _ tokenId;i++) {ownerTokens [owner] [I] = 0;} function transfer (address _ to, uint256 _ tokenId) {address currentOwner = msg.sender; address newOwner = _ to; require (tokenExists [_ tokenId]); require (currentOwner = = ownerOf (_ tokenId)) Require (currentOwner! = newOwner); require (newOwner! = address (0)); removeFromTokenList (_ tokenId); balances [oldOwner]-= 1; tokenOwners [_ tokenId] = newOwner; balances [newOwner] + = 1; Transfer (oldOwner, newOwner, _ tokenId);}} tokenOfOwnerByIndex-pass search

This function is optional, but it is recommended that you implement it.

Each ERC721 pass holder can hold more than one pass at the same time, because each pass has a unique ID, but it may be difficult to track the pass held by a user. To do this, the contract needs to record each pass held by each user. In this way, users can retrieve the pass they own through the index list. The Certificate Retrieval (tokenOfOwnerByIndex) function can trace a particular pass in this way.

Contract MyNFT {mapping (address = > mapping (uint256 = > uint256)) private ownerTokens; function tokenOfOwnerByIndex (address _ owner, uint256 _ index) constant returns (uint tokenId) {return ownerTokens [_ owner] [_ index];} tokenMetaData-pass metadata

As we said before, what makes objects irreplaceable is their unique characteristics. The dollar and tennis cards are irreplaceable because they have different characteristics. However, storing these distinguishing features of each pass on the blockchain is costly and is not recommended. To solve this problem, we can store references (references) for each pass, such as IPFS hashes or HTTP (S) links, which are called metadata. Metadata is optional.

The tokenMetaData function should return the metadata of the pass, or a link to the pass data.

Contract MyNFT {mapping (uint256 = > string) tokenLinks; function tokenMetadata (uint256 _ tokenId) constant returns (string infoUrl) {return tokenLinks [_ tokenId];}}

When the contract method is called, the event will be triggered and, once triggered, will be propagated to the listening system. The external application can listen to the events in the block chain, and once the event in the block chain is triggered, the listening system can execute the logic program through the information contained in the event. The ERC721 standard defines the following two events.

Transfer-transfer

When the ownership of a pass is transferred from one user to another, the event is triggered, and the event information includes the outgoing account, the inward account, and the pass ID.

Contract MyNFT {event Transfer (address indexed _ from,address indexed _ to, uint256 _ tokenId);} Approval-approved

When a user allows another user to hold his or her pass (for example, when the Authorization feature is enabled), the event is triggered and the event information contains the current holding account of the pass, the authorized account, and the pass ID.

Contract MyNFT {event Approval (address indexed _ owner, address indexed _ approved, uint256 _ tokenId);} Thank you for your reading. The above is the content of "how to realize the ERC721 Collection contract". After the study of this article, I believe you have a deeper understanding of how to realize the ERC721 collection contract, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.