Panduan ini akan memandu Anda langkah demi langkah dalam mempelajari Soliditas. Untuk eksplorasi soliditas yang mendalam, silakan lihat kursus blockchain kami.

Ethereum Foundation telah mengguncang dunia blockchain sejak awal proyek, sekitar akhir 2013 dan awal 2014. Ethereum benar-benar memulai “Bitcoin 2.0” dan apa yang kami anggap sebagai gerakan “blockchain”, setelah gerakan besar pertama Bitcoin “bubble” hingga melewati $ 1000 USD di pasar menarik perhatian semua orang. Ethereum adalah proyek blockchain dengan cryptocurrency, Ether, mirip dengan Bitcoin, tetapi Ethereum memiliki fitur tambahan dari bahasa mesin virtual (hampir) Turing- lengkap dan kemampuan pemrosesan yang tertanam ke dalam implementasi node.

Ethereum Virtual Machine (EVM) memungkinkan node Ethereum untuk benar-benar menyimpan dan memproses data dengan imbalan pembayaran, menanggapi peristiwa dunia nyata dan memungkinkan banyak peluang baru untuk mendukung aplikasi on-chain yang sebelumnya tidak pernah tersedia untuk pengembang dan real- pengguna dunia. Saya beruntung benar-benar berada di Swiss pada awal 2014, dan bisa mengunjungi “holon” ​​Ethereum dan bergaul dengan beberapa pendiri Ethereum sebelum penjualan token Ether, saat mereka “mendanai sendiri”.

Saya bertanya kepada Mihai Alisie apa itu kontrak pintar ethereum, dan dia menjelaskan:

“Kontrak pintar adalah cara bagi orang-orang di seluruh dunia untuk berbisnis satu sama lain meskipun mereka tidak berbicara dalam bahasa yang sama atau menggunakan mata uang yang sama.”

Jadi itulah perspektif yang saya mulai, gagasan bahwa kita dapat mendefinisikan secara terprogram aturan kontrak bisnis, dalam bahasa mesin yang sederhana, untuk menyatukan orang dan memungkinkan mereka menjalankan bisnis dengan cara yang dapat dipercaya, aman, dan otomatis.

Solidity Language sendiri adalah alat yang kami gunakan untuk menghasilkan kode tingkat mesin yang dapat dieksekusi di EVM, itu adalah bahasa dengan penyusun yang mengambil kode tingkat tinggi yang dapat dibaca manusia dan memecahnya menjadi instruksi sederhana seperti “masukkan data ke dalam register”, “tambahkan data dari dua register”, “lompat kembali ke instruksi pada titik memori xxxxx”, yang menjadi dasar dari program yang dapat dijalankan mikroprosesor.

Jadi bahasa Solidity hanyalah salah satu dari beberapa bahasa yang dapat dikompilasi menjadi bytecode EVM, bahasa lain yang melakukan hal yang sama disebut Serpent. Setiap bahasa mungkin memiliki beberapa alat kompiler tetapi semuanya melakukan hal yang sama, yaitu menghasilkan bytecode tingkat mesin EVM untuk dijalankan pada node ethereum, untuk pembayaran.

Cara Mempelajari Soliditas

Soliditas sendiri adalah bahasa yang cukup sederhana, sejauh bahasa pemrograman berjalan.

Faktanya, ini adalah a sengaja menurunkan berat badan, bahasa yang diketik longgar dengan sintaks yang sangat mirip dengan ECMAScript (Javascript). Ada beberapa poin penting yang perlu diingat dari Alasan Desain Ethereum dokumen, yaitu bahwa kita bekerja dalam model stack-and-memory dengan ukuran kata instruksi 32-byte, EVM memberi kita akses ke program “tumpukan” yang seperti ruang register di mana kita juga dapat menempelkan alamat memori untuk membuat Program Counter loop / jump (untuk kontrol program sekuensial), sementara yang dapat diperluas “Penyimpanan” dan yang lebih permanen “penyimpanan” yang sebenarnya ditulis ke dalam blockchain permanen, dan yang terpenting, EVM membutuhkan total determinisme dalam kontrak pintar.

Persyaratan determinisme ini adalah alasan Anda tidak akan melihat fungsi “random ()” dalam bahasa Solidity. Ketika blok ethereum “ditambang”, penerapan kontrak pintar dan panggilan fungsi dalam blok itu (artinya yang berbaris terjadi dalam durasi blok terakhir) dieksekusi pada node yang menambang blok tersebut, dan status baru berubah menjadi ruang penyimpanan atau transaksi dalam kontrak pintar itu sebenarnya terjadi di node penambang itu. Kemudian blok baru akan disebarkan ke semua node lain dan setiap node mencoba untuk memverifikasi blok secara independen, yang termasuk melakukan perubahan status yang sama ke salinan lokal blockchain mereka juga. Di sinilah kegagalannya jika smart-contract bertindak secara non-deterministik. Jika node lain tidak dapat mencapai konsensus tentang keadaan blockchain setelah blok baru dan kontraknya dieksekusi, jaringan benar-benar dapat berhenti..

Inilah sebabnya mengapa kontrak pintar ethereum (dan kontrak pintar secara umum dalam sistem blockchain apa pun) harus bersifat deterministik: sehingga jaringan node selalu dapat memvalidasi dan mempertahankan konsensus tentang blok baru yang masuk, untuk terus berjalan.

Batasan lain yang akan Anda temukan dalam kontrak pintar EVM adalah ketidakmampuan untuk mengakses data di luar “memori”, dan “penyimpanan”, (kami tidak ingin kontrak pintar dapat membaca atau menghapus hard-drive dari node yang dijalankannya), dan ketidakmampuan untuk menanyakan sumber daya luar seperti dengan JQuery. Kami tidak benar-benar memiliki akses ke banyak fungsi pustaka seperti untuk mengurai struktur JSON atau melakukan aritmatika floating-point, dan sebenarnya mahal untuk melakukan sub-rutin tersebut atau menyimpan banyak data di ethereum blockchain itu sendiri.

Saat Anda memanggil kontrak pintar yang melakukan beberapa pekerjaan atau komputasi yang mengubah status (tindakan apa pun selain hanya membaca dari penyimpanan), Anda akan dikenai “biaya” gas untuk pekerjaan yang dilakukan oleh kontrak pintar, dan biaya gas ini terkait dengan jumlah pekerjaan komputasi yang diperlukan untuk menjalankan fungsi Anda. Ini semacam sistem “pembayaran mikro untuk mikrokomputer”, di mana Anda dapat berharap untuk membayar sejumlah gas untuk jumlah komputasi yang ditentukan, selamanya.

Harga gas itu sendiri pada umumnya dimaksudkan untuk tetap konstan, yang berarti bahwa ketika Ether naik di pasar global, maka harga gas terhadap Ether harus turun. Jadi, saat Anda menjalankan panggilan fungsi ke kontrak pintar, Anda bisa mendapatkan perkiraan jumlah bahan bakar yang harus Anda bayar sebelumnya, tetapi Anda juga harus menentukan harga (dalam eter per gas) yang bersedia Anda bayar, dan node penambangan dapat memutuskan apakah itu tarif yang cukup baik bagi mereka untuk menerima panggilan fungsi kontrak pintar Anda di blok berikutnya.

Kontrak pintar memiliki alamatnya sendiri, dari mana mereka dapat menerima dan mengirim Ether. Kontrak pintar dapat melacak “pemanggil” dari fungsi dengan cara yang dapat diverifikasi, sehingga dapat menentukan apakah salah satu fungsinya dipanggil oleh akun “pemilik” atau “admin” yang memiliki hak istimewa, dan bertindak sesuai untuk fungsi administratif. Mereka memiliki kemampuan untuk membaca data dari ethereum blockchain, dan mengakses info tentang transaksi di blok yang lebih lama. Tetapi apakah kontrak pintar “terkunci” ke dalam dunia deterministik kecil mereka sendiri, hanya dapat mengetahui data yang disimpan di ethereum blockchain itu sendiri?

