So erstellen Sie eine Blockchain-Anwendung mit Python

Als Blockchain-Entwickler wissen Sie weit überdurchschnittlich gut, wie die Dinge unter der Haube funktionieren. Sie kennen Blöcke, Hashes, Knoten, Transaktionen, verschiedene Datentypen und vieles mehr. Wenn Sie jedoch eine Vorstellung davon haben, wie Blockchain in einer bestimmten Umgebung mit Gelegenheitsbenutzern implementiert werden kann, werden Sie nicht all Ihre Weisheit mit ihnen teilen, geschweige denn sie zwingen, zu lernen, wie jede einzelne Operation ausgeführt wird. Zeitgenössische Benutzer werden mit einfachen und Schnittstellen mit hervorragenden Benutzeroberflächen verwöhnt, die eine großartige Benutzererfahrung gewährleisten. Wenn Sie Ihr Blockchain-Projekt attraktiver gestalten möchten, sollten Sie es zumindest benutzerfreundlich gestalten. Hier kommen dezentrale Anwendungen oder dApps ins Spiel.

Dezentrale Apps sind ein neuer Trend in der Softwareentwicklung. Sie wurden nach dem ICO-Wahn, der 2017 begann, populär. Das Hauptmerkmal von dApps ist, dass sie sich vollständig auf die Blockchain verlassen und daher nicht von Dritten kontrolliert oder heruntergefahren werden können. Darüber hinaus können dApps auch intelligente Verträge verwenden, die wir zuvor besprochen haben, um verschiedene Vorgänge sicher und autonom auszuführen. Ansonsten ähneln dApps zentralisierten Apps und können vom Austausch bis zum Spiel reichen. Sie können einige davon aus unserer Liste von 10 dApps hier überprüfen.

Obwohl es einige dedizierte Programmiersprachen für die Smart Contract- und dApp-Programmierung gibt, wie z. B. Solidity, Vyper und Simplicity, können für diesen Zweck auch andere Sprachen verwendet werden. Für dieses Tutorial haben wir Python als eine der umfassendsten und vielseitigsten Sprachen ausgewählt. Heute zeigen wir Ihnen eine einfache App, die mit Python erstellt wurde, starten sie und erklären, wie sie funktioniert. Lassen Sie es uns nicht länger aufschieben und uns an die Arbeit machen!

Struktur und Eigenschaften einer dApp

Lassen Sie uns zunächst skizzieren, wie eine dApp aussehen soll, und ihre Elemente durchgehen. Es gibt zwei Hauptteile einer dApp:

  • Vorderes Ende

  • Backend

Das Frontend enthält alles, was einem Benutzer angezeigt wird. Wenn Sie beispielsweise durch Ihr Facebook-Profil scrollen, interagieren Sie mit dem Front-End von Facebook. Normalerweise wird es mit HTML, CSS und JavaScript geschrieben, es gibt jedoch auch andere Möglichkeiten. Das hintere Ende ist wie der Motor eines Autos. Niemand außer der Mechanik schaut es sich an, aber es bringt die Dinge zum Laufen. Während zentralisierte Anwendungen Hosting-Dienste und verschiedene Frameworks wie Django und NodeJS verwenden, verwenden dezentrale Anwendungen stattdessen Blockchains. In beiden Fällen Kommunikation zwischen Frontend & Das Backend erfolgt über JSON-formatierte Nachrichten.

Wir sollten auch beachten, dass ein Ingenieur, der eine dApp erstellt, mehrere gründliche Überprüfungen seines Projekts durchführen sollte, um sicherzustellen, dass der Code keine Schwachstellen enthält, da Backend-Aufgaben in der Blockchain ausgeführt werden, in der alles unveränderlich ist. Dadurch sieht das Erstellen von dApps eher nach Hardware als nach Software aus, die im laufenden Betrieb optimiert werden kann. Wenn eine dApp perfekt geschrieben ist, ist sie praktisch nicht hackbar, da es keinen zentralen Fehlerpunkt gibt. Zweitens wird Code für dApps normalerweise als Open Source veröffentlicht. Andernfalls hat die Community Vertrauensprobleme und vermeidet die Verwendung einiger Anwendungen.

Backend erstellen

Nachdem wir nun wissen, dass eine dApp auf der Blockchain basiert, erstellen wir eine lokal mit Python. Dies ist ein sicherer Ansatz zum Lernen und Testen von Dingen, da wir kein echtes Netzwerk mit unnötigem Code überlasten möchten. Darüber hinaus ist diese Demonstration eher geneigt, Ihnen die Prinzipien der Funktionsweise zu zeigen – die realen dApps sind viel komplexer.

