Introduzione a Ethereum J.

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

In questo articolo, diamo uno sguardo alla libreria EthereumJ che ci permette di interagire con la blockchain di Ethereum, utilizzando Java.

Per prima cosa, immergiamoci brevemente in cosa consiste questa tecnologia.

2. Informazioni su Ethereum

Ethereum è una criptovaluta che fa leva su un database distribuito peer-to-peer sotto forma di blockchain programmabile , la Ethereum Virtual Machine (EVM). È sincronizzato e gestito tramite nodi disparati ma connessi .

A partire dal 2017, i nodi sincronizzano la blockchain tramite il consenso, creano monete tramite il mining ( prova di lavoro ), verificano le transazioni, eseguono contratti intelligenti scritti in Solidity ed eseguono l'EVM.

La blockchain è divisa in blocchi che contengono gli stati dell'account (comprese le transazioni tra account ) e la prova del lavoro .

3. La facciata di Ethereum

La classe org.ethereum.facade.Ethereum riassume e unisce molti pacchetti di EthereumJ in un'unica interfaccia facile da usare.

È possibile connettersi a un nodo per sincronizzarsi con l'intera rete e, una volta connessi, possiamo lavorare con la blockchain.

Creare un oggetto di facciata è facile come:

Ethereum ethereum = EthereumFactory.createEthereum();

4. Connessione alla rete Ethereum

Per connettersi alla rete, dobbiamo prima connetterci a un nodo , cioè un server che esegue il client ufficiale. I nodi sono rappresentati dalla classe org.ethereum.net.rlpx.Node .

Gli org.ethereum.listener.EthereumListenerAdapter eventi maniglie blockchain rilevati dal nostro cliente dopo il collegamento ad un nodo è stata stabilita con successo.

4.1. Connessione alla rete Ethereum

Connettiamoci a un nodo sulla rete. Questo può essere fatto manualmente:

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

La connessione alla rete può anche essere eseguita automaticamente utilizzando 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(); } }

Possiamo quindi iniettare il nostro EthBean nella configurazione dell'applicazione. Quindi si connette automaticamente alla rete Ethereum e inizia a scaricare la blockchain.

In effetti, la maggior parte dell'elaborazione della connessione viene opportunamente racchiusa e astratta semplicemente aggiungendo un'istanza org.ethereum.listener.EthereumListenerAdapter alla nostra istanza org.ethereum.facade.Ethereum creata , come abbiamo fatto nel nostro metodo start () sopra:

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

4.2. Gestire la Blockchain utilizzando un listener

Possiamo anche sottoclassare l' EthereumListenerAdapter per gestire gli eventi blockchain rilevati dal nostro cliente.

Per completare questo passaggio, dovremo creare il nostro listener sottoclasse:

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; } } } 

Il metodo onBlock () viene attivato su ogni nuovo blocco ricevuto (vecchio o attuale). EthereumJ rappresenta e gestisce i blocchi utilizzando la classe org.ethereum.core.Block .

Il metodo onSyncDone () si attiva una volta completata la sincronizzazione, portando i nostri dati Ethereum locali aggiornati.

5. Lavorare con la Blockchain

Ora che possiamo connetterci alla rete Ethereum e lavorare direttamente con la blockchain, ci immergeremo in diverse operazioni di base ma comunque molto importanti che utilizzeremo spesso.

5.1. Invio di una transazione

Ora che ci siamo collegati alla blockchain possiamo inviare una transazione. Inviare una transazione è relativamente facile, ma la creazione di una transazione effettiva è un argomento lungo di per sé:

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

5.2. Accedi all'oggetto Blockchain

Il metodo getBlockchain () restituisce un oggetto facciata Blockchain con getter per il recupero delle attuali difficoltà di rete e blocchi specifici .

Poiché abbiamo impostato il nostro EthereumListener nella sezione 4.3, possiamo accedere alla blockchain utilizzando il metodo sopra:

ethereum.getBlockchain(); 

5.3. Restituzione dell'indirizzo di un account Ethereum

Possiamo anche restituire un indirizzo Ethereum .

Per ottenere un account Ethereum , dobbiamo prima autenticare una coppia di chiavi pubblica e privata sulla blockchain.

Creiamo una nuova chiave con una nuova coppia di chiavi casuale:

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

E creiamo una chiave da una data chiave privata:

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. Conclusione

In questo rapido tutorial, abbiamo mostrato come connettersi alla rete Ethereum e diversi metodi importanti per lavorare con la blockchain.

Come sempre il codice utilizzato in questo esempio può essere trovato 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