notebook/v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a8001822-b8bd-4efa-ad70-4b23761ccf33",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 1.1 Blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd64522-db10-403c-8028-40eb213bf519",
   "metadata": {},
   "source": [
    "Bitcoin is commonly thought about as a ledger of transactions. Let's roll with that."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd6493fb-78d9-43b0-a2e5-e568201e539d",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Headers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffcbaf89-6895-49f6-a07c-b12cf8d93010",
   "metadata": {},
   "source": [
    "We group the transactions into '**blocks**'. Each block has a **header**, which consists of the following attributes:\n",
    "\n",
    "- Version: The version number in use.\n",
    "- Previous hash: Each block has an identifier or hash. Here the 32-byte hash from the previous block is an attribute of the header of the current block.\n",
    "- Timestamp: Unix timestamp in seconds.\n",
    "- Nonce: A number that makes the hash of the header start with zeroes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a53d381a-78a4-4437-bceb-c1877190252d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Hash = bytes\n",
    "\n",
    "VERSION: int = 0\n",
    "\n",
    "def init_header(previous_hash: Hash, timestamp: int, nonce: int) -> bytes:\n",
    "    \"\"\" \"\"\"\n",
    "    return (\n",
    "        VERSION.to_bytes(1, byteorder=\"big\")\n",
    "        + previous_hash\n",
    "        + timestamp.to_bytes(4, byteorder=\"big\")\n",
    "        + nonce.to_bytes(32, byteorder=\"big\")\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0abe50-7c08-47fc-97eb-ed4c0dd1392f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb7c9541-30f1-4ba9-b045-0eead81a8c90",
   "metadata": {},
   "source": [
    "We use 'hash' as both a verb (to hash something) and a noun (the output of a hash function). It's a little confusing. To help clear things up, let's do something concrete - we solve for the nonce and create our first block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2655eb8a-788d-4732-ba12-8918429d2eff",
   "metadata": {},
   "source": [
    "Since there is no previous block, the previous hash is set to zero. We choose an arbitrary timestamp and initialize the nonce to zero. The header now looks like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "134e5113-b94d-42a1-adac-324a8efc20bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "header:\n",
      "b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00ao\\x8a\\xe0\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n"
     ]
    }
   ],
   "source": [
    "previous_hash = (0).to_bytes(32, byteorder=\"big\")\n",
    "timestamp = 1634700000\n",
    "nonce = 0\n",
    "\n",
    "header = init_header(previous_hash, timestamp, nonce)\n",
    "print(f\"header:\\n{header}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a09ce74f-59ff-4d95-a908-8c6f887eca9d",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88385480-fd86-4102-bc2a-6b9f3166a4bd",
   "metadata": {},
   "source": [
    "We can make the header more readable by limiting each line to 16 bytes and separating each byte with a dash delimiter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a4638d60-bfd7-4d3a-8e84-dd2a025136d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "header:\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-61-6f-8a-e0-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00\n"
     ]
    }
   ],
   "source": [
    "import binascii\n",
    "\n",
    "def prettify(b: bytes) -> str:\n",
    "    \"\"\" \"\"\"\n",
    "    n = len(b)\n",
    "    m = (n // 16) + (n % 16 > 0)\n",
    "\n",
    "    result = [\n",
    "        binascii.hexlify(b[i * 16 : (i + 1) * 16], sep=\"-\").decode()\n",
    "        for i in range(m)\n",
    "    ]\n",
    "    return \"\\n\".join(result)\n",
    "\n",
    "print(f\"header:\\n{prettify(header)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7efe87b-c2c3-4ace-9971-c3ca72717873",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9e42941-13e7-459f-ad61-ed7345b327e6",
   "metadata": {},
   "source": [
    "OK let's hash. We use SHA-256 and hash the header twice. Even though only the header is hashed, we call it the block hash as it's used to identify the whole block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "df4c86ee-9a60-446f-a146-10c5acf80b91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "block_hash:\n",
      "48-9d-bd-f5-fd-58-0f-dc-0f-c3-72-54-6a-83-46-7e\n",
      "10-01-71-84-09-f0-0c-96-25-90-72-7f-ba-21-cf-2a\n"
     ]
    }
   ],
   "source": [
    "import hashlib\n",
    "\n",
    "guess = hashlib.sha256(hashlib.sha256(header).digest())\n",
    "print(f\"block_hash:\\n{prettify(guess.digest())}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f217575-42fc-443e-8e8c-8639d7a3fa0e",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444d322a-2e04-4c91-8065-821cf9793cea",
   "metadata": {},
   "source": [
    "Let's require the first two bytes be zero. Since each byte is represented by two hex digits, we need the first four characters in the no-delimiter string be zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0e3355d2-1648-45cf-9f1f-154935b4d9b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "block_hash - no delimiter:\n",
      "489dbdf5fd580fdc0fc372546a83467e1001718409f00c962590727fba21cf2a\n",
      "\n",
      "is_new_block: False\n"
     ]
    }
   ],
   "source": [
    "print(f\"block_hash - no delimiter:\\n{guess.hexdigest()}\\n\")\n",
    "\n",
    "is_new_block = guess.hexdigest()[:4] == \"0000\"\n",
    "print(f\"is_new_block: {is_new_block}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b0e377-ccaf-44e4-a5c6-41905da145de",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fac8745-5428-4317-845a-c029b8a987b3",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53c0fca4-59a2-406b-9382-5aa690c1239b",
   "metadata": {},
   "source": [
    "Now we keep incrementing the nonce until the first two bytes are zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d270a566-1371-44ab-8576-d9d6e845a513",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nonce: 70822\n",
      "\n",
      "block_hash:\n",
      "00-00-1f-f5-84-95-c3-dc-2a-1a-aa-69-eb-ca-4e-9b\n",
      "3e-05-e6-3e-5a-31-9f-b7-3b-cd-cc-bc-db-ba-1e-72\n",
      "\n",
      "header:\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-61-6f-8a-e0-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-01-14-a6\n"
     ]
    }
   ],
   "source": [
    "previous_hash = (0).to_bytes(32, byteorder=\"big\")\n",
    "timestamp = 1634700000\n",
    "nonce = 0\n",
    "\n",
    "while True:\n",
    "    header = init_header(previous_hash, timestamp, nonce)\n",
    "    guess = hashlib.sha256(hashlib.sha256(header).digest())\n",
    "\n",
    "    if guess.hexdigest()[:4] == \"0000\":\n",
    "        break\n",
    "\n",
    "    nonce += 1\n",
    "\n",
    "print(f\"nonce: {nonce}\\n\")\n",
    "print(f\"block_hash:\\n{prettify(guess.digest())}\\n\")\n",
    "print(f\"header:\\n{prettify(header)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "128b22f5-89dc-4899-9c24-0c0ea9b2ddd8",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11d7b439-a156-4249-abc6-000d5839c01f",
   "metadata": {},
   "source": [
    "Let's wrap the while loop in a function, and allow for a maximum number of iterations - this will be useful in later sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5a0d957a-fdb8-4ba2-8dca-e2cfb596e1c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, Tuple\n",
    "import hashlib\n",
    "\n",
    "def run_proof_of_work(\n",
    "    previous_hash: Hash,\n",
    "    timestamp: int,\n",
    "    nonce: int = 0,\n",
    "    iterations: Optional[int] = None,\n",
    ") -> Tuple[bool, int, Optional[Hash], Optional[bytes]]:\n",
    "    \"\"\"Find nonce that makes the first 4 bytes of twice-hashed header all\n",
    "    zeroes. Maximum number of iterations can be specified.\"\"\"\n",
    "    iteration_counter = 0\n",
    "\n",
    "    while True:\n",
    "        if iterations is not None and iteration_counter == iterations:\n",
    "            return False, nonce, None, None\n",
    "\n",
    "        header = init_header(previous_hash, timestamp, nonce)\n",
    "        guess = hashlib.sha256(hashlib.sha256(header).digest())\n",
    "\n",
    "        if guess.hexdigest()[:4] == \"0000\":\n",
    "            break\n",
    "\n",
    "        nonce += 1\n",
    "        iteration_counter += 1\n",
    "\n",
    "    return True, nonce, guess.digest(), header"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a894ff5-941b-4af7-aabd-f774d0401e8c",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63210121-3ed1-4abc-a8b2-022269dcce26",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Transactions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a33607c-203a-4622-8765-14e3f5f64a1d",
   "metadata": {},
   "source": [
    "For the time being, we restrict the transaction to the reward for mining the block. We use port numbers to signify each 'account'. Since there is no sender in a reward transaction, we set the sender to be zero. In other words, (i) the first transaction in each block is the reward for the miner, and (ii) the reward transaction is signified by having sender zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6c352ee3-07ba-4667-9c8d-03605d500280",
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_transactions(node_port: int):\n",
    "    \"\"\" \"\"\"\n",
    "    sender = (0).to_bytes(2, byteorder=\"big\")\n",
    "    receiver = node_port.to_bytes(2, byteorder=\"big\")\n",
    "\n",
    "    transaction_counter = 1\n",
    "    transactions = sender + receiver\n",
    "\n",
    "    return transaction_counter, transactions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19ba20c2-d769-4810-a23e-f421d1db06df",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca98575a-41ba-4afd-8b6a-622b772c338f",
   "metadata": {},
   "source": [
    "We start with the first reward going to port 7000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ae501343-01a6-48a3-95f7-4c9ef1b6084a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transaction_counter: 1\n",
      "\n",
      "transactions:\n",
      "00-00-1b-58\n"
     ]
    }
   ],
   "source": [
    "transaction_counter, transactions = init_transactions(7000)\n",
    "\n",
    "print(f\"transaction_counter: {transaction_counter}\\n\")\n",
    "print(f\"transactions:\\n{prettify(transactions)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcfee710-e08e-458f-a29d-1fcded6b684f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d4d0560-6dc9-46ec-ba59-9ee5af84a659",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90292a54-6992-49c5-9f6b-e997f7d15253",
   "metadata": {},
   "source": [
    "The block consists of the header and the transactions - we similarly wrap that in a function. The first byte of the block is reserved for the block size in bytes. The header size is fixed at 69 bytes i.e. 1 + 32 + 4 + 32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2e937a55-2414-42f0-a0c2-14316afccfa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "HEADER_SIZE: int = 69\n",
    "\n",
    "def init_block(\n",
    "    header: bytes, transaction_counter: int, transactions: bytes\n",
    ") -> bytes:\n",
    "    \"\"\" \"\"\"\n",
    "    block_size = 1 + HEADER_SIZE + 1 + len(transactions)\n",
    "\n",
    "    return (\n",
    "        block_size.to_bytes(1, byteorder=\"big\")\n",
    "        + header\n",
    "        + transaction_counter.to_bytes(1, byteorder=\"big\")\n",
    "        + transactions\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3598f202-618f-469c-b123-eb623b1795e2",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a1a6c4c-4782-45fb-986b-5090066a4784",
   "metadata": {},
   "source": [
    "Let's collect what what we have so far with a function that creates the very first block, commonly referred to as the **genesis block**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c5b3cf96-515f-4aaf-a3d7-bf07017373cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_genesis_block() -> Tuple[Hash, bytes]:\n",
    "    \"\"\" \"\"\"\n",
    "    previous_hash = (0).to_bytes(32, byteorder=\"big\")\n",
    "    timestamp = 1634700000\n",
    "    nonce = 70822\n",
    "\n",
    "    header = init_header(previous_hash, timestamp, nonce)\n",
    "    guess = hashlib.sha256(hashlib.sha256(header).digest())\n",
    "    assert guess.hexdigest()[:4] == \"0000\"\n",
    "\n",
    "    transaction_counter, transactions = init_transactions(7000)\n",
    "    block = init_block(header, transaction_counter, transactions)\n",
    "\n",
    "    return guess.digest(), block"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d55443-9ce5-499b-b2a8-e1372b4179cb",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dfa9a4e-c4b4-466d-b3a8-055cce43ebfd",
   "metadata": {},
   "source": [
    "Finally we have in bytes (i) the hash of the the genesis block, and (ii) the genesis block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a095fa81-7c8b-4a71-837f-a634c16800ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "genesis_hash:\n",
      "00-00-1f-f5-84-95-c3-dc-2a-1a-aa-69-eb-ca-4e-9b\n",
      "3e-05-e6-3e-5a-31-9f-b7-3b-cd-cc-bc-db-ba-1e-72\n",
      "\n",
      "genesis_block:\n",
      "4b-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-61-6f-8a-e0-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-01-14-a6-01-00-00-1b-58\n"
     ]
    }
   ],
   "source": [
    "genesis_hash, genesis_block = init_genesis_block()\n",
    "\n",
    "print(f\"genesis_hash:\\n{prettify(genesis_hash)}\\n\")\n",
    "print(f\"genesis_block:\\n{prettify(genesis_block)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b081538-5e10-4045-ac91-ab76a2bc396f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17b89309-c21b-48a5-be66-f2c316c05484",
   "metadata": {},
   "source": [
    "We've simplified a lot! Let's look at a number of things that different compared to the actual implementation.\n",
    "\n",
    "- The mining difficulty is constant at two leading zero bytes. The actual implementation has a difficulty that changes so that a new block is mined, on average, every 10 minutes.\n",
    "- The reward for mining a block is one coin. The actual implementation started at 50 coins in 2009, and halves roughly every 4 years.\n",
    "- The account is represented by port numbers. The actual implementation uses public key cryptography to generate accounts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811b0f51-fea7-46a0-9e03-d7f57cb61580",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f790e830-9212-4adc-8c9d-bbc8c0a8eae4",
   "metadata": {},
   "source": [
    "In the next section, we'll be mining more blocks and 'chain' them together."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c76fdbe7-10bc-444d-bd89-33c06496a9cb",
   "metadata": {
    "tags": []
   },
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65d5022-8315-494d-b6a2-d86fc1b8bc01",
   "metadata": {},
   "source": [
    "# 1.2 Chains"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e00b487-9302-4862-90f1-8dfa429c3f3e",
   "metadata": {},
   "source": [
    "In the previous post, we introduced mining and created the genesis block. Let's mine more blocks and 'chain' them together - we call this the **blockchain**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51239554-96b4-4538-9a43-049e6b685afd",
   "metadata": {},
   "source": [
    "### Initializing the blockchain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb84411-ef78-43b1-8580-d088be6bb3d2",
   "metadata": {},
   "source": [
    "The genesis block is set as the first block in the blockchain. We also keep a running counter how many blocks have been mined. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e619ced6-7ff2-46d5-b1a7-74537058de22",
   "metadata": {},
   "outputs": [],
   "source": [
    "genesis_hash, genesis_block = init_genesis_block()\n",
    "\n",
    "blockchain = genesis_block\n",
    "block_counter = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea928cec-4767-4f4d-ab41-c0fe25c8a651",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d620057-74d4-4b1c-b536-e38127e5148d",
   "metadata": {},
   "source": [
    "As before, we use port numbers to represent accounts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9ebe768f-e7fa-4a05-a9d9-3541cfb3548b",
   "metadata": {},
   "outputs": [],
   "source": [
    "port = 7000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb57dbac-14af-4f38-a145-fb49ba0553dd",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcd4bb96-9cfe-4fb4-b562-4836cd10c4fe",
   "metadata": {},
   "source": [
    "Let's review steps 1 to 4 in mining a new block, introduced previously.\n",
    "\n",
    "1. Get the hash of the previous block, and combine that with the timestamp and nonce to create a header.\n",
    "2. Hash the header twice.\n",
    "3. If the first two bytes are not zero, increment the nonce and try again.\n",
    "4. If the first two bytes are zero, create a reward transaction and combine that with the header to create a new block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e650e893-a635-4437-bcce-ef5899860b5d",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2230555-b48f-443d-ac30-3370c337cfb7",
   "metadata": {},
   "source": [
    "In addition, we introduce steps 5 to 6. We run all the steps to mine up to 10 blocks.\n",
    "\n",
    "1. Append the new block to the blockchain.\n",
    "2. Re-initialize the previous hash, timestamp and nonce values to mine the next block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61c1b399-b7af-40b5-8160-d0552fae7aa2",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc11e75-9f97-43fd-bbf8-8818324db7ff",
   "metadata": {},
   "source": [
    "For our purposes, the first non-zero previous hash is the hash of the genesis block. We set up the loop to iterate through 1,000 nonce values at a time - we'll see why in the next post. Let's also print out (without delimiters) the block hash every time a new block is mined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1028d934-6bd1-4e52-9e37-cb6070fc93fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CREATE block 0: 00001ff58495c3dc2a1aaa69ebca4e9b3e05e63e5a319fb73bcdccbcdbba1e72\n",
      "CREATE block 1: 000071e6ff5b358e57339b42d45b20acc0f112c218fa435b3ffa8f239b777347\n",
      "CREATE block 2: 0000e7d62e199111cc9da5227d7029c8e1224a40a2927e312596732835947e7d\n",
      "CREATE block 3: 00008d85f05207e0db65b0d5c15136ec45ee57a52b9189c8b85e8126435cf6d1\n",
      "CREATE block 4: 000098989806054e1d3cf0b9a061e7b4492251300dc8d2281424612af7660280\n",
      "CREATE block 5: 000035736dd26882f64b58d6a95c37ebf849dc8a6d3a4d55083e0c4498440976\n",
      "CREATE block 6: 0000e136c7f750925dec1f4f6f9d806d1274c90249788042d335de32db69641f\n",
      "CREATE block 7: 00000953bf124a4c47ea23175c0c0dd0a66bb0841f4428f205032fb7b1274f97\n",
      "CREATE block 8: 000073bfe1dc76721bcf70e40d2ec5520d969c60170a8d6bc50b09c9a95526ba\n",
      "CREATE block 9: 000074271e92a82bf58f083d536444f7a12dba90f6432d03de0d573cf0979e38\n"
     ]
    }
   ],
   "source": [
    "previous_hash = genesis_hash\n",
    "timestamp = 1634700600\n",
    "nonce = 0\n",
    "\n",
    "print(\n",
    "    f\"CREATE block {block_counter - 1}: {binascii.hexlify(genesis_hash).decode()}\"\n",
    ")\n",
    "\n",
    "while True:\n",
    "    is_new_block, _, current_hash, header = run_proof_of_work(\n",
    "        previous_hash, timestamp, nonce, 1000\n",
    "    )\n",
    "\n",
    "    # Retry if not solved after 1000 nonce values.\n",
    "    if not is_new_block:\n",
    "        nonce += 1000\n",
    "        continue\n",
    "\n",
    "    # Create transaction to award block if solved.\n",
    "    transaction_counter, transactions = init_transactions(port)\n",
    "    block = init_block(header, transaction_counter, transactions)\n",
    "\n",
    "    blockchain += block\n",
    "    block_counter += 1\n",
    "\n",
    "    print(\n",
    "        f\"CREATE block {block_counter - 1}: {binascii.hexlify(current_hash).decode()}\"\n",
    "    )\n",
    "\n",
    "    if block_counter >= 10:\n",
    "        break\n",
    "\n",
    "    # Reset values for next block header.\n",
    "    previous_hash = current_hash\n",
    "    timestamp += 600\n",
    "    nonce = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a70cff28-d3fa-402c-9246-5121523f7192",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4edcb0fb-6f42-46f2-9625-9bb527726f4b",
   "metadata": {},
   "source": [
    "Each block is 75 bytes i.e. 1 + 69 + 1 + 4, so a blockchain with 10 blocks would be 750 bytes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c7ef2728-2b8b-40f0-919e-3ef4e28ad316",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blockchain:\n",
      "4b-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-61-6f-8a-e0-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-01-14-a6-01-00-00-1b-58-4b-00-00-00-1f\n",
      "f5-84-95-c3-dc-2a-1a-aa-69-eb-ca-4e-9b-3e-05-e6\n",
      "3e-5a-31-9f-b7-3b-cd-cc-bc-db-ba-1e-72-61-6f-8d\n",
      "38-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-e5\n",
      "90-01-00-00-1b-58-4b-00-00-00-71-e6-ff-5b-35-8e\n",
      "57-33-9b-42-d4-5b-20-ac-c0-f1-12-c2-18-fa-43-5b\n",
      "3f-fa-8f-23-9b-77-73-47-61-6f-8f-90-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-0f-17-01-00-00-1b\n",
      "58-4b-00-00-00-e7-d6-2e-19-91-11-cc-9d-a5-22-7d\n",
      "70-29-c8-e1-22-4a-40-a2-92-7e-31-25-96-73-28-35\n",
      "94-7e-7d-61-6f-91-e8-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-01-8c-7a-01-00-00-1b-58-4b-00-00-00\n",
      "8d-85-f0-52-07-e0-db-65-b0-d5-c1-51-36-ec-45-ee\n",
      "57-a5-2b-91-89-c8-b8-5e-81-26-43-5c-f6-d1-61-6f\n",
      "94-40-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "91-ec-01-00-00-1b-58-4b-00-00-00-98-98-98-06-05\n",
      "4e-1d-3c-f0-b9-a0-61-e7-b4-49-22-51-30-0d-c8-d2\n",
      "28-14-24-61-2a-f7-66-02-80-61-6f-96-98-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-d3-32-01-00-00\n",
      "1b-58-4b-00-00-00-35-73-6d-d2-68-82-f6-4b-58-d6\n",
      "a9-5c-37-eb-f8-49-dc-8a-6d-3a-4d-55-08-3e-0c-44\n",
      "98-44-09-76-61-6f-98-f0-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-e6-1c-01-00-00-1b-58-4b-00-00\n",
      "00-e1-36-c7-f7-50-92-5d-ec-1f-4f-6f-9d-80-6d-12\n",
      "74-c9-02-49-78-80-42-d3-35-de-32-db-69-64-1f-61\n",
      "6f-9b-48-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-03-cd-01-00-00-1b-58-4b-00-00-00-09-53-bf-12\n",
      "4a-4c-47-ea-23-17-5c-0c-0d-d0-a6-6b-b0-84-1f-44\n",
      "28-f2-05-03-2f-b7-b1-27-4f-97-61-6f-9d-a0-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-a5-c7-01-00\n",
      "00-1b-58-4b-00-00-00-73-bf-e1-dc-76-72-1b-cf-70\n",
      "e4-0d-2e-c5-52-0d-96-9c-60-17-0a-8d-6b-c5-0b-09\n",
      "c9-a9-55-26-ba-61-6f-9f-f8-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00\n",
      "00-00-00-00-00-00-02-3e-18-01-00-00-1b-58\n"
     ]
    }
   ],
   "source": [
    "print(f\"blockchain:\\n{prettify(blockchain)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1488d046-77b1-415f-bfe6-3fc4c195e24f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6636d99-a52a-405a-8b00-1c978e8e0be9",
   "metadata": {},
   "source": [
    "### Validating the blockchain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "508df5e8-6928-4844-a348-0c6703cfefeb",
   "metadata": {},
   "source": [
    "Suppose we have the opposite problem, in which we are given a blockchain and need to check that it is indeed valid. To make iterating through each block easier, let's create a helper function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7bd33642-0d5a-4439-b574-073df0a950f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "def iterate_blockchain(blockchain: bytes, byte_index: int = 0) -> Generator:\n",
    "    \"\"\"Helper function to simplify iterating through blocks in the blockchain.\"\"\"\n",
    "    block_counter = 0\n",
    "\n",
    "    while True:\n",
    "        block_size = blockchain[byte_index]\n",
    "        block = blockchain[byte_index : byte_index + block_size]\n",
    "\n",
    "        byte_index += block_size\n",
    "        block_counter += 1\n",
    "\n",
    "        yield block, block_counter, byte_index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74b33b73-2d4e-4960-b145-a83dc1d4e25b",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14419a50-311f-4348-87da-f58884160724",
   "metadata": {},
   "source": [
    "For validation, we check that:\n",
    "\n",
    "1. The previous hash attribute in the current header matches the hash of the previous block.\n",
    "2. The hash of the current header starts with two zero bytes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "63cafc71-601a-4acc-abf5-582eb1b5093f",
   "metadata": {},
   "outputs": [],
   "source": [
    "HASH_SIZE: int = 32\n",
    "\n",
    "def validate_blockchain(blockchain: bytes) -> Tuple[bool, int, Optional[bytes]]:\n",
    "    \"\"\"Check that all headers in the blockchain satisfy proof-of-work and indeed form a chain.\"\"\"\n",
    "    previous_hash = (0).to_bytes(32, byteorder=\"big\")\n",
    "    blockchain_size = len(blockchain)\n",
    "\n",
    "    for block, block_counter, byte_index in iterate_blockchain(\n",
    "        blockchain, byte_index=0\n",
    "    ):\n",
    "        header = block[1 : 1 + HEADER_SIZE]\n",
    "\n",
    "        if header[1 : 1 + HASH_SIZE] != previous_hash:\n",
    "            return False, block_counter, None\n",
    "\n",
    "        guess = hashlib.sha256(hashlib.sha256(header).digest())\n",
    "\n",
    "        if guess.hexdigest()[:4] != \"0000\":\n",
    "            return False, block_counter, None\n",
    "\n",
    "        previous_hash = guess.digest()\n",
    "\n",
    "        if byte_index == blockchain_size:\n",
    "            break\n",
    "\n",
    "    return True, block_counter, previous_hash"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5abee908-96a3-4257-9a04-429ec208cfcf",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4393bdaf-5216-4b6d-bc75-45f4479b7d6b",
   "metadata": {},
   "source": [
    "Now let's run our blockchain through the validation function, to confirm the result is as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e3eae1cb-b1de-43e0-b1fb-fb152a49534f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is_valid: True\n",
      "\n",
      "block_counter: 10\n",
      "\n",
      "latest_hash:\n",
      "00-00-74-27-1e-92-a8-2b-f5-8f-08-3d-53-64-44-f7\n",
      "a1-2d-ba-90-f6-43-2d-03-de-0d-57-3c-f0-97-9e-38\n"
     ]
    }
   ],
   "source": [
    "is_valid, block_counter, latest_hash = validate_blockchain(blockchain)\n",
    "\n",
    "print(f\"is_valid: {is_valid}\\n\")\n",
    "print(f\"block_counter: {block_counter}\\n\")\n",
    "print(f\"latest_hash:\\n{prettify(latest_hash)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39e0765c-8b76-42a4-bb56-6f923812d23b",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c6067e1-14d1-43e4-af5b-b3c4d1345a2f",
   "metadata": {},
   "source": [
    "In the next section, we'll implement multiple mining nodes that broadcast to each other."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8da8ba-f099-403c-badb-fab1d333b3dc",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a6d04e2-ed6c-4d63-a5a0-e686e6877fea",
   "metadata": {},
   "source": [
    "# 1.3 Nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3652d05b-56e8-4a14-b910-2b1f118cf761",
   "metadata": {},
   "source": [
    "In the previous post, we introduced a single miner. Now let's set up 3 nodes that mine and broadcast to each other."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "502d7b05-81e6-46fc-bc3e-6f70a8c5441d",
   "metadata": {},
   "source": [
    "### Context"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7bcd12-cce6-4fad-a751-e4365b628008",
   "metadata": {},
   "source": [
    "Let's start by sketching out what each node would do. In mining mode, the node tries 1,000 nonce values at a time and extends the blockchain if a solution is found. In listening mode, the node listens to the network and replaces its blockchain if the broadcasted blockchain is valid and longer than the existing blockchain. To keep things simple, the node would alternate between the two modes instead of running both in parallel."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84715954-da71-4983-8ea1-c3c612fdccc5",
   "metadata": {},
   "source": [
    "```python\n",
    "while True:\n",
    "    try:\n",
    "        # Listen for incoming messages.\n",
    "        #     If message received, check blockchain received is valid and longer      \n",
    "        #     than existing blockchain.\n",
    "        #         If true, replace existing blockchain and initialize variables\n",
    "        #         in header.\n",
    "        #         Otherwise, continue listening.\n",
    "        #     Otherwise, switch to mining mode.\n",
    "    except:\n",
    "        # Run proof-of-work.\n",
    "        #     If not solved after 1000 nonce values, switch to listening mode.\n",
    "        #     Otherwise, update blockchain and broadcast to network.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0484d42f-4656-46a9-a91c-9ef92db1fb06",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2bc8ac1-f589-4c7f-9012-1468c709935e",
   "metadata": {},
   "source": [
    "### Basic nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28a78965-6a9d-4061-9c8c-63ea14440213",
   "metadata": {},
   "source": [
    "Since most of our focus so far has been on mining, let's switch gears briefly to set up nodes that broadcast to each other. To ensure our nodes are set up correctly, we create a `.env` file with the IP address by running the following command in a terminal window."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f7d1d72-377b-48d6-a2c6-488ca846fc80",
   "metadata": {},
   "source": [
    "```\n",
    "echo 'NODE_IP='\"$(ipconfig getifaddr en0)\" > .env\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ff3dc8e-7f53-45dc-9e73-d376f32254b0",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86c6d75d-07aa-4bc0-acd3-44f3da538fca",
   "metadata": {},
   "source": [
    "Next we load the IP address as an environment variable, and enumerate all the ports to be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2bcea302-2bb2-4175-ade2-0d459e5910a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import dotenv\n",
    "import os\n",
    "\n",
    "dotenv.load_dotenv()\n",
    "\n",
    "NODE_IP = os.getenv(\"NODE_IP\")\n",
    "NODE_PORTS = [7000, 8000, 9000]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a8fb7ca-c578-4fc4-a2a8-5c3ce040dde1",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4ecbeec-748c-49e7-84f6-41866e23d770",
   "metadata": {},
   "source": [
    "We introduce a helper function to bind the network socket to the IP address-port pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1033ea34-6085-4fd8-b914-54b6b21063f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import socket\n",
    "\n",
    "def bind_socket(ip_address: str, port: int) -> socket.socket:\n",
    "    \"\"\" \"\"\"\n",
    "    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n",
    "    sock.bind((ip_address, port))\n",
    "    return sock"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87bbf76f-5fe1-4743-82e1-8710075d7b4f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419e38b0-5c17-4bee-8363-9853472d642f",
   "metadata": {},
   "source": [
    "Let's wrap the socket in a class and create functions to (i) initialize the node, and (ii) broadcast to other nodes. The node class also stores the blockchain state - we'll use this in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d3f67fad-fbe1-4660-8bbf-8f19f9d9d654",
   "metadata": {},
   "outputs": [],
   "source": [
    "import dataclasses\n",
    "\n",
    "@dataclasses.dataclass\n",
    "class Node:\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    port: int\n",
    "    sock: socket.socket\n",
    "    blockchain: bytes\n",
    "    block_counter: int\n",
    "\n",
    "def init_node(\n",
    "    port: int, blockchain: bytes = b\"\", block_counter: int = 0\n",
    ") -> Node:\n",
    "    \"\"\" \"\"\"\n",
    "    assert NODE_IP is not None\n",
    "    sock = bind_socket(NODE_IP, port)\n",
    "\n",
    "    return Node(\n",
    "        port=port,\n",
    "        sock=sock,\n",
    "        blockchain=blockchain,\n",
    "        block_counter=block_counter,\n",
    "    )\n",
    "\n",
    "def broadcast(node: Node, message: bytes):\n",
    "    \"\"\" \"\"\"\n",
    "    for node_port in NODE_PORTS:\n",
    "        if node_port == node.port:\n",
    "            continue\n",
    "\n",
    "        node.sock.sendto(message, (NODE_IP, node_port))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df2123be-faf2-4482-bd4f-81f3faa3648d",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa32a4d9-0928-441b-824b-bcdb9f43b2fa",
   "metadata": {},
   "source": [
    "In the placeholder version, we set up the nodes to broadcast a simple message to the network and then sleep for a random time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b7678bcf-5edd-4818-a931-5273a3f351fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "\n",
    "def run(node: Node):\n",
    "    \"\"\" \"\"\"\n",
    "    while True:\n",
    "        try:\n",
    "            node.sock.settimeout(1)\n",
    "            message, _ = node.sock.recvfrom(9216)\n",
    "\n",
    "            node_port = int.from_bytes(message[:2], byteorder=\"big\")\n",
    "            sleep_time = message[2]\n",
    "\n",
    "            print(f\"OTHER {node_port} sleep for {sleep_time} seconds...\")\n",
    "\n",
    "        except socket.timeout:\n",
    "            sleep_time = random.randint(1, 9)\n",
    "            message = node.port.to_bytes(\n",
    "                2, byteorder=\"big\"\n",
    "            ) + sleep_time.to_bytes(1, byteorder=\"big\")\n",
    "\n",
    "            broadcast(node, message)\n",
    "            print(f\"SELF {node.port} sleep for {sleep_time} seconds...\")\n",
    "\n",
    "            time.sleep(sleep_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3412260-5201-48af-a4d9-eaa2a00762cf",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62168eaf-21e1-4101-9b8f-65af92a5b9f7",
   "metadata": {},
   "source": [
    "We set up main to take in the port number as a command line argument."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92b176f5-f558-4300-b80e-fe45bc319d98",
   "metadata": {},
   "source": [
    "```\n",
    "import sys\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    port = int(sys.argv[1])\n",
    "    assert port in NODE_PORTS\n",
    "\n",
    "    node = init_node(port)\n",
    "    run(node)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef1261f-d47c-4b40-9692-d2d07e092997",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b63eef3-dc68-4400-afd6-beb38b3cf9b6",
   "metadata": {},
   "source": [
    "That's a fair amount of setup! Now respectively run each line in different terminal windows. A sample run can be seen here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d5d9b8f-518c-46ec-b168-5eac69c17741",
   "metadata": {},
   "source": [
    "```shell\n",
    "python node.py 7000\n",
    "python node.py 8000\n",
    "python node.py 9000\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea16c460-fb3a-47db-8639-367a0deda78f",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e32853e-6e2b-40a4-9d49-65bd22080973",
   "metadata": {},
   "source": [
    "### Mining nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd0f47a-d978-44d0-aaca-b4af6ae15d02",
   "metadata": {},
   "source": [
    "Now that we've done the heavy-lifting of setting up nodes that broadcast to each other, we can incorporate mining into the nodes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d1114b6-b981-410b-b2b3-f0b899e6e2f7",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6148dccd-1868-4242-95a1-e785d88a3f1e",
   "metadata": {},
   "source": [
    "We modify the node initialization so that the blockchain starts with the genesis block."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2c956db-90f9-416c-b949-0c7dae9fc765",
   "metadata": {},
   "source": [
    "```python\n",
    "import sys\n",
    "\n",
    "import blocks\n",
    "\n",
    "genesis_hash, genesis_block = blocks.init_genesis_block()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    port = int(sys.argv[1])\n",
    "    assert port in NODE_PORTS\n",
    "\n",
    "    node = init_node(port, genesis_block, 1)\n",
    "    run(node)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec85af3a-6ad7-424c-8237-136706453f83",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db803337-380b-49c6-9a2f-477f079adc54",
   "metadata": {},
   "source": [
    "At the start of this post, we discussed alternating between mining mode and listening mode. The steps in mining mode is similar to the previous post; the switch from mining to listening mode happens after trying 1,000 nonce values. The steps in listening mode are as follows.\n",
    "\n",
    "1. Listen to incoming messages from other nodes.\n",
    "2. If message is received, check broadcasted blockchain in the message is valid and longer than the existing blockchain.\n",
    "    1. If the broadcasted blockchain is valid and longer than the existing blockchain, replace the stored blockchain with the broadcasted blockchain.\n",
    "    2. If the broadcasted blockchain is invalid or not longer than the existing blockchain, ignore the broadcasted blockchain.\n",
    "3. If no message is received after listening for 1 second, switch to mining mode."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96577d69-160a-4329-9906-e65f0c84283b",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9607987-f7d7-49a7-b093-2755df0a876f",
   "metadata": {},
   "source": [
    "Since the blockchain is an array of bytes, we can broadcast it directly! We modify the run function as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6d99b1f6-a47b-4ebd-8849-4bcdb3d97d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "import binascii\n",
    "import time\n",
    "\n",
    "def run(node: Node):\n",
    "    \"\"\" \"\"\"\n",
    "    previous_hash = genesis_hash\n",
    "    timestamp = int(time.time())\n",
    "    nonce = 0\n",
    "\n",
    "    while True:\n",
    "        try:\n",
    "            # Listen for incoming messages, with maximum size set at OS X\n",
    "            # maximum UDP package size of 9216 bytes.\n",
    "            node.sock.settimeout(1)\n",
    "            blockchain, _ = node.sock.recvfrom(9216)\n",
    "\n",
    "            # Check blockchain received is valid.\n",
    "            (\n",
    "                is_new_block,\n",
    "                block_counter,\n",
    "                current_hash,\n",
    "            ) = blocks.validate_blockchain(blockchain)\n",
    "\n",
    "            # Skip if invalid or not longer than existing blockchain.\n",
    "            if not is_new_block or block_counter <= node.block_counter:\n",
    "                print(\"IGNORE blockchain...\")\n",
    "                continue\n",
    "\n",
    "            # Replace if valid and longer than existing.\n",
    "            node.blockchain = blockchain\n",
    "            node.block_counter = block_counter\n",
    "\n",
    "            assert current_hash is not None\n",
    "            print(\n",
    "                f\"COPY block {node.block_counter - 1}: {binascii.hexlify(current_hash).decode()}!\"\n",
    "            )\n",
    "\n",
    "            # Force sleep to randomize timestamp.\n",
    "            sleep_time = (node.port + block_counter) % 3 + 1\n",
    "            print(f\"SLEEP for {sleep_time} seconds...\")\n",
    "            time.sleep(sleep_time)\n",
    "\n",
    "        except socket.timeout:\n",
    "            # Run proof-of-work.\n",
    "            print(f\"TRY up to {nonce}...\")\n",
    "            is_new_block, _, current_hash, header = blocks.run_proof_of_work(\n",
    "                previous_hash, timestamp, nonce, 1000\n",
    "            )\n",
    "\n",
    "            # Switch to listening mode if not solved after 1000 nonce values.\n",
    "            if not is_new_block:\n",
    "                nonce += 1000\n",
    "                continue\n",
    "\n",
    "            # Create transaction to award block if solved.\n",
    "            assert current_hash is not None and header is not None\n",
    "            transaction_counter, transactions = blocks.init_transactions(\n",
    "                node.port\n",
    "            )\n",
    "            block = blocks.init_block(header, transaction_counter, transactions)\n",
    "\n",
    "            # Append new block to blockchain.\n",
    "            node.blockchain += block\n",
    "            node.block_counter += 1\n",
    "\n",
    "            # Broadcast full blockchain to network.\n",
    "            broadcast(node, node.blockchain)\n",
    "            print(\n",
    "                f\"CREATE block {node.block_counter - 1}: {binascii.hexlify(current_hash).decode()}!\"\n",
    "            )\n",
    "\n",
    "        # Reset values for next block header.\n",
    "        previous_hash = current_hash\n",
    "        timestamp = int(time.time())\n",
    "        nonce = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c416e38-a71f-4786-8fd6-0ec391576527",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8de6c73-38f1-43d4-b3ef-e0f3062d7bdc",
   "metadata": {},
   "source": [
    "With the changes in place, we re-run each line below in different terminal windows."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0995c80a-8991-421d-9cc1-afa5864ef1a0",
   "metadata": {},
   "source": [
    "```shell\n",
    "python node.py 7000\n",
    "python node.py 8000\n",
    "python node.py 9000\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30b132ea-f29d-4f6f-adee-8e6d2a0ed26b",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d877dfd-43ad-450f-97b0-7f4ed6d0d622",
   "metadata": {},
   "source": [
    "In the next series of posts, we'll take a closer look at transactions and validating that each coin is only spent once."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}