DApps & Smart Contracts Ethereum Tutorial

Come creare uno Smart Contract con Solidity [GUIDA]

Vuoi costruire uno smart contract? Forse vuoi capire come funziona, magari vuoi costruire la tua Dapp, oppure vuoi lanciare la tua ICO da un miliardo di dollari. A prescindere dalle tue intenzioni, imparare come funzionano i famosi smart contracts è una risorsa che potrà essere sempre utile.

La piattaforma Ethereum possiede un enorme potenziale per creare Dapps che potranno cambiare il modo in cui interagiamo sul web nei decenni a venire. Mentre Ethereum distribuisce smart contracts che funzionano in modo molto simile a una transazione blockchain standard, producono un’istruzione condizionale che deve essere soddisfatta prima dell’esecuzione di una funzione. Gli smart contracts possono essere utilizzati per delle votazioni, per il crowdfunding, per delle aste e molto di più.

Un esempio veloce di smart contract

Bob ha la sua attività, è un rottamaio degli Stati Uniti, Eric è il suo fornitore di rottami di ferro. Eric vive poco fuori dalla Cina. Bob e Eric hanno un ottimo rapporto d’affari. Si fidano l’un l’altro e fanno affari da molto tempo. Entrambi hanno imprese in forte espansione. Bob ha un contratto in cui una volta che il suo inventario (di rottami di ferro) raggiunge un certo intervallo, invia automaticamente un ordine a Eric per X kg di rottami di ferro a Y ether per tonnellata.

Eric accetta l’accordo e accetta il pagamento di Bob in ether subito. Eric si mette immediatamente al lavoro e inizia ad adempiere all’ordine di Bob. Eric può scambiare il suo ether in un exchange locale online per Yuan, pagando una piccola commissione, e questo ordina verrà elaborato istantaneamente. Se Eric decide di tenere l’ether o di convertire tutto in Yuan è la sua scelta, ma in ogni caso può accede ai fondi in maniera immediata.

Entrambe le parti sono contente. Senza smart contracts, in genere, Bob avrebbe dovuto contattare la sua banca e richiedere un bonifico bancario da inviare alla banca di Eric in Cina. Normalmente, occorrono circa 48 ore per elaborare il bonifico bancario. A quel punto, Eric dovrà attendere altri giorni prima che la sua banca effettui il bonifico. Non solo, la banca di Bob gli addebiterà una tassa per il trasferimento di denaro a Eric. Tempo e denaro letteralmente buttati via. A peggiorare le cose, entrambe le parti hanno i classici problemi a trasformare i dollari americani in yuan cinesi e spesso devono affidarsi alla banca stessa.

Quindi, cosa imparerò?

Prima di implementare il nostro primo smart contract è necessario imparare alcune nozioni di base. Cosa ancora più importante, voglio sottolineare che la piattaforma Ethereum è stata lanciata nel 2016 di conseguenza ora è il momento perfetto per iniziare a conoscere davvero gli smart contracts.

In questo tutorial impareremo:

  • Nodi Ethereum (Ethereum Nodes)
  • Costruire una Blockchain privata
  • Utilizzare il Plug In MetaMask per Browser
  • Mist Browser
  • Wallet Ethereum
  • Web3 Ethereum JavaScript API
  • Remix Web Browser IDE
  • Interfaccia a linea di comando Geth (Go Ethereum)
  • Il linguaggio di programmazione Solidity

Importante: se in qualsiasi momento si verifica un problema con l’esecuzione del programma, provare ad avviarlo come amministratore facendo clic con il pulsante destro del mouse su di esso e selezionando “Esegui come amministratore”.

Impostazione di un nodo Ethereum

Nella forma più semplice, un nodo Ethereum è qualsiasi dispositivo che esegue il protocollo Ethereum (blockchain). I nodi sono in genere in esecuzione su desktop e laptop. Quando ci colleghiamo al protocollo Ethereum siamo nella rete blockchain di Ethereum e stiamo facendo funzionare un nodo. Eseguendo un nodo Ethereum possiamo connetterci ad altri nodi della rete, avere accesso diretto alla blockchain e persino fare cose come inviare transazioni e implementare contratti intelligenti.

I nodi sono scritti in Go (Go Ethereum / Geth), C++ e Python. In questo tutorial seguiremo il più popolare dei tre, Go. Importante notare anche che scaricando Geth stiamo scaricando l’INTERA blockchain di Ethereum. Detto questo, prima di procedere devi avere lo spazio di archiviazione libero sul tuo computer pari al valore che puoi trovare a questo link.

