Merge #227: [examples] Add segwit example for spending a P2WPKH output

df646ad [examples] Add segwit example for spending a P2WPKH output (Bryan Bishop)

Pull request description:

  Here's an example for using P2WPKH.

ACKs for top commit:
  JSwambo:
    ACK df646ad

Tree-SHA512: 3a8b57c0da5cc953163eb8ef4b981503b5db3e984741077dcf9c883db46fb0af00bbff37905b40545e990de52cdf1d2291b369e62d610b331322f47742faa69a

Author: kanzure

examples/spend-p2wpkh.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2020 The python-bitcoinlib developers
+#
+# This file is part of python-bitcoinlib.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of python-bitcoinlib, including this file, may be copied, modified,
+# propagated, or distributed except according to the terms contained in the
+# LICENSE file.
+
+"""Low-level example of how to spend a P2WPKH output."""
+
+import sys
+if sys.version_info.major < 3:
+    sys.stderr.write("Sorry, Python 3.x required by this example.\n")
+    sys.exit(1)
+
+import hashlib
+
+from bitcoin import SelectParams
+from bitcoin.core import b2x, b2lx, lx, COIN, COutPoint, CTxOut, CTxIn, CTxInWitness, CTxWitness, CScriptWitness, CMutableTransaction, Hash160
+from bitcoin.core.script import CScript, OP_0, SignatureHash, SIGHASH_ALL, SIGVERSION_WITNESS_V0
+from bitcoin.wallet import CBitcoinSecret, P2WPKHBitcoinAddress
+from bitcoin.rpc import Proxy
+
+SelectParams("regtest")
+connection = Proxy()
+
+if connection._call("getblockchaininfo")["chain"] != "regtest":
+    sys.stderr.write("This example is intended for regtest only.\n")
+    sys.exit(1)
+
+
+# Create the (in)famous correct brainwallet secret key.
+h = hashlib.sha256(b'correct horse battery staple').digest()
+seckey = CBitcoinSecret.from_secret_bytes(h)
+
+# Create an address from that private key.
+public_key = seckey.pub
+scriptPubKey = CScript([OP_0, Hash160(public_key)])
+address = P2WPKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
+
+# Give the private key to bitcoind (for ismine, listunspent, etc).
+connection._call("importprivkey", str(seckey))
+
+# Check if there's any funds available.
+unspentness = lambda: connection._call("listunspent", 6, 9999, [str(address)], True, {"minimumAmount": 1.0})
+unspents = unspentness()
+while len(unspents) == 0:
+    # mine some funds into the address
+    connection._call("generatetoaddress", 110, str(address))
+    unspents = unspentness()
+
+# Choose the first UTXO, let's spend it!
+unspent_utxo_details = unspents[0]
+txid = unspent_utxo_details["txid"]
+vout = unspent_utxo_details["vout"]
+amount = int(float(unspent_utxo_details["amount"]) * COIN)
+
+# Calculate an amount for the upcoming new UTXO. Set a high fee to bypass
+# bitcoind minfee setting.
+amount_less_fee = int(amount - (0.01 * COIN))
+
+# Create a destination to send the coins.
+destination_address = connection._call("getnewaddress", "python-bitcoinlib-example", "bech32")
+destination_address = P2WPKHBitcoinAddress(destination_address)
+target_scriptPubKey = destination_address.to_scriptPubKey()
+
+# Create the unsigned transaction.
+txin = CTxIn(COutPoint(lx(txid), vout))
+txout = CTxOut(amount_less_fee, target_scriptPubKey)
+tx = CMutableTransaction([txin], [txout])
+
+# Specify which transaction input is going to be signed for.
+txin_index = 0
+
+# When signing a P2WPKH transaction, use an "implicit" script that isn't
+# specified in the scriptPubKey or the witness.
+redeem_script = address.to_redeemScript()
+
+# Calculate the signature hash for the transaction. This is then signed by the
+# private key that controls the UTXO being spent here at this txin_index.
+sighash = SignatureHash(redeem_script, tx, txin_index, SIGHASH_ALL, amount=amount, sigversion=SIGVERSION_WITNESS_V0)
+signature = seckey.sign(sighash) + bytes([SIGHASH_ALL])
+
+# Construct a witness for this transaction input. The public key is given in
+# the witness so that the appropriate redeem_script can be calculated by
+# anyone. The original scriptPubKey had only the Hash160 hash of the public
+# key, not the public key itself, and the redeem script can be entirely
+# re-constructed (from implicit template) if given just the public key. So the
+# public key is added to the witness. This is P2WPKH in bip141.
+witness = [signature, public_key]
+
+# Aggregate all of the witnesses together, and then assign them to the
+# transaction object.
+ctxinwitnesses = [CTxInWitness(CScriptWitness(witness))]
+tx.wit = CTxWitness(ctxinwitnesses)
+
+# Broadcast the transaction to the regtest network.
+spend_txid = connection.sendrawtransaction(tx)
+
+# Done! Print the transaction to standard output. Show the transaction
+# serialization in hex (instead of bytes), and render the txid.
+print("serialized transaction: {}".format(b2x(tx.serialize())))
+print("txid: {}".format(b2lx(spend_txid)))