Senden von Transaktionen mit Web3

Transaktionen

web3.js

Alchemy

Anfänger

Elan Halpern

Alchemy docs

4. November 2020

10 Minuten Lesezeit

Seite bearbeiten

Dies ist ein anfängerfreundlicher Leitfaden zum Senden von Ethereum-Transaktionen mit Web3. Es gibt drei Hauptschritte, um eine Transaktion an die Ethereum-Blockchain zu senden: Erstellen, Signieren und Übertragen. Wir werden alle drei durchgehen und hoffentlich alle deine Fragen beantworten! In diesem Tutorial verwenden wir Alchemy (opens in a new tab), um unsere Transaktionen an die Ethereum-Chain zu senden. Du kannst hier ein kostenloses Alchemy-Konto erstellen (opens in a new tab).

HINWEIS: Dieser Leitfaden ist für das Signieren deiner Transaktionen im Backend deiner App gedacht. Wenn du das Signieren deiner Transaktionen im Frontend integrieren möchtest, sieh dir die Integration von Web3 mit einem Browser-Provider (opens in a new tab) an.

Die Grundlagen

Wie die meisten Blockchain-Entwickler zu Beginn hast du vielleicht recherchiert, wie man eine Transaktion sendet (etwas, das eigentlich ziemlich einfach sein sollte), und bist auf eine Fülle von Leitfäden gestoßen, die alle etwas anderes sagen und dich ein wenig überfordert und verwirrt zurücklassen. Wenn es dir so geht, mach dir keine Sorgen; das ging uns allen irgendwann so! Bevor wir also anfangen, lass uns ein paar Dinge klarstellen:

1. Alchemy speichert deine privaten Schlüssel nicht

Das bedeutet, dass Alchemy keine Transaktionen in deinem Namen signieren und senden kann. Der Grund dafür sind Sicherheitsaspekte. Alchemy wird dich niemals bitten, deinen privaten Schlüssel weiterzugeben, und du solltest deinen privaten Schlüssel niemals an einen gehosteten Knoten (oder überhaupt an jemanden) weitergeben.
Du kannst mit der Core-API von Alchemy von der Blockchain lesen, aber um darauf zu schreiben, musst du etwas anderes verwenden, um deine Transaktionen zu signieren, bevor du sie über Alchemy sendest (das gilt auch für jeden anderen Knoten-Dienst).

2. Was ist ein „Signer“?

Signer signieren Transaktionen für dich mit deinem privaten Schlüssel. In diesem Tutorial verwenden wir Alchemy Web3 (opens in a new tab), um unsere Transaktion zu signieren, aber du könntest auch jede andere Web3-Bibliothek verwenden.
Im Frontend wäre ein gutes Beispiel für einen Signer MetaMask (opens in a new tab), das Transaktionen in deinem Namen signiert und sendet.

3. Warum muss ich meine Transaktionen signieren?

Jeder Benutzer, der eine Transaktion im Ethereum-Netzwerk senden möchte, muss die Transaktion (mit seinem privaten Schlüssel) signieren, um zu validieren, dass der Ursprung der Transaktion derjenige ist, der er vorgibt zu sein.
Es ist extrem wichtig, diesen privaten Schlüssel zu schützen, da der Zugriff darauf die volle Kontrolle über dein Ethereum-Konto gewährt und es dir (oder jedem mit Zugriff) ermöglicht, Transaktionen in deinem Namen durchzuführen.

4. Wie schütze ich meinen privaten Schlüssel?

Es gibt viele Möglichkeiten, deinen privaten Schlüssel zu schützen und ihn zum Senden von Transaktionen zu verwenden. In diesem Tutorial verwenden wir eine .env-Datei. Du könntest jedoch auch einen separaten Anbieter verwenden, der private Schlüssel speichert, eine Schlüsselspeicher-Datei (Keystore) nutzen oder andere Optionen wählen.

5. Was ist der Unterschied zwischen `eth_sendTransaction` und `eth_sendRawTransaction`?

