Crea un token ERC-20

Questo è il nostro secondo tutorial su Solidity, se ti sei perso dai un’occhiata alla nostra Introduzione a Solidity dove ti guidiamo attraverso alcune basi di questo linguaggio di programmazione per la blockchain di Ethereum.

Spieghiamo un po ‘come funziona Solidity, come è strutturato e inizi con un semplice codice per scrivere uno smart contract “Hello World”.

In questo tutorial andremo più in profondità e ti insegneremo il codice per distribuire il tuo token Ethereum ERC-20. (Ecco il nostro Token Blockonomi ).

Ethereum & Il boom dell’ICO

ICO sta per Initial Coin Offering ed è un tipo di finanziamento che utilizza criptovalute. In una ICO, una quantità di criptovaluta viene venduta sotto forma di “token” (“monete”) a speculatori o investitori, in cambio di moneta a corso legale o altre criptovalute come Bitcoin o Ethereum.

I token venduti vengono promossi come future unità funzionali di valuta se o quando l’obiettivo di finanziamento dell’ICO viene raggiunto e il progetto viene avviato.

Abbiamo già parlato di come i contratti intelligenti abbiano aperto un mondo completamente nuovo agli sviluppatori per creare e innovare. Tuttavia, questi sviluppatori avevano bisogno di un modo per finanziare i loro progetti.

E la soluzione era l’ICO.

Nel 2017 gli ICO erano in piena espansione: innumerevoli progetti apparivano ogni giorno con promesse selvagge di ciò che volevano ottenere e gli investitori li hanno accaparrati.

Da allora, le cose si sono calmate man mano che lo spazio è maturato e gli investitori sono scomparsi, molte ICO non sono riuscite a mantenere ciò che era stato promesso, ma questa è una storia per un altro post – siamo qui per discutere il lato tecnico.

Cos’è un token?

I token sono essenzialmente contratti intelligenti che vivono sulla Blockchain di Ethereum, possono avere usi e scopi.

Un token non è limitato a un ruolo particolare. Può svolgere molti ruoli nel suo ecosistema nativo. Ecco l’elenco di alcuni ruoli che i token possono assumere.

  • Pedaggio: Un token può fungere da gateway per una Dapp. Fondamentalmente, per accedere alla Dapp, dovrai tenere i token.
  • Diritti di voto: I token possono anche qualificare i titolari per avere determinati diritti di voto. Pensa a EOS, possedere token EOS ti consentirà di votare per i produttori di blocchi. EOS Blockchain mira a diventare un sistema operativo decentralizzato in grado di supportare applicazioni decentralizzate su scala industriale.
  • Scambio di valore: Questo è uno dei ruoli più comuni dei token all’interno dell’ecosistema. I token possono aiutare a creare un sistema economico interno all’interno dell’applicazione.
  • Miglioramento dell’esperienza utente: Il token può anche consentire ai possessori di arricchire l’esperienza dell’utente all’interno dei confini di un particolare ambiente. Per esempio. In Brave (un browser web), i possessori di BAT (token utilizzati in Brave) avranno i diritti per arricchire l’esperienza del cliente utilizzando i loro token per aggiungere pubblicità o altri servizi basati sull’attenzione sulla piattaforma Brave.
  • Moneta: Può essere utilizzato come riserva di valore che può essere utilizzato per condurre transazioni sia all’interno che all’esterno dell’ecosistema dato.

Cos’è ERC-20?

ERC-20 è uno standard tecnico utilizzato per gli smart contract sulla blockchain di Ethereum per l’implementazione dei token. La maggior parte dei token emessi sulla blockchain di Ethereum sono conformi a ERC-20.

ERC-20 è uno standard di protocollo che definisce alcune regole e standard per l’emissione di token sulla rete di Ethereum. In “ERC-20”, ERC sta per Ethereum Request For Comments e 20 sta per un numero ID univoco per distinguere questo standard dagli altri.

