Warum Ethers.js? Stellen Sie sich vor, Sie müssten sich mit Promises und Callbacks herumschlagen und gleichzeitig die geheimnisvollen Mysterien der Blockchain-Interaktionen entschlüsseln. Klingt nach einem Rezept für Kopfschmerzen, oder? Ethers.js kommt wie ein Held mit Umhang daher und bietet eine saubere, intuitive API, die die Interaktion mit Ethereum zum Kinderspiel macht. Es ist wie der Unterschied zwischen dem Ringen mit einem Oktopus und dem Streicheln eines Kätzchens.

Einrichtung unseres Web3-Kommandos

Zuallererst müssen wir unsere Entwicklungsumgebung vorbereiten. Wir benötigen Node.js und npm. Sobald das erledigt ist, erstellen Sie ein neues Verzeichnis für Ihr Projekt und führen Sie Folgendes aus:


npm init -y
npm install ethers express dotenv
Bash

Nun erstellen wir unseren einfachen Express-Server in einer Datei namens server.js:


const express = require('express');
const { ethers } = require('ethers');
require('dotenv').config();

const app = express();
app.use(express.json());

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});
JavaScript

Verbindung zum Ethereum-Netzwerk: Es ist keine Raketenwissenschaft, es ist Blockchain!

Jetzt, da unser Server läuft, ist es an der Zeit, unsere Verbindung zum Ethereum-Netzwerk herzustellen. Wir verwenden einen Infura-Endpunkt für dieses Beispiel, aber Sie können jeden Anbieter verwenden, mit dem Sie sich wohlfühlen.

Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie Ihren Infura-API-Schlüssel hinzu:


INFURA_API_KEY=your_infura_api_key_here
Env

Nun richten wir unseren Ethereum-Provider ein:


const provider = new ethers.providers.JsonRpcProvider(`https://mainnet.infura.io/v3/${process.env.INFURA_API_KEY}`);
JavaScript

Interaktion mit Smart Contracts: Wo die Magie passiert

Hier wird es interessant. Wir werden einen einfachen Endpunkt erstellen, der mit einem Smart Contract interagiert. Für dieses Beispiel verwenden wir den DAI-Stablecoin-Contract, denn wer liebt nicht einen guten Stablecoin?

Zuerst definieren wir unser Contract-ABI und die Adresse:


const DAI_ADDRESS = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
const DAI_ABI = [
  'function balanceOf(address owner) view returns (uint256)',
  'function transfer(address to, uint amount) returns (bool)',
];

const daiContract = new ethers.Contract(DAI_ADDRESS, DAI_ABI, provider);
JavaScript

Nun erstellen wir einen Endpunkt, um den DAI-Saldo einer Adresse zu überprüfen:


