Kuidas luua oma krüptoraha Pythoni abil

Krüptorahade praeguse tõusuga tekitab blockchain tehnoloogiamaailmas hoogu. See tehnoloogia on nii palju tähelepanu äratanud peamiselt tänu oma võimele tagada turvalisus, jõustada detsentraliseerimine ja kiirendada protsesse mitmele tööstusharule - eriti finantssektorile.

Põhimõtteliselt on plokiahel avalik andmebaas, mis pöördumatult dokumenteerib ja kinnitab digitaalse vara omamist ja edastamist. Sellel kontseptsioonil põhinevad digitaalsed valuutad, nagu Bitcoin ja Ethereum. Blockchain on põnev tehnoloogia, mille abil saate oma rakenduste võimalusi muuta.

Hiljuti oleme näinud valitsusi, organisatsioone ja üksikisikuid, kes kasutavad plokiahela tehnoloogiat oma krüptovaluutade loomiseks - ja väldivad mahajäämist. Nimelt, kui Facebook pakkus välja oma krüptoraha, nimega Kaalud, tekitas teade kogu maailmas palju veekogusid.

Mis oleks, kui saaksite ka seda eeskuju järgida ja luua oma versioon krüptorahast?

Mõtlesin sellele ja otsustasin välja töötada krüpto loova algoritmi.

Otsustasin helistada krüptorahale fccCoin .

Selles õpetuses illustreerin järkjärgulist protsessi, mida kasutasin digitaalse valuuta loomiseks (kasutasin Pythoni programmeerimiskeele objektorienteeritud kontseptsioone).

Siin on plokiahela algoritmi põhiline plaan fccCoini loomiseks :

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] 

Lubage mul nüüd selgitada, mis toimub ...

1. Esimese Block-klassi ehitamine

Plokiahel koosneb mitmest üksteisega ühendatud plokist (see kõlab tuttavalt, eks?).

Plokkide aheldamine toimub nii, et ühe ploki rikkumise korral muutub ülejäänud ahel kehtetuks.

Ülaltoodud kontseptsiooni rakendamisel lõin järgmise algklotside klassi:

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) 

Nagu ülaltoodud koodist näete, määratlesin funktsiooni __init __ () , mis käivitatakse klassi Block käivitamise ajal, nagu igas muus Pythoni klassis.

Esitasin initsieerimisfunktsioonile järgmised parameetrid:

  • ise - see viitab klassi Block eksemplarile, võimaldades juurdepääsu klassiga seotud meetoditele ja atribuutidele;
  • indeks - see jälgib ploki positsiooni plokiahelas;
  • proof_no - see on uue ploki (nn kaevandamise) loomisel toodetud arv;
  • prev_hash - see viitab eelmise ploki räsi ahelas;
  • andmed - need annavad andmed kõigi lõpetatud tehingute, näiteks ostetud koguse kohta;
  • ajatempel - see paneb tehingute ajatempli.

Klassi teine ​​meetod, arvuta_hash , genereerib plokkide räsi, kasutades ülaltoodud väärtusi. Moodul SHA-256 imporditakse projekti, et aidata plokkide räsisid hankida.

Pärast seda, kui väärtused on sisestatud krüptograafilise räsialgoritmi, tagastab funktsioon 256-bitise stringi, mis tähistab ploki sisu.

Nii saavutatakse turvalisus plokiahelates - igal plokil on räsi ja see räsi toetub eelmise ploki räsile.

Sellisena, kui keegi üritab ahela mõnda plokki ohustada, on teistel plokkidel kehtetud räsid, mis põhjustab kogu plokiahelavõrgu katkemist.

Lõppkokkuvõttes näeb plokk välja selline:

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

2. Blockchaini klassi ehitamine

Plokiahela peamine idee, nagu nimigi ütleb, hõlmab mitme ploki üksteise külge aheldamist.

Seetõttu kavatsen ehitada Blockchaini klassi, mis on kasulik kogu keti töö juhtimiseks. Siin toimub suurem osa tegevusest.

Blockchain klassi on erinevate abistaja meetodid täites erinevaid ülesandeid blockchain.

