streamalism.org

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

1. Inleiding

In dit artikel bekijken we de EthereumJ-bibliotheek waarmee we via Java kunnen communiceren met de Ethereum-blockchain.

Laten we eerst eens kort ingaan op wat deze technologie inhoudt.

2. Over Ethereum

Ethereum is een cryptocurrency gebruikmakend van een gedistribueerde, peer-to-peer database in de vorm van een programmeerbaar blockchain, de Ethereum Virtual Machine (EVM). Het is gesynchroniseerd en bediend via ongelijk maar verbonden knooppunten.

Vanaf 2017 Knooppunten synchroniseer de blockchain door consensus, munten creëren door mijnbouw (bewijs van werk), transacties verifiëren, uitvoeren slimme contracten geschreven in Solidity, en voer de EVM uit.

De blockchain is verdeeld in blokken die bevatten account staten (inclusief transacties tussen rekeningen) en bewijs van werk.

3. Het Ethereum Facade

De org.ethereum.facade.Ethereum class abstracts en verenigt vele pakketten EthereumJ in één eenvoudig te gebruiken interface.

Het is mogelijk om verbinding te maken met een knooppunt om te synchroniseren met het algehele netwerk en, eenmaal verbonden, kunnen we met de blockchain werken.

Een gevelobject maken is zo eenvoudig als:

Ethereum ethereum = EthereumFactory.createEthereum ();

4. Verbinding maken met het Ethereum-netwerk

Om verbinding te maken met het netwerk, moeten we eerst verbinding maken met een knooppunt, d.w.z. een server waarop de officiële client draait. Knooppunten worden vertegenwoordigd door de org.ethereum.net.rlpx.Node klasse.

De org.ethereum.listener.EthereumListenerAdapter verwerkt blockchain-gebeurtenissen die door onze klant zijn gedetecteerd nadat de verbinding met een knooppunt is gelukt.

4.1. Verbinding maken met het Ethereum-netwerk

Laten we verbinding maken met een knooppunt op het netwerk. Dit kan handmatig worden gedaan:

String ip = "// localhost"; int poort = 8345; String nodeId = "a4de274d3a159e10c2c9a68c326511236381b84c9ec ..."; ethereum.connect (ip, poort, nodeId);

Verbinding maken met het netwerk kan ook automatisch worden gedaan met behulp van een boon:

openbare klasse EthBean {privé Ethereum ethereum; openbare leegte start () {ethereum = EthereumFactory.createEthereum (); ethereum.addListener (nieuwe EthListener (ethereum)); } openbaar blok getBestBlock () {retourneer ethereum.getBlockchain (). getBestBlock (); } openbare BigInteger getTotalDifficulty () {retourneer ethereum.getBlockchain (). getTotalDifficulty (); }}

We kunnen dan onze EthBean in onze applicatieconfiguratie. Vervolgens maakt het automatisch verbinding met het Ethereum-netwerk en begint het met het downloaden van de blockchain.

In feite wordt de meeste verbindingsverwerking handig verpakt en geabstraheerd door alleen een org.ethereum.listener.EthereumListenerAdapter instantie naar onze gemaakt org.ethereum.facade.Ethereum bijvoorbeeld, zoals we deden in onze begin() methode hierboven:

EthBean eBean = nieuwe EthBean (); Executors.newSingleThreadExecutor (). Submit (eBean :: start); 

4.2. Omgaan met de blockchain met behulp van een luisteraar

We kunnen ook de EthereumListenerAdapter om blockchain-gebeurtenissen te verwerken die door onze klant zijn gedetecteerd.

Om deze stap te volbrengen, moeten we onze luisteraar in subclassificatie maken:

