Contrats Oracle Ethereum : configuration et orientation

Les contrats intelligents Ethereum sont plus que "la nouvelle chose à la mode". Je crois qu'ils (ou quelque chose de similaire) sont sur le point de changer la façon dont les humains font des affaires les uns avec les autres dans la nouvelle ère d'Internet. Le temps nous dira si c'est le cas.

Ceci est le premier d'un article en trois parties sur le développement de contrats intelligents Ethereum avec Solidity, explorant plus particulièrement l'utilisation de contrats avec des soi-disant «oracles» - qui sont essentiellement des contrats qui pompent des données dans la blockchain pour une utilisation par d'autres contrats intelligents.

• Partie 1 : Une introduction au développement avec Truffle et la configuration du projet pour une expérimentation plus poussée
• Partie 2 : Explorer le code pour un examen plus approfondi
• Partie 3 : Une discussion conceptuelle des oracles avec des contrats intelligents

Le but de cette partie 1 de la série n'est pas d'approfondir le concept des contrats oracle, la philosophie qui les sous-tend, ou même très profondément ce qu'ils sont ; le but de cette partie de notre tuto oracle Ethereum est simplement de :

• Préparez-vous à créer des contrats intelligents avec Truffle.
• Construisez un projet de contrat intelligent qui nous servira dans les parties 2 et 3.
• Présentez quelques concepts liés aux contrats intelligents Ethereum et au codage des contrats intelligents.
• Introduisez le cycle compilation/exécution/débogage avec Truffle et les contrats intelligents.

Définition : Oracle. Un moyen pour les contrats intelligents d'accéder aux données du monde en dehors de la blockchain. Un type de contrat intelligent eux-mêmes, les oracles prennent des données du monde extérieur et les mettent dans la blockchain pour que d'autres contrats intelligents les consomment.

La première partie de cet article consistera à se mettre en place avec tous les prérequis. Ensuite, nous mettrons en place un seul contrat Ethereum et le testerons avec Truffle. Enfin, nous séparerons l'oracle du client et les testerons ensemble.

Logiciels requis

• Tout système d'exploitation majeur fonctionnera, bien qu'une partie de l'installation et de la configuration soit bien sûr différente sur différents systèmes. J'ai fait tout cela sur Ubuntu Linux (16.04). Je n'ai également eu aucun problème pour configurer l'environnement sous Windows. Je n'ai pas essayé Mac, bien que je sois conscient qu'il est courant de le faire également sur Mac.
• Il n'est pas nécessaire d'exécuter un nœud eth complet ; nous utiliserons Truffle, qui est livré avec son propre testnet. Si vous savez un peu ce que vous faites, vous pouvez utiliser n'importe quel autre testnet de votre choix ; Le testnet de développement local de Truffle est simplement le plus simple et le plus accessible aux fins de ce didacticiel.

Connaissances requises

