Contratti Ethereum Oracle: configurazione e orientamento

Gli Smart Contract di Ethereum sono molto più che "la nuova cosa calda". Sono convinto che loro (o qualcosa di correlato) siano pronti a cambiare il modo in cui gli esseri umani fanno affari tra loro nella nuova era imminente di Internet. Il tempo dirà se è così.

Questo è il primo di un articolo in tre parti sullo sviluppo di contratti intelligenti di Ethereum con Solidity, esplorando in particolare l'uso dei contratti con i cosiddetti "oracoli", che sono fondamentalmente contratti che pompano dati nella blockchain per l'utilizzo da parte di altri contratti intelligenti.

• Parte 1: Introduzione allo sviluppo con Tartufo e impostazione del progetto per ulteriori sperimentazioni
• Parte 2: Approfondimento del codice per un esame più approfondito
• Parte 3: Una discussione concettuale sugli oracoli con i contratti intelligenti

L'obiettivo di questo, parte 1 della serie, non è quello di approfondire il concetto di contratti oracolari, la filosofia dietro di essi, o anche molto profondamente ciò che sono; l'obiettivo di questa parte del nostro tutorial sull'oracolo di Ethereum è semplicemente quello di:

• Preparati a creare contratti intelligenti con Tartufo.
• Costruisci un progetto di smart contract che ci servirà nelle parti 2 e 3.
• Introduci alcuni concetti relativi agli smart contract di Ethereum e alla codifica degli smart contract.
• Introduci il ciclo di compilazione/esecuzione/debug con Tartufo e contratti intelligenti.

Definizione: Oracolo. Un mezzo per gli smart contract per accedere ai dati dal mondo al di fuori della blockchain. A loro volta un tipo di smart contract, gli oracoli prendono i dati dal mondo esterno e li inseriscono nella blockchain affinché altri smart contract li consumino.

La prima parte di questo articolo consisterà nel prepararsi con tutti i prerequisiti. Quindi, imposteremo un singolo contratto Ethereum e lo testeremo con Truffle. Infine, separeremo l'oracolo dal cliente e li testeremo insieme.

Requisiti software

• Qualsiasi sistema operativo principale funzionerà, anche se alcune installazioni e impostazioni saranno ovviamente diverse su sistemi diversi. Ho fatto tutto questo su Ubuntu Linux (16.04). Inoltre, non ho avuto problemi a configurare l'ambiente su Windows. Non ho provato Mac, anche se sono consapevole che è comune farlo anche su Mac.
• Non è necessario eseguire un nodo eth completo; useremo Tartufo, che viene fornito con la propria rete di test. Se sai un po' quello che stai facendo, puoi usare qualsiasi altro testnet di tua scelta; Il testnet di sviluppo locale di Truffle è solo il più semplice e accessibile ai fini di questo tutorial.

Requisiti di conoscenza

• Conoscenza di base di come funziona la blockchain
• Comprensione di cosa sia uno smart contract basato su blockchain
• Una certa esperienza di base con lo sviluppo di contratti intelligenti sarà utile, ma non necessaria se sei intelligente e ambizioso. (E so che lo sei!)

Questa serie di articoli può servire come prima introduzione ai contratti intelligenti, ma si sviluppa molto rapidamente in concetti più avanzati. Se è il tuo primo tutorial su eth smart contract, preparati a salire rapidamente in quota. Se ti senti sicuro, fantastico; in caso contrario, sentiti libero di ottenere prima un tipo di tutorial più semplice "ciao mondo" o due sotto la cintura. Dai un'occhiata a uno o ai precedenti articoli di Ethereum e Cryptozombies, per cominciare.

Avvertenza: lo spazio degli smart contract, essendo così nuovo, cambia rapidamente. Le funzionalità della sintassi di Solidity che erano nuove quando è stato scritto questo articolo potrebbero essere obsolete o obsolete nel momento in cui stai leggendo questo articolo. Le versioni Geth potrebbero essere andate e venute. La solidità aggiunge sempre nuove funzionalità linguistiche e disapprova quelle vecchie. Molte nuove funzionalità sono attualmente in lavorazione. Quindi, preparati, se necessario, ad adattare le informazioni in questo articolo al nuovo panorama del futuro; se sei seriamente intenzionato a imparare lo sviluppo di contratti intelligenti, allora ho fiducia in te.