openbare klasse EthListener breidt EthereumListenerAdapter uit {private void out (String t) {l.info (t); } // ... @Override public void onBlock (Block block, List receipts) {if (syncDone) {out ("Net hash rate:" + calcNetHashRate (block)); out ("Block moeilijkheidsgraad:" + block.getDifficultyBI (). toString ()); out ("Blokkeer transacties:" + block.getTransactionsList (). toString ()); out ("Beste blok (laatste blok):" + ethereum .getBlockchain () .getBestBlock (). toString ()); out ("Totale moeilijkheidsgraad:" + ethereum .getBlockchain () .getTotalDifficulty (). toString ()); }} @Override public void onSyncDone (SyncState state) {out ("onSyncDone" + state); if (! syncDone) {out ("** SYNC DONE **"); syncDone = waar; }}} 

De onBlock () methode wordt geactiveerd op elk nieuw ontvangen blok (oud of huidig). EthereumJ vertegenwoordigt en verwerkt blokken met behulp van de org.ethereum.core.Block klasse.

De onSyncDone () methode wordt geactiveerd zodra de synchronisatie is voltooid, waardoor onze lokale Ethereum-gegevens up-to-date zijn.

5. Werken met de blockchain

Nu we verbinding kunnen maken met het Ethereum-netwerk en rechtstreeks met de blockchain kunnen werken, zullen we ingaan op verschillende eenvoudige maar niettemin zeer belangrijke bewerkingen die we vaak zullen gebruiken.

5.1. Een transactie indienen

Nu we verbinding hebben gemaakt met de blockchain, kunnen we een transactie indienen. Een Transactie is relatief eenvoudig, maar het maken van een actual Transactie is op zichzelf een langdurig onderwerp:

ethereum.submitTransaction (nieuwe transactie (nieuwe byte []));

5.2. Toegang krijgen tot Blockchain Voorwerp

De getBlockchain () methode retourneert een Blockchain gevelobject met getters voor het ophalen van actuele netwerkproblemen en specifiek Blokken.

Sinds we onze EthereumListener in sectie 4.3 kunnen we toegang krijgen tot de blockchain met behulp van de bovenstaande methode:

ethereum.getBlockchain (); 

5.3. Een Ethereum-accountadres retourneren

We kunnen ook een Ethereum retourneren Adres.

Om een ​​Ethereum te krijgen Account - we moeten eerst een openbaar en privé sleutelpaar op de blockchain verifiëren.

Laten we een nieuwe sleutel maken met een nieuw willekeurig sleutelpaar:

org.ethereum.crypto.ECKey sleutel = nieuwe ECKey (); 

En laten we een sleutel maken van een bepaalde privésleutel:

org.ethereum.crypto.ECKey sleutel = ECKey.fromPivate (privKey);

We kunnen dan onze sleutel gebruiken om een Account. Door te bellen .in het() we hebben beide een ECKey en de bijbehorende Adres op de Account voorwerp:

org.ethereum.core.Account account = nieuw account (); account.init (sleutel);

6. Andere functionaliteit

Er zijn twee andere belangrijke functionaliteiten die door het raamwerk worden geboden die we hier niet zullen behandelen, maar die het vermelden waard zijn.

Ten eerste hebben we de mogelijkheid om slimme Solidity-contracten samen te stellen en uit te voeren. Het aanmaken van contracten in Solidity, en het vervolgens opstellen en uitvoeren ervan is echter een veelomvattend onderwerp op zich.

Ten tweede, hoewel het framework beperkte mijnbouw ondersteunt met behulp van een CPU, is het gebruik van een GPU-mijnwerker de aanbevolen aanpak, gezien het gebrek aan winstgevendheid van de eerste.

Meer geavanceerde onderwerpen over Ethereum zelf zijn te vinden in de officiële documenten.

7. Conclusie

In deze korte tutorial hebben we laten zien hoe je verbinding kunt maken met het Ethereum-netwerk en verschillende belangrijke methoden om met de blockchain te werken.

Zoals altijd is de code die in dit voorbeeld wordt gebruikt, te vinden op GitHub.

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