神剑山庄资源网 Design By www.hcban.com

随着当前加密货币的兴起,区块链在技术界引起了轰动。 

这项技术之所以吸引了如此多的关注,主要是因为它具有保证安全,强制分权和加快多个行业(尤其是金融行业)流程的能力。

本质上,区块链是一个公共数据库,它不可逆地记录和认证数字资产的拥有和传输。像比特币和以太坊这样的数字货币就是基于这个概念。 

区块链是一项令人兴奋的技术,可用于转换应用程序的功能。

最近,我们看到政府,组织和个人使用区块链技术来创建自己的加密货币。值得注意的是,当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"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"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创建自己的区块链的方式。

如果按原样部署该代币,它将无法满足当前市场对稳定,安全且易于使用的加密货币的需求。

因此,仍可以通过添加其他功能来增强其挖掘和发送财务交易的功能,从而对其进行改进。

以上就是Python创建自己的加密货币的示例的详细内容,更多关于Python创建自己的加密货币的资料请关注其它相关文章!

标签:
python,加密,python,创建加密货币,python,区块链

神剑山庄资源网 Design By www.hcban.com
神剑山庄资源网 免责声明:本站文章均来自网站采集或用户投稿,网站不提供任何软件下载或自行开发的软件! 如有用户或公司发现本站内容信息存在侵权行为,请邮件告知! 858582#qq.com
神剑山庄资源网 Design By www.hcban.com

评论“Python创建自己的加密货币的示例”

暂无Python创建自己的加密货币的示例的评论...

《魔兽世界》大逃杀!60人新游玩模式《强袭风暴》3月21日上线

暴雪近日发布了《魔兽世界》10.2.6 更新内容,新游玩模式《强袭风暴》即将于3月21 日在亚服上线,届时玩家将前往阿拉希高地展开一场 60 人大逃杀对战。

艾泽拉斯的冒险者已经征服了艾泽拉斯的大地及遥远的彼岸。他们在对抗世界上最致命的敌人时展现出过人的手腕,并且成功阻止终结宇宙等级的威胁。当他们在为即将于《魔兽世界》资料片《地心之战》中来袭的萨拉塔斯势力做战斗准备时,他们还需要在熟悉的阿拉希高地面对一个全新的敌人──那就是彼此。在《巨龙崛起》10.2.6 更新的《强袭风暴》中,玩家将会进入一个全新的海盗主题大逃杀式限时活动,其中包含极高的风险和史诗级的奖励。

《强袭风暴》不是普通的战场,作为一个独立于主游戏之外的活动,玩家可以用大逃杀的风格来体验《魔兽世界》,不分职业、不分装备(除了你在赛局中捡到的),光是技巧和战略的强弱之分就能决定出谁才是能坚持到最后的赢家。本次活动将会开放单人和双人模式,玩家在加入海盗主题的预赛大厅区域前,可以从强袭风暴角色画面新增好友。游玩游戏将可以累计名望轨迹,《巨龙崛起》和《魔兽世界:巫妖王之怒 经典版》的玩家都可以获得奖励。