HD_wallet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<style>\n",
    "    .title_div {\n",
    "    padding: 60px;\n",
    "    text-align: center;\n",
    "    background: #ffffff;\n",
    "    }\n",
    "    #title {\n",
    "        color: #f2a900;\n",
    "        font-size: 80px;\n",
    "    }\n",
    "    #subtitle {\n",
    "        color: #4d4d4e;\n",
    "        font-size: 20px;\n",
    "    }\n",
    "</style>\n",
    "\n",
    "<div class=\"title_div\">\n",
    "  <h1 id=\"title\">HD Wallet</h1>\n",
    "  <p id=\"subtitle\">Hierarchical Deterministic Wallet</p>\n",
    "</div>\n",
    "\n",
    "## TOC:\n",
    "* [Mnemonic Seed](#mneumonic-seed)\n",
    "    * [Entropy](#entropy)\n",
    "    * [Mnemonic creation](#mnemonic-create)\n",
    "    * [Seeding](#seeding)\n",
    "    * [Validation](#validation)\n",
    "        * [Mnemonic validation](#mnemonic-validation)\n",
    "        * [Seed validation](#seed-validation)\n",
    "* [Extended Keys](#extended-keys)\n",
    "    * [Master Extended Keys](#master-extended-keys)\n",
    "    * [Key derivation](#key-derivation)\n",
    "        * [Normal child extended private key](#normal-child-private)\n",
    "        * [Hardened child extended private key](#hardened-child-private)\n",
    "        * [Normal child extended public key](#normal-child-public)\n",
    "        * [Hardened child extended public key](#hardened-child-public)\n",
    "    * [Key derivation paths](#derivation-paths)\n",
    "    * [Two parties key derivation test](#two-parties)\n",
    "* [Encodings](#encodings)\n",
    "    * [Extended key serialization](#extended-serialization)\n",
    "    * [WIF](#wif)\n",
    "    * [Addresses](#addreses)\n",
    "* [Our HD-Wallet](#our-wallet)\n",
    "* [From address to QR code](#QRcode)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat, PrivateFormat\n",
    "from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC\n",
    "from cryptography.hazmat.primitives.asymmetric import ec\n",
    "from cryptography.hazmat.primitives import hashes, hmac\n",
    "from cryptography.hazmat import primitives\n",
    "\n",
    "\n",
    "from ecpy.curves import Curve, Point # for elliptic curve math\n",
    "from bitarray import bitarray, util \n",
    "from secrets import token_bytes # secure random source\n",
    "\n",
    "import hashlib # mainly for RMD160 hash\n",
    "import base58 # base 58 encoding\n",
    "\n",
    "# QR codes\n",
    "import pyqrcode\n",
    "from IPython.display import SVG\n",
    "import io"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mnemonic seed <a class=\"anchor\" id=\"mneumonic-seed\"></a>\n",
    "\n",
    "## Entropy <a clas=\"anchor\" id=\"entropy\"></a>\n",
    "Generate a blob between 128 and 256 bits from a secure random source.\n",
    "The length of the entropy should be multiple of 32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entropy_gen(n = 128):\n",
    "    if n < 128 or n > 256:\n",
    "        raise Exception(\"Entropy size must be between 128 and 256 bits inclusive.\")\n",
    "    if n % 32 != 0:\n",
    "        raise Exception(\"Entropy size must be multiple of 32.\")\n",
    "    return token_bytes(n // 8)\n",
    "\n",
    "entropy = entropy_gen(32*8)\n",
    "\n",
    "# Comment line bellow to generate new entropy\n",
    "entropy = bytes.fromhex(\"5558bc76602e06b585ecb25a5b80b56d0cdf0838efd96abb5aad949512270334\")\n",
    "print(f\"Entropy (hex): {entropy.hex()}\") #256 bits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mnemonic creation <a class=\"anchor\" id=\"mnemonic-create\"></a>\n",
    "\n",
    "To make the entropy more human friendly we conver it to a series or words and introduce some error checking. To do so in this case we are gonna make use of __[BIP39-english](https://raw.githubusercontent.com/otromimi/bitcoin_testpad/wallet/BIP-0039_english.txt)__.\n",
    "\n",
    "<div style=\"color:orange\">\n",
    "<h3>Atention</h3>\n",
    "Mnemonic phrases are suported in many lenguages and alphabets. This notebook only uses the english ASCII variant.</br>\n",
    "For other alphabets use UTF-8 NFKD encoding.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = {'red':'\\033[91m', 'green':'\\033[92m', 'yellow':'\\033[93m', 'blue':'\\033[94m', 'purple':'\\033[95m', 'cian':'\\033[96m', 'gray':'\\033[90m'}\n",
    "\n",
    "def mnemonic(bits):\n",
    "    entropy_bits = bitarray()\n",
    "    entropy_bits.frombytes(bits)\n",
    "    \n",
    "    # Checksum\n",
    "    hash256 = hashes.Hash(hashes.SHA256()) \n",
    "    hash256.update(bits)\n",
    "    bin_h = bitarray()\n",
    "    bin_h.frombytes(hash256.finalize())\n",
    "    \n",
    "    entropy_bits = entropy_bits + bin_h[:(len(entropy_bits) // 32)]\n",
    "\n",
    "    numbers = [] # words numbers\n",
    "    for i in range(len(entropy_bits)//11):\n",
    "        numbers.append(util.ba2int(entropy_bits[11*i:11*i+11]))\n",
    "\n",
    "    words = {} # words in our entropy\n",
    "    with open('BIP-0039_english.txt', 'r') as file:\n",
    "        for i, word in enumerate(file):\n",
    "            if i in numbers:\n",
    "                words[i] = word\n",
    "                if len(numbers) == len(words):\n",
    "                    break\n",
    "    \n",
    "    mnemonic_sentence = [] # mneumonic\n",
    "    for i in numbers:\n",
    "        mnemonic_sentence.append(words[i].strip()) \n",
    "    \n",
    "    return tuple(mnemonic_sentence)\n",
    "\n",
    "\n",
    "# change this assigment to check for different values.\n",
    "entropy = entropy # Ex: entropy = entropy_gen()\n",
    "\n",
    "mnemonic_sentence = \" \".join(mnemonic(entropy))\n",
    "\n",
    "# Entropy binary\n",
    "entropy_bits = bitarray()\n",
    "entropy_bits.frombytes(entropy)\n",
    "\n",
    "# Entropy hash\n",
    "hash256 = hashes.Hash(hashes.SHA256())\n",
    "hash256.update(entropy)\n",
    "bin_h = bitarray()\n",
    "entropy_hash = hash256.finalize()\n",
    "bin_h.frombytes(entropy_hash)\n",
    "\n",
    "# Printing\n",
    "if True:\n",
    "    print(colors['purple']+entropy_bits.to01(), end=\"\")\n",
    "    print(colors['yellow']+bin_h.to01()[:(len(entropy_bits) // 32)], end=\"\\n\")\n",
    "    print(f\"{colors['purple']}\\u2589 {'Entropy'}\")\n",
    "    print(f\"{colors['yellow']}\\u2589 {'Checksum (hash)'}\\033[0m\\n\")\n",
    "\n",
    "    print(f\"Entropy (hex): {entropy.hex()}\")\n",
    "    print(f\"Entropy SHA-256: {entropy_hash.hex()}\")\n",
    "\n",
    "    print(\"\\n\\u250F\"+\"\\u2501\"*(len(mnemonic_sentence)+2)+\"\\u2513\")\n",
    "    print(\"\\u2503 \"+mnemonic_sentence+\" \\u2503\")\n",
    "    print(\"\\u2517\"+\"\\u2501\"*(len(mnemonic_sentence)+2)+\"\\u251B\")\n",
    "\n",
    "del entropy_bits, hash256, bin_h, entropy_hash\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seeding<a class=\"anchor\" id=\"seeding\"></a>\n",
    "Derivates the seed that will be use for creating our cryptographic keys. We achive this by using an algorithm computer intensive that will slow down an attack.\n",
    "\n",
    "Algorithm used: PBKDF2_HMAC (Password Based Key Derivation Function 2)<br>\n",
    "* Hashing function: SHA-512 HMAC<br>\n",
    "* Iterations: 2048<br>\n",
    "* length: resulting key (seed) lenght in bytes<br>\n",
    "\n",
    "Thanks to the use of a HMAC (Hash Message Authentication Code) hash function we can add a salt (password) to our nmonic phrase.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mnemonic2seed(mnemonic_sentence, salt=\"\"):\n",
    "    \n",
    "    mnemonic_dev = PBKDF2HMAC(\n",
    "        algorithm = hashes.SHA512(),\n",
    "        length = 64, #bytes\n",
    "        salt = (\"mnemonic\"+salt).encode('ascii'),\n",
    "        iterations = 2048\n",
    "    )\n",
    "\n",
    "    mnemonic_bytes = mnemonic_sentence.encode('ascii')\n",
    "    seed = mnemonic_dev.derive(mnemonic_bytes)\n",
    "\n",
    "    return seed\n",
    "\n",
    "\n",
    "recovery_pass = \"\" # In case we want to add a salt to our mneumonic, add in here\n",
    "\n",
    "seed = mnemonic2seed(mnemonic_sentence, recovery_pass)\n",
    "\n",
    "if recovery_pass:\n",
    "    print(f\"Recovery password: {colors['red']}{recovery_pass}\\033[0m\")\n",
    "print(f\"Seed: {seed.hex()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation<a class=\"anchor\" id=\"validation\"></a>\n",
    "\n",
    "### Mnemonic validation<a class=\"anchor\" id=\"mnemonic-validation\"></a>\n",
    "Validates de entropy against its hash to determinate if the mnemonic secuence was correct.\n",
    "\n",
    "Requires: __[BIP39-english](https://raw.githubusercontent.com/otromimi/bitcoin_testpad/wallet/BIP-0039_english.txt)__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mnemonic_check(mnemonic):\n",
    "\n",
    "    words = mnemonic.split(\" \")\n",
    "    numbers = [None] * len(words)\n",
    "\n",
    "    with open('BIP-0039_english.txt') as file:\n",
    "        for i, word in enumerate(file):\n",
    "            if word.strip() in words:\n",
    "                for j, item in enumerate(words):\n",
    "                    if item == word.strip():\n",
    "                        numbers[j] = i\n",
    "    \n",
    "    entropy = \"\".join([f'{i:011b}' for i in numbers])\n",
    "    entropy = bitarray(entropy)\n",
    "\n",
    "    checksum_len = len(entropy) % 32\n",
    "\n",
    "    hash256 = hashes.Hash(hashes.SHA256())\n",
    "    hash256.update(entropy[:-checksum_len].tobytes())\n",
    "    bin_h = bitarray()\n",
    "    entropy_hash = hash256.finalize()\n",
    "    bin_h.frombytes(entropy_hash)\n",
    "    \n",
    "    if entropy[-checksum_len:] != bin_h[:checksum_len]:\n",
    "        # Just raised in case checksum for mneumonic fails.\n",
    "        raise Exception(f\"Checksum fail, hash: {entropy_hash.hex()}\")\n",
    "    \n",
    "    return entropy[:-checksum_len].tobytes()\n",
    "\n",
    "\n",
    "\n",
    "recover_entropy = mnemonic_check(mnemonic_sentence)\n",
    "\n",
    "print(f\"{entropy.hex()} -> entropy\") # entropy generated on first cell\n",
    "print(f\"{recover_entropy.hex()} -> recovered entropy\")\n",
    "\n",
    "del recover_entropy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seed validation<a class=\"anchor\" id=\"seed-validation\"></a>\n",
    "\n",
    "Validates the seed against the entropy and password."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seed_check(seed, password):\n",
    "\n",
    "    seed_chk = PBKDF2HMAC(\n",
    "        algorithm = hashes.SHA512(),\n",
    "        length = 64,\n",
    "        salt = (\"mnemonic\"+password).encode('ascii'),\n",
    "        iterations = 2048\n",
    "    )\n",
    "    seed_chk.verify(mnemonic_sentence.encode('ascii'), seed) # in case validation fails will raise a exception\n",
    "\n",
    "if not seed_check(seed, recovery_pass):\n",
    "    print(\"Seed check passed. \\u2705\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "# Extended keys <a class=\"anchor\" id=\"extended-keys\"></a>\n",
    "\n",
    "* [Master Extended Keys](#master-extended-keys)\n",
    "* [Key derivation](#key-derivation)\n",
    "    * [Normal child extended private key](#normal-child-private)\n",
    "    * [Hardened child extended private key](#hardened-child-private)\n",
    "    * [Normal child extended public key](#normal-child-public)\n",
    "    * [Hardened child extended public key](#hardened-child-public)\n",
    "* [Key derivation paths](#derivation-paths)\n",
    "* [Two parties key derivation test](#two-parties)\n",
    "\n",
    "## Master Extended Keys <a class=\"anchor\" id=\"master-extended-keys\"></a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def master_key_extended(seed):\n",
    "\n",
    "    expression = \"Bitcoin seed\" # Used for master key\n",
    "\n",
    "    hmac_master = hmac.HMAC(expression.encode('ascii'), hashes.SHA512())\n",
    "    hmac_master.update(seed)\n",
    "    output = hmac_master.finalize()\n",
    "\n",
    "    secret_num = output[:32]\n",
    "    chain_code = output[32:]\n",
    "\n",
    "    return ('m', secret_num, chain_code)\n",
    "\n",
    "\n",
    "_, prv_master_key, chain_master_code = master_key_extended(seed)\n",
    "\n",
    "private_key = ec.derive_private_key(int.from_bytes(prv_master_key, 'big'), ec.SECP256K1())\n",
    "public_key = private_key.public_key()\n",
    "pub_master_key = public_key.public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "\n",
    "print(f\"Chain code: {chain_master_code.hex()}\")\n",
    "print(f\"Private master key (d): {prv_master_key.hex()}\")\n",
    "print(f\"Public master key (compressed): {pub_master_key.hex()}\")\n",
    "\n",
    "del private_key, public_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Key derivation<a class=\"anchor\" id=\"key-derivation\"></a>\n",
    "\n",
    "1. [Normal child extended private key](#normal-child-private)\n",
    "2. [Hardened child extended private key](#hardened-child-private)\n",
    "3. [Normal child extended public key](#normal-child-public)\n",
    "4. [Hardened child extended public key](#hardened-child-public)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def key_derivation(index, parent_key, parent_chain_code):\n",
    "\n",
    "    index_bytes = index.to_bytes(32 // 8, 'big')\n",
    "    data = parent_key + index_bytes\n",
    "    salt = parent_chain_code\n",
    "\n",
    "    hmac_512 = hmac.HMAC(salt, hashes.SHA512())\n",
    "    hmac_512.update(data)\n",
    "    output = hmac_512.finalize()\n",
    "\n",
    "    return (output[:32], output[32:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normal child extended private key<a class=\"anchor\" id=\"normal-child-private\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def private_normal_child(index, parent_prv_key, parent_chain_code):\n",
    "    cv = Curve.get_curve('secp256k1')\n",
    "\n",
    "    # Order of SECP256K1\n",
    "    n = cv.order\n",
    "\n",
    "    # Index range checking\n",
    "    if index > 2147483647 | index < 0:\n",
    "        raise f\"Index: {index}, out of range for soft derivation.\"\n",
    "    \n",
    "    # Generating public key\n",
    "    private_key = ec.derive_private_key(int.from_bytes(parent_prv_key, 'big'), ec.SECP256K1())\n",
    "    public_key = private_key.public_key()\n",
    "    parent_pub_key = public_key.public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "    # Derivation function\n",
    "    child_prv_key, child_chain_code = key_derivation(index, parent_pub_key, parent_chain_code)\n",
    "\n",
    "    # Checking child_chain_code\n",
    "    if int.from_bytes(child_chain_code, 'big') > n:\n",
    "        raise f\"Chain code bigger than curve order \\\"n\\\"; Try with index {index + 1}\"\n",
    "    \n",
    "    # Calculating child private key\n",
    "    child_prv_key = ((int.from_bytes(child_prv_key, 'big') + int.from_bytes(parent_prv_key, 'big')) % n).to_bytes(32, 'big')\n",
    "\n",
    "    return (index, child_prv_key, child_chain_code)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "index, key, chain_code = private_normal_child(0, prv_master_key, chain_master_code)\n",
    "\n",
    "private_key = ec.derive_private_key(int.from_bytes(key, 'big'), ec.SECP256K1())\n",
    "public_key = private_key.public_key()\n",
    "public_compress_child = public_key.public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "print(f\"Index: {index}\")\n",
    "print(f\"Chain code: {chain_code.hex()}\")\n",
    "print(f\"Private key (d): {key.hex()}\")\n",
    "print(f\"Public key (compressed): {public_compress_child.hex()}\")\n",
    "\n",
    "del index, key, chain_code, private_key, public_key, public_compress_child"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hardened child extended private key<a class=\"anchor\" id=\"hardened-child-private\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def private_hardened_child(index, parent_prv_key, parent_chain_code):\n",
    "    cv = Curve.get_curve('secp256k1')\n",
    "\n",
    "    # Order of SECP256K1\n",
    "    n = cv.order\n",
    "\n",
    "    # Index range checking\n",
    "    if index > 2147483647 | index < 0:\n",
    "        raise f\"Index: {index}, Hard index: {index + 2147483648}, out of range for hard derivation.\"\n",
    "    \n",
    "    # Generating public key --> No required\n",
    "\n",
    "    # Derivation function\n",
    "    child_prv_key, child_chain_code = key_derivation(\n",
    "        index + 2147483648, # Hard index range\n",
    "        b'\\x00' + parent_prv_key, # Leading bit for public key compensation\n",
    "        parent_chain_code\n",
    "    )\n",
    "\n",
    "    # Checking child_chain_code\n",
    "    if int.from_bytes(child_chain_code, 'big') > n:\n",
    "        raise f\"Chain code bigger than curve order \\\"n\\\"; Try with index {index + 1}\"\n",
    "    \n",
    "    # Calculating child private key\n",
    "    child_prv_key = ((int.from_bytes(child_prv_key, 'big') + int.from_bytes(parent_prv_key, 'big')) % n).to_bytes(32, 'big')\n",
    "\n",
    "    return (index, child_prv_key, child_chain_code)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "index, key, chain_code = private_hardened_child(0, prv_master_key, chain_master_code)\n",
    "\n",
    "private_key = ec.derive_private_key(int.from_bytes(key, 'big'), ec.SECP256K1())\n",
    "public_key = private_key.public_key()\n",
    "public_compress_child = public_key.public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "\n",
    "print(f\"Index: {index}, Hard index: {index + 2147483648}\")\n",
    "print(f\"Chain code: {chain_code.hex()}\")\n",
    "print(f\"Private key (d): {key.hex()}\")\n",
    "print(f\"Public key (compressed): {public_compress_child.hex()}\")\n",
    "\n",
    "del index, key, chain_code, private_key, public_key, public_compress_child"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normal child extended public key<a class=\"anchor\" id=\"normal-child-public\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def public_normal_child(index, parent_pub_key, parent_chain_code):\n",
    "    cv = Curve.get_curve('secp256k1')\n",
    "\n",
    "    # Order of SECP256K1\n",
    "    n = cv.order\n",
    "\n",
    "    # Index range checking\n",
    "    if index > 2147483647 | index < 0:\n",
    "        raise f\"Index: {index}, out of range for soft derivation.\"\n",
    "    \n",
    "    # Generating public key --> No required, we pass the pub key as parameter\n",
    "\n",
    "    # Derivation function\n",
    "    child_pub_key, child_chain_code = key_derivation(index, parent_pub_key, parent_chain_code)\n",
    "\n",
    "    # Checking child_chain_code\n",
    "    if int.from_bytes(child_chain_code, 'big') > n:\n",
    "        raise f\"Chain code bigger than curve order \\\"n\\\"; Try with index {index + 1}\"\n",
    "\n",
    "    # Calculating child private key\n",
    "    parent_point = cv.decode_point(parent_pub_key)\n",
    "    child_point = cv.mul_point(int.from_bytes(child_pub_key, 'big'), cv.generator)\n",
    "    result_point = parent_point + child_point\n",
    "\n",
    "    # Encoding in weird format because ECPy doesn't support compress point encoding\n",
    "    child_pub_key = ec.EllipticCurvePublicKey.from_encoded_point(\n",
    "        ec.SECP256K1(), \n",
    "        bytes(cv.encode_point(result_point))).public_bytes(\n",
    "            Encoding.X962, \n",
    "            PublicFormat.CompressedPoint\n",
    "        )\n",
    "    \n",
    "    return (index, child_pub_key, child_chain_code)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "index, key, chain_code = public_normal_child(0, pub_master_key, chain_master_code)\n",
    "\n",
    "print(f\"Index: {index}\")\n",
    "print(f\"Chain code: {chain_code.hex()}\")\n",
    "print(f\"Parent public key (compressed): {pub_master_key.hex()}\")\n",
    "print(f\"Public key (compressed): {key.hex()}\")\n",
    "\n",
    "del index, key, chain_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hardened child extended public key<a class=\"anchor\" id=\"hardened-child-public\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def public_hardened_child(index, parent_pub_key, parent_chain_code):\n",
    "    raise f\"You need the private key to derive its peer public key.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Key derivation paths <a class=\"anchor\" id=\"derivation-paths\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def derive_path(path, seed):\n",
    "    path_list = path.split('/')\n",
    "    index, key, chain_code = None, None, None\n",
    "    for term in path_list:\n",
    "        if term == 'm':\n",
    "            # Master extended key from seed\n",
    "            _, key, chain_code = master_key_extended(seed)\n",
    "            continue\n",
    "        if \"'\" in term:\n",
    "            # Case term is hard\n",
    "            _, key, chain_code = private_hardened_child(int(term.strip(\"'\")), key, chain_code)\n",
    "        else:\n",
    "            # Case the term is soft of normal\n",
    "            _, key, chain_code = private_normal_child(int(term), key, chain_code)\n",
    "    return key, chain_code\n",
    "\n",
    "derivation_path = \"m/44'/0'/0'/0/0\" # Path extipulated on BIP 44\n",
    "\n",
    "path_key, _ = derive_path(derivation_path, seed)\n",
    "\n",
    "print(f\"Private key on {derivation_path}:\\n\\t{path_key.hex()}\")\n",
    "\n",
    "del derivation_path, path_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two parties key derivation test <a class=\"anchor\" id=\"two-parties\"></a>\n",
    "\n",
    "For this test we are gonna derive in parallel the public and private key; and then sign and verify a message with those keys independently derived."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Finding the master pub, prv and chain-code\n",
    "prv_secret, chain_code_m = derive_path(\"m\", seed)\n",
    "prv_key_m = ec.derive_private_key(int.from_bytes(prv_secret, 'big'), ec.SECP256K1())\n",
    "pub_key_m = prv_key_m.public_key().public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "# Derive our path for our private key\n",
    "prv_secret, _ = derive_path(\"m/444/8\", seed) # paths must be the same\n",
    "prv_key = ec.derive_private_key(int.from_bytes(prv_secret, 'big'), ec.SECP256K1())\n",
    "\n",
    "# We derive the same path for our public key\n",
    "_, pub_key, chain_code_child = public_normal_child(444, pub_key_m, chain_code_m) # 444/\n",
    "_, pub_key, chain_code_child = public_normal_child(8, pub_key, chain_code_child) # 8/\n",
    "pub_key = ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP256K1(), pub_key)\n",
    "\n",
    "# We sign a message with our derived private key\n",
    "message = b\"Testing derivaiton of extended keys.\"\n",
    "signature = prv_key.sign(message, ec.ECDSA(hashes.SHA256()))\n",
    "\n",
    "# If no exception raised then the signature is correct\n",
    "pub_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))\n",
    "\n",
    "\n",
    "del prv_secret, prv_key_m, pub_key_m, prv_key, pub_key, message, signature, \\\n",
    "    chain_code_child, chain_code_m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "# Encodings <a class=\"anchor\" id=\"encodings\"></a>\n",
    "\n",
    "* [Extended key serialization](#extended-serialization)\n",
    "* [WIF](#wif)\n",
    "* [Addresses](#addreses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extended key serialization <a class=\"anchor\" id=\"extended-serialization\"></a>\n",
    "\n",
    "version + depth + fingerprint + childnumber + chain_code + key + (checksum)\n",
    "\n",
    "* version:     puts xprv or xpub at the start\n",
    "* depth:       how many times this child has been derived from master key (0 = master key)\n",
    "* fingerprint: created from parent public key (allows you to spot adjacent xprv and xpubs)\n",
    "* childnumber: the index of this child key from the parent\n",
    "* chain_code:  the current chain code being used for this key\n",
    "* key:         the private or public key you want to create a serialized extended key for (prepend 0x00 for private)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extended_serialization(depth, parent_key, child_number, chain_code, key, version = None, testnet = True):\n",
    "\n",
    "    # Version BIP 44\n",
    "    if version == None and testnet == False:\n",
    "        serialized_key = b\"\\x04\\x88\\xad\\xe4\" if len(key) == 32 else b\"\\x04\\x88\\xb2\\x1e\"\n",
    "    elif version == None and testnet == True:\n",
    "        serialized_key = b\"\\x04\\x35\\x83\\x94\" if len(key) == 32 else b\"\\x04\\x35\\x87\\xcf\"\n",
    "    else:\n",
    "        serialized_key = verison\n",
    "   \n",
    "    # Depth\n",
    "    serialized_key += depth.to_bytes(1, 'big')\n",
    "\n",
    "    # Fingerpirnt of the pub father key\n",
    "    hash1 = hashlib.sha256(parent_key)\n",
    "    hash2 = hashlib.new('rmd160')\n",
    "    hash2.update(hash1.digest())\n",
    "    fingerprint = hash2.digest()[:4]\n",
    "\n",
    "    # Child index\n",
    "    index = child_number.to_bytes(4, 'big')\n",
    "\n",
    "    serialized_key += fingerprint + index + chain_code\n",
    "\n",
    "    # If pvt key prepend 0x00\n",
    "    if len(key) == 32:\n",
    "        serialized_key += b\"\\x00\"\n",
    "\n",
    "    serialized_key += key\n",
    "\n",
    "    # Checksum\n",
    "    hash1 = hashlib.sha256(serialized_key)\n",
    "    hash2 = hashlib.sha256(hash1.digest())\n",
    "\n",
    "    serialized_key += hash2.digest()[:4]\n",
    "\n",
    "    return base58.b58encode(serialized_key)\n",
    "\n",
    "\n",
    "# Derivaiton paths\n",
    "derivation_path = \"m/0\" #44'/0'/0'/0/0\n",
    "parent_derivation_path = \"/\".join(derivation_path.split('/')[:-1])\n",
    "\n",
    "# Generating necesary keys\n",
    "prv_key, chain_code = derive_path(derivation_path, seed)\n",
    "parent_prv_key, _ = derive_path(parent_derivation_path, seed)\n",
    "parent_prv_key = ec.derive_private_key(int.from_bytes(parent_prv_key, 'big'), ec.SECP256K1())\n",
    "parent_pub_key = parent_prv_key.public_key().public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "# Getting index and depth\n",
    "derivation_count = len(derivation_path.split('/'))-1\n",
    "child_n = int(derivation_path.split('/')[-1].strip(\"'\"))\n",
    "\n",
    "# Serialization\n",
    "serialized_key = extended_serialization(derivation_count, parent_pub_key, child_n, chain_code, prv_key)\n",
    "\n",
    "# Printing\n",
    "if True:\n",
    "    print(f\"Parent derivation path: {parent_derivation_path}\")\n",
    "    print(f\"Parent public key: {parent_pub_key.hex()}\\n\")\n",
    "\n",
    "    print(f\"Derivation path: {derivation_path}\")\n",
    "    print(f\"Key: {prv_key.hex()}\")\n",
    "    print(f\"Chain code: {chain_code.hex()}\\n\")\n",
    "\n",
    "    print(colors['red']+base58.b58decode(serialized_key).hex()[0:8], end=\"\")\n",
    "    print(colors['blue']+base58.b58decode(serialized_key).hex()[8:10], end=\"\")\n",
    "    print(colors['purple']+base58.b58decode(serialized_key).hex()[10:18], end=\"\")\n",
    "    print(colors['cian']+base58.b58decode(serialized_key).hex()[18:26], end=\"\")\n",
    "    print(colors['yellow']+base58.b58decode(serialized_key).hex()[26:90], end=\"\")\n",
    "    print(colors['green']+base58.b58decode(serialized_key).hex()[90:156], end=\"\")\n",
    "    print(colors['gray']+base58.b58decode(serialized_key).hex()[156:], end=\"\\n\")\n",
    "\n",
    "    print(f\"{colors['red']}\\u2589 {'Version'}\", end=\"\\t\")\n",
    "    print(f\"{colors['blue']}\\u2589 {'Depth'}\")\n",
    "    print(f\"{colors['purple']}\\u2589 {'Fingerprint'}\", end=\"\\t\")\n",
    "    print(f\"{colors['cian']}\\u2589 {'Child index'}\")\n",
    "    print(f\"{colors['yellow']}\\u2589 {'Chain code'}\", end=\"\\t\")\n",
    "    print(f\"{colors['green']}\\u2589 {'Key'}\")\n",
    "    print(f\"{colors['gray']}\\u2589 {'Checksum'}\", end=\"\\033[0m\\n\")\n",
    "\n",
    "    print(\"\\n\\u250F\"+\"\\u2501\"*(len(serialized_key.decode('ascii'))+2)+\"\\u2513\")\n",
    "    print(\"\\u2503 \"+serialized_key.decode('ascii')+\" \\u2503\")\n",
    "    print(\"\\u2517\"+\"\\u2501\"*(len(serialized_key.decode('ascii'))+2)+\"\\u251B\")\n",
    "\n",
    "del prv_key, chain_code, parent_prv_key, parent_pub_key, derivation_path, \\\n",
    "    parent_derivation_path, derivation_count, child_n, serialized_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WIF (wallet import format)<a class=\"anchor\" id=\"wif\"></a>\n",
    "\n",
    "A simple way to move private keys arround that contains the following fields in a human friendly base 54 encoding.\n",
    "1. Network (mainet or testnet)\n",
    "2. Private key (d)\n",
    "3. Compress byte (denotates if pub keys are compressed)\n",
    "4. Checksum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wif(key, compressed = True, testnet = True):\n",
    "\n",
    "    # Network\n",
    "    network = b\"\\xef\" if testnet else b\"\\x80\"\n",
    "    \n",
    "    # Network + key + compress byte\n",
    "    result = network + key + (b\"\\x01\" if compressed else b\"\")\n",
    "    \n",
    "    # Checksum\n",
    "    hash1 = hashlib.sha256(result)\n",
    "    hash2 = hashlib.sha256(hash1.digest())\n",
    "    result += hash2.digest()[0:4]\n",
    "\n",
    "    return base58.b58encode(result)\n",
    "\n",
    "\n",
    "wif_key = wif(prv_master_key)\n",
    "\n",
    "# Prints\n",
    "if True:\n",
    "    print(colors['red']+base58.b58decode(wif_key).hex()[0:2], end=\"\")\n",
    "    print(colors['blue']+base58.b58decode(wif_key).hex()[2:66], end=\"\")\n",
    "    if len(base58.b58decode(wif_key).hex()) > 37 * 2:\n",
    "        print(colors['yellow']+base58.b58decode(wif_key).hex()[66:68], end=\"\")\n",
    "        print(colors['purple']+base58.b58decode(wif_key).hex()[68:], end=\"\\n\")\n",
    "    else:\n",
    "        print(colors['purple']+base58.b58decode(wif_key).hex()[66:], end=\"\\n\")\n",
    "\n",
    "    print(f\"{colors['red']}\\u2589 {'Network'}\")\n",
    "    print(f\"{colors['blue']}\\u2589 {'Key'}\")\n",
    "    print(f\"{colors['yellow']}\\u2589 {'Compress byte'}\")\n",
    "    print(f\"{colors['purple']}\\u2589 {'Checksum'}\", end=\"\\033[0m\\n\")\n",
    "\n",
    "    print(\"\\n\\u250F\"+\"\\u2501\"*(len(wif_key.decode('ascii'))+2)+\"\\u2513\")\n",
    "    print(\"\\u2503 \"+wif_key.decode('ascii')+\" \\u2503\")\n",
    "    print(\"\\u2517\"+\"\\u2501\"*(len(wif_key.decode('ascii'))+2)+\"\\u251B\")\n",
    "\n",
    "del wif_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addresses (P2PKH)<a class=\"anchor\" id=\"addreses\"></a>\n",
    "\n",
    "Bitcoin addresses for P2PKH (Pay to public key hash)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def P2PKH(pub_key, testnet = True):\n",
    "    # Network\n",
    "    network = b\"\\x6f\" if testnet else b\"\\x00\"\n",
    "\n",
    "    # hash160\n",
    "    hash1 = hashlib.sha256(pub_key)\n",
    "    hash2 = hashlib.new('rmd160')\n",
    "    hash2.update(hash1.digest())\n",
    "    result = network + hash2.digest()\n",
    "\n",
    "    # Checksum\n",
    "    hash1 = hashlib.sha256(result)\n",
    "    hash2 = hashlib.sha256(hash1.digest())\n",
    "    result += hash2.digest()[:4]\n",
    "\n",
    "    return base58.b58encode(result)\n",
    "\n",
    "address = P2PKH(pub_master_key, False)\n",
    "\n",
    "# Prints\n",
    "if True:\n",
    "    print(colors['red']+base58.b58decode(address).hex()[0:2], end=\"\")\n",
    "    print(colors['blue']+base58.b58decode(address).hex()[2:-8], end=\"\")\n",
    "    print(colors['purple']+base58.b58decode(address).hex()[-8:], end=\"\\n\")\n",
    "\n",
    "    print(f\"{colors['red']}\\u2589 {'Version'}\")\n",
    "    print(f\"{colors['blue']}\\u2589 {'hash160(pub_key)'}\")\n",
    "    print(f\"{colors['purple']}\\u2589 {'Checksum'}\", end=\"\\033[0m\\n\")\n",
    "\n",
    "    print(\"\\n\\u250F\"+\"\\u2501\"*(len(address.decode('ascii'))+2)+\"\\u2513\")\n",
    "    print(\"\\u2503 \"+address.decode('ascii')+\" \\u2503\")\n",
    "    print(\"\\u2517\"+\"\\u2501\"*(len(address.decode('ascii'))+2)+\"\\u251B\")\n",
    "\n",
    "del address"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# Our HD-Wallet <a class=\"anchor\" id=\"our-wallet\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not 'mnemonic_sentence' in vars():\n",
    "    entropy = entropy_gen(256)\n",
    "    mnemonic_sentence = \" \".join(mnemonic(entropy))\n",
    "\n",
    "print(\"\\n\\u250F\"+\"\\u2501\"*(len(mnemonic_sentence)+2)+\"\\u2513\")\n",
    "print(\"\\u2503 \"+mnemonic_sentence+\" \\u2503\")\n",
    "print(\"\\u2517\"+\"\\u2501\"*(len(mnemonic_sentence)+2)+\"\\u251B\")\n",
    "\n",
    "seed = mnemonic2seed(mnemonic_sentence)\n",
    "\n",
    "def encoded_key_pairs(prv_key, chain_code, testnet = True):\n",
    "    # WIF for private key\n",
    "    wif_key = wif(prv_key, True, testnet)\n",
    "\n",
    "    # Getting public key\n",
    "    prv_key = ec.derive_private_key(int.from_bytes(prv_key, 'big'), ec.SECP256K1())\n",
    "    pub_key = prv_key.public_key().public_bytes(Encoding.X962, PublicFormat.CompressedPoint)\n",
    "\n",
    "    # Address from public key\n",
    "    address = P2PKH(pub_key, testnet)\n",
    "    \n",
    "    return (wif_key, address)\n",
    "\n",
    "\n",
    "derivation_path = \"m/44'/1'/0'/0/0\" # Path testnet BIP 44\n",
    "\n",
    "recieve_addresses = []\n",
    "\n",
    "if True:\n",
    "    print(\"{:18}{:38}{:55}\".format('Path'.center(18),'Address'.center(38),'WIF'.center(55)))\n",
    "    print(colors['gray']+\"-\"*111, end='\\033[0m\\n')\n",
    "\n",
    "    # Ordinary\n",
    "    for i in range(10): # Wallets search on the first 20 addresses\n",
    "        derivation = derivation_path.split('/')\n",
    "        derivation[-1] = str(int(derivation_path[-1]) + i)\n",
    "\n",
    "        extended_key = derive_path(\"/\".join(derivation), seed)\n",
    "        key_pair = encoded_key_pairs(*extended_key, True)\n",
    "\n",
    "        print(\"{:>18}\".format(\"/\".join(derivation)), end=\"\")\n",
    "        print(\"{}{:>38}\".format(colors['blue'], key_pair[1].decode('ascii')), end=\"\")\n",
    "        print(\"{}{:>55}\".format(colors['red'], key_pair[0].decode('ascii')), end=\"\\033[0m\\n\")\n",
    "        recieve_addresses.append(key_pair[1].decode('ascii'))\n",
    "\n",
    "    # Change\n",
    "    for i in range(5):\n",
    "        derivation = derivation_path.split('/')\n",
    "        derivation[-2] = '1'\n",
    "        derivation[-1] = str(int(derivation_path[-1]) + i)\n",
    "\n",
    "        extended_key = derive_path(\"/\".join(derivation), seed)\n",
    "        key_pair = encoded_key_pairs(*extended_key, True)\n",
    "\n",
    "        print(\"{:>18}\".format(\"/\".join(derivation)), end=\"\")\n",
    "        print(\"{}{:>38}\".format(colors['yellow'], key_pair[1].decode('ascii')), end=\"\")\n",
    "        print(\"{}{:>55}\".format(colors['red'], key_pair[0].decode('ascii')), end=\"\\033[0m\\n\")\n",
    "    \n",
    "del derivation_path, extended_key, key_pair, derivation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# From address to QR code <a class=\"anchor\" id=\"QRcode\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "address = recieve_addresses[0] # Substitude for address to encode\n",
    "\n",
    "QRCode = pyqrcode.create(address)\n",
    "buffer = io.BytesIO()\n",
    "QRCode.svg(buffer, scale=6)\n",
    "\n",
    "SVG(buffer.getvalue())"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a61bcf1725ac39fd63ff1bfe1b2a097d9bf3f5b24512166876b54ab35169d45a"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 ('hd-wallet-2EL5oofP')",
   "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.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}