Tidak semuanya! Di situlah “Oracles” masuk. Kita bisa menelepon seorang peramal yang akan memberi tahu kita sesuatu tentang dunia luar dengan cara yang dapat dipercaya, dan bertindak atas data itu dalam kontrak pintar. Poin kuncinya di sini adalah bahwa meskipun peristiwa dunia nyata itu sendiri tidak deterministik, Oracle dapat dipercaya untuk selalu menjawab setiap permintaan node tentang apa yang terjadi dengan cara deterministik, sehingga semua node masih dapat mencapai konsensus. Jadi beginilah teori Oracle tepercaya: “oracle” akan mengambil beberapa data, katakanlah feed harga ticker tentang harga saham dunia nyata, dan mencatat data itu ke dalam “penyimpanan” dalam kontrak pintar Oracle sederhana, sesuatu seperti ini

(lihat juga penjelasannya sini):

function storeTickerData (simbol bytes8, uint open, uint high, uint low, uint close)

onlyOracle

kembali (sukses bool)

{

# menyimpan data ticker secara on-chain

tickerData [symbol] [block.number] = [buka, tinggi, rendah, tutup]

# tickerData adalah peta peta, string => uint => larik [uint, uint, uint, uint]

kembali benar;

}

Ada perusahaan yang berspesialisasi dalam menjadi oracle tepercaya, dan merancang sistem untuk memisahkan diri dari keharusan dipercaya dengan datafeed. Jika kita melihat file Oraclize dokumentasi kami melihat kutipan menarik ini:

Secara khusus, tujuannya bukan untuk memaksa pengembang kontrak pintar agar mempercayai Oraclize dengan data yang mereka butuhkan. Tanpa dukungan keaslian, Oraclize dapat dengan mudah merusak data. Inilah sebabnya, untuk menyelesaikan tugas kompleks ini, Oraclize mengembalikan data yang diminta bersama dengan bukti keasliannya: yaitu data tersebut berasal dari penyedia data yang telah secara eksplisit diminta oleh kontrak pintar..

Jadi, Anda harus memeriksa bagian dokumen tentang “bukti keaslian” untuk lebih jelasnya, tetapi idenya adalah bahwa bahkan ketika kutu buku ethereum baru, pada waktu yang jauh di masa depan, memutar node ethereum mereka dan mulai menyinkronkan blockchain mereka ke jaringan , semua data yang mereka butuhkan untuk menjalankan semua kontrak pintar yang “bergantung pada oracle” disimpan dengan aman untuk mereka unduh, selamanya. Masalah siapa yang membayar “gas” untuk oracle untuk melakukan semua penulisan data tentang peristiwa dunia nyata (penyimpanan blockchain dengan biaya gas “perubahan negara”) adalah topik lain, tetapi pada dasarnya, ia dibayar di muka oleh pemohon data di salah satu dari beberapa cara. Hal yang keren di sini adalah meskipun kita tidak dapat menulis kontrak pintar yang “melempar dadu” dalam arti memasukkan keacakan yang sebenarnya, itu aku s sebenarnya mungkin untuk menulis kontrak pintar yang bereaksi terhadap lemparan dadu, seperti yang diatur oleh oracle.

Tutorial Dasar Soliditas

Latar Belakang dan Pengaturan Kode Dasar

Jadi mari kita mulai dengan kontrak pintar ethereum dasar, yang ditulis dalam bahasa Solidity. Cara terbaik untuk belajar adalah dengan melakukan! Kita dapat melihat dari potongan kecil kode di atas bahwa kita memiliki sintaks deklarasi fungsi yang cukup sederhana, dan beberapa dasar tipe data seperti ‘uint’ (unsigned integer) dan ‘string’, dan kami lihat di dokumen kami juga memiliki jenis variabel seperti ‘address’, yang berisi metode ‘.balance’ dan ‘.transfer’, yang dapat diprediksi mengembalikan saldo di Ethereum alamat, dan memungkinkan kontrak pintar untuk benar-benar mengirim Eter ke alamat itu, dengan unit dalam denominasi Wei.

Kami memiliki array dasar, enum, operator, struktur data hash yang disebut ‘pemetaan’, dan beberapa yang telah ditentukan sebelumnya unit dan vars global yang mencakup hal-hal seperti blockheight, stempel waktu blok terakhir, dan beberapa fungsi SHA-hash dan manipulasi alamat / kunci yang praktis. Satu keunikan penting tentang Soliditas saat bekerja dengan array multi-dimensi: pengindeksan berada dalam urutan “terbalik” dari sebagian besar bahasa selama deklarasi saja, seperti yang tercantum dalam dokumen:

Sebuah array dengan ukuran tetap k dan tipe elemen T ditulis sebagai T [k], sebuah array dengan ukuran dinamis sebagai T []. Sebagai contoh, sebuah larik yang terdiri dari 5 larik dinamis dari uint adalah uint [] [5] (perhatikan bahwa notasinya dibalik jika dibandingkan dengan beberapa bahasa lain). Untuk mengakses uint kedua dalam larik dinamis ketiga, Anda menggunakan x [2] [1] (indeks berbasis nol dan akses bekerja dengan cara yang berlawanan dengan deklarasi…)

Oke, kami memiliki cukup alat dasar di sini untuk menjadi berbahaya, mari kita mulai. Mari kita lakukan semacam aplikasi sosial dasar di mana orang dapat memiliki beberapa gambar dan beberapa info dasar tentang diri mereka yang diposting di blockchain. Setiap pengguna akan memiliki alamat ethereum dan “pegangan” atau nama pengguna yang terkait dengan akun mereka. Kami akan memiliki beberapa data demografis dasar yang mungkin atau mungkin tidak dimasukkan orang, dan kemudian kami akan memiliki halaman pencarian sederhana tempat Anda dapat mencari pengguna di direktori dasar, dan melihat gambar yang telah mereka tambahkan / notarisasikan kepada pengguna mereka. Profil.

Berikut adalah gambar tampilan produk Antarmuka Pengguna Aplikasi Terdesentralisasi (Ðapp) ethereum Solidity final kami, dengan pengguna dan gambar yang disahkan ditambahkan:

Cara Mempelajari Soliditas: Panduan Pengodean Ethereum Utama

Saya telah membuatkan foto diri saya yang bagus untuk kalian, dan gambar struktur Kristal Galium Arsenide dari masa sekolah pascasarjana saya untuk Anda. Anda dapat melihat hash notaris SH256 dan cap waktu untuk setiap gambar dan sedikit tanda centang yang menunjukkan bahwa data gambar yang diaktakan masih sesuai dengan hash notaris yang dibuat pada stempel waktu yang ditunjukkan. Jadi saya akan memandu Anda tentang cara saya membuat aplikasi ini, menunjukkan informasi menarik untuk Anda, dengan semua tautan dan contoh kode yang mungkin Anda perlukan untuk referensi di masa mendatang. Kedengarannya bagus? Ayo pergi!

Hal pertama yang akan saya lakukan adalah menyiapkan Truffle “Test-bed” yang akan memungkinkan saya untuk dengan mudah menguji kompilasi kontrak pintar saya. Mengompilasi dan menerapkan kontrak pintar melibatkan menghasilkan transaksi yang ditandatangani lama, tetapi Truffle akan memungkinkan saya untuk menyusun / menerapkan dan menguji kontrak pintar saya menggunakan perintah sederhana. Ada banyak alat yang bisa melakukan ini, tapi kebetulan saya suka tutorial video kontrak pintar Solidity ini yang menggunakan Truffle alat. Saya punya demo proyek github folder yang saya buat hanya untuk tutorial ini agar dapat diikuti oleh semua orang. Saya akan mulai dengan beberapa perintah penyiapan sederhana (di bawah lingkungan linux Debian):

