Kontrak Oracle Ethereum: Pengaturan dan Orientasi

Kontrak Cerdas Ethereum lebih dari sekadar “hal baru yang panas.” Ini keyakinan saya bahwa mereka (atau sesuatu yang terkait) siap untuk mengubah cara manusia melakukan bisnis satu sama lain di era baru internet yang akan datang. Waktu akan memberi tahu apakah itu masalahnya.

Ini adalah yang pertama dari artikel tiga bagian tentang pengembangan kontrak cerdas Ethereum dengan Solidity, yang paling khusus mengeksplorasi penggunaan kontrak dengan apa yang disebut “nubuat”—yang pada dasarnya adalah kontrak yang memompa data ke dalam blockchain untuk digunakan oleh kontrak pintar lainnya.

• Bagian 1: Pengantar pengembangan dengan Truffle, dan penyiapan proyek untuk eksperimen lebih lanjut
• Bagian 2: Menggali kode untuk pemeriksaan lebih dalam
• Bagian 3: Diskusi konseptual oracle dengan kontrak pintar

Tujuan dari ini, bagian 1 dari seri, bukanlah untuk mendapatkan banyak ke dalam konsep kontrak oracle, filosofi di baliknya, atau bahkan sangat mendalam tentang apa itu; tujuan dari bagian tutorial oracle Ethereum kami ini hanyalah untuk:

• Persiapkan Anda dengan membuat kontrak cerdas dengan Truffle.
• Bangun proyek kontrak pintar yang akan melayani kami di bagian 2 dan 3.
• Perkenalkan beberapa konsep yang terkait dengan kontrak pintar Ethereum dan pengkodean kontrak pintar.
• Perkenalkan siklus kompilasi/jalankan/debug dengan Truffle dan kontrak pintar.

Definisi: Oracle. Sarana untuk kontrak pintar untuk mengakses data dari dunia di luar blockchain. Jenis kontrak pintar itu sendiri, nubuat mengambil data dari dunia luar dan memasukkannya ke dalam blockchain untuk dikonsumsi oleh kontrak pintar lainnya.

Bagian pertama dari artikel ini akan terdiri dari persiapan dengan semua prasyarat. Kemudian, kami akan membuat satu kontrak Ethereum dan mengujinya dengan Truffle. Terakhir, kita akan memisahkan oracle dari klien dan mengujinya bersama-sama.

Persyaratan Perangkat Lunak

• Setiap OS utama akan berfungsi, meskipun beberapa instalasi dan pengaturan tentu saja akan berbeda pada sistem yang berbeda. Saya telah melakukan semua ini di Ubuntu Linux (16.04). Saya juga tidak punya masalah mengatur lingkungan di Windows. Saya belum mencoba Mac, meskipun saya sadar bahwa hal itu umum dilakukan di Mac juga.
• Tidak perlu menjalankan node et penuh; kita akan menggunakan Truffle, yang dilengkapi dengan testnet sendiri. Jika Anda tahu sedikit tentang apa yang Anda lakukan, Anda dapat menggunakan testnet lain yang Anda pilih; Testnet dev lokal Truffle adalah yang termudah dan paling mudah diakses untuk tujuan tutorial ini.

Persyaratan Pengetahuan

• Pengetahuan dasar tentang cara kerja blockchain
• Memahami apa itu kontrak pintar berbasis blockchain
• Beberapa pengalaman dasar halo duniawi dengan pengembangan kontrak pintar akan membantu, tetapi tidak perlu jika Anda cerdas dan ambisius. (Dan aku tahu itu kamu!)

Seri artikel ini dapat berfungsi sebagai pengantar pertama untuk kontrak pintar, tetapi ini meningkat dengan sangat cepat ke dalam konsep yang lebih maju. Jika ini adalah tutorial kontrak cerdas et pertama Anda, bersiaplah untuk mendaki ke ketinggian dengan cepat. Jika Anda merasa percaya diri, bagus; jika tidak, jangan ragu untuk mendapatkan satu atau dua jenis tutorial "hello world" yang lebih sederhana terlebih dahulu. Lihat salah satu atau artikel Ethereum sebelumnya dan Cryptozombies, sebagai permulaan.

