Klien Ethereum Ringan Menggunakan Web3j

Java Top

Saya baru saja mengumumkan kursus Learn Spring baru , yang berfokus pada dasar-dasar Spring 5 dan Spring Boot 2:

>> LIHAT KURSUSnya

1. Perkenalan

Tutorial ini memperkenalkan Web3j, implementasi Java dari pustaka abstraksi Web3 yang populer.

Web3j digunakan untuk berinteraksi dengan jaringan Ethereum dengan menghubungkan ke node Ethereum menggunakan JSON-RPC atau standar yang sudah dikenal seperti HTTP, WebSockets, IPC.

Ethereum adalah keseluruhan topik tersendiri, jadi pertama-tama mari kita lihat apa itu!

2. Ethereum

Ethereum adalah (1) cryptocurrency (simbol token ETH), (2) superkomputer terdistribusi, (3) blockchain, dan (4) jaringan kontrak pintar yang ditulis dalam Solidity.

Dengan kata lain, Ethereum ( jaringan ) dijalankan oleh sekelompok server terhubung yang disebut node yang berkomunikasi dalam semacam topologi mesh (secara teknis, ini tidak sepenuhnya benar tetapi cukup dekat untuk mendapatkan pemahaman yang lebih kuat tentang bagaimana semuanya bekerja) .

Web3j , dan pustaka induknya yang disebut Web3 , memungkinkan aplikasi web untuk terhubung ke salah satu node tersebut dan dengan demikian mengirimkan transaksi Ethereum , yang, untuk semua maksud dan tujuan, menyusun fungsi kontrak pintar Solidity yang sebelumnya telah diterapkan ke jaringan Ethereum . Untuk informasi lebih lanjut tentang kontrak pintar, lihat artikel kami tentang membuat dan menerapkannya dengan Solidity di sini.

Setiap Node memancarkan perubahannya ke setiap node lainnya sehingga konsensus dan verifikasi dapat dicapai. Dengan demikian, setiap node berisi seluruh riwayat blockchain Ethereum secara bersamaan sehingga membuat cadangan yang berlebihan dari semua data, dengan cara yang tidak dapat dirusak, dan melalui konsensus dan verifikasi oleh semua node lain di jaringan . \

Untuk informasi lebih detail tentang Ethereum, lihat halaman resminya.

3. Pengaturan

Untuk menggunakan rangkaian lengkap fitur yang disediakan oleh Web3j, kita harus melakukan sedikit lebih banyak untuk menyiapkan daripada biasanya. Pertama, Web3j disediakan dalam beberapa modul yang berdiri sendiri, yang masing-masing dapat ditambahkan secara opsional ke dependensi pom.xml inti :

 org.web3j core 3.3.1  

Harap dicatat bahwa tim di Web3j menyediakan Spring Boot Starter yang sudah dibuat sebelumnya dengan beberapa konfigurasi dan fungsionalitas terbatas yang sudah ada di dalamnya!

Kami akan membatasi fokus kami pada fungsionalitas inti dalam artikel ini (termasuk cara menambahkan Web3j ke aplikasi Spring MVC, sehingga kompatibilitas dengan rentang yang lebih luas dari aplikasi web Spring diperoleh).

Daftar lengkap modul-modul ini dapat ditemukan di Maven Central.

3.1. Menyusun Kontrak: Truffle atau Solc

Ada dua cara utama untuk mengkompilasi dan menerapkan kontrak pintar Ethereum ( file . Solc ):

  1. Kompiler Solidity resmi.
  2. Truffle (paket abstraksi untuk menguji, menerapkan, dan mengelola kontrak pintar).

Kami akan tetap menggunakan Truffle di artikel ini. Truffle menyederhanakan dan mengabstraksi proses penyusunan kontrak pintar , memigrasikannya, dan menerapkannya ke jaringan. Ini juga membungkus kompiler Solc sehingga kita dapat memperoleh pengalaman dengan keduanya.

