Bygg din egen Blockchain med Python: Steg-for-steg guide

by
Tweet
Share
Share
Pin
0 Shares

Utforsking av Blockchain: Bygg din egen med Python

Visste du at selve grunnlaget for Bitcoin hviler på Blockchain-teknologien? I denne artikkelen skal vi trinn for trinn konstruere en enkel Blockchain ved hjelp av programmeringsspråket Python.

Hva er egentlig en Blockchain?

I 2008 publiserte en anonym person eller gruppe, under pseudonymet Satoshi Nakamoto, et banebrytende dokument, det såkalte Bitcoin-papiret. Dette dokumentet introduserte Bitcoin som en desentralisert form for elektroniske penger, muliggjør transaksjoner uten involvering av tradisjonelle finansinstitusjoner som banker. Det mange imidlertid ikke vet, er at samme papir definerte en distribuert metode for informasjonslagring, i dag kjent som Blockchain.

Grunnleggende om Blockchain-teknologi

Enkelt forklart er en Blockchain en delt, permanent digital hovedbok som registrerer transaksjoner over et desentralisert nettverk av datamaskiner. Den fundamentale strukturen kan deles inn i to nøkkelbegreper:

  • Blokk: En enhet der transaksjoner lagres.
  • Kjede: En serie av sammenkoblede poster.

Dette betyr at en Blockchain består av en kjede av blokker, hvor hver blokk inneholder en eller flere transaksjoner med spesifikke detaljer. Hver ny blokk bygges på toppen av den forrige, og skaper en uforanderlig kjede. Denne sammenkoblingen gjør systemet svært robust, og enhver person med tilgang kan verifisere dataintegriteten.

Blockchain-teknologien bringer med seg følgende viktige egenskaper:

  • Uforanderlighet i historikken
  • Dataenes vedvarenhet
  • Sikkerhet mot feil i lagrede data

Blockchain brukes i dag i en rekke systemer, inkludert kryptovalutaer, overføring av eiendeler (NFT-er), og det kan også tenkes at det vil bli brukt i stemmegivning i nær fremtid.

Det er viktig å merke seg at en Python-basert Blockchain ikke nødvendigvis trenger å være et komplekst program. I sin kjerne består den av en liste over transaksjoner som er koblet sammen.

Dette er en kort innføring. Hvis du ønsker en grundigere forklaring, har vi laget en omfattende opplæring for nybegynnere. Sjekk den gjerne ut!

La oss uten videre gå i gang med å bygge en enkel Blockchain ved hjelp av Python.

Utvikling av en Blockchain i Python

Før vi setter i gang, la oss definere hva vi skal oppnå i denne veiledningen:

  • Utvikle et enkelt Blockchain-system skrevet i Python.
  • Bruke vår Blockchain med forhåndsdefinerte transaksjoner, representert som tekststrenger.
  • Teste Blockchainens uforanderlighet.

Vi vil bruke Python-lister i stedet for JSON for å forenkle prosessen og fokusere på de grunnleggende konseptene i en Blockchain.

Dette trenger du for å følge denne veiledningen:

Opprettelse av en Blokk-klasse

Åpne din foretrukne tekstredigerer og lag en fil ved navn «main.py». Dette er filen vi skal jobbe med.

Nå, importer modulen hashlib, som gjør det mulig å generere enveis krypterte meldinger. Kryptografiske teknikker som hashing er avgjørende for å sikre transaksjoner i en Blockchain.

En hash-funksjon er en algoritme som tar data (vanligvis en kodet streng) og produserer en unik identifikator, ofte kalt «digest» eller «signatur». Det er viktig at selv en liten endring i inndataene vil generere en helt annen identifikator. Dette vil vi demonstrere senere.

Foreløpig trenger vi bare å importere den innebygde hashlib-modulen:

# main.py
"""
En enkel Blockchain i Python
"""

import hashlib

Denne modulen inneholder de fleste hashing-algoritmer du trenger. Vi skal spesifikt bruke funksjonen hashlib.sha256().

La oss nå definere klassen GeekCoinBlock, navnet på vår egen Blockchain-variant.

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()

Dette kan virke som mye kode i begynnelsen, la oss derfor se nærmere på hver enkelt del.

Detaljert forklaring av GeekCoinBlock

Først definerer vi klassen GeekCoinBlock, en beholder for objekter med spesifikke egenskaper (attributter) og handlinger (metoder).

Vi definerer metoden __init__ (konstruktøren), som kalles hver gang et nytt GeekCoinBlock-objekt opprettes.

Denne metoden tar tre parametre:

  • self (selve objektet)
  • previous_block_hash (en referanse til den forrige blokken)
  • transaction_list (en liste over transaksjoner i denne blokken)

Vi lagrer den forrige hashen og transaksjonslisten, og vi oppretter en variabel kalt `block_data` som en streng. I ekte kryptovalutaer lagres denne typen data som en egen hash, men for enkelhets skyld lagrer vi alt som en streng.

Til slutt genererer vi `block_hash`, som vil brukes av neste blokk i kjeden. Her er hashlib veldig nyttig. I stedet for å skrive en egen hash-funksjon, bruker vi den forhåndsdefinerte `sha256` for å lage uforanderlige blokker.

Denne funksjonen tar en kodet streng som parameter, derfor bruker vi `block_data.encode()`. Deretter kaller vi `.hexdigest()` for å returnere den kodede dataen som en heksadesimal streng.

