Jak zbudować aplikację Blockchain w Pythonie

Będąc programistą blockchain, będziesz wiedział znacznie więcej niż przeciętni ludzie o tym, jak działają rzeczy pod maską. Będziesz zaznajomiony z blokami, skrótami, węzłami, transakcjami, różnymi typami danych i wieloma innymi. Jeśli jednak masz pomysł, jak zaimplementować blockchain w określonym środowisku z przypadkowymi użytkownikami, nie będziesz dzielić się z nimi całą swoją mądrością, nie mówiąc już o zmuszaniu ich do nauczenia się, jak każda operacja jest wykonywana. Współcześni użytkownicy są rozpieszczani prostotą i interfejsami z doskonałymi interfejsami użytkownika, które zapewniają doskonałe wrażenia użytkownika. Jeśli chcesz, aby Twój projekt blockchain był bardziej atrakcyjny, powinieneś przynajmniej uczynić go łatwym w użyciu. Tutaj do gry wchodzą zdecentralizowane aplikacje lub dApps.

Zdecentralizowane aplikacje to nowy trend w tworzeniu oprogramowania. Stały się popularne po szaleństwie ICO, które rozpoczęło się w 2017 roku. Główną charakterystyczną cechą dApps jest to, że w pełni polegają na łańcuchu bloków i dlatego nie mogą być kontrolowane ani zamykane przez żadną osobę trzecią. Ponadto dApps może również wykorzystywać inteligentne kontrakty, o których mówiliśmy wcześniej, do wykonywania różnych operacji w bezpieczny i autonomiczny sposób. W przeciwnym razie dApps przypomina scentralizowane aplikacje i może być wszystkim, od giełd po gry. Możesz sprawdzić niektóre z nich z naszej listy 10 dApps tutaj.

Chociaż istnieją dedykowane języki programowania dla inteligentnych kontraktów i programowania dApp, takie jak Solidity, Vyper i Simplicity, do tego celu można również użyć innych języków. Na potrzeby tego samouczka wybraliśmy Python, ponieważ jest to jeden z najbardziej wszechstronnych i wszechstronnych języków. Dziś pokażemy Ci prostą aplikację stworzoną w Pythonie, uruchomimy ją i wyjaśnimy, jak działa. Nie odkładajmy tego dłużej i zabierzmy się do pracy!

Struktura i właściwości pliku dApp

Najpierw nakreślmy, jak powinien wyglądać dApp, i przejrzyjmy jego elementy. Istnieją dwie główne części dApp:

  • Przód

  • Back end

Interfejs użytkownika zawiera wszystko, co jest wyświetlane użytkownikowi. Na przykład, kiedy przeglądasz swój profil na Facebooku, wchodzisz w interakcję z interfejsem Facebooka. Zwykle jest napisany przy użyciu HTML, CSS i JavaScript, ale są na to inne sposoby. Zaplecze jest jak silnik samochodu. Nikt, poza mechaniką, nie patrzy na to, ale to sprawia, że ​​wszystko działa. Podczas gdy scentralizowane aplikacje korzystają z usług hostingowych i różnych frameworków, takich jak Django i NodeJS, zdecentralizowane aplikacje zamiast tego używają łańcuchów bloków. W obu przypadkach komunikacja między frontendem & backend odbywa się za pośrednictwem wiadomości w formacie JSON.

Powinniśmy również zauważyć, że ponieważ zadania backendu mają miejsce w łańcuchu bloków, gdzie wszystko jest niezmienne, inżynier budujący dApp powinien wykonać wiele dokładnych kontroli swojego projektu, aby upewnić się, że nie ma luk w kodzie. To sprawia, że ​​budowanie dApps wygląda bardziej jak tworzenie sprzętu, a nie oprogramowania, które można modyfikować w locie. Z drugiej strony, jeśli dApp jest doskonale napisany, jest praktycznie nie do złamania, ponieważ nie ma centralnego punktu awarii. Po drugie, kod dla dApps jest zwykle publikowany jako open-source. W przeciwnym razie społeczność będzie miała problemy z zaufaniem i uniknie korzystania z niektórych aplikacji.

Tworzenie zaplecza

