วิธีสร้าง Cryptocurrency ของคุณเองโดยใช้ Python

ด้วยการเพิ่มขึ้นของ cryptocurrencies ในปัจจุบัน blockchain กำลังสร้างความฮือฮาในโลกเทคโนโลยี เทคโนโลยีนี้ได้รับความสนใจอย่างมากเนื่องจากความสามารถในการรับประกันความปลอดภัยบังคับใช้การกระจายอำนาจและเร่งกระบวนการไปยังอุตสาหกรรมต่างๆโดยเฉพาะในอุตสาหกรรมการเงิน

โดยพื้นฐานแล้ว blockchain เป็นฐานข้อมูลสาธารณะที่ไม่สามารถย้อนกลับได้เอกสารและรับรองความถูกต้องในการครอบครองและการส่งสินทรัพย์ดิจิทัล สกุลเงินดิจิทัลเช่น Bitcoin และ Ethereum เป็นไปตามแนวคิดนี้ Blockchain เป็นเทคโนโลยีที่น่าตื่นเต้นที่คุณสามารถใช้เพื่อเปลี่ยนแปลงความสามารถของแอปพลิเคชันของคุณ

ในช่วงปลายเราได้เห็นรัฐบาลองค์กรและบุคคลต่างๆใช้เทคโนโลยีบล็อกเชนเพื่อสร้างสกุลเงินดิจิทัลของตนเองและหลีกเลี่ยงการถูกทิ้งไว้เบื้องหลัง โดยเฉพาะอย่างยิ่งเมื่อ Facebook เสนอสกุลเงินดิจิทัลของตัวเองที่เรียกว่า Libra การประกาศดังกล่าวได้กระตุ้นให้เกิดน้ำท่วมทั่วโลก

จะเป็นอย่างไรหากคุณสามารถติดตามชุดและสร้างสกุลเงินดิจิทัลของคุณเองได้

ฉันคิดถึงเรื่องนี้และตัดสินใจที่จะพัฒนาอัลกอริทึมที่สร้าง crypto

ฉันตัดสินใจเรียกสกุลเงินดิจิทัลว่าfccCoin

ในบทช่วยสอนนี้ฉันจะอธิบายกระบวนการทีละขั้นตอนที่ฉันใช้ในการสร้างสกุลเงินดิจิทัล (ฉันใช้แนวคิดเชิงวัตถุของภาษาโปรแกรม Python)

นี่คือพิมพ์เขียวพื้นฐานของอัลกอริทึม blockchain สำหรับการสร้างfccCoin :

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] 

ตอนนี้ให้ฉันอธิบายว่าเกิดอะไรขึ้น ...

1. การสร้างคลาสบล็อกแรก

บล็อกเชนประกอบด้วยหลายบล็อกที่เชื่อมต่อกัน (ฟังดูคุ้น ๆ ใช่มั้ย?)

การต่อบล็อกจะเกิดขึ้นในลักษณะที่หากบล็อกหนึ่งถูกดัดแปลงส่วนที่เหลือของโซ่จะไม่ถูกต้อง

ในการใช้แนวคิดข้างต้นฉันได้สร้างคลาสบล็อกเริ่มต้นต่อไปนี้:

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) 

ดังที่คุณเห็นจากโค้ดด้านบนฉันได้กำหนดฟังก์ชัน __init __ ()ซึ่งจะดำเนินการเมื่อเริ่มต้นคลาสบล็อกเช่นเดียวกับในคลาส Python อื่น ๆ

ฉันจัดเตรียมพารามิเตอร์ต่อไปนี้ให้กับฟังก์ชันการเริ่มต้น:

  • self - นี่หมายถึงอินสแตนซ์ของคลาสBlockทำให้สามารถเข้าถึงเมธอดและแอตทริบิวต์ที่เกี่ยวข้องกับคลาสได้
  • ดัชนี - สิ่งนี้ติดตามตำแหน่งของบล็อกภายในบล็อกเชน
  • Proof_no - นี่คือตัวเลขที่เกิดขึ้นระหว่างการสร้างบล็อกใหม่ (เรียกว่าการขุด)
  • prev_hash - นี่หมายถึงแฮชของบล็อกก่อนหน้าภายในห่วงโซ่
  • ข้อมูลนี้ให้บันทึกการทำธุรกรรมทั้งหมดที่เสร็จสมบูรณ์เช่นปริมาณที่ซื้อ
  • การประทับเวลา - ซึ่งจะเป็นการประทับเวลาสำหรับธุรกรรม

วิธีที่สองในคลาสคำนวณ _ แฮชจะสร้างแฮชของบล็อกโดยใช้ค่าข้างต้น โมดูล SHA-256 ถูกนำเข้ามาในโปรเจ็กต์เพื่อช่วยในการรับแฮชของบล็อก

หลังจากป้อนค่าลงในอัลกอริธึมแฮชการเข้ารหัสแล้วฟังก์ชันจะส่งคืนสตริง 256 บิตที่แสดงถึงเนื้อหาของบล็อก

นี่คือวิธีการรักษาความปลอดภัยในบล็อกเชน - ทุกบล็อกจะมีแฮชและแฮชนั้นจะอาศัยแฮชของบล็อกก่อนหน้า

ดังนั้นหากมีคนพยายามที่จะประนีประนอมบล็อกใด ๆ ในเครือข่ายบล็อกอื่น ๆ จะมีแฮชที่ไม่ถูกต้องซึ่งนำไปสู่การหยุดชะงักของเครือข่ายบล็อกเชนทั้งหมด

