Come creare una Token ERC20
Come creare e distribuire un token ERC20 – In 20 minuti
Le criptovalute sono recentemente diventate popolari, aprendo infinite possibilità ad aziende, individui e DAO. Se vuoi imparare come creare e distribuire un token ERC20 in 20 minuti, questo è il posto giusto dove stare.
In questo tutorial, capirai come creare una criptovaluta utilizzando Solidity e lo standard ERC20 Token (richiesta di commento Ethereum) gestito da OpenZeppelin.
Per prima cosa scriveremo lo Smart Contract utilizzando REMIX IDE, un IDE online appositamente realizzato per lo sviluppo di Ethereum con Solidity. Configureremo quindi un ambiente locale utilizzando Hardhat per distribuire la tua criptovaluta su Mumbai Polygon Testnet.
Alla fine di questo tutorial imparerai:
- Sviluppa e distribuisci uno Smart Contracts Ethereum utilizzando l’IDE IX.
- Come creare e distribuire un token ERC20 con Solidity.
- Configura un ambiente di sviluppo Ethereum locale utilizzando Hardhat.
- Distribuisci una criptovaluta su Polygon Mumbai.
- Visualizza la tua criptovaluta su MetaMask.
- Come avviare la propria criptovaluta.
Non si presume alcuna conoscenza precedente di Solidity, anche se si suggerisce di avere alcune conoscenze di programmazione precedenti prima di iniziare questo tutorial. Se non sai da dove cominciare, ti consiglio vivamente di andare a controllare la roadmap completa di web3
Detto questo, approfondiamo direttamente come sviluppare e distribuire un token ERC20.
Come creare un token ERC20: configura l’ambiente con REMIX
Impareremo come creare e distribuire un ERC20 Token Smart Contract usando REMIX, un IDE facile da usare, gratuito, con una grande funzionalità IntelliJ compatibile con Solidity e errori di compilazione decenti.
Passare a remix.ethereum.org, aprire la cartella dei contatti e creare un nuovo file denominato “Token.sol”:
Ogni volta che viene creato un nuovo file Solidity, è obbligatorio aggiungere l’identificatore di licenza e il pragma per specificare la versione di Solidity che il compilatore deve utilizzare per creare il nostro codice.
Nel file Token.sol scrivere il codice seguente:
Token.sol// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
“^” indica che il codice è compatibile con qualsiasi versione del compilatore da Solidity 0.8.0 a 0.8.9.
Ora dobbiamo importare il contratto token ERC20 da OpenZeppelin, ma prima, lasciatemi passare brevemente attraverso quello che è un token ERC20, importante per capire se si vuole creare la propria criptovaluta.
Se hai già familiarità con questo concetto, sentiti libero di saltare al paragrafo successivo.
Come creare e distribuire un token ERC20: cos’è un ERC20?
Secondo la documentazione ufficiale di OpenZeppelin:
“Un contratto token ERC20 tiene traccia dei token fungibili: qualsiasi token è esattamente uguale a qualsiasi altro token; nessun token ha diritti o comportamenti speciali ad essi associati. Questo rende i token ERC20 utili per cose come un mezzo di scambio di valuta, diritti di voto, staking e altro ancora. “
In poche parole, ERC20 non è altro che una classe, con i suoi metodi e membri, che esegue la logica di ciò che comunemente chiamiamo criptovalute, con un significato più ampio, in quanto trova applicazioni anche in altri casi d’uso.
OpenZeppelin d’altra parte è considerata la libreria standard che mantiene le classi di contratti ERC.
Se vuoi saperne di più sullo standard del token ERC20, ecco un paio di risorse:
Ora che abbiamo una breve comprensione del motivo per cui stiamo importando la libreria OpenZeppelin e cosa significa ERC20, continuiamo a imparare come creare e distribuire un token ERC20.
Come creare e distribuire un token ERC20
Importare il contratto OpenZeppelin ERC20 nel file Token.sol:
Token.sol// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
E inizializza il token, ereditando dal contratto ERC20.sol:
Token.sol// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract DevToken is ERC20{
}
Qui stiamo dichiarando un nuovo contratto chiamato “DevToken”, utilizzando il contratto con parole chiave Solidity, mentre ereditiamo dal contratto di OpenZeppelin ERC20 utilizzando la parola chiave “is”.
Ereditare dal contratto ERC20 ci darà accesso a metodi come _mint() e balanceOf(). Se vuoi dare un’occhiata a tutti i metodi disponibili, puoi controllare la documentazione ufficiale ERC20.
Il prossimo passo è creare una criptovaluta è chiamare il costruttore del contratto e fornire il nome e il simbolo del token. Per fare ciò, all’interno del contratto, scrivere il seguente codice:
E inizializza il token, ereditando dal contratto ERC20.sol:
Qui stiamo dichiarando un nuovo contratto chiamato “DevToken”, utilizzando il contratto con parole chiave Solidity, mentre ereditiamo dal contratto di OpenZeppelin ERC20 utilizzando la parola chiave “is”.
Ereditare dal contratto ERC20 ci darà accesso a metodi come _mint() e balanceOf(). Se vuoi dare un’occhiata a tutti i metodi disponibili, puoi controllare la documentazione ufficiale ERC20.
Il prossimo passo è creare una criptovaluta è chiamare il costruttore del contratto e fornire il nome e il simbolo del token. Per fare ciò, all’interno del contratto, scrivere il seguente codice:
A questo punto il codice dovrebbe essere simile al seguente:
Benissimo! Un ultimo passo prima di testare la nostra criptovaluta e passare ad argomenti più complessi, ora dobbiamo distribuire efficacemente il nostro token ERC20.
Come creare un token ERC20: mint la criptovaluta
Come detto prima, ereditare dal contratto ERC20, ci dà accesso al metodo _mint() utilizzato per creare nuovi token e inviarli a un determinato indirizzo, esattamente ciò di cui abbiamo bisogno ora.
Il minting è definito come il processo di convalida delle informazioni, la creazione di un nuovo blocco e la registrazione di tali informazioni nella blockchain. In poche parole, “zecca” significa: creare qualcosa, come un numero di token, o un NFT, e salvarlo sulla blockchain.
Supponiamo di voler creare 1000 token e inviarli al nostro portafoglio, per raggiungere questo obiettivo, possiamo aggiungere il seguente codice nel costruttore:
C’è molto da fare qui, prendiamoci un secondo per capirlo:
Prima di tutto, stiamo chiamando la funzione _mint(), che è responsabile dell’emissione dei token e vuole due parametri:
- a: indirizzo del portafoglio/contratto che riceverà i token,
- importo: quantità di token da inviare.
L’argomento “to” è tratto da msg.sender, una variabile speciale il cui valore è l’indirizzo del portafoglio/contratto che chiama il contratto. L’importo, d’altra parte, deve occuparsi dei decimali, ed è per questo che stiamo passando un numero così grande, lasciatemi passare attraverso di esso per un secondo.
Una nota sui decimali
Quando hai a che fare con criptovalute potresti voler essere in grado di inviare importi arbitrari, come 0.004ETH. Sfortunatamente, Solidity e la macchina virtuale Ethereum non supportano i decimali: è possibile utilizzare solo numeri interi. Ciò significa che solo i numeri interi possono essere inviati (1, 4, 5) e questo, ovviamente, pone un problema.
Quindi qual è la soluzione alternativa?
È molto semplice, un contratto token può utilizzare valori interi più grandi (L’EVM supporta interi a 256 bit) in modo che un saldo di 10000000000000000000000 rappresenti 1 ETH con 18 cifre decimali, quindi un trasferimento di 4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Noi che in mente, quando calcoliamo la nostra offerta totale, dobbiamo tenere conto della quantità totale di token, comprese le cifre decimali che vogliamo avere.
Se vuoi una fornitura massima totale di 1.000.000.000 di token, con 18 cifre decimali, come Ethereum e molte altre criptovalute, vuoi passare 1000000000 * 10 ** 18 cioè (10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
D’altra parte, quando si inviano 2 token il metodo per chiamare sarà in realtà:
Distribuisci la tua criptovaluta token ERC20
Su REMIX, fai clic sull’icona Solidità sul lato sinistro dello schermo e fai clic su Compila. Potresti anche voler attivare la compilazione automatica, per consentire a REMIX di ascoltare le modifiche al codice e compilare il codice.
Questo compilerà il codice Token.sol, popolando la cartella degli artefatti con il nostro Token’s Contract abi (interfaccia binaria dell’applicazione) e la loro versione binaria, utilizzata per distribuirlo sulla blockchain.
Ora che abbiamo i nostri artefatti, fai clic sul logo Ethereum sotto l’icona Solidity, seleziona il tuo contratto nel menu a discesa e fai clic su distribuisci:
Interagisci con la tua prima criptovaluta
Ricordare? Una volta implementato, il nostro contratto intelligente avrebbe dovuto emettere 1000 token sul nostro portafoglio! Se guardi, proprio sopra il pulsante Distribuisci, c’è il campo “account”:
Questo è l’indirizzo del portafoglio che abbiamo usato per distribuire il nostro contratto ERC20 Token, possiamo dire che poiché manca un po ‘di Ethereum, le commissioni del gas che abbiamo pagato per distribuire il contratto sulla macchina virtuale Ethereum.
Se tutto ha funzionato come previsto, ora dovremmo vedere la quantità emessa di token nel saldo dell’indirizzo del nostro portafoglio.
Per testarlo, come puoi notare, proprio sotto il pulsante di distribuzione e “Contratti distribuiti”, c’è il tuo token ERC20 distribuito. Facendo clic sul menu a discesa avrai accesso a tutti i metodi ERC20 che il tuo contratto ha ereditato o implementato:
Il colore dei pulsanti rappresenta se la funzione di rappresentazione modifica qualsiasi valore sulla blockchain, costa gas (arancione), o è una semplice funzione di visualizzazione che legge e restituisce un valore (blu).
Tra questi pulsanti, ce n’è uno che dice “balanceOf“, richiede un indirizzo come input e recupererà la quantità associata di token ERC20. Usiamolo:
- Copia l’indirizzo del portafoglio facendo clic sull’icona “copia” vicino all’indirizzo del portafoglio.
- Scorri verso il basso nei metodi token e cerca “balanceOf”.
- Incolla l’indirizzo del portafoglio nel campo.
- Fare clic sul pulsante blu balanceOf.
- Controlla l’importo.
Ben fatto, hai appena creato la tua criptovaluta! 
Sfortunatamente, però, ci sono due problemi al momento:
- Il nostro Token non è ancora accessibile dall’esterno di REMIX perché attualmente distribuito su Remix EVM, una macchina virtuale che funge da blockchain, non accessibile da nulla tranne che dall’istanza REMIX.
- Invece di emettere tutti i token durante la distribuzione, come stiamo facendo ora, potremmo voler emettere i token come ricompensa, come conseguenza di un’azione o semplicemente in piccoli lotti.
Affrontiamo prima il primo problema, come gestire la fornitura di token.
Nota: REMIX utilizza un ambiente ethereum virtuale ospitato, che può essere paragonato a una testnet ma non è accessibile pubblicamente al di fuori dell’ambiente stesso. Il tuo contratto non verrà distribuito sulla mainnet Ethereum effettiva, né in una testnet accessibile pubblicamente.
Come sviluppare un ERC20: creare una fornitura di token che funzioni
Quando hai bisogno di creare la tua offerta di criptovaluta, abbiamo 3 scelte principali:
- Fornitura Fissa
- Fornitura pigra senza cappuccio
- Fornitura pigra con cappuccio
A questo punto, il nostro token ha una fornitura fissa emessa al momento della distribuzione, esploriamo cosa significa e le alternative che abbiamo quando sviluppiamo le nostre criptovalute.
Fornitura Fissa
La fornitura totale del token viene emessa al momento della distribuzione e inviata all’indirizzo del portafoglio di distribuzione.
In questo caso, scegliamo una fornitura totale in anticipo ed emettiamo l’intero importo al nostro portafoglio quando viene chiamato il costruttore del contratto, lasciandoci lo sforzo di distribuire i token tra diversi titolari.
Se non vogliamo emettere tutti i token contemporaneamente, però, dovremmo optare per un approccio pigro al conio.
Fornitura pigra senza cappuccio
I token non vengono coniati ed emessi in un batch univoco al momento della distribuzione, ma in piccole quantità e inviati ai portafogli specificati, di conseguenza a una o più azioni.
In questo caso, l’offerta massima totale è regolata attraverso principi economici e non su un valore hard-coded.
Pensa a un Minatore che convalida una transazione e ottiene token come ricompensa, o a un utente che impila i propri token per ricevere premi periodici.
L’assenza di una fornitura Max hardcoded, tuttavia, potrebbe rendere il tuo token inflazionistico, incorrendo in una perdita di valore nel tempo o, peggio, mettendo a rischio la sua sicurezza. Anche se questo va al di fuori del focus di questo tutorial, è bene capire che possiamo, e dovremmo, limitare la nostra offerta.
Fornitura con cap
Come nel meccanismo Uncapped Lazy Supply, i token vengono emessi in piccole quantità, con l’unica differenza che qui il max-supply viene deciso in anticipo e codificato nel contratto intelligente o trasmesso alla distribuzione.
In questo tutorial, esploreremo ampiamente tutti i metodi per creare la fornitura dei nostri token.
ERC20 Token Supply – Fornitura fissa
Diciamo che vogliamo un token con una fornitura fissa di 1000 Dev Token (come abbiamo fatto nel nostro codice) inizialmente allocati al wallet che distribuisce il contratto, per farlo abbiamo semplicemente chiamato la funzione privata _mint() all’interno del Costruttore Token:
Sapendo che il costruttore viene chiamato una sola volta, al momento della distribuzione, questo contratto intelligente non solo ha trasferito 1000 token (l’importo ha 18 cifre decimali: vedi una nota sulla sezione decimali) al nostro portafoglio, ma ha anche reso impossibile coniare qualsiasi nuovo token, non avendo una funzione _mint () esposta nel suo codice.
Possiamo controllare il saldo del token dell’indirizzo che ha distribuito il token chiamando il metodo balanceOf(), proprio come abbiamo fatto prima.
Quindi, cosa succede se vogliamo emettere token nel tempo e non in un batch univoco?
ERC20 Token Supply – Cap
Per raggiungere questo obiettivo possiamo semplicemente spostare la funzione di zecca dal nostro costruttore a una nuova funzione pubblica che può essere chiamata in diverse circostanze:
In questo caso, ogni volta che viene chiamato issueToken(), il chiamante riceverà tale quantità di token. Naturalmente, possiamo anche passare argomenti per variare la quantità emessa di monete o il destinatario:
Il problema qui è che, senza ulteriori controlli, non c’è limite al numero di token che un utente può emettere. Come soluzione alternativa, possiamo limitare l’offerta totale del token.
ERC20 Token Supply – Fornitura modulare limitata
Per aggiungere una fornitura massima al nostro Token, possiamo utilizzare la libreria OpenZeppelin ERC20Capped.
ERC20Capped è una sottoclasse di ERC20Mintable che a sua volta eredita dal contratto standard ERC20. Questo ci consente di sostituire la libreria ERC20.sol nel nostro codice, con ERC20Capped, pur mantenendo metodi come _mint() e balanceOf().
Dovremo anche specificare un valore cap passando un argomento uint256 al nostro costruttore Token e inserendolo nel costruttore ERC20Capped.
Importiamo la libreria ERC20Capped da OpenZeppelin e aggiungiamo il seguente codice al contratto Token.sol:
Ora possiamo testare il nostro token Capped usando REMIX, proprio come abbiamo fatto prima:
- Fai clic sull’icona Solidity e compila il tuo codice
- Seleziona il tuo contratto Token dal menu a discesa
- Inserire l’importo del limite nel campo distribuzione
- Fare clic su Distribuisci
- Fare clic sul metodo del pulsante “cap” per recuperare il valore del cap
Come puoi vedere, nell’esempio, abbiamo inserito un valore cap di 100000000000000000000 che, considerando le 18 cifre decimali, corrisponde ad una fornitura massima di 0,01 TVP. L’utilizzo del metodo issueToken() ora ripristinerà la transazione generando un errore “cap superato”:
Ora che abbiamo un token coniabile c’è ancora un problema da risolvere: tutti possono coniarlo chiamando la funzione issueToken(), e questo solleva un enorme problema di sicurezza. Volentieri, c’è una soluzione ad esso: contratti di proprietà.
Come creare un token ERC20 – Sicurezza e controllo degli accessi
Copiando ciò che ci dice la documentazione di OpenZeppelin sul controllo degli accessi:
Il controllo degli accessi, o “chi è autorizzato a fare questa cosa”, è incredibilmente importante quando si tratta di contratti intelligenti. Il controllo degli accessi del tuo contratto può governare chi può coniare token, votare su proposte, congelare i trasferimenti e molte altre cose.
È quindi fondamentale capire come lo implementi, per timore che qualcun altro rubi l’intero sistema.
La forma più comune e basilare di controllo degli accessi è il concetto di proprietà in cui esiste solo un account autorizzato a eseguire attività sensibili su un contratto (il proprietario). Questo approccio è perfettamente ragionevole per i contratti che hanno un unico utente amministrativo.
OpenZeppelin fornisce Ownable per l’implementazione della proprietà nei contratti.
Per usarlo, dovremo importare il contratto nel nostro codice, aggiungerlo come super-classe del nostro contratto Token, proprio come abbiamo fatto prima, e aggiungere un modificatore di funzione alla funzione issueToken() ADD LINK:
Come possiamo notare, il contratto Token sta ora ereditando sia dal contratto ERC20 che dal contratto Ownable, questo ci dà accesso al modificatore della funzione onlyOwner applicato alla funzione issueToken().
onlyOwner verrà eseguito ogni volta che issueToken() viene chiamato, verificando se il chiamante è il proprietario del contratto.
Per impostazione predefinita, il proprietario di un contratto ownable è l’account che lo ha distribuito, che in genere è esattamente quello che si desidera.
Ora che abbiamo una ragionevole comprensione di come progettare la nostra fornitura di token e come proteggere il suo processo di conio, impariamo come distribuire il nostro token su una blockchain reale e accessibile, creando un ambiente di sviluppo locale utilizzando Hardhat.
Configura il tuo ambiente di sviluppo Blockchain locale
Se vogliamo trasferire il Token appena creato su un altro portafoglio, elencarlo in uno scambio o semplicemente usarlo nel mondo reale, REMIX non sarà sufficiente. Per distribuire un contratto intelligente Ethereum su una blockchain pubblica, come Polygon o Ethereum, dovremo creare un ambiente di sviluppo Ethereum come Hardhat o Truffle.
In questo tutorial, useremo Hardhat e supponiamo che tu abbia VSCode già installato sul tuo dispositivo.
Inizia creando una nuova cartella:
mkdir myFirstTokenVai alla cartella del progetto, installa Hardhat e le dipendenze necessarie per compilare e testare il nostro contratto intelligente Token:
yarn add hardhat @nomiclabs/hardhat-waffle @nomiclabs/hardhat-ethers ethers ethereum-wafflePuoi saperne di più sulle dipendenze che stiamo installando, nella documentazione ufficiale di Hardhat.
Una volta installato, inizializzare l’installazione guidata di Hardhat eseguendo:
npx hardhat
Selezionare:
Creare un progetto di esempio di base > lasciare la radice predefinita > aggiungere un file .gitignore.
Questo popolerà la nostra directory di progetto con i file e le cartelle Hardhat predefiniti.
Il prossimo passo sarà quello di modificare il file hardhat.config.js che contiene le impostazioni di configurazione per connettersi con le istanze blockchain in esecuzione, ma prima, prendiamo il nostro URL dell’endpoint del provider di nodi.
Prendi il tuo endpoint del provider di Mumbai usando Alchemy
Quando distribuisci qualcosa sulla blockchain, avrai bisogno di un nodo responsabile per eseguire il tuo contratto intelligente, per farlo hai due opzioni:
- Avvia il tuo nodo Ethereum.
- Utilizzare un provider di nodi di terze parti come Alchemy o Infura.
L’esecuzione del proprio nodo è solitamente scoraggiata, in quanto è difficile da mantenere, è difficile da scalare, deve essere aggiornata e dovrebbe garantire la coerenza dello stato, richiedendo un serio sforzo ingegneristico costante. (leggi di più su Nodes as a Service qui)
In questo caso, useremo Alchemy come fornitore di Nodi di Mumbai, in quanto è completamente gratuito, facile da configurare e ha funzionalità straordinarie.
Passare a alchemy.com e creare un nuovo account:
Una volta effettuato l’accesso, fare clic su “+ CREA APP“:
E compila i campi come segue:
Nome: MyProjectDescrizione
: Il mio primo tokenAmbiente
: DevelopmentChain
: PolygonNetwork
: Polygon Mumbai
E clicca su CREA APP.
Cerca l’app appena creata in Alchemy Apps e fai clic su di essa.
Una volta nella pagina dell’app, fai clic su “VIEW KEY” e copia l’endpoint HTTP:
Ora che abbiamo copiato l’endpoint Polygon Mumbai, modifichiamo il nostro file hardhat.config.js.
Modificare il file hardhat.config
Distribuiremo il nostro token alla Mumbai Polygon Testnet, ma ciò che viene spiegato nel capitolo seguente è applicabile a tutte le reti Blockchain costruite su Ethereum (basta cambiare l’impostazione hardhat.config.js per adattarsi alla catena desiderata).
Aprire il file hardhat.config.js nella directory principale del progetto e aggiungere il codice seguente all’interno dell’oggetto module.exports:
Il prossimo passo è aggiungere la chiave privata del portafoglio che vogliamo utilizzare per distribuire il token sulla blockchain, ma prima dobbiamo installare la libreria dotenv per mantenere sicura la nostra chiave privata
Iniziamo installando dotenv.
Installare dotenv
Nel terminale, all’interno della cartella del progetto, installare la libreria dotenv digitando:
yarn add dotenve creare un nuovo file con estensione env nella cartella principale del progetto.
Una volta creato, aggiungi il file .env al tuo .gitignore, questo ti impedirà di inviare i tuoi segreti a GitHub o a qualsiasi altro servizio di controllo della versione che potresti utilizzare.
Nota: spingendo la chiave privata del tuo portafoglio su GitHub il tuo fondo verrà rubato dai bot. Assicurati di mantenere i tuoi segreti… segreto.
Ora dobbiamo prendere la nostra chiave privata, per farlo, avrai bisogno di un portafoglio crittografico.
Prendi la chiave privata del tuo portafoglio
Una volta installato, passa all’estensione MetaMask e:
- Fare clic sul menu a tre punti.
- Clicca su “Dettagli account”.
- Fare clic su “Esporta chiave privata”.
- Inserisci la tua password.
- e copia la tua chiave privata.
Salva la chiave privata nel file con estensione env
Tornare alla . env nella nostra cartella di progetto e dichiara una nuova variabile, chiamala “PRIVATE_VARIABLE” e assegnale il valore della tua chiave privata:
PRIVATE_KEY="YOUR PRIVATE KEY"Aprire il file hardhat.config.js e inizializzare dotenv per accedere alle variabili di ambiente contenute nel file env. A tale scopo, all’inizio del file hardhat.config.js importare dotenv come segue:
hardhat.config.jsrequire('dotenv').config()
Ora, all’interno dell’oggetto module.exports, proprio sotto la proprietà ‘url’, aggiungi l’account che vogliamo utilizzare per distribuire il nostro contratto Token Smart:
hardhat.config.jsmodule.exports = {
solidity: "0.8.4",
networks:{
mumbai:{
url: 'YOUR ALCHEMY POLYGON MUMBAI ENDPOINT',
accounts: [`0x${process.env.PRIVATE_KEY}`]
}
}
};
Come puoi notare, usando i valori letterali delle stringhe JavaScript, abbiamo aggiunto “0x” alla nostra chiave privata, perché Hardhat si aspetta una stringa esadecimale che inizia con 0x come chiave privata, MetaMask d’altra parte, dà il prefisso per scontato, rimuovendolo.
Stiamo anche accedendo alla nostra variabile PRIVATE_KEY, utilizzando process.env.NAME_OF_VAR.
A questo punto il nostro file hardhat.config.js dovrebbe essere simile a questo:
hardhat.config.jsrequire("@nomiclabs/hardhat-waffle");
require('dotenv').config()
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
const accounts = await hre.ethers.getSigners();
for (const account of accounts) {
console.log(account.address);
}
});
module.exports = {
solidity: "0.8.4",
networks:{
mumbai:{
url: 'https://polygon-mumbai.g.alchemy.com/v2/jD_n5-Vt3zoIDgZX8ui1mtAueDGh4TQn',
accounts: [`0x${process.env.PRIVATE_KEY}`]
}
}
};
Benissimo! Il nostro hardhat.config.js è pronto per distribuire il nostro contratto su Polygon. Ora è il momento di spostare il codice token da REMIX al nostro ambiente di sviluppo locale e modificare lo script di distribuzione.
Iniziamo installando OpenZeppelin nel nostro progetto.
Aggiungi il token Smart Contract al tuo progetto
Prima di tutto, dovremo installare OpenZeppelin nel nostro progetto.
Nel terminale, all'interno della cartella del progetto, scrivi:
yarn add @openzeppelin/contracts
Una volta installato spostati nella cartella "contratti" del nostro progetto e crea un nuovo file chiamato Token.sol. Torna a REMIX, copia il codice Token.sol Contract che abbiamo scritto qualche paragrafo fa e incollalo nel nuovo file Token.sol locale.
Nota: useremo il Token con una fornitura fissa a scopo di tutorial, lo stesso varrà per tutti i contratti.
Il codice dovrebbe essere il seguente:
Token.sol
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract DevToken is ERC20{
constructor(uint256 totalSupply) ERC20("DevToken", "DVT"){
_mint(msg.sender, totalSupply);
}
}
Ora dobbiamo modificare lo script di distribuzione.
Modificare lo script di distribuzione
Nella cartella "scripts", all'interno della directory del progetto, rinominare sample-script.js in "deploy.js" e aprirlo.
Sostituire il contenuto di deploy.js con il codice seguente:
Esaminiamo brevemente cosa sta succedendo qui:
Prima di tutto, stiamo importando la libreria Hardhat, che ci darà accesso a utilità come getContractFactory(). Dichiariamo una funzione asincrona e distribuiamo il token passando come argomento il valore totalSupply necessario nel costruttore Token.
Puoi leggere ulteriori informazioni sulla distribuzione con Hardhat nei documenti ufficiali.
Come si può notare il totalSupply viene passato come stringa (“100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Infine, attendiamo che devToken distribuisca e stampi il suo indirizzo.
Le ultime righe stanno solo chiamando la funzione main() e uscendo in caso di errore.
Ora tutto è pronto per compilare e distribuire la nostra criptovaluta.
Compila e distribuisci la tua criptovaluta su Polygon Mumbai
Prima di tutto, come abbiamo fatto su REMIX, dovremo compilare il nostro contratto token per ottenere gli artefatti e consentire alla funzione getContractFactory() in deploy.js, di afferrare il nostro contratto.
Nel terminale, eseguire:
npx hardhat compileQuesto crea una nuova cartella nella radice del progetto, chiamata artefatti, e la popola con la versione compilata del nostro Token.
Infine, dovremo implementare il nostro contratto, per farlo, però, avremo bisogno di un po ‘di MATIC per pagare le tariffe del gas. Non preoccuparti, non spenderemo un centesimo, questo è il motivo per cui stiamo distribuendo su una testnet.
Ottieni Test MATIC per distribuire la tua criptovaluta
Ottenere alcuni test MATIC è molto semplice:
- Passare a faucet.polygon.technology.
- Seleziona la rete di Mumbai.
- Incolla l’indirizzo del tuo portafoglio.
- Clicca su “Invia”.
- Attendi fino a un minuto per vedere il MATIC trasferito nel tuo portafoglio.
Ora abbiamo abbastanza MATIC per distribuire il nostro contratto token.
Come distribuire un token ERC20 su Polygon Mumbai
Tornare alla cartella del progetto ed eseguire il seguente script nel terminale:
npx hardhat run ./scripts/deploy.js --network mumbaiQui stiamo dicendo a Hardhat di eseguire il nostro script di distribuzione utilizzando la rete di Mumbai le cui impostazioni sono specificate nel file hardhat.config.js.
Dopo un paio di secondi dovresti vedere l’indirizzo token sulla rete di Mumbai registrato nel terminale:
Eccellente! Hai appena distribuito il tuo primo Token sulla Blockchain!
Se tutto ha funzionato come previsto, ora dovresti vedere la tua criptovaluta appena creata e la quantità coniata di token nel tuo portafoglio MetaMask o interagire con loro nella tua DApp (scopri come sviluppare un’applicazione decentralizzata)
Prima, però, dovremo dire a MetaMask come trovare il nostro token.
Aggiungi il tuo token ERC20 a MetaMask
Ci sono due passaggi necessari per visualizzare il tuo ERC20 Toke su Metamask per farlo:
- Aggiungi Polygon Mumbai a MetaMask.
- Aggiungi il nuovo token a Metamask.
Fare riferimento a questa guida per aggiungere Polygon Mumbai a MetaMask.
Aggiungere un nuovo Custom Token, invece, è molto semplice, vediamo come.
Quando abbiamo distribuito il nostro Token abbiamo registrato il suo indirizzo on-chain nel terminale, copiamolo e passiamo a MetaMask:
- Assicurati di essere sulla Testnet di Mumbai
- Scorri fino in fondo all’estensione MetaMask
- Clicca su “Importa token”
- Incolla il tuo indirizzo token
- Clicca su “Aggiungi token personalizzato”
Come puoi notare, MetaMask riconoscerà automaticamente il simbolo del token e il numero di decimali.
Ce l’abbiamo fatta! Hai appena distribuito la tua prima criptovaluta, congratulazioni!
