如何使用 Python 創建自己的加密貨幣

woff

Python,創建,加密貨幣

隨著當前加密貨幣的興起，區塊鏈正在技術世界中引起轟動。這項技術之所以引起如此多的關注，主要是因為它能夠保證安全性、實施去中心化以及加快多個行業的流程——尤其是金融行業。
從本質上講，區塊鍊是一個公共數據庫，不可逆轉地記錄和驗證數字資產的擁有和傳輸。比特幣和以太坊等數字貨幣就是基於這個概念。區塊鍊是一項令人興奮的技術，您可以使用它來轉換應用程序的功能。

最近，我們已經看到政府、組織和個人使用區塊鏈技術來創建自己的加密貨幣，並避免被拋在後面。值得注意的是，當 Facebook 提出自己的加密貨幣Libra 時，這一聲明在全球範圍內掀起了軒然大波。

如果您也可以效仿並創建自己的加密貨幣版本怎麼辦？

我考慮了這一點並決定開發一種算法來創建加密。

我決定將加密貨幣稱為 fccCoin。

在本教程中，我將說明我用來構建數字貨幣的分步過程（我使用了Python編程語言的面向對象概念）。

以下是創建fccCoin 的區塊鏈算法的基本藍圖：

1. class Block:
   
2.   def __init__():
   
3.     #first block class
   
4.     pass
   
5.    
   
6.   def calculate_hash():
   
7.     #calculates the cryptographic hash of every block
   
8.    
   
9. class BlockChain:
   
10.   def __init__(self):
    
11.     # constructor method
    
12.     pass
    
13.    
    
14.   def construct_genesis(self):
    
15.     # constructs the initial block
    
16.     pass
    
17. 
    
18.   def construct_block(self, proof_no, prev_hash):
    
19.     # constructs a new block and adds it to the chain
    
20.     pass
    
21. 
    
22.   @staticmethod
    
23.   def check_validity():
    
24.     # checks whether the blockchain is valid
    
25.     pass
    
26. 
    
27.   def new_data(self, sender, recipient, quantity):
    
28.     # adds a new transaction to the data of the transactions
    
29.     pass
    
30. 
    
31.   @staticmethod
    
32.   def construct_proof_of_work(prev_proof):
    
33.     # protects the blockchain from attack
    
34.     pass
    
35.    
    
36.   @property
    
37.   def last_block(self):
    
38.     # returns the last block in the chain
    
39.     return self.chain[-1]

複製代碼

現在，讓我解釋一下正在發生的事情……

1. 構建第一個 Block 類
區塊鏈由幾個相互連接的塊組成（聽起來很熟悉，對吧？）。

區塊鏈發生這樣的情況，如果一個區塊被篡改，則鏈的其餘部分將無效。

在應用上述概念時，我創建了以下初始塊類：

1. import hashlib
   
2. import time
   
3. 
   
4. class Block:
   
5.   def __init__(self, index, proof_no, prev_hash, data, timestamp=None):
   
6.     self.index = index
   
7.     self.proof_no = proof_no
   
8.     self.prev_hash = prev_hash
   
9.     self.data = data
   
10.     self.timestamp = timestamp or time.time()
    
11. 
    
12.   @property
    
13.   def calculate_hash(self):
    
14.     block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, self.prev_hash, self.data,self.timestamp)
    
15.     return hashlib.sha256(block_of_string.encode()).hexdigest()
    
16. 
    
17.   def __repr__(self):
    
18.     return "{} - {} - {} - {} - {}".format(self.index, self.proof_no,
    
19.     self.prev_hash, self.data,
    
20.     self.timestamp)

複製代碼

從上面的代碼可以看出，我定義了__init__()函數，它將在Block類啟動時執行，就像在任何其他 Python 類中一樣。

我為啟動函數提供了以下參數：

self — 引用Block類的實例，從而可以訪問與該類關聯的方法和屬性；
index——跟踪區塊在區塊鏈中的位置；
proof_no —這是在創建新區塊（稱為挖礦）期間產生的數字；
prev_hash——這是指鏈中前一個區塊的哈希值；
data——這給出了所有已完成交易的記錄，例如購買的數量；
timestamp——這為交易放置了一個時間戳。
類中的第二個方法calculate_hash將使用上述值生成塊的哈希值。項目導入SHA-256模塊，輔助獲取區塊的哈希值。