Descrizione dell'app di esempio

Caso d'uso: gli utenti scommettono sugli incontri di boxe.

• L'utente può tirare un elenco di incontri di boxe scommettibili.
• L'utente può scegliere una partita e piazzare una scommessa sul vincitore.
• L'utente può scommettere qualsiasi importo al di sopra di un minimo specificato.
• Se la scelta dell'utente perde, l'utente perde l'intero importo della scommessa.
• Se la scelta dell'utente vince, l'utente riceve una parte del piatto in base all'importo della sua scommessa e all'importo totale scommesso sul perdente dell'incontro, dopo che la casa (il proprietario del contratto) ha preso una piccola percentuale delle vincite .

Che cos'è un oracolo di Ethereum?

Gli smart contract sono ancora una specie di novità; devono ancora prendere il mainstream e così tanti aspetti di come funzioneranno non sono stati ancora elaborati e standardizzati. Spiegherò brevemente lo slancio dietro l'idea dell'“oracolo” e sii paziente; ne parleremo più approfonditamente nelle parti successive.

Progettare un contratto blockchain non è come programmare un'app client-server. Una differenza importante è che i dati con cui interagisce il contratto devono essere già sulla blockchain. Non ci sono chiamate fuori dalla blockchain. Non solo non è supportato dal linguaggio, non è supportato dal paradigma blockchain. Il contratto può accettare scommesse sotto forma di valuta basata su Ethereum, memorizzarle nel contratto e rilasciarle agli indirizzi di portafoglio corretti secondo una formula, quando viene dichiarato il vincitore di una partita. Ma come fa il contratto a conoscere il vincitore? Non può interrogare un'API REST o qualcosa del genere. Può utilizzare solo dati che sono già nella blockchain! Molti molti casi d'uso di contratti intelligenti incontrano un problema simile: sono seriamente limitati a meno che non possano interagire con il mondo al di fuori della blockchain.

Se il contratto può interagire solo con i dati sulla blockchain, una soluzione ovvia è iniettare i dati necessari nella blockchain. Ed ecco cos'è un oracolo. Un oracolo è un altro contratto, che inietta i dati nella blockchain, consentendo ad altri contratti di consumarli. Anche se ciò può sollevare domande sulla fiducia e sull'inaffidabilità, accetta per ora che questo è ciò che è un oracolo. Nella parte 3 di questa serie, discuteremo di queste sfumature. Nel nostro caso d'uso di esempio, l'oracolo sarà il contratto che inietta i dati nella blockchain, riguardanti (a) quali partite sono disponibili e (b) chi ha vinto quelle partite, una volta deciso.

Configurazione dell'ambiente di sviluppo di Ethereum

Per la configurazione di base, installeremo:

• Geth (opzionale per ora)
• Tartufo
• Ganache CLI (opzionale)
• Un ambiente di sviluppo (opzionale)

Questo articolo non ha lo spazio per essere una guida completa alla configurazione dell'ambiente, ma funge solo da guida approssimativa. Va bene, però, perché ci sono già molte guide di installazione più complete per il tuo particolare sistema operativo e Internet non ha davvero bisogno di una nuova. Quindi ti guiderò rapidamente lungo il percorso e ti indirizzerò verso alcune risorse per ottenere maggiori dettagli secondo necessità. Preparati a installare requisiti e prerequisiti come richiesto dal tuo sistema e come indicato da Google.

Installa Geth (opzionale)

Clicca per vedere l'immagine a grandezza naturale.

Geth è Go-ethereum, il software principale di Ethereum; sebbene non sia affatto necessario per questo esercizio, sarebbe opportuno che qualsiasi aspirante sviluppatore di Ethereum lo possedesse e lo conoscesse. Sarà necessario se hai intenzione di distribuire il tuo smart contract sulla rete Ethereum live.

