JavaScript-API-Bibliotheken

Damit eine Web-Anwendung mit der Ethereum-Blockchain interagieren kann (z. B. Auslesen von Blockchain-Daten und/oder Senden von Transaktionen an das Netzwerk), muss sie sich mit einem Ethereum-Node verbinden.

Zu diesem Zweck implementiert jeder Ethereum-Client die JSON-RPC-Spezifikation, damit es einen einheitlichen Satz von Methoden gibt, auf die sich Anwendungen verlassen können.

Wenn Sie sich über JavaScript mit einem Ethereum-Node verbinden möchten, ist das auch über VanillaJavaScript möglich. Doch es existieren noch weitere Lösungen in Programmbibliotheken in diesem Ökosystem, die das alles viel einfacher machen. Mit diesen Programmbibliotheken können Entwickler intuitive, einzeilige Methoden schreiben, um JSON-RPC-Anfragen („unter der Haube“) zu initialisieren, die mit Ethereum interagieren.

Bitte beachten Sie, dass seit der Zusammenführung zwei verbundene Teile von Ethereum-Software benötigt werden, um einen Knoten zu betreiben. Ein Ausführungsclient und ein Konsensclient. Bitte stellen Sie sicher, dass Ihr Knoten sowohl über einen Ausführungs- als auch einen Konsensclient verfügt. Wenn sich Ihr Knoten nicht auf einem lokalen Rechner (Ihr Knoten läuft z. B. auf einer AWS-Instanz) befindet, müssen Sie die IP-Adressen im Tutorial entsprechend anpassen. Für weitere Informationen schauen Sie sich unsere Seite zum Betreiben eines Knotens an.

Voraussetzungen

Sie müssen JavaScript verstehen. Zusätzlich ist es hilfreich, wenn Sie den Ethereum-Stack und Ethereum-Clients ebenfalls verstehen.

Warum eine Programmbibliothek verwenden?

Mit diesen Programmbibliotheken lässt sich die direkte Interaktion mit einem Ethereum-Node erheblich vereinfachen. Zudem bieten sie Dienstprogrammfunktionen (z. B. Umwandlung von ETH zu GWei), so dass Sie als Entwickler weniger Zeit damit verbringen, Probleme mit Ethereum-Clients zu lösen, und sich auf die einzigartigen Funktionen Ihrer Applikation konzentrieren können.

Eigenschaften von Programmbibliotheken

Verbindung mit Ethereum-Nodes

Sie können sich über einen Provider und diese Bibliotheken mit Ethereum verbinden und die Daten auslesen – über JSON-RPC, INFURA, Etherscan, Alchemy oder MetaMask.

Ether-Beispiel

1// Ein BrowserProvider umschließt einen standardmäßigen Web3-Provider, der
2// von MetaMask als window.ethereum in jede Seite injiziert wird
3const provider = new ethers.BrowserProvider(window.ethereum)
4
5// Das MetaMask-Plugin ermöglicht auch das Signieren von Transaktionen, um
6// Ether zu senden und bezahlte Statusänderungen innerhalb der Blockchain vorzunehmen.
7// Dazu benötigen wir den Unterzeichner vom Konto...
8const signer = provider.getSigner()
 Kopieren

Web3j-Beispiel

1var web3 = new Web3("http://localhost:8545")
2// or
3var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"))
4
5// Provider wechseln
6web3.setProvider("ws://localhost:8546")
7// or
8web3.setProvider(new Web3.providers.WebsocketProvider("ws://localhost:8546"))
9
10// Verwendung der IPC Provider in node.js
11var net = require("net")
12var web3 = new Web3("/Users/myuser/Library/Ethereum/geth.ipc", net) // mac os path
13// oder
14var web3 = new Web3(
15  new Web3.providers.IpcProvider("/Users/myuser/Library/Ethereum/geth.ipc", net)
16) // Mac OS Pfad
17// in Windows ist der Pfad: "\\\\.\\pipe\\geth.ipc"
18// in Linux ist der Pfad: "/users/myuser/.ethereum/geth.ipc"
Alles anzeigen
 Kopieren

Sobald die Einrichtung abgeschlossen ist, können Sie folgende Abfragen für die Blockchain vornehmen:

