Learning-BlockChain.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hashlib import sha256\n",
    "import hashlib\n",
    "import json\n",
    "from uuid import uuid4\n",
    "from time import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ##Blueprint of Our Blockchain Class\n",
    "\n",
    "# \"\"\" \n",
    "# Let's Create a Class name BlockChain which create initial Empty List for storing the Blockchian and transcation\n",
    "# \"\"\"\n",
    "\n",
    "# class Blockchain(object):\n",
    "    \n",
    "#     def __init__(self):\n",
    "#         \"\"\"\n",
    "#         Create two empty list one for Blockchain, and another for Transcation\n",
    "#         \"\"\"\n",
    "        \n",
    "#         self.chain = []\n",
    "#         self.current_transcations = []\n",
    "        \n",
    "#     def new_block(self):\n",
    "#         \"\"\" Create a new Block and adds it to the chain \"\"\"\n",
    "#         pass\n",
    "        \n",
    "#     def new_transcation(self):\n",
    "#         \"\"\" Add a new Transcation to the transcations list \"\"\"\n",
    "#         pass\n",
    "    \n",
    "#     @staticmethod\n",
    "#     def hash(block):\n",
    "#         \"\"\" return hash of the given Block \"\"\"\n",
    "        \n",
    "#     @property\n",
    "#     def last_block(self):\n",
    "#         \"\"\" Pythonic way to return the last time of the list \"\"\"\n",
    "#         pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Blockchain(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        Create two empty list one for Blockchain, and another for Transcation\n",
    "        \"\"\"\n",
    "        \n",
    "        self.chain = []\n",
    "        self.current_transcations = []\n",
    "        \n",
    "        # create the genesis block\n",
    "        self.new_block(previous_hash=1, proof=100)\n",
    "        \n",
    "    def new_block(self, previous_hash, proof):\n",
    "        \"\"\" \n",
    "        Create a new Block and adds it to the Blockchain \n",
    "        :param previous_hash: <str> Hash of the previous Block\n",
    "        :param proof: <int> The proof given by the proof of work algorithm\n",
    "        :return: <dict> New Block\n",
    "        \"\"\"\n",
    "        \n",
    "        block = {\n",
    "            'index' : len(self.chain)+1,\n",
    "            'timestamp' : time(),\n",
    "            'transactions' : self.current_transcations,\n",
    "            'proof' : proof,\n",
    "            'previous_hash' : previous_hash\n",
    "        }\n",
    "    \n",
    "        # Reset the current list of the transcation\n",
    "        self.current_transcations = []\n",
    "        self.chain.append(block)\n",
    "        return block\n",
    "        \n",
    "    def new_transcation(self, sender, recipient, amount):\n",
    "        \"\"\"\n",
    "        Create a new Transcation to go into the next mind Block\n",
    "        :param sender: <str> Address to the Sender\n",
    "        :param recipient: <str> Address to the Recipient\n",
    "        :param amount: <int> Amount\n",
    "        :return: <int> The index of the block that hold the transcation\n",
    "        \"\"\"\n",
    "        \n",
    "        self.current_transcations.append({\n",
    "            'sender' : sender,\n",
    "            'recipient' : recipient,\n",
    "            'amount' : amount,\n",
    "        })\n",
    "    \n",
    "        return self.last_block['index']+1\n",
    "    @staticmethod\n",
    "    def hash(block):\n",
    "        \"\"\" \n",
    "        Create a SHA-256 hash of a Block\n",
    "        :param block: <dict> Block\n",
    "        :return: <str>\n",
    "        \"\"\"\n",
    "        \n",
    "        # we must make sure that dict is Orderd, else we'll have Inconsistent Hash\n",
    "        block_string = json.dumps(block, sort_keys=True).encode()\n",
    "        return sha256(block_string).hexdigest()\n",
    "        \n",
    "        \n",
    "    @property\n",
    "    def last_block(self):\n",
    "        \"\"\" Pythonic way to return the last time of the list \"\"\"\n",
    "        self.chain[-1]\n",
    "        \n",
    "    def proof_of_work(self, last_proof):\n",
    "        \"\"\" \n",
    "        simple Proof of Work's Algorithm\n",
    "        - Find a number p' such that hash(pp') contain leading 4 zeros, where p is the previous p'\n",
    "        - p is the previous proof, p' is the new proof\n",
    "        :param last_proof: <int>\n",
    "        :return: <int>\n",
    "        \"\"\"\n",
    "        \n",
    "        proof = 0\n",
    "        while self.valid_proof(last_proof, proof) is False:\n",
    "            proof += 1\n",
    "        return proof\n",
    "    \n",
    "    @staticmethod\n",
    "    def valid_proof(last_proof, proof):\n",
    "        \"\"\"\n",
    "        Validate the proof: Does hash(last_proof, proof) contatin 4 leading zeroes?\n",
    "        :param last_proof: <int> Previous Proof\n",
    "        :param proof: <int> Current Proof\n",
    "        :return: <bool> True if correct, False incase of Incorrect\n",
    "        \"\"\"\n",
    "        \n",
    "        guess = f'{last_proof}{proof}'.encode()\n",
    "        guess_hash = sha256(guess).hexdigest()\n",
    "        return guess_hash[:4] == \"0000\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# block = {\n",
    "#             'index' : 1,\n",
    "#             'timestamp' : time(),\n",
    "#             'transactions' : {\n",
    "#                 'sender' : \"8527147fe1f5426f9dd545de4b27ee00\",\n",
    "#                 'recipient' : \"a77f5cdfa2934df3954a5c7c7da5df1f\",\n",
    "#                 'amount' : 5,\n",
    "#             },\n",
    "#             'proof' : 324984774000,\n",
    "#             'previous_hash' : \"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824\"\n",
    "#         }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flask import Flask\n",
    "from textwrap import dedent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Intantiate the node\n",
    "app = Flask(__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Genrate a globally unique address for this node\n",
    "node_identifier = str(uuid4()).replace('-','')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "blockchain = Blockchain()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.route('/mine', methods=['GET'])\n",
    "def mine():\n",
    "    # we run the POW algorith to get the next proof\n",
    "    last_block = blockchain.last_block\n",
    "    last_proof = last_block['proof']\n",
    "    proof = blockchain.proof_of_work(last_proof)\n",
    "    \n",
    "    # we must reward for finding the proof\n",
    "    # The sender is \"0\" to signify that this node has mined a new coin\n",
    "    \n",
    "    blockchain.new_transcation(\n",
    "        sender = \"0\",\n",
    "        recipient = node_identifier,\n",
    "        amount = 1,\n",
    "    )\n",
    "    \n",
    "    # Forge the new block by adding it to the chain\n",
    "    previous_hash = blockchain.hash(last_block)\n",
    "    block = blockchain.new_block(proof, previous_hash)\n",
    "    \n",
    "    response = {\n",
    "        'Message' : \"New block Forged\",\n",
    "        'index' : block['index'],\n",
    "        'transactions' : block['transactions'],\n",
    "        'proof' : block['proof'],\n",
    "        'previous_hash' : block['previous_hash'],\n",
    "    }\n",
    "    \n",
    "    return jsonify(response), 200\n",
    "    \n",
    "@app.route('/transactions/new', methods=['POST'])\n",
    "def new_transaction():\n",
    "    values = request.get_json()\n",
    "    #check that the requires field in the post data\n",
    "    requires = ['sender', 'recipient', 'amount']\n",
    "    if not all(k in values for k in requires ):\n",
    "        return \"Missing Values\", 400\n",
    "    \n",
    "    #create a new transaction\n",
    "    index = blockchain.new_transcation(values['sender'],values['recipient'],values['amount'])\n",
    "    \n",
    "    response = {'message' : f'Transaction will be added to Block{index}'}\n",
    "    return jsonify(response), 201\n",
    "@app.route('/chain', methods=['GET'])\n",
    "def full_chain():\n",
    "    response = {\n",
    "        'chain' : blockchain.chain,\n",
    "        'length' : len(blockchain.chain)\n",
    "    }\n",
    "    return jsonify(response),200\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run(host='0.0.0.0', port=5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}