Vai al contenuto principale

Aiuta ad aggiornare questa pagina

🌏

C'è una nuova versione di questa pagina, ma al momento è solo in inglese. Aiutaci a tradurre l'ultima versione.

Traduci la pagina
Visualizza in inglese

Nessun bug qui!🐛

Questa pagina non è stata tradotta. Per il momento, è stata intenzionalmente lasciata in inglese.

Come coniare un NFT (Parte 2/3 della Serie di tutorial sugli NFT)

NFT
ERC-721
Alchemy
Solidity
smart contract
Principiante
✍Sumi Mudgil
📆22 aprile 2021
⏱️9 minuti letti

Beeple: $69 milioni 3LAU: $11 milioni Grimes: $6 milioni

Tutti hanno coniato i propri NFT usando la potente API di Alchemy. In questo tutorial ti insegneremo come fare lo stesso in meno di 10 minuti.

"Coniare un NFT" è l'atto di pubblicare un'istanza unica del tuo token ERC-721 sulla blockchain. Usando il nostro smart contract della Parte 1 di questa serie di tutorial sugli NFT, sfruttiamo le nostre abilità di web3 e coniamo un NFT. Alla fine di questo tutorial, potrai coniare tutti gli NFT che desideri (e che può permettersi il tuo portafoglio)!

Iniziamo!

Fase 1: installa Web3

Se hai seguito il primo tutorial sulla creazione del tuo smart contract di NFT, hai già esperienza nell'uso di Ethers.js. Web3 è simile a Ethers, trattandosi di una libreria usata per effettuare più facilmente richieste di creazione alla Blockchain di Ethereum. In questo tutorial, useremo Alchemy Web3, una libreria web3 migliorata che offre tentativi automatici e robusto supporto a WebSocket.

Nella cartella home del tuo progetto, esegui:

1npm install @alch/alchemy-web3
2

Fase 2: crea un file mint-nft.js

Nella tua cartella di script, crea un file mint-nft.js e aggiungi le seguenti righe di codice:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
4const web3 = createAlchemyWeb3(API_URL)
5
📋 Copia

Fase 3: prendi l'ABI del tuo contratto

L'ABI (Application Binary Interface) del nostro contratto è l'interfaccia per interagire con il nostro smart contract. Puoi saperne di più sull'ABI dei contratti leggi qui. Hardhat genera automaticamente un'ABI e la salva nel file MyNFT.json. Per poterla usare, dovremo analizzare i contenuti aggiungendo le seguenti righe di codice al nostro file mint-nft.js:

1const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
2
📋 Copia

Se vuoi vedere l'ABI, puoi stamparla nella tua console:

1console.log(JSON.stringify(contract.abi))
2
📋 Copia

Per eseguire mint-nft.js e vedere l'ABI stampata alla console, vai alla console ed esegui

1node scripts/mint-nft.js
2
📋 Copia

Fase 4: configura i metadati del tuo NFT usando IPFS

Se ricordi dal nostro tutorial nella Parte 1, la funzione del nostro smart contract mintNFT riceve un parametro tokenURI, che dovrebbe risolversi in un documento JSON che descrive i metadati dell'NFT, ed è questo che porta realmente in vita l'NFT, consentendogli di avere proprietà configurabili, quali nome, descrizione, immagine e altri attributi.

Il Planetary File System (IPFS) è un protocollo decentralizzato e una rete peer-to-peer per memorizzare e condividere i dati in un file di sistema distribuito.

Useremo Pinata, una comoda API di IPFS e strumento per memorizzare la nostra risorsa NFT e i metadati, per essere sicuri che il nostro NFT sia realmente decentralizzato. Se non hai un profilo di Pinata, registrane uno gratuito qui e completa i passaggi per verificare la tua email.

Una volta creato un profilo:

  • Vai alla pagina "File" e clicca il pulsante "Carica" blu in alto a sinistra alla pagina.

  • Carica un'immagine su Pinata, sarà la risorsa immagine del tuo NFT. Assegna alla risorsa il nome desideri

  • Dopo il caricamento, vedrai le informazioni del file nella tabella sulla pagina dei File. Vedrai anche una colonna CID. Puoi copiare il CID cliccando il pulsante di copia accanto. Puoi visualizzare il tuo caricamento su: https://gateway.pinata.cloud/ipfs/<CID>. Puoi trovare l'immagine che abbiamo usato su IPFS qui, ad esempio.

Per chi preferisce un apprendimento "visivo", i passaggi sopra sono riassunti qui:

Come caricare l'immagine su Pinata

Vogliamo caricare ora un altro documento su Pinata. Ma prima, dobbiamo crearlo!

