3. Blockchain.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Let's Create a Simple Blockchain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the very core, we want to create a linked list. Each block points to the fingerprint of the previous block. Additionally, we include a checksum of the content of each block (i.e., fingerprint)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"include/block_diagram.png\" alt=\"block diagram/\" style=\"width: 300px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - Define a class called \"block\" to represent the structure above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block = block(b\"1\", b\"DUMMY DATA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Genesis Block \n",
    "\n",
    "As we can now we can represent each block, and we can point to the previous block. Any modification to any block will propagate to the other blocks. If the data in any block changes, the hash changes, and this would reflect in the consequent blocks.\n",
    "\n",
    "BUT, where does the first block come from? There is no previous block to the first block.\n",
    "\n",
    "We should define one block as the **genesis block** where every other block agrees upon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    "\n",
    " - Define your genesis block, with following parameters:\n",
    "     - previous hash: \"0000000000000000000000000000000000000000000000000000000000000000\n",
    "     - nonce: b\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\"\n",
    "     - data: \"PyCon 2018 Genesis Block\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting the chain into blockchain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our simple blockchain, we will use a *list* to store each block of our blockchain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Define a class called \"blockchain\", define a the following functions\n",
    "     - \"\\__init__\": initialize a empty list\n",
    "     - \"add_blocks\": simply append a block to the list, (block is passed as an argument)\n",
    "     - \"blockchain_valid\": to check if the blockchain is valid, for now just return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain = blockchain()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain.blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain.add_block(genesis_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain.blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blockchain validity\n",
    "Now we want to check if our blockchain is valid. In our example, we want to check if the hash of each block is correct. First we need to create a hash of the block header + data and check if it is correct. Furthermore, we need to check if the previous hash in each block is correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Implement the \"blockchain_valid\", according to the description"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Good Genesis Block\n",
    "test_blockchain = blockchain()\n",
    "test_blockchain.add_block(genesis_block)\n",
    "print(test_blockchain.blockchain_valid()) # this should be True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bad Genesis Block\n",
    "test_blockchain = blockchain()\n",
    "test_blockchain.add_block(block(b\"1\", b\"2\"))\n",
    "print(test_blockchain.blockchain_valid(), \"--Bad Genesis Block--\") # this should be False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Blocks are correct\n",
    "test_blockchain = blockchain()\n",
    "test_blockchain.add_block(genesis_block)\n",
    "print(test_blockchain.blockchain_valid())\n",
    "\n",
    "print(genesis_block)\n",
    "test_block = block(genesis_block.hash, b\"DUMMY DATA\")\n",
    "print(test_block)\n",
    "test_blockchain.add_block(test_block)\n",
    "test_blockchain.blockchain_valid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block2 = block(test_block.hash, b\"DUMMY DATA2\")\n",
    "print(test_block2)\n",
    "test_blockchain.add_block(test_block2)\n",
    "test_blockchain.blockchain_valid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(test_blockchain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Proof of Work\n",
    "\n",
    "Well, now we have a basic blockchain working. However, there is one small problem, everyone can create blocks and chain them together. There is not much effort needed to create new blocks, hash them and add them to the ***list***.\n",
    "\n",
    "### Hashing to the rescue\n",
    "\n",
    "Why not make the creation of valid blocks hard. Then, we only accepts the blocks that have certain amount of work and effort done on them as valid. Each block hash should start with certain amount of zeros. We have set the number of zeros dynamically to be adapt with new technology and also number of ***block truthfulness seekers*** (miners)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Let's put this in code. Set the number of leading zeros to 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Blocks are correct\n",
    "test_blockchain = blockchain()\n",
    "test_blockchain.add_block(genesis_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block = block(genesis_block.hash, b\"DUMMY DATA\")\n",
    "test_block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block.find_nonce(3)\n",
    "test_block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain.add_block(test_block)\n",
    "test_blockchain.blockchain_valid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block2 = block(test_block.hash, b\"DUMMY DATA2\")\n",
    "print(test_block2, \"\\n\")\n",
    "test_block2.find_nonce(3)\n",
    "print(test_block2)\n",
    "test_blockchain.add_block(test_block2)\n",
    "test_blockchain.blockchain_valid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The tale of two blockchains\n",
    "\n",
    "Once again, we have something working. But there is one more problem, if you have to ***branches*** of the blockchain that are ***valid***, how to decide which one to use. We only want to have one true blockchain branch.\n",
    "\n",
    "Why not go with the blockchain that has the most effort and work done on it then? This translates into selecting the blockchain with the longest chain length. Easy!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain1 = blockchain()\n",
    "test_blockchain2 = blockchain()\n",
    "\n",
    "test_blockchain1.add_block(genesis_block)\n",
    "test_blockchain2.add_block(genesis_block)\n",
    "\n",
    "\n",
    "print(test_blockchain1)\n",
    "print()\n",
    "print(test_blockchain2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Set the difficulty to 3 and start creating two branches of the blockchain for 10 second each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mine_blocks(test_blockchain1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mine_blocks(test_blockchain2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(test_blockchain1.blocks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(test_blockchain2.blocks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations! You just created a simple blockchain, with mining, dynamic difficulty level, proof of work, and longest chain consensus algorithm. Now, what does it take to make our blockchain into a cryptocurrency?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cryptocurrency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To transfer our correct blockchain into a cryptocurrency, instead of storing random data, we need to store transaction data.\n",
    "\n",
    " - From: Alice\n",
    " - To: Bob\n",
    " - Amount: 10$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - If we just store the transactions, what stops anyone to put wrong transactions there?\n",
    " - Bob can just create a message indicating Alice-> Bob 100000..0000$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aysmmetric Encryption System and Signatures\n",
    "\n",
    "Fortunately, it's not too hard to mitigate against this.\n",
    "\n",
    " - Instead of Alice, Bob, X let's use $H(pub(Alice))$, $H(pub(Bob))$, $H(pub(X))$. $ADDR_X=H(pub(X))$\n",
    " - Now just sign the hash of a transaction with your private key\n",
    " - $S_X(H(ADDR_X -> ADDR_Y: 10\\$))$, S_X, signing using private key of X\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TX data from, to, amount \n",
    "tx_data = \"{0}======={1}======={2}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.backends import default_backend\n",
    "from cryptography.hazmat.primitives import hashes\n",
    "from cryptography.hazmat.primitives.asymmetric import ec\n",
    "from cryptography.hazmat.primitives.serialization import PublicFormat\n",
    "from cryptography.hazmat.primitives.serialization import Encoding\n",
    "from cryptography.hazmat.primitives import serialization\n",
    "import base64\n",
    "\n",
    "def hash_pub_key(private_key):\n",
    "        digest = hashes.Hash(hashes.SHA256(), backend=default_backend())\n",
    "        digest.update(private_key.public_key().public_bytes(Encoding.DER, PublicFormat.SubjectPublicKeyInfo))\n",
    "        return base64.b16encode(digest.finalize())\n",
    "\n",
    "def sign_tx(tx, private_key):\n",
    "    return private_key.sign(tx, ec.ECDSA(hashes.SHA256()))\n",
    "\n",
    "def serialize_pubkey(publickey):\n",
    "    serialized_public = publickey.public_bytes(\n",
    "    encoding=Encoding.PEM,\n",
    "    format=PublicFormat.SubjectPublicKeyInfo)\n",
    "    \n",
    "    return serialized_public\n",
    "\n",
    "def parse_serialized_pubkey(serialized_pubkey):\n",
    "    loaded_public_key = serialization.load_pem_public_key(serialized_pubkey, backend=default_backend())\n",
    "    return loaded_public_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Define three private keys (Alice, Bob, Carol) and H(pubkey) for each "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a transaction + signature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alice -> Bob, 10$\n",
    "tx_data_b = str.encode(tx_data.format(hash_pub_key(private_keys[\"Alice\"]),\n",
    "                          hash_pub_key(private_keys[\"Bob\"]),\n",
    "                          \"10\"))\n",
    "serialized_pubkey = serialize_pubkey(private_keys[\"Alice\"].public_key())\n",
    "siganture = sign_tx(tx_data_b, private_keys[\"Alice\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transaction data\n",
    "tx_b = tx_data_b+b'======='+serialized_pubkey+b'======='+siganture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bob -> Carol, 15$\n",
    "tx_data_b = str.encode(tx_data.format(hash_pub_key(private_keys[\"Bob\"]),\n",
    "                          hash_pub_key(private_keys[\"Carol\"]),\n",
    "                          \"15\"))\n",
    "serialized_pubkey = serialize_pubkey(private_keys[\"Bob\"].public_key())\n",
    "siganture = sign_tx(tx_data_b, private_keys[\"Bob\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transaction data\n",
    "tx_b2 = tx_data_b+b'======='+serialized_pubkey+b'======='+siganture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Carol -> Alice, 20$\n",
    "tx_data_b = str.encode(tx_data.format(hash_pub_key(private_keys[\"Carol\"]),\n",
    "                          hash_pub_key(private_keys[\"Alice\"]),\n",
    "                          \"20\"))\n",
    "serialized_pubkey = serialize_pubkey(private_keys[\"Carol\"].public_key())\n",
    "siganture = sign_tx(tx_data_b, private_keys[\"Carol\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transaction data\n",
    "tx_b3 = tx_data_b+b'======='+serialized_pubkey+b'======='+siganture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - Let's add 1 transactions to each block\n",
    " - Check if the signature is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SOLUTION\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Blocks are correct\n",
    "test_blockchain = blockchain()\n",
    "test_blockchain.add_block(genesis_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_block = block(genesis_block.hash, tx_b)\n",
    "test_block.find_nonce(3)\n",
    "test_blockchain.add_block(test_block)\n",
    "\n",
    "test_block = block(test_block.hash, tx_b2)\n",
    "test_block.find_nonce(3)\n",
    "test_blockchain.add_block(test_block)\n",
    "\n",
    "test_block = block(test_block.hash, tx_b3)\n",
    "test_block.find_nonce(3)\n",
    "test_blockchain.add_block(test_block)\n",
    "\n",
    "test_blockchain.blockchain_valid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_blockchain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for _block in test_blockchain.blocks[1:]:\n",
    "    verify_tx_signatures(_block.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *<font color=\" #6495ED\">Exercise</font>*\n",
    " - How to make sure the money is not already spent? (double spending)"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}