Creeu un testimoni ERC-20

Aquest és el nostre segon tutorial de Solidity, si us ho heu perdut, mireu la nostra Introducció a Solidity, on us expliquem alguns aspectes bàsics d’aquest llenguatge de programació per a la cadena de blocs d’Ethereum..

Us expliquem una mica com funciona Solidity, com està estructurada i us comencem amb un codi senzill per escriure un contracte intel·ligent “Hello World”.

En aquest tutorial aprofundim i us ensenyem el codi per desplegar el vostre propi testimoni Ethereum ERC-20. (Aquí teniu el nostre Token Blockonomi ).

Ethereum & El boom ICO

ICO significa Initial Coin Offering i és un tipus de finançament que utilitza criptomonedes. En una ICO, es ven una quantitat de criptomoneda en forma de “fitxes” (“monedes”) a especuladors o inversors, a canvi de moneda legal o altres criptomonedes com Bitcoin o Ethereum.

Les fitxes venudes es promocionen com a futures unitats de moneda funcionals si es compleix o no l’objectiu de finançament de l’ICO i es posa en marxa el projecte.

Ja hem parlat de com els contractes intel·ligents van obrir un món completament nou perquè els desenvolupadors poguessin crear i innovar. Tanmateix, aquests desenvolupadors necessitaven una manera de finançar els seus projectes.

I la solució va ser l’ICO.

El 2017, les ICO estaven en auge: cada dia apareixien innombrables projectes amb promeses salvatges del que volien aconseguir i els inversors les abandonaven..

Des de llavors, les coses s’han calmat a mesura que l’espai ha madurat i els inversors han desaparegut, molts ICO no han pogut complir el que s’havia promès, però això és una història per a un altre missatge: som aquí per discutir el vessant tècnic.

Què és un testimoni?

Els tokens són essencialment contractes intel·ligents que viuen a Ethereum Blockchain, que poden tenir usos i finalitats.

Un testimoni no es limita a un rol concret. Pot complir molts rols en el seu ecosistema natiu. Aquí teniu la llista d’alguns rols que poden tenir els tokens.

  • Peatge: Un testimoni pot actuar com una porta d’entrada a un Dapp. Bàsicament, per accedir al Dapp, haureu de mantenir les fitxes.
  • Drets de vot: Les fitxes també poden qualificar els titulars per tenir determinats drets de vot. Penseu en EOS: mantenir els tokens EOS us permetrà votar pels productors de blocs. EOS Blockchain pretén convertir-se en un sistema operatiu descentralitzat que pugui donar suport a aplicacions descentralitzades a escala industrial.
  • Intercanvi de valor: Aquest és un dels rols més comuns de les fitxes dins de l’ecosistema. Les fitxes poden ajudar a crear un sistema econòmic intern dins de l’aplicació.
  • Millora de l’experiència d’usuari: El testimoni també pot permetre als titulars enriquir l’experiència de l’usuari dins dels límits de l’entorn concret. Per exemple. A Brave (un navegador web), els titulars de BAT (tokens utilitzats a Brave) obtindran els drets per enriquir l’experiència del client mitjançant els seus tokens per afegir anuncis o altres serveis basats en l’atenció a la plataforma Brave.
  • Moneda: Es pot utilitzar com a emmagatzematge de valor que es pot utilitzar per dur a terme transaccions dins i fora de l’ecosistema donat.

Què és ERC-20?

ERC-20 és un estàndard tècnic que s’utilitza per a contractes intel·ligents a la cadena de blocs d’Ethereum per implementar tokens. La majoria de les fitxes emeses a la cadena de blocs d’Ethereum compleixen ERC-20.

ERC-20 és un estàndard de protocol que defineix certes regles i estàndards per a l’emissió de tokens a la xarxa d’Ethereum. A “ERC-20”, ERC significa Ethereum Request for Comments (Sol·licitud de comentaris d’Ethereum) i 20 significa un número d’identificació únic per distingir aquest estàndard d’altres..