Blocknummern
Ressourcen-Schätzung
Smart-Contract-Ereignisse
Netzwerk-ID
und weitere...

Wallet-Funktionalität

Diese Programmbibliotheken bieten Ihnen die Funktionalität, um Wallets zu erstellen, Schlüssel zu verwalten und Transaktionen zu signieren.

Hier ist ein Beispiel von Ethers

1// Erstelle eine Wallet-Instanz aus einem Mnemonik...
2mnemonic =
3  "announce room limb pattern dry unit scale effort smooth jazz weasel alcohol"
4walletMnemonic = Wallet.fromPhrase(mnemonic)
5
6// ...oder aus einem privaten Schlüssel
7walletPrivateKey = new Wallet(walletMnemonic.privateKey)
8
9walletMnemonic.address === walletPrivateKey.address
10// true
11
12// Die Adresse als Promise gemäß der Signer API
13walletMnemonic.getAddress()
14// { Promise: '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1' }
15
16// Die Wallet-Adresse ist auch synchron verfügbar
17walletMnemonic.address
18// '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1'
19
20// Die internen kryptographischen Komponenten
21walletMnemonic.privateKey
22// '0x1da6847600b0ee25e9ad9a52abbd786dd2502fa4005dd5af9310b7cc7a3b25db'
23walletMnemonic.publicKey
24// '0x04b9e72dfd423bcf95b3801ac93f4392be5ff22143f9980eb78b3a860c4843bfd04829ae61cdba4b3b1978ac5fc64f5cc2f4350e35a108a9c9a92a81200a60cd64'
25
26// Die Wallet-Mnemonic
27walletMnemonic.mnemonic
28// {
29//   locale: 'en',
30//   path: 'm/44\'/60\'/0\'/0/0',
31//   phrase: 'announce room limb pattern dry unit scale effort smooth jazz weasel alcohol'
32// }
33
34// Hinweis: Ein Wallet, das mit einem privaten Schlüssel erstellt wurde, hat keine
35//       Mnemonic (die Ableitung verhindert dies)
36walletPrivateKey.mnemonic
37// null
38
39// Signieren einer Nachricht
40walletMnemonic.signMessage("Hello World")
41// { Promise: '0x14280e5885a19f60e536de50097e96e3738c7acae4e9e62d67272d794b8127d31c03d9cd59781d4ee31fb4e1b893bd9b020ec67dfa65cfb51e2bdadbb1de26d91c' }
42
43tx = {
44  to: "0x8ba1f109551bD432803012645Ac136ddd64DBA72",
45  value: utils.parseEther("1.0"),
46}
47
48// Signieren einer Transaktion
49walletMnemonic.signTransaction(tx)
50// { Promise: '0xf865808080948ba1f109551bd432803012645ac136ddd64dba72880de0b6b3a7640000801ca0918e294306d177ab7bd664f5e141436563854ebe0a3e523b9690b4922bbb52b8a01181612cec9c431c4257a79b8c9f0c980a2c49bb5a0e6ac52949163eeb565dfc' }
51
52// Die Connect-Methode gibt eine neue Instanz des
53// Wallets zurück, die mit einem Provider verbunden ist
54wallet = walletMnemonic.connect(provider)
55
56// Abfragen des Netzwerks
57wallet.getBalance()
58// { Promise: { BigNumber: "42" } }
59wallet.getTransactionCount()
60// { Promise: 0 }
61
62// Ether senden
63wallet.sendTransaction(tx)
Alles anzeigen
 Kopieren

Lesen Sie die ganzen Dokumente(opens in a new tab)

Einmal eingerichtet, können Sie:

Konten erstellen
Transaktionen senden
Transaktionen signieren
und weitere...

Mit den Funktionen von Smart Contracts interagieren

JavaScript-Client-Bibliotheken ermöglichen Ihrer Anwendung, Smart Contract-Funktionen aufzurufen. Dafür lesen sie die Application Binary Interface (ABI) eines kompilierten Vertrags.

Die ABI erklärt im Wesentlichen die Funktionen des Vertrags im JSON-Format und erlaubt die Verwendung wie ein normales JavaScript-Objekt.

Also folgender Solidity-Vertrag:

1contract Test {
2    uint a;
3    address d = 0x12345678901234567890123456789012;
4
5    function Test(uint testInt)  { a = testInt;}
6
7    event Event(uint indexed b, bytes32 c);
8
9    event Event2(uint indexed b, bytes32 c);
10
11    function foo(uint b, bytes32 c) returns(address) {
12        Event(b, c);
13        return d;
14    }
15}
Alles anzeigen
 Kopieren

Würde in nachfolgendem JSON resultieren:

1[{
2    "type":"constructor",
3    "payable":false,
4    "stateMutability":"nonpayable"
5    "inputs":[{"name":"testInt","type":"uint256"}],
6  },{
7    "type":"function",
8    "name":"foo",
9    "constant":false,
10    "payable":false,
11    "stateMutability":"nonpayable",
12    "inputs":[{"name":"b","type":"uint256"}, {"name":"c","type":"bytes32"}],
13    "outputs":[{"name":"","type":"address"}]
14  },{
15    "type":"event",
16    "name":"Event",
17    "inputs":[{"indexed":true,"name":"b","type":"uint256"}, {"indexed":false,"name":"c","type":"bytes32"}],
18    "anonymous":false
19  },{
20    "type":"event",
21    "name":"Event2",
22    "inputs":[{"indexed":true,"name":"b","type":"uint256"},{"indexed":false,"name":"c","type":"bytes32"}],
23    "anonymous":false
24}]
Alles anzeigen
 Kopieren

Dies bedeutet Sie können:

Sie können eine Transaktion an den Smart Contract senden und seine Methode ausführen.
Sie können eine Ressourcen-Schätzung aufrufen, für die eine Ausführungsmethode in der EVM bei Ausführung erforderlich wird.
Sie können einen Vertrag bereitstellen.
Und mehr...

Dienstprogrammfunktionen

Die Dienstprogrammfunktionen stellen Ihnen praktische Verknüpfungen bereit, die das Entwickeln mit Ethereum erleichtern.

ETH-Werte sind standardmäßig in Wei. 1 ETH = 1.000.000.000.000.000.000.000.000 WEI – sprich, Sie haben es mit vielen Zahlen zu tun. web3.utils.toWei konvertiert für Sie Ether in Wei.

Das sieht in Ether wie folgt aus:

1// Holen Sie sich das Guthaben eines Kontos (über Adresse oder ENS-Name)
2Guthaben = provider.getBalance("Ethers. th")
3// // { BigNumber: "2337132817842795605" }
4
5// Oft müssen Sie die Ausgabe für den Benutzer formatieren,
6// dieser bevorzugt die Werte lieber in Ether (anstatt Wei)
7ethers.utils.formatEther(balance)
8// '2.337132817842795605'
 Kopieren

Verfügbare Programmbibliotheken

Web3.js – Ethereum-JavaScript-API

Ethers.js – Eine vollständige Ethereum-Wallet-Implementierung und Dienstprogramme in JavaScript und TypeScript

The Graph – Ein Protokoll für die Indizierung von Ethereum- und IPFS-Daten und Abfragen mit GraphQL

light.js – Eine reaktive High-Level-JS-Bibliothek, die für leichte Clients optimiert wurde.

GitHub(opens in a new tab)

Web3-Wrapper – Eine Typescript-Alternative zu Web3.js

Alchemyweb3 – Wrapper um Web3.js mit automatischen Wiederholungen und erweiterten APIs

Alchemy NFT API – API für den Abruf von NFT-Daten, einschließlich Eigentumsrechten, Metadatenattributen und mehr.

Viem - Schnittstelle in TypeScript für Ethereum.

Weiterführende Informationen

Sie kennen Community-Resourcen die Ihnen geholfen haben? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!

Web3js einrichten, um die Ethereum-Blockchain in JavaScript zu nutzen – Leitfaden für die Einrichtung von web3.js in Ihrem Projekt.
Aufruf eines intelligenten Vertrags mit JavaScript – Mit dem DAI-Token können Sie die Funktion „Verträge aufrufen“ mit JavaScript verwenden.
Transaktionen über web3 und Alchemy senden – Schritt-für-Schritt-Komplettlösung zum Senden von Transaktionen aus dem Backend.