Teraz, gdy wiemy, że dApp opiera się na łańcuchu bloków, utwórzmy go lokalnie w Pythonie. Jest to bezpieczniejsze podejście do uczenia się i testowania rzeczy, ponieważ nie chcemy obciążać prawdziwej sieci niepotrzebnym kodem. Co więcej, ta demonstracja jest bardziej skłonna do pokazania zasad działania – rzeczywiste aplikacje dApps są znacznie bardziej złożone.

Ponieważ wszystko wydarzy się na twoim komputerze, łańcuch bloków zostanie fizycznie umieszczony na twoim dysku twardym, tworząc zasadniczo węzeł. W tym celu utwórz folder w dowolnym miejscu i nazwij go „Projekt”. W folderze stwórzmy kolejny, nazwijmy go „blockchain” i na stałe zakodujmy tam pierwszy blok. Utwórz plik tekstowy i otwórz go w wybranym edytorze kodu. Będziemy używać Atom.

Inicjalizacja bloku genezy

W pierwszym bloku określimy, że płatnik zapłacił odbiorcy tysiąc monet. Jak zapewne pamiętasz z naszego artykułu o mocy mieszania, głowa każdego bloku jest haszowana, a hash każdego bloku jest dołączany do następnego, aby upewnić się, że sieć nie została naruszona. Blok Genesis nie ma przed sobą bloku, więc będzie pusty hash.

Blok GenesisZdjęcie: U.Today

Następnie przejdźmy do naszego folderu z łańcuchem bloków, stwórzmy plik ze skryptem. Zacznij od zaimportowania biblioteki JSON, ponieważ będziemy używać tego formatowania. Kontynuuj z „if __name__ == "__Główny__": ”, Aby umożliwić weryfikację, czy skrypt zostanie uruchomiony z konsoli, czy nie. Ten krok pomoże Ci podczas importowania. Aby nasz lokalny łańcuch bloków działał, powinniśmy napisać funkcję, która tworzy nowe bloki. Ponadto powinna istnieć funkcja sprawdzająca, czy łańcuch bloków został zmieniony, czy nie.

Pisanie nowych bloków

Zakodujmy funkcję, aby utworzyć następujące bloki w łańcuchu. Aby to zrobić, musimy określić wszystkie typy danych, które zapisaliśmy w bloku genesis. Następnie tworzymy instrukcję „with” z funkcją, aby utworzyć nowy plik, aby kod w nowych blokach był bardziej odpowiedni do czytania, określ wcięcie. Po zakończeniu możemy uruchomić skrypt i pobrać plik z naszym blokiem testowym.

Nowy blok testowy & amp; ScenariuszZdjęcie: U.Today

Funkcja testowa działa! Teraz możemy go rozszerzyć, aby odbierał dane i zapisywał je w kolejnych blokach. Aby to zrobić, umieścimy w funkcji argumenty odbiorcy, kwoty, płatnika i p_hash (hash poprzedniego bloku). T Następnie musimy sprawić, by funkcja zapisała bloki w odpowiednim folderze. W tym celu zaimportuj system operacyjny do pracy z systemem plików komputera. Następnie w funkcji zdefiniujmy katalog, który utworzyliśmy dla naszych bloków za pomocą „os.curdir”. Następnie określ tę deklarację w instrukcji, która zapisuje nowy plik.

Idąc dalej, nie możemy pozostawić pliku testowego oznaczonego tak, jak jest, chcemy, aby każdy nowy blok był nazwany w kolejności. Ponieważ naszym blokiem genezy jest „0”, następny blok powinien mieć wartość 1 i tak dalej. Ten jest raczej prosty, nasza funkcja powinna być w stanie przeanalizować podstawowy katalog blockchain. Znajdź najnowszy numer ostatniego bloku, zwiększ go o jeden i nazwij następny blok. Aby uzyskać wszystkie bloki, użyjemy „listdir” systemu operacyjnego i dostarczymy do niego naszą zmienną katalogową łańcucha bloków. Pamiętaj, że „listdir” nie sortuje bloków według nazw, więc w tym przypadku najnowszy plik może nie być tym, czego potrzebujemy. Dlatego musimy użyć funkcji list składanych, aby zwrócić liczby całkowite dla wszystkich nazw plików i posortować je za pomocą funkcji „sortowania”. Na koniec nauczmy nasz łańcuch bloków, jak oznaczać bloki, zwracając nazwę ostatniego bloku i zwiększając go o jeden. Upewnij się, że konwertujesz etykietę z powrotem na łańcuch i dodajesz nazwę bloku do funkcji „with”.