Per simplificar-ho, ERC-20 és una guia de normes i regulacions que ajudarà a crear un pla per als contractes intel·ligents basats en Ethereum per crear els seus tokens..

Un testimoni a Ethereum és bàsicament només un contracte intel·ligent que segueix algunes regles comunes, és a dir, implementa un conjunt estàndard de funcions que comparteixen tots els altres contractes de tokens, com transferFrom (address _from, address _to, uint256 _tokenId) i balanceOf (address _owner).

Així, bàsicament, un testimoni és només un contracte que fa un seguiment de qui posseeix la quantitat d’aquest testimoni i algunes funcions perquè aquests usuaris puguin transferir els seus testimonis a altres adreces..

Per què l’estàndard ERC-20 és tan important?

Com que tots els tokens ERC-20 comparteixen el mateix conjunt de funcions amb els mateixos noms, es pot interactuar amb tots de la mateixa manera.

Això vol dir que si creeu una aplicació capaç d’interactuar amb un testimoni ERC-20, també pot interactuar amb qualsevol testimoni ERC-20. D’aquesta manera, es poden afegir fàcilment més fitxes a la vostra aplicació en el futur sense necessitat de tenir un codi personalitzat. Simplement podeu connectar la nova adreça del contracte de token i, boom, la vostra aplicació té un altre testimoni que pot utilitzar.

Un exemple d’això seria un intercanvi. Quan un intercanvi afegeix un nou testimoni ERC-20, realment només cal afegir un altre contracte intel·ligent amb el qual parla. Els usuaris poden indicar a aquest contracte que envien els tokens a l’adreça de la cartera de l’intercanvi i l’intercanvi pot dir-li al contracte que enviï els tokens als usuaris quan sol·licitin una retirada..

L’intercanvi només ha d’implementar aquesta lògica de transferència una vegada, i quan vulgui afegir un nou testimoni ERC-20, només es tracta d’afegir la nova adreça del contracte a la seva base de dades..

Comencem a crear un testimoni

Utilitzarem Remix IDE per desenvolupar Smart Contract per al nostre testimoni ERC-20.

Remix és una eina en línia que us permet escriure un contracte intel·ligent Solidity, desplegar-lo i executar-lo.

Només cal anar a https://remix.ethereum.org des del vostre navegador i podem començar a codificar.

Feu clic al botó Solidity i després al botó Plus a l’extrem superior esquerre.

Li posaré el nom de “BlockonomiToken”, podeu triar el nom que vulgueu per a la vostra pròpia criptomoneda.

Bonic, tot està configurat ara.

Regles del testimoni ERC-20

Els tokens ERC-20 segueixen una llista de regles perquè es puguin compartir, canviar per altres tokens o transferir-los a una cartera criptogràfica..

L’estàndard ERC20 consta de 3 regles opcionals i 6 regles obligatòries.

Per dir-ho en termes normals, si incloeu determinades funcions al contracte intel·ligent del testimoni, compliu ERC20. Si no incloeu les funcions obligatòries, no sou ERC20.

Les normes obligatòries són les següents:

  1. oferta total
  2. equilibriOf
  3. transferència
  4. transferènciaDes de
  5. aprovar
  6. bonificació

D’altra banda, les regles opcionals són:

  1. Nom del testimoni
  2. Símbol
  3. Decimal (fins a 18)

És pràctica habitual definir aquestes regles a la interfície. Realment no hi ha una cosa que s’anomeni interfície a Solidity, sinó un contracte intel·ligent més. Per sort, es poden heretar els contractes intel·ligents en llenguatge de programació Solidity.

Herència en solidesa

A Solidity, l’herència és bastant similar als llenguatges de programació d’objectes orientats clàssicament. Primer escrivireu el contracte base i direu que el contracte nou heretarà del contracte base.

contracte IBank {

// codi de contracte base…

}

