Jak zbudować Blockchain w Pythonie?

Jeśli chcesz dowiedzieć się, jak zbudować blockchain, to dobrze trafiłeś. Zanurzmy się głębiej, aby dowiedzieć się, jak zbudować łańcuch bloków w Pythonie.

Jest mnóstwo artykułów na temat blockchain, ale nie wszystkie z nich mówią o budowaniu łańcucha blokowego od zera. Jako programista teorie są ważne, ale musisz także stworzyć łańcuch bloków, aby całkowicie zrozumieć stojącą za nim koncepcję.

Podstawową ideą blockchainów jest ich zdecentralizowany charakter. Będziesz zafascynowany faktem, jak to wszystko działa w środku. Blockchain może wydawać się prosty, ale wewnątrz jest wiele protokołów i algorytmów, które to umożliwiają. Zamierzamy użyć Pythona do stworzenia łańcucha bloków od podstaw.

Możesz także zapisać artykuł i dodać do zakładek jako „Jak zbudować nasz łańcuch bloków”. Uwierz mi; artykuł pomoże ci na dłuższą metę.

Nigdy nie słyszałeś o blockchain? Następnie sprawdź bezpłatny kurs 101Blockchain. Jeśli chcesz rozwinąć swoją karierę, sprawdź kurs Certified Enterprise Blockchain, w którym dowiesz się, jak działa blockchain dla przedsiębiorstw. Zacznijmy.

Czy jesteś początkującym w Blockchain? Zapisz się na darmowy kurs Blockchain i rozpocznij swoją przygodę z Blockchain już teraz.

Jak zbudować łańcuch bloków

Najlepszym sposobem nauczenia się czegokolwiek jest nauka przez działanie. Aby upewnić się, że jesteś na tej samej stronie, co ja, sprawdźmy najpierw wymagania. Opiszemy również pokrótce blockchain, abyśmy oboje byli na tej samej stronie.

Jak zbudować łańcuch bloków w Pythonie

Wymaganie

Podstawowym wymogiem, aby postępować zgodnie z instrukcją, jest umiejętność kodowania. Jeśli nigdy w życiu nie kodowałeś, ten przewodnik nie jest dla Ciebie. Polecam zapoznanie się z różnymi kursami dla początkujących, które są dostępne online. Polecam EdX, Udacity i Coursera, aby uzyskać najlepsze wrażenia z nauki.

Jesteś już programistą? W takim razie powinieneś wiedzieć o podstawowym Pythonie. Pomoże Ci również w śledzeniu samouczka „Jak zbudować łańcuch bloków”.

Przeczytaj teraz: Quorum Blockchain Ultimate Guide


Stworzyliśmy samouczek, aby każdy mógł go śledzić. Jeśli więc nie wiesz i chcesz się nauczyć, jak zbudować blockchain od podstaw, możesz to zrobić!

Jeśli nie znasz języka Python, nie martw się, ponieważ jest on łatwy do opanowania. Sprawdź Dokumentacja Pythona zaczynać.

W samouczku będziemy używać języka Python 3.6+. Jeśli zdecydujesz się użyć innych wersji Pythona, być może będziesz musiał przeprowadzić więcej badań, aby kod działał. Na potrzeby samouczka zalecam zainstalowanie używanej przeze mnie wersji.

Na koniec powinieneś również wiedzieć o HTTP – protokole używanym do komunikacji między dwiema stronami w Internecie.

Instalowanie Pythona przy użyciu pip

Musisz zainstalować Pythona za pomocą pip. Musisz także zainstalować wspaniałą bibliotekę Requests i Flask. Aby to zrobić, po prostu uruchom poniższe polecenie.

$ pip install Flask == 0.12.2 żądań == 2.18.4

Jeśli korzystasz ze środowiska Windows, możesz bezpośrednio przejść do python.org, aby pobrać najnowszą wersję Pythona.

Jeśli chodzi o mnie, pobrałem Pythona 3.8.1 – najnowszą kompilację w momencie pisania samouczka.

W przypadku IDE wolę używać PyCharm. Używam wersji społeczności Python do samouczka. Możesz używać dowolnego wybranego środowiska IDE. Inną świetną alternatywą jest Visual Studio Code – darmowe, zintegrowane środowisko programistyczne o otwartym kodzie źródłowym.