1) Visita il sito web di Go Ethereum e scarica Geth.

https://geth.ethereum.org/downloads/

2)Scarica la versione più stabile di Geth (1.7.2) per Windows, assicurati di scaricare la versione a 64 bit.

contract

3)Una volta completato il download, apri il programma di installazione e fai clic su “Accetto”.

contract

4)Assicurati che la casella Geth sia selezionata e fai clic su “Avanti”.

contract

5)Ti verrà richiesto di selezionare una cartella di destinazione per il download. Per impostazione predefinita, Geth verrà installato in C:\Programmi\Geth

contract

6)Chiudi l’installazione una volta completata.

contract

7)Apri il prompt dei comandi (serve Git Bash – scaricalo qui: https://git-scm.com/,) e vai alla directory di Geth digitando “cd  C:\Programmi\Geth”

contract

8)Inizia la sincronizzazione con la blockchain di Ethereum digitando “Geth”. siccome si tratta della prima sincronizzazione, scaricherai TUTTA la blockchain. Ci vorrà un po ‘di tempo, mettiti comodo.

contract

Fatto? Perfetto. Ora stai eseguendo un nodo Ethereum.

Creiamo la nostra rete privata Ethereum

Ora che abbiamo accesso al protocollo Ethereum tramite il nostro nodo, configureremo il nostro server privato per sviluppare e implementare il nostro smart contract. Nota che nulla di tutto questo verrà effettivamente implementato sulla blockchain di Ethereum, ma lo faremo sulla nostra blockchain. Cominciamo inizializzando il primo blocco nella nostra blockchain, il cosidetto “blocco genesis” (genesis.json).

1) Crea una nuova cartella sul desktop chiamata “Private Chain”.

2) Apri il prompt dei comandi in questa cartella e creare una cartella di directory dei dati digitando “Mkdir chaindata”. È possibile aprire un prompt dei comandi in questa cartella tenendo premuto Maiusc e clic destro, quindi seleziona “Apri finestra di comando qui”.

3) Successivamente, dobbiamo creare e salvare il nostro blocco genesis.json nella nostra cartella Private Chain, poiché il blocco genesis verrà utilizzato per inizializzare la nostra rete privata e archiviare i dati nella cartella relativa: “chaindata”.

4) Apri il blocco note, copia e incolla il codice seguente in un nuovo file chiamato “genesis.json” e salva questo file nella cartella Private Chain.

Per ulteriori informazioni sui parametri genesis.json, visita il seguente link: https://ethereum.stackexchange.com/questions/2376/what-does-each-genesis-json-parameter-mean

{
  "coinbase"   : "0x0000000000000000000000000000000000000001",
  "difficulty" : "0x20000",
  "extraData"  : "",
  "gasLimit"   : "0x2fefd8",
  "nonce"      : "0x0000000000000042",
  "mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "timestamp"  : "0x00",
  "alloc": {},
  "config": {
        "chainId": 15,
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
    }
}

contract

5) Ora vogliamo inizializzare la nostra rete privata nella directory chaindata usando il nostro file genesis.json. Diremo a Geth che vogliamo la directory dei dati in “chaindata” e dove è possibile trovare il file genesis.json (assicurati che genesis.json NON sia nella cartella chaindata) inserendo il codice qui sotto a linea di comando che punta alla cartella Private Chain.

geth --datadir=./chaindata/ init ./genesis.json

6)Dovresti quindi vedere che lo “stato di genesi” è stato scritto con successo.

contract

7)Ora possiamo avviare Geth e connetterci alla nostra chain privata. Come vedrai, la connessione socket dell’endpoint geth.ipc verrà aperta sulla porta 30303.

geth --datadir=./chaindata/

contract

Ogni volta che viene avviato Geth, si apre l’endpoint IPC, che viene utilizzato per elaborare le connessioni a Geth con programmi come MetaMask, Ethereum Wallet, Mist o per l’apertura della console dell’API JavaScript Geth. Ne discuteremo comunque più avanti.

Perfetto, abbiamo appena creato la nostra rete privata Geth.

Cos’è esattamente MetaMask?