在將值輸入到加密哈希算法中後，該函數將返回一個 256 位的字符串，表示塊的內容。

這就是在區塊鏈中實現安全性的方式——每個區塊都有一個哈希值，而該哈希值將依賴於前一個區塊的哈希值。

因此，如果有人試圖破壞鏈中的任何塊，其他塊將具有無效的哈希值，從而導致整個區塊鍊網絡中斷。

最終，一個塊將如下所示：

1. {
   
2.   "index": 2,
   
3.   "proof": 21,
   
4.   "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823",
   
5.   "transactions": [
   
6.     {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}
   
7.   ],
   
8.   "timestamp": 1521646442.4096143
   
9. }

複製代碼

2. 構建區塊鏈類
顧名思義，區塊鏈的主要思想涉及將幾個塊“鏈接”到彼此。

因此，我將構建一個區塊鏈類，該類將有助於管理整個鏈的工作。這是大部分操作將發生的地方。

該Blockchain類將在blockchain完成各種任務的各種輔助方法。

讓我解釋一下類中每個方法的作用。

一個。構造方法
此方法可確保區塊鏈被實例化。

1. class BlockChain:
   
2.   def __init__(self):
   
3.     self.chain = []
   
4.     self.current_data = []
   
5.     self.nodes = set()
   
6.     self.construct_genesis()

複製代碼

以下是其屬性的作用：

self.chain——這個變量保存所有的塊；
self.current_data — 該變量保存區塊中所有已完成的交易；
self.construct_genesis() ——這個方法將負責構建初始塊。
灣 構建創世區塊
區塊鏈需要一個construct_genesis方法來構建鏈中的初始塊。在區塊鏈公約中，這個區塊很特別，因為它像徵著區塊鏈的開始。

在這種情況下，讓我們通過簡單地將一些默認值傳遞給construct_block方法來構建它。

我給proof_no和prev_hash的值都為零，儘管你可以提供任何你想要的值。

1. def construct_genesis(self):
   
2.   self.construct_block(proof_no=0, prev_hash=0)
   
3. 
   
4. def construct_block(self, proof_no, prev_hash):
   
5.   block = Block(
   
6.   index=len(self.chain),
   
7.   proof_no=proof_no,
   
8.   prev_hash=prev_hash,
   
9.   data=self.current_data)
   
10.   self.current_data = []
    
11.   self.chain.append(block)
    
12.   return block

複製代碼

C。構建新塊

該construct_block 方法用於在blockchain創造新的塊。

以下是此方法的各種屬性發生的情況：

index-這表示blockchain的長度;
proof_nor & prev_hash——調用者方法傳遞它們；
data——這包含所有未包含在節點上任何塊中的交易的記錄；
self.current_data — 用於重置節點上的事務列表。如果已經構建了一個塊並將交易分配給它，則重置列表以確保將來的交易添加到此列表中。並且，這個過程會持續進行；
self.chain.append()——這個方法將新構建的塊連接到鏈上；
return -最後，返回一個構造的塊對象。

d. 檢查有效性

該check_validity方法是評估blockchain的完整性，確保異常是缺席重要。
如前所述，散列對於區塊鏈的安全性至關重要，因為即使對像中最輕微的變化也會導致生成全新的散列。

因此，這個check_validity 方法使用if語句來檢查每個塊的哈希是否正確。

它還通過比較它們的哈希值來驗證每個塊是否指向正確的前一個塊。如果一切正確，則返回 true；否則，它返回 false。

1. @staticmethod
   
2. def check_validity(block, prev_block):
   
3.   if prev_block.index + 1 != block.index:
   
4.     return False
   
5. 
   
6.   elif prev_block.calculate_hash != block.prev_hash:
   
7.     return False
   
8. 
   
9.   elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no):
   
10.     return False
    
11. 
    
12.   elif block.timestamp <= prev_block.timestamp:
    
13.     return False
    
14. 
    
15.   return True

複製代碼