contract Bank és IBank {

// codi de contracte heretat…

}

També heu de saber que Solidity admet herències múltiples copiant el codi, inclòs el polimorfisme.

Totes les trucades a funcions són virtuals, el que significa que es crida a la funció més derivada, tret que es doni explícitament el nom del contracte.

Quan un contracte hereta de diversos contractes, només es crea un únic contracte a la cadena de blocs i el codi de tots els contractes base es copia al contracte creat..

Tornem al nostre testimoni ERC-20. Tenim regles obligatòries per tal de crear el testimoni ERC-20.

Les definirem com a 6 funcions i les escriurem a la interfície. Aleshores, el contracte del nostre testimoni heretarà aquesta interfície de trucada.

El vostre codi haurà de ser així.

contracte ERC20Interface {

funció totalSupply ()

públic

vista

retorna (uint);

funció balanceOf (adreça tokenOwner)

públic

vista

rendibilitats (saldo inicial);

bonificació de la funció

(adreça de propietari del testimoni, adreça de despesa)

públic

vista

retorna (us queda);

transferència de funció (adreça a, tokens uint) pública

retorna (èxit boolè);

funció aprovar (adreçar despeses, fitxes uint) públics

retorna (èxit boolè);

transferència de funcions Des de

(adreça de, adreça a, fitxes uint) pública

retorna (èxit boolè);

Transferència d’esdeveniments (adreça indexada des, adreça indexada a, tokens uint);

Aprovació d’esdeveniments (adreça indexada tokenOwner, adreça despesa indexada, fitxes uint);

}

Contracte de token

Creem el nostre contracte simbòlic. Tipus contracte {}

Ara passarem per 3 regles opcionals.

Tot i que no és necessari posar un nom a les vostres fitxes, encara és important donar-li una identitat.

A continuació tenim símbols. Simplement no podem subestimar la seva importància. Un símbol enganxós ajuda a millorar la marca.

Finalment, tenim la divisibilitat que ens ajudarà a determinar el valor més baix possible del testimoni. Una divisibilitat de 0 significarà que el valor més baix del testimoni és 1. En canvi, una divisibilitat de 2 significa que el seu valor més baix serà 0,01. El nombre màxim màxim de decimals permès és de 18. El valor predeterminat suggerit és de 18 decimals. Eviteu canviar-lo

Definim-los i inicialitzem-los al constructor.

contracte BlockonomiToken és ERC20Interface {

nom públic de la cadena;

símbol públic de cadena;

uint8 decimals públics;

constructor () públic {

nom = "BlockonomiToken";

símbol = "BKM";

decimals = 18;

}

}

El nostre testimoni també ha de tenir un subministrament inicial i un registre de tots els saldos. Podem emmagatzemar aquesta informació en matriu.

Al constructor inicialitzarem el nostre contracte amb les fitxes de subministrament inicials al creador del contracte (és a dir msg.sender). Afegiu aquestes línies al nostre codi i discutirem el propòsit de totes elles.

contracte BlockonomiToken és ERC20Interface {

nom públic de la cadena;

símbol públic de cadena;

uint8 decimals públics;

uint256 public _totalSupply;

mapatge (adreça => uint) saldos;

mapatge (adreça => mapatge (adreça => uint)) permès;

constructor () públic {

nom = "BlockonomiToken";

símbol = "BKM";

decimals = 18;

_totalSupply = 10000000000000000000000000000;

balances [msg.sender] = _totalSupply;

emetre Transferència (adreça (0), msg.sender, _totalSupply);

}

}

Tipus de dades de solidesa

Com podeu veure, _totalSupply té un uint256 tipus de dades i decimals uint8.

La solidesa és un llenguatge de tipus estàtic, el que significa que cal especificar el tipus de cada variable (estatal i local) en temps de compilació. Solidity proporciona diversos tipus elementals que es poden combinar per formar tipus complexos.