Ostatnim narzędziem, którego będziesz potrzebować, jest Postman – klient HTTP. Alternatywnie możesz też użyć cURL.

Polecam również zainstalowanie środowiska wirtualnego, aby stworzyć zupełnie inne środowisko dla swojego rozwoju. Możesz śledzić ten przewodnik aby ustawić go poprawnie.

Blockchain Revisited

Zanim zaczniemy budować blockchain, musimy odświeżyć naszą ideę blockchain. Pomoże nam to pozostać na tej samej stronie.

Blockchain to technologia rozproszonej księgi, w której partnerzy mogą uczestniczyć, wchodzić w interakcje i wykonywać transakcje bez potrzeby scentralizowanej jednostki. Każdy peer posiada kopię księgi, co uniemożliwia hakerom dokonywanie oszustw w systemie. Kluczowe cechy blockchain obejmują przejrzystość, niezmienność i bezpieczeństwo. Wykorzystuje zaawansowane algorytmy kryptowalut, aby zapewnić bezpieczeństwo danych. Ponadto, aby osiągnąć konsensus, sieć blockchain będzie wykorzystywać algorytmy konsensusu, takie jak Proof-of-Work, Proof-of-Stake i tak dalej.

Przeczytaj także: Blockchain dla początkujących: przewodnik dla początkujących

Pierwsze kroki z budowaniem łańcucha blokowego

Po wykonaniu wszystkich wymaganych instalacji jesteśmy teraz gotowi, aby rozpocząć od naszego samouczka „Jak zbudować łańcuch bloków”.

Aby rozpocząć, musisz utworzyć plik blockchain.py.

1. Tworzenie łańcucha blokowego

Pierwszym krokiem jest stworzenie funkcjonalnego rozwiązania opartego na łańcuchu bloków. Najpierw musimy stworzyć klasę Blockchain. Tam stworzymy konstruktora, który zainicjuje łańcuch i listę transakcji. Lista łańcuchów będzie przechowywać nasz łańcuch bloków, podczas gdy transakcje będą przechowywane w tablicy current_transacations.

def __init __ (self): self.chain = [] self.current_transactions = []

Następnie musimy stworzyć funkcję new_block, która posłuży do stworzenia nowych bloków, a następnie doda je do istniejącego łańcucha. Kod funkcji new_block jest następujący:

def new_block (self): # Ta funkcja tworzy nowe bloki, a następnie dodaje je do istniejącej przepustki

Metoda new_transcaction utworzy nową transakcję, a następnie doda transakcję do już istniejącej listy transakcji.

def new_transaction (self): # Ta funkcja dodaje nową transakcję do już istniejących transakcji pass Mamy również funkcję hash, która jest używana do tworzenia skrótu dla bloku. @staticmethod def hash (block): # Używane do haszowania bloku

Ostatnia funkcja, którą utworzymy last_block. Służy do wywołania ostatniego bloku w łańcuchu.

Możemy tu też stworzyć jeszcze trzy funkcje.

  • register_node () → Aby zarejestrować nowy węzeł i dodać go do sieci
  • valid_proof () → Zapewni, czy przesłany blok do łańcucha rozwiązuje problem
  • valid_chain () → Sprawdzi, czy kolejne bloki w łańcuchu są prawidłowe, czy nie.

Schemat dla blockchain.py wygląda jak poniżej.

class Blockchain (obiekt): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): # Ta funkcja tworzy nowe bloki, a następnie dodaje do istniejącej przepustki łańcuchowej def new_transaction (self): # Ta funkcja dodaje nową transakcję do już istniejących transakcji pass @staticmethod def hash (block): # Używane do haszowania bloku @property def last_block (self): # Wywołuje i zwraca ostatni blok przebiegu

Klasa Blockchain zarządza całym łańcuchem. Definicje zdefiniowane w ramach klasy zarządzają różnymi działaniami w łańcuchu bloków.

Przejdźmy przez każdą z poniższych metod.

Przeczytaj teraz: Co to jest fragmentowanie łańcucha bloków: wprowadzenie do rozwiązania do skalowania łańcucha bloków

Struktura bloku

Blok zawiera istotne informacje o transakcjach i łańcuchach. Każdy blok w łańcuchu będzie zawierał następujące informacje

  • indeks
  • timestamp w czasie uniksowym
  • lista transakcji
  • dowód
  • Hash poprzedniego bloku