Peringatan: Ruang kontrak pintar, karena sangat baru, berubah dengan cepat. Fitur sintaks soliditas yang baru saat artikel ini ditulis mungkin tidak digunakan lagi atau usang saat Anda membaca ini. Versi Geth mungkin datang dan pergi. Solidity selalu menambahkan fitur bahasa baru dan menghapus yang lama. Banyak fitur baru sedang dalam pengerjaan. Jadi, bersiaplah jika perlu untuk menyesuaikan informasi dalam artikel ini dengan lanskap baru di masa depan; jika Anda serius mempelajari pengembangan kontrak pintar, maka saya percaya pada Anda.

Deskripsi Contoh Aplikasi

Kasus penggunaan: Pengguna bertaruh pada pertandingan tinju.

• Pengguna dapat menarik daftar pertandingan tinju yang dapat dipertaruhkan.
• Pengguna dapat memilih pertandingan dan memasang taruhan pada pemenang.
• Pengguna dapat bertaruh jumlah berapa pun di atas minimum yang ditentukan.
• Jika pilihan pengguna kalah, pengguna kehilangan seluruh jumlah taruhan.
• Jika pilihan pengguna menang, pengguna mendapat porsi pot berdasarkan ukuran taruhannya dan jumlah total taruhan pada yang kalah dalam pertandingan, setelah rumah (pemilik kontrak) mengambil sebagian kecil dari kemenangan .

Apa Itu Oracle Ethereum?

Kontrak pintar masih merupakan hal baru; mereka belum mengambil arus utama, dan begitu banyak aspek bagaimana mereka akan bekerja belum disepakati dan distandarisasi. Saya akan menjelaskan secara singkat dorongan di balik gagasan "oracle"—dan bersabarlah; kita akan membahasnya lebih mendalam di bagian selanjutnya.

Merancang kontrak blockchain tidak seperti memprogram aplikasi client-server. Satu perbedaan penting adalah bahwa data yang berinteraksi dengan kontrak, harus sudah ada di blockchain. Tidak ada panggilan keluar dari blockchain. Tidak hanya tidak didukung oleh bahasa, tetapi juga tidak didukung oleh paradigma blockchain. Kontrak dapat mengambil taruhan dalam bentuk mata uang berbasis Ethereum, menyimpannya dalam kontrak, dan melepaskannya ke alamat dompet yang benar sesuai dengan formula, saat pemenang pertandingan diumumkan. Tapi bagaimana kontrak tahu pemenangnya? Itu tidak dapat menanyakan REST API atau semacamnya. Itu hanya dapat menggunakan data yang sudah ada di blockchain! Banyak kasus penggunaan kontrak pintar mengalami masalah yang sama — mereka sangat terbatas kecuali mereka dapat berinteraksi dengan dunia di luar blockchain.

Jika kontrak hanya dapat berinteraksi dengan data di blockchain, solusi yang jelas adalah dengan menyuntikkan data yang diperlukan ke dalam blockchain. Dan itulah yang dimaksud dengan oracle. Oracle adalah kontrak lain, yang menyuntikkan data ke dalam blockchain, memungkinkan kontrak lain untuk mengkonsumsinya. Sementara itu mungkin menimbulkan pertanyaan tentang kepercayaan dan ketidakpercayaan, terima saja untuk saat ini bahwa itulah oracle. Di bagian 3 seri ini, kita akan membahas nuansa tersebut. Dalam contoh kasus penggunaan kami, oracle akan menjadi kontrak yang menyuntikkan data ke dalam blockchain, mengenai (a) pertandingan apa yang tersedia dan (b) siapa yang memenangkan pertandingan tersebut, setelah diputuskan.

Menyiapkan Lingkungan Pengembangan Ethereum

Untuk pengaturan dasar, kami akan menginstal:

• Geth (opsional untuk saat ini)
• Truffle
• Ganache CLI (opsional)
• Lingkungan pengembangan (opsional)