Parlem sobre el tipus d’enters per ara.

Els nombres enters poden ser int o bé uint: Nombres enters signats i sense signar de diverses mides. Si coneixeu la teoria de la informàtica o coneixeu la diferència entre enters signats i no signats en llenguatge C, tot és absolutament igual a Solidity.

Si no ho és, només ho podem dir un sense signar és un nombre enter que mai no pot ser negatiu! El signat, en canvi, pot ser negatiu i positiu, però només utilitzarem unitats al nostre contracte.

Paraules clau uint8 a uint256 en passos de 8 (sense signar de 8 fins a 256 bits) i int8 a int256. uint i int són àlies de uint256 i int256, respectivament.

Hem parlat que emmagatzemarem els saldos en algun tipus de matriu. Bé, la millor solució és utilitzar taules de hash o en mapes Solidity.

Bàsicament mapem adreça (també és un tipus de dades) a uint.

msg.sender (adreça): remitent del missatge (trucada actual)

msg.sender serà la persona que actualment està connectant amb el contracte.

Més endavant, probablement us ocupareu de contractes relacionats amb contractes. En aquest cas, el contracte que crea la trucada seria el msg.sender.

Mapes

Els tipus de mapatge es declaren com a cartografia(_KeyType => _ValueType). Aquí _KeyType pot ser gairebé qualsevol tipus excepte un mapatge, una matriu de mida dinàmica, un contracte, un enum i una struct. _ValueType en realitat pot ser qualsevol tipus, incloses les assignacions.

Les assignacions es poden veure com a taules de hash pràcticament inicialitzades de manera que existeixen totes les claus possibles i s’assignen a un valor la representació de bytes de la qual són tots zeros: el valor per defecte d’un tipus. Tot i així, la similitud acaba aquí: les dades clau no s’emmagatzemen realment en un mapatge, només s’utilitza el seu hash keccak256 per buscar el valor.

A causa d’això, les assignacions no tenen una longitud ni un concepte de clau o valor que s’estableixi.

Les assignacions només es permeten per a variables d’estat (o com a tipus de referència d’emmagatzematge en funcions internes).

És possible marcar mapes com a públics i fer que Solidity creï un getter. El _KeyType es convertirà en un paràmetre obligatori per al getter i retornarà el _ValueType.

El _ValueType també pot ser un mapatge. El getter tindrà un paràmetre per a cada _KeyType, recursivament.

Esdeveniments

La cadena de blocs és una llista de blocs que fonamentalment són llistes de transaccions. Cada transacció té un rebut adjunt que conté zero o més entrades de registre. Les entrades de registre representen el resultat d’esdeveniments desencadenats d’un contracte intel·ligent.

Al codi font Solidity, per definir un esdeveniment, el marqueu així precedint-lo amb el fitxer esdeveniment paraula clau (d’ús similar a la funció paraula clau). Y

A continuació, crideu o activeu l’esdeveniment al cos de la funció que vulgueu provocar per generar l’esdeveniment. (Dubto que hi hagi una redacció estàndard). Podeu activar esdeveniments des de qualsevol funció mitjançant el fitxer emetre paraula clau.

Interfície ERC-20

Implantem ara la interfície ERC-20. Per fer-ho, hem d’escriure codi per a totes les nostres funcions obligatòries.

1. oferta total

Identifica el nombre total de fitxes ERC-20 creades. L’objectiu d’aquest mètode és determinar el nombre total de fitxes que floten al voltant de l’ecosistema.

funció totalSupply ()

públic

vista

retorna (uint)

{

return _totalSupply – saldos [adreça (0)];

}

2. equilibriOf 

Retorna el nombre de fitxes que una adreça concreta, en aquest cas, el propietari del contracte, té al seu compte.

funció balanceOf (adreça tokenOwner)

públic

vista

devolucions (saldo inicial)

{

saldos de devolució [tokenOwner];

}