Da alles auf Ihrem Computer passiert, befindet sich die Blockchain physisch auf Ihrer Festplatte, was sie im Wesentlichen zu einem Knoten macht. Erstellen Sie zu diesem Zweck einen Ordner an einem beliebigen Ort und nennen Sie ihn “Projekt”. Erstellen Sie innerhalb des Ordners einen weiteren, nennen Sie ihn “Blockchain” und codieren Sie dort einen ersten Block. Erstellen Sie eine Textdatei und öffnen Sie sie in einem Code-Editor Ihrer Wahl. Wir werden Atom verwenden.

Initialisierung des Genesis-Blocks

Im ersten Block geben wir an, dass ein Zahler einem Zahlungsempfänger tausend Münzen gezahlt hat. Wie Sie sich wahrscheinlich aus unserem Artikel über die Hash-Leistung erinnern, wird der Kopf jedes Blocks gehasht und der Hash jedes Blocks in den nächsten aufgenommen, um sicherzustellen, dass das Netzwerk nicht manipuliert wurde. Ein Genesis-Block hat keinen Block vor sich, daher wird ein leerer Hash angezeigt.

Genesis-BlockBild von U.Today

Als nächstes erstellen wir in unserem Ordner mit der Blockchain eine Datei mit dem Skript. Beginnen Sie mit dem Importieren der JSON-Bibliothek, da wir diese Formatierung verwenden werden. Fahren Sie mit dem ‘if __name__ == fort "__Main__": ’Anweisung, um zu überprüfen, ob das Skript über die Konsole gestartet wird oder nicht. Dieser Schritt hilft Ihnen beim Importieren. Damit unsere lokale Blockchain funktioniert, sollten wir eine Funktion schreiben, die neue Blöcke erstellt. Außerdem sollte eine Funktion vorhanden sein, mit der überprüft werden kann, ob die Blockchain geändert wurde oder nicht.

Neue Blöcke schreiben

Codieren wir die Funktion, um die folgenden Blöcke in der Kette zu erstellen. Dazu müssen wir alle Datentypen angeben, die wir im Genesis-Block geschrieben haben. Anschließend erstellen wir eine ‘with’-Anweisung mit der Funktion, eine neue Datei zu erstellen, damit der Code in neuen Blöcken besser zum Lesen geeignet ist. Geben Sie den Einzug an. Sobald dies erledigt ist, können wir das Skript ausführen und eine Datei mit unserem Testblock abrufen.

Neuer Testblock & amp; SkriptBild von U.Today

Die Testfunktion funktioniert! Jetzt können wir es erweitern, um Daten zu empfangen und in die nächsten Blöcke zu schreiben. Dazu werden die Argumente für Zahlungsempfänger, Betrag, Zahler und p_hash (Hash des vorherigen Blocks) in die Funktion eingefügt. Anschließend muss die Funktion die Blöcke in den entsprechenden Ordner schreiben. Importieren Sie zu diesem Zweck das Betriebssystem für die Arbeit mit dem Dateisystem des Computers. Anschließend definieren wir in der Funktion das Verzeichnis, das wir für unsere Blöcke über “os.curdir” erstellt haben. Geben Sie als Nächstes diese Deklaration in der Anweisung an, die eine neue Datei schreibt.

Wenn Sie weiter gehen, können wir die Testdatei nicht so lassen, wie sie ist. Wir möchten, dass jeder neue Block nacheinander benannt wird. Da unser Genesis-Block “0” ist, sollte der nächste Block 1 sein und so weiter. Dieser ist ziemlich einfach, unsere Funktion sollte in der Lage sein, das Blockchain-Kernverzeichnis zu analysieren. Suchen Sie die neueste Nummer des letzten Blocks, erhöhen Sie diese Nummer um eins und benennen Sie den nächsten Block. Um alle Blöcke zu erhalten, verwenden wir “listdir” des Betriebssystems und stellen ihm unsere Blockchain-Verzeichnisvariable zur Verfügung. Beachten Sie, dass “listdir” Blöcke nicht nach ihren Namen sortiert, sodass die neueste Datei in diesem Fall möglicherweise nicht das ist, was wir benötigen. Daher müssen wir das Listenverständnis verwenden, um Ganzzahlen für alle Dateinamen zurückzugeben und diese über die Funktion “Sortiert” zu sortieren. Lassen Sie uns abschließend unserer Blockchain das Beschriften von Blöcken beibringen, indem Sie den Namen des letzten Blocks zurückgeben und um eins erhöhen. Stellen Sie sicher, dass Sie die Beschriftung wieder in eine Zeichenfolge konvertieren und der Funktion “mit” den Blocknamen hinzufügen.