Per mantenerlo semplice, ERC-20 è una guida di regole e regolamenti che aiuteranno a creare un modello per i contratti intelligenti basati su Ethereum per creare i loro token.

Un token su Ethereum è fondamentalmente solo uno smart contract che segue alcune regole comuni, ovvero implementa un set standard di funzioni condivise da tutti gli altri contratti token, come transferFrom (address _from, address _to, uint256 _tokenId) e balanceOf (address _owner).

Quindi fondamentalmente un token è solo un contratto che tiene traccia di chi possiede la quantità di quel token e alcune funzioni in modo che quegli utenti possano trasferire i loro token ad altri indirizzi.

Perché lo standard ERC-20 è così importante?

Poiché tutti i token ERC-20 condividono lo stesso set di funzioni con gli stessi nomi, è possibile interagire con tutti nello stesso modo.

Ciò significa che se crei un’applicazione in grado di interagire con un token ERC-20, è anche in grado di interagire con qualsiasi token ERC-20. In questo modo più token possono essere facilmente aggiunti alla tua app in futuro senza bisogno di codifica personalizzata. Puoi semplicemente collegare il nuovo indirizzo del contratto del token e boom, la tua app ha un altro token che può utilizzare.

Un esempio di questo sarebbe uno scambio. Quando uno scambio aggiunge un nuovo token ERC-20, in realtà deve solo aggiungere un altro contratto intelligente con cui parla. Gli utenti possono indicare a quel contratto di inviare i token all’indirizzo del portafoglio dell’exchange e l’exchange può dire al contratto di inviare nuovamente i token agli utenti quando richiedono un ritiro.

Lo scambio deve implementare questa logica di trasferimento solo una volta, quindi quando vuole aggiungere un nuovo token ERC-20, si tratta semplicemente di aggiungere il nuovo indirizzo del contratto al suo database.

Iniziamo a creare un token

Useremo Remix IDE per sviluppare Smart Contract per il nostro token ERC-20.

Remix è uno strumento online che ti consente di scrivere il contratto intelligente Solidity, quindi distribuirlo ed eseguirlo.

Vai a https://remix.ethereum.org dal tuo browser e possiamo iniziare a scrivere codice.

Fare clic sul pulsante Solidità, quindi sul pulsante Più nell’angolo in alto a sinistra.

Lo chiamerò “BlockonomiToken”, puoi scegliere il nome che preferisci per la tua criptovaluta.

Bene, ora è tutto a posto.

Regole per i token ERC-20

I token ERC-20 seguono un elenco di regole in modo che possano essere condivisi, scambiati con altri token o trasferiti a un cripto-wallet.

Lo standard ERC20 è composto da 3 regole opzionali e 6 regole obbligatorie.

Per dirla in parole povere, se includi determinate funzioni nello smart contract del token, sei conforme a ERC20. Se non includi le funzioni obbligatorie, non sei ERC20.

Le regole obbligatorie sono le seguenti:

  1. totalSupply
  2. equilibrio di
  3. trasferimento
  4. trasferito da
  5. approvare
  6. indennità

D’altra parte, le regole opzionali sono:

  1. Nome token
  2. Simbolo
  3. Decimale (fino a 18)

È pratica comune definire queste regole nell’interfaccia. Non c’è davvero qualcosa chiamato interfaccia in Solidity, è solo un altro Smart Contract. Fortunatamente, si possono ereditare gli Smart Contracts nel linguaggio di programmazione Solidity.

Eredità nella solidità

In Solidity, l’ereditarietà è abbastanza simile ai classici linguaggi di programmazione a oggetti orientati. Scriverai prima il tuo contratto di base e dirai che il tuo nuovo contratto erediterà da quello di base.

contratto IBank {

// codice contratto di base…

}

la banca del contratto è IBank {

// codice contratto ereditato…

}

Devi anche sapere che Solidity supporta l’ereditarietà multipla copiando il codice incluso il polimorfismo.