MetaMask è sia un browser Ethereum che un wallet. Tramite MetaMask è possibile interagire con Dapps e smart contracts sul Web senza dover scaricare la blockchain o installare alcun software. È sufficiente aggiungere MetaMask a Chrome come estensione, creare un wallet e depositare l’ether. Attualmente è disponibile sia per Chrome che per Firefox (la disponibilità di questo ultmio browser risale a un paio di mesi fa).

Il vero problema di Metamask è che come qualsiasi wallet online, devi fidarti. Esiste la possibilità che venga hackerato o che perda la tua chiave privata, poiché le tue informazioni sono archiviate online. Per ulteriori informazioni vi rimando al nostro articolo che spiega nei dettagli che cos’è e come funziona MetaMask.

Puoi scaricare MetaMask qui: https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=it

contract

Il Browser Mist

Mist è un’applicazione ibrida desktop con un’interfaccia web. Ciò consente uno sviluppo più veloce e la possibilità di apportarne modifiche all’interfaccia aiutandosi lato browser.

Mist è potente in quanto include un nodo Geth che viene eseguito in background al momento del lancio; una connessione con la blockchain di Ethereum viene fatta immediatamente. Ma poiché stiamo parlando dello sviluppo di uno smart contract, eseguiremo un nodo sulla nostra rete privata e non ci sarà bisogno di Mist per connettersi al nodo Geth predefinito.

Maggiori informazioni su Mist potete trovarle su github: https://github.com/ethereum/mist/wiki

Cosa dire dell’Ethereum Wallet?

Il Wallet Ethereum è solo un’implementazione Mist che può accedere solo a una singola Dapp, ciò è dovuto ad alcune funzionalità mancanti in Mist. Il Wallet Ethereum è scritto in puro codice HTML e Javascript, fa uso di web3.js per gestire gli account e viene eseguito all’interno del browser Mist. Puoi anche scaricare una versione standalone se preferisci.

Wallet Ethereum: https://github.com/ethereum/meteor-dapp-wallet

Scarichiamo il browser Mist e connettiamoci alla nostra rete privata

1) Vai alla pagina di download di Mist e scarica il programma di installazione dedicato https://github.com/ethereum/mist/releases

2) Apri il programma di installazione e fai clic su “Accetto”.

contract

3) Conferma il percorso di download C:\Program Files\Mist (predefinito) facendo clic su “Avanti”.

contract

4) Conferma i dati della blockchain da memorizzare nel percorso predefinito in ..\Roaming\Ethereum e fai clic su “Installa”.

contract

Sentiti libero di aprire Mist e di giocare con l’interfaccia utente per avere un’idea migliore delle cose.

Colleghiamo Mist alla nostra rete privata

Ora che abbiamo disattivato l’inizializzazione della nostra rete privata con il blocco genesis, possiamo aprire una riga di comando nella nostra cartella Private Chain e dire a Geth di connettersi al nostro datadir. Digita il seguente codice nel prompt dei comandi:

geth --datadir=./chaindata/

contract

Geth inizierà ora a funzionare e una volta aperto Mist verrà aperto l’endpoint geth.ipc; Mist quindi effettuerà la connessione alla nostra rete privata. Assicurati che sia connesso confermando che “Private-Net” esiste nell’angolo in alto a destra della finestra di lancio Mist.

Le basi di Mist

Apriamo Mist e familiarizziamo con alcune cose:

contract

1) In cima possiamo notare la barra degli strumenti. Navigando su “Ethereum Node” sotto la scheda “Develop” si può vedere che NON siamo collegati a Geth, dato che è inattivo (stiamo facendo funzionare la nostra rete). Proprio come Chrome, nella scheda “Sviluppo” possiamo anche accedere a “Strumenti per sviluppatori”.

contract

2) Sul lato sinistro del browser Mist possiamo vedere le varie schede aperte, proprio come qualsiasi altro browser. Cliccando sulla scatola verde apriremo il Wallet Ethereum. Il wallet è un’applicazione distribuita che rende incredibilmente facile l’interazione con l’interfaccia JavaScript di Go Ethereum.

3) Come puoi notare, siamo collegati al Wallet Ethereum tramite https://wallet.ethereum.org/, non dimenticare che Mist è semplicemente un browser. Da qui possiamo fare cose come vedere transazioni passate, inviare ether e persino distribuire o guardare smart contracts.

4) Nella scheda “Wallets” possiamo vedere i nostri conti, aggiungere nuovi account ed esaminare anche le transazioni passate.