Artikel ini tidak memiliki ruang untuk menjadi panduan lengkap untuk pengaturan lingkungan tetapi hanya bertindak sebagai panduan kasar. Tidak apa-apa, karena sudah ada banyak panduan pengaturan yang lebih lengkap untuk OS khusus Anda dan internet tidak benar-benar membutuhkan yang baru. Jadi saya akan membawa Anda dengan cepat ke jalan dan mengarahkan Anda ke beberapa sumber untuk mendapatkan lebih banyak detail yang diperlukan. Bersiaplah untuk menginstal persyaratan dan prasyarat sesuai kebutuhan sistem Anda dan sesuai arahan Google.

Instal Geth (opsional)

Klik untuk melihat gambar berukuran penuh.

Geth adalah Go-ethereum, perangkat lunak inti Ethereum; meskipun sama sekali tidak perlu untuk latihan ini, setiap calon pengembang Ethereum harus memilikinya dan terbiasa dengannya. Ini akan diperlukan jika Anda akan menggunakan kontrak pintar Anda ke jaringan Ethereum langsung.

• 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

Instal Truffle

Klik untuk melihat gambar berukuran penuh.

Truffle adalah hal utama yang akan kita gunakan untuk pengembangan, dan benar-benar merupakan persyaratan untuk panduan ini. Temukan dan ikuti instruksi khusus untuk OS Anda untuk menginstal Truffle. Di bawah ini adalah beberapa tautan yang semoga membantu Anda.

• 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

Instal Ganache CLI (opsional)

Klik untuk melihat gambar berukuran penuh.

Saya merekomendasikan menginstal Ganache CLI untuk digunakan sebagai alat pengujian lain, meskipun kami tidak akan benar-benar menggunakannya untuk tutorial kami. Ini opsional.

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

Lingkungan Pengembangan Ethereum

Akan lebih dari mungkin untuk melakukan seluruh tutorial ini dengan editor teks sederhana, seperti Notepad++, gedit, vi, atau editor teks atau IDE apa pun yang Anda pilih. Saya pribadi menggunakan Visual Studio Code dengan ekstensi berikut:

• Kepadatan
• Soliditas diperpanjang
• Tema ikon bahan

Catatan: Ekstensi tidak diperlukan—ekstensi hanya membuat lingkungan pengkodean yang lebih baik.

Menyiapkan Kode

Pengaturan Proyek

Truffle adalah alat yang sangat nyaman untuk menyusun kontrak pintar, memigrasikannya ke blockchain, dan juga menyediakan utilitas pengembangan dan debugging. Beberapa pengaturan proyek akan diperlukan untuk berintegrasi dengan Truffle. Sekarang kita akan menyiapkan shell untuk proyek kita, baik di Truffle maupun dalam struktur direktori. Duduk saja, ikuti langkah-langkahnya secara robotik untuk saat ini, dan nikmati.

Buat direktori untuk menampung semua kode; sebut saja oracle-example .

Di dalam direktori root, buat dua subdirektori, karena pada akhirnya, proyek akan terdiri dari dua sub-proyek. Buat direktori:

• /oracle-contoh/klien
• /oracle-example/oracle

Masuk ke folder client, karena itu proyek pertama yang akan kita kembangkan. Buka jendela terminal (baris perintah) di folder /Oracle-example/client .

Jalankan perintah truffle init .

Perhatikan bahwa di antara banyak file yang dibuat adalah truffle-config.js dan truffle.js . Kami tidak membutuhkan keduanya, jadi hapus truffle-config.js (hanya untuk menghindari kebingungan dan kekacauan).

Kita perlu mengedit truffle.js , untuk mengarahkan Truffle ke arah yang benar untuk pengujian. Ganti isi truffle.js dengan yang berikut ini:

 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

Perhatikan bahwa Truffle init membuat direktori bernama migrasi ( Oracle-example/client/migrations ). Di dalam folder itu seharusnya ada file bernama 1_initial_migration.js .

Tambahkan file lain di direktori migrasi dan beri nama 2_deploy_contracts.js , dengan konten berikut:

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

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

Menambahkan Kode

