Kaip susikurti savo kriptovaliutą naudojant „Python“

Šiuo metu didėjant kriptovaliutoms, „blockchain“ sukuria šurmulį technologijų pasaulyje. Ši technologija sulaukė tiek daug dėmesio dėl savo sugebėjimo garantuoti saugumą, vykdyti decentralizaciją ir paspartinti procesus keliose pramonės šakose, ypač finansų pramonėje.

Iš esmės „blockchain“ yra vieša duomenų bazė, negrįžtamai dokumentuojanti ir patvirtinanti skaitmeninio turto turėjimą ir perdavimą. Skaitmeninės valiutos, tokios kaip Bitcoin ir Ethereum, yra pagrįstos šia koncepcija. „Blockchain“ yra įdomi technologija, kurią galite naudoti norėdami pakeisti savo programų galimybes.

Vėlai matėme vyriausybes, organizacijas ir asmenis, naudojančius „blockchain“ technologiją kurdami savo kriptovaliutas ir vengdami atsilikti. Pažymėtina, kad kai „Facebook“ pasiūlė savo kriptovaliutą, vadinamą Svarstyklėmis, šis pranešimas sujudino daug vandenų visame pasaulyje.

Ką daryti, jei jūs taip pat galėtumėte pasekti šiuo pavyzdžiu ir sukurti savo kriptovaliutos versiją?

Pagalvojau apie tai ir nusprendžiau sukurti algoritmą, kuris sukurtų kriptografiją.

Aš nusprendžiau paskambinti kriptovaliuta fccCoin .

Šioje pamokoje aš iliustruosiu žingsnis po žingsnio procesą, kurį naudoju kurdamas skaitmeninę valiutą (naudojau objektyvias „Python“ programavimo kalbos sąvokas).

Čia pateikiamas pagrindinis „ blockchain“ algoritmo „ fccCoin“ sukūrimo planas :

class Block: def __init__(): #first block class pass def calculate_hash(): #calculates the cryptographic hash of every block class BlockChain: def __init__(self): # constructor method pass def construct_genesis(self): # constructs the initial block pass def construct_block(self, proof_no, prev_hash): # constructs a new block and adds it to the chain pass @staticmethod def check_validity(): # checks whether the blockchain is valid pass def new_data(self, sender, recipient, quantity): # adds a new transaction to the data of the transactions pass @staticmethod def construct_proof_of_work(prev_proof): # protects the blockchain from attack pass @property def last_block(self): # returns the last block in the chain return self.chain[-1] 

Leiskite man paaiškinti, kas vyksta ...

1. Pirmosios „Block“ klasės statyba

„Blockchain“ sudaro keli blokai, kurie yra sujungti vienas su kitu (tai skamba gerai, tiesa?).

Blokų grandinė vyksta taip, kad jei vienas blokas yra sugadintas, likusi grandinė tampa negaliojanti.

Taikant aukščiau pateiktą koncepciją, aš sukūriau šią pradinę blokų klasę:

import hashlib import time class Block: def __init__(self, index, proof_no, prev_hash, data, timestamp=None): self.index = index self.proof_no = proof_no self.prev_hash = prev_hash self.data = data self.timestamp = timestamp or time.time() @property def calculate_hash(self): block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) return hashlib.sha256(block_of_string.encode()).hexdigest() def __repr__(self): return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) 

Kaip matote iš aukščiau esančio kodo, aš apibrėžiau funkciją __init __ () , kuri bus vykdoma inicijuojant „ Block“ klasę, kaip ir bet kurioje kitoje „Python“ klasėje.

Iniciacijos funkcijai pateikiau šiuos parametrus:

  • „self“ - tai reiškia „ Block“ klasės egzempliorių , leidžiantį pasiekti su klase susijusius metodus ir atributus;
  • indeksas - tai seka bloko padėtį blokų grandinėje;
  • proof_no - tai skaičius, sukurtas kuriant naują bloką (vadinamas kasyba);
  • prev_hash - tai nurodo ankstesnio grandinės maišos grandinėje;
  • duomenys - tai pateikia visų įvykdytų operacijų, pavyzdžiui, nupirkto kiekio, įrašą;
  • laiko žymė - tai uždeda operacijų laiko žymę.

