Contratos Oracle Ethereum: Configuração e Orientação

Os Smart Contracts da Ethereum são mais do que apenas “a nova coisa quente”. Acredito que eles (ou algo relacionado) estão prontos para mudar a maneira como os humanos fazem negócios uns com os outros na próxima nova era da internet. O tempo dirá se for esse o caso.

Este é o primeiro de um artigo de três partes sobre o desenvolvimento de contratos inteligentes Ethereum com Solidity, explorando mais especificamente o uso de contratos com os chamados “oráculos” – que são basicamente contratos que bombeiam dados para o blockchain para uso por outros contratos inteligentes.

• Parte 1: Uma introdução ao desenvolvimento com Truffle e configuração do projeto para mais experimentação
• Parte 2: Aprofundando o código para um exame mais profundo
• Parte 3: Uma discussão conceitual de oráculos com contratos inteligentes

O objetivo desta parte 1 da série não é entrar muito no conceito de contratos oraculares, a filosofia por trás deles, ou mesmo muito profundamente no que eles são; o objetivo desta parte do nosso tutorial do oráculo Ethereum é simplesmente:

• Prepare-se para construir contratos inteligentes com o Truffle.
• Construa um projeto de contrato inteligente que nos servirá nas partes 2 e 3.
• Apresente alguns conceitos relacionados a contratos inteligentes Ethereum e codificação de contratos inteligentes.
• Introduza o ciclo de compilação/execução/depuração com Truffle e contratos inteligentes.

Definição: Oráculo. Um meio para contratos inteligentes acessarem dados do mundo fora do blockchain. Um tipo de contrato inteligente, os oráculos pegam dados do mundo exterior e os colocam no blockchain para outros contratos inteligentes consumirem.

A primeira parte deste artigo consistirá em configurar todos os pré-requisitos. Em seguida, estabeleceremos um único contrato Ethereum e o testaremos com o Truffle. Finalmente, vamos separar o oráculo do cliente e testá-los em conjunto.

Requisitos de software

• Qualquer sistema operacional principal funcionará, embora algumas das instalações e configurações sejam diferentes em sistemas diferentes. Eu fiz tudo isso no Ubuntu Linux (16.04). Também não tive problemas para configurar o ambiente no Windows. Eu não tentei o Mac, embora esteja ciente de que é comum fazê-lo no Mac também.
• Não é necessário executar um nó eth completo; usaremos o Truffle, que vem com sua própria rede de testes. Se você sabe um pouco sobre o que está fazendo, pode usar qualquer outra rede de teste de sua escolha; A rede de teste de desenvolvimento local da Truffle é a mais fácil e acessível para os propósitos deste tutorial.

Requisitos de Conhecimento

• Conhecimento básico de como funciona o blockchain
• Compreensão do que é um contrato inteligente baseado em blockchain
• Alguma experiência básica com o desenvolvimento de contratos inteligentes será útil, mas não necessária se você for inteligente e ambicioso. (E eu sei que você é!)

Esta série de artigos pode servir como uma primeira introdução aos contratos inteligentes, mas avança muito rapidamente para conceitos mais avançados. Se for o seu primeiro tutorial de contrato inteligente eth, esteja preparado para subir rapidamente à altitude. Se você se sente confiante, ótimo; se não, sinta-se à vontade para obter um tutorial mais simples do tipo “hello world” ou dois primeiro. Confira um dos artigos anteriores do Ethereum e Cryptozombies, para começar.

Advertência: O espaço do contrato inteligente, sendo tão novo, muda rapidamente. Os recursos de sintaxe do Solidity que eram novos quando este artigo foi escrito podem estar obsoletos ou obsoletos no momento em que você estiver lendo este artigo. Versões Geth podem ter ido e vindo. O Solidity está sempre adicionando novos recursos de linguagem e depreciando os antigos. Muitos novos recursos estão atualmente em obras. Portanto, esteja preparado, se necessário, para adaptar as informações deste artigo ao novo cenário do futuro; se você leva a sério o aprendizado do desenvolvimento de contratos inteligentes, tenho fé em você.

