Hogyan készítsünk blokkláncot Python segítségével?

Tudtad, hogy a Bitcoin a Blockchainre épül? Ma egy blokkláncot fogunk építeni Python segítségével a semmiből.

Mi az a Blockchain?

2008-ban a Bitcoin papír egy Satoshi Nakamoto nevű ismeretlen személy vagy csoport tette közzé. A Bitcoin az elektronikus készpénz peer-to-peer változataként jelent meg, amely lehetővé tette a tranzakciókat anélkül, hogy központosított intézményeken (bankon) keresztül menne keresztül. A legtöbben nem tudják, hogy ugyanebben a cikkben Satoshi meghatározta az információtárolás elosztott módját, amelyet ma Blockchain néven ismernek.

Blockchain technológia

Egyszerűen fogalmazva, a Blockchain egy megosztott, megváltoztathatatlan digitális főkönyv, amely a tranzakciókat számítógépek decentralizált hálózatán tárolja.

A Blockchaint két egyszerű kifejezésre oszthatjuk:

• Blokk: Olyan hely, ahol a tranzakciókat tároljuk
• Lánc: Összekapcsolt rekordok halmaza

Ez a blokkláncot összekapcsolt blokkok láncaként határozza meg, ahol minden blokk meghatározott paraméterekkel végrehajtott tranzakciót tárol.

Minden blokk egy másik blokk tetejére épül, visszafordíthatatlan blokkláncot hozva létre. Más szóval, minden blokk egy másiktól függ. Ez egy robusztus és megváltoztathatatlan rendszerré válik, amelyben a megfelelő jogosultságokkal rendelkező bárki ellenőrizheti az integritást.

A Blockchain egy érdekes funkciókészletet mutat be:

• A történelem megváltoztathatatlansága
• Információs állandóság
• Nincs hiba a tárolt adatokkal

Jelenleg sok rendszer támaszkodik a blokkláncra, például a kriptovaluták, az eszköztranszfer (NFT), és a közeljövőben valószínűleg a szavazás is.

Érdemes megemlíteni, hogy a Python Blockchainnek nem kell egy összetett programnak lennie több ezer sornyi kóddal. Lényegében az egymáshoz kapcsolódó tranzakciók listája lenne.

Természetesen ez egy rövid magyarázat volt, de ha teljes útmutatóra vágyik, készítettünk egy teljes oktatóanyagot a Blockchainről kezdőknek. Mindenképpen nézd meg.

További késedelem nélkül építsünk egy egyszerű blokkláncot Python segítségével.

Blokklánc építése Python segítségével

Mielőtt elkezdené, határozzuk meg, mit fogunk tenni ebben az oktatóanyagban:

• Építsen egyszerű, Python nyelven írt blokklánc rendszert
• Használja blokkláncunkat előre meghatározott tranzakciókkal, amelyeket karakterláncokként ábrázolnak
• Tesztelje Blockchainünk megváltoztathatatlanságát

Nem JSON-t fogunk használni, hanem Python listákat. Ez lehetővé teszi számunkra, hogy leegyszerűsítsük a folyamatot, és a Blockchain kulcsfontosságú fogalmainak alkalmazására összpontosítsunk.

Amire szüksége lesz az oktatóanyag követéséhez:

A Blokk osztály létrehozása

Nyissa meg kedvenc kódszerkesztőjét, és hozzon létre egy main.py fájlt. Ez lesz az a fájl, amellyel dolgozni fogunk.

Most importáld hashlib, egy modul, amely lehetővé teszi egyirányú titkosított üzenetek létrehozását. A kriptográfiai technikák, mint például a hash, a Blockchaint biztonságos tranzakciók létrehozására késztetik.

A hash függvény egy olyan algoritmus, amely bizonyos adatokat (általában egy kódolt karakterláncot) vesz fel, és egy egyedi azonosítót ad vissza, amelyet gyakran „kivonatnak” vagy „aláírásnak” neveznek. Ez az utolsó rész létfontosságú; hash függvénynél a bemenet enyhe eltérése gyökeresen eltérő azonosítót eredményez kimenetként. Ezt a későbbiekben látni fogjuk működés közben.

Egyelőre csak importálja a beépített hashlib modult:

# main.py file
"""
A simple Blockchain in Python
"""

import hashlib

Ez a modul tartalmazza a legtöbb szükséges kivonatolási algoritmust. Ne feledje, hogy a hashlib.sha256() függvényt fogjuk használni.

Most pedig térjünk rá a GeekCoinBlockra, a teljesen eredeti blokklánc nevünkre.

class GeekCoinBlock:
    
    def __init__(self, previous_block_hash, transaction_list):

        self.previous_block_hash = previous_block_hash
        self.transaction_list = transaction_list

        self.block_data = f"{' - '.join(transaction_list)} - {previous_block_hash}"
        self.block_hash = hashlib.sha256(self.block_data.encode()).hexdigest()