Antrasis metodas klasės, calculate_hash , sukurs blokų, naudojant pirmiau minėtų verčių maišos. SHA-256 modulis yra importuojamas į projektą, kad būtų lengviau gauti blokų maišas.

Įvedus reikšmes į kriptografinio maišos algoritmą, funkcija grąžins 256 bitų eilutę, atspindinčią bloko turinį.

Taip užtikrinamas saugumas blokų grandinėse - kiekviename bloke bus maišos, o ši maiša priklausys nuo ankstesnio bloko maišos.

Taigi, jei kas nors bandys pažeisti bet kurį grandinės bloką, kiti blokai turės netinkamų maišų, o tai sutrikdys visą „blockchain“ tinklą.

Galų gale blokas atrodys taip:

{ "index": 2, "proof": 21, "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823", "transactions": [ {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1} ], "timestamp": 1521646442.4096143 } 

2. „Blockchain“ klasės kūrimas

Pagrindinė „blockchain“ idėja, kaip rodo pavadinimas, apima kelių blokų „sujungimą“ vienas su kitu.

Todėl ketinu sukonstruoti „ Blockchain“ klasę, kuri bus naudinga valdant visos grandinės darbą. Čia vyks didžioji veiksmo dalis.

Blockchain“ klasėje bus įvairūs pagalbiniai metodai, kaip atlikti įvairias užduotis „blockchain“.

Leiskite man paaiškinti kiekvieno metodo vaidmenį klasėje.

a. Konstruktoriaus metodas

Šis metodas užtikrina, kad „blockchain“ yra tiesioginis.

class BlockChain: def __init__(self): self.chain = [] self.current_data = [] self.nodes = set() self.construct_genesis() 

Čia pateikiami jo atributų vaidmenys:

  • „self.chain“ - šis kintamasis saugo visus blokus;
  • self.current_data —šis kintamasis laiko visas užbaigtas operacijas bloke;
  • self.construct_genesis () - šis metodas pasirūpins pradinio bloko sukonstravimu.

b. Konstruuoti genezės bloką

Blockchain reikalauja construct_genesis metodą statyti pradinį blokas grandinėje. „Blockchain“ konvencijoje šis blokas yra ypatingas, nes jis simbolizuoja „blockchain“ pradžią.

Tokiu atveju sukonstruokime jį paprasčiausiai perduodami kai kurias numatytąsias reikšmes metodui „ construct_block“ .

Daviau tiek proof_no ir prev_hash lygus nuliui, nors galite suteikti bet kokią norimą reikšmę.

def construct_genesis(self): self.construct_block(proof_no=0, prev_hash=0) def construct_block(self, proof_no, prev_hash): block = Block( index=len(self.chain), proof_no=proof_no, prev_hash=prev_hash, data=self.current_data) self.current_data = [] self.chain.append(block) return block 

c. Naujų blokų konstravimas

Construct_block“ metodas naudojamas kuriant naujus blokus blokų grandinėje.

Štai kas vyksta naudojant įvairius šio metodo atributus:

  • indeksas - tai reiškia „blockchain“ ilgį;
  • proof_nor & prev_hash - skambintojo metodas juos pralenkia ;
  • duomenys - tai visų operacijų, kurios nėra įtrauktos į jokį mazgo bloką, įrašas;
  • self.current_data - tai naudojama norint iš naujo nustatyti mazgų operacijų sąrašą. Jei buvo sukurtas blokas ir jam priskirtos operacijos, sąrašas iš naujo nustatomas siekiant užtikrinti, kad būsimos operacijos būtų įtrauktos į šį sąrašą. Šis procesas vyks nuolat;
  • self.chain.append () - šis metodas sujungia naujai sukonstruotus blokus su grandine;
  • grįžti - dažniausiai grąžinamas sukonstruotas blokinis objektas.