eth_sendTransaction und eth_sendRawTransaction sind beides Ethereum-API-Funktionen, die eine Transaktion an das Ethereum-Netzwerk übertragen, damit sie einem zukünftigen Block hinzugefügt wird. Sie unterscheiden sich darin, wie sie das Signieren der Transaktionen handhaben.

eth_sendTransaction (opens in a new tab) wird zum Senden unsignierter Transaktionen verwendet. Das bedeutet, dass der Knoten, an den du sendest, deinen privaten Schlüssel verwalten muss, damit er die Transaktion signieren kann, bevor er sie an die Chain überträgt. Da Alchemy die privaten Schlüssel der Benutzer nicht speichert, unterstützen sie diese Methode nicht.
eth_sendRawTransaction (opens in a new tab) wird verwendet, um Transaktionen zu übertragen, die bereits signiert wurden. Das bedeutet, dass du zuerst signTransaction(tx, private_key) (opens in a new tab) verwenden musst und dann das Ergebnis an eth_sendRawTransaction übergibst.

Bei der Verwendung von Web3 wird auf eth_sendRawTransaction zugegriffen, indem die Funktion web3.eth.sendSignedTransaction (opens in a new tab) aufgerufen wird.

Genau das werden wir in diesem Tutorial verwenden.

6. Was ist die Web3-Bibliothek?

Web3.js ist eine Wrapper-Bibliothek um die Standard-JSON-RPC-Aufrufe, die in der Ethereum-Entwicklung sehr häufig verwendet wird.
Es gibt viele Web3-Bibliotheken für verschiedene Sprachen. In diesem Tutorial verwenden wir Alchemy Web3 (opens in a new tab), das in JavaScript geschrieben ist. Du kannst dir hier (opens in a new tab) andere Optionen wie Ethers.js (opens in a new tab) ansehen.

Okay, da wir nun einige dieser Fragen geklärt haben, machen wir mit dem Tutorial weiter. Du kannst jederzeit Fragen im Alchemy-Discord (opens in a new tab) stellen!

7. Wie sendet man sichere, gasoptimierte und private Transaktionen?

Alchemy verfügt über eine Suite von Transact-APIs (opens in a new tab). Du kannst diese verwenden, um verstärkte Transaktionen zu senden, Transaktionen vor ihrer Ausführung zu simulieren, private Transaktionen zu senden und gasoptimierte Transaktionen zu senden.
Du kannst auch die Notify-API (opens in a new tab) verwenden, um benachrichtigt zu werden, wenn deine Transaktion aus dem Mempool gezogen und der Chain hinzugefügt wird.

HINWEIS: Dieser Leitfaden erfordert ein Alchemy-Konto, eine Ethereum-Adresse oder eine MetaMask-Wallet sowie installierte Node.js und npm. Wenn nicht, befolge diese Schritte:

Erstelle ein kostenloses Alchemy-Konto (opens in a new tab)
Erstelle ein MetaMask-Konto (opens in a new tab) (oder besorge dir eine Ethereum-Adresse)
Befolge diese Schritte, um Node.js und npm zu installieren (opens in a new tab)

Schritte zum Senden deiner Transaktion

1. Erstelle eine Alchemy-App im Sepolia-Testnetz

Navigiere zu deinem Alchemy-Dashboard (opens in a new tab) und erstelle eine neue App, wobei du Sepolia (oder ein anderes Testnetz) als dein Netzwerk auswählst.

2. Fordere ETH vom Sepolia-Faucet an

Befolge die Anweisungen auf dem Alchemy Sepolia-Faucet (opens in a new tab), um ETH zu erhalten. Stelle sicher, dass du deine Sepolia-Ethereum-Adresse (von MetaMask) und nicht die eines anderen Netzwerks angibst. Nachdem du die Anweisungen befolgt hast, überprüfe noch einmal, ob du die ETH in deiner Wallet erhalten hast.

3. Erstelle ein neues Projektverzeichnis und wechsle mit `cd` dorthin

Erstelle über die Befehlszeile (Terminal bei Macs) ein neues Projektverzeichnis und navigiere dorthin:

mkdir sendtx-example
cd sendtx-example

4. Installiere Alchemy Web3 (oder eine beliebige Web3-Bibliothek)