5) Creiamo un account facendo clic su “Create account” (account sta per “wallet”), quindi su “Create new account” e inseriamo una password super-sicura (anche se si tratta di un account sulla nostra rete privata e non sarà collegato alla reale Rete Ethereum, è una buona abitudine fare in questo modo). Fai clic su “OK” e crea il tuo wallet.

contract

Sotto la scheda “Send” possiamo inviare ether da un wallet all’altro. Come puoi vedere qui sotto, prima di  cliccare “send” ci viene data la possibilità di impostare il gas (a pagamento) per la nostra transazione. Tutte le transazioni richiedono una certa quantità di gas per incentivare l’elaborazione. A seconda della velocità con cui vogliamo ottenere la transazione elaborata e approvata dalla blockchain, possiamo regolarne la quantità.

contract

Infine, nella scheda “Contracts” possiamo implementare nuovi contratti, guardare quelli esistenti e guardare i token creati in precedenza. Qui è dove creeremo e implementeremo il nostro smart contract “Hello World!”.

contract

Se abbiamo interesse a interagire con un precedente contract già implementato, possiamo cliccare su “Watch Contracts” e inserire il nome del contratto, l’indirizzo e l’ABI (application binary interface). Se abbiamo interesse a guardare, o spendere, i token ERC-20 (token sviluppati sulla blockchain di Ethereum), possiamo anche inserire l’indirizzo del contratto token, il nome e il simbolo.

Se passiamo alla scheda Explore (il riquadro blu con la lente di ingrandimento) vedremo che si aprirà un browser con una barra degli indirizzi e verrà caricata una pagina web. Se facciamo clic su “Connect” nell’angolo in alto a destra dello schermo, possiamo collegare il browser al nostro wallet. Ci collegheremo quindi a “Web 3.0” e da qui potremo visitare le applicazioni distribuite di Ethereum (Dapps) e utilizzare il nostro wallet per interagire con loro.

Provalo tu stesso e visita https://www.stateofthedapps.com/ per vedere alcuni esempi.

contract

Siccome ci troviamo sulla nostra rete privata, saremo in grado di connettere il nostro wallet al browser, ma non abbiamo ether reale. Quindi, saremo limitati in questo esempio. Per ottenere un’esperienza completa è necessario connettersi alla rete Ethereum e depositare l’ether nel proprio wallet, ma ciò non significa che non possiamo navigare.

contract

Web.js

Potresti chiederti “in che modo Mist è in grado di connettere un wallet a un browser e interagire con la blockchain di Ethereum?” Mist è semplicemente un browser, un browser che funziona con la libreria Web3.js e può comunicare con un nodo Ethereum o effettuare transazioni con uno smart contract che si trova sulla blockchain. La libreria Web3.js comunica con un nodo Ethereum tramite chiamate JSON RPC connettendosi a una connessione HTTP o IPC.

Se vuoi saperne di più su Web3.js, visita la documentazione di GitHub qui: https://github.com/ethereum/wiki/wiki/JavaScript-API

Prendiamo un attimo fiato..

Mentre molti potrebbero essere rimasti bloccati al primo tentativo, ti esorto a continuare. Successivamente interagiremo con l’IDE web Remix e scriveremo il nostro primo smart contract in Solidity.

Remix web browser IDE

Entriamo subito nel concreto e iniziamo a scrivere il nostro codice. Mentre possiamo scrivere su Mist in maniera diretta, scriveremo il nostro codice Solidity nell’IDE del browser web Remix. Perché? Bene, Remix ha una manciata di funzionalità che rendono un’esperienza di sviluppo più completa (per ora). In genere è meglio utilizzato per i contratti di dimensioni minori. Le funzionalità di Remix includono:

  • Debugger integrato (step-by-step, istruzioni, variabili di monitoraggio, stack di chiamate).
  • Avvisi come codice” not-safe”, costo del gas, se le funzioni potrebbero essere costanti e verifica la sovrapposizione di nomi di variabili.
  • Test integrato e ambiente di distribuzione.
  • Analisi statica.
  • Sintassi ed evidenziazione degli errori.
  • Funziona con oggetti Web3.
  • Può essere distribuito direttamente su MetaMask o Mist.

Passiamo a Remix visitando: https://remix.ethereum.org/

contract

Proprio al centro della pagina possiamo vedere il nostro spazio per il codice. Nella parte in alto a sinistra dello schermo ci sono alcune diverse opzioni disponibili: “Crea nuovo file”, “Aggiungi file locale”, “Pubblica tutti i file aperti su un Github anonimo”, “Copia tutti i file su un’altra istanza”, e infine “Connetti a Localhost”. Possiamo anche vedere una lista di smart contract in fase di sviluppo.