• Connaissance de base du fonctionnement de la blockchain
• Comprendre ce qu'est un contrat intelligent basé sur la blockchain
• Une expérience de base avec le développement de contrats intelligents sera utile, mais pas nécessaire si vous êtes intelligent et ambitieux. (Et je sais que tu l'es !)

Cette série d'articles peut servir de toute première introduction aux contrats intelligents, mais elle passe très rapidement à des concepts plus avancés. S'il s'agit de votre premier tutoriel sur les contrats intelligents eth, préparez-vous à monter rapidement en altitude. Si vous vous sentez en confiance, tant mieux ; sinon, n'hésitez pas à obtenir d'abord un ou deux tutoriels plus simples de type "hello world" à votre actif. Consultez l'un des articles précédents d'Ethereum et Cryptozombies, pour commencer.

Mise en garde : L'espace des contrats intelligents, étant si nouveau, change rapidement. Les fonctionnalités de syntaxe Solidity qui étaient nouvelles au moment de la rédaction de cet article peuvent être obsolètes ou obsolètes au moment où vous lisez ceci. Les versions Geth sont peut-être allées et venues. Solidity ajoute toujours de nouvelles fonctionnalités linguistiques et déprécie les anciennes. De nombreuses nouvelles fonctionnalités sont actuellement en préparation. Alors, préparez-vous si nécessaire à adapter les informations de cet article au nouveau paysage du futur ; si vous voulez vraiment apprendre le développement de contrats intelligents, alors j'ai confiance en vous.

Description de l'exemple d'application

Cas d'utilisation : les utilisateurs parient sur des matchs de boxe.

• L'utilisateur peut tirer une liste de matchs de boxe pariables.
• L'utilisateur peut choisir un match et placer un pari sur le gagnant.
• L'utilisateur peut miser n'importe quel montant au-dessus d'un minimum spécifié.
• Si le choix de l'utilisateur perd, l'utilisateur perd le montant total du pari.
• Si le choix de l'utilisateur gagne, l'utilisateur obtient une partie du pot en fonction de la taille de son pari et du montant total parié sur le perdant du match, après que la maison (le propriétaire du contrat) prend un petit pourcentage des gains .

Qu'est-ce qu'un oracle Ethereum ?

Les contrats intelligents sont encore une sorte de nouveauté ; ils n'ont pas encore pris le courant dominant, et tant d'aspects de leur fonctionnement n'ont pas encore été définis et standardisés. J'expliquerai brièvement l'impulsion derrière l'idée de «l'oracle» - et soyez patient; nous y reviendrons plus en profondeur dans les parties ultérieures.

Concevoir un contrat blockchain n'est pas comme programmer une application client-serveur. Une différence importante est que les données avec lesquelles le contrat interagit doivent déjà être sur la blockchain. Il n'y a pas d'appel hors de la blockchain. Non seulement il n'est pas pris en charge par le langage, mais il n'est pas pris en charge par le paradigme de la blockchain. Le contrat peut prendre des paris sous forme de devise basée sur Ethereum, les stocker dans le contrat et les libérer aux adresses de portefeuille correctes selon une formule, lorsque le vainqueur d'un match est déclaré. Mais comment le contrat connaît-il le gagnant ? Il ne peut pas interroger une API REST ou quelque chose comme ça. Il ne peut utiliser que des données déjà présentes dans la blockchain ! De nombreux cas d'utilisation de contrats intelligents se heurtent à un problème similaire : ils sont sérieusement limités à moins qu'ils ne puissent interagir avec le monde en dehors de la blockchain.

Si le contrat ne peut interagir qu'avec des données sur la blockchain, une solution évidente consiste à injecter les données nécessaires dans la blockchain. Et c'est ce qu'est un oracle. Un oracle est un autre contrat, qui injecte des données dans la blockchain, permettant à d'autres contrats de les consommer. Bien que cela puisse soulever des questions sur la confiance et l'absence de confiance, acceptez simplement pour l'instant que c'est ce qu'est un oracle. Dans la partie 3 de cette série, nous discuterons de ces nuances. Dans notre exemple de cas d'utilisation, l'oracle sera le contrat qui injecte des données dans la blockchain, concernant (a) les matchs disponibles et (b) qui a remporté ces matchs, une fois décidé.

Configuration de l'environnement de développement Ethereum

Pour la configuration de base, nous allons installer :

• Geth (facultatif pour le moment)
• Truffe
• Ganache CLI (facultatif)
• Un environnement de développement (facultatif)

Cet article n'a pas la place d'être un guide complet de la configuration de l'environnement, mais agit simplement comme un guide approximatif. Ce n'est pas grave, car il existe déjà de nombreux guides de configuration plus complets pour votre système d'exploitation particulier et Internet n'a pas vraiment besoin d'un nouveau. Je vais donc vous guider rapidement sur le chemin et vous orienter vers des ressources pour obtenir plus de détails si nécessaire. Soyez prêt à installer les exigences et les prérequis selon les besoins de votre système et selon les directives de Google.

Installer Geth (facultatif)

Cliquez pour voir l'image en taille réelle.

Geth est Go-ethereum, le logiciel de base d'Ethereum ; bien qu'il ne soit pas du tout nécessaire pour cet exercice, il incomberait à tout développeur potentiel d'Ethereum de l'avoir et de s'y familiariser. Ce sera nécessaire si vous comptez déployer votre contrat intelligent sur le réseau Ethereum en direct.

• 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

Installer Truffe

Cliquez pour voir l'image en taille réelle.

La truffe est la principale chose que nous allons utiliser pour le développement, et c'est absolument une exigence pour ce guide. Recherchez et suivez les instructions spécifiques à votre système d'exploitation pour installer Truffle. Vous trouverez ci-dessous quelques liens qui, espérons-le, vous aideront.

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

Installer Ganache CLI (facultatif)

Cliquez pour voir l'image en taille réelle.

Je recommande d'installer Ganache CLI pour l'utiliser comme un autre outil de test, bien que nous ne l'utilisions pas réellement pour notre didacticiel. C'est facultatif.

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

Environnement de développement Ethereum

Il serait plus que possible de faire tout ce tutoriel avec n'importe quel éditeur de texte simple, comme Notepad++, gedit, vi, ou n'importe quel éditeur de texte ou IDE de votre choix. Personnellement, j'utilise Visual Studio Code avec les extensions suivantes :

• Solidité
• Solidité étendue
• Thème d'icônes matérielles

Remarque : Les extensions ne sont pas obligatoires, elles permettent simplement d'améliorer l'environnement de codage.

Configurer le code

Configuration du projet

Truffle est un outil très pratique pour compiler des contrats intelligents, les migrer vers une blockchain, et il fournit également des utilitaires de développement et de débogage. Une configuration de projet sera nécessaire pour s'intégrer à Truffle. Nous allons maintenant configurer le shell de notre projet, à la fois dans Truffle et dans la structure des répertoires. Asseyez-vous, suivez les étapes de manière robotique pour le moment et profitez-en.

Créez un répertoire pour héberger tout le code ; appelez-le oracle-example .

Dans le répertoire racine, créez deux sous-répertoires, car à terme, le projet sera composé de deux sous-projets. Créez les répertoires :

• /exemple-oracle/client
• /exemple-oracle/oracle

Allez dans le dossier client, car c'est le premier projet que nous allons développer. Ouvrez une fenêtre de terminal (ligne de commande) dans le dossier /oracle-example/client .

Exécutez la commande truffle init .

Notez que parmi les nombreux fichiers créés figurent truffle-config.js et truffle.js . Nous n'avons pas besoin des deux, alors supprimez truffle-config.js (juste pour éviter la confusion et l'encombrement).