Führe den folgenden Befehl in deinem Projektverzeichnis aus, um Alchemy Web3 (opens in a new tab) zu installieren:

Hinweis: Wenn du die Ethers.js-Bibliothek verwenden möchtest, befolge die Anweisungen hier (opens in a new tab).

npm install @alch/alchemy-web3

5. Installiere dotenv

Wir verwenden eine .env-Datei, um unseren API-Schlüssel und unseren privaten Schlüssel sicher zu speichern.

npm install dotenv --save

6. Erstelle die `.env`-Datei

Erstelle eine .env-Datei in deinem Projektverzeichnis und füge Folgendes hinzu (ersetze dabei „your-api-url“ und „your-private-key“):

Um deine Alchemy-API-URL zu finden, navigiere zur App-Detailseite der App, die du gerade in deinem Dashboard erstellt hast, klicke oben rechts auf „View Key“ und kopiere die HTTP-URL.
Um deinen privaten Schlüssel mit MetaMask zu finden, sieh dir diesen Leitfaden (opens in a new tab) an.

API_URL = "your-api-url"
PRIVATE_KEY = "your-private-key"

Commite .env nicht! Bitte stelle sicher, dass du deine .env-Datei niemals mit jemandem teilst oder offenlegst, da du dadurch deine Geheimnisse kompromittierst. Wenn du eine Versionskontrolle verwendest, füge deine .env zu einer gitignore-Datei hinzu.

7. Erstelle die `sendTx.js`-Datei

Großartig, da wir nun unsere sensiblen Daten in einer .env-Datei geschützt haben, fangen wir an zu programmieren. Für unser Beispiel zum Senden einer Transaktion werden wir ETH an das Sepolia-Faucet zurücksenden.

Erstelle eine sendTx.js-Datei, in der wir unsere Beispieltransaktion konfigurieren und senden werden, und füge ihr die folgenden Codezeilen hinzu:

async function main() {
    require('dotenv').config();
    const { API_URL, PRIVATE_KEY } = process.env;
    const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
    const web3 = createAlchemyWeb3(API_URL);
    const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: Ersetze diese Adresse durch deine eigene öffentliche Adresse

    const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // Nonce beginnt bei 0 zu zählen

    const transaction = {
     'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // Faucet-Adresse zur Rückgabe von ETH
     'value': 1000000000000000000, // 1 ETH
     'gas': 30000,
     'nonce': nonce,
     // optionales Datenfeld zum Senden einer Nachricht oder Ausführen eines Smart Contracts
    };

    const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);

    web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
    if (!error) {
      console.log("🎉 Der Hash deiner Transaktion lautet: ", hash, "\n Überprüfe den Mempool von Alchemy, um den Status deiner Transaktion zu sehen!");
    } else {
      console.log("❗Beim Übermitteln deiner Transaktion ist etwas schiefgelaufen:", error)
    }
   });
}

main();

Achte darauf, die Adresse in Zeile 6 durch deine eigene öffentliche Adresse zu ersetzen.

Bevor wir nun dazu übergehen, diesen Code auszuführen, lass uns über einige der Komponenten hier sprechen.

