Contratos de Ethereum Oracle: configuración y orientación

Los contratos inteligentes de Ethereum son más que "lo nuevo de moda". Creo que ellos (o algo relacionado) están preparados para cambiar la forma en que los humanos hacen negocios entre sí en la próxima nueva era de Internet. El tiempo dirá si ese es el caso.

Este es el primero de un artículo de tres partes sobre el desarrollo de contratos inteligentes de Ethereum con Solidity, explorando más específicamente el uso de contratos con los llamados "oráculos", que son básicamente contratos que bombean datos a la cadena de bloques para que los utilicen otros contratos inteligentes.

• Parte 1: una introducción al desarrollo con Truffle y configuración del proyecto para una mayor experimentación
• Parte 2: profundizar en el código para un examen más profundo
• Parte 3: Una discusión conceptual de oráculos con contratos inteligentes

El objetivo de esta, parte 1 de la serie, no es profundizar mucho en el concepto de los contratos de Oracle, la filosofía detrás de ellos, o incluso profundizar en lo que son; el objetivo de esta parte de nuestro tutorial del oráculo de Ethereum es simplemente:

• Prepárese para crear contratos inteligentes con Truffle.
• Cree un proyecto de contrato inteligente que nos servirá en las partes 2 y 3.
• Presente algunos conceptos relacionados con los contratos inteligentes de Ethereum y la codificación de contratos inteligentes.
• Presente el ciclo de compilación/ejecución/depuración con Truffle y los contratos inteligentes.

Definición: Oráculo. Un medio para que los contratos inteligentes accedan a datos del mundo fuera de la cadena de bloques. Un tipo de contrato inteligente en sí mismos, los oráculos toman datos del mundo exterior y los colocan en la cadena de bloques para que otros contratos inteligentes los consuman.

La primera parte de este artículo consistirá en configurar todos los requisitos previos. Luego, configuraremos un único contrato de Ethereum y lo probaremos con Truffle. Finalmente, separaremos el oráculo del cliente y los probaremos juntos.

Requisitos de Software

• Cualquier sistema operativo principal funcionará, aunque parte de la instalación y la configuración, por supuesto, serán diferentes en diferentes sistemas. He hecho todo esto en Ubuntu Linux (16.04). Tampoco he tenido problemas para configurar el entorno en Windows. No he probado Mac, aunque soy consciente de que también es común hacerlo en Mac.
• No es necesario ejecutar un nodo eth completo; Usaremos Truffle, que viene con su propia red de prueba. Si sabe un poco sobre lo que está haciendo, puede usar cualquier otra red de prueba de su elección; La red de prueba de desarrollo local de Truffle es la más fácil y accesible para los propósitos de este tutorial.

Requisitos de conocimiento

• Conocimientos básicos de cómo funciona blockchain
• Comprender qué es un contrato inteligente basado en blockchain
• Una cierta experiencia básica hola-mundial con el desarrollo de contratos inteligentes será útil, pero no necesaria si es inteligente y ambicioso. (¡Y sé que lo eres!)

Esta serie de artículos puede servir como una primera introducción a los contratos inteligentes, pero avanza rápidamente hacia conceptos más avanzados. Si es su primer tutorial de contrato inteligente ético, prepárese para escalar rápidamente. Si te sientes seguro, genial; si no, siéntase libre de obtener un tipo de tutorial más simple de "hola mundo" o dos en su haber primero. Consulte uno de los artículos anteriores de Ethereum y Cryptozombies, para empezar.

Advertencia: el espacio de los contratos inteligentes, al ser tan nuevo, cambia rápidamente. Las funciones de sintaxis de Solidity que eran nuevas cuando se escribió este artículo pueden estar en desuso u obsoletas en el momento en que lo lea. Las versiones Geth pueden haber ido y venido. Solidity siempre está agregando nuevas funciones de lenguaje y descartando las antiguas. Muchas características nuevas están actualmente en proceso. Así que prepárate si es necesario para adaptar la información de este artículo al nuevo panorama del futuro; Si te tomas en serio el aprendizaje del desarrollo de contratos inteligentes, entonces tengo fe en ti.