3. bonificació

Per realitzar una transacció, una de les dades més importants que hauria de conèixer el contracte és el saldo de l’usuari. Al cap i a la fi, l’usuari hauria de tenir la quantitat mínima de fitxes necessàries per fer la transacció.

Per això, el contracte ERC-20 també inclou la funció de bonificació (). Si l’usuari no té el nombre mínim requerit de fitxes, la funció cancel·la la transacció.

bonificació de la funció

(adreça token Propietari, adreça despesa)

públic

vista

retorna (us queda)

{

retorn permès [propietari de fitxes] [gastador];

}

4. aprovar

Un cop comprovat el saldo, el propietari del contracte pot donar el seu vistiplau a l’usuari per recollir el nombre requerit de fitxes a l’adreça del contracte..

La funció d’aprovació també comprova la transacció amb el subministrament total de fitxes per assegurar-se que no en falti ni n’hi hagi de més.

En altres paraules, assegura que la falsificació és impossible.

funció aprovar (adreça de despesa, fitxes uint) pública

torna

(èxit bool)

{

permès [msg.sender] [spender] = fitxes;

emetre aprovació (msg.sender, spender, tokens);

tornar cert;}

Biblioteca matemàtica segura

Per implementar correctament dues funcions restants, necessitem Safe Math Library.

Embalatges de biblioteca matemàtica segurs sobre les operacions aritmètiques de Solidity amb comprovacions de desbordament afegides.

Operacions aritmètiques a Solidity wrap on overflow. Això pot provocar fàcilment errors, perquè els programadors solen suposar que un desbordament provoca un error, que és el comportament estàndard dels llenguatges de programació d’alt nivell..

Safe Math restaura aquesta intuïció revertint la transacció quan es desborda una operació.

L’ús d’aquesta biblioteca en lloc de les operacions sense comprovar elimina tota una classe d’errors, de manera que es recomana utilitzar-la sempre.

Tot el que hem de fer ara és copiar aquest codi per sobre del nostre contracte i després heretar-lo.

contracte SafeMath {

function safeAdd (uint a, uint b) rendiments purs públics (uint c) {

c = a + b;

requerir (c >= a);

}

function safeSub (uint a, uint b) rendiments públics purs (uint c) {

requerir (b <= a); c = a – b; } function safeMul (uint a, uint b) rendiments públics purs (uint c) {c = a * b; require (a == 0 || c / a == b); } function safeDiv (uint a, uint b) rendiments purs públics (uint c) {require (b > 0);

c = a / b;

}

}

No oblideu heretar-lo.

contracte BlockonomiToken és ERC20Interface, SafeMath

5. transferència

Per tant, ara que s’ha fet tota la comprovació i el contracte sap que l’usuari té la quantitat necessària de fitxes necessàries per complir la transacció, el propietari del contracte els pot enviar fitxes mitjançant la funció transfer ().

Aquesta funció permet al propietari del contracte enviar una quantitat determinada del testimoni a una altra adreça de la mateixa manera que una transacció de criptomoneda convencional. Permet transferir un nombre determinat de tokens del subministrament total a un compte d’usuari..

transferència de funcions (adreça a, tokens uint)

públic

retorna (èxit boolè)

{

balances [msg.sender] = safeSub (saldos [msg.sender], fitxes);

saldos [a] = safeAdd (saldos [a], fitxes);

emetre Transferència (msg.sender, to, tokens);

tornar cert;

}

6. transferFrom

Ja hem cobert la funció de transferència, per què en tenim una altra??

Donem un exemple per veure per què TransferFrom és una addició tan brillant al contracte ERC20.

Tots hem de pagar una quantitat de diners cada mes com un rellotge. Pot ser el vostre lloguer, les factures, etc. Realment no cal que pagueu tots aquests imports directament. Sempre podeu configurar un sistema de pagament automàtic amb els vostres bancs per encarregar-vos d’aquests pagaments.