Funkcja pobierania blokówZdjęcie: U.Today

Haszowanie

Teraz za każdym razem, gdy uruchamiasz skrypt, otrzymasz nowy blok. Jednak nadal nie jest to łańcuch bloków, ponieważ węzły powinny również być w stanie sprawdzić integralność, a tym samym bezpieczeństwo danych. Każdy z bloków będzie miał skrót poprzedniego. Zacznijmy od haszowania danych w blokach. Najpierw zaimportujemy moduł „hashlib”. Następnie utworzymy funkcję, która odczyta zawartość bloku, przepuści ją przez algorytm mieszający SHA-256 i zwróci hash. Pamiętaj, że w tym miejscu należy określić lokalizację folderu „blockchain”, w przeciwnym razie funkcja nie znajdzie bloków. W funkcji tworzącej bloki zdefiniuj zmienną dla poprzedniego skrótu, która uruchomi naszą funkcję haszującą dla poprzedniego bloku. Kiedy to testujemy, widzimy, że nowy blok zawiera hash poprzedniego. Możesz łatwo zweryfikować hash, kopiując zawartość bloku numer 1 do internetowego generatora SHA256 i porównując wyniki.

Funkcja haszowaniaZdjęcie: U.Today

Weryfikacja blokowa

Do tej pory mamy funkcję tworzenia bloków i funkcję haszującą. Czas wprowadzić algorytm weryfikacji dla naszego węzła. Funkcja, którą stworzymy, będzie mogła pobrać listę wszystkich plików w łańcuchu bloków, odczytać skróty poprzedniego bloku zaczynając od drugiego bloku, ponownie wygenerować hash każdego poprzedniego bloku, porównać je i zwrócić wynik.

Zaczniemy od zadeklarowania zmiennej, która pobiera wszystkie pliki z katalogu „blockchain”, zmiennej, która zwraca listę plików i takiej, która sortuje bloki w kolejności rosnącej. Następną rzeczą, którą powinniśmy zrobić, jest umożliwienie funkcji iteracji po blokach i odczytywania skrótów poprzednich bloków. Można to zrobić za pomocą pętli „for”, która ładuje wszystkie dane z bloku i zwraca tylko to, co odpowiada „hash”. Teraz do ponownego utworzenia skrótu, aby zweryfikować go względem tego, co otrzymuje funkcja. Wewnątrz pętli „for” zostawimy zmienną „true_h”, która uruchomi funkcję haszującą dla poprzedniego bloku. Ostatnim krokiem jest porównanie hashów za pomocą instrukcji „if / else”. Wyniki zostaną zapisane w tablicy, którą dla nich ustawiliśmy i wszystko zostanie pokazane w konsoli.

Weryfikacja blokowaZdjęcie: U.Today

Po wyczyszczeniu niektórych nadmiarowości mamy lokalny łańcuch bloków zakodowany w Pythonie.

Budowanie frontendu

Mimo że udało nam się umieścić wszystkie niezbędne funkcje w mniej niż 60 wierszach kodu, dla przeciętnego użytkownika nadal wyglądałoby to jak jakiś bełkot. Dlatego musimy uczynić go łatwym do zrozumienia i używania z interfejsem front-end. W tym samouczku będziemy używać frameworka Flask wraz z HTML, CSS i JavaScript.

Przygotowanie środowiska

W katalogu głównym projektu utwórz folder dla środowiska wirtualnego, które będzie pełniło rolę zaplecza. Jeśli nie zrobiłeś tego wcześniej, pobierz Pyton z oficjalnej strony lub za pomocą wiersza poleceń w systemie operacyjnym (używamy homebrew w OSX) i zainstaluj go. Idąc dalej, zainstaluj Virtualenv & Pip za pomocą odpowiednich poleceń wiersza poleceń. Następnie uruchom środowisko wirtualne z wiersza poleceń w folderze „UI”, otrzymasz nowy folder, jeśli wszystko zostało wykonane poprawnie. Czas go aktywować i zainstalować kolbę przez Pip.

Tworzenie i aktywacja venvZdjęcie: U.Today

