如何使用Python创建自己的加密货币

发表于:2021-3-02 09:22

字体: | 上一篇 | 下一篇 | 我要投稿

 作者:链三丰    来源:区块链研究实验室

#
Python
分享:
  随着当前加密货币的兴起,区块链在技术界引起了轰动。
  这项技术之所以吸引了如此多的关注,主要是因为它具有保证安全,强制分权和加快多个行业(尤其是金融行业)流程的能力。
  本质上,区块链是一个公共数据库,它不可逆地记录和认证数字资产的拥有和传输。像比特币和以太坊这样的数字货币就是基于这个概念。
  区块链是一项令人兴奋的技术,可用于转换应用程序的功能。
  最近,我们看到政府,组织和个人使用区块链技术来创建自己的加密货币。值得注意的是,当Facebook提出自己的加密货币Libra时,这一公告激起了全世界的许多热潮。
  如果您也可以效仿并创建自己的加密货币版本,你应该如何着手?
  我考虑了这一点,决定开发一种可以创建加密货币的算法。
  我决定将加密货币称为fccCoin。
  在本教程中,我将逐步说明构建数字货币的过程(我使用了Python编程语言的面向对象概念)。
  这是用于创建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.建立第一个Block类
  区块链由几个相互连接的块组成,因此,如果一个块被篡改,则链将变为无效。
  在应用上述概念时,我创建了以下初始块类:
  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 __()函数,该函数将在启动Block类时执行,就像在其他任何Python类中一样。
  我为启动函数提供了以下参数:
  · self-引用Block类的实例,从而可以访问与该类关联的方法和属性;
  · 索引—跟踪区块链在区块链中的位置;
  · proof_no-这是在创建新块(称为挖矿)期间产生的数量;
  · prev_hash —这是指链中上一个块的哈希值;
  · 数据-提供所有已完成交易的记录,例如购买数量;
  · 时间戳记-为事务放置时间戳记。
  类中的第二个方法calculate_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完成各种任务的各种辅助方法。
  让我解释一下每个方法在类中的作用。
  A.构造方法
  此方法确保实例化区块链。
  class BlockChain: 
   
      def __init__(self): 
          self.chain = [] 
          self.current_data = [] 
          self.nodes = set() 
          self.construct_genesis() 
  以下是其属性的作用:
  · self.chain-此变量保留所有块;
  · self.current_data-此变量将所有已完成的事务保留在该块中;
  · self.construct_genesis() -此方法将负责构造初始块。
  B.构建创世块
  区块链需要一个construct_genesis方法来构建链中的初始块。在区块链惯例中,此块是特殊的,因为它象征着区块链的开始。
  在这种情况下,让我们通过简单地将一些默认值传递给Construct_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 
  C.建造新的街区
  该construct_block 方法用于在blockchain创造新的块。
  这是此方法的各种属性所发生的情况:
  · 索引-代表区块链的长度;
  · proof_nor&prev_hash —调用者方法传递它们;
  · 数据-包含节点上任何块中未包含的所有事务的记录;
  · self.current_data-用于重置节点上的事务列表。如果已经构造了一个块并将事务分配给该块,则会重置该列表以确保将来的事务被添加到该列表中。并且,该过程将连续进行;
  · self.chain.append()-此方法将新构建的块连接到链;
  · return-最后,返回一个构造的块对象。
  D.检查有效性
  该check_validity方法是评估blockchain的完整性,确保异常是绝对重要。
  如上所述,散列对于区块链的安全至关重要,因为即使对象发生任何细微变化也将导致生成全新的哈希。
  因此,此check_validity 方法使用if语句检查每个块的哈希是否正确。
  它还通过比较其哈希值来验证每个块是否指向正确的上一个块。如果一切正确,则返回true;否则,返回true。否则,它返回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.添加交易数据
  该NEW_DATA方法用于添加事务的数据的块。这是一种非常简单的方法:它接受三个参数(发送者的详细信息,接收者的详细信息和数量),并将交易数据附加到self.current_data列表中。
  每当创建新块时,都会将该列表分配给该块,并再次按Construct_block方法中的说明进行重置。
  将交易数据添加到列表后,将返回要创建的下一个块的索引。
  该索引是通过将当前块的索引(即区块链中的最后一个)的索引加1来计算的。数据将帮助用户将来提交交易。
  def new_data(self, sender, recipient, quantity): 
      self.current_data.append({ 
          'sender': sender, 
          'recipient': recipient, 
          'quantity': quantity 
      }) 
      return True 
  F.添加工作证明
  工作量证明是防止区块链滥用的概念。简而言之,其目的是在完成一定数量的计算工作后,确定一个可以解决问题的编号。
  如果识别数字的难度很高,则不鼓励发送垃圾邮件和篡改区块链。
  在这种情况下,我们将使用一种简单的算法来阻止人们挖掘区块或轻松创建区块。
  @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.得到最后一块
  最后,latest_block 方法是一种帮助程序方法,可帮助获取区块链中的最后一个块。请记住,最后一个块实际上是链中的当前块。
  @property 
      def latest_block(self): 
          return self.chain[-1] 
  总结
  这是用于创建fccCoin加密货币的完整代码。
  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']) 
  现在,让我们测试我们的代码,看看它是否有效。
  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) 
  有效!
  这是挖掘过程的输出:
  ***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] 
  结论
  以上就是使用Python创建自己的区块链的方式。
  如果按原样部署该代币,它将无法满足当前市场对稳定,安全且易于使用的加密货币的需求。
  因此,仍可以通过添加其他功能来增强其挖掘和发送财务交易的功能,从而对其进行改进。

  本文内容不用于商业目的,如涉及知识产权问题,请权利人联系51Testing小编(021-64471599-8017),我们将立即处理
《2023软件测试行业现状调查报告》独家发布~

关注51Testing

联系我们

快捷面板 站点地图 联系我们 广告服务 关于我们 站长统计 发展历程

法律顾问:上海兰迪律师事务所 项棋律师
版权所有 上海博为峰软件技术股份有限公司 Copyright©51testing.com 2003-2024
投诉及意见反馈:webmaster@51testing.com; 业务联系:service@51testing.com 021-64471599-8017

沪ICP备05003035号

沪公网安备 31010102002173号