Eine dApp von Grund auf neu erstellen: Beste Praktiken für Entwickler

Dezentrale Anwendungen, dApps, haben unsere Sichtweise auf Software verändert. Im Gegensatz zu traditionellen Anwendungen laufen dApps auf Blockchains, was Transparenz, Sicherheit und Dezentralisierung gewährleistet. Sie treiben DeFi-Protokolle für Kredite und Handel, NFT-Marktplätze für digitale Vermögenswerte und Prognosemärkte für reale Ereignisse an, neben vielen anderen Web3-Innovationen.

Doch der Aufbau einer funktionalen, skalierbaren dApp erfordert mehr als nur die Bereitstellung eines Smart Contracts. Eine der größten Herausforderungen? Der Zugang zu realen Daten.

Blockchains sind eigenständig und interagieren nicht nativ mit Off-Chain-Daten. Das bedeutet, dass, wenn Ihre dApp auf Preisfeeds, Echtzeitereignisse oder externe APIs angewiesen ist, sie einen Oracle benötigt, ein System, das reale Daten auf die Blockchain bringt. Wenn Sie sich bis zu diesem Punkt bereits verloren fühlen, machen Sie sich keine Sorgen. Es ist wichtig, die Grundlagen zu verstehen, bevor Sie eintauchen. Sie können einen Schritt zurücktreten und mit unserem einsteigerfreundlichen Leitfaden zu Blockchain-Orakeln beginnen, um eine solide Grundlage zu erhalten, bevor Sie fortfahren.

Dieser Leitfaden zeigt Ihnen den besten Weg, um eine dApp zu erstellen, einschließlich der Auswahl der Blockchain, Smart Contracts, Frontends und Orakeln, mit einem besonderen Schwerpunkt auf Morpher Oracle, einer leistungsstarken und kosteneffektiven Datenlösung, die für EVM-kompatible Blockchains entwickelt wurde. Am Ende dieses Artikels werden Sie so ziemlich alles haben, was Sie benötigen, um Ihre dApp von Grund auf neu zu erstellen.

Die richtige Blockchain für Ihre dApp auswählen

Bevor Sie auch nur eine Zeile Code schreiben, müssen Sie entscheiden, welche Blockchain Ihre dApp hosten wird. Jede Blockchain hat ihre eigenen Vorteile und Abwägungen in Bezug auf Gebühren, Skalierbarkeit und Entwicklerwerkzeuge.

Ihre Wahl der Blockchain wird sich direkt auf die Kosten, die Skalierbarkeit und die Benutzererfahrung Ihrer dApp auswirken. Hier ist eine Übersicht der wichtigsten Faktoren und der besten Optionen basierend auf Ihren Bedürfnissen:

Sicherheit & Dezentralisierung: Ethereum

Wenn Ihre Priorität maximale Sicherheit und Dezentralisierung ist, ist Ethereum die beste Wahl. Es ist die am weitesten verbreitete Plattform für Smart Contracts, mit den stärksten Netzwerk-Effekten, Entwicklerunterstützung und bewährter Sicherheit.

Am besten geeignet für: Hochwertige DeFi-Protokolle, institutionelle Anwendungen, langfristige Projekte, die Sicherheit priorisieren.

Niedrigere Transaktionskosten: Polygon & Arbitrum

Wenn Gasgebühren ein Anliegen sind, bieten Polygon und Arbitrum eine kostengünstigere Alternative, während sie die Ethereum-Kompatibilität aufrechterhalten.

Polygon: Eine Ethereum Layer 2 Sidechain, die niedrige Gebühren und hohe Transaktionsgeschwindigkeit bietet und sich hervorragend für NFTs, Gaming und verbraucherorientierte dApps eignet, die häufige Interaktionen erfordern.

Arbitrum: Ein Layer 2 Rollup, das die Sicherheit von Ethereum erbt und dabei wesentlich niedrigere Gasgebühren bietet. Es ist ideal für DeFi-Anwendungen, die dennoch die Sicherheit von Ethereum aufrechterhalten möchten.

Optimism: Ein weiteres Ethereum Layer 2 Rollup mit dem Fokus auf Kosteneffizienz und Anreizen für Entwickler.

Am besten geeignet für: Hochfrequenzhandel, NFT-Prägung, Gaming und Anwendungen, die niedrige Gebühren benötigen.

Binance Smart Chain: Eine schnelle & kostengünstige Alternative