tectract @ blockgeeks / ethereum-demo-tools> npm i -g truffle

# jika Anda mengalami kesalahan izin menginstal modul node secara global, lihat di sini

tectract @ blockgeeks / ethereum-demo-tools> mkdir Geekt # Saya akan memanggil aplikasi sosial saya "Geekt"

tectract @ blockgeeks / ethereum-demo-tools> cd Geekt

tectract @ blockgeeks / ethereum-demo-tools / Geekt> truffle init # ini membuat beberapa folder dan file setup, di dalam folder Geekt /

tectract @ blockgeeks / ethereum-demo-tools / Geekt > ls

kontrak migrasi menguji truffle.js # kami telah membuat tiga folder, dan satu file baru bernama truffle.js

tectract @ blockgeeks / ethereum-demo-tools / Geekt > ls kontrak /

ConvertLib.sol MetaCoin.sol Migrations.sol # kami memiliki beberapa kontrak template dasar yang dihasilkan oleh Truffle

tectract @ blockgeeks / ethereum-demo-tools / Geekt > ls migrasi /

1_initial_migration.js 2_deploy_contracts.js # beberapa file untuk pengaturan kompilasi / migrasi dengan Truffle

Contoh Kontrak Cerdas Soliditas Sederhana

Oke, saya akan membuat kontrak bernama Geekt.sol, di folder / Geekt / contract yang dibuat saat saya memanggil ‘truffle init’. Kamu dapat melihat kode kontrak lengkap di sini, dan saya akan menunjukkan bagian yang paling menarik di sini. Di bagian atas file kami adalah baris yang menentukan versi kompilator dan beberapa sintaks definisi kontrak dasar dan definisi variabel.

soliditas pragma ^ 0.4.4;