e. 添加交易數據
該NEW_DATA方法用於添加事務的數據的塊。這是一個非常簡單的方法：它接受三個參數（發送者的詳細信息、接收者的詳細信息和數量）並將交易數據附加到self.current_data列表中。
每當創建一個新塊時，該列表都會分配給該塊並再次重置，如construct_block方法中所述。
一旦將交易數據添加到列表中，將返回下一個要創建的塊的索引。

該索引是通過將當前塊（區塊鏈中的最後一個）的索引加 1 來計算的。該數據將幫助用戶在未來提交交易。

1. def new_data(self, sender, recipient, quantity):
   
2.   self.current_data.append({
   
3.   'sender': sender,
   
4.   'recipient': recipient,
   
5.   'quantity': quantity
   
6.   })
   
7.   return True

複製代碼

F。添加工作證明

工作量證明是一個防止區塊鏈被濫用的概念。簡而言之，它的目標是確定在完成一定量的計算工作後解決問題的數字。

如果識別號碼的難度級別很高，它會阻止垃圾郵件和篡改區塊鏈。

在這種情況下，我們將使用一個簡單的算法來阻止人們挖掘區塊或輕鬆創建區塊。

1. @staticmethod
   
2. def proof_of_work(last_proof):
   
3.   '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes
   
4.   f is the previous f'
   
5.   f' is the new proof
   
6.   '''
   
7.   proof_no = 0
   
8.   while BlockChain.verifying_proof(proof_no, last_proof) is False:
   
9.     proof_no += 1
   
10. 
    
11.   return proof_no
    
12. 
    
13. 
    
14. @staticmethod
    
15. def verifying_proof(last_proof, proof):
    
16.   #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?
    
17. 
    
18.   guess = f'{last_proof}{proof}'.encode()
    
19.   guess_hash = hashlib.sha256(guess).hexdigest()
    
20.   return guess_hash[:4] == "0000"

複製代碼

G。獲取最後一個區塊

最後，latest_block 方法是幫助獲取區塊鏈中最後一個區塊的輔助方法。請記住，最後一個塊實際上是鏈中的當前塊。

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

複製代碼

讓我們總結一下

這是創建fccCoin加密貨幣的完整代碼。

您還可以在此 GitHub 存儲庫中獲取代碼。

1. import hashlib
   
2. import time
   
3. 
   
4. 
   
5. class Block:
   
6. 
   
7.   def __init__(self, index, proof_no, prev_hash, data, timestamp=None):
   
8.     self.index = index
   
9.     self.proof_no = proof_no
   
10.     self.prev_hash = prev_hash
    
11.     self.data = data
    
12.     self.timestamp = timestamp or time.time()
    
13. 
    
14.   @property
    
15.   def calculate_hash(self):
    
16.     block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no,
    
17.     self.prev_hash, self.data,
    
18.     self.timestamp)
    
19. 
    
20.     return hashlib.sha256(block_of_string.encode()).hexdigest()
    
21. 
    
22.   def __repr__(self):
    
23.     return "{} - {} - {} - {} - {}".format(self.index, self.proof_no,
    
24.     self.prev_hash, self.data,
    
25.     self.timestamp)
    
26. 
    
27. 
    
28. class BlockChain:
    
29. 
    
30.   def __init__(self):
    
31.     self.chain = []
    
32.     self.current_data = []
    
33.     self.nodes = set()
    
34.     self.construct_genesis()
    
35. 
    
36.   def construct_genesis(self):
    
37.     self.construct_block(proof_no=0, prev_hash=0)
    
38. 
    
39.   def construct_block(self, proof_no, prev_hash):
    
40.     block = Block(
    
41.     index=len(self.chain),
    
42.     proof_no=proof_no,
    
43.     prev_hash=prev_hash,
    
44.     data=self.current_data)
    
45.     self.current_data = []
    
46. 
    
47.     self.chain.append(block)
    
48.     return block
    
49. 
    
50.   @staticmethod
    
51.   def check_validity(block, prev_block):
    
52.     if prev_block.index + 1 != block.index:
    
53.       return False
    
54. 
    
55.     elif prev_block.calculate_hash != block.prev_hash:
    
56.       return False
    
57. 
    
58.     elif not BlockChain.verifying_proof(block.proof_no,
    
59.     prev_block.proof_no):
    
60.       return False
    
61. 
    
62.     elif block.timestamp <= prev_block.timestamp:
    
63.       return False
    
64. 
    
65.     return True
    
66. 
    
67.   def new_data(self, sender, recipient, quantity):
    
68.     self.current_data.append({
    
69.     'sender': sender,
    
70.     'recipient': recipient,
    
71.     'quantity': quantity
    
72.     })
    
73.     return True
    
74. 
    
75.   @staticmethod
    
76.   def proof_of_work(last_proof):
    
77.     '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes
    
78.     f is the previous f'
    
79.     f' is the new proof
    
80.     '''
    
