Lichtgewicht Ethereum-clients die Web3j gebruiken

Java Top

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

>> BEKIJK DE CURSUS

1. Inleiding

Deze tutorial introduceert Web3j, een Java-implementatie van de populaire Web3-abstractiebibliotheek.

Web3j wordt gebruikt om te communiceren met het Ethereum-netwerk door verbinding te maken met Ethereum-knooppunten met behulp van JSON-RPC of bekende standaarden zoals HTTP, WebSockets, IPC.

Ethereum is een heel onderwerp op zich, dus laten we eerst even kijken wat het is!

2. Ethereum

Ethereum is een (1) cryptocurrency (token-symbool ETH), (2) gedistribueerde supercomputer, (3) blockchain en (4) smart contract-netwerk geschreven in Stevigheid.

Met andere woorden, Ethereum (het netwerk) wordt gerund door een aantal verbonden servers genaamd knooppunten die communiceren in een soort mesh-topologie (technisch gezien is dit niet helemaal waar, maar dichtbij genoeg om een ​​beter begrip te krijgen van hoe het allemaal werkt).

Web3j, en de bovenliggende bibliotheek met de naam Web3, staat toe web applicaties om verbinding te maken met een van deze knooppunten en dien daarbij Ethereum in transacties, die in alle opzichten Solidity zijn samengesteld slim contractfuncties die eerder zijn geïmplementeerd op het Ethereum netwerk. Zie ons artikel over het maken en implementeren ervan met Solidity voor meer informatie over slimme contracten hier.

Elk knooppunt zendt zijn wijzigingen naar elkaar uit knooppunt zodat consensus en verificatie kunnen worden bereikt. Dus, elk knooppunt bevat de volledige geschiedenis van de Ethereum blockchain gelijktijdig waardoor een redundante back-up van alle gegevens wordt gemaakt, op een fraudebestendige manier, en via consensus en verificatie door alle andere knooppunt in de netwerk.\

Raadpleeg de officiële pagina voor meer informatie over Ethereum.

3. Instellen

Om de volledige reeks functies van Web3j te gebruiken, moeten we iets meer doen dan normaal. Ten eerste wordt Web3j geleverd in verschillende, vrijstaande modules die elk optioneel aan de kern kunnen worden toegevoegd pom.xml afhankelijkheid:

 org.web3j kern 3.3.1 

Houd er rekening mee dat het team van Web3j biedt een vooraf gebouwde Spring Boot Starter met een aantal configuratie en beperkte functionaliteit ingebouwd!

We zullen onze focus beperken tot de kernfunctionaliteiten in dit artikel (inclusief het toevoegen van Web3j aan een Spring MVC-applicatie, zodat compatibiliteit met een breder scala aan Spring-webapps wordt verkregen).

Een volledige lijst van deze modules is te vinden op Maven Central.

3.1. Contracten opstellen: Truffle of Solc

Er zijn twee primaire manieren om slimme Ethereum-contracten (.solc bestanden):

  1. De officiële Solidity-compiler.
  2. Truffle (een abstractiesuite voor het testen, implementeren en beheren van slimme contracten).

We blijven in dit artikel bij Truffle. Truffle vereenvoudigt en abstraheert het proces van het opstellen van slimme contracten, ze migreren en ze in een netwerk implementeren. Het omhult ook de Solc compiler waardoor we wat ervaring kunnen opdoen met beide.

Truffle instellen:

$ npm truffel installeren -g $ truffelversie

Vier sleutelopdrachten die we zullen gebruiken om respectievelijk ons ​​project te initialiseren, onze app te compileren, onze app in de Blockchain te implementeren en deze respectievelijk te testen:

$ truffel init $ truffel compileer $ truffel migreer $ truffeltest

Laten we nu een eenvoudig voorbeeld bekijken:

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

Wat bij het compileren de volgende ABI JSON zou moeten opleveren:

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

We kunnen dan de geleverde bytecode en ABI binnen onze applicatie gebruiken om te communiceren met de geïmplementeerde contracten!

3.2. Contracten testen: Ganache

Een van de gemakkelijkste manieren om met een Ethereum-testnet te werken, is door een eigen Ganache-server te starten. We gebruiken de kant-en-klare oplossing, omdat deze het gemakkelijkst is in te stellen en te configureren. Het biedt ook een interface en server-shell voor Ganache CLI die Ganache onder de motorkap drijft.

We kunnen verbinding maken met onze Ganache-server op het standaard opgegeven URL-adres: // localhost: 8545 of // localhost: 7545.

Er zijn een aantal andere populaire benaderingen om een ​​testnetwerk op te zetten, waaronder het gebruik van Meta-Mask, Infura of Go-Lang en Geth.

We blijven in dit artikel bij Ganache, omdat het opzetten van je eigen GoLang-instantie (en het configureren als een aangepast testnet) behoorlijk lastig kan zijn en aangezien de status van Meta-Mask op Chrome momenteel onzeker is.

