NEWS

Creare un Token sulla rete di test Ropsten

Creare un Token sulla rete di test Ropsten

Con questa breve guida voglio spiegarvi come potete creare un token sulla rete di test di Ethereum chiamata Ropsten.

Non entriamo nel merito delle funzionalità presenti nel token sviluppato con lo Smart Contract, in questo articolo descriveremo i passaggi per creare il nostro token e per trasferire dei token verso un altro indirizzo.

 

Per effettuare questa operazione dovrete scarica Ethereum Wallet e dove averlo installato dovremo spostarci sulla rete di test Ropsten. Per fare questo dovremmo cliccare sul menu "Develop", poi "Network" e infine cliccare su "Ropsten - Test network". Dopo questa operazione diremo al wallet di spostare tutte le operazioni sulla rete di test di Ethereum per evitare di fare esperimenti senza consumare Ether.

 

Ropsten - Test network

 

Dopo aver creato un nuovo account dovremo cliccare su "CONTRACS" e quindi utilizzare la funzione "DEPLOY NEW CONTRACT". Nella nuova pagina che vedremo potremo inserire il codice del nostro token. 

 

Deploy new contract

 

Per creare il nostro Smart Contract che definirà il nuovo token utilizzeremo il codice presente alla pagina https://www.ethereum.org/token.   Durante in nostri test con la versione 0.11.1 di Ethereum Wallet per MAC abbiamo effettuare una piccola modifica per risolvere un problema bloccante di compilazione.

 

Solidity contrat source code

 

Nella definizione dell'interfaccia abbiamo dovuto rimuovere "calldata" dalla firma del metodo.

 

interface tokenRecipient { 
   function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; 
}

che quindi è diventato 

 

interface tokenRecipient { 
   function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; 
}

Tutto il resto è rimasto invariato.

 

Questo il codice finale utilizzato per la creazione del nostro token

 

pragma solidity >=0.4.22 <0.6.0;

interface tokenRecipient { 
   function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; 
}

