import hashlib

import json

import requests

from time import time

from urllib.parse import urlparse

class BlockChain:

def __init__(self):

# 储存交易

self.current_transactions = []

# 储存区块链

self.chain = []

# 储存节点

self.nodes = set()

# 创建创世块

self.new_block(previous_hash='1', proof=100)

def register_node(self, address):

"""

Add a new node to the list of nodes

:param address: Address of node. Eg. 'http://localhost:5001'

"""

parsed_url = urlparse(address)

self.nodes.add(parsed_url.netloc)

def valid_chain(self, chain):

"""

Determine if a given block chain is valid

:param chain: A block chain

:return: True if valid, False if not

"""

last_block = chain[0]

current_index = 1

while current_index < len(chain):

block = chain[current_index]

print('{last_block}')

print('{block}')

print("\n-----------\n")

# Check that the hash of the block is correct

if block['previous_hash'] != self.hash(last_block):

return False

# Check that the Proof of Work is correct

if not self.valid_proof(last_block['proof'], block['proof']):

return False

last_block = block

current_index += 1

return True

def resolve_conflicts(self):

"""

共识算法解决冲突

使用网络中最长的链.

:return: 如果链被取代返回 True, 否则为False

"""

neighbours = self.nodes

new_chain = None

# We're only looking for chains longer than ours

max_length = len(self.chain)

# Grab and verify the chains from all the nodes in our network

for node in neighbours:

response = requests.get('http://{}/chain'.format(node))

if response.status_code == 200:

length = response.json()['length']

chain = response.json()['chain']

# Check if the length is longer and the chain is valid

if length > max_length and self.valid_chain(chain):

max_length = length

new_chain = chain

# Replace our chain if we discovered a new, valid chain longer than ours

if new_chain:

self.chain = new_chain

return True

return False

def new_block(self, proof, previous_hash):

"""

生成新块

:param proof: The proof given by the Proof of Work algorithm

:param previous_hash: Hash of previous Block

:return: New Block

"""

block = {

'index': len(self.chain) + 1,

'timestamp': time(),

'transactions': self.current_transactions,

'proof': proof,

'previous_hash': previous_hash or self.hash(self.chain[-1]),

}

# Reset the current list of transactions

self.current_transactions = []

self.chain.append(block)

return block

def new_transaction(self, sender, recipient, amount):

"""

生成新交易信息，信息将加入到下一个待挖的区块中

:param sender: Address of the Sender

:param recipient: Address of the Recipient

:param amount: Amount

:return: The index of the Block that will hold this transaction

"""

self.current_transactions.append({

'sender': sender,

'recipient': recipient,

'amount': amount,

})

return self.last_block['index'] + 1

@property

def last_block(self):

return self.chain[-1]

@staticmethod

def hash(block):

"""

生成块的 SHA-256 hash值

:param block: Block

"""

# We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes

block_string = json.dumps(block, sort_keys=True).encode()

return hashlib.sha256(block_string).hexdigest()

def proof_of_work(self, last_proof):

"""

简单的工作量证明:

- 查找一个 p' 使得 hash(pp') 以4个0开头

- p 是上一个块的证明, p' 是当前的证明

"""

proof = 0

while self.valid_proof(last_proof, proof) is False:

proof += 1

return proof

@staticmethod

def valid_proof(last_proof, proof):

"""

验证证明: 是否hash(last_proof, proof)以4个0开头

:param last_proof: Previous Proof

:param proof: Current Proof

:return: True if correct, False if not.

"""

guess = '{last_proof}{proof}'.encode()

guess_hash = hashlib.sha256(guess).hexdigest()

# return guess_hash[:4] == "0000"

# 此处为便于测试结果，设置一个比较容易获得的数字

return guess_hash[:1] == "5"