Tutte le chiamate di funzione sono virtuali, il che significa che viene chiamata la funzione più derivata, tranne quando il nome del contratto viene fornito esplicitamente.

Quando un contratto eredita da più contratti, viene creato un solo contratto sulla blockchain e il codice di tutti i contratti di base viene copiato nel contratto creato.

Torniamo al nostro token ERC-20. Abbiamo regole obbligatorie per creare il token ERC-20.

Le definiremo come 6 funzioni e le scriveremo nell’interfaccia. Quindi il contratto del nostro token in realtà erediterà tale interfaccia di chiamata.

Il tuo codice dovrà essere simile a questo.

contratto ERC20Interface {

funzione totalSupply ()

pubblico

Visualizza

restituisce (uint);

funzione balanceOf (address tokenOwner)

pubblico

Visualizza

ritorni (saldo uint);

indennità di funzione

(indirizzo token proprietario, indirizzo spender)

pubblico

Visualizza

ritorna (uint rimanente);

trasferimento di funzioni (indirizzo a, token uint) pubblico

restituisce (bool successo);

funzione approva (address spender, uint token) public

restituisce (bool successo);

trasferimento di funzioni

(indirizzo da, indirizzo a, token uint) pubblico

restituisce (bool successo);

Trasferimento evento (indirizzo indicizzato da, indirizzo indicizzato, token uint);

Approvazione evento (tokenOwner indicizzato indirizzo, spender indicizzato indirizzo, token uint);

}

Contratto token

Creiamo il nostro contratto token. genere contrarre {}

Ora esamineremo 3 regole opzionali.

Anche se non è necessario assegnare un nome ai gettoni, è comunque importante dargli un’identità.

Successivamente abbiamo i simboli. Semplicemente non possiamo sottovalutare la loro importanza. Un simbolo accattivante aiuta a migliorare il marchio.

Infine, abbiamo la divisibilità che ci aiuterà a determinare il valore più basso possibile del token. Una divisibilità di 0 significa che il valore più basso del token è 1. Una divisibilità di 2, d’altra parte, significa che il suo valore più basso sarà 0,01. Il numero massimo di cifre decimali consentito è 18. 18 decimali è il valore predefinito fortemente consigliato, evitare di modificarlo

Definiamoli e inizializziamo nel costruttore.

contratto BlockonomiToken è ERC20Interface {

stringa nome pubblico;

stringa simbolo pubblico;

uint8 decimali pubblici;

costruttore () pubblico {

nome = "BlockonomiToken";

simbolo = "BKM";

decimali = 18;

}

}

Il nostro token deve anche avere una fornitura iniziale e una registrazione di tutti i saldi. Possiamo memorizzare queste informazioni in un array.

Nel costruttore inizializzeremo il nostro contratto con i token di fornitura iniziale al creatore del contratto (ovvero msg.sender). Aggiungi queste righe al nostro codice e ne discuteremo lo scopo.

contratto BlockonomiToken è ERC20Interface {

stringa nome pubblico;

stringa simbolo pubblico;

uint8 decimali pubblici;

uint256 public _totalSupply;

mapping (indirizzo => uint) saldi;

mapping (indirizzo => mapping (indirizzo => uint)) consentito;

costruttore () pubblico {

nome = "BlockonomiToken";

simbolo = "BKM";

decimali = 18;

_totalSupply = 100000000000000000000000000;

saldi [msg.sender] = _totalSupply;

emit Transfer (indirizzo (0), msg.sender, _totalSupply);

}

}

Tipi di dati di solidità

Come puoi vedere, _totalSupply ha un file uint256 tipo di dati e decimali uint8.

Solidity è un linguaggio tipizzato staticamente, il che significa che il tipo di ogni variabile (statale e locale) deve essere specificato in fase di compilazione. La solidità fornisce diversi tipi elementari che possono essere combinati per formare tipi complessi.

Parliamo del tipo di numeri interi per ora.

