Crie um token ERC-20

Este é o nosso segundo tutorial do Solidity, se você perdeu, dê uma olhada em nossa Introdução ao Solidity, onde o orientamos através de alguns fundamentos desta linguagem de programação para o blockchain Ethereum.

Explicamos um pouco sobre como o Solidity funciona, como é estruturado e começamos com um código simples para escrever um contrato inteligente “Hello World”.

Neste tutorial, aprofundamos e ensinamos o código para implantar seu próprio token Ethereum ERC-20. (Aqui está o nosso Token Blockonomi ).

Ethereum & O Boom da ICO

ICO significa Oferta Inicial de Moedas e é um tipo de financiamento que usa criptomoedas. Em um ICO, uma quantidade de criptomoeda é vendida na forma de “tokens” (“moedas”) para especuladores ou investidores, em troca de curso legal ou outras criptomoedas, como Bitcoin ou Ethereum.

Os tokens vendidos são promovidos como unidades funcionais futuras de moeda se ou quando a meta de financiamento da OIC for atingida e o projeto for lançado.

Já falamos como os contratos inteligentes abriram um mundo totalmente novo para os desenvolvedores criarem e inovarem. No entanto, esses desenvolvedores precisavam de uma maneira de financiar seus projetos.

E a solução foi o ICO.

Em 2017, os ICOs estavam crescendo – incontáveis ​​projetos surgiam todos os dias com promessas incríveis do que eles queriam alcançar, e os investidores os absorveram.

Desde então, as coisas se acalmaram à medida que o espaço amadureceu e os investidores desapareceram, muitos ICOs não cumpriram o que foi prometido, mas isso é assunto para outro post – estamos aqui para discutir o lado técnico.

O que é um token?

Os tokens são contratos essencialmente inteligentes que vivem no Ethereum Blockchain, eles podem ter vários usos e propósitos.

Um token não se limita a uma função específica. Ele pode cumprir várias funções em seu ecossistema nativo. Aqui está a lista de algumas funções que os tokens podem desempenhar.

  • Pedágio: Um token pode atuar como um gateway para um Dapp. Basicamente, para acessar o Dapp, você precisará manter os tokens.
  • Direito a voto: Os tokens também podem qualificar os detentores de determinados direitos de voto. Pense em EOS, ter tokens EOS permitirá que você vote em produtores de blocos. O EOS Blockchain tem como objetivo se tornar um sistema operacional descentralizado que pode suportar aplicativos descentralizados em escala industrial.
  • Troca de valor: Esta é uma das funções mais comuns dos tokens no ecossistema. Os tokens podem ajudar a criar um sistema econômico interno dentro do aplicativo.
  • Aprimoramento da experiência do usuário: O token também pode permitir aos proprietários enriquecer a experiência do usuário dentro dos limites de um ambiente específico. Por exemplo. No Brave (um navegador da web), os detentores de BAT (tokens usados ​​no Brave) terão o direito de enriquecer a experiência do cliente usando seus tokens para adicionar anúncios ou outros serviços baseados em atenção na plataforma Brave.
  • Moeda: Pode ser usado como uma reserva de valor que pode ser usado para realizar transações dentro e fora de um determinado ecossistema.

O que é ERC-20?

ERC-20 é um padrão técnico usado para contratos inteligentes no blockchain Ethereum para a implementação de tokens. A maioria dos tokens emitidos na blockchain Ethereum são compatíveis com ERC-20.

ERC-20 é um protocolo padrão que define certas regras e padrões para a emissão de tokens na rede da Ethereum. Em ‘ERC-20’, ERC significa Ethereum Request For Comments e 20 significa um número de ID exclusivo para distinguir este padrão de outros.

Para simplificar, ERC-20 é um guia de regras e regulamentos que ajudará a criar um plano para contratos inteligentes baseados em Ethereum para criar seus tokens.

Um token no Ethereum é basicamente um contrato inteligente que segue algumas regras comuns – ou seja, implementa um conjunto padrão de funções que todos os outros contratos de token compartilham, como transferFrom (endereço _from, endereço _to, uint256 _tokenId) e balanceOf (endereço _owner).

Basicamente, um token é apenas um contrato que controla quem é o proprietário de quanto desse token e algumas funções para que os usuários possam transferir seus tokens para outros endereços.