Nella tua cartella di root, crea un nuovo file chiamato nft-metadata.json e aggiungi il seguente codice json:

1{
2 "attributes": [
3 {
4 "trait_type": "Razza",
5 "value": "Maltipoo"
6 },
7 {
8 "trait_type": "Colore occhio",
9 "value": "Mocha"
10 }
11 ],
12 "description": "Il cucciolo più adorabile e sensibile al mondo.",
13 "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14 "name": "Ramses"
15}
16
Mostra tutto
📋 Copia

Puoi modificare liberamente i dati nel json. Puoi rimuoverli o aggiungerli alla sezione degli attributi. Soprattutto, assicurati che il campo immagine punti alla posizione della tua immagine IPFS; altrimenti, il tuo NFT includerà la foto di un cane (molto carino!).

Una volta finito di modificare il file json, salvalo e caricalo su Pinata, seguendo gli stessi passaggi di caricamento dell'immagine.

Come caricare il tuo nft-metadata.json su Pinata

Fase 5: crea un'istanza del tuo contratto

Ora, per interagire con il nostro contratto, dobbiamo crearne un'istanza nel nostro codice. Per farlo, avremo bisogno dell'indirizzo del nostro contratto, che possiamo ottenere dalla distribuzione o da Etherscan, cercando l'indirizzo usato per distribuire il contratto.

Visualizza l'indirizzo del tuo contratto su Etherscan

Nell'esempio precedente, l'indirizzo del nostro contratto è 0x81c587EB0fE773404c42c1d2666b5f557C470eED.

Poi useremo il metodo di contratto di web3 per creare il nostro contratto usando l'ABI e l'indirizzo. Nel tuo file mint-nft.js, aggiungi quanto segue:

1const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
2
3const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
4
📋 Copia

Fase 6: aggiorna il file .env

Ora, per poter creare e inviare le transazioni alla catena di Ethereum, useremo l'indirizzo pubblico del tuo profilo di Ethereum per ottenere il nonce del profilo (spiegheremo in seguito).

Aggiungi la tua chiave pubblica al tuo file .env; se hai completato la parte 1 del tutorial, il nostro file .env dovrebbe somigliare a questo:

1API_URL = "https://eth-ropsten.alchemyapi.io/v2/your-api-key"
2PRIVATE_KEY = "your-private-account-address"
3PUBLIC_KEY = "your-public-account-address"
4
📋 Copia

Fase 7: crea la tua transazione

Prima di tutto, definiamo una funzione denominata mintNFT(tokenData) e creiamo la nostra transazione facendo quanto segue:

  1. Prendi la tua PRIVATE_KEY e PUBLIC_KEY dal file .env.

  2. Poi, dobbiamo trovare il nonce del profilo. La specifica di nonce è usata per tracciare il numero di transazioni inviate dal tuo indirizzo, di cui abbiamo bisogno per scopi di sicurezza e per prevenire gli attacchi replay. Per ottenere il numero di transazioni inviate dal tuo indirizzo, usiamo getTransactionCount.

  3. Infine, configureremo la nostra transazione con le seguenti informazioni:

  • 'from': PUBLIC_KEY — L'origine della nostra transazione è il nostro indirizzo pubblico

  • 'to': contractAddress — Il contratto con cui vogliamo interagire e a cui vogliamo inviare la transazione

  • 'nonce': nonce — Nonce dell'account con il numero di transazioni inviate dal nostro indirizzo

  • 'gas': estimatedGas — Il carburante stimato necessario per completare la transazione

  • 'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() — Il calcolo che vogliamo eseguire in questa transazione, che in questo caso è il conio di un NFT

Il tuo file mint-nft.js dovrebbe somigliare a questo ora:

1 require('dotenv').config();
2 const API_URL = process.env.API_URL;
3 const PUBLIC_KEY = process.env.PUBLIC_KEY;
4 const PRIVATE_KEY = process.env.PRIVATE_KEY;
5
6 const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
7 const web3 = createAlchemyWeb3(API_URL);
8
9 const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
10 const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED";
11 const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
12
13 async function mintNFT(tokenURI) {
14 const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //get latest nonce
15
16 //the transaction
17 const tx = {
18 'from': PUBLIC_KEY,
19 'to': contractAddress,
20 'nonce': nonce,
21 'gas': 500000,
22 'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
23 };
24 }
25
Mostra tutto
📋 Copia

Fase 8: firma la transazione

Ora che abbiamo creato la nostra transazione, dobbiamo firmarla per inviarla. Ecco dove useremo la nostra chiave privata.