contract

Nella parte in alto a destra del nostro schermo abbiamo diverse schede tra cui scegliere. La scheda “Compila” ci consente di compilare appunto il nostro contratto una volta completato. Se clicchiamo su “dettagli”, otteniamo un elenco di diversi dettagli del contract che vanno dai metadati, al bytecode, all’ABI e persino al codice di implementazione Web3 del contratto stesso.

Le schede “Impostazioni”, “Debugger”, “Analisi” e “Supporto” hanno tutte il loro caso d’uso e vale la pena perderci un po di tempo per familiarizzarvi. Noi useremo la scheda “Esegui” per il resto di questo tutorial. Facciamo click su “Esegui”.

contract

Environment: ci sono 3 tipi di ambienti a cui Remix può essere collegato. Entrambi gli ambienti Web3 Provider e Injected Web3 richiedono strumenti esterni come MetaMask o Mist. La VM JavaScript è ciò a cui ci atteniamo, in quanto consentirà l’esecuzione nel nostro browser, oltre all’implementazione in Mist.

Account: Remix fornisce 5 account diversi con 100 Ether precaricati. Possono essere utilizzati durante lo sviluppo del contratto se lo desideriamo.

Gas Limit: si può impostare un limite per la quantità di gas (tassa) legata al contratto.

Gas Price: analogamento si può scegliere una quantità di gas necessaria.

Value: distribuire il contratto con X quantità di etere allegato.

Finalmente…mettiamo le mani su Solidity

Per quelli di voi che hanno familiarità con Javascript sono sicuro che noterete molte somiglianze con Solidity. Proprio come JS, Solidity è un linguaggio ad alto livello che è stato progettato per rivolgersi a Ethereum Virtual Machine (EVM). Il codice è tipizzato staticamente, supporta l’ereditarietà, le librerie e tipi complessi definiti dall’utente, tra le altre caratteristiche.

Nel nostro contratto “Hello world!” creeremo una variabile di stato chiamata “counter” e le assegneremo un valore iniziale di 5. Quindi creeremo una funzione che aumenta la nostra variabile di stato di 1, una funzione che diminuisce la variabile di 1, una funzione che restituisce il nostro “counter” e infine una che distruggerà il contratto.

Il primo bit di codice che inseriremo in Remix è la versione del codice sorgente.Abbiamo scelto 0.4.16. Chiameremo questa versione digitandola all’inizio del nostro contratto:

pragma solidity ^0.4.16;

La parola chiave “pragma” viene chiamata in questo modo perché generalmente le istruzioni per il compilatore sono istruzioni sul come trattare il codice sorgente.

Maggiori informazioni su Solidity possono essere trovate qui: https://solidity.readthedocs.io/en/develop/index.html

Functions & States

Osservando “le ossa” di uno smart contracts, possiamo vedere che i contratti in realtà sono semplicemente raccolte di codice (le sue funzioni) e dati (i suoi stati) che corrispondono a uno specifico indirizzo di contratto sulla blockchain.

Ad esempio, la riga “uint256 counter;” imposta il contatore delle variabili di tipo uint256 (intero senza segno di 256 bit). Ora può essere considerato come un singolo slot in un database che può essere richiamato semplicemente invocando la funzione del codice che gestisce il database. Possiamo persino impostare un valore variabile per il contatore.

uint256 counter = 5;

Le variabili di stato sono in genere al di fuori delle funzioni, in maniera da renderle variabili globali e di solito sono le prime linee di codice del nostro contratto. Ora abbiamo impostato il nostro “counter”. Se vogliamo chiamare una funzione per aumentare il valore del contatore di 1, creeremo una funzione (la chiameremo “add “) e le diremo di aggiungere 1 al contatore.

function add() public {
counter++;
}

Dopo aver chiamato la funzione “add ()”, il nostro “counter” avrà valore 6.

Costruiamo il nostro Smart Contract

Creiamo il nostro contratto “Hello World!” in questo modo:

pragma solidity ^0.4.16
contract HelloWorld {

}

Ora possiamo includere la variabil di stato di cui abbiamo parlato prima. Ricordiamo che assegneremo questa variabile di stato come un numero intero senza segno di 256 bit.

pragma solidity ^0.4.16;