contract TokenERC20 {
   // Public variables of the token
   string public name;
   string public symbol;
   uint8 public decimals = 18;
   // 18 decimals is the strongly suggested default, avoid changing it
   uint256 public totalSupply;

   // This creates an array with all balances
   mapping (address => uint256) public balanceOf;
   mapping (address => mapping (address => uint256)) public allowance;

   // This generates a public event on the blockchain that will notify clients
   event Transfer(address indexed from, address indexed to, uint256 value);
   
   // This generates a public event on the blockchain that will notify clients
   event Approval(address indexed _owner, address indexed _spender, uint256 _value);

   // This notifies clients about the amount burnt
   event Burn(address indexed from, uint256 value);

   /**
    * Constructor function
    *
    * Initializes contract with initial supply tokens to the creator of the contract
    */
   constructor(
       uint256 initialSupply,
       string memory tokenName,
       string memory tokenSymbol
   ) public {
       totalSupply = initialSupply * 10 ** uint256(decimals);  // Update total supply with the decimal amount
       balanceOf[msg.sender] = totalSupply;                // Give the creator all initial tokens
       name = tokenName;                                   // Set the name for display purposes
       symbol = tokenSymbol;                               // Set the symbol for display purposes
   }

   /**
    * Internal transfer, only can be called by this contract
    */
   function _transfer(address _from, address _to, uint _value) internal {
       // Prevent transfer to 0x0 address. Use burn() instead
       require(_to != address(0x0));
       // Check if the sender has enough
       require(balanceOf[_from] >= _value);
       // Check for overflows
       require(balanceOf[_to] + _value >= balanceOf[_to]);
       // Save this for an assertion in the future
       uint previousBalances = balanceOf[_from] + balanceOf[_to];
       // Subtract from the sender
       balanceOf[_from] -= _value;
       // Add the same to the recipient
       balanceOf[_to] += _value;
       emit Transfer(_from, _to, _value);
       // Asserts are used to use static analysis to find bugs in your code. They should never fail
       assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
   }

   /**
    * Transfer tokens
    *
    * Send `_value` tokens to `_to` from your account
    *
    * @param _to The address of the recipient
    * @param _value the amount to send
    */
   function transfer(address _to, uint256 _value) public returns (bool success) {
       _transfer(msg.sender, _to, _value);
       return true;
   }

   /**
    * Transfer tokens from other address
    *
    * Send `_value` tokens to `_to` on behalf of `_from`
    *
    * @param _from The address of the sender
    * @param _to The address of the recipient
    * @param _value the amount to send
    */
   function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
       require(_value <= allowance[_from][msg.sender]);     // Check allowance
       allowance[_from][msg.sender] -= _value;
       _transfer(_from, _to, _value);
       return true;
   }

   /**
    * Set allowance for other address
    *
    * Allows `_spender` to spend no more than `_value` tokens on your behalf
    *
    * @param _spender The address authorized to spend
    * @param _value the max amount they can spend
    */
   function approve(address _spender, uint256 _value) public
       returns (bool success) {
       allowance[msg.sender][_spender] = _value;
       emit Approval(msg.sender, _spender, _value);
       return true;
   }

   /**
    * Set allowance for other address and notify
    *
    * Allows `_spender` to spend no more than `_value` tokens on your behalf, and then ping the contract about it
    *
    * @param _spender The address authorized to spend
    * @param _value the max amount they can spend
    * @param _extraData some extra information to send to the approved contract
    */
   function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
       public
       returns (bool success) {
       tokenRecipient spender = tokenRecipient(_spender);
       if (approve(_spender, _value)) {
           spender.receiveApproval(msg.sender, _value, address(this), _extraData);
           return true;
       }
   }

   /**
    * Destroy tokens
    *
    * Remove `_value` tokens from the system irreversibly
    *
    * @param _value the amount of money to burn
    */
   function burn(uint256 _value) public returns (bool success) {
       require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
       balanceOf[msg.sender] -= _value;            // Subtract from the sender
       totalSupply -= _value;                      // Updates totalSupply
       emit Burn(msg.sender, _value);
       return true;
   }

   /**
    * Destroy tokens from other account
    *
    * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
    *
    * @param _from the address of the sender
    * @param _value the amount of money to burn
    */
   function burnFrom(address _from, uint256 _value) public returns (bool success) {
       require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
       require(_value <= allowance[_from][msg.sender]);    // Check allowance
       balanceOf[_from] -= _value;                         // Subtract from the targeted balance
       allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
       totalSupply -= _value;                              // Update totalSupply
       emit Burn(_from, _value);
       return true;
   }
}

Una volta copiato il codice sorgente sulla destra andremo a selezionare il nostro contratto "Token ERC 20", andremo a definire l'initial supply, cioè la quantità iniziale di token in circolazione, il nome del token, ad esempio "CryptoX Token" e quindi il suo simbolo che potrebbe essere "CRX". Questo è solo un esempio. Per quanto riguarda i'initial supply ad esempio il bitcoin ha fissato in 21000000 il numero massimo in circolazione.

 

A questo potremo cliccare su  "DEPLOY" che troviamo sotto il box con il codice sorgente. Dopo qualche minuto il nostro token sarà sulla blockchain di test di Ethereum. 

 

Ethereum Wallet ora mostrerà i contratti nella sezione "Custom Contract" il nostro contratto appena pubblicato e sotto "Custom Token" il nostro token appena creato. Ricordiamo che entrambi hanno come proprietario l'account Ethereum con il quale avete effettuato l'operazione. 

 

Ora possiamo provare ad inviare i nostri token ad altri indirizzi Ethereum sempre sulla rete di test Ropsten.  Per fare questo selezioniamo il contratto, vedremo i dati del nostro Smart Contract e a destra da "Pick A Function" potremo selezione la funzione "transfer". Dopo aver in inserito l'importo dei token e l'indirizzo Ethereum potremo cliccare su "EXECUTE". L'importo inserito dovrà contenere oltre all'importo altri 18 zeri.  Quindi per trasferire 1000000 di token dovrete scrivere: 1000000000000000000000000.

 