Això és el que us permet fer TransferFrom (). Us ajuda a automatitzar les transferències de pagaments a un compte específic.

transferència de funcions Des de

(adreça de, adreça a, fitxes uint)

públic

retorna (èxit boolè)

{

saldos [de] = safeSub (saldos [de], fitxes);

permès [de] [msg.sender] = safeSub (permès [de] [msg.sender], fitxes);

saldos [a] = safeAdd (saldos [a], fitxes);

emetre Transferència (de, a, fitxes);

tornar cert;

}

El codi complet

Aquí teniu el codi complet del nostre testimoni Blockonomi.

solidesa del pragma ^ 0,5,0;

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

// Interfície ERC Token Standard # 20

//

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

contracte ERC20Interface {

function totalSupply () retorna la vista pública (uint);

funció balanceOf (address tokenOwner) retorna la vista pública (saldo uint);

assignació de funcions (adreça tokenOwner, address spender) retorna la vista pública (no queda);

transferències de funcions (adreça a, tokens uint) retorns públics (èxit boolè);

aprovació de la funció (despesa d’adreça, fitxes uint) declaracions públiques (èxit boolè);

function transferFrom (adreça de, adreça a, tokens uint) retorns públics (èxit boolè);

Transferència d’esdeveniments (adreça indexada des, adreça indexada a, tokens uint);

Aprovació de l’esdeveniment (adreça indexada tokenOwner, adreça despesa indexada, fitxes uint);

}

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

// Biblioteca matemàtica segura

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

contracte SafeMath {

function safeAdd (uint a, uint b) rendiments purs públics (uint c) {

c = a + b;

requerir (c >= a);

}

function safeSub (uint a, uint b) rendiments públics purs (uint c) {

requerir (b <= a); c = a – b; } function safeMul (uint a, uint b) rendiments públics purs (uint c) {c = a * b; require (a == 0 || c / a == b); } function safeDiv (uint a, uint b) rendiments purs públics (uint c) {require (b > 0);

c = a / b;

}

}

contracte BlockonomiToken és ERC20Interface, SafeMath {

nom públic de la cadena;

símbol públic de cadena;

uint8 decimals públics; // 18 decimals és el valor per defecte fortament suggerit; eviteu canviar-lo

uint256 public _totalSupply;

mapatge (adreça => uint) saldos;

mapatge (adreça => mapatge (adreça => uint)) permès;

/ **

* Funció Constrctor

*

* Inicialitza el contracte amb les fitxes de subministrament inicials al creador del contracte

* /

constructor () públic {

nom = "BlockonomiToken";

símbol = "BKM";

decimals = 18;

_totalSupply = 10000000000000000000000000000;

saldos [msg.sender] = _totalSupply;

emetre Transferència (adreça (0), msg.sender, _totalSupply);

}

function totalSupply () retorna la vista pública (uint) {

return _totalSupply – saldos [adreça (0)];

}

funció balanceOf (address tokenOwner) retorna la vista pública (saldo uint) {

saldos de devolució [tokenOwner];

}

assignació de funció (propietari de la fitxa d’adreça, despesa de l’adreça) retorna la visualització pública (us queda) {

retorn permès [propietari de fitxes] [gastador];

}

aprovació de la funció (despesa d’adreça, fitxes uint) declaracions públiques (èxit boolè) {

permès [msg.sender] [spender] = fitxes;

emetre aprovació (msg.sender, spender, tokens);

tornar cert;

}

transferències de funcions (adreça a, tokens uint) retorns públics (èxit boolè) {

balances [msg.sender] = safeSub (saldos [msg.sender], fitxes);

saldos [a] = safeAdd (saldos [a], fitxes);

emetre Transferència (msg.sender, to, tokens);

tornar cert;

}

funció transferFrom (adreça de, adreça a, fitxes uint) retorns públics (èxit boolè) {

saldos [de] = safeSub (saldos [de], fitxes);

permès [de] [msg.sender] = safeSub (permès [de] [msg.sender], fitxes);

saldos [a] = safeAdd (saldos [a], fitxes);

emetre Transferència (de, a, fitxes);

tornar cert;

}

}