d. Tikrinamas galiojimas

Check_validity“ metodas yra svarbus vertinant „ blockchain “ vientisumą ir užtikrinant, kad nėra anomalijų.

Kaip minėta anksčiau, maišos yra būtinos blokų grandinės saugumui, nes net ir dėl menkiausio objekto pasikeitimo atsiras visiškai naujas maišos.

Todėl šis „ check_validity“ metodas naudoja „ if“ teiginius, kad patikrintų, ar kiekvieno bloko maišos teisingos.

Jis taip pat patikrina, ar kiekvienas blokas nurodo dešinįjį ankstesnį bloką, palygindamas jų maišų vertę. Jei viskas teisinga, tai grąžinama tiesa; priešingu atveju jis pateikia klaidingą.

@staticmethod def check_validity(block, prev_block): if prev_block.index + 1 != block.index: return False elif prev_block.calculate_hash != block.prev_hash: return False elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no): return False elif block.timestamp <= prev_block.timestamp: return False return True 

e. Sandorių duomenų pridėjimas

Metodas „ new_data“ naudojamas operacijų duomenims pridėti prie bloko. Tai labai paprastas metodas: jis priima tris parametrus (siuntėjo duomenis, gavėjo duomenis ir kiekį) ir prideda operacijos duomenis prie self.current_data sąrašo.

Bet kada, kai sukuriamas naujas blokas, šis sąrašas priskiriamas tam blokui ir dar kartą nustatomas iš naujo, kaip paaiškinta metodu „ construct_block“ .

Pridėjus operacijos duomenis į sąrašą, grąžinamas kito sukuriamo bloko indeksas.

Šis indeksas apskaičiuojamas pridedant 1 prie dabartinio bloko indekso (kuris yra paskutinis blokų grandinėje). Duomenys padės vartotojui pateikti operaciją ateityje.

def new_data(self, sender, recipient, quantity): self.current_data.append({ 'sender': sender, 'recipient': recipient, 'quantity': quantity }) return True 

f. Pridedamas darbo įrodymas

Darbo įrodymas yra sąvoka, neleidžianti „blockchain“ piktnaudžiauti. Tiesiog jo tikslas yra nustatyti skaičių, kuris išsprendžia problemą atlikus tam tikrą skaičiavimo darbą.

Jei numerio identifikavimo sunkumų lygis yra didelis, tai neskatina šlamšto ir klastotės.

Tokiu atveju naudosime paprastą algoritmą, kuris atgrasys žmones nuo blokų kasimo ar blokų kūrimo.

@staticmethod def proof_of_work(last_proof): '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes f is the previous f' f' is the new proof ''' proof_no = 0 while BlockChain.verifying_proof(proof_no, last_proof) is False: proof_no += 1 return proof_no @staticmethod def verifying_proof(last_proof, proof): #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? guess = f'{last_proof}{proof}'.encode() guess_hash = hashlib.sha256(guess).hexdigest() return guess_hash[:4] == "0000" 

g. Gaunamas paskutinis blokas

Galiausiai „ latest_block“ metodas yra pagalbinis metodas, padedantis gauti paskutinį bloką blokų grandinėje. Atminkite, kad paskutinis blokas iš tikrųjų yra dabartinis grandinės blokas.

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

Apibendrinkime viską kartu

Čia yra visas kodas „ fccCoin“ kriptovaliutai sukurti .

Taip pat kodą galite gauti šioje „GitHub“ saugykloje.