Transfer Executer

 

 


Linda Carlton

Appassionata di criptovalute, blockchain e sistemi di pagamento. 

Donate

13qs9fyjT7bbqStZUuPpkAkwxzELtwe1Wf
0x5913E8dD6FC013368f2012C5EFB64C276a61e006
0x9F322a84Eadc0B417Fc24ce60B35A7b8d000720d

GUADAGNA CRIPTOVALUTE CON CRYPTOX.IT

Se alla fine dell'articolo trovi "Guadagna cripto condividento questo contenuto" potrai guadagnare criptovalute condividendo il contenuto sui tuoi social o tra i tuoi amici, leggi il regolamento.

RELATED NEWS

Cardano porta le risorse digitali su Shopify e WooCommerce

Annunciata una nuova integrazione
by Linda Carlton Apr 25, 2021

COMMENTS


PARTNER

CRYPTO RATES

24h 24h Vol Price
BTC +2,52 53.512,24M 48.685,97 EUR
ETH -6,28 31.782,07M 2.939,91 EUR
RPD +15.989.979,42 0,40M 18,45 EUR
BNB -0,41 2.831,96M 518,98 EUR
DOGE +17,25 22.163,52M 0,59 EUR
XRP -4,29 5.890,89M 1,30 EUR
USDT -0,67 129.912,04M 0,82 EUR
ADA -8,01 3.963,00M 1,31 EUR
DOT -5,29 1.874,84M 32,32 EUR
BCH -3,23 6.294,18M 1.135,13 EUR
aggiornato 4 minuti fa da coinmarketcap.com

POPULAR VIDEOS

POPULAR BOOKS

The Bitcoin Standard
The Bitcoin Standard
by Saifedean Ammous Dec 06, 2020
Compra su Amazon
The Mystery Of Banking
The Mystery Of Banking
by Murray N. Rothbard Dec 06, 2019
Compra su Amazon
Mastering Bitcoin
Mastering Bitcoin
by Andreas M. Antonopoulos Nov 12, 2020
Compra su Amazon
Flash Boys
Flash Boys
by Michael Lewis Nov 19, 2019
Compra su Amazon

POPULAR TWEETS

@AndrewNation13 @AndrewNation13 - 21 hours ago Latest Ripple XRP News @Kevin_Cage_ #XRP #cryptocurrency #bestcrypto https://t.co/VAGjl5MGGo

  • 17
  • 2

Agostino Mario Mela @agostinomela - 6 hours ago Si chiamano criptovalute perché per la stragrande maggioranza delle persone sono e saranno sempre un grande mistero.

  • 14
  • 0

FREE MCAFEE - Freedom Club @ostvest - 23 hours ago La mia microazienda, come sapranno i miei affezionatissimi lettori, accantona il 10% delle fatture in ingresso in criptovalute. Ecco il portafoglio ad oggi. NOT FINANCIAL ADVICE - YES LIFE ADVICE https://t.co/iiZU71sNaX

  • 8
  • 0

IOTA - The next generation of Crypto @IotaBullrun2020 - 21 hours ago #IOTA + #INTEL + #DELL = WORKS $iota $miota #miota #altcoins #altcoin #altseason #btc #bitcoin #usdt #binance #bnb https://t.co/p1tutJZfQa

  • 7
  • 2

ハデス @ripple_chan - 23 hours ago AI inside https://t.co/PY166U65br

  • 7
  • 1

CRYPTO NETWORK

Reward Block Difficulty
BTC 6 682449 20.608.845M
ETH 2 12389569 7.470.847.865M
BCH 6 686885 446.535M
UNO 0 1331510 368.211M
XMR 2 2355926 289.099M
DASH 1 1467121 199M
LTC 12 2048442 12M
ZEC 2 1241587 97M
ZEN 3 928985 33M
ETC 3 12697629 403.997.000M
aggiornato 16 ore fa da coinwarz.com

PODCAST


LINKS