contract HelloWorld {

uint256 counter = 5;

}

Vai avanti e vedi se riesci a creare 2 funzioni.
Abbiamo bisogno di:
1) Una funzione che aumenta il contatore di 1.
2) Una funzione che diminuisce il contatore di 1.


pragma solidity ^0.4.16;
contract HelloWorld {
 
 uint256 counter = 5; //state variable we assigned earlier
 function add() public {  //increases counter by 1
  counter++;
 }
 
 function subtract() public { //decreases counter by 1
  counter--;
 }
 
 
}

Vedrai dal codice soprastante che abbiamo assegnato a entrambe le funzioni il modificatore public. Poiché Solidity conosce due tipi di chiamate di funzione (quelle interne che non creano una chiamata EVM effettiva,  e quelle esterne che lo fanno), ci sono quattro tipi di visibilità per funzioni e variabili di stato. Le funzioni possono essere specificate come external, public, internal o private, il valore predefinito è public. A parte il fatto che Remix invierà un messaggio di warning indicando che non è specificata alcuna visibilità e che è di default public. Ci permetterà di capire meglio le impostazioni dello smart contract durante la stesura del nostro codice.

Ci stiamo avvicinando. La nostra variabile di stato può cambiare a seconda della funzione che chiamiamo, ma abbiamo bisogno di una funzione che emetterà il valore del counter. Prova a creare una funzione chiamata “getCounter ()” che restituirà il counter. Questa sarà un’azione di sola lettura, quindi dobbiamo dire alla nostra funzione che restituiremo una costante. Inoltre, quando si restituisce una variabile di stato, bisogna dire alla funzione il tipo che viene restituito, in questo caso restituiremo un uint256 come discusso in precedenza.


pragma solidity ^0.4.16;
contract HelloWorld {
 
 uint256 counter = 5; //state variable we assigned earlier
function add() public {  //increases counter by 1
  counter++;
 }
 
 function subtract() public { //decreases counter by 1
  counter--;
 }
 function getCounter() public constant returns (uint256) {
  return counter;
    } 
}

Mentre chiamiamo una funzione sulla rete, Ethereum richiederà una piccola quantità di gas da spendere, non è richiesto niente però quando si restituisce una funzione costante.

Ok, quindi ora abbiamo uno smart contract che ci consente di cambiare il valore del nostro contatore come variabile globale. Possiamo anche aumentarlo di 1, diminuirlo di 1 e restituire il valore del nostro counter ogni volta che vogliamo.

Testiamolo

Quindi il tuo codice dovrebbe essere su Remix in “Auto compile”e controllato di default nella scheda “Compile”. Vai verso la scheda “Run”. Le impostazioni predefinite avranno l’ambiente impostato su VM JavaScript, verrà selezionato un account, il limite del gas sarà 3000000 e il prezzo e il valore del gas saranno 0. Fare clic su “Create” nella scheda “Run”. Ora dovresti vedere il tuo smart contract creato:

contract

A prima vista puoi vedere le 3 funzioni che abbiamo creato: “add”, “substract” e “getCounter”. Puoi anche vedere che la variabile di stato ha un valore assegnato a 5. Ora, fai clic su “add” per aumentare il counter di 1. Quindi vai avanti e fai clic su “getCounter” per richiamare il nostro counter appena modificato. Dovresti vedere il valore è stato aggiornato a 6. Provalo di nuovo per “sottrarre”.

contract

Sviluppare smart contracts in Mist

Ora che abbiamo testato il nostro codice in Remix, avviamo Mist (assicurati che sia connesso alla rete privata) ed eseguiamolo sulla nostra rete privata. Passa alla scheda “Contracts” del Wallet Ethereum in Mist. Quindi seleziona “Deploy new contract” e incolla il codice che abbiamo appena scritto da Remix nella casella del codice sorgente.

Prima di procedere oltre, dobbiamo avere ether nel nostro wallet. Possiamo estrarre l’ether sulla nostra rete privata eseguendo il miner. Lo faremo attraverso la console JavaScript Geth.

Apri un’altra finestra del prompt dei comandi che punta alla tua cartella di rete privata (C:/users/name/desktop/private network) e digita geth attach. Premi invio. Vedrai la console Geth JavaScript e ora puoi inserire direttamente i comandi dentro Geth. Iniziamo il mining per un po’ di ether digitando miner.start (); .