Funktion zum Abrufen von BlöckenBild von U.Today

Hashing

Jedes Mal, wenn Sie das Skript ausführen, erhalten Sie einen neuen Block. Dies ist jedoch immer noch keine Blockchain, da die Knoten auch in der Lage sein sollten, die Integrität und damit die Sicherheit der Daten zu überprüfen. Jeder der Blöcke hat einen Hash eines vorherigen. Beginnen wir mit dem Hashing von Daten innerhalb von Blöcken. Zuerst importieren wir das Hashlib-Modul. Anschließend erstellen wir eine Funktion, die den Inhalt eines Blocks liest, ihn durch den SHA-256-Hashing-Algorithmus führt und einen Hash zurückgibt. Bitte beachten Sie, dass Sie hier den Speicherort des Blockchain-Ordners angeben sollten, da die Funktion sonst keine Blöcke findet. Definieren Sie in der Funktion, die Blöcke erstellt, eine Variable für einen vorherigen Hash, die unsere Hashing-Funktion für den vorherigen Block startet. Während wir es testen, können wir sehen, dass der neue Block den Hash des vorherigen enthält. Sie können den Hash einfach überprüfen, indem Sie den Inhalt des Blocks 1 in einen Online-SHA256-Generator kopieren und die Ergebnisse vergleichen.

Hashing-FunktionBild von U.Today

Blocküberprüfung

Bisher haben wir die Blockerstellungsfunktion und die Hashing-Funktion. Es ist Zeit, einen Verifizierungsalgorithmus für unseren Knoten einzuführen. Die Funktion, die wir erstellen, kann die Liste aller Dateien in der Blockchain abrufen, die Hashes des vorherigen Blocks ab dem zweiten Block lesen, einen Hash jedes vorherigen Blocks erneut generieren, sie vergleichen und das Ergebnis zurückgeben.

Wir beginnen mit der Deklaration einer Variablen, die alle Dateien im Blockchain-Verzeichnis abruft, einer Variablen, die die Liste der Dateien zurückgibt, und einer Variablen, die Blöcke in aufsteigender Reihenfolge sortiert. Als nächstes sollten wir die Funktion in die Lage versetzen, die Blöcke zu durchlaufen und die Hashes der vorherigen Blöcke zu lesen. Dies kann über eine ‘for’-Schleife erfolgen, die alle Daten aus einem Block lädt und nur das zurückgibt, was dem’ Hash ‘entspricht. Nun müssen Sie noch einmal einen Hash erstellen, um zu überprüfen, ob eine Funktion ihn empfängt. Innerhalb der ‘for’-Schleife hinterlassen wir eine’ true_h’-Variable, die die Hashing-Funktion für den vorherigen Block startet. Der letzte Schritt besteht darin, Hashes mit einer if / else-Anweisung zu vergleichen. Die Ergebnisse werden in ein Array geschrieben, das wir für sie festgelegt haben, und alles wird in der Konsole angezeigt.

BlocküberprüfungBild von U.Today

Nach dem Bereinigen einiger Redundanzen haben wir eine lokale Blockchain, die in Python codiert ist.

Ein Frontend bauen

Obwohl wir es geschafft haben, alle erforderlichen Funktionen in weniger als 60 Codezeilen zu platzieren, würde dies für einen durchschnittlichen Benutzer immer noch wie ein Haufen Kauderwelsch aussehen. Daher müssen wir es einfach machen, eine Front-End-Schnittstelle zu verstehen und mit ihr zu verwenden. In diesem Tutorial verwenden wir das Flask-Framework zusammen mit HTML, CSS und JavaScript.

Umgebung einrichten

Erstellen Sie im Hauptverzeichnis des Projekts einen Ordner für die virtuelle Umgebung, der als Backend fungiert. Wenn Sie dies noch nicht getan haben, laden Sie es bitte herunter Python von der offiziellen Seite oder über eine Befehlszeile in Ihrem Betriebssystem (wir verwenden Homebrew in OSX) und installieren Sie es. Installieren Sie Virtualenv & Pip über entsprechende Befehlszeilenbefehle. Starten Sie anschließend eine virtuelle Umgebung über die Befehlszeile im Ordner “UI”. Sie erhalten einen neuen Ordner, wenn alles korrekt ausgeführt wurde. Zeit, es zu aktivieren und den Kolben über Pip zu installieren.

Venv erstellen und aktivierenBild von U.Today

