chapter2-segwitv0/p2wsh-2-of-2-multisig.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a P2WSH multisig transaction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we'll create a P2WSH transaction from scratch in python. We'll go through each part of the transaction, how it's constructed, signed, and we'll test it using bitcoin core in regtest mode.\n",
    "\n",
    "## Prerequisite knowledge\n",
    "- For all notebooks:\n",
    "    - A high level understanding of the bitcoin. e.g. [Mastering Bitcoin](https://github.com/bitcoinbook/bitcoinbook) by Andreas Antonopoulos UTXO model, in particular [Chapter 6](https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch06.asciidoc).\n",
    "    - A conceptual understanding of [hash functions](https://www.thesslstore.com/blog/what-is-a-hash-function-in-cryptography-a-beginners-guide).\n",
    "    - [Hexadecimal notation](https://inst.eecs.berkeley.edu/~cs61bl/r//cur/bits/decimal-binary-hex.html?topic=lab28.topic&step=2&course=) and [endianness](https://www.freecodecamp.org/news/what-is-endianness-big-endian-vs-little-endian/).\n",
    "\n",
    "\n",
    "- Specific to this notebook:\n",
    "    - SHA256, HASH256, HASH160 - '[Hash Functions chapter](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/appendix/hash-functions.ipynb)'\n",
    "    - Base58 addresses - '[Addresses chapter](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/appendix/Addresses.ipynb)'\n",
    "    - Bitcoin Script basics - '[Bitcoin Script chapter](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/appendix/Bitcoin%20Script.ipynb)'\n",
    "    - TestShell setup - '[P2PKH chapter](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/chapter1-legacy/p2pkh.ipynb)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup \n",
    "\n",
    "### Requirements\n",
    "For this exercise we'll need Bitcoin Core. This notebook has been tested with [v24.0.1](https://github.com/bitcoin/bitcoin/releases/tag/v24.0.1).\n",
    "\n",
    "Below, set the paths for:\n",
    "1. The bitcoin core functional test framework directory.\n",
    "2. The directory containing bitcoin-tx-tutorial.\n",
    "\n",
    "**You'll need to edit these next two lines for your local setup.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_to_bitcoin_functional_test = \"/Users/dariuscognac/bitcoin/test/functional\"\n",
    "path_to_bitcoin_tx_tutorial = \"/Users/dariuscognac/Documents/Github/bitcoin-tx-tutorial\"\n",
    "\n",
    "import sys\n",
    "\n",
    "# Add the functional test framework to our PATH\n",
    "sys.path.insert(0, path_to_bitcoin_functional_test)\n",
    "from test_framework.test_shell import TestShell\n",
    "\n",
    "# Add the bitcoin-tx-tutorial functions to our PATH\n",
    "sys.path.insert(0, path_to_bitcoin_tx_tutorial)\n",
    "from functions import *\n",
    "\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a P2WSH multisig UTXO\n",
    "\n",
    "In order to create a transaction spending from a P2WSH multisig UTXO, we'll first need to create the UTXO that is locked with a multisig script. For this example we'll use a 2 of 2 multisig script. Note that this type of output will be identical to funding transactions used for layer 2 lightning channels. \n",
    "\n",
    "We'll create a two pubkeys and manually conscruct the multisig script. Then we'll fund it using the bitcoind wallet created in the setup step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create a multisig redeemScript \n",
    "For more on this step, review the 'Bitcoin Script' notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5221034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa2102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f2752ae\n"
     ]
    }
   ],
   "source": [
    "privkey1 = bytes.fromhex(\"1111111111111111111111111111111111111111111111111111111111111111\")\n",
    "pubkey1 = privkey_to_pubkey(privkey1)\n",
    "\n",
    "privkey2 = bytes.fromhex(\"2222222222222222222222222222222222222222222222222222222222222222\")\n",
    "pubkey2 = privkey_to_pubkey(privkey2)\n",
    "\n",
    "# \"21\" is the length of a 33 byte (compressed) pubkey in hex notation\n",
    "redeemScript = bytes.fromhex(\n",
    "    \"52\" \n",
    "    + \"21\"\n",
    "    + pubkey1.hex()\n",
    "    + \"21\"\n",
    "    + pubkey2.hex()\n",
    "    + \"52\"\n",
    "    + \"ae\")\n",
    "\n",
    "print(redeemScript.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convert the redeemScript to a P2WSH address\n",
    "\n",
    "For more on this step, review the 'Addresses' notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bcrt1qpqn5k3h89nfv6cnrkvk3rt3g0zfhqfz23cxkgapsenj29ety5ckqyrn25s\n"
     ]
    }
   ],
   "source": [
    "address_to_spend = script_to_p2wsh(redeemScript, \"regtest\")\n",
    "print(address_to_spend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fund the 'sender' with 2.001 btc (0.001 btc is for the next tx fee)\n",
    "\n",
    "Now that we have the address, we'll fund it using the `TestShell` commands. For more on these steps you can view the [function definitions](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/functions/setup_testshell.py) or look at the first [P2PKH notebook](https://github.com/DariusParvin/bitcoin-tx-tutorial/blob/main/chapter1-legacy/p2pkh.ipynb) example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-12-29T01:40:28.907000Z TestFramework (INFO): Initializing test directory /var/folders/r5/yk8yg2xs1gs8xzkn5l8vr72w0000gn/T/bitcoin_func_test_amyyxq7f\n",
      "txid: 1362ff4ca1cfefb688f3c8b2e965cfed68d8c1549d161162684920dd218b5498, 0\n"
     ]
    }
   ],
   "source": [
    "node = setup_testshell()\n",
    "txid_to_spend, index_to_spend = fund_address(node, address_to_spend, 2.001)\n",
    "print(f\"txid: {txid_to_spend}, {index_to_spend}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spending a P2WSH (multisig) UTXO\n",
    "\n",
    "Now that we have some funds locked up in a P2WSH multisig utxo, we can create a transaction spending from it. Let's say we want to send 1.5 btc to the address `mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE`.\n",
    "\n",
    "From our previous examples we know this corresponds to a scriptPubkey of `76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac`, so we will skip the decoding step. For more on decoding base58 addresses, refer to the 'Addresses' chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "receiver_spk = bytes.fromhex(\"76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an unsigned P2WSH transaction\n",
    "\n",
    "The first thing we'll do is define the inputs and outputs of our transaction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note we have already defined a few variables we need to create our transaction:\n",
    "# The input utxo txid and index: `txid_to_spend` and `index_to_spend`\n",
    "# The input private key and public key: `privkey1`, `pubkey1`, ...\n",
    "\n",
    "# Set our outputs\n",
    "# Create a new pubkey to use as a change output.\n",
    "change_privkey = bytes.fromhex(\"4444444444444444444444444444444444444444444444444444444444444444\")\n",
    "change_pubkey = privkey_to_pubkey(change_privkey)\n",
    "\n",
    "# Determine our output scriptPubkeys and amounts (in satoshis)\n",
    "output1_value_sat = int(float(\"1.5\") * 100000000)\n",
    "output1_spk = receiver_spk\n",
    "output2_value_sat = int(float(\"0.5\") * 100000000)\n",
    "output2_spk = bytes.fromhex(\"76a914\") + hash160(change_pubkey) + bytes.fromhex(\"88ac\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've defined everything we need, we can fill in the fields we need to create our unsigned transaction. What makes a transaction 'unsigned' is that the witness field is empty. This first step is necessary as the signature will cover the whole transaction (using SIGHASH_ALL). In a later chapter we will cover other sighash types and how they are signed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unsigned_tx:  020000000198548b21dd2049686211169d54c1d868edcf65e9b2c8f388b6efcfa14cff62130000000000ffffffff0280d1f008000000001976a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac80f0fa02000000001976a914cc1b07838e387deacd0e5232e1e8b49f4c29e48488ac00000000\n"
     ]
    }
   ],
   "source": [
    "# VERSION\n",
    "# version '2' indicates that we may use relative timelocks (BIP68)\n",
    "version = bytes.fromhex(\"0200 0000\")\n",
    "\n",
    "# MARKER (new to segwit)\n",
    "marker = bytes.fromhex(\"00\")\n",
    "\n",
    "# FLAG (new to segwit)\n",
    "flag = bytes.fromhex(\"01\")\n",
    "\n",
    "# INPUTS\n",
    "# We have just 1 input\n",
    "input_count = bytes.fromhex(\"01\")\n",
    "\n",
    "# Convert txid and index to bytes (little endian)\n",
    "txid = (bytes.fromhex(txid_to_spend))[::-1]\n",
    "index = index_to_spend.to_bytes(4, byteorder=\"little\", signed=False)\n",
    "\n",
    "# For the unsigned transaction we use an empty scriptSig\n",
    "scriptsig = bytes.fromhex(\"\")\n",
    "\n",
    "# use 0xffffffff unless you are using OP_CHECKSEQUENCEVERIFY, locktime, or rbf\n",
    "sequence = bytes.fromhex(\"ffff ffff\")\n",
    "\n",
    "inputs = (\n",
    "    txid\n",
    "    + index\n",
    "    + varint_len(scriptsig)\n",
    "    + scriptsig\n",
    "    + sequence\n",
    ")\n",
    "\n",
    "# OUTPUTS\n",
    "# 0x02 for out two outputs\n",
    "output_count = bytes.fromhex(\"02\")\n",
    "\n",
    "# OUTPUT 1 \n",
    "output1_value = output1_value_sat.to_bytes(8, byteorder=\"little\", signed=True)\n",
    "# 'output1_spk' already defined at the start of the script\n",
    "\n",
    "# OUTPUT 2\n",
    "output2_value = output2_value_sat.to_bytes(8, byteorder=\"little\", signed=True)\n",
    "# 'output2_spk' already defined at the start of the script\n",
    "\n",
    "outputs = (\n",
    "    output1_value\n",
    "    + pushbytes(output1_spk)\n",
    "    + output2_value\n",
    "    + pushbytes(output2_spk)\n",
    ")\n",
    "\n",
    "# LOCKTIME\n",
    "locktime = bytes.fromhex(\"0000 0000\")\n",
    "\n",
    "unsigned_tx = (\n",
    "    version\n",
    "    + input_count\n",
    "    + inputs\n",
    "    + output_count\n",
    "    + outputs\n",
    "    + locktime\n",
    ")\n",
    "print(\"unsigned_tx: \", unsigned_tx.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can decode this raw transaction to inspect it and see that it has all the information we need apart from the segwit fields (marker, flag, witness)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"txid\": \"c243d2ca9343f1bbe24b8a92e93ad37758f65428cce9a8f9b8ffb1913ac691f4\",\n",
      "  \"hash\": \"c243d2ca9343f1bbe24b8a92e93ad37758f65428cce9a8f9b8ffb1913ac691f4\",\n",
      "  \"version\": 2,\n",
      "  \"size\": 119,\n",
      "  \"vsize\": 119,\n",
      "  \"weight\": 476,\n",
      "  \"locktime\": 0,\n",
      "  \"vin\": [\n",
      "    {\n",
      "      \"txid\": \"1362ff4ca1cfefb688f3c8b2e965cfed68d8c1549d161162684920dd218b5498\",\n",
      "      \"vout\": 0,\n",
      "      \"scriptSig\": {\n",
      "        \"asm\": \"\",\n",
      "        \"hex\": \"\"\n",
      "      },\n",
      "      \"sequence\": 4294967295\n",
      "    }\n",
      "  ],\n",
      "  \"vout\": [\n",
      "    {\n",
      "      \"value\": \"1.50000000\",\n",
      "      \"n\": 0,\n",
      "      \"scriptPubKey\": {\n",
      "        \"asm\": \"OP_DUP OP_HASH160 3bc28d6d92d9073fb5e3adf481795eaf446bceed OP_EQUALVERIFY OP_CHECKSIG\",\n",
      "        \"desc\": \"addr(mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE)#xlnzfr97\",\n",
      "        \"hex\": \"76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac\",\n",
      "        \"address\": \"mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE\",\n",
      "        \"type\": \"pubkeyhash\"\n",
      "      }\n",
      "    },\n",
      "    {\n",
      "      \"value\": \"0.50000000\",\n",
      "      \"n\": 1,\n",
      "      \"scriptPubKey\": {\n",
      "        \"asm\": \"OP_DUP OP_HASH160 cc1b07838e387deacd0e5232e1e8b49f4c29e484 OP_EQUALVERIFY OP_CHECKSIG\",\n",
      "        \"desc\": \"addr(mz8AXDhDMhvLs7kxwfQxvcH5GoVH6AdARZ)#6f8xcf93\",\n",
      "        \"hex\": \"76a914cc1b07838e387deacd0e5232e1e8b49f4c29e48488ac\",\n",
      "        \"address\": \"mz8AXDhDMhvLs7kxwfQxvcH5GoVH6AdARZ\",\n",
      "        \"type\": \"pubkeyhash\"\n",
      "      }\n",
      "    }\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "decoded = node.decoderawtransaction(unsigned_tx.hex())\n",
    "print(json.dumps(decoded, indent=2, default=str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Segwit transactions have a new signing scheme described in [BIP143](https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "02000000bfb56f6bdd6a0a677fe1f6e58a3e8ce287e6618d2bf487adf7b2b5fb3f6049113bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e7066504498548b21dd2049686211169d54c1d868edcf65e9b2c8f388b6efcfa14cff621300000000475221034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa2102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f2752aea048ed0b00000000ffffffff7c27b92041484c01942ac85d0fe5ff31e92d1a54e1618e190ef3f316c4799ecf0000000001000000\n"
     ]
    }
   ],
   "source": [
    "scriptcode = redeemScript\n",
    "\n",
    "input_amount_sat = int(2.001 * 100_000_000)\n",
    "value = input_amount_sat.to_bytes(8, byteorder=\"little\", signed=False)\n",
    "\n",
    "hashPrevOuts = hash256(txid + index)\n",
    "hashSequence = hash256(sequence)\n",
    "hashOutputs = hash256(outputs)\n",
    "sighash_type = bytes.fromhex(\"0100 0000\") # SIGHASH_ALL\n",
    "\n",
    "tx_digest_preimage = (\n",
    "    version\n",
    "    + hashPrevOuts\n",
    "    + hashSequence\n",
    "    + txid\n",
    "    + index\n",
    "    + varint_len(scriptcode)\n",
    "    + scriptcode\n",
    "    + value\n",
    "    + sequence\n",
    "    + hashOutputs\n",
    "    + locktime\n",
    "    + sighash_type\n",
    ")\n",
    "print(tx_digest_preimage.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to hash this transaction and produce two ecdsa signatures on it. \n",
    "\n",
    "Before hashing the transaction with hash256, we append the sighash flag. In this example we'll use the most commonly used SIGHASH_ALL flag, meaning the signature guarantees the input will only be used in a transaction with these exact inputs and outputs.\n",
    "\n",
    "Note that when we append the sighash flag to the transaction, we use 4 bytes, however when we append the sighash flag to the end of the signature itself we only use 1 byte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "signed transaction:  0200000000010198548b21dd2049686211169d54c1d868edcf65e9b2c8f388b6efcfa14cff62130000000000ffffffff0280d1f008000000001976a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac80f0fa02000000001976a914cc1b07838e387deacd0e5232e1e8b49f4c29e48488ac040047304402207894d3ba08df43e2a35e6eadbad445ad62a595a82b746a30185c9b46d0ec4b370220312601e8d6fad65735b2e0b625aa6bfbebbe15e6884021222f7c46429cf2519a0147304402207183b76dab31b3173c9822fd62f7efb1faf1c45c3d8237e13690eba04cfea3f502204657fb32d9ff731afad2c9b55a99bbc54fa49c6de1676f41122cb7b5131e9d0301475221034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa2102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f2752ae00000000\n"
     ]
    }
   ],
   "source": [
    "# Create sigHash to be signed\n",
    "sighash = hash256(tx_digest_preimage)\n",
    "\n",
    "# Sign the sigHash with the input privkey1\n",
    "signing_key1 = ecdsa.SigningKey.from_string(privkey1, curve=ecdsa.SECP256k1) \n",
    "signature1 = signing_key1.sign_digest(sighash, sigencode=ecdsa.util.sigencode_der_canonize)\n",
    "\n",
    "# Append SIGHASH_ALL to the signature\n",
    "signature1 = signature1 + bytes.fromhex(\"01\")\n",
    "\n",
    "# Sign the sigHash with the input privkey2\n",
    "signing_key2 = ecdsa.SigningKey.from_string(privkey2, curve=ecdsa.SECP256k1) \n",
    "signature2 = signing_key2.sign_digest(sighash, sigencode=ecdsa.util.sigencode_der_canonize)\n",
    "\n",
    "# Append SIGHASH_ALL to the signature\n",
    "signature2 = signature2 + bytes.fromhex(\"01\")\n",
    "\n",
    "# Combine the signatures into the final scriptSig\n",
    "witness = (\n",
    "    # indicate the number of stack items\n",
    "    bytes.fromhex(\"04\")\n",
    "    + bytes.fromhex(\"00\") # Add an extra \"00\" for the CheckMultiSig bug\n",
    "    + varint_len(signature1)\n",
    "    + signature1\n",
    "    + varint_len(signature2)\n",
    "    + signature2\n",
    "    + varint_len(redeemScript)\n",
    "    + redeemScript\n",
    ")\n",
    "\n",
    "# the final signed transaction\n",
    "signed_tx = (\n",
    "    version\n",
    "    + marker\n",
    "    + flag\n",
    "    + input_count\n",
    "    + inputs\n",
    "    + output_count\n",
    "    + outputs\n",
    "    + witness\n",
    "    + locktime\n",
    ")\n",
    "\n",
    "print(\"signed transaction: \",signed_tx.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcast the transaction (on regtest mode)\n",
    "If we get back a txid (32 byte hash), then it means the tx was successfully broadcast! If we just want to see if the transaction would have been accepted, but without broadcasting it, we can use the `testmempoolaccept` command (commented out)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c243d2ca9343f1bbe24b8a92e93ad37758f65428cce9a8f9b8ffb1913ac691f4\n"
     ]
    }
   ],
   "source": [
    "new_tx_txid = node.sendrawtransaction(signed_tx.hex())\n",
    "# result = node.testmempoolaccept(rawtxs=[signed_tx.hex()])\n",
    "print(new_tx_txid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"txid\": \"c243d2ca9343f1bbe24b8a92e93ad37758f65428cce9a8f9b8ffb1913ac691f4\",\n",
      "  \"hash\": \"eb53fe0f9c4b5edec8f81d5b05da2b49af2d4306f81328746d4c53d16762aaec\",\n",
      "  \"version\": 2,\n",
      "  \"size\": 339,\n",
      "  \"vsize\": 174,\n",
      "  \"weight\": 696,\n",
      "  \"locktime\": 0,\n",
      "  \"vin\": [\n",
      "    {\n",
      "      \"txid\": \"1362ff4ca1cfefb688f3c8b2e965cfed68d8c1549d161162684920dd218b5498\",\n",
      "      \"vout\": 0,\n",
      "      \"scriptSig\": {\n",
      "        \"asm\": \"\",\n",
      "        \"hex\": \"\"\n",
      "      },\n",
      "      \"txinwitness\": [\n",
      "        \"\",\n",
      "        \"304402207894d3ba08df43e2a35e6eadbad445ad62a595a82b746a30185c9b46d0ec4b370220312601e8d6fad65735b2e0b625aa6bfbebbe15e6884021222f7c46429cf2519a01\",\n",
      "        \"304402207183b76dab31b3173c9822fd62f7efb1faf1c45c3d8237e13690eba04cfea3f502204657fb32d9ff731afad2c9b55a99bbc54fa49c6de1676f41122cb7b5131e9d0301\",\n",
      "        \"5221034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa2102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f2752ae\"\n",
      "      ],\n",
      "      \"sequence\": 4294967295\n",
      "    }\n",
      "  ],\n",
      "  \"vout\": [\n",
      "    {\n",
      "      \"value\": \"1.50000000\",\n",
      "      \"n\": 0,\n",
      "      \"scriptPubKey\": {\n",
      "        \"asm\": \"OP_DUP OP_HASH160 3bc28d6d92d9073fb5e3adf481795eaf446bceed OP_EQUALVERIFY OP_CHECKSIG\",\n",
      "        \"desc\": \"addr(mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE)#xlnzfr97\",\n",
      "        \"hex\": \"76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac\",\n",
      "        \"address\": \"mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE\",\n",
      "        \"type\": \"pubkeyhash\"\n",
      "      }\n",
      "    },\n",
      "    {\n",
      "      \"value\": \"0.50000000\",\n",
      "      \"n\": 1,\n",
      "      \"scriptPubKey\": {\n",
      "        \"asm\": \"OP_DUP OP_HASH160 cc1b07838e387deacd0e5232e1e8b49f4c29e484 OP_EQUALVERIFY OP_CHECKSIG\",\n",
      "        \"desc\": \"addr(mz8AXDhDMhvLs7kxwfQxvcH5GoVH6AdARZ)#6f8xcf93\",\n",
      "        \"hex\": \"76a914cc1b07838e387deacd0e5232e1e8b49f4c29e48488ac\",\n",
      "        \"address\": \"mz8AXDhDMhvLs7kxwfQxvcH5GoVH6AdARZ\",\n",
      "        \"type\": \"pubkeyhash\"\n",
      "      }\n",
      "    }\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "decoded = node.decoderawtransaction(signed_tx.hex())\n",
    "print(json.dumps(decoded, indent=2, default=str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quiz\n",
    "\n",
    "1. How does the scriptPubKey for a P2WSH output compare to a P2SH output?\n",
    "2. If we generated a new valid signature for `signature2` and replaced it in `signed_tx`, would the resulting transaction have the same or a different transaction ID? Why is this property important for lightning payment channels?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answers\n",
    "\n",
    "1. P2SH scriptPubKeys use a 20-byte HASH160 digest, whereas P2WSH uses a 32-byte HASH256 digest. For an explanation of the security benefits of P2WSH outputs see this [Stack Exchange Answer](https://bitcoin.stackexchange.com/questions/106140/why-are-p2wsh-addresses-larger-than-p2sh-addresses).\n",
    "2. The resulting transaction ID would be the same. This property (non-transaction malleability) is important for lightning payment channels as it allows parties to create offline transaction dependency chains."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inspired by this [Stack Exchange Post](https://bitcoin.stackexchange.com/questions/115443/1-of-1-multisig), try creating a 1 of 1 multisig address using `pubkey1`. The address should be:\n",
    "`bcrt1q6vaj75sc5ygw4hcpjwrw4e52k7fglsdwdr2jpyyw5cx9d64nxfgs9es26d`\n",
    "\n",
    "Try sending some bitcoin to that address and spending from it. The code used should be the same as the example above, but with some small modifications to the witness field. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}