silent-payments-workshop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73602732",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.bech32m import convertbits, bech32_encode, Encoding\n",
    "from utils.key import ECKey, ECPubKey, generate_bip340_key_pair\n",
    "from utils.bip158 import gcs_match_any\n",
    "\n",
    "from bip32 import BIP32\n",
    "from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException\n",
    "\n",
    "import hashlib\n",
    "def sha256(s):\n",
    "    if type(s) != bytes:\n",
    "        s = s.get_bytes()\n",
    "    return hashlib.new('sha256', s).digest()\n",
    "\n",
    "G = ECKey().set(1).get_pubkey()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed320771",
   "metadata": {},
   "source": [
    "# Silent Payments\n",
    "\n",
    "Using a new address for each Bitcoin transaction is a crucial aspect of maintaining privacy. This often requires a secure interaction between sender and receiver so that the receiver can hand out a fresh address, a batch of fresh address, or a way for the send to generate addresses, such as an xpub.\n",
    "\n",
    "However, interaction is often infeasible and in many cases undesirable. To solve for this, various protocols have been proposed which use a static payment address and notifications, sent via the blockchain[footnote]. These protocols eliminate the need for interaction, but at the expense of increased costs for one-time payments and a noticeable footprint in the blockchain, potentially revealing metadata about the sender and receiver. Notification schemes also allow the receiver to link all payments from the same sender, compromising sender privacy.\n",
    "\n",
    "This proposal aims to address the limitations of these current approaches by presenting a solution that eliminates the need for interaction, eliminates the need for notifications, and protects both sender and receiver privacy.\n",
    "\n",
    "## Goals\n",
    "\n",
    "We aim to present a transaction protocol which satisifies the following properties:\n",
    "\n",
    "* No increase in the size or cost of transactions\n",
    "* Resulting transactions blend in with other bitcoin transactions and can't be distinguished\n",
    "* Transactions can't be linked to a silent payment address by an outside observer\n",
    "* No sender-receiver interaction required\n",
    "* No linking of multiple payments to the same sender\n",
    "* Each silent payment goes to a unique address, avoiding accidental reuse\n",
    "* Supports payment purpose labeling\n",
    "* Uses existing seed phrase or descriptor methods for backup and recovery\n",
    "* Separates scanning and spending responsibilities\n",
    "* Compatible with other spending protocols, such as CoinJoin\n",
    "* Light client/SPV wallet support\n",
    "* Protocol is upgradeable\n",
    "\n",
    "\n",
    "## What this workshop will attempt to cover\n",
    "\n",
    "* Generating a silent payment address\n",
    "* Scanning for silent payments\n",
    "* Sync the wallet using BIP158 block filters\n",
    "* BONUS:\n",
    "  * Add label support\n",
    "  * Scan for multiple outputs\n",
    "  * Run on signet\n",
    "  \n",
    "## What this workshop won't cover\n",
    "\n",
    "* Sending to silent payment addresses\n",
    "\n",
    "# Elliptic Curve math review\n",
    "\n",
    "Elliptic Curve math involves scalars and points.\n",
    "\n",
    "* A scalar is a positive integer which is smaller than the group order, and is denoted by a lower case letter (eg `a`).\n",
    "* A point lies on the curve and is denoted by an upper-case letter (eg `C`) or a pair of co-ordinates (eg `(x,y)`).\n",
    "\n",
    "In Bitcoin, key pair generation and signing is performed over the secp256k1 curve. All scalars are modulo the group order `SECP256K1_ORDER`, which is a very large number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a687eafc",
   "metadata": {},
   "source": [
    "![test](images/ec_math0.jpg)\n",
    "\n",
    "_An overview of all operations of scalars and points over elliptic curves._"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9cf5760",
   "metadata": {},
   "source": [
    "## Simple case\n",
    "\n",
    "Bob wishes to receive payments from Alice, so he publishes his public key B as a silent payment address. Alice selects a UTXO with private key a and public key A from her wallet to fund the transaction and creates the output P for Bob in the following way:\n",
    "\n",
    "* Let *P = HASH(a·B)·G + B*\n",
    "\n",
    "Bob detects this payment by computing *P = HASH(b·A)·G + B*, since *a·B == b·A* (Elliptic Curve Diffie-Hellman)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f968ce2",
   "metadata": {},
   "outputs": [],
   "source": [
    "b, B = generate_bip340_key_pair()\n",
    "a, A = generate_bip340_key_pair()\n",
    "\n",
    "# Alice generates the output using her private key b and Bob's public key\n",
    "# sha256(a * B)\n",
    "t = \n",
    "\n",
    "# create a pubkey: T = t * G\n",
    "T = \n",
    "\n",
    "# create the silent payment output: D = T + B\n",
    "D = \n",
    "\n",
    "# Bob checks if D is hers using her private key and Bob's public key\n",
    "t_prime = \n",
    "T_prime = \n",
    "D_prime = \n",
    "\n",
    "assert D == D_prime"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4f9012d",
   "metadata": {},
   "source": [
    "### Sending to more than one output\n",
    "\n",
    "<p>In the event Alice needs more than one output for Bob, she can do so in the following manner:</p>\n",
    "<ul>\n",
    "<li>Let <em>P<sub>0</sub> = HASH(a·B || 0)·G + B</em></li>\n",
    "<li>For additional outputs:\n",
    "<ul>\n",
    "<li>Let <em>P<sub>i</sub> = HASH(a·B || n)·G + B</em>, where <em>n</em> starts from 1 and is incremented for each subsequent output</li>\n",
    "</ul></li>\n",
    "</ul>\n",
    "<p>Bob detects this output the same as before by searching for <em>P<sub>0</sub> = HASH(b·A || 0)·G + B</em>. Once he detects the first output, he must:</p>\n",
    "<ul>\n",
    "<li>Check for <em>P<sub>1</sub> = HASH(b·A || 1)·G + B</em></li>\n",
    "<li>If <em>P<sub>1</sub></em> is not found, stop</li>\n",
    "<li>If <em>P<sub>1</sub></em> is found, continue to check for <em>P<sub>2</sub></em> and so on until an additional output is not found</li>\n",
    "</ul>\n",
    "<p>Since Bob will only perform these subsquent checks after a transaction with at least one output paying him is found, the increase to his overall scanning requirement is negligible.</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84a5a560",
   "metadata": {},
   "source": [
    "## Preventing address reuse\n",
    "\n",
    "<p>If Alice were to use a different UTXO from the same public key <em>A</em> for a subsequent payment to Bob, she would end up deriving the same destination <em>P</em>. To prevent this, Alice should include a hash of the outpoint in the following manner:</p>\n",
    "<ul>\n",
    "<li>Let <em>outpoint_hash = HASH(txid || vout)</em></li>\n",
    "<li>Let <em>P<sub>0</sub> = HASH(outpoint_hash·a·B || 0)·G + B</em></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caa0464b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the outpoint hash\n",
    "\n",
    "txid1 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "txid2 = b'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'\n",
    "vout1 = (0).to_bytes(4, 'little')\n",
    "vout2 = (1).to_bytes(4, 'little')\n",
    "\n",
    "# sha256(txid || vout)\n",
    "# TODO: these should be sorted\n",
    "outpoint_hash = \n",
    "\n",
    "t = \n",
    "T = t * G\n",
    "D = T + B\n",
    "\n",
    "# Bob scans..\n",
    "\n",
    "t_prime = \n",
    "T_prime = t_prime * G\n",
    "D_prime = T_prime + B\n",
    "\n",
    "assert D == D_prime"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc72ad7",
   "metadata": {},
   "source": [
    "### Using all inputs\n",
    "\n",
    "<p>In our simplified example we have been referring to Alice’s transactions as having only one input <em>A</em>, but in reality a Bitcoin transaction can have many inputs. Instead of requiring Alice to pick a particular input and requiring Bob to check each input separately, we can instead require Alice to perform the tweak with the sum of the input public keys. This significantly reduces Bob's scanning requirement, makes light client support more feasible, and protects Alice's privacy in collaborative transaction protocols such as CoinJoin.</p>\n",
    "<p>Alice performs the tweak with the sum of her input private keys in the following manner:</p>\n",
    "<ul>\n",
    "<li>Let <em>outpoints_hash = HASH(txid<sub>1</sub> || vout<sub>1</sub> || … txid<sub>n</sub> || vout<sub>n</sub>)</em></li>\n",
    "<li>Let <em>a = a<sub>0</sub> + a<sub>1</sub> … + a<sub>n</sub></em></li>\n",
    "<li>Let <em>A = A<sub>0</sub> + A<sub>1</sub> … + A<sub>n</sub></em></li>\n",
    "<li>Let <em>P<sub>0</sub> = HASH(outpoints_hash·a·B || 0)·G + B</em></li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92271084",
   "metadata": {},
   "outputs": [],
   "source": [
    "# doesn't have to be a taproot UTXO\n",
    "txid1 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "vout1 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a1 = ECKey().generate()\n",
    "A1 = a1.get_pubkey()\n",
    "\n",
    "# taproot UTXO\n",
    "txid2 = b'a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d'\n",
    "vout2 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a2, A2 = generate_bip340_key_pair()\n",
    "\n",
    "outpoint_hash = sha256(txid1 + vout1 + txid2 + vout2)\n",
    "\n",
    "# sha256(outputpoint_hash * Sum of Alice's input privkeys * B)\n",
    "t = \n",
    "T = t * G\n",
    "D = T + B\n",
    "\n",
    "# Bob scans...\n",
    "t_prime = \n",
    "T_prime = t_prime * G\n",
    "D_prime = T_prime + B\n",
    "\n",
    "assert D_prime == D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace390b4",
   "metadata": {},
   "source": [
    "### Spend and Scan Key\n",
    "\n",
    "<p>Since Bob needs his private key <em>b</em> to check for incoming payments, this requires <em>b</em> to be exposed to an online device. To minimize the risks involved, Bob can instead publish an address of the form <em>(B<sub>scan</sub>, B<sub>spend</sub>)</em>. This allows Bob to keep <em>b<sub>spend</sub></em> in offline cold storage and perform the scanning with the public key <em>B<sub>spend</sub></em> and private key <em>b<sub>scan</sub></em>. Alice performs the tweak using both of Bob’s public keys in the following manner:</p>\n",
    "<ul>\n",
    "<li>Let <em>P<sub>0</sub> = HASH(outpoints_hash·a·B<sub>scan</sub> || 0)·G + B<sub>spend</sub></em></li>\n",
    "</ul>\n",
    "<p>Bob detects this payment by calculating <em>P<sub>0</sub> = HASH(outpoints_hash·b<sub>scan</sub>·A)·G + B<sub>spend</sub></em> with his online device and can spend from his cold storage signing device using <em>(HASH(outpoints_hash·b<sub>scan</sub>·A) + b<sub>spend</sub>) mod p</em> as the private key.</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eefd4f42",
   "metadata": {},
   "outputs": [],
   "source": [
    "b_scan, B_scan = generate_bip340_key_pair()\n",
    "b_spend, B_spend = generate_bip340_key_pair()\n",
    "\n",
    "# doesn't have to be a taproot UTXO\n",
    "txid1 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "vout1 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a1 = ECKey().generate()\n",
    "A1 = a1.get_pubkey()\n",
    "\n",
    "# taproot UTXO\n",
    "txid2 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "vout2 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a2, A2 = generate_bip340_key_pair()\n",
    "\n",
    "outpoint_hash = sha256(txid1 + vout1 + txid2 + vout2)\n",
    "\n",
    "# sha256(outpoint_hash * sum of Alice's privkeys * Bob's scan public key)\n",
    "t = \n",
    "T = t * G\n",
    "# add to Bob's spend public key\n",
    "D = \n",
    "\n",
    "# Bob scans..\n",
    "t_prime = \n",
    "T_prime = t_prime * G\n",
    "D_prime = \n",
    "\n",
    "assert D_prime == D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "728998a0",
   "metadata": {},
   "source": [
    "### Labels\n",
    "\n",
    "<p>For a single silent payment address of the form <em>(B<sub>scan</sub>, B<sub>spend</sub>)</em>, Bob may wish to differentiate incoming payments by using labels. Naively, Bob could publish multiple silent payment addresses, but this would require him to scan for each one, which becomes prohibitively expensive. Instead, Bob can tweak his spend public key <em>B<sub>spend</sub></em> with an integer <em>m</em> in the following way:</p>\n",
    "<ul>\n",
    "<li>Let <em>B<sub>m</sub> = B<sub>spend</sub> + m·G</em></li>\n",
    "<li>Publish <em>(B<sub>scan</sub>, B<sub>0</sub>)</em>, <em>(B<sub>scan</sub>, B<sub>1</sub>) …</em></li>\n",
    "</ul>\n",
    "<p>Alice performs the tweak same as before using one of the published <em>(B<sub>scan</sub>, B<sub>m</sub>)</em> pairs. Bob detects the labeled payment in the following manner:</p>\n",
    "<ul>\n",
    "<li>Let <em>P<sub>0</sub> = HASH(outpoints_hash·b<sub>scan</sub>·A || 0)·G + B<sub>spend</sub></em></li>\n",
    "<li>Compute <em>P<sub>0m</sub> = P<sub>0</sub> + m·G</em> for each <em>m</em></li>\n",
    "<li>For each <em>P<sub>0m</sub></em> in {<em>P<sub>00</sub> … P<sub>0m</sub></em>}, check if any are present in the transaction outputs</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7aeddbcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "b_scan, B_scan = generate_bip340_key_pair()\n",
    "b_spend, B_spend = generate_bip340_key_pair()\n",
    "\n",
    "# create some labels\n",
    "labels = {\n",
    "    'twitter': B_spend + ,\n",
    "    'github': B_spend + ,\n",
    "    'project a': B_spend + ,\n",
    "    'project b': B_spend + ,\n",
    "}\n",
    "\n",
    "# doesn't have to be a taproot UTXO\n",
    "txid1 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "vout1 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a1 = ECKey().generate()\n",
    "A1 = a1.get_pubkey()\n",
    "\n",
    "# taproot UTXO\n",
    "txid2 = b'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16'\n",
    "vout2 = (0).to_bytes(4, 'little')\n",
    "\n",
    "a2, A2 = generate_bip340_key_pair()\n",
    "\n",
    "# Bob finds Alice's silent payment address through github and makes a payment\n",
    "B_2 = labels['github']\n",
    "\n",
    "outpoint_hash = sha256(txid1 + vout1 + txid2 + vout2)\n",
    "t = \n",
    "T = t * G\n",
    "D = \n",
    "\n",
    "# Bob scans..\n",
    "t_prime = \n",
    "T_prime = t_prime * G\n",
    "\n",
    "D_prime = None\n",
    "for k,V in labels.items():\n",
    "        \n",
    "assert D_prime == D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c947ef0",
   "metadata": {},
   "source": [
    "## Putting it all together\n",
    "\n",
    "### Simple wallet: generating silent payment keys\n",
    "\n",
    "* Use BIP32 hardened derivation for the silent payment keys\n",
    "* Generate a silent payment address\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0df3157",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SPWallet:\n",
    "    \n",
    "    REASON = \"1337\"\n",
    "\n",
    "    def __init__(self, seed):\n",
    "        self.master = BIP32.from_seed(bytes.fromhex(seed))\n",
    "        self.spend_path = \n",
    "        self.scan_path = \n",
    "        self.scan_privkey, self.scan_pubkey = self.convert_to_bip340_key_pair(\n",
    "            self.get_scan_privkey()\n",
    "        )\n",
    "        self.spend_privkey, self.spend_pubkey = self.convert_to_bip340_key_pair(\n",
    "            self.get_spend_privkey()\n",
    "        )\n",
    "        \n",
    "    def convert_to_bip340_key_pair(self, seckey):\n",
    "        d = seckey * G\n",
    "        P = d.get_pubkey()\n",
    "        if P.get_y() % 2 != 0:\n",
    "            d.negate()\n",
    "            P.negate()\n",
    "        return d, P\n",
    "        \n",
    "    def get_scan_pubkey(self):\n",
    "        return self.master.get_pubkey_from_path(self.scan_path)\n",
    "    \n",
    "    def get_scan_privkey(self):\n",
    "        return self.master.get_privkey_from_path(self.scan_path)\n",
    "    \n",
    "    def get_spend_pubkey(self):\n",
    "        return self.master.get_pubkey_from_path(self.spend_path)\n",
    "    \n",
    "    def get_spend_privkey(self):\n",
    "        return self.master.get_privkey_from_path(self.spend_path)\n",
    "    \n",
    "    def get_silent_payment_address(self):\n",
    "        pubkeys = \n",
    "        \n",
    "        data = convertbits(pubkeys, 8, 5)\n",
    "        return bech32_encode(\"sprt\", data, Encoding.BECH32M)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae846d8f",
   "metadata": {},
   "source": [
    "### Scanning:  BIP158 block filters\n",
    "\n",
    "* Get the tweak data per transaction (using `getsilentpaymentblockdata` rpc)\n",
    "* Do the ECDH tweaks\n",
    "* Check if any outputs exist in a block using BIP158 block filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e1b9001",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SPScanner:\n",
    "    PUBKEY_BYTES = 33\n",
    "    TRUNC_HASH_BYTES = 8\n",
    "    WITNESS_VERSION_1 = '5120'\n",
    "    \n",
    "    def __init__(self, spend_pubkey, scan_privkey, rpc_client, start_height):\n",
    "\n",
    "        self.spend_pubkey = spend_pubkey\n",
    "        self.scan_privkey = scan_privkey\n",
    "        self.start_from_height = start_height\n",
    "        self.last_block_scanned = self.start_from_height - 1\n",
    "        self.rpc = rpc_client\n",
    "        \n",
    "    def sha256_secp256k1_ecdh(self, x32, y32):\n",
    "        \n",
    "        version = (y32[31] & 0x01) | 0x02\n",
    "        sha = hashlib.sha256()\n",
    "        sha.update(bytes([version]))\n",
    "        sha.update(bytes(x32))\n",
    "        \n",
    "        return sha.digest()\n",
    "        \n",
    "    def refresh(self, rpc_client):\n",
    "        self.rpc = rpc_client\n",
    "        \n",
    "    def scan(self, start=None):\n",
    "    \n",
    "        if start:\n",
    "            self.start_from_height = start\n",
    "            \n",
    "        # get the chain height\n",
    "        stop = self.rpc.getblockchaininfo()['blocks']\n",
    "        current_block = self.start_from_height\n",
    "        while current_block <= stop:\n",
    "            \n",
    "            # get the silent payment tweak data\n",
    "            res = \n",
    "            if res['total_tx'] == 0:\n",
    "                # if there are no silent payment \"eligible\" txs, move on\n",
    "                current_block += 1\n",
    "                continue\n",
    "            \n",
    "            # get the tweak data \n",
    "            tweak_data = \n",
    "            \n",
    "            # compute the tweaks\n",
    "            outputs_to_check = \n",
    "            \n",
    "            # check if any of the outputs exist in the block\n",
    "            # if they do, they necessarily belong to us\n",
    "            self.is_mine(outputs_to_check, res['block_hash'])\n",
    "            current_block += 1\n",
    "            \n",
    "        self.start_from_height = current_block\n",
    "        print(\"done scanning\")\n",
    "        \n",
    "    def get_silent_payment_block_data(self, height):\n",
    "            \n",
    "        # get the block hash for a given height\n",
    "        block_hash = \n",
    "        \n",
    "        # get the silent payment block data\n",
    "        data = \n",
    "        \n",
    "        # add the block hash to the response (saves an rpc call later)\n",
    "        data['block_hash'] = block_hash\n",
    "        return data\n",
    "        \n",
    "    def parse_silent_payment_block_data(self, data):\n",
    "        total_txs = data['total_tx']\n",
    "        tx_data = data['data']\n",
    "        txs = [\n",
    "            tx_data[i:i + ?]\n",
    "            for i in range(0, len(tx_data), ?\n",
    "        ]\n",
    "        tweaks = [\n",
    "            (tx[:self.PUBKEY_BYTES*2], tx[self.PUBKEY_BYTES*2:]) for tx in txs\n",
    "        ]\n",
    "        assert len(tweaks) == total_txs\n",
    "        return tweaks\n",
    "    \n",
    "    def compute_outputs(self, txs):\n",
    "        potential_outputs = []\n",
    "        for (sum_pubkeys, trunc_hash) in txs:\n",
    "            # convert the hex pubkey into an ECPubKey\n",
    "            I = \n",
    "            \n",
    "            # hash the truncated hash\n",
    "            outpoint_hash = \n",
    "            \n",
    "            # compute the tweak\n",
    "            ecdh = \n",
    "            \n",
    "            # SHA256(outpoint_hash * a * B) - use the special hash function which implements secp256k1 ecdh\n",
    "            shared_secret = self.sha256_secp256k1_ecdh(\n",
    "                ecdh.get_x().to_bytes(32, 'big'),\n",
    "                ecdh.get_y().to_bytes(32, 'big'),\n",
    "            )\n",
    "            \n",
    "            # t * G + A\n",
    "            pubkey = \n",
    "            \n",
    "            # create a taproot scriptPubKey: 1 <pubkey>\n",
    "            spk = \n",
    "            potential_outputs.append(spk)\n",
    "            \n",
    "        return potential_outputs\n",
    "    \n",
    "    def get_compact_block_filter(self, block_hash):\n",
    "        res = self.rpc.getblockfilter(block_hash)\n",
    "        \n",
    "        # cheating here, because this is actually a compactSize field\n",
    "        N = int(res['filter'][:2], 16)\n",
    "        block_filter = res['filter'][2:]\n",
    "        return {'size': N, 'filter': block_filter}\n",
    "    \n",
    "    def is_mine(self, script_pub_keys, block_hash):\n",
    "        \n",
    "        gcs_data = self.get_compact_block_filter(block_hash)\n",
    "        if gcs_match_any(block_hash, script_pub_keys, gcs_data):\n",
    "            block_data = self.rpc.getblock(block_hash, 2)\n",
    "            for tx in block_data['tx']:\n",
    "                for vout in tx['vout']:\n",
    "                    if vout['scriptPubKey']['hex'] in script_pub_keys:\n",
    "                        print(f\"{tx['txid']} is mine!\")\n",
    "        \n",
    "def rpc_client():\n",
    "    return AuthServiceProxy(\"http://%s:%s@127.0.0.1:18443\"%(\"silent\", \"payments\"))\n",
    "\n",
    "wallet = SPWallet(sha256(b'stuff n fluff').hex())\n",
    "wallet.get_silent_payment_address()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65ec106f",
   "metadata": {},
   "outputs": [],
   "source": [
    "scanner = SPScanner(wallet.spend_pubkey, wallet.scan_privkey, rpc_client(), 315)\n",
    "scanner.scan()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}