Por que o padrão ERC-20 é tão importante?

Uma vez que todos os tokens ERC-20 compartilham o mesmo conjunto de funções com os mesmos nomes, eles podem interagir da mesma forma.

Isso significa que, se você criar um aplicativo capaz de interagir com um token ERC-20, também será capaz de interagir com qualquer token ERC-20. Dessa forma, mais tokens podem ser facilmente adicionados ao seu aplicativo no futuro, sem a necessidade de codificação personalizada. Você poderia simplesmente inserir o novo endereço de contrato de token e, bum, seu aplicativo tem outro token que pode usar.

Um exemplo disso seria uma troca. Quando uma troca adiciona um novo token ERC-20, na verdade, ela só precisa adicionar outro contrato inteligente com o qual conversar. Os usuários podem dizer a esse contrato para enviar tokens para o endereço da carteira da bolsa, e a bolsa pode dizer ao contrato para enviar os tokens de volta aos usuários quando eles solicitarem um saque.

A troca só precisa implementar essa lógica de transferência uma vez, então, quando quiser adicionar um novo token ERC-20, é simplesmente uma questão de adicionar o novo endereço de contrato ao seu banco de dados.

Vamos começar a criar um token

Usaremos Remix IDE para desenvolver um contrato inteligente para nosso token ERC-20.

Remix é uma ferramenta online que permite que você escreva um contrato inteligente Solidity, em seguida, implante-o e execute-o.

Apenas vá para https://remix.ethereum.org do seu navegador e podemos começar a codificar.

Clique no botão Solidity e, em seguida, no botão Plus no canto superior esquerdo.

Vou chamá-lo de “BlockonomiToken”, você pode escolher o nome que quiser para sua própria criptomoeda.

Legal, tudo está configurado agora.

Regras de token ERC-20

Os tokens ERC-20 seguem uma lista de regras para que possam ser compartilhados, trocados por outros tokens ou transferidos para uma cripto-carteira.

O padrão ERC20 consiste em 3 regras opcionais e 6 regras obrigatórias.

Para colocá-lo em termos gerais, se você incluir certas funções no contrato inteligente do token, você está em conformidade com ERC20. Se você não incluir as funções obrigatórias, você não é ERC20.

As regras obrigatórias são as seguintes:

  1. totalSupply
  2. equilíbrio de
  3. transferir
  4. transferir de
  5. aprovar
  6. abono

Por outro lado, as regras opcionais são:

  1. Nome do token
  2. Símbolo
  3. Decimal (até 18)

É prática comum definir essas regras na interface. Não há realmente algo chamado interface no Solidity, é apenas outro contrato inteligente. Felizmente, pode-se herdar Contratos Inteligentes na linguagem de programação Solidity.

Herança em Solididade

No Solidity, a herança é muito semelhante às linguagens clássicas de programação de objetos orientados. Primeiro, você escreverá seu contrato básico e dirá que seu novo contrato herdará do contrato básico.

contrato IBank {

// código do contrato base…

}

contrato Banco é IBank {

// código de contrato herdado…

}

Você também precisa saber que o Solidity oferece suporte a herança múltipla, copiando o código, incluindo polimorfismo.

Todas as chamadas de função são virtuais, o que significa que a função mais derivada é chamada, exceto quando o nome do contrato é fornecido explicitamente.

Quando um contrato herda de vários contratos, apenas um único contrato é criado no blockchain, e o código de todos os contratos base é copiado para o contrato criado.

Vamos voltar ao nosso token ERC-20. Temos regras obrigatórias para criar o token ERC-20.

Vamos defini-los como 6 funções e escrever na interface. Então, o contrato do nosso token de verdade herdará essa interface de chamada.

Seu código precisará ser assim.

contrato ERC20Interface {

função totalSupply ()

público

Visão

retorna (uint);

função balanceOf (endereço tokenOwner)

público

Visão

retorna (saldo uint);

subsídio de função

(endereço tokenOwner, endereço gastador)

público

Visão

retorna (uint restante);

transferência de função (endereço para, tokens uint) público

retorna (sucesso de bool);

aprovação de função (endereço de gastador, tokens uint) público

retorna (sucesso de bool);

função transferFrom

(endereço de, endereço para, tokens uint) público

retorna (sucesso de bool);

transferência de evento (endereço indexado de, endereço indexado para, tokens uint);

Aprovação de evento (tokenOwner indexado por endereço, spender indexado por endereço, tokens uint);

}