Descrição do aplicativo de exemplo

Caso de uso: Usuários apostam em lutas de boxe.

• O usuário pode puxar uma lista de lutas de boxe que podem ser apostadas.
• O usuário pode escolher uma partida e fazer uma aposta no vencedor.
• O usuário pode apostar qualquer valor acima de um mínimo especificado.
• Se a escolha do usuário perder, o usuário perde o valor total da aposta.
• Se a escolha do usuário vencer, o usuário recebe uma parte do pote com base no tamanho de sua aposta e no valor total apostado no perdedor da partida, depois que a casa (o proprietário do contrato) fica com uma pequena porcentagem dos ganhos .

O que é um Oráculo Ethereum?

Contratos inteligentes ainda são uma novidade; eles ainda precisam se popularizar, e muitos aspectos de como eles funcionarão ainda não foram elaborados e padronizados. Vou explicar brevemente o ímpeto por trás da ideia do “oráculo” – e ser paciente; entraremos nisso com mais profundidade em partes posteriores.

A engenharia de um contrato de blockchain não é como programar um aplicativo cliente-servidor. Uma diferença importante é que os dados com os quais o contrato interage já devem estar no blockchain. Não há chamada para fora do blockchain. Não só não é suportado pela linguagem, como não é suportado pelo paradigma blockchain. O contrato pode aceitar apostas na forma de moeda baseada em Ethereum, armazená-las no contrato e liberá-las para os endereços corretos da carteira de acordo com uma fórmula, quando o vencedor de uma partida for declarado. Mas como o contrato conhece o vencedor? Ele não pode consultar uma API REST ou algo assim. Ele só pode usar dados que já estão no blockchain! Muitos casos de uso de contratos inteligentes se deparam com um problema semelhante - eles são seriamente limitados, a menos que possam interagir com o mundo fora do blockchain.

Se o contrato só pode interagir com dados no blockchain, uma solução óbvia é injetar os dados necessários no blockchain. E é isso que é um oráculo. Um oráculo é outro contrato, que injeta dados no blockchain, permitindo que outros contratos o consumam. Embora isso possa levantar questões sobre confiança e falta de confiança, apenas aceite por enquanto que é isso que é um oráculo. Na parte 3 desta série, discutiremos essas nuances. Em nosso caso de uso de exemplo, o oráculo será o contrato que injeta dados no blockchain, sobre (a) quais partidas estão disponíveis e (b) quem venceu essas partidas, uma vez decididas.

Configurando o Ambiente de Desenvolvimento Ethereum

Para configuração básica, instalaremos:

• Geth (opcional por enquanto)
• Brigadeiro
• Ganache CLI (opcional)
• Um ambiente de desenvolvimento (opcional)

Este artigo não tem espaço para ser um guia completo para a configuração do ambiente, mas funciona apenas como um guia aproximado. Tudo bem, porém, porque já existem muitos guias de configuração mais completos para o seu sistema operacional específico e a Internet realmente não precisa de um novo. Então, vou guiá-lo rapidamente pelo caminho e indicar alguns recursos para obter mais detalhes conforme necessário. Esteja preparado para instalar os requisitos e pré-requisitos conforme seu sistema exigir e conforme o Google orientar você.

Instalar Geth (opcional)

Clique para ver a imagem em tamanho real.

Geth é o Go-ethereum, o software principal do Ethereum; embora não seja necessário para este exercício, caberia a qualquer aspirante a desenvolvedor Ethereum tê-lo e estar familiarizado com ele. Será necessário se você for implantar seu contrato inteligente na rede Ethereum ao 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

Clique para ver a imagem em tamanho real.

Trufa é a principal coisa que vamos usar para o desenvolvimento e é absolutamente um requisito para este guia. Encontre e siga as instruções específicas do seu sistema operacional para instalar o Truffle. Abaixo estão alguns links que esperamos ajudá-lo.

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

