Clienti Ethereum leggeri che utilizzano Web3j

Java Top

Ho appena annunciato il nuovo corso Learn Spring , incentrato sui fondamenti di Spring 5 e Spring Boot 2:

>> SCOPRI IL CORSO

1. Introduzione

Questo tutorial introduce Web3j, un'implementazione Java della popolare libreria di astrazione Web3.

Web3j viene utilizzato per interagire con la rete Ethereum connettendosi ai nodi Ethereum utilizzando JSON-RPC o standard familiari come HTTP, WebSocket, IPC.

Ethereum è un argomento a sé stante, quindi diamo prima una rapida occhiata a quello che è!

2. Ethereum

Ethereum è una (1) criptovaluta (simbolo del token ETH), (2) supercomputer distribuito, (3) blockchain e (4) rete di contratti intelligenti scritti in Solidity.

In altre parole, Ethereum (la rete ) è gestita da un gruppo di server connessi chiamati nodi che comunicano in una sorta di topologia mesh (tecnicamente, questo non è esattamente vero ma abbastanza vicino per avere una comprensione più solida di come funziona il tutto) .

Web3j , e la sua libreria madre chiamata Web3 , consente alle applicazioni web di connettersi a uno di quei nodi e quindi inviare transazioni Ethereum , che sono, a tutti gli effetti, funzioni di contratto intelligente Solidity compilate che sono state precedentemente implementate sulla rete Ethereum . Per ulteriori informazioni sugli smart contract, consulta il nostro articolo sulla creazione e la distribuzione con Solidity qui.

Ogni nodo trasmette le proprie modifiche a ogni altro nodo in modo da ottenere il consenso e la verifica. Pertanto, ogni nodo contiene l'intera cronologia della blockchain di Ethereum simultaneamente creando così un backup ridondante di tutti i dati, a prova di manomissione, e tramite consenso e verifica da parte di tutti gli altri nodi della rete . \

Per informazioni più dettagliate su Ethereum, controlla la pagina ufficiale.

3. Configurazione

Per utilizzare la suite completa di funzionalità fornite da Web3j, dobbiamo fare un po 'di più per la configurazione del solito. Innanzitutto, Web3j è fornito in diversi moduli indipendenti, ognuno dei quali può essere aggiunto facoltativamente alla dipendenza principale pom.xml :

 org.web3j core 3.3.1  

Tieni presente che il team di Web3j fornisce uno Spring Boot Starter preconfigurato con alcune configurazioni e funzionalità limitate incorporate!

In questo articolo limiteremo la nostra attenzione alle funzionalità principali (incluso come aggiungere Web3j a un'applicazione Spring MVC, in modo da ottenere la compatibilità con una gamma più ampia di webapp Spring).

Un elenco completo di questi moduli può essere trovato su Maven Central.

3.1. Compilazione contratti: Tartufo o Solc

Esistono due modi principali per compilare e distribuire smart contract Ethereum ( file . Solc ):

  1. Il compilatore ufficiale di Solidity.
  2. Truffle (una suite di astrazione per testare, distribuire e gestire contratti intelligenti).

Resteremo fedeli al tartufo in questo articolo. Truffle semplifica e astrae il processo di compilazione di contratti intelligenti , migrazione e distribuzione su una rete. Avvolge anche il compilatore Solc permettendoci di acquisire un po 'di esperienza con entrambi.

Per impostare Truffle:

$ npm install truffle -g $ truffle version

Quattro comandi chiave che useremo rispettivamente per inizializzare il nostro progetto, compilare la nostra app, distribuire la nostra app sulla Blockchain e testarla rispettivamente:

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

Ora, esaminiamo un semplice esempio:

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

Che dovrebbe produrre il seguente ABI JSON quando compilato:

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

Possiamo quindi utilizzare il bytecode fornito e l'ABI all'interno della nostra applicazione per interagire con i contratti distribuiti!

3.2. Contratti di prova: Ganache

Uno dei modi più semplici per lavorare con un testnet Ethereum è avviare il proprio server Ganache. Useremo la soluzione preconfigurata, pronta per l'uso, poiché è la più semplice da impostare e configurare. Fornisce inoltre un'interfaccia e una shell del server per Ganache CLI che guida Ganache sotto il cofano.

Possiamo connetterci al nostro server Ganache sull'indirizzo URL fornito di default: // localhost: 8545 o // localhost: 7545.

Ci sono un paio di altri approcci popolari per configurare una rete di test, incluso l'uso di Meta-Mask, Infura o Go-Lang e Geth.

Resteremo fedeli a Ganache in questo articolo poiché configurare la tua istanza GoLang (e configurarla come testnet personalizzato) può essere piuttosto complicato e poiché lo stato di Meta-Mask su Chrome è attualmente incerto.

Possiamo usare Ganache per scenari di test manuali (durante il debug o completare il nostro test di integrazione) o usarli per scenari di test automatici (su cui dobbiamo costruire i nostri test poiché, in tali circostanze, potremmo non avere gli endpoint disponibili).

4. Web3 e RPC

Web3 fornisce una facciata e un'interfaccia per interagire facilmente con la blockchain di Ethereum e i nodi del server Ethereum. In altre parole, Web3 facilita l'intercomunicazione tra i client e la Blockchain di Ethereum tramite JSON-RPC. Web3J è il port Java ufficiale di Web3.

Possiamo inizializzare Web3j per l'uso all'interno della nostra applicazione passando un provider (ad esempio, l'endpoint di un nodo Ethereum di terze parti o locale):

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(); 

Per un elenco completo delle funzionalità degli smart contract, consultare i documenti ufficiali.

7. Conclusione

Questo è tutto! Abbiamo configurato un'app Java Spring MVC con Web3j : è tempo di Blockchain!

Come sempre, gli esempi di codice utilizzati in questo articolo sono disponibili su GitHub.

Fondo Java

Ho appena annunciato il nuovo corso Learn Spring , incentrato sui fondamenti di Spring 5 e Spring Boot 2:

>> SCOPRI IL CORSO