Contrato de Token

Vamos criar nosso contrato de token. Tipo contrato {}

Agora vamos passar por 3 regras opcionais.

Mesmo que não seja necessário nomear seus tokens, ainda é importante dar-lhes uma identidade.

A seguir, temos símbolos. Simplesmente não podemos subestimar sua importância. Um símbolo atraente ajuda a melhorar a marca.

Finalmente, temos a divisibilidade que nos ajudará a determinar o menor valor possível do token. Uma divisibilidade de 0 significa que o valor mais baixo do token é 1. Uma divisibilidade de 2, por outro lado, significa que seu valor mais baixo será 0,01. O número máximo de casas decimais permitido é 18. 18 decimais é o padrão fortemente sugerido, evite alterá-lo

Vamos defini-los e inicializar no construtor.

O contrato BlockonomiToken é ERC20Interface {

string public name;

símbolo público de string;

uint8 decimais públicos;

construtor () public {

nome = "BlockonomiToken";

símbolo = "BKM";

decimais = 18;

}

}

Nosso token também precisa ter um estoque inicial e algum registro de todos os saldos. Podemos armazenar essas informações na matriz.

No construtor, inicializaremos nosso contrato com tokens de fornecimento inicial para o criador do contrato (ou seja msg.sender) Adicione essas linhas ao nosso código e discutiremos o propósito de todas elas.

O contrato BlockonomiToken é ERC20Interface {

string public name;

símbolo público de string;

uint8 decimais públicos;

uint256 public _totalSupply;

mapeamento (endereço => uint) saldos;

mapeamento (endereço => mapeamento (endereço => uint)) permitido;

construtor () public {

nome = "BlockonomiToken";

símbolo = "BKM";

decimais = 18;

_totalSupply = 100000000000000000000000000;

saldos [msg.sender] = _totalSupply;

emitir Transfer (endereço (0), msg.sender, _totalSupply);

}

}

Tipos de dados de solidez

Como você pode ver, _totalSupply tem um uint256 tipo de dados e decimais uint8.

Solidity é uma linguagem estaticamente digitada, o que significa que o tipo de cada variável (estadual e local) precisa ser especificado em tempo de compilação. Solidity fornece vários tipos elementares que podem ser combinados para formar tipos complexos.

Vamos discutir sobre o tipo de inteiros por agora.

Inteiros podem ser int ou uint: Inteiros assinados e não assinados de vários tamanhos. Se você está familiarizado com a teoria da Ciência da Computação ou sabe a diferença entre inteiros com e sem sinal na linguagem C, tudo é absolutamente igual no Solidity.

Se não estiver, podemos apenas dizer que um sem sinal é um número inteiro que nunca pode ser negativo! Por outro lado, assinados podem ser negativos e positivos, mas usaremos apenas unidades em nosso contrato.

Palavras-chave uint8 a uint256 em etapas de 8 (sem sinal de 8 até 256 bits) e int8 a int256. uint e int são aliases para uint256 e int256, respectivamente.

Falamos que iremos armazenar saldos em algum tipo de array. Bem, a melhor solução é usar tabelas de hash, ou em mapeamentos Solidity.

Basicamente, nós mapeamos Morada (esse é o tipo de dados também) para uint.

msg.sender (endereço): remetente da mensagem (chamada atual)

msg.sender será a pessoa que atualmente se conecta com o contrato.

Mais tarde, você provavelmente lidará com contratos vinculados a contratos. Nesse caso, o contrato que está criando a chamada seria o msg.sender.

Mapeamentos

Os tipos de mapeamento são declarados como mapeamento(_Tipo de chave => _ValueType). Aqui _KeyType pode ser quase qualquer tipo, exceto para um mapeamento, uma matriz de tamanho dinâmico, um contrato, um enum e uma estrutura. _ValueType pode realmente ser qualquer tipo, incluindo mapeamentos.

