From 97ae1b4bd0b0af2854c32e18a5b6c18cfa908ffd Mon Sep 17 00:00:00 2001 From: Lucas de Souza <201293@gmail.com> Date: Sun, 19 Sep 2021 20:16:59 -0300 Subject: [PATCH] Code from blockchain --- .../README.md | 6 + .../blockchain.py | 280 ++++++++++++++++++ 2 files changed, 286 insertions(+) create mode 100644 python/blockchain/learn_blockchains_by_building_one/README.md create mode 100644 python/blockchain/learn_blockchains_by_building_one/blockchain.py diff --git a/python/blockchain/learn_blockchains_by_building_one/README.md b/python/blockchain/learn_blockchains_by_building_one/README.md new file mode 100644 index 0000000..85440e8 --- /dev/null +++ b/python/blockchain/learn_blockchains_by_building_one/README.md @@ -0,0 +1,6 @@ +Tutorial about this code: +https://hackernoon.com/learn-blockchains-by-building-one-117428612f46 + +Visual explanation about blockchain: +https://andersbrownworth.com/blockchain/ +https://www.youtube.com/watch?v=bBC-nXj3Ng4 diff --git a/python/blockchain/learn_blockchains_by_building_one/blockchain.py b/python/blockchain/learn_blockchains_by_building_one/blockchain.py new file mode 100644 index 0000000..5b7c164 --- /dev/null +++ b/python/blockchain/learn_blockchains_by_building_one/blockchain.py @@ -0,0 +1,280 @@ +import hashlib +import json +from textwrap import dedent +from time import time +from uuid import uuid4 +import requests + +from flask import Flask, jsonify, request +from urllib.parse import urlparse + +class Blockchain(object): + def __init__(self): + self.chain = [] + self.current_transactions = [] + self.nodes = set() + + # 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 + :param proof: The proof given by the Proof of Work algorithm + :param previous_hash: (Optional) 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 transaction + self.current_transactions = [] + + self.chain.append(block) + return block + + def new_transaction(self, sender, recipient, amount): + """ + Creates a new transaction to go into the next mined Block + :param sender: Address of the Sender + :param recipient: Address of Recipient + :param amount: Amount + :return: Block + :return: + """ + + # 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): + """ + Simple Proof of Work Algorithm: + - Find a number p' such that hash(pp') contains leading 4 zeroes, where o is the previous p' + - p is the previous proof, and p' is the new proof + :param last_proof: + :return: + """ + + 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? + :param last_proof: Previous Proof + :param proof: Current Proof + :return: True if correct, False if not. + """ + + guess = f'{last_proof}{proof}'.encode() + guess_hash = hashlib.sha256(guess).hexdigest() + return guess_hash[:4] == "0000" + + def register_node(self, address): + """ + Add a new node to the list of nodes + :param address: Address of node. Eg. 'http://192.168.0.5:5000' + :return: None + """ + + parsed_url = urlparse(address) + self.nodes.add(parsed_url.netloc) + + def valid_chain(self, chain): + """ + Determine if a given blockchain is valid + :param chain: A blockchain + :return: True if valid, False if not + """ + + last_block = chain[0] + current_index = 1 + + while current_index < len(chain): + block = chain[current_index] + print(f'{last_block}') + print(f'{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): + """ + This is our Consensus Algorithm, it resolves conflicts + by replacing our chain with the longest one in the network. + :return: True if our chain was replaced, False if not + """ + + 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(f'http://{node}/chain') + + if response.status_code == 200: + length = response.json()['length'] + chain = response.json()['chain'] + + # Check if the legth is longerand 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 + + +# Instantiate our Node +app = Flask(__name__) + +# Generate a globally unique address for this node +node_identifier = str(uuid4()).replace('-', '') + +# Instantiate the BLockchain +blockchain = Blockchain() + +@app.route('/mine', methods=['GET']) +def mine(): + # We run the proof of work algorithm to get the next proof... + last_block = blockchain.last_block + last_proof = last_block['proof'] + proof = blockchain.proof_of_work(last_proof) + + # We must receive a reward for finding the proof + # The sender is "0" to signify that this node has mined a new coin. + blockchain.new_transaction( + sender="0", + recipient=node_identifier, + amount=1, + ) + + # Forge the new Block by adding it to the chain + previous_hash = blockchain.hash(last_block) + block = blockchain.new_block(proof, previous_hash) + + response = { + 'message': "New Block Forged", + 'index': block['index'], + 'transactions': block['transactions'], + 'proof': block['proof'], + 'previous_hash': block['previous_hash'], + } + print(response) + return jsonify(response), 200 + +@app.route('/transactions/new', methods=['POST']) +def new_transaction(): + values = request.get_json() + + # Check that the required fields are in the POST'ed data + required = ['sender', 'recipient', 'amount'] + if not all(k in values for k in required): + return 'Missing values', 400 + + # Create a new Transaction + index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount']) + + response = {'message': f'Transaction will be added to Block {index}'} + return jsonify(response), 201 + +@app.route('/chain', methods=['GET']) +def full_chain(): + response = { + 'chain': blockchain.chain, + 'length': len(blockchain.chain), + } + return jsonify(response), 200 + +@app.route('/nodes/register', methods=['POST']) +def register_node(): + values = request.get_json() + + nodes = values.get('nodes') + if nodes is None: + return "Error: Please supply a valid list of nodes", 400 + + for node in nodes: + blockchain.register_node(node) + + response = { + 'message': 'New nodes have been added', + 'total_nodes': list(blockchain.nodes), + } + return jsonify(respones), 201 + +@app.route('/nodes/resolve', methods=['GET']) +def consensus(): + replaced = blockchain.resolve_conflicts() + + if replace: + response = { + 'message': 'Our chain was replaced', + 'new_chain': blockchain.chain + } + else: + response = { + 'message': 'Our chain is authoritative', + 'chain': blockchain.chain + } + + return jsonify(response), 200 + +if __name__ == '__main__': + from argparse import ArgumentParser + + parser = ArgumentParser() + parser.add_argument('-p', '--port', default=5000, type=int, help='port to listen on') + args = parser.parse_args() + port = args.port + + app.run(host='0.0.0.0', port=port) +