Für Projekte, die Einzelhandelsnutzer mit hohem Transaktionsvolumen ansprechen, bietet die Binance Smart Chain (BSC) schnelle, kostengünstige Transaktionen. BSC ist vollständig EVM-kompatibel, was bedeutet, dass es Solidity-Smart Contracts unterstützt und die Integration mit Morpher Oracle sowie die Migration bestehender Ethereum-basierter dApps erleichtert.

Am besten geeignet für: Verbraucher-dApps, Gaming, Einzelhandels-DeFi und Anwendungen, bei denen die Transaktionskosten minimal sein müssen.

Unterstützte EVM-kompatible Blockchains für Morpher Oracle

Morpher Oracle ist für Ethereum und EVM-kompatible Blockchains konzipiert, was bedeutet, dass es nahtlos in mehreren Ökosystemen verwendet werden kann:

Ethereum: Sicher, weit verbreitet, hat jedoch hohe Gasgebühren.

Polygon: Ethereum-kompatible Layer 2-Lösung mit niedrigeren Gebühren.

Arbitrum & Optimism: Ethereum Layer 2 Rollups für kosteneffiziente Transaktionen.

Binance Smart Chain: Kostengünstige Alternative mit EVM-Kompatibilität.

Welche sollten Sie wählen?

• Wenn Sie ein DeFi-Protokoll mit hohem TVL (Total Value Locked) erstellen und maximale Sicherheit benötigen, wählen Sie Ethereum.
• Wenn Sie Skalierbarkeit und niedrigere Gebühren benötigen, während Sie EVM-kompatibel bleiben, sind Polygon oder Arbitrum starke Optionen.
• Wenn Ihre dApp auf Massenakzeptanz, Mikrozahlungen oder Verbraucherfinanzen abzielt, bietet BSC die niedrigsten Kosten und die höchste Geschwindigkeit, während sie weiterhin mit Morpher Oracle kompatibel ist.

Unabhängig von Ihrer Wahl ist Morpher Oracle so konzipiert, dass es nahtlos mit allen EVM-kompatiblen Chains funktioniert, um Flexibilität und Multi-Chain-Expansion bei Bedarf zu ermöglichen.

Kernkomponenten einer dApp

Eine voll funktionsfähige dApp besteht aus drei Hauptkomponenten:

Frontend (Benutzeroberfläche): Entwickelt mit React.js, Vue.js oder Svelte für eine moderne, responsive Benutzeroberfläche.

Stellt eine Verbindung zur Blockchain über Ethers.js oder Web3.js her.

Smart Contracts (Backend auf der Blockchain): In Solidity für Ethereum und EVM-kompatible Netzwerke geschrieben. Behandelt Geschäftslogik, wie z.B. Token-Übertragungen, NFT-Prägungen oder Kreditprotokolle.

Orakel (Verbindung zwischen On-Chain und Off-Chain Welten): Da Smart Contracts nicht direkt auf externe Daten zugreifen können, verwenden dApps Orakel für Echtzeitdaten.

Warum Morpher Oracle wählen?

Orakel sind entscheidend für dApps, die Echtzeit-Preisfeeds, externe Datenüberprüfungen oder Off-Chain-Informationen benötigen. Allerdings sind nicht alle Orakel gleich aufgebaut. Viele traditionelle Orakel bringen hohe Kosten, Latenzprobleme und komplexe Integrationsanforderungen mit sich; Herausforderungen, die die Entwicklung verlangsamen und die Betriebskosten erhöhen können.

Morpher Oracle verfolgt einen intelligenteren, kosteneffizienteren Ansatz, der das Leben der Entwickler erleichtert.

• Niedrigere Kosten: Traditionelle Orakel verlangen hohe Gebühren für den Datenzugang. Morpher Oracle basiert auf einem ERC-4337-Konto-Abstraktionsmodell, wodurch es günstiger und effizienter als Alternativen ist.
• Nahtlose EVM-Kompatibilität: Funktioniert nativ auf Ethereum, Polygon, Arbitrum und BNB Chain, sodass Sie Ihre dApp auf mehreren Chains ohne Kompatibilitätsprobleme bereitstellen können.
• Datenfrische & Genauigkeit: Morpher Oracle verwendet ein robustes Datengültigkeitssystem in Kombination mit einem intent-basierten Orakelmodell, um sicherzustellen, dass Ihre dApp die aktuellsten, manipulationssicheren Daten genau dann erhält, wenn sie benötigt werden. Anstatt Daten kontinuierlich on-chain zu übertragen, was kostspielig und ineffizient sein kann, ruft Morpher Oracle Daten auf Abruf ab, reduziert unnötige Transaktionen und gewährleistet die Genauigkeit für Preisfeeds, Marktdaten und andere reale Eingaben.
• Vereinfachte Integration: Viele Orakel erfordern komplexe Konfigurationen. Morpher Oracle bietet eine Plug-and-Play-Integration mit einem entwicklerfreundlichen SDK und klarer Dokumentation, sodass Sie Echtzeitdaten mit minimalem Aufwand abrufen können.