Gli interi possono essere int o uint: Numeri interi con e senza segno di varie dimensioni. Se hai familiarità con la teoria dell’informatica o conosci la differenza tra interi con segno e senza segno in linguaggio C, tutto è assolutamente uguale in Solidity.

Se non lo sei, possiamo solo dirlo un unsigned è un numero intero che non può mai essere negativo! Firmato d’altra parte può essere sia negativo che positivo, ma nel nostro contratto useremo solo unità.

Parole chiave da uint8 a uint256 a passi di 8 (senza segno da 8 a 256 bit) e da int8 a int256. uint e int sono alias rispettivamente per uint256 e int256.

Abbiamo detto che immagazzineremo i saldi in una sorta di matrice. Bene, la soluzione migliore è usare le tabelle hash o nelle mappature Solidity.

Fondamentalmente mappiamo indirizzo (anche questo è il tipo di dati) a uint.

msg.sender (indirizzo): mittente del messaggio (chiamata corrente)

msg.sender sarà la persona che attualmente si connette con il contratto.

In seguito, probabilmente ti occuperai di contratti collegati ai contratti. In tal caso, il contratto che crea la chiamata sarebbe il msg.sender.

Mappature

I tipi di mappatura sono dichiarati come Mappatura(_KeyType => _ValueType). Qui _KeyType può essere quasi qualsiasi tipo tranne che per una mappatura, un array di dimensioni dinamiche, un contratto, un’enumerazione e una struttura. _ValueType può effettivamente essere qualsiasi tipo, inclusi i mapping.

Le mappature possono essere viste come tabelle hash che sono virtualmente inizializzate in modo tale che ogni possibile chiave esista e sia mappata su un valore la cui rappresentazione in byte è tutti zeri: il valore predefinito di un tipo. La somiglianza finisce qui, però: i dati chiave non sono effettivamente memorizzati in una mappatura, solo il suo hash keccak256 usato per cercare il valore.

Per questo motivo, le mappature non hanno una lunghezza o il concetto di una chiave o di un valore “impostata”.

Le mappature sono consentite solo per le variabili di stato (o come tipi di riferimento di archiviazione nelle funzioni interne).

È possibile contrassegnare le mappature come pubbliche e fare in modo che Solidity crei un getter. _KeyType diventerà un parametro obbligatorio per il getter e restituirà _ValueType.

Anche _ValueType può essere una mappatura. Il getter avrà un parametro per ogni _KeyType, in modo ricorsivo.

Eventi

La blockchain è un elenco di blocchi che sono fondamentalmente elenchi di transazioni. Ogni transazione ha una ricevuta allegata che contiene zero o più voci di registro. Le voci di registro rappresentano il risultato di eventi generati da uno smart contract.

Nel codice sorgente di Solidity, per definire un evento, lo si contrassegna quindi precedendolo con il evento parola chiave (simile nell’uso alla parola chiave funzione). Y

Puoi quindi chiamare o attivare l’evento nel corpo di qualsiasi funzione desideri causare per generare l’evento. (Dubito che ci sia una formulazione standard per questo). È possibile attivare eventi da qualsiasi funzione utilizzando il emettere parola chiave.

Interfaccia ERC-20

Implementiamo ora l’interfaccia ERC-20. Per fare ciò, dobbiamo scrivere codice per tutte le nostre sei funzioni obbligatorie.

1. TotalSupply

Identifica il numero totale di token ERC-20 creati. Lo scopo di questo metodo è determinare il numero totale di token che fluttuano nell’ecosistema.

funzione totalSupply ()

pubblico

Visualizza

restituisce (uint)

{

return _totalSupply – saldi [indirizzo (0)];

}

2. balanceOf 

Restituisce il numero di token che un particolare indirizzo, in questo caso, il proprietario del contratto, ha nel proprio account.

funzione balanceOf (address tokenOwner)

pubblico

Visualizza

ritorna (saldo uint)

{

saldi di ritorno [tokenOwner];

}