Os mapeamentos podem ser vistos como tabelas hash que são virtualmente inicializadas de modo que todas as chaves possíveis existam e sejam mapeadas para um valor cuja representação de byte é toda zeros: o valor padrão de um tipo. A semelhança termina aqui, porém: os dados-chave não são realmente armazenados em um mapeamento, apenas seu hash keccak256 usado para pesquisar o valor.

Por causa disso, os mapeamentos não têm um comprimento ou conceito de uma chave ou valor sendo “definido”.

Os mapeamentos são permitidos apenas para variáveis ​​de estado (ou como tipos de referência de armazenamento em funções internas).

É possível marcar mapeamentos públicos e fazer com que o Solidity crie um getter. O _KeyType se tornará um parâmetro obrigatório para o getter e retornará _ValueType.

O _ValueType também pode ser um mapeamento. O getter terá um parâmetro para cada _KeyType, recursivamente.

Eventos

O blockchain é uma lista de blocos que são basicamente listas de transações. Cada transação tem um recibo anexado que contém zero ou mais entradas de log. As entradas de registro representam o resultado de eventos disparados de um contrato inteligente.

No código-fonte do Solidity, para definir um evento, você o marca, precedendo-o com o evento palavra-chave (semelhante em uso à palavra-chave de função). Y

Você então chama ou dispara o evento no corpo de qualquer função que você deseja fazer para gerar o evento. (Duvido que haja uma formulação padrão para isso). Você pode disparar eventos de qualquer função usando o emitir palavra chave.

Interface ERC-20

Vamos implementar a interface ERC-20 agora. Para fazer isso, precisamos escrever código para todas as nossas seis funções obrigatórias.

1. totalSupply

Identifica o número total de tokens ERC-20 criados. O objetivo deste método é determinar o número total de tokens flutuando ao redor do ecossistema.

função totalSupply ()

público

visualizar

retorna (uint)

{

return _totalSupply – saldos [endereço (0)];

}

2. balanceOf 

Retorna o número de tokens que um endereço específico, neste caso, o proprietário do contrato, tem em sua conta.

função balanceOf (endereço tokenOwner)

público

visualizar

retorna (saldo uint)

{

saldos de retorno [tokenOwner];

}

3. mesada

Para realizar uma transação um dos dados mais importantes que o contrato deve saber é o saldo do usuário. Afinal, o usuário deve ter a quantidade mínima de tokens necessária para fazer a transação.

É por isso que o contrato ERC-20 também inclui a função allowance (). Se o usuário não tiver o número mínimo necessário de tokens, a função cancela a transação.

subsídio de função

(endereço tokenOwner, endereço gastador)

público

visualizar

retorna (uint restante)

{

retorno permitido [tokenOwner] [spender];

}

4. aprovar

Depois que o saldo for verificado, o proprietário do contrato pode dar sua aprovação ao usuário para coletar o número necessário de tokens do endereço do contrato.

A função de aprovação também verifica a transação em relação ao fornecimento total de tokens para se certificar de que não há nenhum ausente ou extra.

Em outras palavras, garante que a falsificação seja impossível.

aprovação de função (endereço de gastador, tokens uint) público

retorna

(sucesso de bool)

{

permitido [msg.sender] [spender] = tokens;

emitir Aprovação (msg.sender, spender, tokens);

return true;}

Biblioteca de matemática segura

Para implementar corretamente as duas funções restantes, precisamos da Safe Math Library.

Wrappers da Safe Math Library sobre as operações aritméticas do Solidity com verificações de estouro adicionais.

Operações aritméticas em Solidity envolvem em overflow. Isso pode resultar facilmente em bugs, porque os programadores geralmente assumem que um estouro gera um erro, que é o comportamento padrão em linguagens de programação de alto nível.

O Safe Math restaura essa intuição, revertendo a transação quando uma operação estourou.

Usar esta biblioteca em vez das operações não verificadas elimina uma classe inteira de bugs, por isso é recomendado usá-la sempre.

Tudo o que precisamos fazer agora é copiar este código acima do nosso contrato e, em seguida, herdá-lo.

contrato SafeMath {

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

c = a + b;

requer (c >= a);

}

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

requer (b <= a); c = a – b; } function safeMul (uint a, uint b) retornos públicos puros (uint c) {c = a * b; requerem (a == 0 || c / a == b); } function safeDiv (uint a, uint b) retornos públicos puros (uint c) {require (b > 0);

c = a / b;

}

}

