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

ERC-721

Alchemy

Solidity

contratti intelligenti

Principiante

Sumi Mudgil

22 aprile 2021

9 minuti di lettura

Beeple (opens in a new tab): 69 milioni di dollari 3LAU (opens in a new tab): 11 milioni di dollari Grimes (opens in a new tab): 6 milioni di dollari

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

"Coniare un NFT" è l'atto di pubblicare un'istanza unica del tuo token ERC-721 sulla blockchain. Usando il nostro contratto intelligente dalla Parte 1 di questa serie di tutorial sugli NFT, mettiamo in mostra le nostre abilità con Web3 e coniamo un NFT. Alla fine di questo tutorial, sarai in grado di coniare tutti gli NFT che il tuo cuore (e il tuo portafoglio) desidera!

Iniziamo!

Passaggio 1: Installare Web3

Se hai seguito il primo tutorial sulla creazione del tuo contratto intelligente per NFT, hai già esperienza nell'uso di Ethers.js. Web3 è simile a Ethers, in quanto è una libreria usata per facilitare la creazione di richieste alla blockchain di Ethereum. In questo tutorial useremo Alchemy Web3 (opens in a new tab), che è una libreria Web3 migliorata che offre tentativi automatici e un solido supporto per WebSocket.

Nella directory principale del tuo progetto esegui:

1npm install @alch/alchemy-web3

Passaggio 2: Creare un file `mint-nft.js`

All'interno della tua directory degli 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)

Passaggio 3: Ottenere l'ABI del tuo contratto

L'ABI (Application Binary Interface) del nostro contratto è l'interfaccia per interagire con il nostro contratto intelligente. Puoi saperne di più sulle ABI dei contratti qui (opens in a new tab). Hardhat genera automaticamente un'ABI per noi e la salva nel file MyNFT.json. Per poterla usare dovremo analizzarne i contenuti aggiungendo le seguenti righe di codice al nostro file mint-nft.js:

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

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

1console.log(JSON.stringify(contract.abi))

Per eseguire mint-nft.js e vedere la tua ABI stampata nella console, naviga nel tuo terminale ed esegui:

1node scripts/mint-nft.js

Passaggio 4: Configurare i metadati per il tuo NFT usando IPFS

Se ricordi dal nostro tutorial nella Parte 1, la nostra funzione del contratto intelligente mintNFT accetta un parametro tokenURI che dovrebbe risolversi in un documento JSON che descrive i metadati dell'NFT, che è in realtà ciò che dà vita all'NFT, permettendogli di avere proprietà configurabili, come un nome, una descrizione, un'immagine e altri attributi.

L'Interplanetary File System (IPFS) è un protocollo decentralizzato e una rete peer-to-peer per l'archiviazione e la condivisione di dati in un file system distribuito.

Useremo Pinata, una comoda API e toolkit IPFS, per archiviare la risorsa e i metadati del nostro NFT per assicurarci che il nostro NFT sia veramente decentralizzato. Se non hai un account Pinata, registrati per un account gratuito qui (opens in a new tab) e completa i passaggi per verificare la tua email.

Una volta creato un account:

Naviga alla pagina "Files" e clicca sul pulsante blu "Upload" in alto a sinistra della pagina.
Carica un'immagine su Pinata: questa sarà la risorsa immagine per il tuo NFT. Sentiti libero di nominare la risorsa come preferisci
Dopo il caricamento, vedrai le informazioni del file nella tabella sulla pagina "Files". Vedrai anche una colonna CID. Puoi copiare il CID cliccando sul pulsante di copia accanto ad esso. Puoi visualizzare il tuo caricamento su: https://gateway.pinata.cloud/ipfs/<CID>. Puoi trovare l'immagine che abbiamo usato su IPFS qui (opens in a new tab), per esempio.

Per chi apprende in modo più visivo, i passaggi precedenti sono riassunti qui:

Ora, vorremo caricare un altro documento su Pinata. Ma prima di farlo, dobbiamo crearlo!

Nella tua directory principale, crea un nuovo file chiamato nft-metadata.json e aggiungi il seguente codice json:

1{
2  "attributes": [
3    {
4      "trait_type": "Breed",
5      "value": "Maltipoo"
6    },
7    {
8      "trait_type": "Eye color",
9      "value": "Mocha"
10    }
11  ],
12  "description": "The world's most adorable and sensitive pup.",
13  "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
14  "name": "Ramses"
15}

Sentiti libero di cambiare i dati nel json. Puoi rimuovere o aggiungere alla sezione degli attributi. La cosa più importante è assicurarsi che il campo dell'immagine punti alla posizione della tua immagine IPFS, altrimenti il tuo NFT includerà una foto di un cane (molto carino!).

Una volta terminata la modifica del file JSON, salvalo e caricalo su Pinata, seguendo gli stessi passaggi che abbiamo fatto per caricare l'immagine.

