CuteBlockchain_v3

__author__ = 'etxxybc'
import hashlib
import  json
from  time import time
from uuid import uuid4
from textwrap import dedent
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()

    def register_node(self,address):
        parsed_url=urlparse(address)
        self.nodes.add(parsed_url.netloc)

    def new_block(self,proof, prevous_hash=None):
        block={"index":len(self.chain)+1,"timestamp":time(),"transactions":self.current_transactions,
               "proof":proof, "previous_hash":prevous_hash}
        self.current_transactions=[]
        self.chain.append(block)
        return block

    def new_genesis_block(self):
        proof=self.prrof_of_work(10)
        self.new_transaction(sender=0,recipient=node_identifier,amount=50)
        block={"index":1,"timestamp":time(),"transactions":self.current_transactions,
               "proof":proof, "previous_hash":"000000000000000000"}
        self.chain.append(block)
        self.current_transactions=[]
        return block

    def hash(self,block):
        block_string=json.dumps(block,sort_keys=True).encode()
        return  hashlib.sha256(block_string).hexdigest()

    def last_block(self):
        if len(self.chain) ==0:
            print("hit here !!!!!!!!!")
            return None
        else:
            return self.chain[-1]

    def new_transaction(self,sender, recipient,amount):
        self.current_transactions.append({"sender":sender, "recipient":recipient,"amount":amount})
        if self.last_block() is None:
            return 0
        return self.last_block()["index"]+1

    def prrof_of_work(self,last_proof):
        proof=0
        while self. valid_proof(last_proof,proof) is False:
            proof +=1

        return  proof

    def valid_proof(self,last_proof,proof):
        guess="{0}{1}".format(last_proof,proof).encode()
        guess_hash=hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

    def valid_chain(self,chain):
        last_block=chain[0]
        current_index=1
        while current_index < len(chain):
            block=chain[current_index]
            if block["previous_hash"] != self.hash(last_block):
                return False
            if not self.valid_proof(last_block["proof"],block["proof"]):
                return False
            last_block=block
            current_index += 1
            return True
    def resolve_conflicts(self):
        neighbours=self.nodes
        new_chain=None
        max_length=len(self.chain)
        for node in neighbours:
            response=request.get('http://{0}/chain'.format(node))
            if response.status_code == 200:
                length=response.json()["length"]
                chain=response.json()["chain"]
                if length > max_length and self.valid_chain(chain):
                    max_length=length
                    new_chain=chain

        if new_chain:
            self.chain=new_chain
            return True
        return  False



app=Flask(__name__)
node_identifier=str(uuid4()).replace("_","")
blockchain=BlockChain()

@app.route('/mine', methods=['GET'])
def mine():
    last_block=blockchain.last_block()
    block=None
    if last_block is None:
        block=blockchain.new_genesis_block()
        response={"message":"new block forged ", "index":block["index"],"transactions":block["transactions"],"proof":
        block["proof"],"previous_hash":block["previous_hash"]}
        return jsonify(response), 200
    last_proof=last_block["proof"]
    proof=blockchain.prrof_of_work(last_proof)
    blockchain.new_transaction(sender=0,recipient=node_identifier,amount=50)
    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"]}
    return jsonify(response), 200

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    values=request.get_json()
    required = ['sender', 'recipient', 'amount']
    if not all (k in values for k in required ):
        return "Missing Values ", 400
    index= blockchain.new_transaction(values["sender"],values["recipient"], values["amount"])
    msg="Transactions will be added to block {0}".format(index)
    response={"Message": msg}
    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('/ping', methods=['GET'])
def ping():
    return  "I am alive ..."

@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values=request.get_json()
    nodes=values.get("nodes")
    if nodes is None:
        return  jsonify({"Error":"please supply valid nodes"}), 400
    for node in nodes :
        blockchain.register_node(node)

    response={"Message":"new node has been added", "Tota;_nodes": list(blockchain.nodes)}
    return  jsonify(response), 201

@app.route("/nodes/resolve", methods=["GET"])
def consesus():
    replaced=blockchain.resolve_conflicts()
    if replaced:
        response={"Message": "our chain were replaced ", "new_chain":blockchain.chain}
    else:
        response={"Message": "our chain is authoritative "}

    return jsonify(response)


if __name__ == '__main__':
    app.run()