Descripción de la aplicación de ejemplo

Caso de uso: Los usuarios apuestan en combates de boxeo.

• El usuario puede obtener una lista de combates de boxeo aptos para apuestas.
• El usuario puede elegir un partido y apostar al ganador.
• El usuario puede apostar cualquier cantidad por encima de un mínimo especificado.
• Si la selección del usuario pierde, el usuario pierde el monto total de la apuesta.
• Si la elección del usuario gana, el usuario obtiene una parte del bote según el tamaño de su apuesta y el monto total apostado al perdedor del partido, después de que la casa (el propietario del contrato) se lleva un pequeño porcentaje de las ganancias. .

¿Qué es un oráculo de Ethereum?

Los contratos inteligentes siguen siendo algo nuevo; todavía tienen que tomar la corriente principal, y muchos aspectos de cómo funcionarán aún no se han elaborado ni estandarizado. Explicaré brevemente el ímpetu detrás de la idea del "oráculo" y sea paciente; lo profundizaremos en partes posteriores.

Diseñar un contrato de cadena de bloques no es como programar una aplicación cliente-servidor. Una diferencia importante es que los datos con los que interactúa el contrato ya deben estar en la cadena de bloques. No hay llamadas fuera de la cadena de bloques. No solo no es compatible con el lenguaje, no es compatible con el paradigma de la cadena de bloques. El contrato puede tomar apuestas en forma de moneda basada en Ethereum, almacenarlas en el contrato y enviarlas a las direcciones de billetera correctas de acuerdo con una fórmula, cuando se declara el ganador de un partido. Pero, ¿cómo conoce el contrato al ganador? No puede consultar una API REST ni nada por el estilo. ¡Solo puede usar datos que ya están en la cadena de bloques! Muchos casos de uso de contratos inteligentes se encuentran con un problema similar: están seriamente limitados a menos que puedan interactuar con el mundo fuera de la cadena de bloques.

Si el contrato solo puede interactuar con datos en la cadena de bloques, una solución obvia es inyectar los datos necesarios en la cadena de bloques. Y eso es lo que es un oráculo. Un oráculo es otro contrato, que inyecta datos en la cadena de bloques, lo que permite que otros contratos los consuman. Si bien eso puede generar preguntas sobre la confianza y la falta de confianza, simplemente acepte por ahora que eso es lo que es un oráculo. En la parte 3 de esta serie, discutiremos esos matices. En nuestro caso de uso de ejemplo, el oráculo será el contrato que inyecta datos en la cadena de bloques con respecto a (a) qué partidos están disponibles y (b) quién ganó esos partidos, una vez decididos.

Configuración del entorno de desarrollo de Ethereum

Para la configuración básica, instalaremos:

• Geth (opcional por ahora)
• Trufa
• CLI de Ganache (opcional)
• Un entorno de desarrollo (opcional)

Este artículo no tiene espacio para ser una guía completa para la configuración del entorno, pero actúa como una guía aproximada. Sin embargo, está bien, porque ya hay muchas guías de configuración más completas para su sistema operativo en particular e Internet realmente no necesita una nueva. Así que lo guiaré rápidamente por el camino y le indicaré algunos recursos para obtener más detalles según sea necesario. Esté preparado para instalar requisitos y requisitos previos según lo requiera su sistema y según lo indique Google.

Instalar Geth (opcional)

Haga clic para ver la imagen a tamaño completo.

Geth es Go-ethereum, el software central de Ethereum; Si bien no es necesario para este ejercicio en absoluto, le convendría a cualquier posible desarrollador de Ethereum tenerlo y estar familiarizado con él. Será necesario si alguna vez va a implementar su contrato inteligente en la red Ethereum en vivo.

• 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

Instalar Trufa

Haga clic para ver la imagen a tamaño completo.

La trufa es lo principal que vamos a utilizar para el desarrollo y es absolutamente un requisito para esta guía. Busque y siga las instrucciones específicas de su sistema operativo para instalar Truffle. A continuación se muestran algunos enlaces que, con suerte, le ayudarán.

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