import hashlib import time class Block: def __init__(self, index, proof_no, prev_hash, data, timestamp=None): self.index = index self.proof_no = proof_no self.prev_hash = prev_hash self.data = data self.timestamp = timestamp or time.time() @property def calculate_hash(self): block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) return hashlib.sha256(block_of_string.encode()).hexdigest() def __repr__(self): return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) class BlockChain: def __init__(self): self.chain = [] self.current_data = [] self.nodes = set() self.construct_genesis() def construct_genesis(self): self.construct_block(proof_no=0, prev_hash=0) def construct_block(self, proof_no, prev_hash): block = Block( index=len(self.chain), proof_no=proof_no, prev_hash=prev_hash, data=self.current_data) self.current_data = [] self.chain.append(block) return block @staticmethod def check_validity(block, prev_block): if prev_block.index + 1 != block.index: return False elif prev_block.calculate_hash != block.prev_hash: return False elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no): return False elif block.timestamp <= prev_block.timestamp: return False return True def new_data(self, sender, recipient, quantity): self.current_data.append({ 'sender': sender, 'recipient': recipient, 'quantity': quantity }) return True @staticmethod def proof_of_work(last_proof): '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes f is the previous f' f' is the new proof ''' proof_no = 0 while BlockChain.verifying_proof(proof_no, last_proof) is False: proof_no += 1 return proof_no @staticmethod def verifying_proof(last_proof, proof): #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? guess = f'{last_proof}{proof}'.encode() guess_hash = hashlib.sha256(guess).hexdigest() return guess_hash[:4] == "0000" @property def latest_block(self): return self.chain[-1] def block_mining(self, details_miner): self.new_data( sender="0", #it implies that this node has created a new block receiver=details_miner, quantity= 1, #creating a new block (or identifying the proof number) is awarded with 1 ) last_block = self.latest_block last_proof_no = last_block.proof_no proof_no = self.proof_of_work(last_proof_no) last_hash = last_block.calculate_hash block = self.construct_block(proof_no, last_hash) return vars(block) def create_node(self, address): self.nodes.add(address) return True @staticmethod def obtain_block_object(block_data): #obtains block object from the block data return Block( block_data['index'], block_data['proof_no'], block_data['prev_hash'], block_data['data'], timestamp=block_data['timestamp']) 

Dabar patikrinkime savo kodą, ar jis veikia.

blockchain = BlockChain() print("***Mining fccCoin about to start***") print(blockchain.chain) last_block = blockchain.latest_block last_proof_no = last_block.proof_no proof_no = blockchain.proof_of_work(last_proof_no) blockchain.new_data( sender="0", #it implies that this node has created a new block recipient="Quincy Larson", #let's send Quincy some coins! quantity= 1, #creating a new block (or identifying the proof number) is awarded with 1 ) last_hash = last_block.calculate_hash block = blockchain.construct_block(proof_no, last_hash) print("***Mining fccCoin has been successful***") print(blockchain.chain) 

Pavyko!

Štai kasybos proceso rezultatas:

***Mining fccCoin about to start*** [0 - 0 - 0 - [] - 1566930640.2707076] ***Mining fccCoin has been successful*** [0 - 0 - 0 - [] - 1566930640.2707076, 1 - 88914 - a8d45cb77cddeac750a9439d629f394da442672e56edfe05827b5e41f4ba0138 - [{'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}] - 1566930640.5363243] 

Išvada

Štai, jūs turite tai!

Taip jūs galite sukurti savo blokų grandinę naudodami „Python“.

Leiskite man pasakyti, kad šioje pamokoje tik parodomos pagrindinės kojų sušlapimo idėjos naudojant naujovišką „blockchain“ technologiją.

Jei ši moneta būtų išleista tokia, kokia yra, ji negalėtų patenkinti dabartinių rinkos poreikių, susijusių su stabilia, saugia ir lengvai naudojama kriptovaliuta.

Todėl jį vis tiek galima patobulinti pridedant papildomų funkcijų, kad būtų pagerintos jo galimybės gauti kasybą ir siųsti finansines operacijas.

Nepaisant to, tai yra geras atspirties taškas, jei nuspręsite garsinti savo vardą nuostabiame kriptų pasaulyje.

Jei turite pastabų ar klausimų, rašykite juos žemiau.

Laimingo (kriptografinio) kodavimo!