Passaggio 5: Creare un'istanza del tuo contratto

Ora, per interagire con il nostro contratto, dobbiamo crearne un'istanza nel nostro codice. Per farlo avremo bisogno del nostro indirizzo del contratto che possiamo ottenere dalla distribuzione o da Blockscout (opens in a new tab) cercando l'indirizzo che hai usato per distribuire il contratto.

Nell'esempio sopra, il nostro indirizzo del contratto è 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778.

Successivamente useremo il metodo contract (opens in a new tab) di Web3 per creare il nostro contratto usando l'ABI e l'indirizzo. Nel tuo file mint-nft.js, aggiungi quanto segue:

1const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
2
3const nftContract = new web3.eth.Contract(contract.abi, contractAddress)

Passaggio 6: Aggiornare il file `.env`

Ora, per creare e inviare transazioni alla catena di Ethereum, useremo l'indirizzo pubblico del tuo account Ethereum per ottenere il nonce dell'account (lo spiegheremo di seguito).

Aggiungi la tua chiave pubblica al tuo file .env: se hai completato la parte 1 del tutorial, il nostro file .env dovrebbe ora apparire così:

1API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
2PRIVATE_KEY = "your-private-account-address"
3PUBLIC_KEY = "your-public-account-address"

Passaggio 7: Creare la tua transazione

Per prima cosa, definiamo una funzione chiamata mintNFT(tokenData) e creiamo la nostra transazione facendo quanto segue:

Prendi la tua PRIVATE_KEY e PUBLIC_KEY dal file .env.
Successivamente, dovremo capire il nonce dell'account. La specifica del nonce è usata per tenere traccia del numero di transazioni inviate dal tuo indirizzo, di cui abbiamo bisogno per motivi di sicurezza e per prevenire attacchi di replay (opens in a new tab). Per ottenere il numero di transazioni inviate dal tuo indirizzo, usiamo getTransactionCount (opens in a new tab).
Infine imposteremo 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 desideriamo interagire e a cui inviare la transazione
'nonce': nonce — Il nonce dell'account con il numero di transazioni inviate dal nostro indirizzo
'gas': estimatedGas — Il gas stimato necessario per completare la transazione
'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI() — Il calcolo che desideriamo eseguire in questa transazione, che in questo caso è coniare un NFT

Il tuo file mint-nft.js dovrebbe apparire così 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 = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
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'); // ottieni l'ultimo nonce
15
16   // la transazione
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   }

Passaggio 8: Firmare la transazione

Ora che abbiamo creato la nostra transazione, dobbiamo firmarla per poterla inviare. È qui che useremo la nostra chiave privata.

web3.eth.sendSignedTransaction ci darà l'hash della transazione, che possiamo usare per assicurarci che la nostra transazione sia stata minata e non sia stata scartata dalla rete. Noterai che nella sezione della firma della transazione, abbiamo aggiunto un controllo degli errori in modo da sapere se la nostra transazione è andata a buon fine.

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 = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // ottieni l'ultimo nonce
15
16  // la transazione
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}

Passaggio 9: Chiamare `mintNFT` ed eseguire node `mint-nft.js`

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

Ecco come ottenere il codice hash:

Come ottenere il codice hash dei metadati del tuo nft su Pinata

Controlla due volte che il codice hash 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 apparire simile allo screenshot qui sotto:

La tua pagina dovrebbe visualizzare i metadati json

Nel complesso, il tuo codice dovrebbe apparire più o meno così:

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 = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
11const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
12
13async function mintNFT(tokenURI) {
14  const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") // ottieni l'ultimo nonce
15
16  // la transazione
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
51mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")

Ora, esegui node scripts/mint-nft.js per distribuire il tuo NFT. Dopo un paio di secondi, dovresti vedere una risposta come questa nel tuo terminale:

The hash of your transaction is: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8

Check Alchemy's Mempool to view the status of your transaction!

Successivamente, visita la tua mempool di Alchemy (opens in a new tab) per vedere lo stato della tua transazione (se è in sospeso, minata o è stata scartata dalla rete). Se la tua transazione è stata scartata, è anche utile controllare Blockscout (opens in a new tab) e cercare l'hash della tua transazione.

Visualizza l'hash della transazione del tuo NFT su Etherscan

E questo è tutto! Ora hai distribuito E coniato un NFT sulla blockchain di Ethereum

Usando mint-nft.js puoi coniare tutti gli NFT che il tuo cuore (e il tuo portafoglio) desidera! Assicurati solo di passare un nuovo tokenURI che descrive i metadati dell'NFT (altrimenti, finirai solo per crearne un mucchio identici con ID diversi).

Presumibilmente, ti piacerebbe poter mostrare il tuo NFT nel tuo portafoglio, quindi assicurati di dare un'occhiata alla Parte 3: Come visualizzare il tuo NFT nel tuo portafoglio!

Ultimo aggiornamento della pagina: 3 marzo 2026

+21