Instalar Ganache CLI (opcional)

Haga clic para ver la imagen a tamaño completo.

Recomiendo instalar Ganache CLI para usar como otra herramienta de prueba, aunque en realidad no la usaremos para nuestro tutorial. es opcional

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

Entorno de desarrollo de Ethereum

Sería más que posible hacer todo este tutorial con cualquier editor de texto simple, como Notepad ++, gedit, vi o cualquier editor de texto o IDE de su elección. Personalmente estoy usando Visual Studio Code con las siguientes extensiones:

• Solidez
• Solidez extendida
• Tema de icono de material

Nota: Las extensiones no son obligatorias, solo crean un mejor entorno de codificación.

Configuración del código

Configuración del proyecto

Truffle es una herramienta muy conveniente para compilar contratos inteligentes, migrarlos a una cadena de bloques y también proporciona utilidades de desarrollo y depuración. Será necesaria alguna configuración del proyecto para integrarse con Truffle. Ahora configuraremos el shell de nuestro proyecto, tanto en Truffle como en la estructura de directorios. Solo siéntate, sigue los pasos robóticamente por ahora y disfruta.

Cree un directorio para albergar todo el código; llámalo oracle-example .

Dentro del directorio raíz, cree dos subdirectorios, porque eventualmente, el proyecto constará de dos subproyectos. Crea los directorios:

• /oracle-ejemplo/cliente
• /oracle-example/oracle

Vaya a la carpeta del cliente, porque ese es el primer proyecto que vamos a desarrollar. Abra una ventana de terminal (línea de comando) en la carpeta /oracle-example/client .

Ejecute el comando truffle init .

Tenga en cuenta que entre muchos archivos creados se encuentran truffle-config.js y truffle.js . No los necesitamos a ambos, así que elimine truffle-config.js (solo para evitar confusiones y desorden).

Necesitamos editar truffle.js para señalar a Truffle en la dirección correcta para la prueba. Reemplace el contenido de truffle.js con lo siguiente:

 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

Tenga en cuenta que Truffle init creó un directorio llamado migraciones ( oracle-example/client/migrations ). Dentro de esa carpeta debe haber un archivo llamado 1_initial_migration.js .

Agregue otro archivo en el directorio de migraciones y asígnele el nombre 2_deploy_contracts.js , con el siguiente contenido:

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

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

Agregar el código

Ahora que la configuración simple está fuera del camino, estamos listos para comenzar a codificar. Recuerde, esta parte del artículo sigue siendo una introducción y configuración, por lo que vamos a repasar el código bastante rápido. Veremos explicaciones más detalladas del código en la parte 2 y una discusión más detallada de la arquitectura y el concepto en la parte 3. Dicho esto, abordaremos rápidamente algunos conceptos básicos evidentes en el código. Siga cuidadosamente para mantenerse al día.

El código completo para este paso del proceso está disponible en GitHub: https://github.com/jrkosinski/oracle-example/tree/part1-step1

Contratos en Solidez

Un "contrato" en Solidity es más o menos análogo a una clase en otros lenguajes orientados a objetos. El lenguaje en sí se ha comparado con Golang y JavaScript, entre otros. Algunas otras construcciones de lenguaje en Solidity, de las cuales tendremos ejemplos más adelante, son modificadores, bibliotecas e interfaces. La herencia (incluida la herencia múltiple) es compatible con los contratos. Los archivos de contrato de Solidity tienen una extensión .sol.

Interfaz de oráculo

Agregue este archivo a su proyecto: /oracle-example/client/contracts/OracleInterface.sol

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

Haga clic para ver la imagen a tamaño completo.

Normalmente, la interfaz de Oracle sería solo eso: una interfaz. Para esta primera iteración, es solo una clase simple contenida dentro del proyecto Solidity, solo como un marcador de posición por ahora. Lo moveremos en el siguiente paso, después de compilar y ejecutar con éxito el contrato en Truffle. Después de convertir esto en una interfaz real más adelante, las implementaciones de la función estarán vacías.