Nous devons éditer truffle.js afin d'orienter Truffle dans la bonne direction pour les tests. Remplacez le contenu de truffle.js par ce qui suit :

 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

Notez que Truffle init a créé un répertoire appelé migrations ( oracle-example/client/migrations ). Dans ce dossier doit se trouver un fichier nommé 1_initial_migration.js .

Ajoutez un autre fichier dans le répertoire des migrations et nommez-le 2_deploy_contracts.js , avec le contenu suivant :

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

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

Ajouter le code

Maintenant que la configuration simple est terminée, nous sommes prêts à commencer le codage. N'oubliez pas que cette partie de l'article est toujours une introduction et une configuration, nous allons donc parcourir assez rapidement le code. Nous entrerons dans des explications plus approfondies du code dans la partie 2, et une discussion plus approfondie de l'architecture et du concept dans la partie 3. Cela dit, nous aborderons rapidement certains concepts de base évidents dans le code. Suivez attentivement pour suivre.

Le code complet de cette étape du processus est disponible sur GitHub : https://github.com/jrkosinski/oracle-example/tree/part1-step1

Des contrats solidaires

Un « contrat » dans Solidity est à peu près analogue à une classe dans d'autres langages orientés objet. Le langage lui-même a été comparé à Golang et JavaScript, entre autres. Certaines autres constructions de langage dans Solidity - dont nous aurons des exemples plus tard - sont les modificateurs, les bibliothèques et les interfaces. L'héritage (y compris l'héritage multiple) est pris en charge pour les contrats. Les fichiers de contrat Solidity ont une extension .sol.

Interface Oracle

Ajoutez ce fichier à votre projet : /oracle-example/client/contracts/OracleInterface.sol

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

Cliquez pour voir l'image en taille réelle.

Normalement, l'interface oracle ne serait que cela : une interface. Pour cette toute première itération, c'est juste une simple classe contenue dans le projet Solidity, juste comme un espace réservé pour l'instant. Nous le déplacerons à l'étape suivante, après avoir compilé et exécuté avec succès le contrat sur Truffle. Après avoir converti cela en une interface réelle plus tard, les implémentations de fonction seront vides.

Contrat client

Ajoutez ce fichier à votre projet : /oracle-example/client/contracts/BoxingBets.sol

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

Il s'agit du contrat qui consomme les données des matchs de boxe, permet aux utilisateurs d'interroger les matchs disponibles et de placer des paris dessus. Dans les itérations ultérieures, il calculera et paiera les gains.

Compilation et exécution

C'est maintenant que nous verrons si nous avons tout bien fait du premier coup !

Compiler et migrer le contrat

Ouvrez un terminal dans le dossier /oracle-example/client/

Compilez le code avec cette commande :

 truffle compile 

Cliquez pour voir l'image en taille réelle.

Cliquez pour voir l'image en taille réelle.

Alternative : utilisez mon script shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/recompile.sh).