Umieśćmy nasz back-end obok frontendu. Wytnij folder „blockchain” i skrypt i wklej je w folderze „app” w głównym katalogu. W folderze zaplecza musimy utworzyć główny plik skryptu.

Tworzenie struktury

W naszym głównym skrypcie powinniśmy najpierw zaimportować Flask i umieścić łącze do nazwy pliku, aby umożliwić Flask odczytanie ścieżek. Powinniśmy również umieścić standardową instrukcję, która sprawdza, czy skrypt jest uruchamiany z konsoli i czy uruchamia naszą aplikację. Pamiętaj, aby dodać „debug”, aby umożliwić ponowne załadowanie Flaska za każdym razem, gdy zmienisz coś w kodzie.

Pusta aplikacjaZdjęcie: U.Today

Jeśli uruchomisz skrypt w tym momencie, zobaczysz, że localhost: 5000 działa, ale wyświetla błąd 404. Jest to normalne, ponieważ aplikacja jest nadal pusta. Zacznijmy od utworzenia funkcji, która sprawi, że nasz węzeł będzie przetwarzał zapytania użytkowników. Wewnątrz (umieszczając „@” przed funkcją) umieścimy funkcję indeksu. Spowoduje to utworzenie struktury lokalnych adresów URL i odpowiadających im funkcji. Funkcja „index” pokaże użytkownikom index.html za pośrednictwem modułu „render_template”.

Aplikacja z funkcją wyświetlaniaZdjęcie: U.Today

Teraz możemy przystąpić do tworzenia naszej struktury HTML. Będą dwa pliki, jeden zawierający informacje ogólne, a drugi dla interfejsu użytkownika pierwszej strony. W base.html zaimportujemy bibliotekę Bootstrap do tworzenia układu za pomocą CSS. Utwórzmy wyśrodkowaną kolumnę i umieśćmy tam blok dla treści w formacie, który może być zinterpretowany przez Jinja z Flask.

Pierwsza strona w htmlZdjęcie: U.Today

Tworzenie interfejsu użytkownika

Nasza aplikacja będzie prostym systemem płatności. Będzie płatnik, odbiorca i kwota przelewu. Wszystko będzie odbywać się za pośrednictwem łańcucha bloków, ale dla użytkownika będzie to wyglądać jak zwykła aplikacja. Kiedy przesyłasz pieniądze przez Internet, zazwyczaj wypełniasz jakiś formularz i przesyłasz go. Bootstrap ma różne formy, które pomagają nam przy niektórych ustawieniach wstępnych. Możesz skopiować ten, z którego wybraliśmy tutaj i skopiuj kod do pliku index.html. We wstępnie napisanej formie będą tylko dwa pola i checkbox, usuniemy checkbox i dodamy pole. Następnie dostosujemy odpowiednie etykiety, identyfikatory, typy i symbole zastępcze. Na koniec przypiszemy do formularza naszą funkcję indeksu. Kiedy użytkownik wprowadzi swoje imię i nazwisko, kwotę i kontragenta, wszystkie informacje muszą zostać gdzieś zapisane, a następnie zawarte w bloku. W tym celu zmieńmy nasze pola wejściowe, dodając „nazwę” i „wartość”. Wartość użyje metody „get”, aby wyodrębnić wszystko, co użytkownik umieści w polu „Płatnik”. Nie zapomnij podać pustego ciągu na wypadek, gdyby użytkownik niczego nie wprowadził.

FormularzZdjęcie: U.Today

Wróćmy do naszego głównego scenariusza. Skrypt powinien być w stanie zrozumieć, czy żądanie wysłane przez użytkownika to POST, czy nie. Aby to umożliwić, zaimportujemy moduł żądania z kolby i określimy metody w naszej aplikacji. W aplikacji zadeklarujemy zmienne, które będą żądać odpowiednich danych z formularza.

Zaktualizowana aplikacjaZdjęcie: U.Today

Idąc dalej, będziemy musieli przekazać wszystkie zebrane dane do nowego bloku. Wymaga to od nas połączenia głównego skryptu z tym, który pisze bloki. Aby to zrobić w instrukcji „if”, która sprawdza typ żądania, umieścimy funkcję „write” z argumentami odpowiadającymi temu, co mamy w naszych blokach.

Łączenie interfejsu użytkownika z zapleczemZdjęcie: U.Today

