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 Scrivere e Distribuire un NFT (Parte 1/3 della Serie di tutorial sugli NFT)

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

Ora che gli NFT rendono nota la blockchain al grande pubblico, si presenta un'eccellente opportunità per comprendere tu stesso questo interesse, pubblicando il tuo NFT (Token ERC-721) sulla blockchain di Ethereum!

Alchemy è estremamente orgogliosa di supportare i più grandi nomi nello spazio degli NFT, tra cui Makersplace (ha recentemente toccato un record nella vendita di opere d'arte digitali a Christie, per $69 milioni), Dapper Labs (creatori di NBA Top Shot e Crypto Kitties), OpenSea (il più grande mercato di NFT al mondo), Zora, Super Rare, NFTfi, Foundation, Enjin, Origin Protocol, Immutable e altri.

In questo tutorial, ti guideremo verso la creazione e distribuzione di uno smart contract ERC-721 sulla rete di prova di Ropsten usando MetaMask, Solidity, Hardhat, Pinata e Alchemy (non preoccuparti se ancora non capisci che significa; te lo spiegheremo!).

Nella Parte 2 di questo tutorial affronteremo come possiamo usare il nostro smart contract per coniare un NFT e nella Parte 3 spiegheremo come visualizzare il tuo NFT su MetaMask.

E, ovviamente, se in qualsiasi momento hai domande, non esitare a contattarci nel Discord di Alchemy o consulta la documentazione sulle NFT API di Alchemy!!

Fase 1: connettersi alla rete di Ethereum

Ci sono molti modi per effettuare richieste alla Blockchain di Ethereum, ma per rendere le cose facili, useremo un profilo gratuito su Alchemy, una piattaforma per sviluppatori della blockchain e API che ci consente di comunicare con la chain di Ethereum senza dover eseguire dei nodi nostri.

In questo tutorial, approfitteremo anche degli strumenti per monitoraggio e analisi per sviluppatori messi a disposizione da Alchemy per comprendere cosa succede dietro le quinte quando distribuiamo il nostro smart contract. Se non hai già un profilo di Alchemy, puoi iscriverti gratuitamente qui.

Fase 2: crea la tua app (e chiave API)

Una volta creato un profilo di Alchemy, puoi generare una chiave API creando un'app. Questo ci consentirà di effettuare richieste alla rete di prova di Ropsten. Dai un'occhiata a questa guida se vuoi maggiori informazioni sulle reti di prova.

  1. Vai alla pagina “Crea App” nella tua dashboard di Alchemy passando su “App” nella barra di navigazione e cliccando “Crea App”

Crea la tua app

  1. Dai un nome alla tua app (noi abbiamo scelto “Il mio primo NFT!"), aggiungi una breve descrizione, seleziona “Staging” come Ambiente (serve per la contabilità della tua app) e scegli "Ropsten" come rete.

Configura e pubblica la tua app

  1. Clicca “Create app” ed è tutto! La tua app dovrebbe apparire nella tabella seguente.

Fase 3: crea un profilo di Ethereum (indirizzo)

Per inviare e ricevere transazioni serve un profilo Ethereum. Per questo tutorial, useremo MetaMask, un portafoglio virtuale nel browser per gestire l'indirizzo del tuo profilo Ethereum. Se vuoi capire di più su come funzionano le transazioni su Ethereum, dai un'occhiata a questa pagina della Ethereum Foundation.

Puoi scaricare e creare gratuitamente un account MetaMask qui. Quando crei un profilo, o se ne hai già uno, assicurati di passare alla "Rete di Prova Ropsten" in alto a destra (per non avere a che fare con soldi reali).

Imposta Ropsten come rete

Fase 4: aggiungi ether da un Faucet

Per poter distribuire il nostro smart contract alla rete di prova, avremo bisogno di di ETH finti. Per ottenere ETH, puoi andare all'indirizzo FaucETH e inserire l'indirizzo del tuo account Ropsten, cliccare su "Richiedi fondi", poi selezionare "Ethereum Testnet Ropsten" nel menu a tendina e, infine, cliccare nuovamente il pulsante "Richiedi fondi". Subito dopo dovresti vedere gli ETH nel tuo account MetaMask!

Fase 5: controlla il saldo

Per ricontrollare che ci sia il saldo, facciamo una richiesta eth_getBalance usando lo strumento compositore di Alchemy. Questo restituirà l'importo di ETH nel nostro portafoglio. Dopo aver inserito l'indirizzo del tuo account di MetaMask e aver cliccato “Invia richiesta”, dovresti vedere una risposta come questa:

1`{"jsonrpc": "2.0", "id": 0, "result": "0xde0b6b3a7640000"}`
2

NOTA: Questo risultato è in wei non in ETH. Wei è usato come taglio più piccolo dell'ether. La conversione da wei a ETH è: 1 eth = 1018 wei. Quindi se convertiamo 0xde0b6b3a7640000 in decimali, otteniamo 1*1018 wei, pari a 1 ETH.

Menomale! I nostri soldi finti ci sono tutti.

Fase 6: inizializza il progetto

Prima, dovremo creare una cartella per il nostro progetto. Vai alla riga di comando e digita:

1mkdir my-nft
2cd my-nft
3

Ora che siamo nella cartella del nostro progetto, useremo npm init per inizializzare il progetto. Se non hai già installato npm, segui queste istruzioni (avremo bisogno anche di Node.js, quindi scarica anche questo!).

1npm init
2

Non è rilevante come rispondi alle domande d'installazione; ecco le nostre risposte come esempio:

1package name: (my-nft)
2version: (1.0.0)
3description: My first NFT!
4entry point: (index.js)
5test command:
6git repository:
7keywords:
8author:
9license: (ISC)
10About to write to /Users/thesuperb1/Desktop/my-nft/package.json:
11
12{
13 "name": "my-nft",
14 "version": "1.0.0",
15 "description": "My first NFT!",
16 "main": "index.js",
17 "scripts": {
18 "test": "echo \"Error: no test specified\" && exit 1"
19 },
20 "author": "",
21 "license": "ISC"
22}
23
Mostra tutto

Approva il package.json, e siamo pronti!

Fase 7: installa Hardhat

Hardhat è un ambiente di sviluppo per compilare, distribuire, testare ed effettuare il debug del tuo software di Ethereum. Aiuta gli sviluppatori nella creazione di smart contract e di dApps localmente, prima di distribuirli alla catena dal vivo.

Nel nostro progetto my-nft esegui:

1npm install --save-dev hardhat
2

Dai un'occhiata a questa pagina per ulteriori dettagli sulle istruzioni d'installazione.

Fase 8: crea un progetto Hardhat

Nella cartella del nostro progetto esegui:

1npx hardhat
2

Dovresti poi vedere un messaggio di benvenuto e l'opzione per selezionare cosa desideri fare. Seleziona “crea un hardhat.config.js vuoto”:

1888 888 888 888 888
2888 888 888 888 888
3888 888 888 888 888
48888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
5888 888 "88b 888P" d88" 888 888 "88b "88b 888
6888 888 .d888888 888 888 888 888 888 .d888888 888
7888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
8888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
9👷 Welcome to Hardhat v2.0.11 👷‍
10? Cosa vuoi fare? …
11Create a sample project
12❯ Create an empty hardhat.config.js
13Quit
14
Mostra tutto

Questo genererà un file hardhat.config.js, in cui specificheremo tutta la configurazione per il nostro progetto (alla fase 13).

Fase 9: aggiungi le cartelle del progetto

Per mantenere organizzato il nostro progetto, creeremo due nuove cartelle. Vai alla cartella di root del tuo progetto nella tua riga di comando e digita:

1mkdir contracts
2mkdir scripts
3
  • contracts/ è dove manterremo il codice dello smart contract del nostro NFT

  • scripts/ è dove manterremo gli script per distribuire e interagire con il nostro smart contract

Fase 10: compila il nostro contratto

Ora che il nostro ambiente è configurato, passiamo alle cose più entusiasmanti: scrivere il codice del nostro smart contract!

Apri il progetto my-nft nel tuo editor preferito (a noi piace VSCode). Gli smart contract sono scritti in un linguaggio detto Solidity, che useremo per scrivere il nostro smart contract MyNFT.sol.

  1. Vai alla cartella contracts e crea un nuovo file chiamato MyNFT.sol

  2. Segue il codice dello smart contract del nostro NFT, che abbiamo basato sull'implementazione ERC-721 della libreria di OpenZeppelin. Copia e incolla i seguenti contenuti nel tuo file MyNFT.sol.

    1//Contratto basato su [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721)
    2// SPDX-License-Identifier: MIT
    3pragma solidity ^0.8.0;
    4
    5import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    6import "@openzeppelin/contracts/utils/Counters.sol";
    7import "@openzeppelin/contracts/access/Ownable.sol";
    8import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
    9
    10contract MyNFT is ERC721URIStorage, Ownable {
    11 using Counters for Counters.Counter;
    12 Counters.Counter private _tokenIds;
    13
    14 constructor() ERC721("MyNFT", "NFT") {}
    15
    16 function mintNFT(address recipient, string memory tokenURI)
    17 public onlyOwner
    18 returns (uint256)
    19 {
    20 _tokenIds.increment();
    21
    22 uint256 newItemId = _tokenIds.current();
    23 _mint(recipient, newItemId);
    24 _setTokenURI(newItemId, tokenURI);
    25
    26 return newItemId;
    27 }
    28}
    29
    Mostra tutto
    📋 Copia
  3. Poiché stiamo ereditando classi dalla libreria di contratti di OpenZeppelin, nella riga di comando esegui npm install @openzeppelin/contracts per installare la libreria nella nostra cartella.

Quindi, cosa fa esattamente questo codice? Analizziamolo, riga dopo riga.

In cima al nostro smart contract, importiamo tre classi dello smart contract di OpenZeppelin:

  • @openzeppelin/contracts/token/ERC721/ERC721.sol contiene l'implementazione dello standard ERC-721, che lo smart contract del nostro NFT erediterà. (Per essere un NFT valido, il tuo smart contract deve implementare tutti i metodi dello standard ERC-721.) Per saperne di più sulle funzioni ERC-721 ereditate, dai un'occhiata alla definizione dell'interfaccia qui.

  • @openzeppelin/contracts/utils/Counters.sol fornisce contatori che possono esser solo incrementati o diminuiti di unità alla volta. Il nostro smart contract usa un contatore per tener traccia del numero totale di NFT coniati e impostare l'ID univoco sul nostro nuovo NFT. (A ogni NFT coniato usando uno smart contract, deve essere assegnato un ID univoco, qui il nostro ID univoco è determinato solo dal numero totale di NFT esistenti. Ad esempio, il primo NFT che coniamo con il nostro smart contract ha ID "1," il nostro secondo NFT ha ID "2," ecc.)

  • @openzeppelin/contracts/access/Ownable.sol imposta il controllo d'accesso sul nostro smart contract, così solo il proprietario dello smart contract (tu) può coniare NFT. (Nota, prevedere il controllo dell'accesso è totalmente facoltativo. Se vuoi che tutti possano coniare un NFT usando il tuo smart contract, devi rimuovere la parola Ownable alla riga 10 e onlyOwner alla riga 17.)

Dopo le nostre dichiarazioni d'importazione, abbiamo il nostro smart contract NFT personalizzato, che è sorprendentemente breve: contiene solo un contatore, un costruttore e una sola funzione! Questo grazie ai nostri contratti ereditati da OpenZeppelin, che implementa gran parte dei metodi che necessitiamo per creare un NFT, come ownerOf, che restituisce il proprietario dell'NFT e transferFrom, che trasferisce la proprietà dell'NFT da un account a un altro.

Nel nostro costruttore ERC-721, noterai che passiamo 2 stringhe, “MyNFT” e “NFT.” La prima variabile è il nome dello smart contract mentre la seconda è il suo simbolo. Puoi assegnare a ciascuna di queste variabili il nome che desideri!

Infine, abbiamo la nostra funzione mintNFT(address recipient, string tokenURI) che ci consente di coniare un NFT! Noterai che questa funzione usa due variabili:

  • address recipient specifica l'indirizzo che riceverà il tuo NFT appena coniato

  • string memory tokenURI è una stringa che dovrebbe risolversi in un documento JSON che descrive i metadati dell'NFT. I metadati di un NFT sono davvero ciò che lo porta in vita, consentendogli di avere proprietà configurabili, quali nome, descrizione, immagine e altri attributi. Nella parte 2 di questo tutorial, descriveremo come configurare questi metadati.

mintNFT chiama alcuni metodi dalla libreria ERC-721 ereditata e, infine, restituisce un numero che rappresenta l'ID dell'NFT appena coniato.

Fase 11: connetti MetaMask e Alchemy al tuo progetto

Ora che abbiamo creato un portafoglio MetaMask, un profilo di Alchemy e scritto il nostro smart contract, è il momento di collegare questi tre elementi.

Ogni transazione inviata dal tuo portafoglio virtuale richiede una firma tramite la tua chiave privata unica. Per fornire al nostro programma quest'autorizzazione, possiamo memorizzare in sicurezza la nostra chiave privata (e la chiave API di Alchemy) in un file ambientale.

Per saperne di più sull'invio delle transazioni, dai un'occhiata a questo tutorial sull'invio di transazioni usando web3.

Prima, installa il pacchetto dotenv nella cartella del tuo progetto:

1npm install dotenv --save
2

Poi, crea un file .env nella cartella di root del nostro progetto e aggiungi la tua chiave privata di MetaMask e l'URL API di Alchemy HTTP.

  • Segui queste istruzioni per esportare la tua chiave privata da MetaMask

  • Vedi di seguito come ottenere l'URL dell'API di Alchemy HTTP e copialo negli appunti

Copia l'URL dell'API di Alchemy

Il tuo .env dovrebbe somigliare a questo:

1API_URL="https://eth-ropsten.alchemyapi.io/v2/your-api-key"
2PRIVATE_KEY="your-metamask-private-key"
3

Per connetterli realmente al nostro codice, faremo riferimento a queste variabili nel nostro file hardhat.config.js nella fase 13.

Non eseguire il commit di .env! Assicurati di non condividere o esporre mai il tuo file .env con nessuno, poiché così facendo comprometteresti i tuoi segreti. Se stai usando il controllo di versione, aggiungi il tuo .env a un file gitignore.

Fase 12: installa Ethers.js

Ethers.js è una libreria che rende più facile interagire ed effettuare richieste a Ethereum tramite wrapping dei metodi JSON-RPC standard con altri metodi più facili da usare.

Hardhat rende davvero facile integrare Plugin per strumenti e funzionalità aggiuntive. Sfrutteremo il plugin di Ethers per la distribuzione del contratto (Ethers.js ha dei metodi di distribuzione del contratto molto puliti).

Nella cartella del tuo progetto digita:

1npm install --save-dev @nomiclabs/hardhat-ethers ethers@^5.0.0
2

Avremo bisogno di ethers anche nel nostro hardhat.config.js nella prossima fase.

Fase 13: aggiorna hardhat.config.js

Finora abbiamo aggiunto diverse dipendenze e plugin, ora dobbiamo aggiornare hardhat.config.js in modo che il nostro progetto li riconosca tutti.

Aggiorna il tuo hardhat.config.js affinché somigli a questo:

1/**
2* @type import('hardhat/config').HardhatUserConfig
3*/
4require('dotenv').config();
5require("@nomiclabs/hardhat-ethers");
6const { API_URL, PRIVATE_KEY } = process.env;
7module.exports = {
8 solidity: "0.8.1",
9 defaultNetwork: "ropsten",
10 networks: {
11 hardhat: {},
12 ropsten: {
13 url: API_URL,
14 accounts: [`0x${PRIVATE_KEY}`]
15 }
16 },
17}
18
Mostra tutto

Fase 14: compila il contratto

Per assicurarti che tutto funzioni fino a questo punto, compila il contratto. L'attività di compilazione è una delle attività integrate di hardhat.

Dalla riga di comando esegui:

1npx hardhat compile
2

Potresti ottenere un avviso sull'assenza nel file sorgente dell'identificativo della licenza SPDX, ma non preoccupartene, si spera che tutto il resto funzioni! Altrimenti, puoi sempre inviare un messaggio nel Discord di Alchemy.

Fase 15: scrivi lo script di distribuzione

Ora che il nostro contratto è scritto e il nostro file di configurazione è pronto, è il momento di scrivere lo script di distribuzione del contratto.

Vai alla cartella script/ e crea un nuovo file chiamato deploy.js, aggiungendo i seguenti contenuti:

1async function main() {
2 const MyNFT = await ethers.getContractFactory("MyNFT")
3
4 // Start deployment, returning a promise that resolves to a contract object
5 const myNFT = await MyNFT.deploy()
6 await myNFT.deployed()
7 console.log("Contract deployed to address:", myNFT.address)
8}
9
10main()
11 .then(() => process.exit(0))
12 .catch((error) => {
13 console.error(error)
14 process.exit(1)
15 })
16
Mostra tutto
📋 Copia

Nel suo tutorial sui Contratti hardhat spiega in modo eccellente cosa fa ognuna di queste righe di codice nel loro, quindi riportiamo qui le loro spiegazioni.

1const MyNFT = await ethers.getContractFactory("MyNFT");
2

Un ContractFactory su ethers.js è un'astrazione usata per distribuire nuovi smart contract, quindi MyNFT qui è una fabbrica di istanze del nostro contratto NFT. Usando il plugin hardhat-ethers, le istanze ContractFactory e Contract sono connesse di default al primo firmatario.

1const myNFT = await MyNFT.deploy();
2

Chiamare deploy() su un ContractFactory avvierà la distribuzione e restituirà un Promise che si risolve in un Contract. Questo è l'oggetto che ha un metodo per ciascuna delle funzioni del nostro smart contract.

Fase 16: distribuisci il contratto

Siamo finalmente pronti a distribuire il nostro smart contract! Torna alla root della cartella del tuo progetto e nella riga di comando esegui:

1npx hardhat --network ropsten run scripts/deploy.js
2

Vorrai poi vedere qualcosa del genere:

1Contract deployed to address: 0x81c587EB0fE773404c42c1d2666b5f557C470eED
2

Se andiamo a Ropsten etherscan e cerchiamo l'indirizzo del nostro contratto, dovremmo poter vedere che è stato distribuito correttamente. Se non riesci a vederlo immediatamente, attendi un po', poiché potrebbe essere necessario un po' di tempo. La transazione somiglierà a questa:

Visualizza l'indirizzo della tua transazione su Etherscan

L'indirizzo "Da" dovrebbe corrispondere all'indirizzo del tuo account di MetaMask mentre l'indirizzo "A" sarà: “Creazione del Contratto.” Se clicchiamo nella transazione, vedremo l'indirizzo del nostro contratto nel campo "A":

Visualizza l'indirizzo del tuo contratto su Etherscan

Sì! Hai appena distribuito il tuo smart contract dell'NFT alla chain di Ethereum!

Per capire cosa sta succedendo, andiamo alla scheda Explorer nella nostra dashboard di Alchemy. Se hai diverse app di Alchemy, assicurati di filtrare per app e selezionare "MyNFT".

Visualizza le chiamate effettuate "dietro le quinte" con la dashboard Explorer di Alchemy

Qui vedrai numerose chiamate a JSON-RPC che Hardhat/Ethers ha effettuato per noi quando abbiamo chiamato la funzione .deploy(). Due chiamate importanti sono eth_sendRawTransaction, che è la richiesta per scrivere realmente il nostro smart contract sulla catena di Ropstein e eth_getTransactionByHash, che è una richiesta a leggere le informazioni sulla nostra transazione dato l'hash (sistema tipico quando si inviano delle transazioni). Per saperne di più sull'invio delle transazioni, dai un'occhiata a questo tutorial sull'invio di transazioni usando web3.

È tutto per la Parte 1 di questo tutorial. Nella Parte 2, interagiremo realmente con il nostro smart contract, coniando un NFT, mentre nella Parte 3 ti mostreremo come visualizzare il tuo NFT nel tuo portafoglio di Ethereum!

Ultima modifica: , Invalid DateTime
Modifica la pagina

Questa pagina è stata utile?