• http://www.talkcrypto.org/blog/2018/01/23/what-is-geth/
• https://github.com/ethereum/go-ethereum/wiki/Installation-Instructions-for-Ubuntu
• https://github.com/ethereum/go-ethereum/wiki/Installation-instructions-for-Windows

Installa il tartufo

Clicca per vedere l'immagine a grandezza naturale.

Il tartufo è la cosa principale che useremo per lo sviluppo ed è assolutamente un requisito per questa guida. Trova e segui le istruzioni specifiche per il tuo sistema operativo per installare Tartufo. Di seguito sono riportati alcuni collegamenti che si spera possano aiutarti.

• https://truffleframework.com/docs/truffle/getting-started/installation
• https://github.com/trufflesuite/truffle
• https://truffleframework.com/tutorials/how-to-install-truffle-and-testrpc-on-windows-for-blockchain-development

Installa Ganache CLI (opzionale)

Clicca per vedere l'immagine a grandezza naturale.

Raccomando di installare Ganache CLI da utilizzare come altro strumento di test, anche se in realtà non lo utilizzeremo per il nostro tutorial. È facoltativo.

https://github.com/trufflesuite/ganache-cli

Ambiente di sviluppo di Ethereum

Sarebbe più che possibile eseguire l'intero tutorial con qualsiasi semplice editor di testo, come Notepad ++, gedit, vi o qualsiasi editor di testo o IDE di tua scelta. Personalmente sto usando Visual Studio Code con le seguenti estensioni:

• Solidità
• Solidità estesa
• Tema icona materiale

Nota: le estensioni non sono necessarie, creano solo un ambiente di codifica migliore.

Impostazione del codice

Configurazione del progetto

Il tartufo è uno strumento molto conveniente per compilare contratti intelligenti, migrarli su una blockchain e fornisce anche utilità di sviluppo e debug. Saranno necessari alcuni setup di progetto per integrarsi con il tartufo. Ora configureremo la shell per il nostro progetto, sia in Truffle che nella struttura delle directory. Siediti, segui i passaggi in modo robotico per ora e divertiti.

Creare una directory per ospitare tutto il codice; chiamalo esempio di oracolo .

All'interno della directory principale, crea due sottodirectory, perché alla fine il progetto sarà composto da due sottoprogetti. Crea le directory:

• /esempio-oracolo/client
• /esempio-oracolo/oracolo

Vai nella cartella client, perché questo è il primo progetto che svilupperemo. Aprire una finestra del terminale (riga di comando) nella cartella /oracle-example/client .

Esegui il comando truffle init .

Nota che tra i molti file creati ci sono tartufo-config.js e tartufo.js . Non abbiamo bisogno di entrambi, quindi elimina tartufo-config.js (solo per evitare confusione e disordine).