Stellen wir unser Backend neben das Frontend. Schneiden Sie den Blockchain-Ordner und das Skript aus und fügen Sie sie in den App-Ordner im Hauptverzeichnis ein. Im Backend-Ordner müssen wir die Hauptskriptdatei erstellen.

Struktur erstellen

In unserem Hauptskript sollten wir zuerst Flask importieren und einen Link zum Namen der Datei einfügen, damit Flask die Pfade verstehen kann. Wir sollten auch eine Standardanweisung einfügen, die prüft, ob das Skript über die Konsole gestartet wird und unsere Anwendung ausführt. Stellen Sie sicher, dass Sie “Debug” hinzufügen, damit Flask jedes Mal neu geladen werden kann, wenn Sie etwas im Code ändern.

Leere AppBild von U.Today

Wenn Sie das Skript an dieser Stelle starten, können Sie sehen, dass localhost: 5000 aktiv ist, aber den Fehler 404 anzeigt. Dies ist normal, da die App noch leer ist. Beginnen wir mit dem Ausfüllen, indem wir eine Funktion erstellen, mit der die Benutzeranfragen unserer Knoten verarbeitet werden. Darin (durch Platzieren von “@” vor der Funktion) wird eine Indexfunktion eingefügt. Dadurch wird eine Struktur lokaler URLs und entsprechender Funktionen erstellt. Die Funktion “Index” zeigt den Benutzer index.html über das Modul “render_template” an.

App mit AnzeigefunktionBild von U.Today

Jetzt können wir mit der Erstellung unserer HTML-Struktur fortfahren. Es gibt zwei Dateien, eine für allgemeine Informationen und eine für die Benutzeroberfläche der ersten Seite. In base.html importieren wir die Bootstrap-Bibliothek zum Erstellen eines Layouts über CSS. Lassen Sie uns eine zentrierte Spalte erstellen und dort einen Block für Inhalte in einem Format einfügen, das von Flask’s Jinja interpretiert werden kann.

Erste Seite in HTMLBild von U.Today

Erstellen der Benutzeroberfläche

Unsere Anwendung wird ein einfaches Zahlungssystem sein. Es werden ein Zahler, ein Zahlungsempfänger und ein Geldbetrag überwiesen. Alles wird über Blockchain erledigt, aber für einen Benutzer sieht es aus wie eine normale App. Wenn Sie Geld im Internet überweisen, füllen Sie normalerweise ein Formular aus und senden es ab. Bootstrap hat verschiedene Formen, die uns bei einigen Voreinstellungen helfen. Sie können die von uns ausgewählte kopieren Hier und kopieren Sie den Code in Ihre index.html. Das vorab geschriebene Formular enthält nur zwei Felder und ein Kontrollkästchen. Wir entfernen das Kontrollkästchen und fügen ein Feld hinzu. Dann passen wir die richtigen Beschriftungen, IDs, Typen und Platzhalter an. Schließlich werden wir unsere Indexfunktion dem Formular zuordnen. Wenn ein Benutzer seinen Namen, seinen Betrag und einen Gegenagenten eingibt, müssen alle Informationen irgendwo gespeichert und dann in einen Block aufgenommen werden. Ändern Sie dazu unsere Eingabefelder, indem Sie “Name” und “Wert” hinzufügen. Der Wert verwendet die Methode “get”, um zu extrahieren, was ein Benutzer in das Feld “Payer” eingibt. Vergessen Sie nicht, eine leere Zeichenfolge anzugeben, falls ein Benutzer nichts eingibt.

BildenBild von U.Today

Kehren wir zu unserem Hauptskript zurück. Das Skript sollte verstehen können, ob die von einem Benutzer gesendete Anforderung POST ist oder nicht. Um dies zu ermöglichen, importieren wir das Anforderungsmodul aus der Flasche und geben die Methoden in unserer App an. Innerhalb der App deklarieren wir Variablen, die entsprechende Daten aus dem Formular anfordern.

App aktualisiertBild von U.Today

In einem weiteren Schritt müssen wir alle gesammelten Daten an einen neuen Block übergeben. Dies erfordert, dass wir das Hauptskript mit dem verbinden, das Blöcke schreibt. Zu diesem Zweck setzen wir in der if-Anweisung, die den Typ einer Anforderung überprüft, eine Schreibfunktion mit Argumenten ein, die dem entsprechen, was wir in unseren Blöcken haben.

Verknüpfung der Benutzeroberfläche mit dem BackendBild von U.Today