Lubage mul selgitada iga meetodi rolli klassis.

a. Konstruktori meetod

See meetod tagab plokiahela instantsimise.

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

Siin on selle atribuutide rollid:

  • ise.ahel - see muutuja hoiab kõiki plokke;
  • self.current_data - see muutuja hoiab plokis kõik lõpetatud tehingud;
  • ise.konstrueeri_genees () - see meetod hoolitseb esialgse ploki konstrueerimise eest.

b. Geneesibloki konstrueerimine

Plokiahel nõuab ahela algploki ehitamiseks meetodit construct_genesis . Plokiahela konventsioonis on see plokk eriline, kuna see sümboliseerib plokiahela algust.

Sel juhul koostame selle, edastades mõned vaikeväärtused meetodile construct_block .

Andsin nii proof_no kui ka prev_hash väärtuseks null, kuigi võite anda mis tahes väärtuse, mida soovite.

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. Uute plokkide ehitamine

Construct_block meetodit kasutatakse uute plokkide blockchain.

Selle meetodi erinevate atribuutidega toimub järgmine:

  • indeks - see tähistab plokiahela pikkust;
  • proof_nor & prev_hash - helistaja meetod läbib need;
  • andmed - need sisaldavad kirjet kõigi tehingute kohta, mis pole sõlmes üheski plokis;
  • self.current_data—this is used to reset the transaction list on the node. If a block has been constructed and the transactions allocated to it, the list is reset to ensure that future transactions are added into this list. And, this process will take place continuously;
  • self.chain.append()—this method joins newly constructed blocks to the chain;
  • return—lastly, a constructed block object is returned.

d. Checking validity

The check_validity method is important in assessing the integrity of the blockchain and ensuring anomalies are absent.

As mentioned earlier, hashes are essential for the security of the blockchain as even the slightest change in the object will lead to the generation of a completely new hash.

Therefore, this check_validitymethod uses if statements to check whether the hash of every block is correct.

It also verifies if every block points to the right previous block, through comparing the value of their hashes. If everything is correct, it returns true; otherwise, it returns false.

@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. Adding data of transactions

The new_data method is used for adding the data of transactions to a block. It’s a very simple method: it accepts three parameters (sender’s details, receiver’s details, and quantity) and append the transaction data to self.current_data list.

Anytime a new block is created, this list is allocated to that block and reset once more as explained in the construct_block method.

Once the transaction data has been added to the list, the index of the next block to be created is returned.

This index is calculated by adding 1 to the index of the current block (which is the last in the blockchain). The data will assist a user in submitting the transaction in future.

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

f. Adding proof of work

Proof of work is a concept that prevents the blockchain from abuse. Simply, its objective is to identify a number that solves a problem after a certain amount of computing work is done.

If the difficulty level of identifying the number is high, it discourages spamming and tampering with the blockchain.

In this case, we’ll use a simple algorithm that discourages people from mining blocks or creating blocks easily.

@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. Getting the last block

Lastly, the latest_blockmethod is a helper method that assists in obtaining the last block in the blockchain. Remember that the last block is actually the current block in the chain.

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

Let’s sum everything together

Here is the entire code for creating the fccCoin cryptocurrency.

You can also get the code on this GitHub repository.

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']) 

Now, let’s test our code to see if it works.

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) 

It worked!

Here is the output of the mining process:

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

Conclusion

There you have it!

That’s how you could create your own blockchain using Python.

Let me say that this tutorial just demonstrates the basic concepts for getting your feet wet in the innovative blockchain technology.

Kui see münt kasutataks sellisena, nagu see on, ei saaks see rahuldada turu praeguseid nõudmisi stabiilse, turvalise ja hõlpsasti kasutatava krüptoraha järele.

Seetõttu saab seda siiski täiustada lisafunktsioonide lisamisega, et parandada selle võimalusi kaevandamiseks ja finantstehingute saatmiseks.

Sellest hoolimata on see hea lähtepunkt, kui otsustate oma nime krüptode hämmastavas maailmas tuntuks teha.

Kui teil on kommentaare või küsimusi, postitage need allpool.

Head (krüpto) kodeerimist!