https://www.talksonlaw.com/briefs/how-do-nft-royalties-work
O que é NFT?
Os NFTs, vulgo tokens não fungíveis, são uma tendência entre as Blockchains. O padrão EVM para NFTs pode ser ERC-721 e ERC-1155 (Padrão Multi-token). Os NFTs podem ser vendidos em em mercados como Opensea, Rarible, LooksRare.
O que é Royalty?
Os royalties são uma porcentagem (comissão) para o criador/artista do NFT para cada venda secundária feita no mercado. Para facilitar as coisas, a ETHEREUM IMPROVEMENT PROPOSALS (EIP ou Propostas de Melhoramento da Ethereum) introduziu a EIP-2891 para implementar royalty a seu NFT.
Vamos criar um padrão EIP-2981 de NFT
Primeiro, vamos criar um token padrão ERC-721 e criar nosso NFT. Vá para o assistente do Openzeppelin e gere um contrato ERC-721 simples.
Seu código ficará semelhante a este:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/[email protected]/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
import "@openzeppelin/[email protected]/utils/Counters.sol";
contract RoyaltyNFT is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
constructor() ERC721("RoyaltyNFT", "RNFT") {}
function safeMint(address to, string memory uri) public onlyOwner {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}
// As seguintes funções são sobrepostas em conformidade com a Solidity..
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
super._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
super._burn(tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}
Seu contrato NFT está pronto. Agora vamos implementar o padrão EIP-2981 (NFT Royalty Standard).
Nota: A Opensea não suporta a EIP-2981. Você precisa ter metadados de nível de contrato implementado em seu contrato NFT para adicionar Royalty à coleção. No entanto, você pode definir manualmente os royalties para cada token na Opensea.
Importe ERC2981.sol do Openzeppelin e implemente-o em seu contrato.
Substitua a declaração import “@openzeppelin/[email protected]/” por “https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/” se você estiver usando o IDE Remix.
Nota:Substitua a __beforeConsecutiveTokenTransfer, já que mais de um contrato herdado está usando esta função.
Seu código final ficaria assim:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/common/ERC2981.sol";
contract RoyaltyNFT is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, ERC2981 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
constructor() ERC721("RoyaltyNFT", "RNFT") {}
function safeMint(address to, string memory uri) public onlyOwner {
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}
// As seguintes funções são sobrepostas em conformidade com a Solidity.
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
super._beforeTokenTransfer(from, to, tokenId);
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
super._burn(tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC2981)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
function _beforeConsecutiveTokenTransfer(
address,
address,
uint256,
uint96
) internal virtual override(ERC721, ERC721Enumerable) {
revert("ERC721Enumerable: consecutive transfers not supported");
}
}
Nós importamos o ERC-2981 para nosso contrato. Agora vamos criar um mintWithRoyalty para cunhar o NFT com porcentagem de Royalty Fee (taxa de royalty). Esta função terá 2 parâmetros extras para definir o receptor da royaltyFee e a porcentagem de royalty.
O Openzeppelin calcula a taxa de royalty usando pontos de base. Que será o percentual vezes 10 elevado a 2. Por exemplo, se você quiser definir 1% como porcentagem de taxa de royalties, ela deverá ser definida como 100.
function mintWithRoyalty(address recipient, string memory uri, address royaltFeeReceiver, uint96 fee) public returns(uint256){
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(recipient, tokenId);
_setTokenURI(tokenId, uri);
_setTokenRoyalty(tokenId, royaltFeeReceiver, fee);
return tokenId;
}
Criamos agora uma função para cunhar NFTs com royalties. Vamos implantar o contrato na Rede Rinkeby (Nota do tradutor: A Rinkeby foi descontinuada. Utilize a rede de testes Goerli) e verificar nosso NFT na Rarible. Para este tutorial, eu estou usando o Remix IDE para desenvolvimento e implantação dos contratos inteligentes.
Consulte este artigo sobre como implantar contratos inteligentes no Remix IDE
Cunhar NFT com Royalty
É assim que parece, uma vez que seu contrato inteligente é implantado. Você pode ver à esquerda as funções que escrevemos/implementamos em nosso contrato.
Vamos cunhar um NFT com Royalty.
Como dissemos, a função requer 4 parâmetros: Token Receiver (Destinatário do Token), Token URI (URI do Token), Royalty Fee Receiver (Destinatário da Taxa de Royalty) e a Fee percentage in Basis Points (porcentagem da taxa em pontos de base). Eu defini uma string vazia para o parâmetro URI para fins de teste. Você pode adicionar o URL dos metadados do seu token a ele. Eu defini a taxa de royalties como 10% que é de 1000 pontos de base.
0xf37e62edbabd48182b8d8691593ffee100cbedf292b4a2b094647b6c86a3351b O hash de transação da execução da função acima.
Visualizar o NFT na Rarible
A Rede de teste Rarible suporta a rede Rinkeby. Conecte sua carteira à Metamask com a rede de teste Rarible. Certifique-se de usar a chave pública utilizada para implantar o contrato. Uma vez configurada sua conta na Rarible, verifique suas coleções em seu perfil. Você poderá ver seu Contrato NFT como uma coleção.
Uma vez que você clicar em sua coleção, poderá visualizar todos os NFTs da coleção.
Você pode ver nosso NFT cunhado na coleção. Como eu não adicionei Metadados ao token, ele não exibe o nome, imagem ou descrição. No entanto, você pode ver a porcentagem de royalties e o receptor de royalties que adicionamos ao criar o NFT.
A Rarible foi capaz de detectar royalties em nosso token porque suporta a interface EIP-2981.
Agora aprendemos como criar um NFT de padrão EIP-2981. Vamos aprender mais juntos.
Vamos nos conectar
Siga-me no Medium, LinkedIn, Twitter, Instagram
Esse artigo foi escrito por Nufailismath e traduzido por Fátima Lima. O original pode ser lido aqui.
Top comments (0)