Notez que vous verrez beaucoup d'avertissements, car notre code n'est pas encore dans sa forme définitive !

Ouvrez la console de développement Truffle :

 truffle develop

Maintenant, dans la console développeur Truffle, migrez vers le réseau de test :

 truffle(develop)> migrate

Exécuter le contrat

À l'invite de la console de développement, saisissez la ligne de code suivante :

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

Maintenant, "instance" est la variable qui fait référence au contrat BoxingBets et peut être utilisée pour appeler ses méthodes publiques.

Testez-le à l'aide de la commande suivante :

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

Notez que nous avons inclus une fonction "test" publique dans BoxingBets.sol . Il additionne les deux nombres que vous lui transmettez, juste pour démontrer que le contrat exécute du code et que nous pouvons l'appeler depuis la console de développement Truffle. Si nous obtenons une réponse saine d'esprit (voir ci-dessous), notre travail ici est terminé (pour l'instant du moins).

Séparez l'Oracle Ethereum

Si tout a réussi jusqu'ici, alors nous avons franchi le cap. La prochaine chose que nous ferons est de séparer le contrat oracle du contrat BoxingBets. En utilisation réelle, le contrat de l'oracle existera séparément du contrat du client sur la blockchain, nous devrons donc pouvoir :

• Instanciez-le par adresse blockchain.
• Modifiez dynamiquement l'adresse oracle que le contrat client utilise pour référencer l'oracle.

Donc, en bref, ce que nous allons faire maintenant, c'est séparer l'oracle et le client en deux entités contractuelles blockchain distinctes, et les faire se parler. Le client va instancier l'oracle par adresse et l'appeler.

Contrat client

Tout d'abord, nous allons modifier le contrat client (client) afin qu'il fasse référence à une interface dynamique vers un oracle plutôt qu'à une classe concrète. Ensuite, nous nous assurerons qu'il instancie l'oracle à partir d'un contrat extérieur.

Allez dans /oracle-example/client/contracts/OracleInterface.sol . Comme nous l'avons noté précédemment, ce n'est actuellement pas une interface, mais nous sommes sur le point d'en faire une. Remplacez ce qu'il y a dedans par le contenu de :

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; }

Dans BoxingBets.sol , nous allons remplacer cette ligne :

 OracleInterface internal boxingOracle = new OracleInterface();

Avec ces deux lignes :

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

Maintenant, ce que nous voulons, c'est un moyen de définir l'adresse de l'oracle, dynamiquement, et une fonction que nous pouvons appeler pour connaître l'adresse actuelle de l'oracle. Ajoutez ces deux fonctions à 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; }

Et enfin, pour tester la connexion entre le client et l'oracle, nous pouvons remplacer la fonction test dans BoxingBets par une fonction pour tester la connexion oracle :

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

Propriétaire

Notez que la définition de setOracleAddress est suivie d'un modificateur onlyOwner . Cela empêche cette fonction d'être appelée par une personne autre que le propriétaire du contrat, même si la fonction est publique. Ce n'est pas une caractéristique de la langue. Cela nous est fourni par le contrat Ownable, qui est extrait de la bibliothèque de contrats d'utilité générale Solidity d'OpenZeppelin. Nous entrerons dans les détails de cela dans la partie 2, mais afin de faciliter l'utilisation de ce modificateur onlyOwner , nous devons apporter quelques modifications :

Copiez Ownable.sol de https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts/Ownable.sol dans /oracle-example/client/contracts/ .