3. indennità

Per poter effettuare una transazione uno dei dati più importanti che il contratto dovrebbe conoscere è il saldo dell’utente. Dopo tutto, l’utente dovrebbe avere la quantità minima di token richiesta per eseguire la transazione.

Questo è il motivo per cui il contratto ERC-20 include anche la funzione di indennità (). Se l’utente non dispone del numero minimo di token richiesto, la funzione annulla la transazione.

indennità di funzione

(indirizzo token proprietario, indirizzo spender)

pubblico

Visualizza

restituisce (uint rimanente)

{

restituzione consentita [tokenOwner] [spender];

}

4. approvare

Una volta verificato il saldo, il titolare del contratto può dare la propria approvazione all’utente per raccogliere il numero richiesto di token dall’indirizzo del contratto.

La funzione di approvazione controlla anche la transazione rispetto alla fornitura totale di token per assicurarsi che non ce ne siano mancanti o extra.

In altre parole, assicura che la contraffazione sia impossibile.

funzione approva (address spender, uint token) public

ritorna

(bool successo)

{

consentito [msg.sender] [spender] = token;

emettere approvazione (msg.sender, spender, token);

return true;}

Libreria matematica sicura

Per implementare correttamente le due funzioni rimanenti, abbiamo bisogno di Safe Math Library.

Wrapper di Safe Math Library sulle operazioni aritmetiche di Solidity con controlli di overflow aggiunti.

Le operazioni aritmetiche in Solidity avvolgono l’overflow. Ciò può facilmente causare bug, perché i programmatori di solito presumono che un overflow sollevi un errore, che è il comportamento standard nei linguaggi di programmazione di alto livello.

Safe Math ripristina questa intuizione annullando la transazione quando un’operazione va in overflow.

L’utilizzo di questa libreria al posto delle operazioni deselezionate elimina un’intera classe di bug, quindi è consigliabile utilizzarla sempre.

Tutto quello che dobbiamo fare ora è copiare questo codice sopra il nostro contratto e quindi ereditarlo.

contratto SafeMath {

function safeAdd (uint a, uint b) public pure returns (uint c) {

c = a + b;

richiedono (c >= a);

}

function safeSub (uint a, uint b) public pure returns (uint c) {

richiedono (b <= a); c = a – b; } funzione safeMul (uint a, uint b) rendimenti pubblici puri (uint c) {c = a * b; richiedono (a == 0 || c / a == b); } function safeDiv (uint a, uint b) public pure restituisce (uint c) {require (b > 0);

c = a / b;

}

}

Non dimenticare di ereditarlo.

contratto BlockonomiToken è ERC20Interface, SafeMath

5. trasferimento

Quindi, ora che tutti i controlli sono stati effettuati e il contratto sa che l’utente ha la quantità richiesta di token necessari per completare la transazione, il proprietario del contratto può inviare loro token utilizzando la funzione transfer ().

Questa funzione consente al titolare del contratto di inviare una determinata quantità di token a un altro indirizzo proprio come una normale transazione di criptovaluta., Consente di trasferire un certo numero di token dalla fornitura totale a un account utente.

trasferimento di funzioni (indirizzo a, token uint)

pubblico

restituisce (bool successo)

{

saldi [msg.sender] = safeSub (saldi [msg.sender], token);

saldi [a] = safeAdd (saldi [a], gettoni);

emettere Transfer (msg.sender, to, token);

restituire vero;

}

6. transferFrom

Abbiamo già coperto la funzione di trasferimento, perché ne abbiamo un’altra?

Bene, facciamo un esempio per vedere perché transferFrom è un’aggiunta così brillante al contratto ERC20.

Dobbiamo tutti pagare una certa somma di denaro ogni mese come un orologio. Potrebbe essere l’affitto, le bollette, ecc. Non è davvero necessario pagare tutti questi importi da solo. Puoi sempre impostare un sistema di pagamento automatico con le tue banche per occuparti di questi pagamenti.