Wenn wir nun zu unserem Browser zurückkehren und eine Transaktion senden, erhalten wir einen neuen Block in unserem Blockchain-Ordner, der die von uns übermittelten Informationen enthält. Sie können jedoch feststellen, dass die Felder nicht aktualisiert wurden. Zu diesem Zweck müssen wir einen Benutzer auf eine neue Instanz von index.html umleiten. Vergessen Sie nicht, die von uns verwendeten Module aus Flask zu importieren. Voila, alles wird aktualisiert, nachdem Sie eingereicht haben.

UmleitenBild von U.Today

Der letzte Schliff für unsere Benutzeroberfläche wird a Taste Dadurch überprüft unser Knoten, ob Sicherheitsverletzungen in unserer Blockchain vorliegen. Zu diesem Zweck erstellen wir ein weiteres Routing zur Überprüfung mit einer darin enthaltenen Funktion. Als nächstes kehren wir zu unserer base.html zurück und geben zwei weitere Container für eine Schaltfläche und Überprüfungsergebnisse mit den oberen Rändern an, die als 5 definiert sind. Fügen Sie einen Block in einen Container und auch in die index.html ein.

Block zur ÜberprüfungBild von U.Today

Für den nächsten Schritt wählen wir eine Schaltfläche aus der Bootstrap-Bibliothek aus und platzieren sie in base.html in einem Formular. Geben Sie im Formular unsere Funktion “Überprüfen” als Aktion ein und hängen Sie sie an die Funktion “Überprüfen” im Hauptskript an. Kehren Sie anschließend zum Hauptskript zurück und fügen Sie die Überprüfungsfunktion aus dem Skript zum Erstellen von Blöcken in die Überprüfungsfunktion ein. Gehen Sie zur base.html. Hier möchten wir eine ‘for’-Schleife für jede Variable im’ results’-Array erstellen. In der ‘for’-Schleife erstellen wir ein div, das die Überprüfungsergebnisse anzeigt.

Überprüfung für SchleifeBild von U.Today

Testen der dApp

Da haben Sie es also. Kehren Sie zu Ihrem Browser zurück und aktualisieren Sie die Seite. Von nun an kann unsere dApp Transaktionen in der Blockchain aufzeichnen und überprüfen, ob einer der Blöcke gehackt wurde. Um sicherzustellen, dass alles funktioniert, senden Sie eine Transaktion mit den Daten Ihrer Wahl und wechseln Sie in den Blockchain-Ordner. Sie sollten dort eine neue Textdatei mit dem von Ihnen angegebenen Zahler, Betrag und Zahlungsempfänger sowie dem Hash des vorherigen Blocks haben.

dApp-SchnittstelleBild von U.TodayNeuer BlockBild von U.Today

Kehren Sie zum Browser zurück, machen Sie weitere Blöcke und starten Sie den Überprüfungsprozess. Sie werden sehen, dass an diesem Punkt alle Blöcke echt sind. Es ist Zeit, unseren Knoten zu hacken! Wechseln Sie in den Blockchain-Ordner und ändern Sie einen der Blöcke, die Sie vor dem letzten erstellt haben. Kehren Sie nun wieder zum Browser zurück und überprüfen Sie unsere Kette noch einmal. Wie Sie sehen können, signalisiert unser Knoten, dass ein Block beschädigt ist, und wir sollten den Daten dieser Blockchain nicht vertrauen.

Gefälschte BlöckeBild von U.Today

Zusammenfassung

Zusammenfassend haben wir Ihnen heute eine einfache dezentrale Anwendung auf einer lokal betriebenen Blockchain gezeigt. Das dezentrale Erstellen von Anwendungen hat seine Funktionen, ähnelt aber auch dem Erstellen regulärer Anwendungen. Schließlich sind Anwendungen für den Endbenutzer gedacht, sodass man an der Oberfläche wahrscheinlich keinen großen Unterschied feststellen würde.

Wenn Sie sich mit dem Codieren von dApps befassen, müssen Sie die Prinzipien der Blockchain-Technologie kennen und verstehen, wie man sowohl für das Frontend als auch für das Backend schreibt. Wenn Sie über ein derart fortgeschrittenes Wissen verfügen, sollten Sie eine schnelle und einfache Programmiersprache wie Python wählen. Mit Python können Sie sowohl einen kompakten Code erstellen als auch einen lokalen Server problemlos ausführen. Letzteres ist sehr wichtig, da Sie vor der Veröffentlichung alle erforderlichen Sicherheitsüberprüfungen durchführen möchten, da die Blockchain unveränderlich ist.

Wir hoffen, dass dieses Tutorial Ihnen sehr geholfen hat, sich mit dApps vertraut zu machen. Genießen!