ในที่สุดบล็อกจะมีลักษณะดังนี้:

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

2. การสร้างคลาส Blockchain

แนวคิดหลักของ blockchain เช่นเดียวกับชื่อที่มีความหมายเกี่ยวข้องกับการ“ ผูกมัด” หลาย ๆ บล็อกต่อกัน

ดังนั้นฉันจะสร้างคลาสBlockchainที่จะมีประโยชน์ในการจัดการการทำงานของห่วงโซ่ทั้งหมด นี่คือจุดที่การดำเนินการส่วนใหญ่เกิดขึ้น

Blockchainชั้นจะมีวิธีการช่วยเหลือต่าง ๆ สำหรับการจบงานต่าง ๆ ใน blockchain

ให้ฉันอธิบายบทบาทของแต่ละวิธีในชั้นเรียน

ก. วิธีการสร้าง

วิธีนี้ช่วยให้มั่นใจได้ว่าบล็อกเชนถูกสร้างอินสแตนซ์

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

นี่คือบทบาทของคุณลักษณะ:

  • self.chainตัวแปรนี้เก็บบล็อกทั้งหมด
  • self.current_data - ตัวแปรนี้เก็บธุรกรรมที่เสร็จสมบูรณ์ทั้งหมดไว้ในบล็อก
  • self.construct_genesis () - วิธีนี้จะดูแลการสร้างบล็อกเริ่มต้น

ข. การสร้างบล็อกการกำเนิด

blockchain ต้องใช้construct_genesisวิธีการในการสร้างบล็อกเริ่มต้นในห่วงโซ่ ในอนุสัญญาบล็อคเชนบล็อกนี้มีความพิเศษเนื่องจากเป็นสัญลักษณ์ของการเริ่มต้นของบล็อกเชน

ในกรณีนี้ให้สร้างโดยเพียงแค่ส่งค่าเริ่มต้นบางค่าไปยังเมธอดconstruction_block

ฉันให้ทั้งproof_noและprev_hashเป็นค่าศูนย์แม้ว่าคุณจะระบุค่าใดก็ได้ที่คุณต้องการ

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 

ค. การสร้างบล็อกใหม่

construct_blockวิธีการใช้สำหรับการสร้างบล็อกใหม่ใน blockchain

นี่คือสิ่งที่เกิดขึ้นพร้อมกับคุณสมบัติต่างๆของวิธีนี้:

  • ดัชนี - นี่แสดงถึงความยาวของบล็อกเชน
  • proof_nor & prev_hash - วิธีการโทรผ่านพวกเขา
  • ข้อมูลนี้มีบันทึกของธุรกรรมทั้งหมดที่ไม่รวมอยู่ในบล็อกใด ๆ บนโหนด
  • self.current_data - ใช้เพื่อรีเซ็ตรายการธุรกรรมบนโหนด หากมีการสร้างบล็อกและธุรกรรมที่จัดสรรให้รายการจะถูกรีเซ็ตเพื่อให้แน่ใจว่ามีการเพิ่มธุรกรรมในอนาคตลงในรายการนี้ และกระบวนการนี้จะเกิดขึ้นอย่างต่อเนื่อง
  • self.chain.append () -วิธีนี้รวมบล็อกที่สร้างขึ้นใหม่เข้ากับห่วงโซ่
  • กลับมาในที่สุดวัตถุบล็อกที่สร้างขึ้นจะถูกส่งคืน

ง. กำลังตรวจสอบความถูกต้อง

check_validityวิธีเป็นสิ่งสำคัญในการประเมินความสมบูรณ์ของ blockchain และสร้างความมั่นใจในความผิดปกติที่ขาด

ดังที่ได้กล่าวไว้ก่อนหน้านี้แฮชมีความสำคัญต่อการรักษาความปลอดภัยของบล็อกเชนเนื่องจากการเปลี่ยนแปลงวัตถุเพียงเล็กน้อยจะนำไปสู่การสร้างแฮชใหม่

ดังนั้นเมธอดcheck_validityนี้ใช้คำสั่งifเพื่อตรวจสอบว่าแฮชของทุกบล็อกถูกต้องหรือไม่

นอกจากนี้ยังตรวจสอบว่าทุกบล็อกชี้ไปทางขวาบล็อกก่อนหน้าหรือไม่โดยเปรียบเทียบมูลค่าของแฮช ถ้าทุกอย่างถูกต้องมันจะกลับมาเป็นจริง มิฉะนั้นจะส่งกลับเท็จ

@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 

จ. การเพิ่มข้อมูลธุรกรรม

new_dataวิธีการที่ใช้สำหรับการเพิ่มข้อมูลของการทำธุรกรรมที่จะกระชาก มันเป็นวิธีการที่ง่ายมาก: จะยอมรับสามพารามิเตอร์ (รายละเอียดของผู้ส่งรายละเอียดของผู้รับและปริมาณ) และผนวกข้อมูลการทำธุรกรรมเพื่อself.current_dataรายการ

เมื่อใดก็ตามที่มีการสร้างบล็อกใหม่รายการนี้จะถูกจัดสรรให้กับบล็อกนั้นและรีเซ็ตอีกครั้งตามที่อธิบายไว้ในวิธีการสร้างบล็อก

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.

If this coin were deployed as-is, it could not meet the present market demands for a stable, secure, and easy-to-use cryptocurrency.

Therefore, it can still be improved by adding additional features to enhance its capabilities for mining and sending financial transactions.

Nonetheless, it’s a good starting point if you decide to make your name known in the amazing world of cryptos.

If you have any comments or questions, please post them below.

Happy (crypto) coding!