81.     proof_no = 0
    
82.     while BlockChain.verifying_proof(proof_no, last_proof) is False:
    
83.       proof_no += 1
    
84. 
    
85.     return proof_no
    
86. 
    
87.   @staticmethod
    
88.   def verifying_proof(last_proof, proof):
    
89.     #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?
    
90. 
    
91.     guess = f'{last_proof}{proof}'.encode()
    
92.     guess_hash = hashlib.sha256(guess).hexdigest()
    
93.     return guess_hash[:4] == "0000"
    
94. 
    
95.   @property
    
96.   def latest_block(self):
    
97.     return self.chain[-1]
    
98. 
    
99.   def block_mining(self, details_miner):
    
100. 
     
101.     self.new_data(
     
102.     sender="0",  #it implies that this node has created a new block
     
103.     receiver=details_miner,
     
104.     quantity=1,  #creating a new block (or identifying the proof number) is awarded with 1
     
105.     )
     
106. 
     
107.     last_block = self.latest_block
     
108. 
     
109.     last_proof_no = last_block.proof_no
     
110.     proof_no = self.proof_of_work(last_proof_no)
     
111. 
     
112.     last_hash = last_block.calculate_hash
     
113.     block = self.construct_block(proof_no, last_hash)
     
114. 
     
115.     return vars(block)
     
116. 
     
117.   def create_node(self, address):
     
118.     self.nodes.add(address)
     
119.     return True
     
120. 
     
121.   @staticmethod
     
122.   def obtain_block_object(block_data):
     
123.     #obtains block object from the block data
     
124. 
     
125.     return Block(
     
126.     block_data['index'],
     
127.     block_data['proof_no'],
     
128.     block_data['prev_hash'],
     
129.     block_data['data'],
     
130.     timestamp=block_data['timestamp'])

複製代碼

現在，讓我們測試我們的代碼，看看它是否有效。

1. blockchain = BlockChain()
   
2. 
   
3. print("***Mining fccCoin about to start***")
   
4. print(blockchain.chain)
   
5. 
   
6. last_block = blockchain.latest_block
   
7. last_proof_no = last_block.proof_no
   
8. proof_no = blockchain.proof_of_work(last_proof_no)
   
9. 
   
10. blockchain.new_data(
    
11.     sender="0",  #it implies that this node has created a new block
    
12.     recipient="Quincy Larson",  #let's send Quincy some coins!
    
13.     quantity=1,  #creating a new block (or identifying the proof number) is awarded with 1
    
14. )
    
15. 
    
16. last_hash = last_block.calculate_hash
    
17. block = blockchain.construct_block(proof_no, last_hash)
    
18. 
    
19. print("***Mining fccCoin has been successful***")
    
20. print(blockchain.chain)

複製代碼

有效！

這是挖礦過程的輸出：

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

複製代碼

結論

你有它！

這就是您可以使用 Python 創建自己的區塊鏈的方式。

讓我說，本教程只是演示了讓您涉足創新區塊鏈技術的基本概念。

如果按原樣部署該硬幣，則無法滿足當前市場對穩定、安全和易於使用的加密貨幣的需求。

因此，它仍然可以通過添加附加功能來改進其挖掘和發送金融交易的能力。

儘管如此，如果您決定讓您的名字在令人驚嘆的加密貨幣世界中廣為人知，這是一個很好的起點。

文章出處