Ajoutez-y une référence en haut de BoxingBets.sol , comme ceci :

 import "./Ownable.sol";

(Vous pouvez l'ajouter juste sous la ligne qui importe OracleInterface.sol .)

Modifier la déclaration contractuelle de BoxingBets pour la faire hériter de Ownable, à partir de ceci :

 contract BoxingBets {

Pour ça:

 contract BoxingBets is Ownable {

Et nous devrions être prêts. Le code complet est ici au cas où vous vous perdriez : https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts

Contrats Oracle

Installer

Maintenant que le contrat BoxingBets tente de se référer à un contrat complètement séparé (c'est-à-dire l'oracle) par adresse, notre prochaine tâche consiste à créer ce contrat oracle. Nous allons donc maintenant créer un projet entièrement séparé qui contiendra le contrat oracle. Il s'agit essentiellement de la même configuration que celle que nous avons déjà effectuée pour le projet de contrat client ; c'est-à-dire la configuration de Truffle pour la compilation et le développement.

Vous devriez déjà avoir un dossier appelé /oracle-example/oracle/ que nous avons créé à une étape précédente (ou sinon, allez-y et créez ce répertoire vide maintenant). Ouvrez un terminal dans ce répertoire.

• Exécutez la commande truffle init .
• Supprimez /oracle-example/oracle/truffle-config.js .
• Modifiez /oracle-example/oracle/truffle.js comme suit :

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

Voir l'exemple ici : https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/truffle.js

Dans /oracle-example/oracle/migrations/ , créez un fichier appelé 2_deploy_contracts.js , avec le contenu suivant :

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

Voir l'exemple ici : https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/migrations/2_deploy_contracts.js

Code Oracle

Pour cette étape, copiez simplement les trois fichiers suivants de https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/contracts/ dans votre dossier /oracle-example/oracle/contracts/ :

• BoxingOracle.sol : Le contrat oracle principal.
• Ownable.sol : pour les fonctions réservées au propriétaire, comme nous l'avons déjà utilisé dans le contrat client.
• DateLib.sol : une bibliothèque de dates. Nous l'examinerons plus en détail dans la partie 2 de cette série.

Tester l'Oracle

Maintenant, dans l'itération actuelle du projet, nous devons vraiment tester en profondeur notre oracle de contrat intelligent, car ce sera notre base sur laquelle nous construirons le reste du projet. Donc, maintenant que nous avons configuré le projet oracle et copié le code, nous voudrons :

• Compilez l'oracle.
• Assurez-vous que l'oracle s'exécute.
• Exécutez quelques fonctions dans la console Truffle pour vous assurer que l'oracle fonctionne comme prévu.

Compiler et migrer l'Oracle

Toujours dans un terminal ouvert sur /oracle-example/oracle/ , exécutez les commandes suivantes. Encore une fois, ces étapes sont identiques à ce que nous avons déjà fait pour compiler et migrer le contrat client.

 truffle compile

Alternative : utilisez mon script shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/recompile.sh).

Ouvrez la console de développement Truffle :

 truffle develop

Migrez vers le réseau de test :

 truffle(develop)> migrate

Exécutez et testez l'Oracle

Toujours dans la console de développement Truffle, entrez ceci pour capturer un pointeur utilisable vers le contrat oracle :

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

Maintenant, nous pouvons (et devrions) exécuter une suite de tests sur notre contrat oracle pour le tester. Essayez d'exécuter les commandes suivantes, chacune à son tour, et examinez les résultats.

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

Nous vous encourageons à ce stade à parcourir le code oracle, à voir quelles méthodes publiques sont disponibles, à lire les commentaires dans le code et à proposer certains de vos propres tests à exécuter (et à les exécuter ici dans la console, comme montré ci-dessus).

Test et débogage

Nous sommes maintenant prêts pour le test final : tester que le contrat client peut appeler le contrat oracle qui est déjà sur la blockchain, puis extraire et utiliser ses données. Si tout cela fonctionne, alors nous avons une paire client-oracle que nous pouvons utiliser pour d'autres expérimentations. Nos étapes pour exécuter le test de bout en bout :

• Compiler et exécuter le contrat oracle
• Compiler et exécuter le contrat client
• Obtenir l'adresse du contrat oracle
• Définir l'adresse oracle dans le contrat client
• Ajouter des données de test au contrat oracle
• Testez que nous pouvons récupérer ces données dans le contrat client

Ouvrez deux fenêtres de terminal :

• Un dans /oracle-example/client/
• Et l'autre dans /oracle-example/oracle/

Je vous suggère de garder le /oracle-example/client/ ouvert à gauche et le /oracle-example/oracle/ ouvert à droite, et de suivre attentivement pour éviter toute confusion.

Compiler et exécuter le contrat Oracle

Exécutez les commandes suivantes dans le terminal /oracle-example/oracle/ :

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

Compiler et exécuter le contrat client

Exécutez les commandes suivantes dans le terminal /oracle-example/client/ :

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

Obtenir l'adresse du contrat Oracle

Exécutez la commande suivante pour Truffle dans le terminal /oracle-example/oracle/ :

 truffle(develop)> instance.getAddress()

Copiez l'adresse qui est la sortie de cet appel ; et utilisez-le à l'étape suivante.

Définir l'adresse Oracle dans le contrat client

Exécutez la commande suivante pour truffler dans le terminal /oracle-example/client/ :

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

Et testez-le :

 truffle(develop)> instance.testOracleConnection()

Si la sortie est true , alors nous sommes prêts à partir.

Testez que nous pouvons récupérer ces données dans le contrat client

Exécutez la commande suivante pour truffler dans le terminal /oracle-example/client/ :

 truffle(develop)> instance.getBettableMatches()

Il doit renvoyer un tableau vide, car aucune donnée de test n'a encore été ajoutée du côté oracle.

Exécutez la commande suivante pour truffler dans le terminal /oracle-example/oracle/ afin d'ajouter des données de test :

 truffle(develop)> instance.addTestData()

Exécutez la commande suivante pour truffler dans le terminal /oracle-example/client/ , pour voir si nous pouvons récupérer les données de test nouvellement ajoutées à partir du client :

 truffle(develop)> instance.getBettableMatches()

Maintenant, si vous prenez des adresses individuelles du tableau renvoyé par getBettableMatches() , et branchez-les dans getMatch() .

Nous vous encourageons à ce stade à parcourir le code client, à voir quelles méthodes publiques sont disponibles, à lire les commentaires dans le code et à proposer certains de vos propres tests à exécuter (et à les exécuter ici dans la console, comme au dessus).

Conclusion de la première partie

Nos résultats de cet exercice sont limités, mais nos objectifs l'étaient aussi, afin de garder un rythme réaliste. Notre client n'a pas encore la capacité de prendre des paris, de gérer des fonds, de répartir les gains, etc. Ce que nous avons, outre les connaissances et l'expérience acquises, c'est :

• Un oracle de contrat intelligent principalement fonctionnel
• Un client qui peut se connecter et interagir avec l'oracle
• Un cadre pour le développement et l'apprentissage ultérieurs

Et ce n'est pas trop mal pour un court article.

Dans la deuxième partie de cette série , nous approfondirons le code et examinerons certaines des fonctionnalités propres au développement de contrats intelligents, ainsi que certaines des fonctionnalités linguistiques spécifiques à Solidity. Beaucoup de choses qui viennent d'être passées sous silence dans cette partie seront expliquées dans la suivante.

Dans la troisième partie de cette série , nous discuterons un peu de la philosophie et de la conception des contrats intelligents, en particulier en ce qui concerne leur utilisation avec les oracles.

Autres étapes facultatives

L'expérimentation en solo est un bon moyen d'apprendre. Voici quelques suggestions simples si vous réfléchissez à des moyens d'étendre ce didacticiel pour une meilleure connaissance (aucun des éléments suivants ne sera couvert dans les parties 2 et 3):

• Déployez les contrats sur Ganache (anciennement testrpc) et exécutez les mêmes tests pour vérifier le fonctionnement.
• Déployez les contrats sur des réseaux de test ropsten ou rinkeby et exécutez les mêmes tests pour vérifier le fonctionnement.
• Créez un frontal web3js pour l'oracle ou le client (ou les deux).

Bonne chance et n'hésitez pas à me contacter pour toute question. Je ne peux pas nécessairement garantir une réponse rapide, mais je ferai de mon mieux.