Vedrai che la console restituisce “null”, significa che il mining è iniziato! Dai un’occhiata al tuo wallet su Mist, vedrai incrementarne il contenuto di 5 ether ogni tanto. Puoi fermare il miner in qualsiasi momento digitando miner.stop (); nella console, o puoi continuare a estrarre l’ether (falso).

Ulteriori informazioni sui comandi della console JS qui: https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console

contract

Ora torna alla scheda “Contracts”, “Deploy new contract”, assicurati che il codice sia nella casella del codice sorgente. A destra della casella del sorgente selezionare “Hello World” come contratto da distribuire, quindi fare clic su deploy.

contract

Dopo aver inserito la password, torna alla scheda Wallets. Scorri fino a “Lastest transaction” e vedrai il contratto che abbiamo appena distribuito. Noterai inoltre che il contratto mostra 0 di 12 conferme ed è bloccato in uno stato perpetuo di “creazione di un contratto”.

contract

Il motivo per cui il nostro contratto non è stato completamente creato è che non ci sono miners sulla nostra rete che lo confermeranno. Avvia di nuovo il mining nella console di Geth JavaScript che abbiamo aperto in precedenza (miner.start ();). Quando avremo iniziato di nuovo il mining, vedremo che il numero di conferme inizierà ad aumentare e alla fine il nostro contract verrà completamente creato.

contract

Ora fai clic sul nome del contratto. Da qui possiamo fare ogni cosa. Possiamo trasferire l’ether al contratto, copiare l’indirizzo del contratto, generare un codice QR da scansionare, ottenere l’interfaccia dei contratti (ABI) e persino eseguirne le funzioni.

contract

Notiamo che il nostro contract “Hello World” sta utilizzando la funzione getCounter () con la variabile di stato del contatore di 5. Vai a “select function” e seleziona la funzione “add” o “substract”. Una volta selezionato, premi “run”. Non dimenticare, siamo gli unici sulla nostra rete privata, quindi dobbiamo confermare la transazione eseguendo alcun processo di mining!

contract

Fatto. Il nostro contratto ha eseguito le funzioni che gli abbiamo chiest restituendo il valore di “4”. Ora abbiamo uno smart contract reale sulla nostra rete di blockchain Ethereum privata che può essere interagita su Mist!

Bonus: aggiunta di una funzione di autodistruzione

Come menzionato sopra, quando gli smart contracts vengono distribuiti si aggiungono ufficialmente alla blockchain di Ethereum e chiunque abbia l’indirizzo del contratto può interagirvi, in una certa misura. Cosa succede se decidiamo, come proprietari, di rimuovere il contratto dalla blockchain? Fortunatamente, Solidity offre un metodo incredibilmente facile, forse troppo semplice, per porre fine al contratto. Possiamo eseguire l’operazione di autodistruzione. Quando autodistruggiamo il contratto, tutto il restante Ether memorizzato all’indirizzo viene inviato a un target designato e il contratto non esiste più.

Vogliamo assicurarci che tale operazione possa essere eseguita solo dal creatore del contratto. Potrebbe essere catastrofico trascurare l’assegnazione dei privilegi di autodistruzione a una certa persona. Dobbiamo quindi prima dire al nostro contratto chi è il proprietario, che è msg.sender. Andiamo avanti e impostiamo il proprietario della variabile di stato come msg.sender. Poiché msg.sender è associato a un indirizzo, dobbiamo anche dire a Solidity che la variabile di stato verrà assegnata come indirizzo.


pragma solidity ^0.4.16;
contract HelloWorld {
 
 uint256 counter = 5; //state variable we assigned earlier
 address owner = msg.sender; //set owner as msg.sender
 ........
}

Chiameremo la funzione autodistruzione “kill” e creeremo anche un’istruzione condizionale if per garantire che la persona che esegue la funzione kill sia effettivamente il proprietario. Definiremo anche il selfdestruct (proprietario); dirà al contratto di inviare tutti i fondi presenti al proprietario.