kontrak Geekt {

alamat GeektAdmin;

pemetaan (bytes32 => notarizedImage) notarizedImages; // ini memungkinkan untuk mencari notarizedImages dengan SHA256notaryHash mereka

bytes32 [] imagesByNotaryHash; // ini seperti whitepages dari semua gambar, oleh SHA256notaryHash

pemetaan (alamat => Pengguna) Pengguna; // ini memungkinkan untuk mencari Pengguna dengan alamat ethereum mereka

alamat [] usersByAddress; // ini seperti halaman putih dari semua pengguna, menurut alamat ethereum

Saat Anda memanggil fungsi yang mengubah keadaan di dunia nyata, Anda harus menentukan berapa banyak eter yang akan Anda bayarkan untuk itu, tetapi untungnya Anda dapat meminta perkiraan biaya dalam hal biaya gas dan harga gas ( dalam gas / eter) sebelumnya, dan biasanya sangat akurat. Penambang ethereum akan memutuskan apakah Anda membayar cukup, dan memasukkan transaksi yang mengubah status Anda di blok berikutnya, jadi Anda benar-benar harus menunggu fungsi-fungsi itu kembali ketika blok berikutnya ditemukan. Membaca data dari struktur “penyimpanan” ini gratis dan Anda juga tidak perlu menunggu blok berikutnya, node hanya akan membaca data dan segera mengembalikannya kepada Anda.

Sehingga Pengguna pemetaan adalah objek penyimpanan utama kami yang memungkinkan kami membuat objek Pengguna dan mencarinya berdasarkan alamat. Pemetaan sangat efisien untuk menyimpan data dan mengambilnya dengan cepat, tetapi tidak ada cara mudah untuk mengulang peta, jadi Anda dapat melihat saya juga membuat usersByAddress larik alamat yang menampung setiap alamat pengguna yang diketahui di sistem kami, seperti halaman putih semua pengguna. Saya membuat

Saya membuat notarizedImages pemetaan untuk memungkinkan kita membuat objek “gambar” dalam penyimpanan dan mencarinya dengan hash SHA256 terkait dari data gambar, dan indeks notaryHash tersebut memiliki panjang 32 byte.

Kami juga memiliki file ImagesByNotaryHash bytes32 array yang merupakan daftar semua notaryHashes, seperti halaman putih yang memungkinkan kita untuk mengulang semua gambar yang telah diaktakan.

struct notarizedImage {

string imageURL;

uint timeStamp;

}

Pengguna struct {

pegangan tali;

kota bytes32;

negara bytes32;

negara bytes32;

bytes32 [] myImages;

}

Ini (di atas) adalah struct yang sangat mendasar, dan mereka juga mewakili objek “penyimpanan”, jadi harganya eter nyata untuk “dibuat” dan data di dalamnya sebenarnya disimpan di ethereum blockchain, dan memerlukan eter nyata untuk mengubah “status Variabel internal mereka. Kami benar-benar baru saja menggunakan pemetaan dan array luar untuk melacak di mana dalam memori blockchain tempat gambar / struktur pengguna ini berada. Kami notarizedImage struct hanya menyimpan URL ke gambar, di suatu tempat di web mungkin, dan stempel waktu yang memberi tahu kapan gambar itu diaktakan. Kami Pengguna struct menyimpan beberapa pengguna dasar: pegangan, kota, negara bagian, negara, dan juga menyimpan larik dari semua gambar yang telah disahkan oleh pengguna ini dan “ditambahkan” ke akun pengguna mereka, seperti versi mini pengguna-oleh-pengguna dari global imagesByNotaryHash objek halaman putih.

function registerNewUser (string handle, bytes32 city, bytes32 state, bytes32 country) mengembalikan (sukses bool) {

alamat thisNewAddress = msg.sender;

// jangan menimpa entri yang sudah ada, dan pastikan pegangannya bukan null

if (byte (Users [msg.sender] .handle) .length == 0 && byte (handle) .length! = 0) {

Pengguna [thisNewAddress] .handle = handle;

Pengguna [thisNewAddress] .city = city;

Pengguna [thisNewAddress] .state = state;

Pengguna [thisNewAddress] .country = country;

usersByAddress.push (thisNewAddress); // menambahkan entri untuk pengguna ini ke ‘whitepages’ pengguna

kembali benar;

} lain {

return false; // salah satu pegangan nol, atau pengguna dengan pegangan ini sudah ada

}

}

Ini milik kami registerNewUser fungsi. Dibutuhkan pegangan, kota, negara bagian, negara sebagai variabel masukan dan mengembalikan benar atau salah untuk menunjukkan keberhasilan atau kegagalan. Mengapa gagal? Kami tidak ingin mengizinkan pengguna untuk saling menulis pegangan satu sama lain, jadi ini akan menjadi seperti sistem klaim pertama untuk pegangan. Jika pengguna dengan pegangan ini sudah ada, kami mengembalikan null, jadi saya telah menempatkan baris “jika” conditianal di sana untuk memeriksanya. Kami juga tidak mengizinkan pembuatan nama pengguna tanpa pegangan. Satu hal yang kami perhatikan adalah thisNewAddress yang merupakan pemanggil fungsi tersebut, Anda dapat melihat kami menggunakan khusus pengirim pesan berfungsi untuk mengambil data itu, ini adalah alamat tempat transaksi “lakukan fungsi ini” dikirim dari saat seseorang (siapa pun) memanggil fungsi kontrak pintar kita, dan mereka membayar untuk melakukannya. Jadi objek “pemetaan” adalah null secara default, dan saat kita memanggil:

Pengguna [thisNewAddress] .handle = handle;

Ini membuat objek Pengguna baru, dalam pemetaan Pengguna kami, dan mengatur pegangan. Sama dengan kota, negara bagian, negara. Perhatikan bahwa kami juga mendorong alamat Pengguna baru ke dalam objek “halaman putih” UsersByAddress global Users kami sebelum kami mengembalikan true di sana.

function addImageToUser (string imageURL, bytes32 SHA256notaryHash) kembali (sukses bool) {

alamat thisNewAddress = msg.sender;

if (bytes (Users [thisNewAddress] .handle) .length! = 0) {// pastikan pengguna ini telah membuat akun terlebih dahulu

if (bytes (imageURL) .length! = 0) {//) {// tidak bisa mendapatkan pemeriksaan bytes32 null untuk bekerja, oh well!

// cegah pengguna memperebutkan sha->daftar gambar di whitepages, tetapi masih memungkinkan mereka untuk menambahkan referensi pribadi ke sha apa pun

if (byte (notarizedImages [SHA256notaryHash] .imageURL) .length == 0) {

imagesByNotaryHash.push (SHA256notaryHash); // menambahkan entri untuk gambar ini ke whitepages gambar kami

}

notarizedImages [SHA256notaryHash] .imageURL = imageURL;

notarizedImages [SHA256notaryHash] .timeStamp = block.timestamp; // perhatikan bahwa memperbarui gambar juga memperbarui stempel waktu

Pengguna [thisNewAddress] .myImages.push (SHA256notaryHash); // tambahkan hash gambar ke array .myImages users ini

kembali benar;

} lain {

return false; // imageURL atau SHA256notaryHash null, tidak dapat menyimpan gambar

}

kembali benar;

} lain {

return false; // pengguna belum memiliki akun, tidak dapat menyimpan gambar

}

}

Kami addImageToUser untuk fungsi pengguna sangat mirip dengan registerNewUser fungsi. Itu mencari Anda dengan alamat pengiriman Anda melalui khusus pengirim pesan objek dan memeriksa apakah ada Pengguna terdaftar (menurut pegangan) untuk alamat itu sebelum mencoba menambahkan gambar untuk entri pengguna Anda. Kami mengizinkan pengguna untuk menambahkan notaryHash mereka ke halaman putih global gambar hanya jika tidak ada, untuk mencegah pengguna memperebutkan entri di halaman putih global, tetapi kami mengizinkan mereka untuk menambahkan / memperbarui entri notaryHash di dalam memiliki mini-whitepages dari gambar mereka sendiri. Tidak ada untuk itu!

function getUsers () pengembalian konstan (alamat []) {return usersByAddress; }

function getUser (address userAddress) pengembalian konstan (string, bytes32, bytes32, bytes32, bytes32 []) {

return (Users [userAddress] .handle, Users [userAddress] .city, Users [userAddress] .state, Users [userAddress] .country, Users [userAddress] .myImages);

}

function getAllImages () pengembalian konstan (bytes32 []) {return imagesByNotaryHash; }

function getUserImages (address userAddress) pengembalian konstan (bytes32 []) {return Users [userAddress] .myImages; }

function getImage (bytes32 SHA256notaryHash) pengembalian konstan (string, uint) {

return (notarizedImages [SHA256notaryHash] .imageURL, notarizedImages [SHA256notaryHash] .timeStamp);

}

Terakhir, fungsi pengakses (di atas) memungkinkan kita untuk membaca setiap pengguna atau gambar, atau mendapatkan daftar halaman putih lengkap dari semua pengguna atau semua gambar. Perhatikan fungsi-fungsi ini kembali konstan data, yang pada dasarnya berarti mereka hanya-baca, tidak “mengubah status” dan mereka bebas menelepon dan langsung mengembalikan data, Anda tidak perlu menunggu sampai blok berikutnya. Kami pada dasarnya hanya memanggil pemetaan / array global kami dan mengembalikan data yang relevan: pengguna berdasarkan alamat atau gambar oleh notaryHash.

Mengompilasi & Menguji Kontrak Cerdas

Sekarang kami ingin benar-benar menguji kontrak pintar kami secara lokal, di lingkungan pengujian. Sangat mudah menggunakan perintah Truffle sederhana, tetapi pertama-tama kami benar-benar membutuhkan simpul ethereum lokal untuk menguji. Di situlah Ethereum TestRPC datang. TestRPC pada dasarnya adalah node palsu, program ramping yang hanya berpura-pura menjadi node dan merespons seperti node akan merespons pada mesin localhost Anda. TestRPC berjalan pada port 8545 seperti node ethereum normal, dan memiliki kemampuan untuk menyusun kontrak pintar Solidity ke dalam kode EVM dan menjalankan kode itu juga, ditambah Anda mendapatkan respons instan untuk pengujian, daripada harus menunggu di jaringan ethereum yang sebenarnya untuk temukan blok berikutnya. Sekarang, Anda dapat menjalankan perintah kompilasi / penerapan uji Truffle terhadap node ethereum nyata, tetapi itu akan menghabiskan biaya Ether nyata, ditambah memakan waktu dan memori untuk menjalankan node Anda sendiri jika Anda tidak perlu. Jadi kami melakukan beberapa perintah pemasangan cepat:

npm i -g ethereum-testrpc

testrpc -m “sampel anjing datang tahun merangkak semprot belajar mendeteksi umum pilot jeli perak”

Ini memulai TestRPC dengan frase “seed” yang ditentukan, dan Anda akan melihat sesuatu seperti ini sebagai output:

EthereumJS TestRPC v3.0.5

Akun yang Tersedia

==================

(0) 0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2

(1) 0xb0a36610de0912f2ee794d7f326acc4b3d4bc7bc

(9) 0x4c1cc45ef231158947639c1eabec5c5cb187401c

Kunci Pribadi

==================

(0) 91e639bd434790e1d4dc4dca95311375007617df501e8c9c250e6a001689f2c7

(1) afaeff0fc68439c4057b09ef1807aaf4e695294db57bd631ce0ddd2e8332eea7

(9) dcc51540372fa2cf808efd322c5e158ad5b0dbf330a809c79b540f553c6243d7

Dompet HD

==================

Mnemonic: sampel anjing datang tahun merangkak semprot belajar mendeteksi umum pilot jelly perak

Jalur HD Dasar: m / 44 ‘/ 60’ / 0 ‘/ 0 / {account_index}

Mendengarkan di localhost: 8545

Anda akan melihat beberapa aktivitas di sini di jendela ini dengan TestRPC berjalan, saat Anda menerapkan dan berinteraksi dengan kontrak pintar Anda melalui Truffle atau Web3.js. Oke, kami siap untuk uji penerapan. Anda perlu mengubah file /migrations/2_deploy_contracts.js untuk menyertakan nama smart-contract Anda, agar truffle tahu cara menyusun dan menerapkannya. Kami melakukan perintah ini:

kompilasi truffle

Jika semua berjalan lancar, Anda akan melihat pesan yang mengatakan “menyimpan artefak”, dan tidak ada pesan kesalahan. Saya tidak akan berbohong, jika kontrak Anda memiliki kesalahan sintaks atau masalah lain, pesan kesalahan penyusun yang akan Anda lihat kemungkinan besar misterius dan sulit ditafsirkan! Jika Anda mendapatkan kesalahan tentang “ukuran tumpukan”, itu mungkin berarti Anda memiliki terlalu banyak variabel yang diteruskan ke / dari pemanggilan fungsi, aturan yang baik untuk diingat adalah 16 variabel input atau output adalah maks, secara umum. Juga, ingat bahwa kontrak pintar Solidity tidak dapat mengembalikan tipe data struct kustom, jadi Anda harus mengatasinya juga, biasanya saya hanya mengembalikan array dan pointer / alamat dari struct lain di pemetaan internal saya. Jika Anda mendapatkan runtime pesan kesalahan tentang “tumpukan”, itu mungkin berarti Anda memiliki kondisi yang buruk dalam kode Anda.

truffle bermigrasi

Perintah ini (di atas) sebenarnya melakukan penerapan uji coba kontrak pintar Anda ke node TestRPC Anda. Saya melihat hasil keluaran ini:

Menjalankan migrasi: 1_initial_migration.js

Menerapkan Migrasi…

Migrasi: 0xd06a1935230c5bae8c7ecf75fbf4f17a04564ed8

Menyimpan migrasi yang berhasil ke jaringan…

Menyimpan artefak…

Menjalankan migrasi: 2_deploy_contracts.js

Menerapkan Geekt…

Geekt: 0xe70ff0fa937a25d5dd4172318fa1593baba5a027

Menyimpan migrasi yang berhasil ke jaringan…

Menyimpan artefak..

Kontrak pintar kami (bernama “Geekt”) diberi alamat di blockchain Ethereum ketika berhasil diterapkan, Anda dapat melihat di atas, alamatnya adalah 0xe70ff0fa937a25d5dd4172318fa1593baba5a027. Di jaringan ethereum langsung yang nyata, Anda membayar gas untuk menerapkan kontrak Anda dan alamatnya tidak pernah berubah. Pada TestRPC, jika Anda mematikan TestRPC, semuanya akan terlupakan, dan setelah Anda memulai TestRPC kembali, Anda harus menerapkan kembali kontrak Anda dan Anda akan mendapatkan alamat yang berbeda untuk kontrak pintar Anda. Alamat kontrak pintar Anda adalah tempat orang dapat mengirim transaksi dengan pesan untuk berinteraksi dengannya, untuk melakukan transaksi yang mengubah status atau hanya membaca data dari ethereum blockchain. Kontrak pintar juga dapat berinteraksi langsung satu sama lain melalui alamat ini, menggunakan “pesan”. Kontrak pintar yang berinteraksi dengan kontrak pintar lainnya untuk menyimpan, mengubah, atau membaca data melalui “pesan” ethereum blockchain ini dikenal sebagai Organisasi Otonomi Terdesentralisasi, atau DAO.

Oke, sekarang sampai pada bagian yang menyenangkan. Kami siap untuk benar-benar melakukan beberapa pengujian awal dan berinteraksi dengan kontrak pintar kami. Kami memulai “konsol” Truffle dan melakukan beberapa kueri terhadap node localhost TestRPC kami, untuk memastikan semuanya berfungsi dan kami dapat menambahkan pengguna dan gambar serta mengambilnya dengan benar.

konsol truffle

> Geekt = Geekt.deployed ()

> Geekt.then (fungsi (instance) {return JSON.stringify (instance.abi);})

> Geekt.then (function (instance) {return instance.registerNewUser ("Tectract","Denver","BERSAMA","Amerika Serikat");})

> Geekt.then (fungsi (instance) {return instance.addImageToUser (‘www.myimageURL.com’, ‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’);})

> Geekt.then (fungsi (instance) {return instance.getUser (‘0x0ac21f1a6fe22241ccd3af85477e5358ac5847c2’);}) > Geekt.then (fungsi (instance) {return instance.getUsers ();})

> Geekt.then (fungsi (instance) {return instance.getImages ();})

> Geekt.then (fungsi (instance) {return instance.getImage (‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’);})

Salah satu konsep penting di sini adalah ABI, yang merupakan objek berformat javascript yang mendeskripsikan nama fungsi dan input / output untuk berinteraksi dengan kontrak pintar Anda, ini seperti deskripsi Antarmuka Pemrogram Aplikasi (API) untuk kontrak pintar Anda, yang memberi tahu orang-orang bagaimana membentuk pesan untuk itu. Fungsi registerNewUser () saya berfungsi! Saya melihat ini sebagai tanggapan atas panggilan fungsi registerNewUser (), di jendela konsol:

{tx: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

resi:

{transactionHash: ‘0x1b9f55971871921ccd23a9aa7620620c6c958a893af334087283926d4c6d60b1’,

transactionIndex: 0,

blockHash: ‘0x2be4fab68daaf8db199e2a6adea101c0f1ed06f46aba21e8e4c06e752ca3325c’,

blockNumber: 5,

gas Digunakan: 145215,

kumulatif Gas Digunakan: 145215,

contractAddress: null,

log: []},

log: []}

Fungsi AddImageToUser () mengembalikan kesuksesan dengan cara yang sama, dan ketika saya sekarang dapat mengambil catatan pengguna individu atau catatan gambar yang diaktakan dari ethereum blockchain. Panggilan fungsi getUser () saya kembali:

[‘Tectract’,

‘0x44656e7665720000000000000000000000000000000000000000000000000000’,

‘0x434f000000000000000000000000000000000000000000000000000000000000’,

‘0x5553410000000000000000000000000000000000000000000000000000000000’,

[‘0x6c3e007e281f6948b37c511a11e43c8026d2a16a8a45fed4e83379b66b0ab927’]]

dan saya dapat mengambil data gambar itu melalui string hash SHA256Notary 32-byte yang telah saya kaitkan dengannya, fungsi getImage () saya kembali:

[‘www.myimageURL.com’,

{[String: ‘1496256315’] s: 1, e: 9, c: [1496256315]}]

Ini semua terlihat bagus. Semuanya berfungsi, diuji di TestRPC dan Truffle, dan kami siap untuk benar-benar membangun antarmuka pengguna grafis yang keren untuk Ðapp kami sehingga dunia dapat berinteraksi dengan pendaftaran pengguna dan notaris gambar kami di ethereum blockchain.

Ethereum Dasar Ð Desain Aplikasi

Desain Localhost & Menguji

Kami siap untuk pergi, kontrak pintar bahasa Soliditas kami telah berhasil dikompilasi, dan diterapkan ke node ethereum testRPC lokal kami. Sekarang kita dapat dengan cepat membangun ÐApp sederhana yang memungkinkan pengguna untuk berinteraksi dengan kontrak pintar melalui browser web mereka, menggunakan beberapa pemrograman web dasar dan khusus Web3.js modul javascript, dibuat khusus untuk berinteraksi dengan node Ethereum dan kontrak pintar melalui web.

saya telah membuat demo ini (repositori github open-source) sebagai referensi untuk digunakan orang saat membangun Ethereum ÐApps menggunakan web3.js, Demo ini dibuat dengan alat yang mudah digunakan bernama Buat-React-App, ini menggunakan React bahasa web internal Facebook, tetapi kami tidak akan berfokus pada kode React apa pun, hanya perintah javascript web.js yang diperlukan. Kode saya ada di CommonJS, hampir persis sama dengan javascript ES6 biasa.

Jadi di aplikasi web Anda, Anda menginstal modul node web3 melalui perintah seperti “npm i -S web3” dan ini akan disimpan ke file package.json Anda, jika Anda menggunakannya. Jadi, Anda akan memiliki, di dalam tag “” atau di dalam file .js, baris seperti ini untuk memuat modul web3 itu sendiri:

impor Web3 dari ‘web3’;

(atau, dalam javascript ES6)

var Web3 = membutuhkan (‘web3’);

Kami harus memberi tahu Web3 tentang beberapa detail tentang node kami dan kontrak pintar kami, sehingga dapat terhubung. Anda akan melihat baris seperti ini:

# baris ini menentukan IP node localhost kita: pengaturan port

var web3 = Web3 baru (Web3.providers.HttpProvider baru ("http: // localhost: 8545"));

# alamat kontrak pintar kami, dari atas

var GeektAddress = ‘0xe70ff0fa937a25d5dd4172318fa1593baba5a027’;

# ABI kontrak pintar kami, sebagai objek javascript mentah, bukan string yang dikutip!

var GeektABI = [{"konstan":benar,"masukan": [],"nama":"getUsers","keluaran": [{"nama":"", (…)

# ini memuat kontrak pintar ke objek web3 kita

GeektContract = web3.eth.contract (GeektABI) .at (GeektAddress);

# ini menemukan akun default terdaftar untuk koneksi node (akun 0 dari TestRPC di atas)

defaultAccount = web3.eth.accounts [0];

Berikut beberapa baris yang mendemonstrasikan fungsi hanya-baca yang berinteraksi dengan kontrak pintar kami, melalui web3:

# Fungsi di bawah ini diaktifkan saat halaman dimuat, untuk mendapatkan "halaman putih" dari semua alamat pengguna yang diketahui

GeektContract.getUsers (function (err, usersResult) {

# Fungsi di bawah ini mengambil gambar sesuai kebutuhan, dan menyimpannya dalam memori browser…

GeektContract.getImage (imageHash, fungsi (err, imageResult) {

Demo sederhana ÐApp ini hanya memuat semua alamat pengguna yang diketahui dan mengambil detail gambar pengguna yang sebenarnya dan gambar tersebut merekam sendiri sesuai kebutuhan saat itu juga. Berikut tangkapan layarnya:

Cara Mempelajari Soliditas: Panduan Pengodean Ethereum Utama

Pada titik ini (gambar di atas) saya telah menyegarkan klien TestRPC saya dan baru saja melakukan perintah “truffle migrate” yang menerapkan kontrak pintar terhadap node TestRPC localhost saya. Anda dapat melihat antarmuka yang siap untuk saya klik tombol dan “mendaftar” pengguna pertama. Ketika saya melakukan klik tombol ini, fungsi registerNewUser () saya dari kontrak pintar saya akan dipanggil, menambahkan data pengguna ini ke simpul ethereum blockchain (pengujian localhost) saya di alamat kontrak pintar yang kami catat di atas. Menambahkan data pengguna ke “penyimpanan” blockchain akan menghabiskan biaya bensin, dan kita perlu mencari tahu berapa banyak bahan bakar yang harus kita bayar, daripada hanya mengambil tebakan ilmiah liar (SWAG). Berikut kode yang sebenarnya dipanggil ketika tombol “Masuk Buku Tamu” ini diklik:

GeektContract.registerNewUser.estimateGas (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{dari: defaultAccount},

function (err, result) {

var myGasNum = hasil;

GeektContract.registerNewUser.sendTransaction (

outerThis.state.defaultHandle,

outerThis.state.defaultCity,

outerThis.state.defaultState,

outerThis.state.defaultCountry,

{dari: defaultAccount, gas: myGasNum},

function (err, result) {

Jadi Anda bisa lihat, ketika kami melakukan transaksi perubahan status yang sebenarnya harus kami bayar dengan gas ethereum (gas nyata atau testnet), kami akan menyebutnya registerNewUser.estimateGas () fungsi sebelumnya, dan kemudian gunakan perkiraan jumlah gas saat kita memanggil fungsi pengubah keadaan secara nyata, menggunakan registerNewUser.sendTransaction () fungsi.

Ketika kami memulai TestRPC dan itu mengeluarkan beberapa alamat dompet uji untuk kami, akun ini mirip dengan akun yang akan Anda miliki jika Anda menjalankan node penuh dan melakukan perintah RPC getAccounts terhadapnya, seperti dompet full-node. TestRPC memberi Anda beberapa koin testnet gratis, 100 testnet Ether per akun saat dijalankan.

Saat kita menyebut fungsi yang mengubah status ini seperti registerNewUser () atau addImageToUser (), dalam fase pengujian localhost, terhadap node TestRPC kami, TestRPC hanya membayar gas testnet untuk Anda dan segera mengembalikan hasil transaksi. Pada node localhost penuh, Anda harus “membuka” akun itu sebelum transaksi berhasil di mainnet, dan Anda harus menunggu di mainnet untuk blok berikutnya untuk mengambil transaksi Anda, dengan asumsi perkiraan bahan bakar kami sudah cukup! Tapi selalu ada cara yang lebih baik, homies &# x1f642;

Mengaitkan Ðapp Anda ke Mainnet

Saya telah menyiapkan dan menerapkan kontrak pintar ke ethereum Mainnet, dan aplikasi demo ini di salah satu server web saya, di www.enledger.io/etherereum-demo-tools. Jika Anda mengunjungi situs ini dan tidak memiliki TestRPC atau node ethereum penuh yang berjalan di localhost: 8545, dan Anda mengunjungi situs ini, Anda mungkin akan melihat sesuatu seperti ini:

Melihat koneksi ke jaringan: !

Melihat akun default: (tidak ada tautan node web3.eth)

Jadi, apakah ini berarti Anda memerlukan node ethereum penuh yang berjalan, atau node penuh Virtual Private Server (VPS) untuk dihubungkan, untuk berinteraksi dengan ethereum Mainnet? Sampai baru-baru ini itu benar, tetapi sekarang kami memiliki plugin chrome hebat ini yang disebut Metamask (untuk browser Chrome), yang memungkinkan Anda untuk terhubung ke ethereum Mainnet dalam browser Anda, dan Metamask pada dasarnya menyediakan koneksi ke node penuh untuk Anda , di sana, gratis, jadi alat peraga untuk mereka!

Anda dapat melihat di kode saya, saya mendeteksi objek web3 khusus “yang disuntikkan” dari plugin metamask yang mengatur koneksi node ke node ethereum penuh mereka. Berikut kode relevan yang beralih secara otomatis ke klien reguler Anda (localhost) atau koneksi web3 metamask:

function loadWeb3 () {

biarkan web3Injected = window.web3;

if (typeof web3Injected! == ‘undefined’) {

console.log ("melihat web yang disuntikkan3!");

web3 = Web3 baru (web3Injected.currentProvider);

} lain {

console.log ("tidak melihat web3 diinjeksi!");

web3 = Web3 baru (Web3.providers.HttpProvider baru ("http: // localhost: 8545"));

}

}

Pada gambar di bawah, perhatikan logo Metamask Fox di pojok kanan atas, Saya telah menginstal Plugin Metamask dan terhubung ke ethereum Mainnet di browser saya! Anda dapat melihat bahwa saya telah menambahkan beberapa pengguna ke buku tamu yang sudah ada di kontrak pintar demo Buku Tamu “Geekt”. Antarmuka ÐAplikasi memungkinkan Anda memilih pengguna dan menelusuri gambar mereka, dan Anda akan melihat halaman Masuk Buku Tamu jika Anda terhubung dari alamat yang belum mendaftarkan pengguna.

Saya menambahkan beberapa kode sehingga Anda bisa menempelkan URL gambar yang ingin Anda tambahkan ke akun pengguna Anda, dan itu akan mengambil hash notaris SHA256 untuk Anda tambahkan ke gambar, dan itu juga akan memeriksa hash notaris SHA256 dari gambar saat dimuat ke halaman, dan memberi Anda sedikit tanda centang hijau atau ‘X’ merah berdasarkan apakah gambar di URL itu dan hash notaris masih cocok. Saya menambahkan gambar logo “BlockGeeks” di bawah akun pengguna Ryan M. saya di sini, dan saya telah mengklik tombol untuk menambahkan gambar untuk pengguna ini.

Plugin Metamask telah mendeteksi bahwa saya perlu membayar transaksi ethereum web3 ini dengan gas Ethereum asli, dan telah muncul jendela kecil untuk menanyakan apakah saya akan menerima transaksi ini. Saya telah mengirim sedikit Ether asli ke dompet Metamask ini, dan itu cukup untuk menyelesaikan transaksi, jadi saya klik ‘terima’.

Cara Mempelajari Soliditas: Panduan Pengodean Ethereum Utama

Pikiran Akhir, Refleksi Dalam

Selesai, berhasil! Artikel demo dan repositori kode ini akan sangat membantu Anda untuk menjadi Ethereum Solidity Language dan pengembang ÐApp! Anda dapat menginstal Plugin Metamask, terhubung ke Ethereum Mainnet, dan mengunjungi www.enledger.io/etherereum-demo-tools dan Anda akan melihat aplikasi Buku Tamu / Demo Notaris saya dan pengguna serta gambar yang sama ini, dan Anda bahkan dapat menandatangani buku tamu dan membuat notaris gambar juga, jika Anda mau &# x1f642;

Supaya kalian tidak terlalu lepas kendali dengan hal ini, saya menambahkan sedikit kemampuan moderasi ke “pemilik” kontrak pintar, yang telah saya tetapkan secara internal ke alamat siapa pun yang awalnya membayar untuk menerapkan smart- kontrak ke mainnet, yaitu saya. Saya ingin menunjukkan kepada Anda dengan sangat cepat bagaimana kemampuan admin khusus itu bekerja karena sangat umum untuk melihat pola kode pengguna admin semacam ini:

alamat GeektAdmin;

function Geekt () hutang {// ini adalah CONSTRUCTOR (nama yang sama dengan kontrak) itu dipanggil SEKALI hanya ketika kontrak pertama kali digunakan

GeektAdmin = pengirim pesan; // cukup setel admin, sehingga mereka dapat menghapus pengguna atau gambar yang buruk jika diperlukan, tetapi tidak ada yang bisa

}

modifier onlyAdmin () {

if (msg.sender! = GeektAdmin)

melemparkan;

// Jangan lupakan "_;"! Ini akan digantikan oleh badan fungsi aktual saat pengubah digunakan.

_;

}

function removeUser (address badUser) onlyAdmin return (sukses bool) {

hapus Pengguna [badUser];

kembali benar;

}

function removeImage (bytes32 badImage) onlyAdmin return (sukses bool) {

hapus notarizedImages [badImage];

kembali benar;

}

Kami memiliki fungsi konstruktor khusus, Geekt (), dengan nama yang sama dengan kontrak itu sendiri, yang dipanggil hanya sekali, saat kontrak pertama kali diterapkan ke blockchain. Fungsi ini menyetel pengguna admin ke alamat pengirim pesan yang membayar untuk menerapkan kontrak pintar. Kami juga memiliki fungsi pengubah onlyAdmin () khusus yang kemudian diterapkan ke fungsi removeUser () dan removeImage () kami, untuk membatasi fungsi tersebut sehingga hanya dapat diaktifkan jika alamat msg.sender adalah alamat pengguna admin.

Sekarang saya punya cara untuk menghapus semua badUsers, jika perlu &# x1f642; Jangan paksa aku melakukannya!

Hal terakhir lainnya yang ingin saya sebutkan adalah bahwa kita baru benar-benar menggores permukaannya di sini. Salah satu jenis fitur dasar yang tidak saya bahas adalah “acara” Soliditas, yang merupakan cara bagi Anda untuk mendorong pembaruan kembali ke browser, seperti koneksi “soket” yang menonton dan mengaktifkan acara browser ketika pengguna baru terdaftar atau gambar terdeteksi. Bagian paling keren dari ethereum dan Solidity berasal dari kontrak pintar yang berinteraksi dengan Oracles, dan kontrak pintar yang berbicara dan bertindak satu sama lain menggunakan “pesan” (DAO). Ada juga beberapa

Bagian paling keren dari ethereum dan Solidity berasal dari kontrak pintar yang berinteraksi dengan Oracles, dan kontrak pintar yang berbicara dan bertindak satu sama lain menggunakan “pesan” (DAO). Ada juga beberapa cukup serius pertimbangan keamanan yang harus Anda pelajari, sebelum Anda mencoba menyimpan ethereum nyata dalam kontrak pintar Anda dan mengirimkannya kepada orang-orang berdasarkan panggilan fungsi, sekelompok orang kehilangan sekitar M dolar karena itu dan akhirnya membelah jaringan ethereum dalam hard-fork kontroversial. Itu adalah sesuatu yang harus Anda perhatikan, dan saya mungkin harus membahasnya di artikel lain, tentunya &# x1f642; Artikel ini seharusnya bagus untuk membuat Anda maju dan menjadi “berbahaya” seperti yang saya katakan, dan saya mendorong Anda untuk mempelajarinya, bahkan meminta beberapa perusahaan yang baik untuk membayar Anda untuk mempelajarinya jika Anda bisa, tetapi masih ada yang lebih dari jalur ini.

Satu lagi, poin terakhir yang ingin saya bicarakan adalah struktur ethereum dan biaya nyata penggunaan kontrak pintar, saat ini. ethereum adalah jaringan yang berjalan pada blockchain publik tunggal yang besar, di mana setiap orang dapat membayar untuk mengakses dan menyimpan data di sana. Namun sebenarnya perbuatan itu agak mahal. Anda dapat melihat di atas pada gambar saya, saya ditagih 0,004182 Ether, yang hari ini setara dengan $ 0,96 dalam dolar AS nyata, untuk menyimpan URL gambar, hash notaris SHA256, dan stempel waktu, yang terdiri dari 196 byte, ke Ethereum Mainnet. Ini berhasil dengan biaya penyimpanan data $ 5.159,03 per MB!

Itu benar-benar gila-gilaan mahal. Ide asli untuk biaya gas yang dijelaskan dalam Buku Putih ethereum mengatakan bahwa biaya gas idealnya seharusnya tetap agak konstan, namun biaya gas terkait dengan nomor blok, dalam implementasi yang sebenarnya, dan nomor blok tidak naik hampir secepat arus harga pasar ethereum, jadi gas menjadi jauh lebih mahal secara riil. Selain itu, situasi hard-fork menunjukkan bahwa ini benar-benar merupakan rantai publik, dan jika sesuatu yang benar-benar diperdebatkan terjadi padanya, hal itu dapat bercabang dan data Anda secara teoritis dapat mengalami rollback, atau kelas aset yang mendasarinya dapat turun harga secara tajam. Biaya data yang sangat besar, dan lautan data di luar sana menunggu untuk disimpan berarti bahwa jumlah data yang dapat disimpan dalam rantai apa pun mungkin perlu dibatasi, atau mungkin membatasi diri.

ethereum mungkin paling cocok untuk hal-hal yang hanya membutuhkan sejumlah kecil penyimpanan data yang tersedia untuk umum agar menjadi on-chain, seperti mungkin sistem reputasi online, atau proyek notaris data. Mungkin tidak masuk akal untuk membangun proyek blockchain untuk meletakkan semua data industri widget AS ke dalam blockchain ethereum, misalnya, karena Anda mungkin tidak ingin semua info itu tersedia untuk umum, dan Anda perlu menurunkan biaya transaksi tersebut untuk Anda. widget-penggunaan khusus industri. Anda mungkin menganggap bahwa model blockchain bukti kepemilikan mungkin lebih hemat energi, bahkan jika itu mungkin mewakili melemahnya teoritis model keamanan konsensus versus bukti kepemilikan Nakamoto untuk proyek blockchain Anda.

Saya menyarankan sebelum memulai proyek blockchain baru, pertimbangkan baik-baik platform yang ingin Anda gunakan, lihat hal-hal terbaru di luar sana dan jangan takut untuk menjelajah, dan juga pertimbangkan baik-baik insentif node yang akan menarik orang untuk mendownload kode node keren Anda, dan menjalankannya! Pujian terbaik yang bisa didapat programmer adalah orang-orang yang menggunakan kode mereka di dunia nyata, dan menjadi produktif dengannya.

Bagian Bonus Gila Rahasia

Lepaskan aku ke Mainnet, Kapten

Saya kembali, dengan lebih banyak hal keren untuk Anda dan komunitas ethereum! Jadi saya melewatkan detail penting di atas, Anda mungkin telah memperhatikan. Setelah Anda menulis kontrak pintar, uji kompilasi ribuan kali hingga berhasil, penerapan, uji localhost, semuanya berfungsi. Sekarang, bagaimana neraka apa kau memasukkan benda ini ke Mainnet !? Semacam itu

Agak sulit dan biasanya harus menjalankan node ethereum lengkap Anda sendiri, atau membayar seseorang untuk menjalankannya untuk Anda dan mengizinkan Anda mengaksesnya (seperti melalui VPS). Jadi, itu sangat merepotkan bagi saya, karena saya tidak sabar dan saya menulis artikel ini dengan tenggat waktu, semuanya! Saya tidak punya waktu untuk menunggu simpul penuh ethereum baru saya untuk disinkronkan, dan saya tidak ingin menghabiskan beberapa ratus pertunjukan ruang hard-drive dan salah satu kotak saya untuk mengunyah ethereum tx secara penuh, dan saya Saya juga terlalu murah untuk membayar VPS untuk melakukannya untuk saya, lol.

Jadi saya menggunakan beberapa javascript web kung-fu khusus, dan baru saja mengetahui bagaimana saya dapat membuat halaman web dengan kotak dan tombol, di mana Anda dapat menempelkan kontrak Anda, mengklik tombol, dan menerapkan kontrak pintar Solidity langsung ke Mainnet, melalui Metamask Plugin. Terutama saya melakukan ini hanya untuk kenyamanan, untuk menulis artikel ini, tetapi ternyata itu adalah alat yang sangat berguna, jadi saya memasangnya di web untuk digunakan semua orang. Untuk pertama kalinya, Anda dapat melakukan semua pengujian dan bahkan penerapan kontrak pintar penuh ke ethereum Mainnet, tanpa memerlukan node ethereum lengkap Anda sendiri! Mari saya perkenalkan EthDeployer tool, ini gratis untuk kalian karena perangkat lunak gratis memberi kita kebebasan &# x1f642;

Ini tautan ke EthDeployer Repo di Github, dan Anda juga dapat mengakses siaran langsung saya EthDeployer Tectract dan menerapkan kontrak Anda langsung dari sana, Anda hanya perlu menginstal Plugin Metamask dan terhubung ke Mainnet Ethereum terlebih dahulu, ditambah lagi Anda akan memerlukan sedikit Ether di dompet Metamask Anda untuk membayar biaya penerapan kontrak pintar Mainnet juga, tentu saja!

Alat ini menggunakan Browser-Solc alat, yang hanya merupakan alat pemuat yang diperkecil dan di-browser untuk memuat versi javascript dari Solidity Compiler, langsung ke browser sisi klien, untuk mem-parsing / menyusun kontrak cerdas secara langsung. Hal ini membuat alat tersebut sepenuhnya berdiri sendiri dan portabel, yang berarti Anda tidak perlu khawatir tentang memasang kompiler Solc di komputer Anda, dan saya juga tidak perlu khawatir tentang memasangnya di server saya, yang sangat bagus untuk semua orang. Izinkan saya menunjukkan kode yang memuat kompiler soliditas terbaru yang tersedia:

Saya memiliki pemuatan javascript browser-solc.min.js yang diperkecil melalui halaman index.html tingkat atas, yang membuat window.BrowserSolc objek tersedia untuk skrip reaksi tingkat rendah saya. Ini adalah aplikasi create-react-sangat sederhana yang dapat diinstal dan digunakan dalam beberapa menit di mesin Anda sendiri, saya bahkan menyediakan readme.md yang benar-benar berguna di repo github yang menunjukkan kepada Anda bagaimana melakukannya.

setupCompiler () {

var outerThis = ini;

setTimeout (function () {

// console.debug (window.BrowserSolc);

window.BrowserSolc.getVersions (function (soljsonSources, soljsonReleases) {

var compilerVersion = soljsonReleases [_. keys (soljsonReleases) [0]];

console.log ("Versi kompiler browser-solc: " + compilerVersion);

window.BrowserSolc.loadVersion (compilerVersion, function (c) {

kompiler = c;

outerThis.setState ({statusMessage:"siap!"},fungsi(){

console.log ("Versi Solc Dimuat: " + compilerVersion);

});

});

});

}, 1000);

}

Fungsi setupCompiler menunggu sesaat hingga objek window.BrowserSolc tersedia setelah halaman dimuat, lalu melakukan fungsi internal .getVersions () dan .loadVersion (), sebenarnya tidak banyak, dan kami memiliki kompiler Solc yang fungsional tersedia bagi kami secara langsung di lingkungan sisi klien sepenuhnya, bagus! Untuk kelengkapan, saya akan menunjukkan beberapa baris relevan yang benar-benar menangani kompilasi dan penerapan kontrak dari dalam fungsi javascript, saat “kompilasi & menyebarkan!” tombol ditekan:

compileAndDeploy () {

var result = compiler.compile (this.state.contractText, optimalkan);

var abi = JSON.parse (result.contracts [_. keys (result.contracts) [0]]. interface);

var bytecode = "0x" + result.contracts [_. keys (result.contracts) [0]]. bytecode;

var myContract = web3.eth.contract (abi);

web3.eth.estimateGas ({data: bytecode}, function (err, gasEstimate) {

myContract.new ({from: web3.eth.accounts [0], data: bytecode, gas: inflatedGasCost}, function (err, newContract) {

thisTxHash: newContract.transactionHash,

thisAddress: newContract.address

Kita memiliki semua objek yang kita kenal sebelumnya, kita sebut compiler.compile () pada teks kontrak, dan dapatkan objek “hasil” kontrak yang dikompilasi dari mana kami mengekstrak abi dan bytecode, dan mengirimkannya dalam transaksi baru. Kami melihat fungsi .estimateGas () kami yang lama digunakan di sini untuk ukuran yang baik juga. Kami mengambil ID transaksi dan alamat kontrak baru untuk ditampilkan kembali kepada pengguna saat kontrak berhasil diterapkan. Bam, selesai! Mari kita lihat aksinya:

“Oh ya, jika Anda mendapatkan pesan kesalahan saat penerapan, pastikan untuk benar-benar memeriksa tautan ID transaksi, kontrak kemungkinan besar DID benar-benar berhasil diterapkan, terkadang Metamask gagal mengambil status transaksi keberhasilan penerapan dan alamat kontrak baru dan mengembalikan itu ke lingkungan browser kami dengan sukses. “

Cara Mempelajari Soliditas: Panduan Pengodean Ethereum Utama

Itu masih hidup. Hal ini membuatku begitu senang! Bonus Ekstra Gila Rahasia Tidak Terkunci! Jadi, saya membayar 0,02268 Ether dalam gas, yaitu sekitar $ 5,30 USD (1 Juni 2017), untuk menerapkan kontrak ini ke ethereum Mainnet. Ingat ini seharusnya menjadi aplikasi demo yang sangat sederhana, dengan hanya dua kemungkinan struktur data. Itu hanya seperti $ 2 beberapa minggu yang lalu, ini liar! Namun tetap terjangkau, Anda tidak perlu menerapkan kontrak Anda ke rantai utama yang sering, hanya sekali melakukannya.

Hanya itu yang saya miliki untuk Anda kali ini, guys! Semoga tutorial ini sangat berguna, dan Anda dapat memanfaatkan alat EthDeployer dengan baik dalam petualangan developer Anda di luar sana. Saya menantikan untuk mendengar pertanyaan dan komentar, terima kasih!

Ryan Molecke

Ryan Molecke, Chief Technology Officer (CTO) dari EnLedger Corp.., adalah peneliti ilmu komputasi akademis multi-disiplin, yang beralih ke dunia teknologi keuangan dan sistem perdagangan. Dia bekerja di beberapa perusahaan rintisan teknologi keuangan yang terkenal dan sukses, membantu merancang sistem perdagangan dan perantara / pertukaran, dan sekarang fokus pada buku besar yang diizinkan dan integrasi sistem blockchain, tokenisasi, dan program kredit. Dia memegang gelar B.S.E. di bidang Teknik Komputer dan Ph.D. di Nanoscience dan Microsystems Engineering, keduanya dari UNM

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me