用最通俗的方式聊聊区块链和比特币¶

# We want the hash value starts with '00000'
difficulty = 5
answer = '0'*difficulty

def compute_hash(data,nonce):
    return sha256((data+str(nonce)).encode()).hexdigest()

data = '123'
nonce = 1 # data to change

# init hash_value    
hash_value = compute_hash(data,nonce)

# change nonce recursively until hash_value begins with the answer.
while hash_value[:difficulty] != answer:
    nonce += 1
    hash_value = compute_hash(data,nonce)


print('tryout times:',nonce)
print('hash_value:',hash_value)

tryout times: 96064
hash_value: 00000bdebc0a945fcd1a1b6127267393dfc299c89b031b7879d926a32921e9f6

from hashlib import sha256
import time
import json
import logging
from typing import Dict, List
import rsa


# block + chain
class Block():
    def __init__(self, transactions: List, prev_hash):
        # transaction -> list of objects
        self.transactions = transactions
        self.prev_hash = prev_hash
        self.nonce = 1  # use for mining
        self.timestamp = time.time()
        self.hash = self.compute_hash()

    def __repr__(self):
        return f"{self.transactions}"

    def compute_hash(self):
        block_string = "{}{}{}{}".format(json.dumps(
            self.transactions), self.prev_hash, str(self.nonce), self.timestamp)
        return sha256(block_string.encode()).hexdigest()

    def validate_transaction(self):
        for transaction in self.transactions:
            if not transaction.is_valid():
                return False
            else:
                return True

    def mine(self, difficulty: int):
        if not self.validate_transaction():
            raise Exception('Abnormal transaction found, abort.')

        answer = '0'*difficulty

        while self.hash[:difficulty] != answer:
            self.nonce += 1
            self.hash = self.compute_hash()

        print(f'Finished mining, tryout times:{self.nonce}')


class Transaction(Dict):
    def __init__(self, payer, payee, amount):
        self.update(payer=payer)
        self.update(payee=payee)
        self.update(amount=amount)
        # self.timestamp = timestamp
        self.update(hash=self.compute_hash())

    def __repr__(self):
        return json.dumps(self)

    def sign(self, private_key):
        self.signature = rsa.sign_hash(
            hash_value=self['hash'].encode("utf-8"),
            priv_key=private_key,
            hash_method='SHA-256')

    def is_valid(self):
        if not self['payer']:
            return False

        else:
            # 这里由于没有引入数字签名，暂不验证
            return True

    def compute_hash(self):
        Transaction_string = "{}{}{}".format(
            self['payer'], self['payee'], self['amount'])
        return sha256(Transaction_string.encode()).hexdigest()


class BlockChain():
    def __init__(self, difficulty):
        self.chain = [self.create_genesis()]
        self.transactionPool = []
        self.Reward = 1
        self.difficulty = difficulty

    def set_difficulty(self, difficulty):
        self.difficulty = difficulty

    def create_genesis(self) -> Block:
        genesis_block = Block(transactions=[], prev_hash=0)
        return genesis_block

    def get_latest_block(self):
        return self.chain[-1]

    def add_block_to_chain(self, new_block: Block):
        if new_block.hash[:self.difficulty] == '0'*self.difficulty:
            new_block.prev_hash = self.get_latest_block().hash
            self.chain.append(new_block)
            print(f" a new block added to blockchain.")
        else:
            print('block validation failed.')

    def validate_chain(self):
        if len(self.chain) == 1:
            return self.chain[0].compute_hash() == self.chain[0].hash

        # validate block
        for i in range(1, len(self.chain)):
            block_to_validate = self.chain[i]

            # validate transactions in block
            if not block_to_validate.validate_transaction():
                logging.error('Fraud transactions!')
                return False

            # validate data in this block hasn't been tampered
            elif not block_to_validate.hash == block_to_validate.compute_hash():
                logging.error(
                    f'Data has been tampered! \n this hash:{block_to_validate.hash} \n computed hash:{block_to_validate.compute_hash()}')
                return False

            # validate block.prev_hash == previous block.hash
            elif not block_to_validate.prev_hash() == self.chain[i-1].hash:
                logging.error('Chain broke!')
                return False

            else:
                return True
    pass

# test
# 创建区块链，同时生成创始区块
blockchain = BlockChain(4)

transaction1 = Transaction(payer='Paparazzi', payee='Elephant', amount='666')

transaction2 = Transaction(payer='Elephant', payee='Sylar', amount='100')

# add one block to chain
block1 = Block(
    transactions=[transaction1],
    prev_hash=blockchain.get_latest_block().hash)
block1.mine(difficulty=4)
blockchain.add_block_to_chain(block1)
print(f"hash of block1: {block1.hash}")

# add another block to chain
block2 = Block(
    transactions=[transaction2],
    prev_hash=blockchain.get_latest_block().hash)
block2.mine(difficulty=5)
blockchain.add_block_to_chain(block2)
print(f"hash of block2: {block1.hash}")

# Output:
Finished mining, tryout times:222523
 a new block added to blockchain.
hash of block1: 0000d7f7e1018f498431eefa24faf7ab6b8ec9c42ecf89d1039939f8f74c15d5
Finished mining, tryout times:1321891
 a new block added to blockchain.
hash of block2: 0000018c800c81b750dae4785652efc679929177c6fed9b0d268627f038dde1c

print(f"previous hash of last block:{blockchain.chain[-1].prev_hash}")
print(f"hash of second last block:{blockchain.chain[-2].hash}")

# Output:
previous hash of last block:0000c245596fd46a0a8b80e8c2f84efb7f19b077a1a61881260f95dc6098d57a
hash of second last block:0000c245596fd46a0a8b80e8c2f84efb7f19b077a1a61881260f95dc6098d57a