Chapter03/chapter3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blockchain functionality \n",
    "Block linking process will have few tasks such as clubbing all the information to create a structure, calculating the hash of the block and appending it to the blockchain. Let's break down each of these functionalities into blockchain methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import json\n",
    "\n",
    "from Crypto.Hash import SHA256\n",
    "from datetime import datetime\n",
    "\n",
    "\n",
    "class Block(object):\n",
    "    \"\"\"A class representing the block for the blockchain\"\"\"\n",
    "\n",
    "    def __init__(self, index, previous_hash, timestamp, data, hash):\n",
    "        self.index = index\n",
    "        self.previous_hash = previous_hash\n",
    "        self.timestamp = timestamp\n",
    "        self.data = data\n",
    "        self.hash = hash\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above code snippet has python class called Block which has all the basic attributes to represent a block. Usually a block will contain both header and a body where header part will have metadata about the block. But, above example doesn’t distinguish between the header and body. A typical blockchain application such as bitcoin will have a huge set of data such as transactions, but we will consider data as just string type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Blockchain(object):\n",
    "    \"\"\"A class representing list of blocks\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self._chain = [self.get_genesis_block()]\n",
    "        self.timestamp = datetime.now().strftime(\"%s\")\n",
    "        \n",
    "    def get_genesis_block(self):\n",
    "        \"\"\"creates first block of the chain\"\"\"\n",
    "\n",
    "        return Block(0, \"0\", 1465154705, \"my genesis block!!\",\n",
    "                     \"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\")\n",
    "\n",
    "    def calculate_hash(self, index, previous_hash, timestamp, data):\n",
    "        \"\"\"calculates SHA256 hash value\"\"\"\n",
    "\n",
    "        hash_object = SHA256.new(data=(str(index) + previous_hash + str(timestamp) + data).encode())\n",
    "        return hash_object.hexdigest()\n",
    "\n",
    "    def get_latest_block(self):\n",
    "        \"\"\"gets the last block from the blockchain\"\"\"\n",
    "\n",
    "        try:\n",
    "            return self._chain[-1]\n",
    "        except IndexError as e:\n",
    "            return None\n",
    "    \n",
    "    def create_block(self, block_data):\n",
    "        \"\"\"creates a new block with the given block data\"\"\"\n",
    "\n",
    "        previous_block = self.get_latest_block()\n",
    "        next_index = previous_block.index + 1\n",
    "        next_timestamp = self.timestamp\n",
    "        next_hash = self.calculate_hash(next_index, previous_block.hash, next_timestamp, block_data)\n",
    "        return Block(next_index, previous_block.hash, next_timestamp, block_data, next_hash)\n",
    "\n",
    "    @property\n",
    "    def chain(self):\n",
    "        \"\"\"created a dict containing list of block objects to view\"\"\"\n",
    "\n",
    "        return self.dict(self._chain)\n",
    "\n",
    "    def dict(self, chain):\n",
    "        \"\"\"converts list of block objects to dictionary\"\"\"\n",
    "\n",
    "        return json.loads(json.dumps(chain, default=lambda o: o.__dict__))\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"resets the blockchain blocks except genesis block\"\"\"\n",
    "\n",
    "        self._chain = [self._chain[0]]\n",
    "\n",
    "    def add_block(self, data):\n",
    "        \"\"\"appends a new block to the blockchain\"\"\"\n",
    "\n",
    "        self._chain.append(self.create_block(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above class is a collection of class methods to create a valid blockchain by using hash function. Constructor of the Blockchain will initialize a chain by appending genesis block, which is the first block of the blockchain which doesn't have any reference to previous block. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### get_genesis_block(self)\n",
    "\n",
    "A genesis block is hardcoded block which will be appended to the beginning of the blockchain. It is created with all static contents. Above genesis block has a hardcoded hash value which is created using SHA256 as follows.\n",
    "\n",
    "SHA256.new(data=(str(0) + \"0\"+ str(1465154705) +\"my genesis block!!\").encode()).hexdigest() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calculate_hash(self, index, previous_hash, timestamp, data):\n",
    "\n",
    "calculate_hash is a crucial method of the blockchain as this method creates a hash value which will bind all the blocks together. SHA256 hash value is created by using PyCryptodome package as shown in the chapter 2. This method will concatenate block index, hash value of previous block, timestamp and data to create a string to be hashed. SHA256 hash function will generate a digest which will be the hash value of that block. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### get_latest_block(self)\n",
    "\n",
    "This function identifies the last block which is appended to the chain which is required while creating each block to find the hash value of previous block. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### create_block(self, block_data):\n",
    "\n",
    "This function will build a block by constructing all the required attributes to create a Block object. It will also calculate the hash value for the current block. A new Block object consisting of the block structure will be finally created. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### chain(self), dict(self, chain), reset(self), add_block(self, data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the above functions are used to add blocks, reset and read the blocks of the blockchain. Method add_block and the attribute chain are the only required class members that needs to be exposed to the user. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a blockchain "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have defined all the required functionalities of a simple blockchain linker, let's emulate a blockchain linker by creating few blocks and adding them to the blockchain. \n",
    "\n",
    "The below code snippet creates a Blockchain object and adds three blocks to the blockchain along with an existing genesis block. This operation is performed again after resetting the blockchain. The important observation here is that both the output of new_chain.chain would produce same list of blocks containing same block hashes as below. This is due to the fact that all the attributes contributing to the hash value creation are same during both the execution, and hash function always produces the same hash value if the fed input is the same. The time stamp is intentionally kept constant for all the blocks to showcase the feature of the hash function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{\"index\": 0, \"previous_hash\": \"0\", \"data\": \"my genesis block!!\", \"hash\": \"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\", \"timestamp\": 1465154705}, {\"index\": 1, \"previous_hash\": \"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\", \"data\": \"modified first block data\", \"hash\": \"0237cae5709bd1fbf991f7352741fc794606e6886cd33b1e21d604c62879d4f0\", \"timestamp\": \"1521878822\"}, {\"index\": 2, \"previous_hash\": \"0237cae5709bd1fbf991f7352741fc794606e6886cd33b1e21d604c62879d4f0\", \"data\": \"second block data\", \"hash\": \"78e42d25ecd9aca0bb9b82b6d333c58319b5dc74611c4444017da39a494505a3\", \"timestamp\": \"1521878822\"}, {\"index\": 3, \"previous_hash\": \"78e42d25ecd9aca0bb9b82b6d333c58319b5dc74611c4444017da39a494505a3\", \"data\": \"third block data\", \"hash\": \"91e81e5582c3e7af2de4a9c8a2db793be0e6859981a082b17cd36c2ecf86c1aa\", \"timestamp\": \"1521878822\"}]\n"
     ]
    }
   ],
   "source": [
    "new_chain = Blockchain()\n",
    "new_chain.add_block(data=\"modified first block data\")\n",
    "new_chain.add_block(data=\"second block data\")\n",
    "new_chain.add_block(data=\"third block data\")\n",
    "\n",
    "print(json.dumps(new_chain.chain))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An example implementation of proof-of-work. \n",
    "\n",
    "### Example for brute forcing with nonce \n",
    "\n",
    "Below code snippet is a simple example for generating hashes to solve the proof-of-work puzzle. The nonce is created in an incremental fashion and appended to the input data. Hash value is computed using SHA256 algorithm and this is repeated for all the nonce values. \n",
    "\n",
    "The program will generate below hashes for each of the nonce appended data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Satoshi Nakamoto0=>a80a81401765c8eddee25df36728d732acb6d135...\n",
      "I am Satoshi Nakamoto1=>f7bc9a6304a4647bb41241a677b5345fe3cd30db...\n",
      "I am Satoshi Nakamoto2=>ea758a8134b115298a1583ffb80ae62939a2d086...\n",
      "I am Satoshi Nakamoto3=>bfa9779618ff072c903d773de30c99bd6e2fd70b...\n",
      "I am Satoshi Nakamoto4=>bce8564de9a83c18c31944a66bde992ff1a77513...\n",
      "I am Satoshi Nakamoto5=>eb362c3cf3479be0a97a20163589038e4dbead49...\n",
      "I am Satoshi Nakamoto6=>4a2fd48e3be420d0d28e202360cfbaba410bedde...\n",
      "I am Satoshi Nakamoto7=>790b5a1349a5f2b909bf74d0d166b17a333c7fd8...\n",
      "I am Satoshi Nakamoto8=>702c45e5b15aa54b625d68dd947f1597b1fa571d...\n",
      "I am Satoshi Nakamoto9=>7007cf7dd40f5e933cd89fff5b791ff0614d9c60...\n",
      "I am Satoshi Nakamoto10=>c2f38c81992f4614206a21537bd634af7178964...\n",
      "I am Satoshi Nakamoto11=>7045da6ed8a914690f087690e1e8d662cf9e56f...\n",
      "I am Satoshi Nakamoto12=>60f01db30c1a0d4cbce2b4b22e88b9b93f58f10...\n",
      "I am Satoshi Nakamoto13=>0ebc56d59a34f5082aaef3d66b37a661696c2b6...\n",
      "I am Satoshi Nakamoto14=>27ead1ca85da66981fd9da01a8c6816f54cfa0d...\n",
      "I am Satoshi Nakamoto15=>394809fb809c5f83ce97ab554a2812cd901d3b1...\n",
      "I am Satoshi Nakamoto16=>8fa4992219df33f50834465d30474298a7d5ec7...\n",
      "I am Satoshi Nakamoto17=>dca9b8b4f8d8e1521fa4eaa46f4f0cdf9ae0e69...\n",
      "I am Satoshi Nakamoto18=>9989a401b2a3a318b01e9ca9a22b0f39d82e48b...\n",
      "I am Satoshi Nakamoto19=>cda56022ecb5b67b2bc93a2d764e75fc6ec6e6e...\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from __future__ import print_function\n",
    "from Crypto.Hash import SHA256\n",
    "\n",
    "text = \"I am Satoshi Nakamoto\"\n",
    "\n",
    "# iterate nonce from 0 to 19\n",
    "for nonce in range(20):\n",
    "\n",
    "    # add the nonce to the end of the text\n",
    "    input_data = text + str(nonce)\n",
    "\n",
    "    # calculate the SHA-256 hash of the input (text+nonce)\n",
    "    hash_data = SHA256.new(input_data.encode()).hexdigest()\n",
    "\n",
    "    # show the input and hash result\n",
    "    print((input_data + '=>' + hash_data)[:64] + \"...\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example for finding a nonce to solve proof-of-work \n",
    "\n",
    "This example will illustrate on finding a nonce by brute forcing with the help of SHA256 to find a hash value that will satisfy the target hash. Target hash value is determined by setting the difficulty bits in the proof-of-work algorithm. We will use the same blockchain linker created in the earlier section and will modify that example to include proof-of-work algorithm while creating new block. Let’s modify few functions of the blockchain example to include the consensus algorithm. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "from Crypto.Hash import SHA256\n",
    "from datetime import datetime\n",
    "\n",
    "max_nonce = 2 ** 32  # 4 billion\n",
    "\n",
    "\n",
    "class Block(object):\n",
    "    \"\"\"A class representing the block for the blockchain\"\"\"\n",
    "\n",
    "    def __init__(self, index, previous_hash, timestamp, data,\n",
    "                 difficulty_bits, nonce, hash):\n",
    "        self.index = index\n",
    "        self.previous_hash = previous_hash\n",
    "        self.timestamp = timestamp\n",
    "        self.data = data\n",
    "        self.difficulty_bits = difficulty_bits\n",
    "        self.nonce = nonce\n",
    "        self.hash = hash\n",
    "\n",
    "\n",
    "class Blockchain(object):\n",
    "    \"\"\"A class representing list of blocks\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self._chain = [self.get_genesis_block()]\n",
    "        self.timestamp = datetime.now().strftime(\"%s\")\n",
    "        self.difficulty_bits = 0\n",
    "\n",
    "    @property\n",
    "    def chain(self):\n",
    "        \"\"\"created a dict containing list of block objects to view\"\"\"\n",
    "\n",
    "        return self.dict(self._chain)\n",
    "\n",
    "    def dict(self, chain):\n",
    "        \"\"\"converts list of block objects to dictionary\"\"\"\n",
    "\n",
    "        return json.loads(json.dumps(chain, default=lambda o: o.__dict__))\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"resets the blockchain blocks except genesis block\"\"\"\n",
    "\n",
    "        self._chain = [self._chain[0]]\n",
    "\n",
    "    def get_genesis_block(self):\n",
    "        \"\"\"creates first block of the chain\"\"\"\n",
    "\n",
    "        # SHA256.new(data=(str(0) + \"0\"+ str(1465154705) +\"my genesis block!!\"+\"0\").encode()).hexdigest()\n",
    "        return Block(0, \"0\", 1465154705, \"my genesis block!!\", 0, 0,\n",
    "                     \"f6b3fd6d417048423692c275deeaa010d4174bd680635d3e3cb0050aa46401cb\")\n",
    "\n",
    "    def add_block(self, data):\n",
    "        \"\"\"appends a new block to the blockchain\"\"\"\n",
    "\n",
    "        self._chain.append(self.create_block(data))\n",
    "\n",
    "    def create_block(self, block_data):\n",
    "        \"\"\"creates a new block with the given block data\"\"\"\n",
    "\n",
    "        previous_block = self.get_latest_block()\n",
    "        next_index = previous_block.index + 1\n",
    "        next_timestamp = self.timestamp\n",
    "        next_hash, next_nonce = self.calculate_hash(next_index, previous_block.hash, next_timestamp, block_data)\n",
    "        return Block(next_index, previous_block.hash, next_timestamp, block_data, self.difficulty_bits, next_nonce, next_hash)\n",
    "\n",
    "    def get_latest_block(self):\n",
    "        \"\"\"gets the last block from the blockchain\"\"\"\n",
    "\n",
    "        try:\n",
    "            return self._chain[-1]\n",
    "        except IndexError as e:\n",
    "            return None\n",
    "\n",
    "    def calculate_hash(self, index, previous_hash, timestamp, data):\n",
    "        \"\"\"calculates SHA256 hash value by solving hash puzzle\"\"\"\n",
    "\n",
    "        header = str(index) + previous_hash + str(timestamp) + data + str(self.difficulty_bits)\n",
    "\n",
    "        hash_value, nonce = self.proof_of_work(header)\n",
    "        return hash_value, nonce\n",
    "\n",
    "    def proof_of_work(self, header):\n",
    "\n",
    "        target = 2 ** (256 - difficulty_bits)\n",
    "\n",
    "        for nonce in xrange(max_nonce):\n",
    "            hash_result = SHA256.new(data=(str(header) + str(nonce)).encode()).hexdigest()\n",
    "\n",
    "            if int(hash_result, 16) < target:\n",
    "                print(\"Success with nonce %d\" % nonce)\n",
    "                print(\"Hash is %s\" % hash_result)\n",
    "                return (hash_result, nonce)\n",
    "\n",
    "        print(\"Failed after %d (max_nonce) tries\" % nonce)\n",
    "        return nonce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difficulty: 1 (0 bits)\n",
      "Starting search...\n",
      "Success with nonce 0\n",
      "Hash is 3668b619d449a007c5e8bb2f038edb80270665f0f7d1f821722d800c93a48354\n",
      "Elapsed Time: 0.0004 seconds\n",
      "Hashing Power: 0 hashes per second\n",
      "Difficulty: 2 (1 bits)\n",
      "Starting search...\n",
      "Success with nonce 3\n",
      "Hash is 1644c850e78d4f4bd08a41e0de0926798ca114018ff92d17a9dfaf5b2320af5b\n",
      "Elapsed Time: 0.0021 seconds\n",
      "Hashing Power: 1463 hashes per second\n",
      "Difficulty: 4 (2 bits)\n",
      "Starting search...\n",
      "Success with nonce 0\n",
      "Hash is 200dc175db7698acff9a4f9b4f116d2ca465b2d5ece577edb6616f3529d12d57\n",
      "Elapsed Time: 0.0002 seconds\n",
      "Hashing Power: 0 hashes per second\n",
      "Difficulty: 8 (3 bits)\n",
      "Starting search...\n",
      "Success with nonce 3\n",
      "Hash is 1a8df5bcefc9cbc670b5af27c614a3d0ecadddc0dffa64e9f1db11ea27fbc6a9\n",
      "Elapsed Time: 0.0003 seconds\n",
      "Hashing Power: 9118 hashes per second\n",
      "Difficulty: 16 (4 bits)\n",
      "Starting search...\n",
      "Success with nonce 7\n",
      "Hash is 08c3d5e18b138eab0f84084af9c1dd6827456ceb199a10916f5dba523c8e9b8b\n",
      "Elapsed Time: 0.0005 seconds\n",
      "Hashing Power: 14553 hashes per second\n",
      "Difficulty: 32 (5 bits)\n",
      "Starting search...\n",
      "Success with nonce 58\n",
      "Hash is 07b79176964c58b45274463a2ac68a47e085a6d39f2e146b63fe8999549df1fc\n",
      "Elapsed Time: 0.0029 seconds\n",
      "Hashing Power: 20265 hashes per second\n",
      "Difficulty: 64 (6 bits)\n",
      "Starting search...\n",
      "Success with nonce 2\n",
      "Hash is 032c060af745943aeb87987da5e3cfb14d20ee2b7fd93e52cf6d0ddbc74b4f5b\n",
      "Elapsed Time: 0.0035 seconds\n",
      "Hashing Power: 578 hashes per second\n",
      "Difficulty: 128 (7 bits)\n",
      "Starting search...\n",
      "Success with nonce 372\n",
      "Hash is 00c24c672782067f8bb67fe16a6cec2e6ff2d60ec1c1b9133902253ca8f77058\n",
      "Elapsed Time: 0.0241 seconds\n",
      "Hashing Power: 15408 hashes per second\n",
      "Difficulty: 256 (8 bits)\n",
      "Starting search...\n",
      "Success with nonce 161\n",
      "Hash is 00ef63f1db92c15ffbd41259b59f45a1a056e29d7c1ff231c72ba79b12dc4114\n",
      "Elapsed Time: 0.0083 seconds\n",
      "Hashing Power: 19442 hashes per second\n",
      "Difficulty: 512 (9 bits)\n",
      "Starting search...\n",
      "Success with nonce 145\n",
      "Hash is 000e92f18688e14a0ed0017608e998a85095fa9e7fbbebcba4b9b12050bb50fc\n",
      "Elapsed Time: 0.0074 seconds\n",
      "Hashing Power: 19663 hashes per second\n",
      "Difficulty: 1024 (10 bits)\n",
      "Starting search...\n",
      "Success with nonce 2076\n",
      "Hash is 001c7d29f1f2b223f19cca2122d746e6f05b3266acd81ed04481d2164321b1e7\n",
      "Elapsed Time: 0.0887 seconds\n",
      "Hashing Power: 23412 hashes per second\n",
      "Difficulty: 2048 (11 bits)\n",
      "Starting search...\n",
      "Success with nonce 3658\n",
      "Hash is 0008e705ec16e5d30300379230c294ab497cdbba4d9fb3426b0b6657e27e9005\n",
      "Elapsed Time: 0.1623 seconds\n",
      "Hashing Power: 22538 hashes per second\n",
      "Difficulty: 4096 (12 bits)\n",
      "Starting search...\n",
      "Success with nonce 7054\n",
      "Hash is 00064a6b324577b8016e602ba3d0ef1ab90a3ba63da436af1c67a512eb6a9857\n",
      "Elapsed Time: 0.3037 seconds\n",
      "Hashing Power: 23224 hashes per second\n",
      "Difficulty: 8192 (13 bits)\n",
      "Starting search...\n",
      "Success with nonce 8526\n",
      "Hash is 00056d068fcd3aa96fc5061a52dcfd3f41919b1b8e2ffd093b9960e324e76223\n",
      "Elapsed Time: 0.3765 seconds\n",
      "Hashing Power: 22648 hashes per second\n",
      "Difficulty: 16384 (14 bits)\n",
      "Starting search...\n",
      "Success with nonce 2971\n",
      "Hash is 0000d9624213be7bc1604efc6a3c9b37a2ccead92dbcf3259e50168e32bb130a\n",
      "Elapsed Time: 0.1344 seconds\n",
      "Hashing Power: 22098 hashes per second\n",
      "Difficulty: 32768 (15 bits)\n",
      "Starting search...\n",
      "Success with nonce 3536\n",
      "Hash is 0001720e55ef28d466cc43b44c1902177f4c8a929c4403774ce13d6d3eebbbf6\n",
      "Elapsed Time: 0.2208 seconds\n",
      "Hashing Power: 16012 hashes per second\n",
      "Difficulty: 65536 (16 bits)\n",
      "Starting search...\n",
      "Success with nonce 27755\n",
      "Hash is 0000e184aadda46abf0561b1f957d8c554f1f54eae2e9d46aa79d9661bafdb37\n",
      "Elapsed Time: 1.3135 seconds\n",
      "Hashing Power: 21129 hashes per second\n",
      "Difficulty: 131072 (17 bits)\n",
      "Starting search...\n",
      "Success with nonce 183076\n",
      "Hash is 00004a0bf5df7074c1592480232bb0648778804d2d645806fa71de9edf8e18eb\n",
      "Elapsed Time: 8.3107 seconds\n",
      "Hashing Power: 22028 hashes per second\n",
      "Difficulty: 262144 (18 bits)\n",
      "Starting search...\n",
      "Success with nonce 244811\n",
      "Hash is 0000284384c9c8fbc1ce532095f24fae730493e8656d2131f2fe7301640b4c6e\n",
      "Elapsed Time: 10.7978 seconds\n",
      "Hashing Power: 22672 hashes per second\n",
      "Difficulty: 524288 (19 bits)\n",
      "Starting search...\n",
      "Success with nonce 62771\n",
      "Hash is 00001b819ad78af6125850fce0c182234d9113284a445dca69540de3cc7725a3\n",
      "Elapsed Time: 2.9173 seconds\n",
      "Hashing Power: 21516 hashes per second\n",
      "Difficulty: 1048576 (20 bits)\n",
      "Starting search...\n",
      "Success with nonce 1912952\n",
      "Hash is 000002302cfec2309a975d8ca9a041cd11251c7dc39d52f55fa0308712965d75\n",
      "Elapsed Time: 101.7455 seconds\n",
      "Hashing Power: 18801 hashes per second\n",
      "Difficulty: 2097152 (21 bits)\n",
      "Starting search...\n",
      "Success with nonce 631077\n",
      "Hash is 0000041e57c825ed5fe8aea3ed4354c04487c013e038318009dff8cbb60cdce6\n",
      "Elapsed Time: 29.7742 seconds\n",
      "Hashing Power: 21195 hashes per second\n",
      "Difficulty: 4194304 (22 bits)\n",
      "Starting search...\n",
      "Success with nonce 1366945\n",
      "Hash is 00000154d38a07eb9660ce77b67271a2cfc9446f1fef30fdb88480adf30163d9\n",
      "Elapsed Time: 64.7163 seconds\n",
      "Hashing Power: 21122 hashes per second\n",
      "Difficulty: 8388608 (23 bits)\n",
      "Starting search...\n",
      "Success with nonce 6117327\n",
      "Hash is 000001f043659f27909dff5eedd55f5e8f005dd49945242d0c2752b792fa2a67\n",
      "Elapsed Time: 301.2819 seconds\n",
      "Hashing Power: 20304 hashes per second\n",
      "Difficulty: 16777216 (24 bits)\n",
      "Starting search...\n",
      "Success with nonce 2933928\n",
      "Hash is 0000001eb841ee53923eea344136daaedcc700175e70b05f18c64aff10dea6e9\n",
      "Elapsed Time: 141.0369 seconds\n",
      "Hashing Power: 20802 hashes per second\n",
      "Difficulty: 33554432 (25 bits)\n",
      "Starting search...\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "\n",
    "    new_chain = Blockchain()\n",
    "\n",
    "    for difficulty_bits in range(32):\n",
    "        difficulty = 2 ** difficulty_bits\n",
    "        new_chain.difficulty_bits = difficulty_bits\n",
    "        print(\"Difficulty: %ld (%d bits)\" % (difficulty, difficulty_bits))\n",
    "        print(\"Starting search...\")\n",
    "\n",
    "        start_time = datetime.now()\n",
    "\n",
    "        new_block_data = 'test block with transactions'\n",
    "        new_chain.add_block(data=new_block_data)\n",
    "\n",
    "\n",
    "        end_time = datetime.now()\n",
    "\n",
    "        elapsed_time = (end_time - start_time).total_seconds()\n",
    "        print(\"Elapsed Time: %.4f seconds\" % elapsed_time)\n",
    "\n",
    "        if elapsed_time > 0:\n",
    "\n",
    "            hash_power = float(int(new_chain.chain[-1].get(\"nonce\")) / elapsed_time)\n",
    "            print(\"Hashing Power: %ld hashes per second\" % hash_power)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above main method of python creates a new object of Blockchain class which will create a new chain with genesis block. The for loop will create a new block, each time increasing the difficulty_bits by 1. Proof of work function will be invoked for each block creation.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is quite evident from the example output that the time taken to compute the solution directly proportional to the number of difficulty bits used. To be precise, for every bit increase in the difficulty level, probability of finding the nonce decreases by half as the target space decreases by half. Although sometimes luck might benefit in solving few of the puzzles, probability theory holds for the majority cases in proof of work consensus algorithm."
   ]
  },
  {
   "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": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}