Untuk mengatur Truffle:

$ npm install truffle -g $ truffle version

Empat perintah utama yang akan kami gunakan untuk menginisialisasi proyek kami masing-masing, mengompilasi aplikasi kami, menerapkan aplikasi kami ke Blockchain, dan mengujinya masing-masing:

$ truffle init $ truffle compile $ truffle migrate $ truffle test

Sekarang, mari kita lihat contoh sederhana:

pragma solidity ^0.4.17; contract Example { function Example() { // constructor } } 

Yang seharusnya menghasilkan ABI JSON berikut saat dikompilasi:

{ "contractName": "Example", "abi": [ { "inputs": [], "payable": false, "stateMutability": "nonpayable", "type": "constructor" } ], "bytecode": "0x60606040523415600e57600080fd5b603580601b6..., "deployedBytecode": "0x6060604052600080fd00a165627a7a72305..., //... }

Kami kemudian dapat menggunakan bytecode dan ABI yang disediakan dalam aplikasi kami untuk berinteraksi dengan kontrak yang diterapkan!

3.2. Kontrak Pengujian: Ganache

Salah satu cara termudah untuk bekerja dengan testnet Ethereum adalah dengan meluncurkan server Ganache sendiri. Kami akan menggunakan solusi yang sudah dibuat sebelumnya, di luar kotak, karena paling mudah untuk disiapkan dan dikonfigurasi. Ini juga menyediakan antarmuka dan shell server untuk Ganache CLI yang menjalankan Ganache secara tersembunyi.

Kita dapat terhubung ke server Ganache kita pada alamat URL yang disediakan default: // localhost: 8545 atau // localhost: 7545.

Ada beberapa pendekatan populer lainnya untuk menyiapkan jaringan pengujian termasuk menggunakan Meta-Mask, Infura, atau Go-Lang dan Geth.

Kami akan tetap menggunakan Ganache dalam artikel ini karena menyiapkan instance GoLang Anda sendiri (dan mengonfigurasinya sebagai testnet khusus) bisa sangat rumit dan karena status Meta-Mask di Chrome saat ini tidak pasti.

Kami dapat menggunakan Ganache untuk skenario pengujian manual (saat men-debug atau menyelesaikan pengujian integrasi kami) atau menggunakannya untuk skenario pengujian otomatis (yang kami harus membangun pengujian kami karena, dalam keadaan seperti itu, kami mungkin tidak memiliki titik akhir yang tersedia).

4. Web3 dan RPC

Web3 menyediakan fasad dan antarmuka untuk berinteraksi dengan mudah dengan blockchain Ethereum dan node server Ethereum. Dengan kata lain, Web3 memfasilitasi interkomunikasi antara klien dan Ethereum Blockchain melalui JSON-RPC. Web3J adalah port Java resmi Web3.

Kita dapat menginisialisasi Web3j untuk digunakan dalam aplikasi kita dengan mengirimkan penyedia (misalnya - titik akhir node Ethereum pihak ketiga atau lokal):

Web3j web3a = Web3j.build(new HttpService()); Web3j web3b = Web3j.build(new HttpService("YOUR_PROVIDER_HERE")); Web3j myEtherWallet = Web3j.build( new HttpService("//api.myetherapi.com/eth"));

The third option shows how to add in a third-party provider (thereby connecting with their Ethereum node). But we also have the option to leave our provider option empty. In that case, the default port will be used (8545) on localhost instead.

5. Essential Web3 Methods

Now that we know how to initialize our app to communicate with the Ethereum blockchain, let's look at a few, core, ways to interact with the Ethereum blockchain.

It's a good policy to wrap your Web3 methods with a CompleteableFuture to handle the asynchronous nature of JSON-RPC requests made to your configured Ethereum node.

5.1. Current Block Number

We can, for example, return the current block number:

public EthBlockNumber getBlockNumber() { EthBlockNumber result = new EthBlockNumber(); result = this.web3j.ethBlockNumber() .sendAsync() .get(); return result; }

5.2. Account

To get the account of a specified address:

public EthAccounts getEthAccounts() { EthAccounts result = new EthAccounts(); result = this.web3j.ethAccounts() .sendAsync() .get(); return result; }

5.3. Number of Account Transactions

To get the number of transactions of a given address:

public EthGetTransactionCount getTransactionCount() { EthGetTransactionCount result = new EthGetTransactionCount(); result = this.web3j.ethGetTransactionCount(DEFAULT_ADDRESS, DefaultBlockParameter.valueOf("latest")) .sendAsync() .get(); return result; }

5.4. Account Balance

And finally, to get the current balance of an address or wallet:

public EthGetBalance getEthBalance() { EthGetBalance result = new EthGetBalance(); this.web3j.ethGetBalance(DEFAULT_ADDRESS, DefaultBlockParameter.valueOf("latest")) .sendAsync() .get(); return result; }

6. Working With Contracts in Web3j

Once we've compiled our Solidity contract using Truffle, we can work with our compiled Application Binary Interfaces (ABI) using the standalone Web3j command line tool available here or as a free-standing zip here.

6.1. CLI Magic

We can then automatically generate our Java Smart Contract Wrappers (essentially a POJO exposing the smart contract ABI) using the following command:

$ web3j truffle generate [--javaTypes|--solidityTypes] /path/to/.json -o /path/to/src/main/java -p com.your.organisation.name

Running the following command in the root of the project:

web3j truffle generate dev_truffle/build/contracts/Example.json -o src/main/java/com/baeldung/web3/contract -p com.baeldung

generated our Example class:

public class Example extends Contract { private static final String BINARY = "0x60606040523415600e576..."; //... }

6.2. Java POJO's

Now that we have our Smart Contract Wrapper, we can create a wallet programmatically and then deploy our contract to that address:

WalletUtils.generateNewWalletFile("PASSWORD", new File("/path/to/destination"), true);
Credentials credentials = WalletUtils.loadCredentials("PASSWORD", "/path/to/walletfile");

6.3. Deploy a Contract

We can deploy our contract like so:

Example contract = Example.deploy(this.web3j, credentials, ManagedTransaction.GAS_PRICE, Contract.GAS_LIMIT).send(); 

And then get the address:

contractAddress = contract.getContractAddress();

6.4. Sending Transactions

To send a Transaction using the Functions of our Contract we can initialize a Web3j Function with a List of input values and a List of output parameters:

List inputParams = new ArrayList(); List outputParams = new ArrayList(); Function function = new Function("fuctionName", inputParams, outputParams); String encodedFunction = FunctionEncoder.encode(function); 

We can then initialize our Transaction with necessary gas (used to execute of the Transaction) and nonce parameters:

BigInteger nonce = BigInteger.valueOf(100); BigInteger gasprice = BigInteger.valueOf(100); BigInteger gaslimit = BigInteger.valueOf(100); Transaction transaction = Transaction .createFunctionCallTransaction("FROM_ADDRESS", nonce, gasprice, gaslimit, "TO_ADDRESS", encodedFunction); EthSendTransaction transactionResponse = web3j.ethSendTransaction(transaction).sendAsync().get(); transactionHash = transactionResponse.getTransactionHash(); 

Untuk daftar lengkap fungsi kontrak pintar, lihat dokumen resmi.

7. Kesimpulan

Itu dia! Kami telah menyiapkan aplikasi Java Spring MVC dengan Web3j - saatnya Blockchain !

Seperti biasa, contoh kode yang digunakan dalam artikel ini tersedia di GitHub.

Jawa bawah

Saya baru saja mengumumkan kursus Learn Spring baru , yang berfokus pada dasar-dasar Spring 5 dan Spring Boot 2:

>> LIHAT KURSUSnya