Większość informacji w tym bloku nie wymaga wyjaśnień. Tutaj dwie kluczowe zmienne to previous_hash, który zawiera wartość hash poprzedniego bloku. Jest to ważne, ponieważ zapewnia, że ​​łańcuch bloków jest niezmienny i żaden złośliwy aktor nie może aktualizować, usuwać ani dodawać żadnych danych do łańcucha.

Przeczytaj teraz: Dlaczego Blockchain zmieni świat?

Dodawanie transakcji do bloku

Po zrozumieniu struktury bloku nauczmy się teraz, jak dodać transakcję do bloku. Kod do tego jest jak poniżej.

def new_transaction (self): # Ta funkcja dodaje nową transakcję do już istniejących transakcji """Spowoduje to utworzenie nowej transakcji, która zostanie wysłana do następnego bloku. Będzie zawierał trzy zmienne, w tym nadawcę, odbiorcę i kwotę """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient ‘amount’: amount,}) return self.last_block [‘index’] + 1 Jak widać, po prostu dodaje do listy current_transaction obiekt zawierający trzy zmienne → nadawca, odbiorca, kwota.

Po zakończeniu dodawania metoda wysyła indeks bloku do łańcucha. To kolejny blok, który zostanie wydobyty.

Tworzenie nowych bloków

Zanim zaczniemy tworzyć nowe bloki, musimy stworzyć blok Genesis. Aby to zrobić, musimy użyć prostego wiersza kodu, jak poniżej.

self.new_block (previous_hash = 1, proof = 100)

Ta linia powinna zostać dodana do twojej klasy Blockchain.

W przypadku metody new_block () musisz wysłać dwie zmienne jako jej parametry. Zawiera dowód i previous_hash.

Przyjrzyjmy się teraz poniższej metodzie new_block ().

def new_block (self, proof, previous_hash = None): # Ta funkcja tworzy nowe bloki, a następnie dodaje do istniejącego łańcucha """Ta metoda będzie zawierała dowód dwóch parametrów, poprzedni hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘dowód’: dowód, previous_hash: previous_hash lub self.hash (self.chain [-1]),}

# Ustaw aktualną listę transakcji na pustą.

   self.current_transactions = [] self.chain.append (blok) zwraca blok

Wyjaśnijmy kod nowego_bloku. Tworzymy listę bloków, która zawiera trzy ważne parametry. Po ich zdefiniowaniu piszemy również kod, aby zresetować listę current_transaction, a następnie dołączamy blok do łańcucha. Wywołana metoda new_block zwraca blok.

Przeczytaj teraz: przewodnik dla początkujących: co to jest Ethereum Classic?

Zdefiniujmy również poniżej metodę last_block.

@własność

def last_block (self):

# Wywołuje i zwraca ostatni blok łańcucha

return self.chain [-1]

Ponadto kod metody hash () jest następujący:

def hash (block): # Używane do haszowania bloku """Poniższy kod utworzy blokowy hash SHA-256, a także zapewni uporządkowanie słownika""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Jeśli połączysz cały kod do tej pory, otrzymamy następujący blockchain.py. Sprawdź to poniżej.

class Blockchain (obiekt): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def new_block (self, proof, previous_hash = None): #This funkcja tworzy nowe bloki, a następnie dodaje do istniejącego łańcucha """Ta metoda będzie zawierała dowód dwóch parametrów, poprzedni hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘dowód’: dowód, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set aktualna lista transakcji jest pusta. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): # Ta funkcja dodaje nową transakcję do już istniejących transakcji """Spowoduje to utworzenie nowej transakcji, która zostanie wysłana do następnego bloku. Będzie zawierał trzy zmienne, w tym nadawcę, odbiorcę i kwotę """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient, ‘amount’: amount,}) return self.last_block [‘index’] + 1 @staticmethod def hash (block): # Używane do haszowania blok """Poniższy kod utworzy blokowy hash SHA-256, a także zapewni uporządkowanie słownika""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @property def last_block (self): # Wywołuje i zwraca ostatni blok łańcucha return self.chain [ -1]

Dowód wykonania pracy

Naszym kolejnym krokiem w budowaniu blockchain.py jest implementacja Proof-of-Work.