Questo è ciò che transferFrom () ti consente di fare. Ti aiuta ad automatizzare i trasferimenti di pagamento a un account specifico.

trasferimento di funzioni

(indirizzo da, indirizzo a, token uint)

pubblico

restituisce (bool successo)

{

saldi [da] = safeSub (saldi [da], token);

consentito [da] [msg.sender] = safeSub (consentito [da] [msg.sender], token);

saldi [a] = safeAdd (saldi [a], gettoni);

emettere Transfer (da, a, token);

restituire vero;

}

Il codice completo

Ecco il codice completo per il nostro token Blockonomi.

solidità pragma ^ 0,5,0;

// —————————————————————————-

// Interfaccia ERC Token Standard # 20

//

// —————————————————————————-

contratto ERC20Interface {

funzione totalSupply () public view returns (uint);

funzione balanceOf (address tokenOwner) public view ritorna (uint balance);

indennità di funzione (tokenOwner dell’indirizzo, spender dell’indirizzo) restituisce la visualizzazione pubblica (uint rimanente);

trasferimento di funzioni (indirizzo a, token uint) ritorni pubblici (successo bool);

funzione approva (address spender, uint token) public return (bool success);

funzione transferFrom (indirizzo da, indirizzo a, token uint) ritorni pubblici (bool successo);

Trasferimento di eventi (indirizzo indicizzato da, indirizzo indicizzato a, token uint);

Approvazione evento (tokenOwner indicizzato indirizzo, spender indicizzato indirizzo, token uint);

}

// —————————————————————————-

// Libreria matematica sicura

// —————————————————————————-

contratto SafeMath {

function safeAdd (uint a, uint b) public pure returns (uint c) {

c = a + b;

richiedono (c >= a);

}

function safeSub (uint a, uint b) public pure returns (uint c) {

richiedono (b <= a); c = a – b; } funzione safeMul (uint a, uint b) rendimenti pubblici puri (uint c) {c = a * b; richiedono (a == 0 || c / a == b); } function safeDiv (uint a, uint b) public pure restituisce (uint c) {require (b > 0);

c = a / b;

}

}

contratto BlockonomiToken è ERC20Interface, SafeMath {

stringa nome pubblico;

stringa simbolo pubblico;

uint8 decimali pubblici; // 18 decimali è il valore predefinito fortemente consigliato, evita di cambiarlo

uint256 public _totalSupply;

mapping (indirizzo => uint) saldi;

mapping (indirizzo => mapping (indirizzo => uint)) consentito;

/ **

* Funzione costruttore

*

* Inizializza il contratto con gettoni di fornitura iniziale al creatore del contratto

* /

costruttore () pubblico {

nome = "BlockonomiToken";

simbolo = "BKM";

decimali = 18;

_totalSupply = 100000000000000000000000000;

saldi [msg.sender] = _totalSupply;

emettere Transfer (indirizzo (0), msg.sender, _totalSupply);

}

function totalSupply () public view returns (uint) {

return _totalSupply – saldi [indirizzo (0)];

}

function balanceOf (address tokenOwner) public view returns (uint balance) {

saldi di ritorno [tokenOwner];

}

function allowance (address tokenOwner, address spender) public view returns (uint rimanenti) {

restituzione consentita [tokenOwner] [spender];

}

function approve (address spender, uint tokens) public returns (bool success) {

consentito [msg.sender] [spender] = token;

emettere approvazione (msg.sender, spender, token);

restituire vero;

}

function transfer (address to, uint tokens) public returns (bool success) {

saldi [msg.sender] = safeSub (saldi [msg.sender], token);

saldi [a] = safeAdd (saldi [a], gettoni);

emettere Transfer (msg.sender, to, token);

restituire vero;

}

function transferFrom (address from, address to, uint tokens) public returns (bool success) {

saldi [da] = safeSub (saldi [da], token);

consentito [da] [msg.sender] = safeSub (consentito [da] [msg.sender], token);

saldi [a] = safeAdd (saldi [a], gettoni);

emettere Transfer (da, a, token);

restituire vero;

}

}