La oss eksperimentere med `hashlib` i et Python-skall:

In [1]: import hashlib

In [2]: message = "Python er fantastisk"

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 er ikke fantastisk")

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

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

Som du ser, vil en liten endring i input, som fra «Python er fantastisk» til «Python er ikke fantastisk», produsere en helt annen hash. Dette er avgjørende for integriteten til Blockchain. En liten endring i en blokk vil endre hashen drastisk. Derfor er utsagnet «Du kan ikke tukle med en Blockchain» sant.

Anvendelse av vår Blokk-klasse

Vi skal utvikle en fullverdig Blockchain-klasse senere, men la oss først bruke `Block`-klassen til å lage en kjede av blokker (Blockchain).

I samme fil, lag noen få transaksjoner som enkle strenger lagret i variabler:

class GeekCoinBlock:
    ...

t1 = "Noah sender 5 GC til Mark"
t2 = "Mark sender 2.3 GC til James"
t3 = "James sender 4.2 GC til Alisson"
t4 = "Alisson sender 1.1 GC til Noah"

Her står GC for GeekCoin.

Lag den første blokken i Blockchain ved hjelp av `GeekCoinBlock`-klassen og skriv ut dens attributter. Den første blokkens `previous_hash`-parameter, også kalt genesis-blokken, settes til en vilkårlig streng, for eksempel «firstblock».

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

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

Deretter gjør vi det samme med den andre blokken, men bruker den første blokkens hash som `previous_hash`-parameter.

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

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

La oss kjøre koden og analysere output:

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

Dette er en visualisering av hvordan en Blockchain fungerer. Vi begynner med en genesis-blokk og fortsetter å legge til blokker ved å bruke den forrige blokkens hash. Dette gjør det umulig å endre tidligere blokker uten at hashen for alle etterfølgende blokker også endres.

Alle kan verifisere integriteten i kjeden. Hvis vi endrer en transaksjon litt, som for eksempel:

t2 = "Mark sender 2.3 GC til James" -> t2 = "Mark sender 3.2 GC til James"

vil vi se en dramatisk endring i hashen for alle etterfølgende blokker:

Blokk 1 data: Noah sender 5 GC til Mark - Mark sender 3.2 GC til James - firstblock
Blokk 1 hash: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Blokk 2 data: James sender 4.2 GC til Alisson - Alisson sender 1.1 GC til Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Blokk 2 hash: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Du kan se det aktuelle prosjektet på dette GitHub-repoet.

Koding av selve Blockchain

Det er ikke ideelt å basere systemets integritet på manuelt definerte variabler. Vi trenger en mer robust tilnærming. Nå som vi har blokkene, er det på tide å lage en klasse som samler dem i en Blockchain.

La oss slette de tidligere transaksjonene og blokkobjektene og bruke koden nedenfor:

# 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]

Dette er igjen mye kode. La oss se nærmere på hver del:

  • `self.chain` – En liste der alle blokker lagres. Hver blokk kan nås via indeks.
  • `generate_genesis_block` – Legger til den første blokken i kjeden. Den forrige hashen er satt til «0», og transaksjonslisten er bare «Genesis Block.»
  • `create_block_from_transaction` – Lar oss legge til nye blokker til kjeden med en liste over transaksjoner. Det ville være tungvint å opprette en ny blokk manuelt hver gang vi ønsket å registrere en transaksjon.
  • `display_chain` – Skriver ut alle blokkene i kjeden med en løkke.
  • `last_block` – En egenskap som lar oss få tilgang til det siste elementet i kjeden, som vi brukte i `create_block_from_transaction`-metoden.

La oss nå teste denne Blockchain.

# main.py

import hashlib

class GeekCoinBlock:
    ...


class Blockchain:
    ...

t1 = "George sender 3.1 GC til Joe"
t2 = "Joe sender 2.5 GC til Adam"
t3 = "Adam sender 1.2 GC til Bob"
t4 = "Bob sender 0.5 GC til Charlie"
t5 = "Charlie sender 0.2 GC til David"
t6 = "David sender 0.1 GC til 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()

Kjør `main.py`-filen:

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

Data 2: George sender 3.1 GC til Joe - Joe sender 2.5 GC til Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Data 3: Adam sender 1.2 GC til Bob - Bob sender 0.5 GC til Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Data 4: Charlie sender 0.2 GC til David - David sender 0.1 GC til Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589
Hash 4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

Gratulerer! Du har nå utviklet en enkel Python Blockchain fra bunnen av!

Du kan nå styrke uforanderligheten ved å bruke getters og setters, eller implementere andre funksjoner som «proof-of-work», «mining» eller andre konsepter vi forklarte i artikkelen om grunnleggende Bitcoin Mining.

Konklusjon

Blockchain er kjerneteknologien bak Bitcoin, Ethereum og mange andre kryptovalutaer. I denne artikkelen har vi lært hvordan man bygger en Blockchain med Python, ved hjelp av hash-algoritmer som SHA256, klasser og objekter.

Din neste utfordring kan være å lage et «mining»-system, eller implementere dette med en REST API ved hjelp av rammeverk som Django eller Flask.

Mange tjener store penger på kryptovaluta. Tenk hva du kan oppnå om du skaper din egen!

Fortsett å kode! 👨‍💻