Introduction à EthereumJ

Haut Java

Je viens d'annoncer le nouveau cours Learn Spring , axé sur les principes de base de Spring 5 et Spring Boot 2:

>> VOIR LE COURS

1. Introduction

Dans cet article, nous examinons la bibliothèque EthereumJ qui nous permet d'interagir avec la blockchain Ethereum, en utilisant Java.

Tout d'abord, plongeons brièvement dans ce qu'est cette technologie.

2. À propos d'Ethereum

Ethereum est une crypto - monnaie exploitant une base de données distribuée, peer-to-peer, sous la forme d'une blockchain programmable , la machine virtuelle Ethereum (EVM). Il est synchronisé et exploité via des nœuds disparates mais connectés .

À partir de 2017, les nœuds synchronisent la blockchain par consensus, créent des pièces grâce au minage ( preuve de travail ), vérifient les transactions, exécutent des contrats intelligents écrits dans Solidity et exécutent l'EVM.

La blockchain est divisée en blocs qui contiennent les états des comptes (y compris les transactions entre les comptes ) et la preuve de travail .

3. La façade Ethereum

La classe org.ethereum.facade.Ethereum résume et unit de nombreux packages d'EthereumJ en une seule interface facile à utiliser.

Il est possible de se connecter à un nœud pour se synchroniser avec le réseau global et, une fois connecté, nous pouvons travailler avec la blockchain.

Créer un objet de façade est aussi simple que:

Ethereum ethereum = EthereumFactory.createEthereum();

4. Connexion au réseau Ethereum

Pour se connecter au réseau, il faut d'abord se connecter à un nœud , c'est à dire un serveur exécutant le client officiel. Les nœuds sont représentés par la classe org.ethereum.net.rlpx.Node .

Le org.ethereum.listener.EthereumListenerAdapter gère les événements blockchain détectés par notre client après que la connexion à un nœud a été établie avec succès.

4.1. Connexion au réseau Ethereum

Connectons-nous à un nœud du réseau. Cela peut être fait manuellement:

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

La connexion au réseau peut également se faire automatiquement à l'aide d'un bean:

public class EthBean { private Ethereum ethereum; public void start() { ethereum = EthereumFactory.createEthereum(); ethereum.addListener(new EthListener(ethereum)); } public Block getBestBlock() { return ethereum.getBlockchain().getBestBlock(); } public BigInteger getTotalDifficulty() { return ethereum.getBlockchain().getTotalDifficulty(); } }

Nous pouvons ensuite injecter notre EthBean dans la configuration de notre application. Ensuite, il se connecte automatiquement au réseau Ethereum et commence à télécharger la blockchain.

En fait, le plus grand nombre de traitements de connexion est commodément encapsulé et abstrait en ajoutant simplement une instance org.ethereum.listener.EthereumListenerAdapter à notre instance org.ethereum.facade.Ethereum créée , comme nous l'avons fait dans notre méthode start () ci-dessus:

EthBean eBean = new EthBean(); Executors.newSingleThreadExecutor().submit(eBean::start); 

4.2. Gestion de la blockchain à l'aide d'un auditeur

Nous pouvons également sous- classer EthereumListenerAdapter pour gérer les événements blockchain détectés par notre client.

Pour accomplir cette étape, nous devrons créer notre auditeur sous-classé:

public class EthListener extends EthereumListenerAdapter { 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 difficulty: " + block.getDifficultyBI().toString()); out("Block transactions: " + block.getTransactionsList().toString()); out("Best block (last block): " + ethereum .getBlockchain() .getBestBlock().toString()); out("Total difficulty: " + ethereum .getBlockchain() .getTotalDifficulty().toString()); } } @Override public void onSyncDone(SyncState state) { out("onSyncDone " + state); if (!syncDone) { out(" ** SYNC DONE ** "); syncDone = true; } } } 

La méthode onBlock () est déclenchée sur tout nouveau bloc reçu (qu'il soit ancien ou actuel). EthereumJ représente et gère les blocs à l'aide de la classe org.ethereum.core.Block .

La méthode onSyncDone () se déclenche une fois la synchronisation terminée, mettant à jour nos données Ethereum locales.

5. Travailler avec la blockchain

Maintenant que nous pouvons nous connecter au réseau Ethereum et travailler directement avec la blockchain, nous allons plonger dans plusieurs opérations basiques mais néanmoins très importantes que nous utiliserons souvent.

5.1. Soumettre une transaction

Maintenant que nous nous sommes connectés à la blockchain, nous pouvons soumettre une transaction. Soumettre une transaction est relativement facile, mais la création d'une transaction réelle est un long sujet en soi:

ethereum.submitTransaction(new Transaction(new byte[]));

5.2. Accéder à l' objet Blockchain

La méthode getBlockchain () retourne un objet de façade Blockchain avec des getters pour récupérer les difficultés actuelles du réseau et des blocs spécifiques .

Depuis que nous avons configuré notre EthereumListener dans la section 4.3, nous pouvons accéder à la blockchain en utilisant la méthode ci-dessus:

ethereum.getBlockchain(); 

5.3. Renvoyer une adresse de compte Ethereum

Nous pouvons également renvoyer une adresse Ethereum .

Pour obtenir un compte Ethereum , nous devons d'abord authentifier une paire de clés publique et privée sur la blockchain.

Créons une nouvelle clé avec une nouvelle paire de clés aléatoire:

org.ethereum.crypto.ECKey key = new ECKey(); 

Et créons une clé à partir d'une clé privée donnée:

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

We can then use our key to initialize an Account. By calling .init() we set both an ECKey and the associated Address on the Account object:

org.ethereum.core.Account account = new Account(); account.init(key);

6. Other Functionality

There are two other major functionalities provided for by the framework that we won't cover here but that are worth mentioning.

First, we have the ability to compile and execute Solidity smart contracts. However, creating contracts in Solidity, and subsequently compiling and executing them is an extensive topic in its own right.

Second, although the framework supports limited mining using a CPU, using a GPU miner is the recommended approach given the lack of profitability of the former.

More advanced topics regarding Ethereum itself can be found in the official docs.

7. Conclusion

Dans ce tutoriel rapide, nous avons montré comment se connecter au réseau Ethereum et plusieurs méthodes importantes pour travailler avec la blockchain.

Comme toujours, le code utilisé dans cet exemple se trouve à l'adresse over sur GitHub.

Fond Java

Je viens d'annoncer le nouveau cours Learn Spring , axé sur les principes de base de Spring 5 et Spring Boot 2:

>> VOIR LE COURS