Teraz, jeśli wrócimy do naszej przeglądarki i prześlemy transakcję, otrzymamy nowy blok w naszym folderze blockchain, który będzie zawierał przekazane przez nas informacje. Jednak widać, że pola nie zostały odświeżone. W tym celu musimy przekierować użytkownika do nowej instancji index.html. Nie zapomnij zaimportować używanych przez nas modułów z Flask. Voila, wszystko odświeża się po złożeniu.

PrzekierowanieZdjęcie: U.Today

Ostatnim akcentem naszego interfejsu użytkownika będzie plik przycisk to sprawia, że ​​nasz węzeł sprawdza wszelkie naruszenia bezpieczeństwa w naszym łańcuchu bloków. Aby to zrobić, utworzymy kolejny routing do weryfikacji z zawartą w nim funkcją. Następnie wróćmy do naszego base.html i określmy dwa dodatkowe kontenery dla przycisku i wyników weryfikacji z górnymi marginesami zdefiniowanymi jako 5. Umieść blok w jednym kontenerze, a także w index.html.

Zablokuj do weryfikacjiZdjęcie: U.Today

W następnym kroku wybierzemy przycisk z biblioteki Bootstrap i umieścimy go w pliku base.html w formularzu. W formularzu umieść naszą funkcję „weryfikuj” jako akcję i dołącz ją do funkcji „sprawdź” w głównym skrypcie. Gdy to zrobisz, wróć do głównego skryptu i umieść w skrypcie funkcję weryfikującą do tworzenia bloków w funkcji sprawdzającej. Przejdź do base.html, tutaj chcemy utworzyć pętlę „for” dla każdej zmiennej w tablicy „results”. W pętli „for” utworzymy element div, który będzie wyświetlał wyniki weryfikacji.

Weryfikacja pętliZdjęcie: U.Today

Testowanie dApp

Więc masz to. Wróć do przeglądarki i odśwież stronę. Od teraz nasza dApp może rejestrować transakcje na łańcuchu bloków i sprawdzać, czy któryś z bloków nie został zhakowany. Aby upewnić się, że wszystko działa, prześlij transakcję z wybranymi przez siebie danymi i przejdź do folderu blockchain. Powinieneś mieć tam nowy plik tekstowy z płatnikiem, kwotą i odbiorcą, którego podałeś oraz hash poprzedniego bloku.

Interfejs dAppZdjęcie: U.TodayNowy blokZdjęcie: U.Today

Wróć do przeglądarki, zrób więcej bloków i uruchom proces weryfikacji. Zobaczysz, że w tym momencie wszystkie klocki są oryginalne. Czas zhakować nasz węzeł! Przejdź do folderu blockchain i zmień jeden z bloków, który utworzyłeś przed ostatnim. Teraz wróć do przeglądarki i jeszcze raz zweryfikuj nasz łańcuch. Jak widać, nasz węzeł sygnalizuje, że jeden blok jest uszkodzony i nie powinniśmy ufać danym tego łańcucha bloków.

Fałszywe blokiZdjęcie: U.Today

streszczenie

Podsumowując, dzisiaj pokazaliśmy Ci prostą zdecentralizowaną aplikację na lokalnie obsługiwanym łańcuchu bloków. Tworzenie aplikacji w sposób zdecentralizowany ma swoje cechy, ale jest też podobne do tworzenia zwykłych aplikacji. W końcu aplikacje są przeznaczone dla użytkownika końcowego, więc na pierwszy rzut oka prawdopodobnie nie byłoby dużej różnicy.

Jeśli zastanawiasz się nad kodowaniem dApps, musisz znać zasady technologii blockchain i rozumieć, jak pisać zarówno dla frontendu, jak i backendu. Przy tak zaawansowanym poziomie wiedzy lepiej wybrać szybki i łatwy język programowania, taki jak Python. Dzięki Pythonowi będziesz w stanie bezproblemowo stworzyć zwarty kod i uruchomić lokalny serwer. To ostatnie jest bardzo ważne, ponieważ chcesz przeprowadzić wszystkie niezbędne kontrole bezpieczeństwa przed publikacją, ponieważ blockchain jest niezmienny.

Mamy nadzieję, że ten samouczek bardzo pomógł ci w zrozumieniu dApps. Cieszyć się!