Sekarang setelah penyiapan sederhana selesai, kita siap untuk memulai pengkodean. Ingat, bagian artikel ini masih pengenalan dan penyiapan, jadi kita akan membahas kodenya dengan lebih cepat. Kita akan masuk ke penjelasan lebih mendalam tentang kode di bagian 2, dan diskusi lebih mendalam tentang arsitektur dan konsep di bagian 3. Karena itu, kami akan segera menyentuh beberapa konsep inti yang terlihat dalam kode. Ikuti dengan cermat untuk mengikuti.

Kode lengkap untuk langkah dalam proses ini tersedia di GitHub: https://github.com/jrkosinski/Oracle-example/tree/part1-step1

Kontrak dalam Soliditas

Sebuah "kontrak" di Solidity kira-kira analog dengan kelas dalam bahasa berorientasi objek lainnya. Bahasa itu sendiri telah dibandingkan dengan Golang dan JavaScript, antara lain. Beberapa konstruksi bahasa lain di Solidity—yang akan kita contoh nanti—adalah pengubah, pustaka, dan antarmuka. Warisan (termasuk warisan ganda) didukung untuk kontrak. File kontrak soliditas memiliki ekstensi .sol.

Antarmuka Oracle

Tambahkan file ini ke proyek Anda: /Oracle-example/client/contracts/OracleInterface.sol

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

Klik untuk melihat gambar berukuran penuh.

Biasanya, antarmuka oracle akan seperti itu—antarmuka. Untuk iterasi pertama ini, itu hanya kelas sederhana yang terkandung dalam proyek Solidity, hanya sebagai pengganti untuk saat ini. Kami akan memindahkannya di langkah berikutnya, setelah kami berhasil mengkompilasi dan menjalankan kontrak di Truffle. Setelah kami mengonversinya ke antarmuka aktual nanti, implementasi fungsi akan kosong.

Kontrak Klien

Tambahkan file ini ke proyek Anda: /Oracle-example/client/contracts/BoxingBets.sol

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

Ini adalah kontrak yang menggunakan data pertandingan tinju, memungkinkan pengguna untuk menanyakan pertandingan yang tersedia, dan memasang taruhan pada mereka. Dalam iterasi selanjutnya, itu akan menghitung dan membayar kemenangan.

Mengkompilasi dan Menjalankan

Sekarang adalah saat kita akan melihat apakah kita melakukan semuanya dengan benar untuk pertama kalinya!

Kompilasi dan Migrasi Kontrak

Buka terminal di folder /Oracle-example/client/

Kompilasi kode dengan perintah ini:

 truffle compile 

Klik untuk melihat gambar berukuran penuh.

Klik untuk melihat gambar berukuran penuh.

