basic_blockchain-oscon2018-livecode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coding A Basic Blockchain\n",
    "## Josh Butikofer - Adobe (@jbutikofer - butikofe@adobe.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DISCLAIMER:** _All opinions, ideas, and code expressed here are my own._\n",
    "\n",
    "This is a live coding tutorial that will step you through the basic steps of building a _very_ basic blockchain written in Python. It was originally presented as a Live Coding Session at OSCON 2018 in Portland, OR. This notebook requires Python 3.7 or greater. See the accompanying `Pipfile` file for other dependencies.\n",
    "\n",
    "## Definitions\n",
    "\n",
    "Although there are several slightly different definitions for what constitutes a blockchain, this tutorial assumes the Wikipedia definition. Paraphrased from Wikipedia: A blockchain is composed of blocks that are cryptographically linked together to form a long chain. Because each block has a cryptographic hash of the previous block we can easily verify that the chain is immutable. Blocks also contain transactions and a timestamp. The transactions record some transfer of value between parties and typically use public-key cryptography to verify the transactions' integrity. Because value transfer by way of transactions is a major use case of blockchains, they are often called \"distributed ledgers.\" (I like this moniker better than blockchain.) \n",
    "\n",
    "Blockchains derive a lot of their advantage by being decentralized in a peer-to-peer network. Because of this there needs to be a decentralized consensus algorithm so all the peers can agree on the current state of the chain that is distributed among them.\n",
    "\n",
    "Put another way, a blockchain is a database that represents a ledger and has some of the following key characteristics:\n",
    "\n",
    "* Cryptographically verifiable and auditable\n",
    "* Immutable\n",
    "* Implements a decentralized consensus algorithm\n",
    "* Uses a peer-to-peer network to achieve decentralization\n",
    "\n",
    "## Underlying Technology\n",
    "\n",
    "An interesting observation is that the individual technologies used in blockchain are not new. The novelty of blockchain was was the combination of this technology to solve the problems inherent in digital cash systems--_without the need for a central authority._\n",
    "\n",
    "Our basic blockchain will use the same cryptographic tech that mainstream ones do: hashing and public-key signatures. We will also use one of the most popular decentralized consensus algorithms, \"Proof-of-Work\", to show how blocks are made and shared in a distributed ledger."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Nuts and Bolts\n",
    "\n",
    "Most blockchains are built from  a core set of nuts and bolts.\n",
    "\n",
    "A blockchain has:\n",
    "\n",
    "* **Transactions**: These are the entries in the ledger. In our example these will describe how user X wants to send some tokens to user Y. Transactions are cryptographically signed by user X to prove that they authorize the transfer of tokens.\n",
    "\n",
    "* **Blocks**: Transactions are bundled up together into a block. Depending on the blockchain, there can be hundreds or thousands of transactions in a block. The transactions are validated and then the block includes the previous block's hash, linking itself to the previous block. There is also a process called \"mining\" or \"forging\" that proves to the network of blockchain participants that this block's creation can be trusted.\n",
    "\n",
    "* **Blockchain**: All successfully mined blocks are strung together in a big, verifiable, and immutable chain. This is the system of record--the distributed ledger.\n",
    "\n",
    "* **Nodes**: Computers around the world that participate in the distributed ledger network and are called \"nodes.\" They often have a full copy of the chain and are responsible for accepting transactions, making new blocks, and updating the blockchain. They communicate via the other nodes in a P2P fashion. The decentralized consensus algorithm becomes critical here to help all nodes agree on what is the definitive chain since each node is working to grow the chain. *In our simple example, we will only have one node!*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enough talk--let's get coding!\n",
    "\n",
    "## Transactions\n",
    "\n",
    "First we will implement a **Transaction**. Transactions need to have:\n",
    "\n",
    "* Sender address\n",
    "* Recipient address\n",
    "* Some payload--in our case this will be the amount of \"tokens\" that are being transferred.\n",
    "\n",
    "**Another CRITICAL rule that satisifies one of the core tenets of blockchain: transactions need to be cryptographically signed. This verifies that the sender really wants to send tokens and someone is not stealing them!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will be using some of the niceties of Python 3.7 and a helpful\n",
    "# crypto library to help with public-key signing\n",
    "from dataclasses import dataclass, field\n",
    "from typing import *\n",
    "import rsa # Don't implement your own\n",
    "import hashlib\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass  # New Python 3.7 feature!\n",
    "class Transaction:\n",
    "    sender_address: rsa.PublicKey\n",
    "    recipient_address: rsa.PublicKey\n",
    "    value: float\n",
    "    signature: bytes = field(default=b'')\n",
    "       \n",
    "    def sign(self, sender_private_key: rsa.PrivateKey) -> None:\n",
    "        \"\"\"Takes a private key, which the sender should never share, \n",
    "        and signs this transaction to verify they want to transfer the\n",
    "        tokens. We sign the core attributes of the transaction using \n",
    "        the private key. We will use SHA-256 as the signature hashing \n",
    "        algorithm.\"\"\"\n",
    "        \n",
    "        # sign and then validate to make sure the signature is valid\n",
    "        \n",
    "        self.signature = rsa.sign(self.get_header(), sender_private_key, 'SHA-256')\n",
    "        self.validate()\n",
    "        \n",
    "    def get_header(self) -> bytes:\n",
    "        \"\"\"Provides the core info needed to sign the transaction--basically\n",
    "        everything BUT the signature.\"\"\"\n",
    "        \n",
    "        return (str(self.sender_address) + str(self.recipient_address) + str(self.value)).encode()\n",
    "        \n",
    "    def validate(self) -> None:\n",
    "        \"\"\"Validates the integrity of this transaction by using RSA to\n",
    "        verify it is signed properly. Gets the core data about the \n",
    "        transaction, and the signature made using the private key,\n",
    "        and uses the public key to validate it is signed. The public key\n",
    "        is the sender_address.\"\"\"\n",
    "        \n",
    "        rsa.verify(self.get_header(), self.signature, self.sender_address)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blocks\n",
    "\n",
    "Now that we have transactions figured out (we think) we can focus on **Blocks**. Blocks needs to have:\n",
    "\n",
    "* Block number (to make it easy to identify them)\n",
    "* Timestamp\n",
    "* A list of transactions included in the block\n",
    "* The hash of the previous block in the chain (this is important for immutability)\n",
    "* A hash of this block (again, to help enforce immutability)\n",
    "* Nonce (this is used to help implement the distributed trust consensus algorithm)\n",
    "\n",
    "The most important thing about a block is we must be able to tell if someone has changed the block and must prove that its addition to the chain is valid, hence the cryptographic hashing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Block:\n",
    "    num: int\n",
    "    timestamp: float\n",
    "    prev_block_hash: str\n",
    "    transactions: List[Transaction]\n",
    "    block_hash: str = field(default=\"\")\n",
    "    nonce: int = field(default=0)\n",
    "      \n",
    "    def hash(self) -> str:\n",
    "        \"\"\"Uses SHA-256 to hash the header of the block (the core\n",
    "        attributes of the block). Saves the hash to the block object\n",
    "        for later use and also returns the hash in hex format.\"\"\"\n",
    "        self.block_hash = hashlib.sha256(self.get_header()).hexdigest()\n",
    "        return self.block_hash\n",
    "    \n",
    "    def get_header(self) -> bytes:\n",
    "        \"\"\"Returns a string that represents the core attributes that\n",
    "        uniquely identify the block AND link it to the previous block\n",
    "        (forming the chain). These attributes include: block num,\n",
    "        timestamp, previous block hash, transactions\n",
    "        (real chains use a Merkle root hash for efficiency),\n",
    "        and a nonce.\"\"\"\n",
    "        \n",
    "        return (str(self.num) + str(self.timestamp) + str(self.prev_block_hash) + str(self.transactions) +\n",
    "                str(self.nonce)).encode()\n",
    "    \n",
    "    def validate(self, proof_of_work_func: Callable[[str], bool]) -> bool:\n",
    "        \"\"\"Using the given function, ensure that this block hashes\n",
    "        correctly, adhering to the agreed-upon consensus algorithm.\"\"\"\n",
    "        return proof_of_work_func(self.hash())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blockchain Node\n",
    "\n",
    "Now that we have Transactions and Blocks, we need to have an object to hold the chain and put them all together! We will implement some code that acts as a \"node\" on the blockchain to accept transactions, mine blocks, and validate things.\n",
    "\n",
    "A **Blockchain Node** needs to have the following:\n",
    "\n",
    "* An address for it to receive reward tokens for mining new blocks!\n",
    "* A authoritative list of blocks in the chain\n",
    "* A way to receive new transactions (and validate them)\n",
    "* A way to mine new blocks, thereby adding transactions into the chain\n",
    "* A way to validate the chain, to prove that it adheres to the requirements of a distributed ledger and can be trusted\n",
    "\n",
    "Let's do it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "REWARD_AMOUNT = 2.0\n",
    "\n",
    "class BlockchainNode:\n",
    "    \n",
    "    def __init__(self, miner_address: rsa.PublicKey) -> None:\n",
    "        self.miner_address: rsa.PublicKey = miner_address\n",
    "        self.blocks: List[Block] = []\n",
    "        self.pending_transactions: List[Transaction] = []\n",
    "        self.proof_of_work_func: Callable[[str], bool] = lambda x: x.endswith('00000')\n",
    "            \n",
    "        self.mine_block()\n",
    "      \n",
    "    def submit_transaction(self, transaction: Transaction) -> None:        \n",
    "        \"\"\"This is used to submit a new transaction to the chain. End-users\n",
    "        send transactions and aren't concerned about the blocks, per se.\n",
    "        This function takes a signed transaction will validate it is\n",
    "        cryptographically sound. It will then need to check that there\n",
    "        is sufficient balance to make the transfer. If these are good,\n",
    "        we will add the transaction to a list of those that will be\n",
    "        considered when the next block is mined.\"\"\"\n",
    "        \n",
    "        # Ensure the transaction is properly signed by the private key\n",
    "        transaction.validate()\n",
    "        \n",
    "        # Make sure the funds exist for the requested transaction        \n",
    "        balance = self.get_balance(transaction.sender_address)\n",
    "        \n",
    "        if balance < transaction.value:\n",
    "            raise Exception(\"Insufficient funds!\")\n",
    "     \n",
    "        # Transaction checks out--add to the list of our pending\n",
    "        # transactions!\n",
    "        \n",
    "        self.pending_transactions.append(transaction)\n",
    "        \n",
    "    def mine_block(self) -> None:\n",
    "        \"\"\"This function bundles all pending transactions and mines a new\n",
    "        block. Mining is the process by which a node creates a new block.\n",
    "        This is where the decentralized consensus algorithm comes in.\n",
    "        We will be using a proof-of-work algorithm that is computationally\n",
    "        expensive. This prevents bad actor nodes from flooding the P2P\n",
    "        network with invalid transactions, blocks, or chains. It is too\n",
    "        expensive to rewrite history, making the blockchain more secure\n",
    "        from these kinds of attacks. This function will mine\n",
    "        the new block and then append it to the chain automatically.\n",
    "        \n",
    "        Nodes that successfully mine a new block get a token award.\n",
    "        This is how new tokens start to circulate up in the chain and\n",
    "        this is supposed to incentivize more peers on the network.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Make sure we have a genesis block to start the chain\n",
    "        if len(self.blocks) <= 0:\n",
    "            prev_hash = \"-\"\n",
    "            next_num = 0\n",
    "        else:\n",
    "            prev_block = self.blocks[-1]\n",
    "            prev_hash = prev_block.block_hash\n",
    "            next_num = prev_block.num + 1\n",
    "        \n",
    "        # Get the previous block in the chain and use its number\n",
    "        # and hash to incorporate into the new block.\n",
    "        \n",
    "        new_block = Block(next_num, time.time(), prev_hash, self.pending_transactions.copy())\n",
    "        \n",
    "        # Add a reward transaction at the end of the block for this node\n",
    "        \n",
    "        reward = Transaction(None, self.miner_address, REWARD_AMOUNT)\n",
    "        \n",
    "        new_block.transactions.append(reward)\n",
    "        \n",
    "        # Execute proof-of-work\n",
    "        self.execute_pow(new_block)\n",
    "        \n",
    "        # Add the block to the chain\n",
    "        self.blocks.append(new_block)\n",
    "        \n",
    "        # Reset our pending transactions\n",
    "        self.pending_transactions.clear()\n",
    "        \n",
    "        # Print out success\n",
    "        print(f\"Successfully mined new block {new_block.num}\")\n",
    "        \n",
    "        \n",
    "\n",
    "    def execute_pow(self, block: Block) -> None:\n",
    "        \"\"\"Using the defined proof-of-work lambda, increment the nonce \n",
    "        on the block until we satisfy the lambda's assertion. Since this\n",
    "        iterating and hashing can take a long time and a lot of CPU,\n",
    "        it can become computationally intensive. When this function\n",
    "        returns the block will have a nonce and hash that meet the\n",
    "        consensus algorithm requirements and can be very easily checked.\"\"\"\n",
    "        \n",
    "        # Print out success\n",
    "        block.nonce = 0\n",
    "        while not block.validate(self.proof_of_work_func):\n",
    "            block.nonce += 1\n",
    "            \n",
    "            \n",
    "        print(f\"Successfully mined new block {block.num} with nonce {block.nonce}\")\n",
    "        \n",
    "        \n",
    "    def validate_chain(self) -> None:\n",
    "        \"\"\"Verifies that this chain is cryptographically sound and\n",
    "        has not been modified. Also ensures that all blocks meet the\n",
    "        conensus algorithm requirements. This function is MUCH faster\n",
    "        than mining new blocks: this is why the proof-of-work algorithm\n",
    "        works well. Verification is very fast, but mining new blocks\n",
    "        is difficult.\"\"\"\n",
    "        \n",
    "        # Cycle through each block and compare previous block hashes\n",
    "        # and verify proof-of-work compliance.\n",
    "        \n",
    "        prev_hash = \"-\"\n",
    "        for b in self.blocks:\n",
    "            if b.prev_block_hash != prev_hash:\n",
    "                raise Exception(\"Previous hashes don't match\")\n",
    "            elif not b.validate(self.proof_of_work_func):\n",
    "                raise Exception(\"Something is wrong with PoW hash\")\n",
    "                \n",
    "            prev_hash = b.block_hash\n",
    "        \n",
    "        # Print out success!\n",
    "        \n",
    "        print(f\"Successfully validated chain of size {len(self.blocks)}\")\n",
    "        \n",
    "    def get_balance(self, address: rsa.PublicKey) -> float:\n",
    "        \"\"\"This method provides an easy way to traverse the chain to\n",
    "        find out the balance of the given address. Bitcoin doesn't\n",
    "        necessarily work this way, but other chains do, and it works\n",
    "        fine for our purposes. This method will return the token balance\n",
    "        of the given address, returning 0.0 if the address has never been\n",
    "        seen on the chain before.\"\"\"\n",
    "        \n",
    "        # Start balance at 0 and cycle through all blocks\n",
    "        # and their transactions, looking for the given\n",
    "        # address and keeping track of the balance accordingly.\n",
    "        balance = 0.0\n",
    "        for b in self.blocks:\n",
    "            for t in b.transactions:\n",
    "                if t.sender_address == address:\n",
    "                    balance -= t.value\n",
    "                elif t.recipient_address == address:\n",
    "                    balance += t.value\n",
    "                    \n",
    "        return balance\n",
    "            \n",
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can try and create transactions and mine some blocks. First we need some RSA public keys to act as addresses and to allow for signing. We can use the included `rsa` module to create these for us. Due to the requirements of RSA signing with SHA-256, we will need at least 512-bit keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "public_key, private_key = rsa.newkeys(512)\n",
    "receiving_public_key, receiving_private_key = rsa.newkeys(512)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use our public and private keys to make our first transaction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = Transaction(public_key, receiving_public_key, 0.5)\n",
    "t1.sign(private_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make another one. It's easy!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "t2 = Transaction(public_key, receiving_public_key, 1.0)\n",
    "t2.sign(private_key)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if we try to create a transaction to take tokens from an address for which we don't have the private key?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "bad_t = Transaction(public_key, receiving_public_key, 1000.0)\n",
    "bad_t.sign(private_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to submit our transactions to a blockchain node. Let's create one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully mined new block 0 with nonce 65479\n",
      "Successfully mined new block 0\n"
     ]
    }
   ],
   "source": [
    "node = BlockchainNode(public_key)\n",
    "node.submit_transaction(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The transaction will not be included in the blockchain until a block is mined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully mined new block 1 with nonce 613329\n",
      "Successfully mined new block 1\n"
     ]
    }
   ],
   "source": [
    "node.mine_block()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can test our implementation, and validate the integrity of the chain, by using the `validate_chain()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully validated chain of size 2\n"
     ]
    }
   ],
   "source": [
    "node.validate_chain()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to hack the chain by changing the value of a transaction...the immutability and validity of transactions should be violated and the validation should fail!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "Something is wrong with PoW hash",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-88f9de6f3494>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0morig_value\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mhack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100000.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mnode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_chain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-25-596daa7641a3>\u001b[0m in \u001b[0;36mvalidate_chain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    117\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Previous hashes don't match\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    118\u001b[0m             \u001b[0;32melif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mproof_of_work_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Something is wrong with PoW hash\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    120\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    121\u001b[0m             \u001b[0mprev_hash\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mblock_hash\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: Something is wrong with PoW hash"
     ]
    }
   ],
   "source": [
    "hack = node.blocks[1].transactions[0]\n",
    "orig_value = hack.value\n",
    "hack.value = 100000.0\n",
    "node.validate_chain()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Restoring the transaction back to its original state will allow the chain to be valid again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully validated chain of size 2\n"
     ]
    }
   ],
   "source": [
    "hack.value = orig_value\n",
    "node.validate_chain()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can show how \"spending checks\" are enforced. Let's try submitting a transaction that has a larger amount than our balance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully mined new block 3 with nonce 17112\n",
      "Successfully mined new block 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#node.mine_block()\n",
    "node.get_balance(public_key)\n",
    "node.submit_transaction(t2)\n",
    "node.mine_block()\n",
    "node.get_balance(receiving_public_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last, but not least, let's explore what happens if we increase the complexity of our PoW 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": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}