Abbiamo bisogno di modificare tartufo.js , per indirizzare Tartufo nella giusta direzione per il test. Sostituisci il contenuto di tartufo.js con il seguente:

 module.exports = { networks: { development: { host: "localhost", port: 8545, network_id: "*" // Match any network id } } };

https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/truffle.js

Nota che Truffle init ha creato una directory chiamata migrations ( oracle-example/client/migrations ). All'interno di quella cartella dovrebbe esserci un file chiamato 1_initial_migration.js .

Aggiungi un altro file nella directory delle migrazioni e denominalo 2_deploy_contracts.js , con il seguente contenuto:

 var BoxingBets = artifacts.require("BoxingBets"); module.exports = function(deployer) { deployer.deploy(BoxingBets); };

https://github.com/jrkosinski/oracle-example/tree/part1-step1

Aggiunta del codice

Ora che la semplice configurazione è fuori mano, siamo pronti per iniziare la codifica. Ricorda, questa parte dell'articolo è ancora introduzione e configurazione, quindi esamineremo piuttosto rapidamente il codice. Entreremo in spiegazioni più approfondite del codice nella parte 2 e in una discussione più approfondita dell'architettura e del concetto nella parte 3. Detto questo, toccheremo rapidamente alcuni concetti fondamentali evidenti nel codice. Segui attentamente per stare al passo.

Il codice completo per questo passaggio del processo è disponibile su GitHub: https://github.com/jrkosinski/oracle-example/tree/part1-step1

Contratti in Solidità

Un "contratto" in Solidity è più o meno analogo a una classe in altri linguaggi orientati agli oggetti. Il linguaggio stesso è stato paragonato, tra gli altri, a Golang e JavaScript. Alcuni altri costrutti di linguaggio in Solidity, di cui avremo esempi in seguito, sono modificatori, librerie e interfacce. L'ereditarietà (inclusa l'ereditarietà multipla) è supportata per i contratti. I file di contratto Solidity hanno un'estensione .sol.

Interfaccia Oracle

Aggiungi questo file al tuo progetto: /oracle-example/client/contracts/OracleInterface.sol

https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/contracts/OracleInterface.sol

Clicca per vedere l'immagine a grandezza naturale.

Normalmente, l'interfaccia di Oracle sarebbe proprio questo: un'interfaccia. Per questa primissima iterazione, è solo una semplice classe contenuta all'interno del progetto Solidity, solo come segnaposto per ora. Lo sposteremo nel passaggio successivo, dopo aver compilato ed eseguito correttamente il contratto su Tartufo. Dopo averlo convertito in un'interfaccia effettiva in seguito, le implementazioni della funzione saranno vuote.

Contratto con il cliente

Aggiungi questo file al tuo progetto: /oracle-example/client/contracts/BoxingBets.sol

https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/contracts/BoxingBets.sol

Questo è il contratto che consuma i dati degli incontri di boxe, consente agli utenti di interrogare le partite disponibili e piazzare scommesse su di esse. Nelle iterazioni successive, calcolerà e pagherà le vincite.

Compilazione ed esecuzione

Ora è quando vedremo se abbiamo fatto tutto bene la prima volta!

Compila e migra il contratto

Apri un terminale nella cartella /oracle-example/client/

Compila il codice con questo comando:

 truffle compile 

Clicca per vedere l'immagine a grandezza naturale.

Clicca per vedere l'immagine a grandezza naturale.

In alternativa: usa il mio script di shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/recompile.sh).

Nota che vedrai molti avvisi, perché il nostro codice non è ancora nella sua forma finale!

Apri la console di sviluppo Tartufo:

 truffle develop

Ora, nella console per sviluppatori di Truffle, migra alla rete di test:

 truffle(develop)> migrate

Esegui il contratto

Al prompt della console di sviluppo, immettere la seguente riga di codice:

 truffle(develop)> BoxingBets.deployed().then(inst => { instance = inst })

Ora, "istanza" è la variabile che si riferisce al contratto BoxingBets e può essere utilizzata per chiamare i suoi metodi pubblici.

Provalo usando il seguente comando:

 truffle(develop)> instance.test(3, 4)

Nota che abbiamo incluso una funzione di "test" pubblica in BoxingBets.sol . Somma tutti i due numeri che gli passi, solo per dimostrare che il contratto sta eseguendo codice e che possiamo chiamarlo dalla console di sviluppo di Truffle. Se otteniamo una risposta dall'aspetto sano (vedi sotto), il nostro lavoro qui è finito (almeno per ora).

Separa l'oracolo di Ethereum

Se tutto è riuscito finora, allora siamo oltre il baratro. La prossima cosa che faremo è separare il contratto Oracle dal contratto BoxingBets. Nell'uso reale, il contratto dell'oracolo esisterà separatamente dal contratto del cliente sulla blockchain, quindi dovremo essere in grado di:

• Crea un'istanza tramite l'indirizzo blockchain.
• Modifica dinamicamente l'indirizzo Oracle utilizzato dal contratto client per fare riferimento a Oracle.

Quindi, in breve, quello che faremo ora è separare l'oracolo e il cliente in due entità contrattuali blockchain separate e farli parlare tra loro. Il cliente istanzia l'oracolo per indirizzo e lo chiamerà.

Contratto con il cliente

Per prima cosa, cambieremo il contratto client (client) in modo che faccia riferimento a un'interfaccia dinamica a un oracolo piuttosto che a una classe concreta. Quindi ci assicureremo che istanzia l'oracolo da un contratto esterno.

Vai in /oracle-example/client/contracts/OracleInterface.sol . Come abbiamo notato prima, questa non è attualmente un'interfaccia, ma stiamo per farne una. Sostituisci quello che c'è dentro con il contenuto di:

https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts/OracleInterface.sol

 pragma solidity ^0.4.17; contract OracleInterface { enum MatchOutcome { Pending, //match has not been fought to decision Underway, //match has started & is underway Draw, //anything other than a clear winner (eg cancelled) Decided //index of participant who is the winner } function getPendingMatches() public view returns (bytes32[]); function getAllMatches() public view returns (bytes32[]); function matchExists(bytes32 _matchId) public view returns (bool); function getMatch(bytes32 _matchId) public view returns ( bytes32 id, string name, string participants, uint8 participantCount, uint date, MatchOutcome outcome, int8 winner); function getMostRecentMatch(bool _pending) public view returns ( bytes32 id, string name, string participants, uint participantCount, uint date, MatchOutcome outcome, int8 winner); function testConnection() public pure returns (bool); function addTestData() public; }

In BoxingBets.sol sostituiremo questa riga:

 OracleInterface internal boxingOracle = new OracleInterface();

Con queste due righe:

 address internal boxingOracleAddr = 0; OracleInterface internal boxingOracle = OracleInterface(boxingOracleAddr);

Ora quello che vogliamo è un modo per impostare l'indirizzo dell'oracolo, in modo dinamico, e una funzione che possiamo chiamare per scoprire l'indirizzo attuale dell'oracolo. Aggiungi queste due funzioni a BoxingBets.sol :

 /// @notice sets the address of the boxing oracle contract to use /// @dev setting a wrong address may result in false return value, or error /// @param _oracleAddress the address of the boxing oracle /// @return true if connection to the new oracle address was successful function setOracleAddress(address _oracleAddress) external onlyOwner returns (bool) { boxingOracleAddr = _oracleAddress; boxingOracle = OracleInterface(boxingOracleAddr); return boxingOracle.testConnection(); } /// @notice gets the address of the boxing oracle being used /// @return the address of the currently set oracle function getOracleAddress() external view returns (address) { return boxingOracleAddr; }

E infine, per testare la connessione tra il client e l'oracolo, possiamo sostituire la funzione di test in BoxingBets con una funzione per testare la connessione dell'oracolo:

 /// @notice for testing; tests that the boxing oracle is callable /// @return true if connection successful function testOracleConnection() public view returns (bool) { return boxingOracle.testConnection(); }

Possedibile

Si noti che la definizione di setOracleAddress ha un modificatore onlyOwner che la segue. Ciò impedisce a questa funzione di essere chiamata da chiunque non sia il proprietario del contratto, anche se la funzione è pubblica. Questa non è una caratteristica della lingua. Questo ci viene fornito dal contratto Ownable, che viene ritirato dalla libreria di OpenZeppelin di contratti Solidity di utilità generale. Entreremo nei dettagli di ciò nella Parte 2, ma per facilitare l'uso di quel modificatore onlyOwner , dobbiamo apportare alcune modifiche:

Copia Ownable.sol da https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts/Ownable.sol in /oracle-example/client/contracts/ .

Aggiungi un riferimento ad esso nella parte superiore di BoxingBets.sol , in questo modo:

 import "./Ownable.sol";

(Puoi aggiungerlo appena sotto la riga che importa OracleInterface.sol .)

Modificare la dichiarazione del contratto di BoxingBets per farla ereditare da Ownable, da questo:

 contract BoxingBets {

A questo:

 contract BoxingBets is Ownable {

E dovremmo essere a posto. Il codice completo è qui nel caso ti fossi perso: https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts

Contratti Oracle

Impostare

Ora che il contratto BoxingBets sta tentando di fare riferimento a un contratto completamente separato (che è l'oracolo) per indirizzo, il nostro prossimo lavoro è creare quel contratto oracolo. Quindi ora creeremo un intero progetto separato che conterrà il contratto Oracle. È essenzialmente la stessa configurazione che abbiamo già fatto per il progetto del contratto con il cliente; cioè, impostare Tartufo per la compilazione e lo sviluppo.

Dovresti già avere una cartella chiamata /oracle-example/oracle/ che abbiamo creato in un passaggio precedente (o in caso contrario, vai avanti e crea quella directory vuota ora). Apri un terminale in quella directory.

• Esegui il comando truffle init .
• Elimina /oracle-example/oracle/truffle-config.js .
• Modifica /oracle-example/oracle/truffle.js in questo modo:

 module.exports = { networks: { development: { host: "localhost", port: 8545, network_id: "*" // Match any network id } } };

Vedi l'esempio qui: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/truffle.js

All'interno di /oracle-example/oracle/migrations/ , crea un file chiamato 2_deploy_contracts.js , con il seguente contenuto:

 var BoxingOracle = artifacts.require("BoxingOracle"); module.exports = function(deployer) { deployer.deploy(BoxingOracle); };

Vedi l'esempio qui: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/migrations/2_deploy_contracts.js

Codice Oracle

Per questo passaggio, copia semplicemente i seguenti tre file da https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/contracts/ nella cartella /oracle-example/oracle/contracts/ :

• BoxingOracle.sol: Il contratto principale dell'oracolo.
• Ownable.sol: per le funzioni riservate al proprietario, come già utilizzato nel contratto con il cliente.
• DateLib.sol: una libreria di date. Lo esamineremo in modo più approfondito nella parte 2 di questa serie.

Testare l'Oracolo

Ora, nell'attuale iterazione del progetto, abbiamo davvero bisogno di testare a fondo il nostro oracolo del contratto intelligente, poiché quella sarà la nostra base su cui costruiremo il resto del progetto. Quindi, ora che abbiamo impostato il progetto Oracle e copiato il codice, vorremo:

• Compila l'oracolo.
• Assicurati che l'oracolo funzioni.
• Esegui alcune funzioni nella console Truffle per assicurarti che l'oracolo funzioni come previsto.

Compila e migra l'Oracolo

Sempre in un terminale aperto su /oracle-example/oracle/ , esegui i seguenti comandi. Anche in questo caso, questi passaggi sono identici a quelli che abbiamo già fatto per compilare e migrare il contratto client.

 truffle compile

In alternativa: usa il mio script di shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/recompile.sh).

Apri la console di sviluppo Tartufo:

 truffle develop

Migra alla rete di prova:

 truffle(develop)> migrate

Esegui e prova l'Oracolo

Sempre nella console di sviluppo di Truffle, inserisci questo per acquisire un puntatore utilizzabile al contratto Oracle:

 truffle(develop)> BoxingOracle.deployed().then(inst => { instance = inst })

Ora possiamo (e dovremmo) eseguire una serie di test sul nostro contratto Oracle per testarlo. Prova a eseguire i seguenti comandi, ciascuno a turno, ed esamina i risultati.

 truffle(develop)> instance.testConnection() ... truffle(develop)> instance.getAllMatches() ... truffle(develop)> instance.addTestData() ... truffle(develop)> instance.getAllMatches() ...

A questo punto sei incoraggiato a dare un'occhiata al codice Oracle, vedere quali metodi pubblici sono disponibili, leggere i commenti nel codice e trovare alcuni dei tuoi test da eseguire (ed eseguirli qui nella console, come sopra riportati).

Test e debug

Ora siamo pronti per il test finale: per verificare che il contratto del cliente possa chiamare il contratto Oracle che è già sulla blockchain, e inserire e utilizzare i suoi dati. Se tutto questo funziona, allora abbiamo una coppia cliente-oracolo che possiamo usare per ulteriori sperimentazioni. I nostri passaggi per eseguire il test end-to-end:

• Compila ed esegui il contratto Oracle
• Compila ed esegui il contratto cliente
• Ottieni l'indirizzo del contratto Oracle
• Imposta l'indirizzo Oracle nel contratto del cliente
• Aggiungi i dati del test al contratto Oracle
• Verifica che possiamo recuperare quei dati nel contratto del cliente

Apri due finestre di terminale:

• Uno in /oracle-example/client/
• E l'altro in /oracle-example/oracle/

Ti suggerisco di tenere aperto /oracle-example/client/ a sinistra e /oracle-example/oracle/ aperto a destra e segui attentamente per evitare confusione.

Compila ed esegui il contratto Oracle

Esegui i seguenti comandi nel terminale /oracle-example/oracle/ :

 bash recompile.sh truffle develop truffle(develop)> migrate truffle(develop)> BoxingOracle.deployed().then(inst => { instance = inst })

Compila ed esegui il contratto cliente

Esegui i seguenti comandi nel terminale /oracle-example/client/ :

 bash recompile.sh truffle develop truffle(develop)> migrate truffle(develop)> BoxingBets.deployed().then(inst => { instance = inst })

Ottieni l'indirizzo del contratto Oracle

Esegui il seguente comando su Truffle nel terminale /oracle-example/oracle/ :

 truffle(develop)> instance.getAddress()

Copia l'indirizzo che è l'output di questa chiamata; e usalo nel passaggio successivo.

Impostare l'indirizzo Oracle nel contratto cliente

Esegui il comando seguente per eseguire il tartufo nel terminale /oracle-example/client/ :

 truffle(develop)> instance.setOracleAddress('<insert address here, single quotes included>')

E provalo:

 truffle(develop)> instance.testOracleConnection()

Se l'output è true , allora siamo a posto.

Verifica che possiamo recuperare quei dati nel contratto del cliente

Esegui il comando seguente per eseguire il tartufo nel terminale /oracle-example/client/ :

 truffle(develop)> instance.getBettableMatches()

Dovrebbe restituire un array vuoto, perché nessun dato di test è stato ancora aggiunto al lato Oracle.

Esegui il comando seguente per eseguire il tartufo nel terminale /oracle-example/oracle/ per aggiungere i dati del test:

 truffle(develop)> instance.addTestData()

Esegui il seguente comando per tartufare nel terminale /oracle-example/client/ , per vedere se possiamo raccogliere i dati di test appena aggiunti dal client:

 truffle(develop)> instance.getBettableMatches()

Ora, se prendi i singoli indirizzi dall'array restituito da getBettableMatches() , e li inserisci in getMatch() .

A questo punto sei incoraggiato a dare un'occhiata al codice client, vedere quali metodi pubblici sono disponibili, leggere i commenti nel codice e trovare alcuni dei tuoi test da eseguire (ed eseguirli qui nella console, come sopra).

Conclusione della prima parte

I nostri risultati di questo esercizio sono limitati, ma lo erano anche i nostri obiettivi, al fine di mantenere un ritmo realistico. Il nostro cliente non ha ancora la capacità di accettare scommesse, gestire fondi, spartire le vincite, ecc. Quello che abbiamo, a parte le conoscenze e l'esperienza acquisite, è:

• Un oracolo smart contract per lo più funzionale
• Un client in grado di connettersi e interagire con Oracle
• Un quadro per l'ulteriore sviluppo e apprendimento

E non è male per un breve articolo.

Nella seconda parte di questa serie , approfondiremo il codice e esamineremo alcune delle funzionalità esclusive dello sviluppo di contratti intelligenti, nonché alcune delle funzionalità del linguaggio specifiche di Solidity. Molte delle cose che sono state appena tralasciate in questa parte verranno spiegate nella prossima.

Nella terza parte di questa serie , parleremo un po' della filosofia e del design degli smart contract, in particolare in relazione al loro utilizzo con gli oracoli.

Ulteriori passaggi opzionali

La sperimentazione in solitaria è un buon modo per imparare. Ecco alcuni semplici suggerimenti se stai pensando a come estendere questo tutorial per una maggiore conoscenza (nessuno dei seguenti sarà trattato nelle parti 2 e 3):

• Distribuire i contratti su Ganache (precedentemente testrpc) ed eseguire gli stessi test per verificarne il funzionamento.
• Distribuire i contratti per ropsten o rinkeby testnet ed eseguire gli stessi test per verificarne il funzionamento.
• Crea un front-end web3js per l'oracle o il client (o entrambi).

Buona fortuna e non esitate a contattarmi per qualsiasi domanda. Non posso garantire necessariamente una risposta rapida, ma farò del mio meglio.