nonce : Die Nonce-Spezifikation wird verwendet, um die Anzahl der von deiner Adresse gesendeten Transaktionen zu verfolgen. Wir benötigen dies aus Sicherheitsgründen und um Replay-Angriffe (opens in a new tab) zu verhindern. Um die Anzahl der von deiner Adresse gesendeten Transaktionen zu erhalten, verwenden wir getTransactionCount (opens in a new tab).
transaction: Das Transaktionsobjekt hat einige Aspekte, die wir spezifizieren müssen:
- to: Dies ist die Adresse, an die wir ETH senden möchten. In diesem Fall senden wir ETH an das Sepolia-Faucet (opens in a new tab) zurück, von dem wir sie ursprünglich angefordert haben.
- value: Dies ist der Betrag, den wir senden möchten, angegeben in Wei, wobei 10^18 Wei = 1 ETH entsprechen.
- gas: Es gibt viele Möglichkeiten, die richtige Menge an Gas zu bestimmen, die deiner Transaktion beigefügt werden soll. Alchemy hat sogar einen Gaspreis-Webhook (opens in a new tab), um dich zu benachrichtigen, wenn der Gaspreis unter einen bestimmten Schwellenwert fällt. Für Mainnet-Transaktionen ist es eine gute Praxis, einen Gas-Schätzer wie ETH Gas Station (opens in a new tab) zu überprüfen, um die richtige Menge an Gas zu bestimmen. 21000 ist die Mindestmenge an Gas, die eine Operation auf Ethereum verbraucht. Um sicherzustellen, dass unsere Transaktion ausgeführt wird, geben wir hier 30000 an.
- nonce: Siehe obige Nonce-Definition. Die Nonce beginnt bei null zu zählen.
- [OPTIONAL] data: Wird zum Senden zusätzlicher Informationen mit deinem Transfer oder zum Aufrufen eines Smart Contracts verwendet. Für Guthabentransfers nicht erforderlich, siehe den Hinweis unten.
signedTx: Um unser Transaktionsobjekt zu signieren, verwenden wir die Methode signTransaction mit unserem PRIVATE_KEY.
sendSignedTransaction: Sobald wir eine signierte Transaktion haben, können wir sie absenden, damit sie in einen nachfolgenden Block aufgenommen wird, indem wir sendSignedTransaction verwenden.

Ein Hinweis zu data (Daten) Es gibt zwei Hauptarten von Transaktionen, die in Ethereum gesendet werden können.

Guthabentransfer: Sende ETH von einer Adresse an eine andere. Es ist kein Datenfeld erforderlich. Wenn du jedoch zusätzliche Informationen zusammen mit deiner Transaktion senden möchtest, kannst du diese Informationen im HEX-Format in dieses Feld aufnehmen.
- Nehmen wir zum Beispiel an, wir wollten den Hash eines IPFS-Dokuments in die Ethereum-Chain schreiben, um ihm einen unveränderlichen Zeitstempel zu geben. Unser Datenfeld sollte dann so aussehen: data: web3.utils.toHex(‘IPFS hash‘). Und nun kann jeder die Chain abfragen und sehen, wann dieses Dokument hinzugefügt wurde.
Smart-Contract-Transaktion: Führe Smart-Contract-Code auf der Chain aus. In diesem Fall sollte das Datenfeld die Smart-Funktion, die du ausführen möchtest, zusammen mit allen Parametern enthalten.
- Ein praktisches Beispiel findest du in Schritt 8 dieses Hello-World-Tutorials (opens in a new tab).

8. Führe den Code mit `node sendTx.js` aus

Navigiere zurück zu deinem Terminal oder deiner Befehlszeile und führe Folgendes aus:

node sendTx.js

9. Sieh dir deine Transaktion im Mempool an

Öffne die Mempool-Seite (opens in a new tab) in deinem Alchemy-Dashboard und filtere nach der von dir erstellten App, um deine Transaktion zu finden. Hier können wir beobachten, wie unsere Transaktion vom ausstehenden Zustand (pending) in den geminten Zustand (mined) übergeht (falls erfolgreich) oder in den verworfenen Zustand (dropped), falls nicht erfolgreich. Stelle sicher, dass du die Einstellung auf „All“ belässt, damit du „mined“-, „pending“- und „dropped“-Transaktionen erfasst. Du kannst auch nach deiner Transaktion suchen, indem du nach Transaktionen suchst, die an die Adresse 0x31b98d14007bdee637298086988a0bbd31184523 gesendet wurden.

Um die Details deiner Transaktion anzuzeigen, sobald du sie gefunden hast, wähle den tx-Hash aus, was dich zu einer Ansicht führen sollte, die so aussieht:

Von dort aus kannst du deine Transaktion auf Etherscan ansehen, indem du auf das rot eingekreiste Symbol klickst!

Juhuuu! Du hast gerade deine erste Ethereum-Transaktion mit Alchemy gesendet 🎉

Für Feedback und Vorschläge zu diesem Leitfaden schreibe bitte Elan im Discord (opens in a new tab) von Alchemy!

Ursprünglich veröffentlicht unter https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy (opens in a new tab)

Letzte Aktualisierung der Seite: 3. März 2026

+16