Instale o Ganache CLI (opcional)

Clique para ver a imagem em tamanho real.

Eu recomendo instalar o Ganache CLI para usar como outra ferramenta de teste, embora não a usemos para nosso tutorial. É opcional.

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

Ambiente de Desenvolvimento Ethereum

Seria mais do que possível fazer todo este tutorial com qualquer editor de texto simples, como Notepad++, gedit, vi ou qualquer editor de texto ou IDE de sua escolha. Pessoalmente, estou usando o Visual Studio Code com as seguintes extensões:

• Solidez
• Solidez estendida
• Tema de ícone de material

Observação: as extensões não são obrigatórias — elas apenas contribuem para um ambiente de codificação melhor.

Configurando o código

Configuração do projeto

Truffle é uma ferramenta muito conveniente para compilar contratos inteligentes, migrando-os para uma blockchain e também fornece utilitários de desenvolvimento e depuração. Alguma configuração do projeto será necessária para integrar com o Truffle. Agora vamos configurar o shell para nosso projeto, tanto no Truffle quanto na estrutura de diretórios. Apenas sente-se, siga os passos roboticamente por enquanto e divirta-se.

Crie um diretório para hospedar todo o código; chame-o de oracle-exemplo .

Dentro do diretório raiz, crie dois subdiretórios, pois eventualmente o projeto será composto por dois subprojetos. Crie os diretórios:

• /oracle-example/client
• /oráculo-exemplo/oracle

Entre na pasta do cliente, pois esse é o primeiro projeto que vamos desenvolver. Abra uma janela de terminal (linha de comando) na pasta /oracle-example/client .

Execute o comando truffle init .

Observe que entre muitos arquivos criados estão trufa-config.js e trufa.js . Nós não precisamos de ambos, então exclua trufa-config.js (apenas para evitar confusão e confusão).

Precisamos editar truffe.js , para apontar o Truffle na direção certa para o teste. Substitua o conteúdo de trufa.js pelo seguinte:

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

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

Observe que o init do Truffle criou um diretório chamado migrations ( oracle-example/client/migrations ). Dentro dessa pasta deve haver um arquivo chamado 1_initial_migration.js .

Adicione outro arquivo no diretório de migrações e nomeie-o 2_deploy_contracts.js , com o seguinte conteúdo:

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

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

Adicionando o código

Agora que a configuração simples está fora do caminho, estamos prontos para começar a codificar. Lembre-se, esta parte do artigo ainda é introdução e configuração, então vamos passar rapidamente pelo código. Entraremos em explicações mais aprofundadas do código na parte 2 e na discussão mais aprofundada da arquitetura e do conceito na parte 3. Dito isso, abordaremos rapidamente alguns conceitos centrais evidentes no código. Siga com atenção para acompanhar.

O código completo para esta etapa do processo está disponível no GitHub: https://github.com/jrkosinski/oracle-example/tree/part1-step1

Contratos em Solidez

Um “contrato” no Solidity é aproximadamente análogo a uma classe em outras linguagens orientadas a objetos. A linguagem em si foi comparada a Golang e JavaScript, entre outras. Algumas outras construções de linguagem no Solidity — das quais teremos exemplos mais adiante — são modificadores, bibliotecas e interfaces. A herança (incluindo herança múltipla) é suportada para contratos. Os arquivos de contrato do Solidity têm uma extensão .sol.

Interface Oracle

Adicione este arquivo ao seu projeto: /oracle-example/client/contracts/OracleInterface.sol

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

Clique para ver a imagem em tamanho real.

Normalmente, a interface do oráculo seria apenas isso – uma interface. Para esta primeira iteração, é apenas uma classe simples contida no projeto Solidity, apenas como um espaço reservado por enquanto. Nós o moveremos na próxima etapa, depois de compilarmos e executarmos com sucesso o contrato no Truffle. Depois de convertermos isso em uma interface real mais tarde, as implementações da função estarão vazias.