Contrato de cliente

Agregue este archivo a su proyecto: /oracle-example/client/contracts/BoxingBets.sol

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

Este es el contrato que consume los datos del combate de boxeo, permite a los usuarios consultar los combates disponibles y realizar apuestas en ellos. En iteraciones posteriores, calculará y pagará las ganancias.

Compilando y Ejecutando

¡Ahora es cuando veremos si acertamos todo a la primera!

Compilar y migrar el contrato

Abra una terminal en la carpeta /oracle-example/client/

Compile el código con este comando:

 truffle compile 

Haga clic para ver la imagen a tamaño completo.

Haga clic para ver la imagen a tamaño completo.

Alternativo: use mi script de shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/recompile.sh).

Tenga en cuenta que verá muchas advertencias, ¡porque nuestro código aún no está en su forma final!

Abra la consola de desarrollo de Truffle:

 truffle develop

Ahora, en la consola para desarrolladores de Truffle, migre a la red de prueba:

 truffle(develop)> migrate

Ejecutar el contrato

En el indicador de la consola de desarrollo, ingrese la siguiente línea de código:

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

Ahora, "instancia" es la variable que se refiere al contrato de BoxingBets y se puede usar para llamar a sus métodos públicos.

Pruébalo usando el siguiente comando:

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

Tenga en cuenta que hemos incluido una función de "prueba" pública en BoxingBets.sol . Suma los dos números que le pases, solo para demostrar que el contrato está ejecutando código y que podemos llamarlo desde la consola de desarrollo de Truffle. Si recibimos una respuesta aparentemente sensata (ver más abajo), entonces nuestro trabajo aquí está hecho (al menos por ahora).

Separar el Ethereum Oracle

Si todo ha tenido éxito hasta ahora, entonces estamos sobre la joroba. Lo siguiente que haremos será separar el contrato de Oracle del contrato de BoxingBets. En el uso real, el contrato del oráculo existirá por separado del contrato del cliente en la cadena de bloques, por lo que necesitaremos poder:

• Instanciarlo por dirección de blockchain.
• Cambie dinámicamente la dirección del oráculo que usa el contrato del cliente para hacer referencia al oráculo.

En resumen, lo que vamos a hacer ahora es separar el oráculo y el cliente en dos entidades de contrato de cadena de bloques separadas y hacer que hablen entre sí. El cliente creará una instancia del oráculo por dirección y lo llamará.

Contrato de cliente

Primero, vamos a cambiar el contrato del cliente (cliente) para que se refiera a una interfaz dinámica a un oráculo en lugar de una clase concreta. Luego nos aseguraremos de que instancia el oráculo desde un contrato externo.

Vaya a /oracle-example/client/contracts/OracleInterface.sol . Como señalamos antes, actualmente no es una interfaz, pero estamos a punto de convertirla en una. Reemplace lo que hay allí con el contenido 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; }

En BoxingBets.sol , vamos a reemplazar esta línea:

 OracleInterface internal boxingOracle = new OracleInterface();

Con estas dos líneas:

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

Ahora lo que queremos es una forma de establecer la dirección del oráculo, dinámicamente, y una función a la que podamos llamar para averiguar la dirección actual del oráculo. Agregue estas dos funciones 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; }

Y finalmente, para probar la conexión entre el cliente y el oráculo, podemos reemplazar la función de prueba en BoxingBets con una función para probar la conexión del oráculo:

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

propiedad

Observe que la definición de setOracleAddress tiene un modificador onlyOwner a continuación. Eso restringe que esta función sea llamada por cualquier persona que no sea el propietario del contrato, aunque la función sea pública. Esa no es una característica del idioma. Eso nos lo proporciona el contrato Ownable, que se extrae de la biblioteca de contratos Solidity de servicios generales de OpenZeppelin. Entraremos en detalles de eso en la Parte 2, pero para facilitar el uso de ese modificador onlyOwner , necesitamos hacer algunos cambios:

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

Agregue una referencia en la parte superior de BoxingBets.sol , así:

 import "./Ownable.sol";