Tudom, hogy ez ügyetlen kódrészletet eredményezhet. A következő részben bontsuk fel az egyes részeket.

GeekCoinBlock magyarázat

Először létrehozunk egy GeekCoinBlock nevű osztályt, amely olyan objektumok burkolója, amelyek bizonyos jellemzőkkel (attribútumokkal) és viselkedéssel (módszerekkel) rendelkeznek.

Ezután definiáljuk az __init__ metódust (más néven konstruktort), amely minden alkalommal meghívódik, amikor egy GeekCoinBlock objektumot létrehoznak.

Ennek a módszernek három paramétere van:

• én (minden objektum példánya)
• previous_block_hash (hivatkozás az előző blokkra)
• tranzakció_lista (az aktuális blokkban végrehajtott tranzakciók listája).

Tároljuk az előző hash- és tranzakciólistát, és sztringként létrehozunk egy block_data példányváltozót. Ez nem történik meg valódi kriptovalutákkal, amelyekben az ilyen típusú adatokat újabb hashként tároljuk, de az egyszerűség kedvéért minden adatblokkot karakterláncként tárolunk.

Végül létrehozzuk a block_hash-t, amelyet más blokkok fognak használni a lánc folytatásához. Itt jön jól a hashlib; egyéni hash függvény létrehozása helyett az előre beépített sha256-ot használhatjuk megváltoztathatatlan blokkok készítésére.

Ez a függvény kódolt karakterláncokat (vagy bájtokat) kap paraméterként. Ezért használjuk a block_data.encode() metódust. Ezt követően meghívjuk a hexdigest() függvényt, hogy a kódolt adatokat hexadecimális formátumba adjuk vissza.

Tudom, hogy mindez elsöprő tud lenni, ezért játsszunk a hashlib-el egy Python-héjon.

In [1]: import hashlib

In [2]: message = "Python is great"

In [3]: h1 = hashlib.sha256(message.encode())

In [4]: h1
Out[4]: <sha256 ... object @ 0x7efcd55bfbf0>

In [5]: h1.hexdigest()
Out[5]: 'a40cf9cca ... 42ab97'

In [6]: h2 = hashlib.sha256(b"Python is not great")

In [7]: h2
Out[7]: <sha256 ... object @ 0x7efcd55bfc90>

In [8]: h2.hexdigest()
Out[8]: 'fefe510a6a ... 97e010c0ea34'

Amint láthatja, a bemenet enyhe módosítása, mint például a „Python nagyszerű” és „A Python nem nagyszerű”, teljesen más hash-t eredményezhet. Ez mind a Blockchain integritásához kapcsolódik. Ha egy kis változtatást viszünk be a blokkláncba, a hash drámaian megváltozik. Ez az oka annak, hogy igaz a mondás: „A blokkláncot nem lehet megrontani”.

A blokkosztályunk használata

Később felépítünk egy teljes Blockchain osztályt, de egyelőre használjuk a Block osztályunkat egy blokklánc létrehozására (Blockchain).

Ugyanabban a fájlban hozzon létre néhány tranzakciót, amelyek változókban tárolt egyszerű karakterláncokból állnak, például:

class GeekCoinBlock:
    ...

t1 = "Noah sends 5 GC to Mark"
t2 = "Mark sends 2.3 GC to James"
t3 = "James sends 4.2 GC to Alisson"
t4 = "Alisson sends 1.1 GC to Noah"

Természetesen a GC a GeekCoinra utal

Most készítse el a Blockchain első blokkját a GeekCoinBlock osztály használatával, és nyomtassa ki annak attribútumait. Vegye figyelembe, hogy a genesis blokk previous_hash paramétere (az első blokk, amely megelőzi a többi blokkot) mindig valamilyen tetszőleges karakterlánc vagy hash lesz, ebben az esetben az „első blokk”.

block1 = GeekCoinBlock('firstblock', [t1, t2])

print(f"Block 1 data: {block1.block_data}")
print(f"Block 1 hash: {block1.block_hash}")

Ezután ugyanezt tesszük a második blokkal, de az első blokk hash-ét a previous_hash argumentumként adjuk át.

block2 = GeekCoinBlock(block1.block_hash, [t3, t4])

print(f"Block 2 data: {block2.block_data}")
print(f"Block 2 hash: {block2.block_hash}")

Futtassuk és elemezzük az ebből a kódrészletből kapott kimenetet. Még egyszer írja be a terminálját:

❯ python main.py
Block 1 data: Noah sends 5 GC to Mark - Mark sends 2.3 GC to James - firstblock
Block 1 hash: 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 data: James sends 4.2 GC to Alisson - Alisson sends 1.1 GC to Noah - 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 hash: 448c4306caf7f6937b0307f92f27fbea3bb73b3470363dee5026a1209dadcfa8

Egyelőre csak szöveget és néhány 64 karakteres hash-t lát, de ez nagyjából a blokklánc mechanizmusát veszi fel.