Contrato do cliente

Adicione este arquivo ao seu projeto: /oracle-example/client/contracts/BoxingBets.sol

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

Este é o contrato que consome os dados das lutas de boxe, permite que os usuários consultem as partidas disponíveis e façam apostas nelas. Em iterações posteriores, ele calculará e pagará os ganhos.

Compilando e executando

Agora é quando veremos se acertamos tudo da primeira vez!

Compilar e migrar o contrato

Abra um terminal na pasta /oracle-example/client/

Compile o código com este comando:

 truffle compile 

Clique para ver a imagem em tamanho real.

Clique para ver a imagem em tamanho real.

Alternativa: Use meu script de shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step1/client/recompile.sh).

Observe que você verá muitos avisos, pois nosso código ainda não está em sua forma final!

Abra o console de desenvolvimento do Truffle:

 truffle develop

Agora, no console do desenvolvedor do Truffle, migre para a rede de teste:

 truffle(develop)> migrate

Executar o contrato

No prompt do console de desenvolvimento, digite a seguinte linha de código:

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

Agora, “instance” é a variável que se refere ao contrato BoxingBets e pode ser usada para chamar seus métodos públicos.

Teste-o usando o seguinte comando:

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

Observe que incluímos uma função pública de “teste” em BoxingBets.sol . Ele soma quaisquer dois números que você passar para ele, apenas para demonstrar que o contrato está executando o código e que podemos chamá-lo do console de desenvolvimento do Truffle. Se obtivermos uma resposta de aparência sã (veja abaixo), nosso trabalho aqui está feito (pelo menos por enquanto).

Separe o Oráculo Ethereum

Se tudo deu certo até agora, então estamos superados. A próxima coisa que faremos é separar o contrato oráculo do contrato BoxingBets. No uso real, o contrato do oráculo existirá separadamente do contrato do cliente no blockchain, então precisaremos ser capazes de:

• Instancie-o por endereço de blockchain.
• Altere dinamicamente o endereço do oráculo que o contrato do cliente usa para fazer referência ao oráculo.

Então, resumindo, o que vamos fazer agora é separar o oráculo e o cliente em duas entidades de contrato blockchain separadas e fazê-los conversar entre si. O cliente irá instanciar o oráculo por endereço e chamá-lo.

Contrato do cliente

Primeiro, vamos alterar o contrato do cliente (cliente) para que ele se refira a uma interface dinâmica para um oráculo em vez de uma classe concreta. Então nos certificaremos de que ele instancia o oráculo de um contrato externo.

Vá para /oracle-example/client/contracts/OracleInterface.sol . Como observamos anteriormente, atualmente não é uma interface, mas estamos prestes a torná-la uma. Substitua o que está lá pelo conteúdo 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; }

Em BoxingBets.sol , vamos substituir esta linha:

 OracleInterface internal boxingOracle = new OracleInterface();

Com essas duas linhas:

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

Agora o que queremos é uma forma de definir o endereço do oráculo, dinamicamente, e uma função que possamos chamar para descobrir o endereço do oráculo atual. Adicione estas duas funções ao 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 finalmente, para testar a conexão entre o cliente e o oráculo, podemos substituir a função de teste no BoxingBets por uma função para testar a conexão do 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(); }

Proprietário

Observe que a definição de setOracleAddress tem um modificador onlyOwner seguindo-a. Isso restringe essa função de ser chamada por qualquer pessoa que não seja o proprietário do contrato, mesmo que a função seja pública. Isso não é um recurso de linguagem. Isso nos é fornecido pelo contrato Ownable, que é retirado da biblioteca de contratos Solidity de utilidade geral do OpenZeppelin. Entraremos em detalhes disso na Parte 2, mas para facilitar o uso desse modificador onlyOwner , precisamos fazer algumas alterações:

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

Adicione uma referência a ele no topo de BoxingBets.sol , assim:

 import "./Ownable.sol";

