Binno

[Jabka25]

import hashlib import json from time import time from uuid import uuid4

class Blockchain: def init(self): self.chain = [] self.current_transactions = [] # Create the genesis block self.new_block(previous_hash='1', proof=100)

def new_block(self, proof, previous_hash=None):
    """
    Create a new Block in the Blockchain
    """
    block = {
        'index': len(self.chain) + 1,
        'timestamp': time(),
        'transactions': self.current_transactions,
        'proof': proof,
        'previous_hash': previous_hash or self.hash(self.chain[-1]),
    }
    self.current_transactions = []
    self.chain.append(block)
    return block

def new_transaction(self, sender, recipient, amount):
    """
    Adds a new transaction to the list of transactions
    """
    self.current_transactions.append({
        'sender': sender,
        'recipient': recipient,
        'amount': amount,
    })
    return self.last_block['index'] + 1

@staticmethod
def hash(block):
    """
    Creates a SHA-256 hash of a Block
    """
    block_string = json.dumps(block, sort_keys=True).encode()
    return hashlib.sha256(block_string).hexdigest()

@property
def last_block(self):
    return self.chain[-1]

def proof_of_work(self, last_proof):
    """
    Simple Proof of Work Algorithm:
     - Find a number p' such that hash(pp') contains leading 4 zeroes, where p is the previous proof, and p' is the new proof
    """
    proof = 0
    while self.valid_proof(last_proof, proof) is False:
        proof += 1
    return proof

@staticmethod
def valid_proof(last_proof, proof):
    """
    Validates 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"