web3.eth. endSignedTransaction ci darà l'hash della transazione, che possiamo usare per assicurarci che la nostra transazione sia stata minata e non sia stata eliminata dalla rete. Noterai nella sezione di firma della transazione che abbiamo aggiunto dei controlli degli errori, per poter sapere se la nostra transazione è passata correttamente.

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14 const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
15
16 //the transaction
17 const tx = {
18 from: PUBLIC_KEY,
19 to: contractAddress,
20 nonce: nonce,
21 gas: 500000,
22 data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23 }
24
25 const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26 signPromise
27 .then((signedTx) => {
28 web3.eth.sendSignedTransaction(
29 signedTx.rawTransaction,
30 function (err, hash) {
31 if (!err) {
32 console.log(
33 "The hash of your transaction is: ",
34 hash,
35 "\nCheck Alchemy's Mempool to view the status of your transaction!"
36 )
37 } else {
38 console.log(
39 "Something went wrong when submitting your transaction:",
40 err
41 )
42 }
43 }
44 )
45 })
46 .catch((err) => {
47 console.log(" Promise failed:", err)
48 })
49}
50
Mostra tutto
📋 Copia

Fase 9: chiamare mintNFT ed eseguire il nodo mint-nft.js

Ricordi il metadata.json che hai caricato su Pinata? Ottieni il suo hashcode da Pinata e passa il seguente come un parametro alla funzione mintNFT https://gateway.pinata.cloud/ipfs/<metadata-hash-code>

Ecco come ottenere l'hashcode:

Come ottenere l'hashcode dei metadati del tuo NFT su PinataCome ottenere l'hashcode dei metadati del tuo NFT su Pinata

Ricontrolla che l'hashcode che hai copiato si colleghi al tuo metadata.json, caricando https://gateway.pinata.cloud/ipfs/<metadata-hash-code> in una finestra separata. La pagina dovrebbe somigliare al seguente screenshot:

La tua pagina dovrebbe visualizzare i metadati in json La tua pagina deve mostrare i metadati in json

Nel complesso, il tuo codice dovrebbe somigliare a questo:

1require("dotenv").config()
2const API_URL = process.env.API_URL
3const PUBLIC_KEY = process.env.PUBLIC_KEY
4const PRIVATE_KEY = process.env.PRIVATE_KEY
5
6const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
7const web3 = createAlchemyWeb3(API_URL)
8
9const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
10const contractAddress = "0x81c587EB0fE773404c42c1d2666b5f557C470eED"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14 const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //get latest nonce
15
16 //the transaction
17 const tx = {
18 from: PUBLIC_KEY,
19 to: contractAddress,
20 nonce: nonce,
21 gas: 500000,
22 data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
23 }
24
25 const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
26 signPromise
27 .then((signedTx) => {
28 web3.eth.sendSignedTransaction(
29 signedTx.rawTransaction,
30 function (err, hash) {
31 if (!err) {
32 console.log(
33 "The hash of your transaction is: ",
34 hash,
35 "\nCheck Alchemy's Mempool to view the status of your transaction!"
36 )
37 } else {
38 console.log(
39 "Qualcosa è andato storto inviando la tua transazione:",
40 err
41 )
42 }
43 }
44 )
45 })
46 .catch((err) => {
47 console.log("Promessa fallita:", err)
48 })
49}
50
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
52
Mostra tutto
📋 Copia

Ora, esegui scripts/mint-nft.js per distribuire il tuo NFT. Dopo qualche secondo, dovresti vedere una risposta come questa nel tuo terminale:

1The hash of your transaction is: 0x10e5062309de0cd0be7edc92e8dbab191aa2791111c44274483fa766039e0e00
2
3Check Alchemy's Mempool to view the status of your transaction!
4

Vai quindi alla tua mempool di Alchemy per vedere lo stato della transazione (se è sospesa, minata o eliminata dalla rete). Se la tua transazione è stata eliminata, è utile controllare anche Ropsten Etherscan e cercare l'hash della transazione.

Visualizza l'hash della tua transazione NFT su Etherscan Visualizza l'hash della tua transazione NFT su Etherscan

Ecco fatto! Hai ora distribuito E coniato con un NFT sulla Blockchain di Ethereum 🤑

Usando mint-nft.js puoi coniare tutti gli NFT che desideri (e che può permettersi il tuo portafoglio)! Basta che ti accerti di passare un nuovo tokenURI che descriva i metadati dell'NFT (altrimenti, finirai per crearne tanti identici con ID differenti).

Molto probabilmente vorrai visualizzare il tuo NFT nel tuo portafoglio, quindi assicurati di leggere la Parte 3: come visualizzare il tuo NFT nel portafoglio!

Ultima modifica: , Invalid DateTime
Modifica la pagina

Questa pagina è stata utile?