(Você pode adicioná-lo logo abaixo da linha que importa OracleInterface.sol .)

Modifique a declaração de contrato da BoxingBets para torná-la herdada de Ownable, desta:

 contract BoxingBets {

Para isso:

 contract BoxingBets is Ownable {

E devemos estar prontos. O código completo está aqui caso você se perca: https://github.com/jrkosinski/oracle-example/tree/part1-step2/client/contracts

Contratos Oracle

Configuração

Agora que o contrato BoxingBets está tentando se referir a um contrato completamente separado (que é o oráculo) por endereço, nosso próximo trabalho é criar esse contrato de oráculo. Então agora vamos criar um projeto totalmente separado que conterá o contrato oracle. É essencialmente a mesma configuração que já fizemos para o projeto de contrato do cliente; ou seja, configurando o Truffle para compilar e desenvolver.

Você já deve ter uma pasta chamada /oracle-example/oracle/ que criamos em uma etapa anterior (ou se não, vá em frente e crie esse diretório vazio agora). Abra um terminal nesse diretório.

• Execute o comando truffle init .
• Exclua /oracle-example/oracle/trufa-config.js .
• Edite /oracle-example/oracle/trufa.js assim:

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

Veja o exemplo aqui: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/trufa.js

Dentro de /oracle-example/oracle/migrations/ , crie um arquivo chamado 2_deploy_contracts.js , com o seguinte conteúdo:

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

Veja o exemplo aqui: https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/migrations/2_deploy_contracts.js

Código Oracle

Para esta etapa, basta copiar os três arquivos a seguir de https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/contracts/ em sua pasta /oracle-example/oracle/contracts/ :

• BoxingOracle.sol: O principal contrato do oráculo.
• Ownable.sol: Para funções exclusivas para o proprietário, como já usamos no contrato do cliente.
• DateLib.sol: Uma biblioteca de datas. Veremos isso com mais profundidade na Parte 2 desta série.

Testando o Oráculo

Agora, na iteração atual do projeto, realmente precisamos testar completamente nosso oráculo de contrato inteligente, pois essa será nossa base na qual construiremos o restante do projeto. Então, agora que configuramos o projeto oracle e copiamos o código, vamos querer:

• Compile o oráculo.
• Certifique-se de que o oráculo seja executado.
• Execute algumas funções no console do Truffle para garantir que o oráculo esteja funcionando conforme o esperado.

Compilar e migrar o Oracle

Ainda em um terminal aberto em /oracle-example/oracle/ , execute os seguintes comandos. Novamente, essas etapas são idênticas ao que já fizemos para compilar e migrar o contrato do cliente.

 truffle compile

Alternativa: Use meu script de shell recompile.sh (https://github.com/jrkosinski/oracle-example/tree/part1-step2/oracle/recompile.sh).

Abra o console de desenvolvimento do Truffle:

 truffle develop

Migre para a rede de teste:

 truffle(develop)> migrate

Executar e testar o Oracle

Ainda no console de desenvolvimento do Truffle, digite isso para capturar um ponteiro utilizável para o contrato oracle:

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

Agora podemos (e devemos) executar um conjunto de testes em nosso contrato oracle para testá-lo. Tente executar os comandos a seguir, cada um por sua vez, e examine os resultados.

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

Você é encorajado neste ponto a dar uma olhada no código oracle, ver quais métodos públicos estão disponíveis, ler os comentários no código e criar alguns de seus próprios testes para executar (e executá-los aqui no console, como Mostrado acima).

Teste e depuração

Agora estamos prontos para o teste final: testar se o contrato do cliente pode chamar o contrato oracle que já está no blockchain, e puxar e usar seus dados. Se tudo isso funcionar, temos um par cliente-oráculo que podemos usar para novas experiências. Nossas etapas para executar o teste de ponta a ponta:

• Compile e execute o contrato oracle
• Compilar e executar o contrato do cliente
• Obtenha o endereço do contrato oracle
• Defina o endereço oracle no contrato do cliente
• Adicionar dados de teste ao contrato oracle
• Teste se podemos recuperar esses dados no contrato do cliente

Abra duas janelas de terminal:

• Um em /oracle-example/client/
• E o outro em /oracle-example/oracle/

Sugiro que você mantenha o /oracle-example/client/ aberto à esquerda e o /oracle-example/oracle/ aberto à direita, e acompanhe de perto para evitar confusão.

Compilar e executar o contrato Oracle

Execute os seguintes comandos no terminal /oracle-example/oracle/ :

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

Compilar e executar o contrato do cliente

Execute os seguintes comandos no terminal /oracle-example/client/ :

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

Obtenha o Endereço do Contrato Oracle

Execute o seguinte comando para Truffle no terminal /oracle-example/oracle/ :

 truffle(develop)> instance.getAddress()

Copie o endereço que é a saída desta chamada; e use-o na próxima etapa.

Defina o endereço Oracle no contrato do cliente

Execute o seguinte comando para trufado no terminal /oracle-example/client/ :

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

E teste:

 truffle(develop)> instance.testOracleConnection()

Se a saída for true , então estamos prontos.

Testar se podemos recuperar esses dados no contrato do cliente

Execute o seguinte comando para trufado no terminal /oracle-example/client/ :

 truffle(develop)> instance.getBettableMatches()

Ele deve retornar um array vazio, porque nenhum dado de teste ainda foi adicionado ao lado do oráculo.

Execute o seguinte comando para trufado no terminal /oracle-example/oracle/ para adicionar dados de teste:

 truffle(develop)> instance.addTestData()

Execute o seguinte comando para trufado no terminal /oracle-example/client/ , para ver se podemos pegar os dados de teste recém-adicionados do cliente:

 truffle(develop)> instance.getBettableMatches()

Agora, se você pegar endereços individuais do array retornado por getBettableMatches() , e conectá-los em getMatch() .

Você é encorajado neste ponto a dar uma olhada no código do cliente, ver quais métodos públicos estão disponíveis, ler os comentários no código e criar alguns de seus próprios testes para executar (e executá-los aqui no console, como acima de).

Conclusão da Parte Um

Nossos resultados deste exercício são limitados, mas nossos objetivos também eram, a fim de manter um ritmo realista. Nosso cliente ainda não tem a capacidade de fazer apostas, lidar com fundos, dividir os ganhos, etc. O que temos – além do conhecimento e da experiência adquirida – é:

• Um oráculo de contrato inteligente principalmente funcional
• Um cliente que pode se conectar e interagir com o oráculo
• Uma estrutura para mais desenvolvimento e aprendizado

E isso não é tão ruim para um artigo curto.

Na parte dois desta série , aprofundaremos o código e veremos alguns dos recursos exclusivos do desenvolvimento de contratos inteligentes, bem como alguns dos recursos de linguagem específicos do Solidity. Muitas das coisas que foram apenas encobertas nesta parte serão explicadas na próxima.

Na terceira parte desta série , discutiremos um pouco sobre a filosofia e o design dos contratos inteligentes, especificamente em relação ao seu uso com oráculos.

Outras etapas opcionais

A experimentação solo é uma boa maneira de aprender. Aqui estão algumas sugestões simples se você estiver pensando em maneiras de estender este tutorial para maior conhecimento (nenhuma das opções a seguir será abordada nas Partes 2 e 3):

• Implante os contratos no Ganache (anteriormente testrpc) e execute os mesmos testes para verificar a função.
• Implante os contratos em redes de teste ropsten ou rinkeby e execute os mesmos testes para verificar a função.
• Construa um front-end web3js para o oráculo ou para o cliente (ou ambos).

Boa sorte, e sinta-se à vontade para entrar em contato comigo com qualquer dúvida. Não posso garantir uma resposta rápida necessariamente, mas farei o meu melhor.