Für Entwickler, die nach einer zuverlässigen, kosteneffektiven und skalierbaren Orakel-Lösung suchen, ist Morpher Oracle die beste Wahl, insbesondere für dApps im DeFi-Bereich, bei NFT-Preisgestaltungen, Vorhersagemärkten und automatisierter Smart-Contract-Ausführung. Wenn Sie mehr darüber erfahren möchten, wie sich Morpher Oracle von traditionellen Orakeln unterscheidet, sollten Sie unbedingt unseren umfassenden Leitfaden von unserem CTO, Thomas, lesen.

💡 Bevorzugen Sie es, direkt mit dem Codieren zu beginnen? Sehen Sie sich die Morpher Datenfeeds an und beginnen Sie noch heute mit dem Bau.

Der beste Weg, eine dApp zu erstellen: Eine Schritt-für-Schritt-Anleitung zur Verwendung von Morpher Oracle

Die Integration von Morpher Oracle in Ihre dApp umfasst vier wichtige Schritte:
1. Implementierung der DataDependent-Schnittstelle
2. Aufruf von consumeData(), um Oracle-Daten abzurufen
3. Einrichtung eines ERC-4337-Clients zur Automatisierung von Transaktionen
4. Bereitstellung und Optimierung Ihrer dApp für den Zugriff auf Echtzeitdaten

Gehen wir jeden Schritt durch.

Schritt 1: Implementierung der DataDependent-Schnittstelle

Um externe Daten anzufordern, muss Ihr Smart Contract festlegen, welche Daten er vom Oracle benötigt. Dies geschieht durch die Implementierung der DataDependent-Schnittstelle.

Beispiel: Anforderung von BTC/USD-Preisdaten

pragma solidity ^0.8.26;

interface DataDependent {
    struct DataRequirement {
        address provider;
        address requester;
        bytes32 dataKey;
    }

    function requirements(
        bytes4 _selector
    ) external view returns (DataRequirement[] memory);
}

contract YourContract is DataDependent {

    address dataProvider; //holen Sie dies von der Feed-Seite
    address oracle;
    bytes32 BTC_USD = keccak256("BINANCE:BTC_USDT");
  
    // ...

    function requirements(bytes4 _selector) external view override returns (DataRequirement[] memory) {
        if (_selector == 0x6a627842) {
            DataRequirement[] memory requirement = new DataRequirement[](1);
            requirement[0] = DataRequirement(dataProvider, address(this), BTC_USD);
            return requirement;
        }
        return new DataRequirement[](0);
    }

    // ...

}

Was dies bewirkt:

• Definiert, von welchem Datenanbieter der Vertrag Daten abrufen wird.
• Gibt den genauen benötigten Datenschlüssel an (BTC/USD-Preis von Binance).
• Implementiert die requirements() Funktion, damit der Vertrag weiß, welche Daten angefordert werden sollen.

Schritt 2: Aufruf von consumeData(), um Oracle-Daten abzurufen

Sobald Ihr Vertrag seine Datenanforderungen definiert hat, muss er bei Bedarf Echtzeitdaten vom Oracle abrufen. Dies geschieht mit der Funktion consumeData().

Beispiel: Abrufen des BTC/USD-Preises vom Oracle

pragma solidity ^0.8.26;

interface OracleEntrypoint {
    function consumeData(
        address _provider,
        bytes32 _dataKey
    ) public payable returns (bytes32);

    function prices(address _provider, bytes32 _dataKey) public view returns(uint256);
}