pragma solidity ^0.4.16;
contract HelloWorld {
 
 uint256 counter = 5; //state variable we assigned earlier
 address owner = msg.sender; //set owner as msg.sender
function add() public {  //increases counter by 1
  counter++;
 }
 
 function subtract() public { //decreases counter by 1
  counter--;
 }
 function getCounter() public constant returns (uint256) {
  return counter;
    } 
 function kill() public { //self-destruct function, 
   if(msg.sender == owner) {
    selfdestruct(owner); 
        }
}

Ora possiamo tornare a Mist e ridistribuire un nuovo contratto con la funzione kill () che abbiamo aggiunto. Per vedere la funzione kill () in pieno vigore, implementeremo il nuovo contratto, invieremo l’ether al contratto, quindi inizializzeremo kill () e vedremo il nostro ether tornare nel nostro wallet. Allo stesso modo, dobbiamo anche creare una funzione che viene eseguita ogni volta che il nostro contratto riceve Ether. Per ricevere Ether, una funzione di fallback deve essere contrassegnata come pagabile nel contratto. Se tale funzione non esiste, il contratto non può ricevere Ether. Aggiungiamo la funzione sotto al nostro contract, può essere posizionata sotto la funzione kill ().



function () public payable {
 
 }

Bene, ora il nostro smart contract può ricevere Ether da qualsiasi wallet che abbia l’indirizzo del contratto. Vai avanti e fai clic su “Deploy” per implementare il nuovo contratto e inviare la tua password. Assicurati che il tuo contratminer sia in esecuzione per confermare la transazione. Una volta completato, torna al contratto e fai clic su “Copy address”. Riceverai un messaggio di avviso che ti ricorda che sei su una rete di test, seleziona “copy anyway”.

contract

Inviamo un po’ di Ether

Abbiamo copiato l’indirizzo del nostro contract e ora possiamo inviare un po ‘di Ether per testare la nostra funzione kill (). Fare clic sulla scheda “Send” e copia l’indirizzo del contract nel campo “a”. Inserisci l’ether che desideri inviare per questo test.

contract

contract

Adesso conosci la routine, scorri verso il basso e fai clic su “send”, attiva il miner e attendi che la transazione venga elaborata. Dovresti notare subito che il tuo wallet non contiene più l’ether che abbiamo inviato al contratto. Seleziona la funzione kill sotto il menu “Seleziona funzione” e vai avanti distruggendo il contratto. Inserisci la tua password e avvia il miner. Dopo 12/12 conferme, il tuo wallet verrà ripristinato con l’Ether che abbiamo inviato al contract. Ora il contratto è inutilizzabile, ma la sua storia esiste ancora sulla blockchain.

cripto

Vi invitiamo a seguirci sul nostro canale Telegram ed anche sul gruppo ufficiale Telegram, dove sarà possibile discutere insieme delle notizie e dell’andamento del mercato, sulla nostra pagina Facebook e sul nostro account Twitter.


La più grande community italiana dedicata alle criptovalute: Italian Crypto Club (ICC)

[VIA]

Stefano Cavalli

Nato a Parma, classe '92. Laureato in Ingegneria Informatica Elettronica e delle Telecomunicazioni all'Università degli Studi di Parma. Appassionato da anni in tecnologia Blockchain, economia decentralizzata e criptovalute. Esperto in Web-Development & Software-Development.
Follow Me:

Related Posts

  1. Andrea Pellegrino says:

    Ciao, prima di tutto volevo ringraziarti per la tua guida molto intuitiva e completa. Volevo provare a pubblicare su mist un contratto composto da più contratti, vedi i contratti standard come quelli che fornisce openzeppelin etc, come faccio? Ho provato pubblicandone uno alla volta ma MIST mi da un errore, ti metto lo screen del messaggio. Provando a pubblicare il primo contratto che non deve ereditare variabili da altri contratti

    https://ibb.co/ksNhdy

    grazie mille.

  2. Synchronisation failed

    Ciao Complimenti per la guida.
    mi sto affacciando per la prima volta agli smat contract e dopo la teoria volevo passare alla pratica, ma ho un problema:
    Dopo aver installato Get e Git, inizio finanlmente la sincronizzazione (previsto ad oggi 74GB).
    Dopo due gg di download, controllo il disco ed effettivamente ha scaricato i 74GB bella BC, il problema è che contina a darmi il seguente errore:

    WARN [05-26|13:35:57] Synchronisation failed, dropping peer peer=038f4aaa05d36b1c err=”retrieved hash chain is invalid”
    INFO [05-26|13:43:14] Regenerated local transaction journal transactions=0 accounts=0
    WARN [05-26|13:49:04] Synchronisation failed, dropping peer peer=ddf78aea032ab522 err=timeout

    Tenta più volte la sincronizzazione ma alla fine risulta fallita.
    Cosa Posso fare??
    Grazie.

Rispondi