Come creare il tuo Token personalizzato in meno di un’ora su TestNet! (Ethereum ERC20 Standard)

Immagino che tu conosca già la differenza tra “Cryptocurrency” e “Token”, vero? Se non sei famigliare con le differenze, ti consiglio di andarti a leggere il seguente articolo:

Differenza tra “Cryptocurrency” (Moneta Digitale) e “Token” (Gettone)

Con questa semplice guida, anche un non-esperto programmatore potrebbe creare il proprio Token (ERC20) sulla piattaforma (blockchain) Ethereum… un po’ per gioco, ma magari anche per un progetto reale futuro!

Mi preme evidenziare come le informazioni e le risorse per imparare a programmare in Ethereum siano ancora molto scarse, per cui, anche se la guida sottostante sembra molto semplice, non sottovalutare quanto lavoro ci sia stato da parte mia per collezionare tutte le informazioni necessarie.

Allo stesso tempo, se decidi di creare il tuo Token, e l’informazione presente in questa pagina non è sufficientemente accurata e precisa, e come risultato ottieni una perdita economica, finanziaria e/o di qualsiasi natura, mi preme precisare come italianCRYTO non è e non sarà in alcun modo responsabile.

Ma proseguiamo con la guida “step by step”:

Step 1: Decidi le caratteristiche del tuo token

Al fine di creare un Token ERC20, occorre definire i seguenti parametri:

  • Il nome del token
  • Il simbolo del token
  • I posti decimali del token
  • Il numero di token da generare (la circolazione totale)

Supponiamo di voler create un Token per italianCRYPTO; in questo caso imposterei i parametri come segue:

  • Nome: italianCRYPTO
  • Simbolo: ITAC
  • Posti decimali: 18 (questo è il parametro standard, significa che si possono avere e scambiare fino a .0000000000000000001 ITAC)
  • Circolazione: 100 tokens (gettoni)

Una nota particolare sulle posizioni decimali: nell’eventualità che tu non voglia avere frazioni di token, devi impostare tale parametro a “zero”… il che significherebbe che chiunque possegga il tuo token, può possederne solamente quantità intere: 1, 2, 100, 1375 etc. ma non 1,50000 o 5,3346546.

Step 2: Scrivere lo “Smart Contract” per create il token nella rete Ethereum

Il codice sottostante, è un codice “preso da internet”, dove con un semplice “copia ed incolla”, ti permetterà di creare il tuo Token ERC20. Un ringraziamento perticolare a Tokne Factory per aver pubblicato il codice.