Não se esqueça de herdá-lo.

contrato BlockonomiToken é ERC20Interface, SafeMath

5. transferência

Então, agora que toda a verificação foi feita e o contrato sabe que o usuário tem a quantidade necessária de tokens para cumprir a transação, o proprietário do contrato pode enviar tokens para eles usando a função transfer ().

Esta função permite que o proprietário do contrato envie uma determinada quantidade do token para outro endereço, assim como uma transação de criptomoeda convencional., Permite que um certo número de tokens seja transferido do fornecimento total para uma conta de usuário.

transferência de função (endereço para, tokens uint)

público

retorna (sucesso de bool)

{

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

saldos [para] = safeAdd (saldos [para], tokens);

emitir Transfer (msg.sender, to, tokens);

return true;

}

6. transferFrom

Já cobrimos a função de transferência, por que temos outro?

Bem, vamos dar um exemplo para ver por que transferFrom é uma adição brilhante ao contrato ERC20.

Todos nós temos que pagar uma certa quantia de dinheiro todo mês como um relógio. Pode ser seu aluguel, as contas, etc. Você realmente não precisa pagar todas essas quantias sozinho. Você sempre pode configurar um sistema de pagamento automático com seus bancos para cuidar desses pagamentos.

Isso é o que transferFrom () permite que você faça. Ajuda a automatizar as transferências de pagamento para uma conta específica.

função transferFrom

(endereço de, endereço para, tokens uint)

público

retorna (sucesso de bool)

{

saldos [de] = SafeSub (saldos [de], tokens);

permitido [de] [msg.sender] = safeSub (permitido [de] [msg.sender], tokens);

saldos [para] = safeAdd (saldos [para], tokens);

emitir Transfer (de, para, tokens);

return true;

}

O código completo

Aqui está o código completo para nosso Token Blockonomi.

solidez do pragma ^ 0,5,0;

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

// Interface ERC Token Standard # 20

//

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

contrato ERC20Interface {

função totalSupply () retornos de exibição pública (uint);

função balanceOf (endereço tokenOwner) retornos de exibição pública (uint balance);

permissão de função (endereço tokenOwner, endereço gastador) retornos de exibição pública (uint restante);

transferência de função (endereço para, tokens uint) retornos públicos (sucesso de bool);

aprovar função (endereço spender, tokens uint) retornos públicos (sucesso de bool);

função transferFrom (endereço de, endereço para, tokens uint) retornos públicos (sucesso de bool);

transferência de evento (endereço indexado de, endereço indexado para, tokens uint);

Aprovação de evento (tokenOwner indexado por endereço, spender indexado por endereço, tokens uint);

}

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

// Biblioteca de matemática segura

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

contrato SafeMath {

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

c = a + b;

requer (c >= a);

}

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

requer (b <= a); c = a – b; } function safeMul (uint a, uint b) retornos públicos puros (uint c) {c = a * b; requerem (a == 0 || c / a == b); } function safeDiv (uint a, uint b) retornos públicos puros (uint c) {require (b > 0);

c = a / b;

}

}

O contrato BlockonomiToken é ERC20Interface, SafeMath {

string public name;

símbolo público de string;

uint8 decimais públicos; // 18 decimais é o padrão fortemente sugerido, evite alterá-lo

uint256 public _totalSupply;

mapeamento (endereço => uint) saldos;

mapeamento (endereço => mapeamento (endereço => uint)) permitido;

/ **

* Função de construtor

*

* Inicializa o contrato com tokens de fornecimento inicial para o criador do contrato

* /

construtor () public {

nome = "BlockonomiToken";

símbolo = "BKM";

decimais = 18;

_totalSupply = 100000000000000000000000000;

saldos [msg.sender] = _totalSupply;

emitir Transfer (endereço (0), msg.sender, _totalSupply);

}

function totalSupply () retornos de exibição pública (uint) {

return _totalSupply – saldos [endereço (0)];

}

function balanceOf (address tokenOwner) retornos de exibição pública (uint balance) {

saldos de retorno [tokenOwner];

}

function allowance (address tokenOwner, address spender) public view return (uint restante) {

retorno permitido [tokenOwner] [spender];

}

função de aprovação (endereço spender, uint tokens) retornos públicos (sucesso de bool) {

permitido [msg.sender] [spender] = tokens;

emitir Aprovação (msg.sender, spender, tokens);

return true;

}

transferência de função (endereço para, tokens uint) retornos públicos (sucesso de bool) {

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

saldos [para] = safeAdd (saldos [para], tokens);

emitir Transfer (msg.sender, to, tokens);

return true;

}

function transferFrom (endereço de, endereço para, tokens uint) retornos públicos (sucesso de bool) {

saldos [de] = SafeSub (saldos [de], tokens);

permitido [de] [msg.sender] = safeSub (permitido [de] [msg.sender], tokens);

saldos [para] = safeAdd (saldos [para], tokens);

emitir Transfer (de, para, tokens);

return true;

}

}