Więc co to jest dowód pracy? Jest to metoda konsensusu wykorzystywana do dodawania nowych bloków do łańcucha. Stanowi wyzwanie dla górnika, a gdy górnik rozwiąże problem, blok jest następnie weryfikowany. W zamian górnik otrzymuje nagrodę zależną od złożoności problemu.

Bitcoin’s Proof of Work jest znany jako Hashcash. Zapewnia, że ​​konsensus sieci bitcoin działa zgodnie z przeznaczeniem.

Przeczytaj także: Algorytmy konsensusu: źródło technologii Blockchain

Zdefiniujmy metodę proof_of_work (). Metoda będzie częścią klasy Blockchain.

def proof_of_work (self, last_proof): """W tej metodzie zaimplementowano algorytm konsensusu. Przyjmuje dwa parametry, w tym self i last_proof""" dowód = 0, podczas gdy self.valid_proof (last_proof, dowód) jest fałszywy: dowód + = 1 zwrot dowodu @staticmethod def valid_proof (last_proof, dowód): """Ta metoda sprawdza poprawność bloku""" guess = f ‘{last_proof} {dowód}’. encode () guess_hash = hashlib.sha256 (przypuszczenie) .hexigest () return guess_hash [: 4] == "0000"

Pierwsza metoda proof_of_work jest prosta; po prostu ustawia dowód na 0, a następnie uruchamia pętlę while, aby uruchomić metodę valid_proof. Jeśli to fałsz, dodaj jeden do dowodu.

Możesz zwiększyć trudność hasha, dodając więcej zer.

To prowadzi nas do końca naszego Blockchain.py. Nasz kod jest przedstawiony poniżej.

class Blockchain (obiekt): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def proof_of_work (self, last_proof): """W tej metodzie zaimplementowano algorytm konsensusu. Przyjmuje dwa parametry, w tym self i last_proof""" dowód = 0, podczas gdy self.valid_proof (last_proof, dowód) jest fałszywy: dowód + = 1 zwrot dowodu @staticmethod def valid_proof (last_proof, dowód): """Ta metoda sprawdza poprawność bloku""" guess = f ‘{last_proof} {dowód}’. encode () guess_hash = hashlib.sha256 (przypuszczenie) .hexigest () return guess_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): # Ta funkcja tworzy nowe bloki, a następnie dodaje je do istniejącego łańcucha """Ta metoda będzie zawierała dowód dwóch parametrów, poprzedni hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘dowód’: dowód, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set aktualna lista transakcji jest pusta. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): # Ta funkcja dodaje nową transakcję do już istniejących transakcji """Spowoduje to utworzenie nowej transakcji, która zostanie wysłana do następnego bloku. Będzie zawierał trzy zmienne, w tym nadawcę, odbiorcę i kwotę """ self.current_transactions.append ({‘nadawca’: nadawca, ‘odbiorca’: odbiorca, ‘kwota’: kwota,})

return self.last_block [„indeks”] + 1

@staticmethod

def hash (blok):

# Używany do haszowania bloku

„” ”Poniższy kod utworzy blokowy hash SHA-256, a także zapewni uporządkowanie słownika” ””

block_string = json.dumps (block, sort_keys = True) .encode ()

return hashlib.sha256 (block_string) .hexdigest ()

@własność

def last_block (self):

# Wywołuje i zwraca ostatni blok łańcucha

return self.chain [-1]

2. Integracja API

Świetnie, tworzymy blockchain, który działa! Teraz, aby efektywnie z niego korzystać, musimy stworzyć API (Application Programming Interface).

Aby to zrobić, użyjemy popularnego Python Framework: Flask.

Flask to mikro-framework, co oznacza, że ​​jest lekki i możesz dodawać potrzebne biblioteki. Umożliwia także łatwe tworzenie punktów końcowych funkcji Pythona.

Aby stworzyć interfejsy API, musimy najpierw upewnić się, że nasz łańcuch bloków może akceptować żądania przez HTTP. Aby to zrobić, musimy stworzyć więcej metod.

Teraz zmodyfikujemy blockchain.py.