pragma solidity ^0.4.4;contract Token {/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);}contract StandardToken is Token {function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can’t be over max (2^256 – 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn’t wrap.
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
//if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}//name this contract whatever you’d like
contract ERC20Token is StandardToken {function () {
//if ether is sent to this address, send it back.
throw;
}/* Public variables of the token *//*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
string public name; //fancy name: eg Simon Bucks
uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It’s like comparing 1 wei to 1 ether.
string public symbol; //An identifier: eg SBX
string public version = ‘H1.0’; //human 0.1 standard. Just an arbitrary versioning scheme.//
// CHANGE THESE VALUES FOR YOUR TOKEN
////make sure this function name matches the contract name above. So if you’re token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Tokenfunction ERC20Token(
) {
balances[msg.sender] = NUMBER_OF_TOKENS_HERE; // Give the creator all initial tokens (100000 for example)
totalSupply = NUMBER_OF_TOKENS_HERE; // Update total supply (100000 for example)
name = “NAME OF YOUR TOKEN HERE”; // Set the name for display purposes
decimals = 0; // Amount of decimals for display purposes
symbol = “SYM”; // Set the symbol for display purposes
}/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn’t have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3(“receiveApproval(address,uint256,address,bytes)”))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
}

 

Prima di proseguire, devi editare il codice ed inserire i tuoi parametri in modo da personalizzare:

  • Il nome del token
  • Il simbolo del token (consigliabile non più di 4 caratteri)
  • I posti decimali del token
  • Quanti token vuoi avere come proprietario
  • Circolazione totale (per rendere tale esempio semplice, configuriamo tale parametro con lo stesso valore dei token per il proprietario)

Prima di procedere, teniamo presente che:

  • La quantità di token, dipende dal numero di posizioni decimali

Nel nostro esempio, avendo definito la circolazione pari a 100 token, ed avendo 18 posizioni decimali, nello Smart Contratto occorre impostare come circolazione totale 100 (numero di token) x 1.000.000.000.000.000.000 (numero di posizioni decimali) = 100.000.000.000.000.000.000 total supply.

  • Imposta la quantità di token che riceverai come creatore del contratto.

All’interno dello Smart Contract identifica la linea di codice sottostante:

equilibri [msg.sender] = NUMBER_OF_TOKENS_HERE;

Una volta “lanciato” il contratto, il tuo portafoglio Ethereum verrà addebitato con tale cifra.

Andiamo ora a create il token ERC20 sulla rete di test (TestNet).

Step 3: testare il token su TestNet

Prima di create il token sulla rete reale, andiamo a fare un test, per vedere se tutto funziona.

Per prima cosa, se non lo hai già, scarica MetaMask. Questo ti permetterà di avere un’interfaccia semplice ed intuitiva per effettuare operazioni su rete Ethereum e non solo.

Una volta installato MetaMask, assicurati di aver effettuato l’accesso sulla rete di test di Ropsten.

MetaMask in automatico ci assegna un “digital wallet” (portafoglio digitale) e tale digital wallet sarà quello proprietario e responsabile della creazione dei token (mi raccomando, non perdere le chiavi d’accesso, altrimenti perderai anche tutti i token associati a tale indirizzo).

Ora, al fine di caricare il nostro Smart Contract sulla blockchain, occorre andare al seguente sito internet: Solidity Remix Compiler.

Copia ed incolla il contratto precedentemente creato (personalizzato dei tuoi parametri) nella pagina principale

Ora vai alle impostazioni (Setting) e seleziona l’ultima versione del compilatore di versioni (versione con la dicitura “commit”), ed assicurati che nessuna opzione sia selezionata.

Annotati la versione attuale di Solidity (nel mio esempio 0.4.20+commit.3155dd80, in quanto questo parametro verrà utilizzato di seguito per verificare la fonte del contratto.

Ora torna alla sezione “Run” e clicca “Create” sotto il nome della funzione “ERC20Token”.

A questo punto comparirà MetaMask che ti chiederà di premere “SUBMIT” per pagare la transazione (non ti preoccupare, se sei su “Ropsten Network”, il pagamento è fittizio, perché la rete è sviluppata semplicemente per fare test)

Continua premendo “SUBMIT” e nell’elenco delle transazioni in MetaMask, troverai una nuova transazione. Attendi finché la transazione sara’ confermata.

Ora clicca la data della transazione e verrai reindirizzato su Ropsten Etherscan (la rete di test di Ethereum).

Step 4: Verificare la creazione dei token

Avendo specificate nello Smart Contract che tutti i token devono essere inviati al digital wallet del creatore del contratto, ci dobbiamo assicurare che nel nostro MetaMask ci siano tutti i Token.

A take scopo, dobbiamo inserire in MetaMask i’indirizzo del nostro Smart Contract nella sezione TOKENS e se non ci sono errori, ti dovresti trovare tutti i Token creati nel tuo “digital Wallet”.

Wow, MetaMask dice che ho i 100 token che ho creato: il tutto ha funzionato alla perfezione! (nota bene che nel mondo anglosassone, il puntino “.” rappresenta la “nostra virgola “,”, quindi 100.000 equivalgono a 100 token).

Step 5: Verifica il codice sorgente

Al fine di validare il nostro nuovo token, occorre andare a verificare il codice sorgente!
Tale passaggio non è necessario, ma da credibilità al token stesso, soprattutto per il fatto che solitamente, un codice verificato, ha un certo livello di garanzia sul fatto che non stai facendo nulla di losco.
Per verificare il codice, in Etherscan, nella pagine del contratto, clicca sulla scheda “Contract Code” e la, clicca di nuovo su “Verify and Publish”.

Nella nuova schermata, inserisci i seguenti parametri:

  • Contract Address: dovrebbe gia’ essere compilato in automatico
  • Contract Name: inserisci lo stesso nome utilizzato nello Step 3 (Function Name), nel mio caso ERC20Token
  • Compiler: seleziona lo stesso compiler selezionato nello Step 3 (0.4.20+commit.3155dd80, nel mio caso)
  • Optimization: Seleziona NO
  • Enter Solidity Contract Code Below: copia ed incolla il contratto precedentemente utilizzato in Solidity Remix Compiler

Scorri a fine pagina, conferma di non essere un robot (reCAPTCHA check) e clicca “Verify and Publish”

Se tutto è andato a buon fine, dovresti avere una schermata che conferma il tutto

Per visualizzare dettagli del contratto, naviga le schede “Contract Source” e “Read Smart Contract”

Congratulazioni! Hai creato il tuo Token Personalizzato nella rete di TEST!

Se hai ancora dubbi, non esitare a contattarci su uno dei nostri social media – FacebookTwitter o Telegram!

Market Quotes by TradingView