contract YourContract is DataDependent {

    struct ResponseWithExpenses {
        uint value;
        uint expenses;
    }
  
    // ...

    function _invokeOracle(address _provider, bytes32 _key) private returns (ResponseWithExpenses memory) {
        uint expenses = OracleEntrypoint(oracle).prices(_provider, _key);
        // zahlen Sie jetzt das Oracle, erhalten Sie später die Mittel vom Absender nach Wunsch (z.B. abziehen von msg.value)
        bytes32 response = OracleEntrypoint(oracle).consumeData{value: expenses}(_provider, _key);
        uint256 asUint = uint256(response);
        uint256 timestamp = asUint >> (26 * 8);
        // in diesem Beispiel möchten wir, dass der Preis aktuell ist
        require(timestamp > 1000 * (block.timestamp - 30), "Daten zu alt!");
        uint8 decimals = uint8((asUint >> (25 * 8)) - timestamp * (2 ** 8));
        // in diesem Beispiel erwarten wir eine Antwort mit 18 Dezimalstellen
        require(decimals == 18, "Oracle-Antwort mit falschen Dezimalstellen!");
        uint256 price = uint256(
            asUint - timestamp * (2 ** (26 * 8)) - decimals * (2 ** (25 * 8))
        );
        return ResponseWithExpenses(price, expenses);
    }

    // ...

}

Was dies bewirkt:

• Ruft consumeData() beim Morpher Oracle auf, um den neuesten BTC/USD-Preis abzurufen.
• Stellt sicher, dass die Daten aktuell sind (verhindert die Verwendung veralteter Informationen).
• Konvertiert die Antwort in einen lesbaren Preiswert mit den richtigen Dezimalstellen.

Schritt 3: Einrichtung eines ERC-4337-Clients

Jetzt, da Ihr Vertrag Echtzeitdaten vom Oracle abrufen kann, müssen Sie sicherstellen, dass die Benutzer nahtlos mit ihm interagieren können. ERC-4337 (Account Abstraction) hilft, indem es die Gaszahlungen automatisiert und die Transaktionen effizienter gestaltet.

Einrichtungsanleitung

1. Installieren Sie Morphers DataDependent AbstractionKit:

• Dieses Kit wird:
• Die Datenanforderungen Ihres Smart Contracts automatisch abrufen.
• Gasgebühren mit dem modifizierten RPC-Endpunkt schätzen.
• Datenabhängige Transaktionen nahtlos einreichen.

2. Verwenden Sie den Bundler RPC Ihres gewählten Anbieters, um Transaktionen effizient einzureichen.

Warum das wichtig ist:

• Entfernt die Notwendigkeit für Benutzer, Transaktionen manuell zu senden.
• Vereinfacht das Abrufen von Oracle-Daten durch Automatisierung der Anfragen.
• Verbessert die Benutzererfahrung, indem Transaktionen gas-effizient und skalierbar gemacht werden.

Schritt 4: Bereitstellung und Optimierung Ihrer dApp

Jetzt, da alles funktioniert, ist es an der Zeit, Ihre dApp für den Einsatz in der realen Welt bereitzustellen und zu optimieren.

Testen vor der Bereitstellung

• Stellen Sie Ihren Smart Contract in Testnetzen bereit, bevor Sie ihn im Hauptnetz starten:
  • Ethereum-Testnetze: Goerli, Sepolia
  • Polygon-Testnet: Mumbai
• Verwenden Sie Hardhat oder Foundry, um Transaktionen zu simulieren, bevor Sie live bereitstellen.

Optimierung für niedrige Gasgebühren

• Verwenden Sie die ERC-4337-Kontokapselung für kosteneffizientere Transaktionen.
• Optimieren Sie den Speicher und die Logik des Smart Contracts, um die Gasgebühren zu senken.
• Bündeln Sie Oracle-Anfragen, wenn möglich, um wiederholte Aufrufe zu minimieren.

Nächste Schritte

An diesem Punkt ist Ihre dApp bereit, Echtzeit-Orakel-Daten abzurufen, diese innerhalb von Smart Contracts zu verarbeiten und gasoptimierte Transaktionen auf Ethereum, Polygon oder BSC durchzuführen.

Möchten Sie diesen Prozess in Aktion sehen? Wir haben ein schrittweises Entwickler-Tutorial mit einer funktionierenden NFT dApp vorbereitet, das die vollständigen Fähigkeiten von Morpher Oracle demonstriert.

🎥 Sehen Sie sich hier das gesamte Tutorial an und folgen Sie den realen Codebeispielen.

Was Sie im Tutorial lernen werden:

✅ Implementierung der DataDependent-Schnittstelle in einem Live-Smart Contract.
✅ Abrufen von Echtzeit-Preisfeeds mit Morpher Oracle.
✅ Einrichtung eines ERC-4337 Clients für automatisierte Transaktionen.
✅ Bereitstellung und Test Ihrer dApp auf Ethereum, Polygon und BSC.

Bereit, Echtzeitdaten in Ihre dApp zu bringen? Lassen Sie uns etwas Erstaunliches schaffen!