Enhorabona! Heu desenvolupat amb èxit el vostre propi testimoni ethereum.

L’últim pas és el desplegament a la xarxa real.

Desplegament del vostre testimoni

Per fer-ho, necessitarem una cartera Metamask.

Metamask és una extensió que us permet executar Ethereum dApps directament al navegador sense executar un node Ethereum complet.

Anar a https://metamask.io/ des del navegador (Chrome, Firefox o Opera) i afegiu-lo.

Creeu una cartera nova a MetaMask

Quan estigui instal·lada l’extensió, feu clic a la icona de l’extrem superior dret del navegador per començar a crear una cartera.

Llegiu i accepteu els termes, introduïu una contrasenya segura i feu clic a “Crea”.

Veureu una frase llavor de 12 paraules. Deseu les paraules inicials com a fitxer o copieu-les en un lloc segur i feu clic a “L’he copiat en algun lloc segur”.

Ara heu creat amb èxit un compte a MetaMask amb una nova adreça de cartera!

Notareu que actualment teniu 0 ETH a la cartera. Per desplegar un contracte a la xarxa Ethereum, cal una mica d’Eter. No desplegarem el nostre contracte a la xarxa principal, ja que només és una demostració.

Publicarem aquest contracte a la xarxa de proves. En realitat, hi ha algunes proves de cadenes de blocs d’Ethereum: Ropsten, Rinkeby, Kovan …

Utilitzem Ropsten per a aquest exemple.

Primer necessiteu una mica d’èter, oi? A la xarxa de proves treballem amb èters gratuïts falsos. Només cal reivindicar alguns dels de Faucet.

Anar a: https://faucet.ropsten.be/ , enganxeu l’adreça de la cartera i feu clic a “Envia’m l’èter de prova”.

Al cap d’un parell de segons, veureu una mica d’ETH a la cartera.

Posant-lo en directe

Ara toca que tot sigui viu!

Aneu a Remix IDE i compileu el contracte. Si no hi ha errors, estem preparats per al desplegament.

Per a l’entorn, seleccioneu Injected Web3. Detectarà automàticament la cartera de metamascada.

Feu clic al botó Desplega.

Ara Metamask us demanarà que retireu alguns fons de la cartera per poder comprar aquesta transacció.

Confirmeu-ho. A continuació, torneu a Remix IDE i presteu atenció al terminal. Veiem que la transacció ha estat satisfactòria.

Com a resultat, obtenim hash de transaccions. Feu clic a l’uri des del terminal que té el següent aspecte: ropsten.etherscan.io/

Ens desplaçarà fins a etherscan.io – això és Ethereum Blockchain Explorer i aquí podeu fer un seguiment de tot el que passa a les xarxes principals i de prova, perquè, per descomptat, tot és públic a blockchain.

Quan anem a aquest uri, veurem detalls sobre la nostra transacció. Feu clic al hash del contracte per explorar més.

Tot és públic a la cadena de blocs, fins i tot al nostre codi. Els desenvolupadors de Solidity no tenen espai per als errors!

Feu clic al botó fitxa de contracte i veureu el nostre bytecode compilat

Ara podeu anar a Token Tracer per veure els detalls del nostre Token Blockonomi. Podeu veure 3 regles opcionals que hem definit anteriorment.

Ara reviseu la cartera. Veureu que s’ha eliminat l’Eter que pagàvem per desplegar el contracte intel·ligent a Ropsten.

Conclusió

Això completa el nostre tutorial, si seguiu aquests passos i els nostres exemples de codi, hauríeu de ser capaç de desplegar el vostre propi testimoni Ethereum ERC-20..

Diverteix-te!

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