Egy genezis blokkal kezdi, amely az összes többi blokk alapja.

Bárki ellenőrizheti a lánc integritását, és ezért a Blockchain olyan biztonságos rendszer. Például, ha kissé módosítjuk egy tranzakció tartalmát, mondjuk:

t2 = "Mark sends 2.3 GC to James" -> t2 = "Mark sends 3.2 GC to James" 

Drámai változást látunk a blokkok hash-ében.

Block 1 data: Noah sends 5 GC to Mark - Mark sends 3.2 GC to James - firstblock
Block 1 hash: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 data: James sends 4.2 GC to Alisson - Alisson sends 1.1 GC to Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 hash: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Ezen megtekintheti az aktuális projektet GitHub repó.

Blockchain kódolása

Nem olyan okos dolog a rendszer integritását kézzel kódolt változókra alapozni, ezért más megközelítésre van szükségünk.

Megvannak a blokkok. Ideje felépíteni egy osztályt, amely egy blokkláncba kapcsolja őket.

Kezdjük a korábbi tranzakciók és blokkobjektumok törlésével, majd az alábbi kód használatával.

# main.py

class Blockchain:
    def __init__(self):
        self.chain = []
        self.generate_genesis_block()

    def generate_genesis_block(self):
        self.chain.append(GeekCoinBlock("0", ['Genesis Block']))
    
    def create_block_from_transaction(self, transaction_list):
        previous_block_hash = self.last_block.block_hash
        self.chain.append(GeekCoinBlock(previous_block_hash, transaction_list))

    def display_chain(self):
        for i in range(len(self.chain)):
            print(f"Data {i + 1}: {self.chain[i].block_data}")
            print(f"Hash {i + 1}: {self.chain[i].block_hash}n")

    @property
    def last_block(self):
        return self.chain[-1]

Ez megint egy hatalmas kódrészlet. Bontsuk fel az egyes részeket:

• self.chain — Az összes blokkot rögzítő lista. Az egyes blokkokat listaindexeken keresztül érhetjük el.
• gener_genesis_block — A keletkezés vagy az első blokk hozzáfűzése a lánchoz. A blokk előző hashje „0”, a tranzakciók listája pedig egyszerűen „Genesis Block”.
• create_block_from_transaction — Ez lehetővé teszi számunkra, hogy blokkokat fűzzünk a lánchoz a tranzakciók listájával. Nagyon bosszantó lenne manuálisan létrehozni egy blokkot minden alkalommal, amikor rögzíteni akarunk egy tranzakciót
• display_chain — Kiírja a blokkok láncát egy for ciklussal
• last_block – Olyan tulajdonság, amely lehetővé teszi a lánc utolsó elemének elérését. A create_block_from_transaction metódusban használtuk.

Teszteljük ezt a blokkláncot.

# main.py

import hashlib

class GeekCoinBlock:
    ...


class Blockchain:
    ...

t1 = "George sends 3.1 GC to Joe"
t2 = "Joe sends 2.5 GC to Adam"
t3 = "Adam sends 1.2 GC to Bob"
t4 = "Bob sends 0.5 GC to Charlie"
t5 = "Charlie sends 0.2 GC to David"
t6 = "David sends 0.1 GC to Eric"

myblockchain = Blockchain()

myblockchain.create_block_from_transaction([t1, t2])
myblockchain.create_block_from_transaction([t3, t4])
myblockchain.create_block_from_transaction([t5, t6])

myblockchain.display_chain()

Most futtassa a main.py fájlt.

Data 1: Genesis Block - 0
Hash 1: 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e

Data 2: George sends 3.1 GC to Joe - Joe sends 2.5 GC to Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Data 3: Adam sends 1.2 GC to Bob - Bob sends 0.5 GC to Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Data 4: Charlie sends 0.2 GC to David - David sends 0.1 GC to Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589
Hash 4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

Gratulálunk! 🙌 Most a semmiből készítettél egy egyszerű Python Blockchaint.

Mostantól megerősítheti a Blockchain megváltoztathatatlanságát getterek és setterek használatával, és más funkciókat is megvalósíthat, például a munkabizonyítást, a bányászatot vagy bármely más koncepciót, amelyet a Bitcoin Mining Fundamentals cikkében ismertettünk.

Következtetés

A blokklánc a Bitcoin, az Etherium és minden más kriptovaluta mögött álló technológia. Ebből a cikkből megtanulta, hogyan hozhat létre blokkláncot Python segítségével hash algoritmusok, például sha256, osztályok és objektumok használatával.

Az Ön kihívása egy bányászati ​​rendszer létrehozása, és miért ne valósítsa meg egy REST API-val olyan keretrendszerek használatával, mint a Django vagy a Flask.

Sokan vagyonokat keresnek kriptovalutákból. Képzelje csak el, mit tehetne, ha egyedül hozna létre egyet. 🤑

Folytasd a kódolást! 👨‍💻