(Puede agregarlo justo debajo de la línea que importa OracleInterface.sol ).

Modifique la declaración de contrato de BoxingBets para que herede de Ownable, de esto:

 contract BoxingBets {

A esto:

 contract BoxingBets is Ownable {

Y deberíamos estar listos. El código completo está aquí en caso de que se haya perdido: https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts

Contratos de Oracle

Configuración

Ahora que el contrato de BoxingBets intenta referirse a un contrato completamente separado (que es el oráculo) por dirección, nuestro siguiente trabajo es crear ese contrato del oráculo. Así que ahora vamos a crear un proyecto completamente separado que contendrá el contrato de Oracle. Es esencialmente la misma configuración que ya hicimos para el proyecto de contrato del cliente; es decir, configurando Truffle para compilar y desarrollar.

Ya debería tener una carpeta llamada /oracle-example/oracle/ que creamos en un paso anterior (o si no, continúe y cree ese directorio vacío ahora). Abra una terminal en ese directorio.

• Ejecute el comando truffle init .
• Elimine /oracle-example/oracle/truffle-config.js .
• Edite /oracle-example/oracle/truffle.js así:

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

Vea el ejemplo aquí: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/truffle.js

Dentro de /oracle-example/oracle/migrations/ , cree un archivo llamado 2_deploy_contracts.js , con el siguiente contenido:

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

Vea el ejemplo aquí: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/migrations/2_deploy_contracts.js

código oracle

Para este paso, simplemente copie los siguientes tres archivos de https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/contracts/ en su carpeta /oracle-example/oracle/contracts/ :

• BoxingOracle.sol: El principal contrato de Oracle.
• Ownable.sol: para funciones exclusivas del propietario, como ya usamos en el contrato del cliente.
• DateLib.sol: Una biblioteca de fechas. Lo veremos con más profundidad en la Parte 2 de esta serie.

Probando el oráculo

Ahora, en la iteración actual del proyecto, realmente necesitamos probar a fondo nuestro oráculo de contrato inteligente, ya que esa será nuestra base sobre la cual construiremos el resto del proyecto. Entonces, ahora que configuramos el proyecto de Oracle y copiamos el código, querremos:

• Compilar el oráculo.
• Asegúrese de que el oráculo se ejecute.
• Ejecute algunas funciones en la consola de Truffle para asegurarse de que el oráculo funcione como se esperaba.

Compilar y migrar Oracle

Todavía en una terminal abierta en /oracle-example/oracle/ , ejecute los siguientes comandos. Nuevamente, estos pasos son idénticos a lo que ya hemos hecho para compilar y migrar el contrato del cliente.

 truffle compile

Alternativo: use mi script de shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/recompile.sh).

Abra la consola de desarrollo de Truffle:

 truffle develop

Migrar a la red de prueba:

 truffle(develop)> migrate

Ejecutar y probar Oracle

Todavía en la consola de desarrollo de Truffle, ingrese esto para capturar un puntero utilizable al contrato de Oracle:

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

Ahora podemos (y debemos) ejecutar un conjunto de pruebas en nuestro contrato de Oracle para probarlo. Intente ejecutar los siguientes comandos, cada uno por turno, y examine los resultados.

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

En este punto, lo alentamos a que eche un vistazo al código de Oracle, vea qué métodos públicos están disponibles, lea los comentarios en el código y proponga algunas de sus propias pruebas para ejecutar (y ejecútelas aquí en la consola, como mostrado anteriormente).

Pruebas y depuración

Ahora estamos listos para la prueba final: probar que el contrato del cliente puede llamar al contrato de Oracle que ya está en la cadena de bloques, y extraer y usar sus datos. Si todo esto funciona, entonces tenemos un par cliente-oráculo que podemos usar para experimentar más. Nuestros pasos para ejecutar la prueba de extremo a extremo:

• Compilar y ejecutar el contrato de Oracle
• Compilar y ejecutar el contrato de cliente
• Obtener la dirección del contrato de Oracle
• Establecer la dirección de Oracle en el contrato del cliente
• Agregar datos de prueba al contrato de Oracle
• Probar que podemos recuperar esos datos en el contrato del cliente

Abra dos ventanas de terminal:

• Uno en /oracle-example/client/
• Y el otro en /oracle-example/oracle/

Le sugiero que mantenga el /oracle-example/client/ abierto a la izquierda y el /oracle-example/oracle/ abierto a la derecha, y siga de cerca para evitar confusiones.

Compilar y ejecutar el contrato de Oracle

Ejecute los siguientes comandos en el terminal /oracle-example/oracle/ :

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

Compilar y ejecutar el contrato de cliente

Ejecute los siguientes comandos en el terminal /oracle-example/client/ :

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

Obtenga la dirección del contrato de Oracle

Ejecute el siguiente comando para Truffle en la terminal /oracle-example/oracle/ :

 truffle(develop)> instance.getAddress()

Copie la dirección que es el resultado de esta llamada; y utilícelo en el siguiente paso.

Establecer la dirección de Oracle en el contrato del cliente

Ejecute el siguiente comando para truffle en la terminal /oracle-example/client/ :

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

Y pruébalo:

 truffle(develop)> instance.testOracleConnection()

Si la salida es true , entonces estamos listos para comenzar.

Probar que podemos Recuperar esos Datos en el Contrato del Cliente

Ejecute el siguiente comando para truffle en la terminal /oracle-example/client/ :

 truffle(develop)> instance.getBettableMatches()

Debería devolver una matriz vacía, porque aún no se han agregado datos de prueba al lado de Oracle.

Ejecute el siguiente comando para truffle en el terminal /oracle-example/oracle/ para agregar datos de prueba:

 truffle(develop)> instance.addTestData()

Ejecute el siguiente comando para truffle en el terminal /oracle-example/client/ , para ver si podemos recoger los datos de prueba recién agregados del cliente:

 truffle(develop)> instance.getBettableMatches()

Ahora, si toma direcciones individuales de la matriz devuelta por getBettableMatches() y las conecta a getMatch() .

En este punto, le recomendamos que eche un vistazo al código del cliente, vea qué métodos públicos están disponibles, lea los comentarios en el código y proponga algunas de sus propias pruebas para ejecutar (y ejecútelas aquí en la consola, como encima).

Conclusión de la primera parte

Nuestros resultados de este ejercicio son limitados, pero también lo fueron nuestros objetivos, para mantener un ritmo realista. Nuestro cliente aún no tiene la capacidad de aceptar apuestas, manejar fondos, repartir las ganancias, etc. Lo que sí tenemos, aparte del conocimiento y la experiencia adquiridos, es:

• Un oráculo de contrato inteligente en su mayoría funcional
• Un cliente que puede conectarse e interactuar con el oráculo
• Un marco para un mayor desarrollo y aprendizaje

Y eso no está nada mal para un artículo breve.

En la segunda parte de esta serie , profundizaremos más en el código y veremos algunas de las características que son exclusivas del desarrollo de contratos inteligentes, así como algunas de las características del lenguaje que son específicas de Solidity. Muchas de las cosas que se acaban de pasar por alto en esta parte se explicarán en la siguiente.

En la tercera parte de esta serie , discutiremos un poco sobre la filosofía y el diseño de los contratos inteligentes, específicamente en relación con su uso con oráculos.

Otros pasos opcionales

La experimentación en solitario es una buena manera de aprender. Aquí hay algunas sugerencias simples si está pensando en formas de ampliar este tutorial para obtener un mayor conocimiento (ninguno de los siguientes se tratará en las Partes 2 y 3):

• Implemente los contratos en Ganache (anteriormente testrpc) y ejecute las mismas pruebas para verificar el funcionamiento.
• Implemente los contratos para redes de prueba ropsten o rinkeby y ejecute las mismas pruebas para verificar el funcionamiento.
• Cree una interfaz web3js para el oráculo o el cliente (o ambos).

Buena suerte, y no dude en ponerse en contacto conmigo con cualquier pregunta. No puedo garantizar necesariamente una respuesta rápida, pero haré lo mejor que pueda.