We kunnen Ganache gebruiken voor handmatige testscenario's (bij het debuggen of het voltooien van onze integratietests) of ze gebruiken voor geautomatiseerde testscenario's (waar we onze tests omheen moeten bouwen omdat we in dergelijke omstandigheden mogelijk niet over de beschikbare eindpunten beschikken).

4. Web3 en RPC

Web3 biedt een façade en interface voor eenvoudige interactie met de Ethereum-blockchain en Ethereum-serverknooppunten. Met andere woorden, Web3 vergemakkelijkt de onderlinge communicatie tussen klanten en de Ethereum Blockchain via JSON-RPC. Web3J is de officiële Java-poort van Web3.

We kunnen Web3j initialiseren voor gebruik binnen onze applicatie door een provider door te geven (bijv. - het eindpunt van een externe of lokale Ethereum-node):

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

De derde optie laat zien hoe je een externe provider toevoegt (waardoor je verbinding maakt met hun Ethereum-knooppunt). Maar we hebben ook de mogelijkheid om onze provideroptie leeg te laten. In dat geval wordt de standaardpoort gebruikt (8545) Aan localhost in plaats daarvan.

5. Essentiële Web3-methoden

Nu we weten hoe we onze app moeten initialiseren om te communiceren met de Ethereum-blockchain, laten we eens kijken naar een paar belangrijke manieren om te communiceren met de Ethereum-blockchain.

Het is een goed beleid om uw Web3-methoden te omhullen met een Voltooibare toekomst om de asynchrone aard van JSON-RPC-verzoeken aan uw geconfigureerde Ethereum-knooppunt af te handelen.

5.1. Huidig ​​bloknummer

We kunnen bijvoorbeeld geef het huidige bloknummer terug:

openbaar EthBlockNumber getBlockNumber () {Resultaat EthBlockNumber = nieuw EthBlockNumber (); resultaat = this.web3j.ethBlockNumber () .sendAsync () .get (); resultaat teruggeven; }

5.2. Account

Om het rekening van een opgegeven adres:

openbare EthAccounts getEthAccounts () {EthAccounts resultaat = nieuwe EthAccounts (); resultaat = this.web3j.ethAccounts () .sendAsync () .get (); resultaat teruggeven; }

5.3. Aantal rekeningtransacties

Om het aantal transacties van een bepaald adres:

openbaar EthGetTransactionCount getTransactionCount () {EthGetTransactionCount resultaat = nieuw EthGetTransactionCount (); result = this.web3j.ethGetTransactionCount (DEFAULT_ADDRESS, DefaultBlockParameter.valueOf ("laatste")) .sendAsync () .get (); resultaat teruggeven; }

5.4. Accountsaldo

En tot slot, om het huidig ​​saldo van een adres of portemonnee:

openbare EthGetBalance getEthBalance () {EthGetBalance resultaat = nieuwe EthGetBalance (); this.web3j.ethGetBalance (DEFAULT_ADDRESS, DefaultBlockParameter.valueOf ("laatste")) .sendAsync () .get (); resultaat teruggeven; }

6. Werken met contracten in Web3j

Zodra we ons Solidity-contract met Truffle hebben samengesteld, kunnen we met ons samengestelde Binaire interfaces voor toepassingen (ABI) met behulp van het zelfstandige Web3j-opdrachtregelprogramma dat hier beschikbaar is of als een vrijstaande zip hier.

6.1. CLI Magic

We kunnen dan automatisch onze Java Smart Contract Wrappers genereren (in wezen een POJO die de slimme contract ABI blootlegt) met behulp van de volgende opdracht:

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

Het volgende commando uitvoeren in de root van het project:

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

gegenereerd onze Voorbeeld klasse:

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

6.2. Java POJO's

Nu we onze Smart Contract Wrapper hebben, we kunnen programmatisch een portemonnee maken en vervolgens ons contract op dat adres implementeren:

WalletUtils.generateNewWalletFile ("PASSWORD", nieuw bestand ("/ pad / naar / bestemming"), waar);
Inloggegevens credentials = WalletUtils.loadCredentials ("PASSWORD", "/ pad / naar / walletfile");

6.3. Zet een contract in

We kunnen ons contract als volgt inzetten:

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

En haal dan het adres op:

contractAddress = contract.getContractAddress ();

6.4. Transacties verzenden

Om een Transactie de ... gebruiken Functies van onze Contract we kunnen een Web3j Functie met een Lijst van invoerwaarden en een Lijst van outputparameters:

Lijst inputParams = nieuwe ArrayList (); Lijst outputParams = nieuwe ArrayList (); Functie function = nieuwe functie ("fuctionName", inputParams, outputParams); String encodedFunction = FunctionEncoder.encode (functie); 

We kunnen dan onze Transactie met de nodige gas- (gebruikt om het Transactie) en nonce-parameters:

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

Zie de officiële documenten voor een volledige lijst met slimme contractfunctionaliteiten.

7. Conclusie

Dat is het! We hebben een Java Spring MVC-app opgezet met Web3j - het is Blockchain-tijd!

Zoals altijd zijn de codevoorbeelden die in dit artikel worden gebruikt, beschikbaar op GitHub.

Java onderkant

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

>> BEKIJK DE CURSUS