Congratulazioni! Hai sviluppato con successo il tuo token Ethereum.

L’ultimo passaggio è l’implementazione nella rete effettiva.

Distribuzione del tuo token

Per fare ciò, avremo bisogno del portafoglio Metamask.

Metamask è un’estensione che ti consente di eseguire le dApp Ethereum direttamente nel tuo browser senza eseguire un nodo Ethereum completo.

Vai a https://metamask.io/ dal tuo browser (Chrome, Firefox o Opera) e aggiungilo.

Crea un nuovo portafoglio in MetaMask

Quando l’estensione è installata, fai clic sull’icona nell’angolo in alto a destra del browser per iniziare a creare un portafoglio.

Leggi e accetta i termini, quindi inserisci una password complessa e fai clic su “Crea”.

Vedrai una frase seme di 12 parole. Salva le parole seme come file o copiale in un posto sicuro e fai clic su “L’ho copiato da qualche parte al sicuro”.

Ora hai creato con successo un account in MetaMask con un nuovo indirizzo di portafoglio!

Noterai che attualmente hai 0 ETH nel tuo portafoglio. Per implementare il contratto sulla rete Ethereum è necessaria una certa quantità di Ether. Non distribuiremo il nostro contratto alla rete principale poiché questa è solo una demo.

Pubblicheremo questo contratto sulla rete di test. In realtà ci sono alcune testnet blockchain di Ethereum: Ropsten, Rinkeby, Kovan …

Usiamo Ropsten per questo esempio.

Per prima cosa hai bisogno di Ether, giusto? Sulla rete di test lavoriamo con falsi eteri gratuiti. Uno ha solo bisogno di rivendicare alcuni di quelli da Faucet.

Vai a: https://faucet.ropsten.be/ , incolla l’indirizzo del tuo portafoglio e fai clic su “Inviami ether di prova”.

Dopo un paio di secondi, vedrai un po ‘di ETH nel tuo portafoglio.

Metterlo in diretta

Ora è il momento di far vivere tutto!

Vai a Remix IDE e compila il contratto. Se non ci sono errori, siamo pronti per l’implementazione.

Per l’ambiente selezionare Injected Web3. Rileverà automaticamente il tuo portafoglio metamask.

Premi il pulsante Distribuisci.

Metamask ora ti chiederà di prelevare alcuni fondi dal tuo portafoglio per acquistare questa transazione.

Confermare che. Quindi torna a Remix IDE e presta attenzione al terminale. Vediamo che la transazione ha avuto successo.

Come risultato abbiamo Transaction hash. Fare clic sull’URI dal terminale che assomiglia a: ropsten.etherscan.io/

Ci guiderà verso etherscan.io – questo è Ethereum Blockchain explorer e qui puoi tenere traccia di tutto ciò che accade sulle reti principali e di test, perché ovviamente tutto è pubblico su blockchain.

Quando andremo a questo uri vedremo i dettagli sulla nostra transazione. Fare clic sull’hash del contratto per esplorare di più.

Tutto è pubblico sulla blockchain, anche il nostro codice. Gli sviluppatori Solidity non hanno spazio per gli errori!

Clicca sul scheda contratto e vedrai il nostro bytecode compilato

Ora puoi andare su Token Tracer per vedere i dettagli del nostro Token Blockonomi. Puoi vedere 3 regole opzionali che abbiamo definito in precedenza.

Ora controlla il tuo portafoglio. Vedrai che l’Ether che abbiamo pagato per la distribuzione del contratto intelligente su Ropsten è stato rimosso.

Conclusione

Questo conclude il nostro tutorial, seguendo questi passaggi e i nostri esempi di codice dovresti essere in grado di distribuire il tuo token Ethereum ERC-20.

Divertiti!

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me