Como criar um NFT dinâmico usando 3 serviços da Chainlink [< 1 hora]
Este artigo é uma tradução. Artigo original: How To Create a Dynamic NFT Using 3 Chainlink Services [<1 Hour]
Visão geral
Nível de dificuldade: Iniciante / Intermediário
Tempo estimado para concluir: 60 minutos
Neste tutorial, você aprenderá como implantar um contrato inteligente na testnet Polygon Mumbai usando o Remix. O contrato inteligente cria um NFT que é atualizado dinamicamente com base no preço do ETH em relação ao USD.
Abaixo, você encontrará instruções passo a passo sobre como:
- Crie uma carteira MetaMask
- Obter fundos na rede de teste Polygon Mumbai
- Crie uma assinatura do Chainlink VRF
- Implante o contrato inteligente Dynamic NFT ( dNFT ) usando o Remix
- Adicione o contrato inteligente dNFT como consumidor de VRF
- Automatize o NFT usando o Chainlink Automation
- Veja e interaja com seu NFT no OpenSea
Etapa 1: criar uma carteira MetaMask
Nota: Se você já possui uma carteira MetaMask (ou qualquer outra carteira), fique à vontade para pular esta etapa.
Para criar uma carteira MetaMask, vá para o site da MetaMask e siga as instruções para criar sua carteira.
Etapa 2: obtenha fundos da rede de teste Polygon Mumbai
A ) Vá para https://faucets.chain.link/mumbai
B ) Clique em “ Conecte a carteira ” no canto superior direito.
C ) Se esta é a primeira vez que você interage com a Polygon Mumbai, clique em “ Approve ” no prompt da MetaMask com a mensagem “ Permita que este site adicione uma rede? ”
D ) Clique em “ Trocar de rede ”.
E ) Verifique a caixa de seleção “ Sou humano ” e preencha o CAPTCHA.
F ) Clique em “ Send request” para enviar a solicitação.
G ) Aguarde a conclusão da transação.
Parabéns! Você solicitou e recebeu com sucesso o testnet Polygon Mumbai MATIC e o testnet LINK.
Nota: Se o Faucet da Chainlink ficar sem MATIC de testnet, use o Faucet da Polygon Mumbai para receber o testnet MATIC. Você ainda precisará usar o Chainlink Faucet para receber o testnet LINK.
Etapa 3: criar uma assinatura VRF
Antes de implantarmos o contrato inteligente do nosso dNFT, primeiro criaremos uma assinatura VRF. Pense nisso como um balde de fundos para o seu contrato usar ao gerar números aleatórios. Precisamos do ID da assinatura para implantar o contrato inteligente.
A ) Vá para https://vrf.chain.link/mumbai
B ) Clique em “ Conectar carteira ” no canto superior direito.
C ) Clique em “ Create Subscription” para criar uma assinatura.
D ) Clique em “ Create Subscription” novamente.
E ) Um prompt da MetaMask deve aparecer. Clique em “ Assinar ”.
F ) Clique em “ Confirme ” na MetaMask e aguarde a confirmação da transação.
G ) Depois que a transação for confirmada e a assinatura for criada, clique em “ Add funds” para adicionar fundos.
H ) Na caixa de entrada “ Adicionar fundos (LINK) ”, adicione 2 LINK e clique em “Add funds”.
I ) Confirme a transação na MetaMask.
Parabéns! Você criou com sucesso sua assinatura VRF e a financiou com alguns testnet LINK. Voltaremos à assinatura do VRF na próxima etapa.
Etapa 4: implante o contrato inteligente do NFT dinâmico no Remix
O Remix é um ambiente de desenvolvimento integrado on-line (IDE) projetado especificamente para desenvolver e testar contratos inteligentes na blockchain da Ethereum. Ele fornece uma interface amigável e um conjunto de ferramentas poderosas para escrever, compilar, implantar e depurar contratos inteligentes Ethereum.
Nesta etapa, você aprenderá como criar um novo espaço de trabalho do Remix e implantar um contrato inteligente. Não se preocupe: o contrato inteligente já está escrito, então tudo que você precisa fazer é copiar e colar.
A ) Vá para https://remix.ethereum.org/
B ) Clique no ícone “ + ” no canto superior esquerdo da tela para criar um novo espaço de trabalho.
C ) Digite um nome para o seu novo espaço de trabalho e clique em “ OK ”.
D ) Clique com o botão direito do mouse em “ contrai ” na barra lateral esquerda e clique em “ New File” para criar um novo arquivo.
E ) Nomeie o arquivo “ demo.sol ” ou qualquer outro nome que você desejar e pressione enter.
F ) Copie este código.
// SPDX-License-Identifier: MIT
// This is for DEMO purposes only and should not be used in production!
pragma solidity ^0.8.10;
// Importing other contracts
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
// Define SuperDynamicNFT contract which inherits from ERC721, ERC721URIStorage and VRFConsumerBaseV2
contract SuperDynamicNFT is ERC721, ERC721URIStorage, VRFConsumerBaseV2 {
// State variables for tracking ETH price and the corresponding emoji
int256 previousEthPrice = 0;
string ethIndicatorUp = unicode"😀";
string ethIndicatorDown = unicode"😔";
string ethIndicatorFlat = unicode"😑";
string ethIndicator;
// State variables for creating SVGs
string[] public hexDigits = [
"0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b",
"c", "d", "e", "f"
];
string public fillColor = "#000000";
// Interfaces for getting price data and random numbers from Chainlink
AggregatorV3Interface internal priceFeed;
VRFCoordinatorV2Interface COORDINATOR;
// VRF-related state variables
uint64 private s_subscriptionId;
uint32 private callbackGasLimit = 2500000;
uint16 private requestConfirmations = 3;
uint32 private numWords = 6;
uint256[] public s_randomWords;
// Contract owner's address
address private s_owner;
// VRF settings specific to Mumbai testnet
address private vrfCoordinator = 0x7a1BaC17Ccc5b313516C5E16fb24f7659aA5ebed;
bytes32 private keyHash = 0x4b09e658ed251bcafeebbc69400383d49f344ace09b9576fe248bb02c003fe9f;
// Constructor takes subscription ID and sets up the contract
constructor(uint64 subscriptionId)
ERC721("ETH Watch SVG", "ewSVG")
VRFConsumerBaseV2(vrfCoordinator)
{
priceFeed = AggregatorV3Interface(0x0715A7794a1dc8e42615F059dD6e406A6594651A);
s_owner = msg.sender;
COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
s_subscriptionId = subscriptionId;
_safeMint(s_owner, 0);
}
// Function to request random Numbers from the VRF
function requestRandomWords() public {
// Will revert if subscription is not set and funded.
COORDINATOR.requestRandomWords(
keyHash,
s_subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
}
// Callback function used by VRF Coordinator
function fulfillRandomWords(
uint256, /* requestId */
uint256[] memory randomWords
) internal override {
s_randomWords = randomWords;
//Get new fill color
updateFillColor();
// Update NFT SVG
updateETHPrice();
}
// Function to update fill color of SVG based on VRF-provided random numbers
function updateFillColor() internal {
fillColor = string(
abi.encodePacked(
"#",
randomHexDigit(s_randomWords[0]),
randomHexDigit(s_randomWords[1]),
randomHexDigit(s_randomWords[2]),
randomHexDigit(s_randomWords[3]),
randomHexDigit(s_randomWords[4]),
randomHexDigit(s_randomWords[5])
)
);
}
// Function to update ETH price and corresponding emoji
function updateETHPrice() internal returns (string memory) {
int256 currentEthPrice = getETHPrice();
if (currentEthPrice > previousEthPrice) {
ethIndicator = ethIndicatorUp;
} else if (currentEthPrice < previousEthPrice) {
ethIndicator = ethIndicatorDown;
} else {
ethIndicator = ethIndicatorFlat;
}
previousEthPrice = currentEthPrice;
return ethIndicator;
}
// Helper function to generate a random hex digit
function randomHexDigit(uint256 _randomNum)
internal
view
returns (string memory)
{
uint256 randomIndex = _randomNum % hexDigits.length;
return hexDigits[randomIndex];
}
// Function to get the current price of ETH from Chainlink
function getETHPrice() internal view returns (int256) {
(, int256 price, , , ) = priceFeed.latestRoundData();
return price;
}
// Overridden tokenURI function to produce SVG images as NFTs
function tokenURI(uint256) public view override(ERC721, ERC721URIStorage)
returns (string memory)
{
// Create SVG rectangle with color
string memory imgSVG = string(
abi.encodePacked(
"<svg xmlns='http://www.w3.org/2000/svg' version='1.1' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:svgjs='http://svgjs.com/svgjs' width='500' height='500' preserveAspectRatio='none' viewBox='0 0 500 500'> <rect width='100%' height='100%' fill='",
fillColor,
"' />",
"<text x='50%' y='50%' font-size='128' dominant-baseline='middle' text-anchor='middle'>",
ethIndicator,
"</text>",
"</svg>"));
string memory json = Base64.encode(
bytes(
string(
abi.encodePacked(
'{"name": "ETH Watching SVG",',
'"description": "An Automated ETH tracking SVG",',
'"image": "data:image/svg+xml;base64,',
Base64.encode(bytes(imgSVG)),
'"}'
)
)
)
);
// Create token URI
string memory finalTokenURI = string(
abi.encodePacked("data:application/json;base64,", json)
);
return finalTokenURI;
}
// Overridden burn function to ensure ERC721 and ERC721URIStorage compatibility
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
super._burn(tokenId);
}
// Modifier to restrict certain functions to contract owner
modifier onlyOwner() {
require(msg.sender == s_owner);
_;
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721URIStorage)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}G ) Volte para Remix e cole o código no seu arquivo demo.sol recém-criado
Nota: Você pode receber um aviso pop-up de que está colando um grande pedaço de código. Clique em “OK ”.
H ) Clique no ícone “Solidity Compiler” na barra lateral esquerda.
I ) Clique em “Compile demo.sol”.
J ) Clique no ícone “Deploy & run transactions” na barra lateral esquerda para implantar e executar transações.
K ) Clique no menu suspenso “Environment” e altere-o de “Remix VM (Xangai ) ” para “Injected Provider — MetaMask ” e siga as instruções na MetaMask para conectar sua carteira.
L ) Antes de implantar o contrato inteligente na blockchain Polygon Mumbai, precisamos do ID da assinatura da assinatura VRF que criamos na etapa anterior. Volte para https://vrf.chain.link/mumbai e anote o ID da assinatura VRF que acabamos de criar. Seu ID será diferente daquele no exemplo. Você primeiro precisa informar o contrato sobre a assinatura. Em uma etapa futura, você informará a assinatura sobre o contrato.
M ) No Remix, insira o ID da assinatura na caixa de entrada ao lado do botão laranja “ Deploy”.
N ) Clique em “Deploy” e confirme a transação na MetaMask.
O ) Se você vir uma marca de seleção verde no console na parte inferior da tela, parabéns! Você implantou com sucesso o contrato na blockchain Polygon Mumbai!
Etapa 5: adicione um consumidor à sua assinatura VRF
Parabéns! Você implantou com sucesso seu contrato inteligente. Agora, é hora de adicionar o contrato inteligente como consumidor à assinatura VRF que você criou na etapa 3.
A ) No Remix, copie o endereço do seu contrato.
B ) Vá para https://vrf.chain.link/mumbai e conecte sua carteira clicando em “Connect Wallet” no canto superior direito. Se sua carteira já estiver conectada, você poderá pular esta etapa.
C ) Clique no ID da assinatura que você criou na etapa 3. Você pode encontrar sua assinatura em “My Subscriptions”.
D ) Clique em “ Add consumer” para adicionar um consumidor.
E ) Cole o endereço do contrato na caixa de entrada “Consumer address”. Isso informará a assinatura sobre o contrato que você implantou.
F ) Clique em “ Add consumer” e siga as instruções na MetaMask.
G ) Clique em “Fechar” depois que a transação for confirmada e atualize a página. Você concluiu esta etapa com êxito se vir um consumidor adicionado à sua assinatura, como na imagem abaixo.
Etapa 6: automatize seu NFT com Chainlink Automation
Nesta etapa, você criará uma manutenção baseada em tempo usando o Chainlink Automation para atualizar dinamicamente a cor de fundo e o emoji do seu NFT.
A ) Vá para https://automation.chain.link/mumbai e conecte sua carteira clicando em “Connect wallet” no canto superior direito. Se sua carteira já estiver conectada, você poderá pular esta etapa.
B ) Clique em “Register new Upkeep” para registrar uma nova manutenção.
C ) Selecione “Time-based” para selecionar um Upkeep baseado no tempo.
D ) Cole o endereço do contrato e clique em “Next” (consulte a etapa 5A se precisar de ajuda para encontrar o endereço do contrato).
E ) Você receberá um alerta com o seguinte texto: “Não foi possível buscar o ABI.” Em uma guia separada, volte para o Remix e selecione a guia “Solidity Compiler” na barra lateral esquerda.
F ) Verifique se o seu contrato está selecionado no menu suspenso “Contract” e clique no botão “Copiar ABI”.
G ) Volte ao seu registro de Upkeep e cole o ABI na caixa de entrada e clique em “Next” para prosseguir.
H ) Em “Target Function”, selecione “requestRandomWords ” e clique em “Next”.
I ) Em “Specify your time schedule” insira a seguinte expressão CRON para gerar uma nova cor de plano de fundo para o seu NFT a cada 2 minutos: */2 * * * * .
J ) Clique em “Next”.
K ) Dê à sua manutenção um nome (por exemplo. Demo dinâmico de NFT) e insira um saldo inicial de 2 LINK.
L ) Clique em “Registrar manutenção” e aprove a transação para implantar o contrato de trabalho CRON no MetaMask.
M ) Depois que a transação for aprovada, a MetaMask solicitará que você confirme uma segunda transação para “Request time-based upkeep registration” para solicitar o registro de manutenção (upkeep) com base no tempo.
N ) Aguarde a confirmação da transação e clique em “View Upkeep”.
O ) Você concluiu esta etapa com sucesso se vir “Active” sob o status de sua manutenção recém-criada. Parabéns!
Etapa 7: visualize seu NFT no OpenSea
A ) Vá para https://testnets.opensea.io/ e selecione “Profile” no menu suspenso no canto superior direito.
B ) Conecte sua carteira como mostrado abaixo. Pode ser necessário assinar uma transação do OpenSea.
C ) No seu perfil, clique no NFT rotulado como “ETH Watching SVG”.
D ) Clique nos três pontos no canto superior direito e selecione “Refresh metadata”.
E ) Aguarde 30 segundos e atualize a página e você verá o seu dNFT recém-criado!
Parabéns! Você concluiu o tutorial. A cada dois minutos, até que suas assinaturas fiquem sem fundos, seu NFT verificará o preço do ETH e solicitará uma nova cor de fundo. Na próxima vez que você atualizar os metadados, verá algo um pouco diferente.
Conclusão
Se você chegou até aqui, parabéns! Você implantou com sucesso um NFT de atualização dinâmica na rede de testes Polygon Mumbai que usa os feeds de preços da Chainlink para rastrear o preço do Ethereum, o Chainlink VRF para escolher uma cor de fundo aleatória, e Chainlink Automation para atualizar a imagem a cada dois minutos.
Continue aprendendo:
