chapter5-timelocks/script-level-timelocks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Script level timelocks (OP_CLTV and OP_CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we'll cover how to create a transaction level timelocks with `OP_CHECKLOCKTIMEVERIFY` (`OP_CTLV`) and `OP_CHECKSEQUENCEVERIFY` (`OP_CSV`).\n",
    "\n",
    "Script level timelocks are an essential part of many layer 2 protocols such lightning HTLC transactions and cross chain atomic swaps. They build off `nLocktime` and `nSequence` by allowing the script verification to check that the spending transaction has those fields set to specific values. \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",
    "- 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)'\n",
    "\n",
    "\n",
    "### Further Reading\n",
    "- https://medium.com/summa-technology/bitcoins-time-locks-27e0c362d7a1\n",
    "\n",
    "\n",
    "## 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": [
    "### Scenario\n",
    "We will use the same scenario as with the transaction-level timelock example:\n",
    "\n",
    "> Kim is an old grandmother who wants to pass some of her wealth (0.1 btc) on to her grandson, Peter. However, Peter is still a child and Kim doesn't trust Peter to spend his bitcoin wisely. Kim would rather wait until Peter turns 18 before he's able to spend his bitcoin. Kim doesn't know how much longer she'll be around for, and she doesn't trust anyone else to handle her money. To give Peter bitcoin in a way which will only allow him to spend it once he's 18, Kim will do this by giving Peter a signed transaction for 0.1 btc with an absolute timelock set to expire on his 18th birthday.\n",
    "\n",
    "> Note that 1 year corresponds to about 50,000 blocks. To save us having to mine tens of thousands of regtest blocks (which may take a few minutes), we'll instead suppose Peter's 18th birthday is happening much sooner, at block 500.\n",
    "\n",
    "In the previous notebook we achieved this by using transaction-level timelocks. There were a some potential downsides of this solution however:\n",
    "- Although Peter has a valid signed transaction from Kim, it is possible that she, or someone with access to her private key, may spend the input before Peter is able to broadcast his transaction. \n",
    "- Since the timelocks were on a transaction level, any additional outputs would be encumbered by the same timelock. \n",
    "- Peter has to safely store the signed transaction until it can be broadcast.\n",
    "\n",
    "A better solution in this case would be to use script-level timelocks. The OP_CODES `OP_CHECKLOCKTIMEVERIFY`  \n",
    "and `OP_CHECKSEQUENCEVERIFY` are included in the redeemScript and can enforce that the spending transaction uses a specific value for `nLocktime` or `nSequence` respectively. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a script using OP_CHECKLOCKTIMEVERIFY\n",
    "\n",
    "We'll create the script that Kim and Peter will agree on to send the bitcoin to. Peter wants to ensure that his public key is included in the script, so that he can create the signature for it, and Kim wants to be sure that the script has a timelock on it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequence:  fffffffe\n",
      "02f401b1752102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27ac\n"
     ]
    }
   ],
   "source": [
    "# Set a public key for the receiver (Peter)\n",
    "receiver_privkey = bytes.fromhex(\"2222222222222222222222222222222222222222222222222222222222222222\")\n",
    "receiver_pubkey = privkey_to_pubkey(receiver_privkey)\n",
    "\n",
    "# let's suppose Peter's 18th birthday is estimated to happen at block 500\n",
    "locktime_int = 500\n",
    "locktime = locktime_int.to_bytes(4, byteorder=\"little\", signed=False)\n",
    "locktime_val = locktime_int.to_bytes(2, byteorder=\"little\", signed=False)\n",
    "\n",
    "sequence = bytes.fromhex(\"ffff fffe\")\n",
    "print(\"sequence: \", sequence.hex())\n",
    "\n",
    "redeemScript = (\n",
    "    varint_len(locktime_val)\n",
    "    + locktime_val\n",
    "    + bytes.fromhex(\"b1\") # OP_CLTV\n",
    "    + bytes.fromhex(\"75\") # OP_DROP\n",
    "    + pushbytes(receiver_pubkey)\n",
    "    + bytes.fromhex(\"ac\"))\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": [
      "bcrt1qd75w96efgck0afp7zxarmhmzp2zjmzq0khkdf0fpaasrzl09m6aszmc5kn\n"
     ]
    }
   ],
   "source": [
    "address_to_spend = script_to_p2wsh(redeemScript, \"regtest\")\n",
    "print(address_to_spend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create Peter's utxo with 0.1 btc\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-08T11:15:24.191000Z TestFramework (INFO): Initializing test directory /var/folders/r5/yk8yg2xs1gs8xzkn5l8vr72w0000gn/T/bitcoin_func_test_1tq57_mj\n",
      "txid: e248baa92bf049bef96d7d0317dc60cda5bd8f0e63745ddf11c579a1eb365ab9, 1\n"
     ]
    }
   ],
   "source": [
    "node = setup_testshell()\n",
    "txid_to_spend, index_to_spend = fund_address(node, address_to_spend, 0.1)\n",
    "print(f\"txid: {txid_to_spend}, {index_to_spend}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spending a P2WSH time-locked UTXO\n",
    "\n",
    "Now that we have some funds locked up in a P2WSH utxo with a timelock, we can create a transaction spending from it. Let's say Peter wants to send 0.099 btc to the address `mkxwE7XtVYJKepoD2hbHnDjftuMQ1k6deE`.\n",
    "\n",
    "From our previous examples we know this corresponds to a scriptPubkey of `76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "output1_spk = bytes.fromhex(\"76a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac\")\n",
    "output1_value_sat = int(float(\"0.099\") * 100000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an unsigned transaction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the values for `nLocktime` that we set above `nSequence`, we'll create the unsigned transaction and sign it in the same way we did when creating a regular P2WSH transaction. Note that the value for `nLocktime` must be a 4 byte integer, whereas the value preceeding `OP_CHECKLOCKTIMEVERIFY` must be a variable length integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unsigned_tx:  0200000001b95a36eba179c511df5d74630e8fbda5cd60dc17037d6df9be49f02ba9ba48e20100000000fffffffe01e00f9700000000001976a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88acf4010000\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",
    "# SEQUENCE\n",
    "# set above\n",
    "\n",
    "inputs = (\n",
    "    txid\n",
    "    + index\n",
    "    + varint_len(scriptsig)\n",
    "    + scriptsig\n",
    "    + sequence\n",
    ")\n",
    "\n",
    "# OUTPUTS\n",
    "output_count = bytes.fromhex(\"01\")\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",
    "outputs = (\n",
    "    output1_value\n",
    "    + varint_len(output1_spk)\n",
    "    + output1_spk\n",
    ")\n",
    "\n",
    "# LOCKTIME\n",
    "# set above\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": [
    "### Signing the transaction\n",
    "\n",
    "Segwit transaction signing scheme described in [BIP143](https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "020000004718bd17ac0f84a7bfd6da7f8759e2ddacf763ce22c17cc425ff257ad3cdf240bbdebfac1cd12080fb29f8919f7f8be7bdb21a89c8d09e8a59fc7bb1d2a73796b95a36eba179c511df5d74630e8fbda5cd60dc17037d6df9be49f02ba9ba48e2010000002802f401b1752102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27ac8096980000000000fffffffe5d18c7a03d8b14317752ff0d8801c9fe97f8e11c3abfc3d0543fa2fedcceb020f401000001000000\n"
     ]
    }
   ],
   "source": [
    "input_amount_sat = int(0.1 * 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(redeemScript)\n",
    "    + redeemScript\n",
    "    + value\n",
    "    + sequence\n",
    "    + hashOutputs\n",
    "    + locktime\n",
    "    + sighash_type\n",
    ")\n",
    "print(tx_digest_preimage.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hash this transaction and produce an ecdsa signature on it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "signed transaction:  02000000000101b95a36eba179c511df5d74630e8fbda5cd60dc17037d6df9be49f02ba9ba48e20100000000fffffffe01e00f9700000000001976a9143bc28d6d92d9073fb5e3adf481795eaf446bceed88ac024830450221008bf4cb4162e95e1b5f1744675f7b948da6f32d0ccbc77584a04370480d71f72802201f50567fcf3d792d891225b09323ee4dd9aeb842d2f593621d560600ee28ab54012802f401b1752102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27acf4010000\n"
     ]
    }
   ],
   "source": [
    "# Create sigHash to be signed\n",
    "sighash = hash256(tx_digest_preimage)\n",
    "\n",
    "# Sign the sigHash with the input private key\n",
    "signing_key = ecdsa.SigningKey.from_string(receiver_privkey, curve=ecdsa.SECP256k1) \n",
    "signature = signing_key.sign_digest(sighash, sigencode=ecdsa.util.sigencode_der_canonize)\n",
    "\n",
    "# Append SIGHASH_ALL to the signature\n",
    "signature = signature + bytes.fromhex(\"01\")\n",
    "\n",
    "# Witness field\n",
    "witness = (\n",
    "    # indicate the number of stack items\n",
    "    bytes.fromhex(\"02\")\n",
    "    + varint_len(signature)\n",
    "    + signature\n",
    "    + varint_len(redeemScript)\n",
    "    + redeemScript\n",
    ")\n",
    "\n",
    "# tx_in with our new sigScript containing the signature we just created\n",
    "inputs_signed = (\n",
    "    txid\n",
    "    + index\n",
    "    + varint_len(scriptsig)\n",
    "    + scriptsig\n",
    "    + sequence\n",
    ")\n",
    "\n",
    "# the final signed transaction\n",
    "signed_tx = (\n",
    "    version\n",
    "    + marker\n",
    "    + flag\n",
    "    + input_count\n",
    "    + inputs_signed\n",
    "    + output_count\n",
    "    + outputs\n",
    "    + witness\n",
    "    + locktime\n",
    ")\n",
    "\n",
    "print(\"signed transaction: \",signed_tx.hex())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scenario\n",
    "The `OP_CHECKLOCKTIMEVERIFY` OP_CODE in the script is essentially forcing the transaction spending from it (Peter's transaction) to have `nLocktime` (and `nSequence` not set to `0xffffffff`) set in the transaction spending from it. Therefore Peter's transaction will behave as we expect for a transaction that has a transaction-level timelock.\n",
    "\n",
    "If he were to try broadcasting the transaction at the current height (102), it would result in the following `non-final` error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blockchain height:  102\n",
      "[{'txid': '5434444cb806c1df051a25f45c17b70b6cdefc5dcc4c6c3073de3ddef6256dff', 'wtxid': '08e13f1ba8516fc682ba72c51627c45081267a460e2b615666fe5f965744f1e8', 'allowed': False, 'reject-reason': 'non-final'}]\n"
     ]
    }
   ],
   "source": [
    "height = node.getblockcount()\n",
    "print(\"Blockchain height: \", height)\n",
    "\n",
    "result = node.testmempoolaccept(rawtxs=[signed_tx.hex()])\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll simulate 398 blocks passing (to reach block 500), and see what happens if Peter tries to broadcast his transaction again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blockchain height:  500\n",
      "[{'txid': '5434444cb806c1df051a25f45c17b70b6cdefc5dcc4c6c3073de3ddef6256dff', 'wtxid': '08e13f1ba8516fc682ba72c51627c45081267a460e2b615666fe5f965744f1e8', 'allowed': True, 'vsize': 115, 'fees': {'base': Decimal('0.00100000')}}]\n"
     ]
    }
   ],
   "source": [
    "node.generate(398, invalid_call=False)\n",
    "height = node.getblockcount()\n",
    "print(\"Blockchain height: \", height)\n",
    "\n",
    "result = node.testmempoolaccept(rawtxs=[signed_tx.hex()])\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time the transaction is successfully broadcasted and Peter has successfully spent his script-level, time-locked output. \n",
    "\n",
    "To view the decoded transaction, uncomment the lines below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"txid\": \"5434444cb806c1df051a25f45c17b70b6cdefc5dcc4c6c3073de3ddef6256dff\",\n",
      "  \"hash\": \"08e13f1ba8516fc682ba72c51627c45081267a460e2b615666fe5f965744f1e8\",\n",
      "  \"version\": 2,\n",
      "  \"size\": 202,\n",
      "  \"vsize\": 115,\n",
      "  \"weight\": 457,\n",
      "  \"locktime\": 500,\n",
      "  \"vin\": [\n",
      "    {\n",
      "      \"txid\": \"e248baa92bf049bef96d7d0317dc60cda5bd8f0e63745ddf11c579a1eb365ab9\",\n",
      "      \"vout\": 1,\n",
      "      \"scriptSig\": {\n",
      "        \"asm\": \"\",\n",
      "        \"hex\": \"\"\n",
      "      },\n",
      "      \"txinwitness\": [\n",
      "        \"30450221008bf4cb4162e95e1b5f1744675f7b948da6f32d0ccbc77584a04370480d71f72802201f50567fcf3d792d891225b09323ee4dd9aeb842d2f593621d560600ee28ab5401\",\n",
      "        \"02f401b1752102466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27ac\"\n",
      "      ],\n",
      "      \"sequence\": 4278190079\n",
      "    }\n",
      "  ],\n",
      "  \"vout\": [\n",
      "    {\n",
      "      \"value\": \"0.09900000\",\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",
      "}\n"
     ]
    }
   ],
   "source": [
    "decoded = node.decoderawtransaction(signed_tx.hex())\n",
    "print(json.dumps(decoded, indent=2, default=str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script-level relative timelocks (OP_CHECKSEQUENCEVERIFY)\n",
    "\n",
    "Similar to how `OP_CHECKLOCKTIMEVERIFY` enforces the transaction spending that output to set an absolute locktime with `nLocktime`, `OP_CHECKSEQUENCEVERIFY` enforces the transaction spending that output to set a relative timelock with `nSequence`.\n",
    "\n",
    "In the scenario we just covered, Kim could have achieved the same outcome but using a relative timelock instead. The only difference would be that the delay would be specified relative to when the input was confirmed, rather than the absolute block height. \n",
    "\n",
    "Note that `version` must be set to **`2`** for relative timelocks to be enabled.\n",
    "\n",
    "### Exercise\n",
    "Repeat the scenario above, but using `OP_CHECKSEQUENCEVERIFY` to enforce the delay.\n",
    "\n",
    "Hint: the block chain starts off at block 102, so the relative timelock should be set to 398 blocks for the transaction to be broadcastable at block 500.\n",
    "\n",
    "Hint 2: nSequence is a 32 bit unsigned integer, so you can use the same `.to_bytes` method used to convert `locktime_int` to `locktime` in the previous example.\n",
    "\n",
    "\n",
    "#### Solution for running with nSequence\n",
    "```\n",
    "locktime_int = 0\n",
    "locktime = locktime_int.to_bytes(4, byteorder=\"little\", signed=False)\n",
    "\n",
    "sequence_int = 398\n",
    "sequence = sequence_int.to_bytes(4, byteorder=\"little\", signed=False)\n",
    "sequence_val = sequence_int.to_bytes(2, byteorder=\"little\", signed=False)\n",
    "\n",
    "redeemScript = (\n",
    "    varint_len(sequence_val)\n",
    "    + sequence_val\n",
    "    + bytes.fromhex(\"b2\") # OP_CSV\n",
    "    + bytes.fromhex(\"75\") # OP_DROP\n",
    "    + pushbytes(receiver_pubkey)\n",
    "    + bytes.fromhex(\"ac\"))\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quiz\n",
    "\n",
    "- 1. Earlier we learned that setting `nSequence` to `0xffffffff` disables `nLocktime`, so what would happen if you tried setting `nSequence` to `0xffffffff` when spending from an input that uses `OP_CLTV`?\n",
    "- 2. What information does Peter need to hold on to in order to spend from the outputs in these examples?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answers\n",
    "- 1. The transaction would be invalid as `OP_CLTV` checks that `nSequence` in the spending transaction is not set to `0xffffffff`.\n",
    "- 2. He needs his private key to sign the transaction, and the redeem script.\n"
   ]
  }
 ],
 "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
}