Parabéns! Você desenvolveu com sucesso seu próprio token ethereum.

A última etapa é a implantação na rede real.

Implementando Seu Token

Para fazer isso, precisaremos da carteira Metamask.

Metamask é uma extensão que permite que você execute Ethereum dApps diretamente no seu navegador sem executar um nó Ethereum completo.

Vamos para https://metamask.io/ a partir do seu navegador (Chrome, Firefox ou Opera) e adicione-o.

Crie uma nova carteira no MetaMask

Quando a extensão estiver instalada, clique no ícone no canto superior direito do seu navegador para começar a criar uma carteira.

Leia e aceite os termos e, em seguida, digite uma senha forte e clique em “Criar”.

Você verá uma frase semente de 12 palavras. Salve as palavras-semente como um arquivo ou copie-as para um local seguro e clique em “Copiei para algum lugar seguro”.

Você acabou de criar com sucesso uma conta na MetaMask com um novo endereço de carteira!

Você notará que atualmente tem 0 ETH em sua carteira. Para implantar o contrato na rede Ethereum, é necessária uma certa quantidade de Ether. Não implantaremos nosso contrato na rede principal, pois esta é apenas uma demonstração.

Publicaremos este contrato para a rede de teste. Existem algumas redes de teste de blockchain da Ethereum na verdade – Ropsten, Rinkeby, Kovan …

Vamos usar Ropsten para este exemplo.

Primeiro você precisa de um pouco de Ether, certo? Na rede de teste, trabalhamos com éteres gratuitos falsos. Basta reivindicar alguns daqueles de Faucet.

Vamos para: https://faucet.ropsten.be/ , cole o endereço da sua carteira e clique em “Send me test ether”.

Depois de alguns segundos, você verá um pouco de ETH em sua carteira.

Colocando ao Vivo

Agora é hora de fazer tudo viver!

Vá para Remix IDE e compile o contrato. Se não houver erros, estamos prontos para implantação.

Para o ambiente, selecione Web3 injetado. Irá detectar automaticamente a sua carteira metamask.

Clique no botão Implementar.

Metamask irá agora pedir-lhe para retirar alguns fundos da sua carteira para comprar esta transação.

Confirme isso. Em seguida, volte ao Remix IDE e preste atenção ao Terminal. Vemos que a transação foi bem-sucedida.

Temos hash de transação como resultado. Clique no uri do terminal que se parece com: ropsten.etherscan.io/

Isso nos levará a etherscan.io – esse é o Ethereum Blockchain explorer e aqui você pode rastrear tudo o que está acontecendo nas redes principal e de teste, porque tudo é público no blockchain, é claro.

Quando formos a este uri veremos detalhes sobre nossa transação. Clique no hash do contrato para explorar mais.

Tudo é público no blockchain, até mesmo nosso código. Desenvolvedores de Solidity não têm espaço para erros!

Clique no guia de contrato e você verá nosso bytecode compilado

Agora você pode ir ao Token Tracer para ver detalhes de nosso Token Blockonomi. Você pode ver 3 regras opcionais que definimos anteriormente.

Agora verifique sua carteira. Você verá que o Ether que pagamos para implantar o contrato inteligente na Ropsten foi removido.

Conclusão

Isso conclui nosso tutorial, seguindo estas etapas e nossos exemplos de código, você deve ser capaz de implantar seu próprio Token Ethereum ERC-20.

Diverta-se!

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