Einführung in EthereumJ

Einführung in EthereumJ

1. Einführung

In diesem Artikel werfen wir einen Blick auf die BibliothekEthereumJ, mit der wir mithilfe von Java mit der BlockchainEthereuminteragieren können.

Lassen Sie uns zunächst kurz darauf eingehen, worum es bei dieser Technologie geht.

2. Über Ethereum

Ethereum ist eincryptocurrency, der eine verteilte Peer-to-Peer-Datenbank in Form eines programmierbarenblockchain, der Ethereum Virtual Machine (EVM), nutzt. Es wird synchronisiert und über unterschiedliche, aber verbundenenodes betrieben.

Ab 2017 synchronisierenNodes dieblockchain durch Konsens, erstellen Münzen durch Mining (proof of work), überprüfen Transaktionen, führensmart contracts aus, die inSolidity geschrieben sind, und führen sie aus das EVM.

blockchain wird inblocks unterteilt, dieaccount states (einschließlich Transaktionen zwischenaccounts) undproof of work enthalten.

3. DieEthereum Facade

Die Klasseorg.ethereum.facade.Ethereumabstrahiert und vereint viele Pakete von EthereumJ zu einer benutzerfreundlichen Oberfläche.

Es ist möglich, eine Verbindung zu einem Knoten herzustellen, um eine Synchronisierung mit dem gesamten Netzwerk durchzuführen. Sobald die Verbindung hergestellt ist, können wir mit der Blockchain arbeiten.

Das Erstellen eines Fassadenobjekts ist so einfach wie:

Ethereum ethereum = EthereumFactory.createEthereum();

4. Verbindung zum Ethereum-Netzwerk herstellen

Um eine Verbindung zum Netzwerk herzustellen, müssen wir zuerst eine Verbindung zu einem Knoten, i.e.eines Servers herstellen, auf dem der offizielle Client ausgeführt wird. Knoten werden durch die Klasseorg.ethereum.net.rlpx.Nodedargestellt.

Dasorg.ethereum.listener.EthereumListenerAdapter verarbeitet Blockchain-Ereignisse, die von unserem Client erkannt wurden, nachdem die Verbindung zu einem Knoten erfolgreich hergestellt wurde.

4.1. Verbindung zum Ethereum-Netzwerk herstellen

Stellen Sie eine Verbindung zu einem Knoten im Netzwerk her. Dies kann manuell erfolgen:

String ip = "http://localhost";
int port = 8345;
String nodeId = "a4de274d3a159e10c2c9a68c326511236381b84c9ec...";

ethereum.connect(ip, port, nodeId);

Die Verbindung zum Netzwerk kann auch automatisch über eine Bean hergestellt werden:

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

Wir können dann unsereEthBean in unsere Anwendungskonfiguration einfügen. Anschließend wird automatisch eine Verbindung zum Ethereum-Netzwerk hergestellt und der Download der Blockchain gestartet.

Tatsächlich wird die meiste Verbindungsverarbeitung bequem verpackt und abstrahiert, indem lediglich eineorg.ethereum.listener.EthereumListenerAdapter-Instanz zu unserer erstelltenorg.ethereum.facade.Ethereum-Instanz hinzugefügt wird, wie wir es in unserer obigenstart()-Methode getan haben:

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

4.2. Umgang mit der Blockchain mit einem Listener

Wir können auch dieEthereumListenerAdapter in Unterklassen unterteilen, um von unserem Client erkannte Blockchain-Ereignisse zu verarbeiten.

Um diesen Schritt auszuführen, müssen wir unseren untergeordneten Listener erstellen:

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

DieonBlock()-Methode wird bei jedem neuen empfangenen Block (ob alt oder aktuell) ausgelöst. EthereumJ repräsentiert und behandelt Blöcke mit der Klasseorg.ethereum.core.Block.

Die MethodeonSyncDone()wird ausgelöst, sobald die Synchronisierung abgeschlossen ist, und bringt unsere lokalen Ethereum-Daten auf den neuesten Stand.

5. Arbeiten mit der Blockchain

Jetzt, da wir uns mit dem Ethereum-Netzwerk verbinden und direkt mit der Blockchain arbeiten können, werden wir uns mit einigen grundlegenden, aber dennoch sehr wichtigen Vorgängen befassen, die wir häufig verwenden werden.

5.1. Senden einer Transaktion

Nachdem wir uns mit der Blockchain verbunden haben, können wir eine Transaktion senden. Das Einreichen einesTransaction ist relativ einfach, aber das Erstellen eines tatsächlichenTransaction ist ein langwieriges Thema für sich:

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

5.2. Zugriff auf dasBlockchain-Objekt

The[.pl-en]# getBlockchain#() Methode gibt einBlockchain Fassadenobjekt mit Gettern zurück, um aktuelle Netzwerkschwierigkeiten und bestimmteBlocks abzurufen.

Da wir unsereEthereumListener in Abschnitt 4.3 eingerichtet haben, können wir mit der obigen Methode auf die Blockchain zugreifen:

ethereum.getBlockchain();

5.3. Rückgabe einer Ethereum-Kontoadresse

Wir können auch ein EthereumAddress. zurückgeben

Um ein EthereumAccount –zu erhalten, müssen wir zuerst ein öffentliches und ein privates Schlüsselpaar in der Blockchain authentifizieren.

Erstellen wir einen neuen Schlüssel mit einem neuen zufälligen Schlüsselpaar:

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

Und erstellen wir einen Schlüssel aus einem bestimmten privaten Schlüssel:

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

Wir können dann unseren Schlüssel verwenden, um einAccount zu initialisieren. Durch Aufrufen von.init() setzen wir sowohl einECKey als auch das zugehörigeAddress für dasAccount-Objekt:

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

6. Andere Funktionen

Das Framework bietet zwei weitere wichtige Funktionen, die wir hier nicht behandeln, die jedoch erwähnenswert sind.

Erstens haben wir die Möglichkeit, Solidity Smart-Verträge zu kompilieren und auszuführen. Das Erstellen und anschließende Kompilieren und Ausführen von Verträgen in Solidity ist jedoch ein umfangreiches Thema.

Zweitens, obwohl das Framework begrenztes Mining mit einer CPU unterstützt, ist die Verwendung eines GPU-Miners der empfohlene Ansatz, da erstere nicht rentabel sind.

Weiterführende Themen zu Ethereum selbst finden Sie in den offiziellendocs.

7. Fazit

In diesem kurzen Tutorial haben wir gezeigt, wie Sie eine Verbindung zum Ethereum-Netzwerk herstellen und wie Sie mit der Blockchain arbeiten.

Wie immer ist der in diesem Beispiel verwendete Codeover on GitHub.