Leichte Ethereum-Clients mit Web3j

Java Top

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs

1. Einleitung

In diesem Tutorial wird Web3j vorgestellt, eine Java-Implementierung der beliebten Web3-Abstraktionsbibliothek.

Web3j wird zur Interaktion mit dem Ethereum-Netzwerk verwendet, indem mithilfe von JSON-RPC oder bekannten Standards wie HTTP, WebSockets und IPC eine Verbindung zu Ethereum-Knoten hergestellt wird .

Ethereum ist ein ganzes Thema für sich, also schauen wir uns zuerst kurz an, was es ist!

2. Ethereum

Ethereum ist eine (1) Kryptowährung (Tokensymbol ETH), (2) verteilter Supercomputer, (3) Blockchain und (4) intelligentes Vertragsnetzwerk, geschrieben in Solidity.

Mit anderen Worten, Ethereum (das Netzwerk ) wird von einer Reihe verbundener Server betrieben, die als Knoten bezeichnet werden und in einer Art Maschentopologie kommunizieren (technisch gesehen ist dies nicht genau richtig, aber nah genug, um ein besseres Verständnis der Funktionsweise zu erhalten). .

Web3j , und ihre Mutter Bibliothek namens Web3 , ermöglicht Web - Anwendungen zu einer jener verbinden Knoten und damit Astraleum einreichen Transaktionen , die sind, für alle Absichten und Zwecke, zusammengestellt Solidity Smart Vertrag Funktionen , die zuvor auf dem Astraleum bereitgestellt wurden Netzwerk . Weitere Informationen zu intelligenten Verträgen finden Sie in unserem Artikel zum Erstellen und Bereitstellen mit Solidity.

Jeder Knoten sendet seine Änderungen an jeden anderen Knoten, damit Konsens und Überprüfung erreicht werden können. Somit jeder Knoten enthält die gesamte Geschichte des Astraleum blockchain gleichzeitig dadurch eine redundante Sicherung aller Daten zu schaffen, in einer manipulationssicheren Art und Weise und über Konsens und Verifikation von allen anderen Knoten in dem Netzwerk . \

Weitere Informationen zu Ethereum finden Sie auf der offiziellen Seite.

3. Einrichten

Um die gesamte Palette der von Web3j bereitgestellten Funktionen nutzen zu können, müssen wir etwas mehr tun, um als üblich eingerichtet zu werden. Erstens wird Web3j in mehreren freistehenden Modulen geliefert, von denen jedes optional zur Kernabhängigkeit pom.xml hinzugefügt werden kann :

 org.web3j core 3.3.1  

Bitte beachten Sie, dass das Team von Web3j einen vorgefertigten Spring Boot Starter mit einigen integrierten Konfigurationen und eingeschränkten Funktionen bereitstellt!

Wir werden unseren Fokus auf die Kernfunktionen in diesem Artikel beschränken (einschließlich des Hinzufügens von Web3j zu einer Spring MVC-Anwendung, damit die Kompatibilität mit einer größeren Auswahl an Spring Webapps erreicht wird).

Eine vollständige Liste dieser Module finden Sie in Maven Central.

3.1. Verträge zusammenstellen: Trüffel oder Solc

Es gibt zwei Hauptmethoden zum Kompilieren und Bereitstellen von Ethereum-Smart-Verträgen (. Solc- Dateien):

  1. Der offizielle Solidity-Compiler.
  2. Truffle (eine Abstraktionssuite zum Testen, Bereitstellen und Verwalten intelligenter Verträge).

Wir bleiben in diesem Artikel bei Truffle. Truffle vereinfacht und abstrahiert den Prozess des Kompilierens intelligenter Verträge , der Migration und Bereitstellung in einem Netzwerk. Außerdem wird der Solc- Compiler umschlossen, sodass wir mit beiden Erfahrungen sammeln können.

So richten Sie Trüffel ein:

$ npm install truffle -g $ truffle version

Vier Schlüsselbefehle, mit denen wir unser Projekt initialisieren, unsere App kompilieren, unsere App in der Blockchain bereitstellen und jeweils testen:

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

Lassen Sie uns nun ein einfaches Beispiel durchgehen:

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

Was beim Kompilieren den folgenden ABI JSON ergeben sollte:

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

Wir können dann den bereitgestellten Bytecode und ABI in unserer Anwendung verwenden, um mit den bereitgestellten Verträgen zu interagieren!

3.2. Testverträge: Ganache

Eine der einfachsten Möglichkeiten, mit einem Ethereum-Testnetz zu arbeiten, besteht darin, einen eigenen Ganache-Server zu starten. Wir werden die vorgefertigte, sofort einsatzbereite Lösung verwenden, da sie am einfachsten einzurichten und zu konfigurieren ist. Es bietet auch eine Schnittstelle und eine Server-Shell für die Ganache-CLI, die Ganache unter der Haube steuert.

Wir können eine Verbindung zu unserem Ganache-Server unter der standardmäßig angegebenen URL-Adresse herstellen: // localhost: 8545 oder // localhost: 7545.

Es gibt einige andere beliebte Ansätze zum Einrichten eines Testnetzwerks, einschließlich der Verwendung von Meta-Mask, Infura oder Go-Lang und Geth.

Wir werden uns in diesem Artikel an Ganache halten, da das Einrichten einer eigenen GoLang-Instanz (und das Konfigurieren als benutzerdefiniertes Testnetz) ziemlich schwierig sein kann und der Status von Meta-Mask in Chrome derzeit ungewiss ist.

Wir können Ganache für manuelle Testszenarien (beim Debuggen oder Abschließen unserer Integrationstests) oder für automatisierte Testszenarien verwenden (um die wir unsere Tests aufbauen müssen, da wir unter solchen Umständen möglicherweise nicht über die verfügbaren Endpunkte verfügen).

4. Web3 und RPC

Web3 bietet eine Fassade und eine Schnittstelle für die einfache Interaktion mit der Ethereum-Blockchain und den Ethereum-Serverknoten. Mit anderen Worten, Web3 erleichtert die Kommunikation zwischen Clients und der Ethereum-Blockchain über JSON-RPC. Web3J ist der offizielle Java-Port von Web3.

Wir können Web3j für die Verwendung in unserer Anwendung initialisieren, indem wir einen Anbieter übergeben (z. B. den Endpunkt eines Drittanbieter- oder lokalen Ethereum-Knotens):

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

Eine vollständige Liste der Funktionen für intelligente Verträge finden Sie in den offiziellen Dokumenten.

7. Fazit

Das ist es! Wir haben eine Java Spring MVC-App mit Web3j eingerichtet - es ist Blockchain-Zeit!

Wie immer sind die in diesem Artikel verwendeten Codebeispiele auf GitHub verfügbar.

Java unten

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs