JavaScript-API-Bibliotheken

Damit eine Web-App mit der Ethereum-Blockchain interagieren kann (d. h. Blockchain-Daten lesen und/oder Transaktionen an das Netzwerk senden), muss sie sich mit einem Ethereum-Knoten verbinden.

Zu diesem Zweck implementiert jeder Ethereum-Client die JSON-RPC-Spezifikation, sodass es eine einheitliche Reihe von Methoden gibt, auf die sich Anwendungen verlassen können.

Wenn Sie JavaScript verwenden möchten, um sich mit einem Ethereum-Knoten zu verbinden, ist es möglich, reines (Vanilla) JavaScript zu verwenden, aber es gibt im Ökosystem mehrere praktische Bibliotheken, die dies viel einfacher machen. Mit diesen Bibliotheken können Entwickler intuitive, einzeilige Methoden schreiben, um (intern) JSON-RPC-Anfragen zu initialisieren, die mit Ethereum interagieren.

Bitte beachten Sie, dass seit dem Merge zwei verbundene Teile von Ethereum-Software – ein Ausführungsclient und ein Konsens-Client – erforderlich sind, um einen Knoten auszuführen. Bitte stellen Sie sicher, dass Ihr Knoten sowohl einen Ausführungs- als auch einen Konsens-Client enthält. Wenn sich Ihr Knoten nicht auf Ihrem lokalen Computer befindet (z. B. wenn Ihr Knoten auf einer AWS-Instanz läuft), aktualisieren Sie die IP-Adressen im Tutorial entsprechend. Weitere Informationen finden Sie auf unserer Seite zum Ausführen eines Knotens.

Voraussetzungen

Neben dem Verständnis von JavaScript könnte es hilfreich sein, den Ethereum-Stack und Ethereum-Clients zu verstehen.

Warum eine Bibliothek verwenden?

Diese Bibliotheken abstrahieren einen Großteil der Komplexität der direkten Interaktion mit einem Ethereum-Knoten. Sie bieten auch Hilfsfunktionen (z. B. die Umwandlung von ETH in Gwei), sodass Sie als Entwickler weniger Zeit mit den Feinheiten von Ethereum-Clients verbringen und sich mehr auf die einzigartige Funktionalität Ihrer Anwendung konzentrieren können.

Funktionen der Bibliothek

Mit Ethereum-Knoten verbinden

Mithilfe von Providern ermöglichen Ihnen diese Bibliotheken, sich mit Ethereum zu verbinden und dessen Daten zu lesen, sei es über JSON-RPC, Infura, Etherscan, Alchemy oder MetaMask.

Warnung: Web3.js wurde am 4. März 2025 archiviert. Lesen Sie die Ankündigung (opens in a new tab). Erwägen Sie für neue Projekte die Verwendung alternativer Bibliotheken wie Ethers.js (opens in a new tab) oder Viem (opens in a new tab).

Ethers-Beispiel

// Ein BrowserProvider umschließt einen Standard-Web3-Provider, also
// das, was MetaMask als window.ethereum in jede Seite einfügt
const provider = new ethers.BrowserProvider(window.ethereum)

// Das MetaMask-Plugin ermöglicht auch das Signieren von Transaktionen, um
// Ether zu senden und für Zustandsänderungen innerhalb der Blockchain zu bezahlen.
// Dafür benötigen wir den Account-Signer...
const signer = provider.getSigner()

Web3.js-Beispiel

var web3 = new Web3("http://localhost:8545")
// or
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"))

// Provider wechseln
web3.setProvider("ws://localhost:8546")
// or
web3.setProvider(new Web3.providers.WebsocketProvider("ws://localhost:8546"))

// Verwendung des IPC-Providers in node.js
var net = require("net")
var web3 = new Web3("/Users/myuser/Library/Ethereum/geth.ipc", net) // macOS-Pfad
// or
var web3 = new Web3(
  new Web3.providers.IpcProvider("/Users/myuser/Library/Ethereum/geth.ipc", net)
) // macOS-Pfad
// unter Windows ist der Pfad: "\\\\.\\pipe\\geth.ipc"
// unter Linux ist der Pfad: "/users/myuser/.ethereum/geth.ipc"

Sobald dies eingerichtet ist, können Sie die Blockchain abfragen nach:

Blocknummern
Gas-Schätzungen
Smart-Contract-Ereignissen
Netzwerk-ID
und mehr ...

Wallet-Funktionalität

Diese Bibliotheken bieten Ihnen Funktionen zum Erstellen von Wallets, Verwalten von Schlüsseln und Signieren von Transaktionen.

Hier ist ein Beispiel von Ethers

// Erstellen einer Wallet-Instanz aus einem Mnemonic...
mnemonic =
  "announce room limb pattern dry unit scale effort smooth jazz weasel alcohol"
walletMnemonic = Wallet.fromPhrase(mnemonic)

// ...oder aus einem privaten Schlüssel
walletPrivateKey = new Wallet(walletMnemonic.privateKey)

walletMnemonic.address === walletPrivateKey.address
// true

// Die Adresse als Promise gemäß der Signer-API
walletMnemonic.getAddress()
// { Promise: '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1' }

// Eine Wallet-Adresse ist auch synchron verfügbar
walletMnemonic.address
// '0x71CB05EE1b1F506fF321Da3dac38f25c0c9ce6E1'

// Die internen kryptografischen Komponenten
walletMnemonic.privateKey
// '0x1da6847600b0ee25e9ad9a52abbd786dd2502fa4005dd5af9310b7cc7a3b25db'
walletMnemonic.publicKey
// '0x04b9e72dfd423bcf95b3801ac93f4392be5ff22143f9980eb78b3a860c4843bfd04829ae61cdba4b3b1978ac5fc64f5cc2f4350e35a108a9c9a92a81200a60cd64'

// Das Wallet-Mnemonic
walletMnemonic.mnemonic
// {
//   locale: 'en',
//   path: 'm/44\'/60\'/0\'/0/0',
//   phrase: 'announce room limb pattern dry unit scale effort smooth jazz weasel alcohol'
// }

// Hinweis: Eine mit einem privaten Schlüssel erstellte Wallet hat
//       kein Mnemonic (die Ableitung verhindert dies)
walletPrivateKey.mnemonic
// null

// Signieren einer Nachricht
walletMnemonic.signMessage("Hello World")
// { Promise: '0x14280e5885a19f60e536de50097e96e3738c7acae4e9e62d67272d794b8127d31c03d9cd59781d4ee31fb4e1b893bd9b020ec67dfa65cfb51e2bdadbb1de26d91c' }

tx = {
  to: "0x8ba1f109551bD432803012645Ac136ddd64DBA72",
  value: utils.parseEther("1.0"),
}

// Signieren einer Transaktion
walletMnemonic.signTransaction(tx)
// { Promise: '0xf865808080948ba1f109551bd432803012645ac136ddd64dba72880de0b6b3a7640000801ca0918e294306d177ab7bd664f5e141436563854ebe0a3e523b9690b4922bbb52b8a01181612cec9c431c4257a79b8c9f0c980a2c49bb5a0e6ac52949163eeb565dfc' }

// Die connect-Methode gibt eine neue Instanz der
// mit einem Provider verbundenen Wallet zurück
wallet = walletMnemonic.connect(provider)

// Abfragen des Netzwerks
wallet.getBalance()
// { Promise: { BigNumber: "42" } }
wallet.getTransactionCount()
// { Promise: 0 }

// Senden von Ether
wallet.sendTransaction(tx)

Lesen Sie die vollständige Dokumentation (opens in a new tab)

Sobald dies eingerichtet ist, können Sie:

Konten erstellen
Transaktionen senden
Transaktionen signieren
und mehr ...

Mit Smart-Contract-Funktionen interagieren

JavaScript-Client-Bibliotheken ermöglichen es Ihrer Anwendung, Smart-Contract-Funktionen aufzurufen, indem sie das Application Binary Interface (ABI) eines kompilierten Vertrags lesen.

Das ABI erklärt im Wesentlichen die Funktionen des Vertrags in einem JSON-Format und ermöglicht es Ihnen, ihn wie ein normales JavaScript-Objekt zu verwenden.

Der folgende Solidity-Vertrag:

contract Test {
    uint a;
    address d = 0x12345678901234567890123456789012;

    constructor(uint testInt)  { a = testInt;}

    event Event(uint indexed b, bytes32 c);

    event Event2(uint indexed b, bytes32 c);

    function foo(uint b, bytes32 c) returns(address) {
        Event(b, c);
        return d;
    }
}

Würde zu folgendem JSON führen:

[{
    "type":"constructor",
    "payable":false,
    "stateMutability":"nonpayable"
    "inputs":[{"name":"testInt","type":"uint256"}],
  },{
    "type":"function",
    "name":"foo",
    "constant":false,
    "payable":false,
    "stateMutability":"nonpayable",
    "inputs":[{"name":"b","type":"uint256"}, {"name":"c","type":"bytes32"}],
    "outputs":[{"name":"","type":"address"}]
  },{
    "type":"event",
    "name":"Event",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"}, {"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
  },{
    "type":"event",
    "name":"Event2",
    "inputs":[{"indexed":true,"name":"b","type":"uint256"},{"indexed":false,"name":"c","type":"bytes32"}],
    "anonymous":false
}]

Das bedeutet, Sie können:

Eine Transaktion an den Smart Contract senden und seine Methode ausführen
Einen Aufruf tätigen, um das Gas zu schätzen, das eine Methodenausführung bei der Ausführung in der EVM benötigt
Einen Vertrag bereitstellen
Und mehr ...

Hilfsfunktionen

Hilfsfunktionen bieten Ihnen praktische Abkürzungen, die das Entwickeln mit Ethereum etwas einfacher machen.

ETH-Werte sind standardmäßig in Wei angegeben. 1 ETH = 1.000.000.000.000.000.000 WEI – das bedeutet, Sie haben es mit vielen Zahlen zu tun! web3.utils.toWei wandelt Ether für Sie in Wei um.

Und in Ethers sieht das so aus:

// Abrufen des Guthabens eines Kontos (über Adresse oder ENS-Namen)
balance = await provider.getBalance("ethers.eth")
// { BigNumber: "2337132817842795605" }

// Oft müssen Sie die Ausgabe für den Benutzer formatieren,
// der Werte lieber in Ether (anstatt in Wei) sieht
ethers.utils.formatEther(balance)
// '2.337132817842795605'

Verfügbare Bibliotheken

Web3.js – Ethereum-JavaScript-API.

Ethers.js – Vollständige Ethereum-Wallet-Implementierung und Hilfsprogramme in JavaScript und TypeScript.

The Graph – Ein Protokoll zur Indizierung von Ethereum- und IPFS-Daten und deren Abfrage mittels GraphQL.

Alchemy SDK – Wrapper um Ethers.js mit erweiterten APIs.

Viem – TypeScript-Schnittstelle für Ethereum.

Codex – Angereicherte Echtzeit-Blockchain-Daten-API über Dutzende von Chains hinweg.

Drift – TypeScript-Meta-Bibliothek mit integriertem Caching, Hooks und Test-Mocks.

Weiterführende Literatur

Kennen Sie eine Community-Ressource, die Ihnen geholfen hat? Bearbeiten Sie diese Seite und fügen Sie sie hinzu!

Web3.js einrichten, um die Ethereum-Blockchain in JavaScript zu nutzen – Anleitung zur Einrichtung von Web3.js in Ihrem Projekt.
Einen Smart Contract aus JavaScript aufrufen – Sehen Sie am Beispiel des DAI-Tokens, wie man Vertragsfunktionen mit JavaScript aufruft.
Transaktionen mit Web3 und Alchemy senden – Schritt-für-Schritt-Anleitung zum Senden von Transaktionen aus dem Backend.

Tutorials: JavaScript-APIs & WebSockets auf Ethereum

WebSockets verwenden – Wie man WebSockets mit Alchemy verwendet, um Ethereum-Ereignisse zu abonnieren und JSON-RPC-Anfragen in Echtzeit zu stellen.