# Tworzenie węzła aplikacji app = Flask (__ name__) node_identifier = str (uuid4 ()). Replace (‘-‘, ”) # Inicjalizacja blockchain blockchain = Blockchain () @ app.route (‘/ mine’, methods = [ ‘GET’]) def mine (): return "Wydobywanie nowego bloku" @ app.route (‘/ transaction / new’, methods = [‘POST’]) def new_transaction (): return "Dodanie nowej transakcji" @ app.router (‘/ chain’, methods = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} return jsonify (odpowiedź) , 200, jeśli __name__ == ‘__main__’: app.run (host ="0.0.0.0", port = 5000)

Kod jest w większości oczywisty. Najpierw wykonujemy inicjację węzła. Następnie tworzymy losowy węzeł. Po zakończeniu inicjalizujemy naszą klasę Blockchain. Po zakończeniu musimy utworzyć trzy punkty końcowe, jak poniżej.

  • / mine endpoint
  • / transakcje / nowy punkt końcowy
  • / punkt końcowy łańcucha

Wreszcie uruchamiamy serwer na porcie 5000.

Aplikacja jest już prawie utworzona. Wystarczy, że stworzymy metodę klasy transakcji.

@ app.route (‘/ transaction / new’, methods = [‘POST’]) def new_transaction (): values ​​= request.get_json () # Sprawdzanie, czy wymagane dane są, czy nie są wymagane = [‘sender’, ‘ odbiorca ‘,’ kwota ‘] jeśli nie wszystkie (k w wartościach dla k w wymaganym): zwraca’ Brakujące wartości ‘, 400 # tworzenie nowego indeksu transakcji = blockchain.new_transaction (wartości [‘ nadawca ‘], wartości [‘ odbiorca ‘ , wartości [‘amount’]]) response = {‘message’: f’Transaction ma zostać dodany do Block No. {index} ‘} return jsonify (response), 201

Przeczytaj także: Oto, co musisz wiedzieć o dowodzie działania Blockchain

Punkt końcowy wyszukiwania

Ostatnim punktem końcowym, który zamierzamy utworzyć, jest punkt końcowy wyszukiwania. Aby to zrobić, musimy upewnić się, że wykonuje następujące trzy rzeczy.

  • Obliczenie dowodu pracy
  • Wykuj nowy łańcuch bloków, a następnie dodaj go do łańcucha
  • Nagradzaj górnika za jego pracę

@ app.route (‘/ mine’, methods = [‘GET’]) def mine (): """Tutaj robimy dowód działania algorytmu pracy""" last_block = blockchain.last_block last_proof = last_block [‘dowód’] dowód = blockchain.proof_of_work (last_proof) # nagradzanie górnika za jego wkład. 0 określa, że ​​nowa moneta została wydobyta blockchain.new_transaction (sender ="0", odbiorca = identyfikator_węzła, kwota = 1,) # teraz utwórz nowy blok i dodaj go do łańcucha previous_hash = blockchain.hash (last_block) block = blockchain.new_block (dowód, previous_hash) response = {‘message’: ‘Nowy blok został sfałszowany ‘,’ indeks ‘: blok [‘ indeks ‘],’ transakcje ‘: blok [‘ transakcje ‘],’ dowód ‘: blok [‘ dowód ‘],’ poprzedni_hash ‘: blok [‘ poprzedni_hash ‘]} powrót jsonify (odpowiedź), 200

Przeczytaj teraz: Przewodnik dla początkujących: Co to jest AION? Pierwsza na świecie sieć Blockchain trzeciej generacji

3. Interakcja Blockchain

Ostatnim krokiem jest interakcja z blockchainem. Zamierzamy użyć Postmana do interakcji z siecią blockchain za pomocą właśnie utworzonego API.

Uruchom poniższy kod w konsoli Python

python blockchain.py

Wniosek

To prowadzi nas do końca naszego poradnika Jak zbudować łańcuch bloków. Mam nadzieję, że powyższe kroki i kody pomogą Ci zbudować Blockchain w Pythonie. Tak więc, jeśli jesteś nowicjuszem i aspirujesz do budowania kariery w Blockchain, sugerujemy, abyś rozpoczął swoją karierę w blockchain od naszego bezpłatnego kursu z podstaw Blockchain. Wybierz nas jako swojego partnera do nauki, a będziemy Cię mieć, dopóki nie znajdziesz wymarzonej pracy.

Co więc myślisz o blockchain i jego implementacji? Skomentuj poniżej i daj nam znać.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
Adblock
detector
map