Alternatif: Gunakan skrip shell recompile.sh saya (https://github.com/jrkosinski/Oracle-example/tree/part1-step1/client/recompile.sh).

Perhatikan bahwa Anda akan melihat banyak peringatan, karena kode kita belum dalam bentuk final!

Buka konsol pengembangan Truffle:

 truffle develop

Sekarang, di konsol pengembang Truffle, migrasi ke jaringan uji:

 truffle(develop)> migrate

Jalankan Kontrak

Pada prompt konsol pengembangan, masukkan baris kode berikut:

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

Sekarang, "instance" adalah variabel yang mengacu pada kontrak BoxingBets dan dapat digunakan untuk memanggil metode publiknya.

Uji dengan menggunakan perintah berikut:

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

Perhatikan bahwa kami telah menyertakan fungsi "tes" publik di BoxingBets.sol . Itu menambahkan bersama apa pun dua angka yang Anda berikan, hanya untuk menunjukkan bahwa kontrak sedang mengeksekusi kode, dan bahwa kita dapat memanggilnya dari konsol pengembangan Truffle. Jika kami mendapatkan respons yang tampak waras (lihat di bawah) maka pekerjaan kami di sini selesai (setidaknya untuk saat ini).

Pisahkan Ethereum Oracle

Jika semuanya telah berhasil sejauh ini, maka kita sudah melewati punuk. Hal berikutnya yang akan kita lakukan adalah memisahkan kontrak oracle dari kontrak BoxingBets. Dalam penggunaan nyata, kontrak oracle akan ada secara terpisah dari kontrak klien di blockchain, jadi kita harus dapat:

• Instansiasikan dengan alamat blockchain.
• Ubah alamat oracle secara dinamis yang digunakan kontrak klien untuk mereferensikan oracle.

Jadi singkatnya, apa yang akan kita lakukan sekarang adalah memisahkan oracle dan klien menjadi dua entitas kontrak blockchain yang terpisah, dan membuat mereka berbicara satu sama lain. Klien akan membuat instance oracle berdasarkan alamat dan menyebutnya.

Kontrak Klien

Pertama, kita akan mengubah kontrak klien (klien) sehingga mengacu pada antarmuka dinamis ke oracle daripada kelas konkret. Kemudian kami akan memastikan bahwa itu membuat oracle dari kontrak luar.

Masuk ke /Oracle-example/client/contracts/OracleInterface.sol . Seperti yang kami catat sebelumnya, ini saat ini bukan antarmuka, tetapi kami akan membuatnya menjadi satu. Ganti apa yang ada di sana dengan isi:

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

Di BoxingBets.sol , kami akan mengganti baris ini:

 OracleInterface internal boxingOracle = new OracleInterface();

Dengan dua baris ini:

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

Sekarang yang kita inginkan adalah cara untuk mengatur alamat oracle, secara dinamis, dan fungsi yang dapat kita panggil untuk mengetahui alamat oracle saat ini. Tambahkan dua fungsi ini ke 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; }

Dan terakhir, untuk menguji koneksi antara klien dan oracle, kita dapat mengganti fungsi test di BoxingBets dengan fungsi untuk menguji koneksi 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(); }

Dapat dimiliki

Perhatikan bahwa definisi untuk setOracleAddress memiliki pengubah onlyOwner yang mengikutinya. Itu membatasi fungsi ini untuk dipanggil oleh siapa pun selain pemilik kontrak, meskipun fungsinya bersifat publik. Itu bukan fitur bahasa. Itu diberikan kepada kami oleh kontrak yang Dapat Dimiliki, yang dikeluarkan dari perpustakaan kontrak Soliditas utilitas umum OpenZeppelin. Kami akan membahas detailnya di Bagian 2, tetapi untuk memfasilitasi penggunaan pengubah onlyOwner itu, kami perlu membuat beberapa perubahan:

Salin Ownable.sol dari https://github.com/jrkosinski/Oracle-example/tree/part1-step2/client/contracts/Ownable.sol ke /Oracle-example/client/contracts/ .

Tambahkan referensi ke sana di bagian atas BoxingBets.sol , seperti:

 import "./Ownable.sol";

(Anda dapat menambahkannya tepat di bawah baris yang mengimpor OracleInterface.sol .)

