2.0-taproot-introduction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import util\n",
    "from test_framework.address import program_to_witness\n",
    "from test_framework.key import generate_key_pair\n",
    "from test_framework.messages import COutPoint, CTransaction, CTxIn, CTxOut, CTxInWitness\n",
    "from test_framework.script import SegwitV0SignatureHash, SIGHASH_ALL, hash160, get_p2pkh_script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.0 Taproot Introduction\n",
    "\n",
    "Over the following chapters, we introduce various aspects of the schnorr/taproot soft fork proposal. Each chapter is built around a case study, demonstrating how the technology can be used in world applications.\n",
    "\n",
    "In each chapter, we first introduce the case study scenario and give an overview of the technology. We then demonstrate its use as follows:\n",
    "\n",
    "1. We first construct a segwit v1 witness program that implements the desired spending policy and derive the bech32m address for that witness program;\n",
    "2. Then we start a Bitcoin Core full node, generate 101 blocks on the node (so that the node has a mature balance to spend), and spend coins from the Bitcoin Core wallet to the bech32m address from step (1);\n",
    "3. Finally, we construct a transaction spending from the output created in step (2) back to the Bitcoin Core wallet. We sign the transaction and verify that the transaction is valid using the full node's `testmempoolaccept` RPC method.\n",
    "\n",
    "This sequence of steps is illustrated below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![test](images/segwit_version1_1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In each chapter, we'll implement the spending policy using both v0 (pre-taproot) segwit and v1 (taproot) segwit outputs, and highlight the differences in transaction weight and privacy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transaction sequence\n",
    "\n",
    "This chapter demonstrates the transaction sequence in full detail. Future chapters follow the same steps, but use convenience functions to abstract away the low-level details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.1 Generate a segwit v0 bech32 address\n",
    "\n",
    "We generate an address *outside* the Bitcoin Core wallet, which we'll send funds to from Bitcoin Core.\n",
    "\n",
    "In this example, we'll use a P2WPKH segwit output (not a taproot output)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a new key pair\n",
    "privkey, pubkey = generate_key_pair()\n",
    "print(\"Pubkey: {}\\n\".format(pubkey.get_bytes(bip340=False).hex()))\n",
    "\n",
    "# Get the hash160 of the public key for the witness program\n",
    "# Note that the function 'get_bytes(bip340=False)' is used to get the compressed DER encoding of the public key needed for \n",
    "# segwit v0.\n",
    "program = hash160(pubkey.get_bytes(bip340=False))\n",
    "print(\"Witness program: {}\\n\".format(program.hex()))\n",
    "\n",
    "# Create (regtest) bech32 address\n",
    "version = 0x00\n",
    "address = program_to_witness(version, program)\n",
    "print(\"bech32 address: {}\".format(address))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.2 Start a Bitcoin Core node, then generate blocks and send output to the bech32 address generated above\n",
    "\n",
    "This functionality will be encapsulated in the `node.generate_and_send_coins(address)` method later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start node\n",
    "test = util.TestWrapper()\n",
    "test.setup()\n",
    "node = test.nodes[0]\n",
    "\n",
    "version = node.getnetworkinfo()['subversion']\n",
    "print(\"\\nClient version is {}\\n\".format(version))\n",
    "\n",
    "# Generate 101 blocks\n",
    "node.generate(101)\n",
    "balance = node.getbalance()\n",
    "print(\"Balance: {}\\n\".format(balance))\n",
    "\n",
    "assert balance > 1\n",
    "\n",
    "unspent_txid = node.listunspent(1)[-1][\"txid\"]\n",
    "inputs = [{\"txid\": unspent_txid, \"vout\": 0}]\n",
    "\n",
    "# Create a raw transaction sending 1 BTC to the address and then sign it.\n",
    "tx_hex = node.createrawtransaction(inputs=inputs, outputs=[{address: 1}])\n",
    "res = node.signrawtransactionwithwallet(hexstring=tx_hex)\n",
    "\n",
    "tx_hex = res[\"hex\"]\n",
    "assert res[\"complete\"]\n",
    "assert 'errors' not in res\n",
    "\n",
    "# Send the raw transaction. We haven't created a change output,\n",
    "# so maxfeerate must be set to 0 to allow any fee rate.\n",
    "txid = node.sendrawtransaction(hexstring=tx_hex, maxfeerate=0)\n",
    "\n",
    "print(\"Transaction {}, output 0\\nsent to {}\".format(txid, address))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.3 Construct a transaction to spend the coins back to the Bitcoin Core wallet\n",
    "\n",
    "In this example, we'll manually construct a transaction which spends the output back to the Bitcoin Core wallet.\n",
    "\n",
    "To do that we create a `CTransaction` object and populate the data members:\n",
    "\n",
    " * `nVersion`\n",
    " * `nLocktime`  \n",
    " * `tx_vin` (list of `CTxIn` objects)\n",
    " * `tx_vout` (list of `CTxOut` objects)\n",
    "\n",
    "This functionality will be encapsulated in the `test.create_spending_transaction(coin_txid, version)` method later.\n",
    "\n",
    "The only item that we don't populate is the witness:\n",
    " \n",
    " * `tx.wit.vtxinwit` (list of `CTxInWitness` objects)\n",
    "\n",
    "which we'll do later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct transaction\n",
    "spending_tx = CTransaction()\n",
    "\n",
    "# Populate the transaction version\n",
    "spending_tx.nVersion = 1\n",
    "\n",
    "# Populate the locktime\n",
    "spending_tx.nLockTime = 0\n",
    "\n",
    "# Populate the transaction inputs\n",
    "outpoint = COutPoint(int(txid, 16), 0)\n",
    "spending_tx_in = CTxIn(outpoint)\n",
    "spending_tx.vin = [spending_tx_in]\n",
    "\n",
    "# Generate new Bitcoin Core wallet address\n",
    "dest_addr = node.getnewaddress(address_type=\"bech32\")\n",
    "scriptpubkey = bytes.fromhex(node.getaddressinfo(dest_addr)['scriptPubKey'])\n",
    "\n",
    "# Complete output which returns 0.5 BTC to Bitcoin Core wallet\n",
    "amount_sat = int(0.5 * 100_000_000)\n",
    "dest_output = CTxOut(nValue=amount_sat, scriptPubKey=scriptpubkey)\n",
    "spending_tx.vout = [dest_output]\n",
    "\n",
    "print(\"Spending transaction:\\n{}\".format(spending_tx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.4 Generate signature for transaction, add it to the witness, and test mempool acceptance.\n",
    "\n",
    "In this example, we sign the transaction, add the signature to the transaction's witness, and then use `testmempoolaccept` to verify that the transaction is valid. Later on, we'll use the `node.test_transaction()` convenience method to test mempool acceptance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the segwit v0 signature hash for signing\n",
    "sighash = SegwitV0SignatureHash(script=get_p2pkh_script(program),\n",
    "                                txTo=spending_tx,\n",
    "                                inIdx=0,\n",
    "                                hashtype=SIGHASH_ALL,\n",
    "                                amount=100_000_000)\n",
    "\n",
    "# Sign using ECDSA and append the SIGHASH byte\n",
    "sig = privkey.sign_ecdsa(sighash) + chr(SIGHASH_ALL).encode('latin-1')\n",
    "\n",
    "print(\"Signature: {}\\n\".format(sig.hex()))\n",
    "\n",
    "# Add a witness to the transaction. For a P2WPKH, the witness field is the signature and pubkey\n",
    "spending_tx.wit.vtxinwit.append(CTxInWitness([sig, pubkey.get_bytes(bip340=False)]))\n",
    "\n",
    "print(\"Spending transaction:\\n{}\\n\".format(spending_tx))\n",
    " \n",
    "# Serialize signed transaction for broadcast\n",
    "spending_tx_str = spending_tx.serialize().hex()\n",
    " \n",
    "# Test mempool acceptance\n",
    "assert node.testmempoolaccept(rawtxs=[spending_tx_str], maxfeerate=0)[0]['allowed']\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.5 Shutdown the node\n",
    "\n",
    "Finally we run `test.shutdown()` to end the test and shutdown the node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.6 Repeat the steps using convenience functions\n",
    "\n",
    "We'll repeat the set of steps using the convenience functions:\n",
    "\n",
    "1. Start the node and create an output that we can spend using `node.generate_and_send_coins(address)`\n",
    "2. Create a `CTransaction` object that spends the output back to the Bitcoin Core wallet using `test.create_spending_transaction(coin_txid, version)`\n",
    "3. Manually sign the transaction and add the witness\n",
    "4. Test mempool acceptance using `node.test_transaction()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start node\n",
    "test = util.TestWrapper()\n",
    "test.setup()\n",
    "node = test.nodes[0]\n",
    "\n",
    "# Generate coins and create an output\n",
    "tx = node.generate_and_send_coins(address)\n",
    "print(\"Transaction {}, output 0\\nsent to {}\\n\".format(tx.hash, address))\n",
    "\n",
    "# Create a spending transaction\n",
    "spending_tx = test.create_spending_transaction(tx.hash)\n",
    "print(\"Spending transaction:\\n{}\\n\".format(spending_tx))\n",
    "\n",
    "# Sign the spending transaction and append the witness\n",
    "sighash = SegwitV0SignatureHash(script=get_p2pkh_script(program),\n",
    "                                txTo=spending_tx,\n",
    "                                inIdx=0,\n",
    "                                hashtype=SIGHASH_ALL,\n",
    "                                amount=100_000_000)\n",
    "sig = privkey.sign_ecdsa(sighash) + chr(SIGHASH_ALL).encode('latin-1')\n",
    "spending_tx.wit.vtxinwit.append(CTxInWitness([sig, pubkey.get_bytes(bip340=False)]))\n",
    "\n",
    "# Test mempool acceptance\n",
    "assert node.test_transaction(spending_tx)\n",
    "print(\"Success!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example 2.0.7 Shutdown the node\n",
    "\n",
    "As always, we finish by shutting down the node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations!** In this chapter, you have:\n",
    "\n",
    "- Started a Bitcoin Core full node (in regtest mode), generated 101 blocks and sent a transaction output to a segwit address\n",
    "- Constructed a transaction that spends the segwit output back to the wallet, and tested that it is accepted by the mempool\n",
    "- Repeated the same steps using the `generate_and_send_coins()` and `create_spending_transaction()` convenience functions\n",
    "\n",
    "We'll use exactly the same sequence of steps in future chapters to spend to and from segwit v1 addresses."
   ]
  }
 ],
 "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
}