app.get('/balance/:address', async (req, res) => {
  try {
    const balance = await daiContract.balanceOf(req.params.address);
    res.json({ balance: ethers.utils.formatEther(balance) });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
JavaScript

Transaktionen verwalten: Verlieren Sie nicht Ihr ETH!

Die Interaktion mit Smart Contracts beinhaltet oft das Senden von Transaktionen. Lassen Sie uns einen Endpunkt erstellen, um DAI-Token zu übertragen. Aber denken Sie daran, mit großer Macht kommt große Verantwortung (und Gasgebühren)!

Zuerst müssen wir ein Wallet einrichten. Fügen Sie Ihren privaten Schlüssel zur .env-Datei hinzu (aber teilen Sie ihn niemals oder speichern Sie ihn in der Versionskontrolle!):


PRIVATE_KEY=your_private_key_here
Env

Nun erstellen wir unser Wallet und eine neue Instanz des Contracts, die damit verbunden ist:


const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
const daiContractWithSigner = daiContract.connect(wallet);
JavaScript

Und hier ist unser Transfer-Endpunkt:


app.post('/transfer', async (req, res) => {
  const { to, amount } = req.body;
  try {
    const tx = await daiContractWithSigner.transfer(to, ethers.utils.parseEther(amount));
    await tx.wait();
    res.json({ txHash: tx.hash });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
JavaScript

Fehlerbehandlung: Denn auch Blockchain-Entwickler machen Fehler

Bei der Arbeit mit Blockchain-Interaktionen kann viel schiefgehen. Gaspreise könnten steigen, Transaktionen könnten fehlschlagen oder das Netzwerk könnte überlastet sein. Lassen Sie uns einige Fehlerbehandlungen hinzufügen, um unser Leben zu erleichtern:


app.use((err, req, res, next) => {
  if (err instanceof ethers.errors.TransactionError) {
    res.status(400).json({ error: 'Transaction failed', details: err.message });
  } else if (err.code === 'INSUFFICIENT_FUNDS') {
    res.status(400).json({ error: 'Insufficient funds for transaction' });
  } else {
    res.status(500).json({ error: 'Internal server error', details: err.message });
  }
});
JavaScript

Testen Ihres Web3-Backends: Vertrauen, aber überprüfen

Bevor Sie Ihr neues Web3-Backend bereitstellen, ist es wichtig, es gründlich zu testen. Hier ist ein einfaches Testskript, das Sie ausführen können, um zu überprüfen, ob alles wie erwartet funktioniert:


const axios = require('axios');

async function testBackend() {
  const baseURL = 'http://localhost:3000';

  // Test balance endpoint
  const balanceResponse = await axios.get(`${baseURL}/balance/0x6B175474E89094C44Da98b954EedeAC495271d0F`);
  console.log('Balance:', balanceResponse.data);

  // Test transfer endpoint (be careful with this one!)
  const transferResponse = await axios.post(`${baseURL}/transfer`, {
    to: '0x1234567890123456789012345678901234567890',
    amount: '0.1'
  });
  console.log('Transfer TX Hash:', transferResponse.data);
}

testBackend().catch(console.error);
JavaScript

Bereitstellung: Entfesseln Sie Ihr Web3-Biest auf die Welt

Jetzt, da Sie Ihr Web3-Backend erstellt und getestet haben, ist es an der Zeit, es bereitzustellen. Sie können Plattformen wie Heroku oder DigitalOcean verwenden, aber denken Sie daran, Ihre Umgebungsvariablen sicher zu setzen. Geben Sie niemals Ihre privaten Schlüssel oder API-Schlüssel in Ihrem Code oder öffentlichen Repositories preis!

Fazit: Sie sind jetzt ein Web3-Backend-Zauberer!

Herzlichen Glückwunsch! Sie haben erfolgreich die Lücke zwischen traditioneller Backend-Entwicklung und der neuen Welt von Web3 überbrückt. Mit Ethers.js als Ihrem treuen Begleiter haben Sie ein Backend erstellt, das mit Smart Contracts interagieren, Transaktionen abwickeln und mit den Eigenheiten der Blockchain-Entwicklung umgehen kann.

Denken Sie daran, dies ist nur die Spitze des Eisbergs. Der Web3-Bereich entwickelt sich ständig weiter, mit neuen Protokollen, Standards und Best Practices, die ständig entstehen. Bleiben Sie neugierig, lernen Sie weiter, und wer weiß? Vielleicht sind Sie derjenige, der das nächste große Ding im dezentralen Web entwickelt.

Denkanstoß: Die Zukunft der Web3-Backends

Zum Abschluss hier einige Fragen zum Nachdenken:

  • Wie könnten sich Backend-Architekturen entwickeln, um dezentrale Anwendungen besser zu unterstützen?
  • Welche Sicherheitsüberlegungen sind einzigartig für Web3-Backends und wie können wir sie angehen?
  • Wie können wir die Skalierbarkeit bei der Arbeit mit Blockchain-Interaktionen optimieren?

Die Antworten auf diese Fragen könnten die Zukunft der Web3-Entwicklung gestalten. Also, weiter coden, weiter fragen und vor allem die Grenzen dessen, was im dezentralen Web möglich ist, weiter verschieben!