Ubah deklarasi kontrak BoxingBets untuk membuatnya mewarisi dari Ownable, dari ini:

 contract BoxingBets {

Untuk ini:

 contract BoxingBets is Ownable {

Dan kita harus siap. Kode lengkap ada di sini jika Anda tersesat: https://github.com/jrkosinski/Oracle-example/tree/part1-step2/client/contracts

Kontrak Oracle

Mempersiapkan

Sekarang kontrak BoxingBets mencoba merujuk ke kontrak yang sepenuhnya terpisah (yaitu oracle) berdasarkan alamat, tugas kita selanjutnya adalah membuat kontrak oracle itu. Jadi sekarang kita akan membuat proyek terpisah yang akan berisi kontrak oracle. Ini pada dasarnya adalah pengaturan yang sama yang telah kita lakukan untuk proyek kontrak klien; yaitu, menyiapkan Truffle untuk kompilasi dan pengembangan.

Anda seharusnya sudah memiliki folder bernama /Oracle-example/Oracle/ yang kita buat pada langkah sebelumnya (atau jika tidak, lanjutkan dan buat direktori kosong itu sekarang). Buka terminal di direktori itu.

• Jalankan perintah truffle init .
• Hapus /Oracle-example/Oracle/truffle-config.js .
• Edit /Oracle-example/Oracle/truffle.js seperti ini:

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

Lihat contohnya di sini: https://github.com/jrkosinski/Oracle-example/tree/part1-step2/Oracle/truffle.js

Di dalam /Oracle-example/Oracle/migrations/ , buat file bernama 2_deploy_contracts.js , dengan konten berikut:

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

Lihat contohnya di sini: https://github.com/jrkosinski/Oracle-example/tree/part1-step2/Oracle/migrations/2_deploy_contracts.js

Kode Oracle

Untuk langkah ini, cukup salin tiga file berikut dari https://github.com/jrkosinski/Oracle-example/tree/part1-step2/Oracle/contracts/ ke folder /oracle-example/oracle/contracts/ Anda:

• BoxingOracle.sol: Kontrak oracle utama.
• Ownable.sol: Untuk fungsi khusus pemilik, seperti yang sudah kami gunakan dalam kontrak klien.
• DateLib.sol: Perpustakaan tanggal. Kita akan melihatnya secara lebih mendalam di Bagian 2 dari seri ini.

Menguji Oracle

Sekarang, dalam iterasi proyek saat ini, kami benar-benar perlu menguji oracle kontrak pintar kami secara menyeluruh, karena itu akan menjadi basis kami di mana kami akan membangun sisa proyek. Jadi, sekarang kita telah menyiapkan proyek Oracle dan menyalin kodenya, kita akan ingin:

• Kompilasi orakel.
• Pastikan oracle berjalan.
• Jalankan beberapa fungsi di konsol Truffle untuk memastikan oracle berfungsi seperti yang diharapkan.

Kompilasi dan Migrasi Oracle

Masih di terminal yang terbuka untuk /oracle-example/oracle/ , jalankan perintah berikut. Sekali lagi, langkah-langkah ini identik dengan apa yang telah kita lakukan untuk mengkompilasi dan memigrasikan kontrak klien.

 truffle compile

Alternatif: Gunakan skrip shell recompile.sh saya (https://github.com/jrkosinski/Oracle-example/tree/part1-step2/Oracle/recompile.sh).

Buka konsol pengembangan Truffle:

 truffle develop

Bermigrasi ke jaringan uji:

 truffle(develop)> migrate

Jalankan dan Uji Oracle

Masih di konsol pengembangan Truffle, masukkan ini untuk menangkap pointer yang dapat digunakan ke kontrak Oracle:

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

Sekarang kita dapat (dan harus) menjalankan serangkaian tes pada kontrak Oracle kita untuk mengujinya. Coba jalankan perintah berikut, masing-masing secara bergantian, dan periksa hasilnya.

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

Anda dianjurkan pada titik ini untuk melihat-lihat kode oracle, melihat metode publik apa yang tersedia, membaca komentar dalam kode, dan membuat beberapa pengujian Anda sendiri untuk dijalankan (dan menjalankannya di sini di konsol, sebagai ditunjukkan di atas).

Pengujian dan Debug

Sekarang kami siap untuk tes terakhir: untuk menguji bahwa kontrak klien dapat memanggil kontrak oracle yang sudah ada di blockchain, dan menarik serta menggunakan datanya. Jika semua ini berhasil, maka kita memiliki pasangan client-oracle yang dapat kita gunakan untuk eksperimen lebih lanjut. Langkah-langkah kami untuk menjalankan pengujian end-to-end:

• Kompilasi dan jalankan kontrak oracle
• Kompilasi dan jalankan kontrak klien
• Dapatkan alamat kontrak oracle
• Tetapkan alamat oracle dalam kontrak klien
• Tambahkan data uji ke kontrak oracle
• Uji apakah kami dapat mengambil data itu dalam kontrak klien

Buka dua jendela terminal:

• Satu di /Oracle-example/client/
• Dan yang lainnya di /Oracle-example/Oracle/

Saya menyarankan agar Anda membiarkan /Oracle-example/client/ tetap terbuka di sebelah kiri dan /Oracle-example/Oracle/ terbuka di sebelah kanan, dan ikuti terus untuk menghindari kebingungan.

Kompilasi dan Jalankan Kontrak Oracle

Jalankan perintah berikut di terminal /Oracle-example/Oracle/ :

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

Kompilasi dan Jalankan Kontrak Klien

Jalankan perintah berikut di terminal /Oracle-example/client/ :

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

Dapatkan Alamat Kontrak Oracle

Jalankan perintah berikut ke Truffle di terminal /Oracle-example/Oracle/ :

 truffle(develop)> instance.getAddress()

Salin alamat yang merupakan output dari panggilan ini; dan menggunakannya di langkah berikutnya.

Tetapkan Alamat Oracle di Kontrak Klien

Jalankan perintah berikut untuk truffle di terminal /Oracle-example/client/ :

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

Dan mengujinya:

 truffle(develop)> instance.testOracleConnection()

Jika outputnya true , maka kita siap melakukannya.

Uji bahwa kami dapat Mengambil Data itu di Kontrak Klien

Jalankan perintah berikut untuk truffle di terminal /Oracle-example/client/ :

 truffle(develop)> instance.getBettableMatches()

Itu harus mengembalikan array kosong, karena belum ada data uji yang ditambahkan ke sisi Oracle.

Jalankan perintah berikut ke truffle di terminal /Oracle-example/Oracle/ untuk menambahkan data pengujian:

 truffle(develop)> instance.addTestData()

Jalankan perintah berikut ke truffle di terminal /Oracle-example/client/ , untuk melihat apakah kita dapat mengambil data pengujian yang baru ditambahkan dari klien:

 truffle(develop)> instance.getBettableMatches()

Sekarang, jika Anda mengambil alamat individual dari larik yang dikembalikan oleh getBettableMatches() , dan hubungkan ke getMatch() .

Anda dianjurkan pada titik ini untuk melihat-lihat kode klien, melihat metode publik apa yang tersedia, membaca komentar dalam kode, dan membuat beberapa pengujian Anda sendiri untuk dijalankan (dan menjalankannya di sini di konsol, sebagai di atas).

Kesimpulan Bagian Satu

Hasil kami dari latihan ini terbatas, tetapi begitu juga tujuan kami, untuk menjaga kecepatan yang realistis. Klien kami belum memiliki kemampuan untuk bertaruh, menangani dana, membagi kemenangan, dll. Apa yang kami miliki—selain dari pengetahuan dan pengalaman yang diperoleh—adalah:

• Oracle kontrak pintar yang sebagian besar berfungsi
• Klien yang dapat terhubung dan berinteraksi dengan oracle
• Kerangka kerja untuk pengembangan dan pembelajaran lebih lanjut

Dan itu tidak terlalu buruk untuk sebuah artikel pendek.

Di bagian dua seri ini , kita akan mempelajari lebih dalam kode dan melihat beberapa fitur yang unik untuk pengembangan kontrak pintar serta beberapa fitur bahasa yang khusus untuk Solidity. Banyak hal yang baru saja dipoles di bagian ini akan dijelaskan di bagian berikutnya.

Di bagian ketiga seri ini , kita akan membahas sedikit tentang filosofi dan desain kontrak pintar, khususnya dalam kaitannya dengan penggunaannya dengan oracle.

Langkah Opsional Lebih Lanjut

Eksperimen tunggal adalah cara yang baik untuk belajar. Berikut adalah beberapa saran sederhana jika Anda memikirkan cara untuk memperluas tutorial ini untuk pengetahuan yang lebih besar (tidak satu pun dari berikut ini yang akan dibahas di Bagian 2 dan 3):

• Terapkan kontrak ke Ganache (sebelumnya testrpc) dan jalankan tes yang sama untuk memverifikasi fungsi.
• Terapkan kontrak ke ropsten atau rinkeby testnets dan jalankan tes yang sama untuk memverifikasi fungsi.
• Bangun ujung depan web3js untuk Oracle, atau klien (atau keduanya).

Semoga berhasil, dan jangan ragu untuk menghubungi saya jika ada pertanyaan. Saya tidak dapat menjamin jawaban yang cepat, tetapi saya akan melakukan yang terbaik.