Inside Bitcoin

251        assert_equal(tx_info["hex"], canonical_tx_hex)
252        assert_equal(tx_info["wtxid"], canonical_wtxid)
253        # alternate_wtxids lists the other variants, never the canonical one
254        assert canonical_wtxid not in tx_info["alternate_wtxids"]
255        assert_equal(set(tx_info["alternate_wtxids"]), set(alternate_wtxids))
256
257        # listtransactions exposes the same alternate_wtxids field as gettransaction
258        list_entry = next(entry for entry in wallet.listtransactions() if entry["txid"] == txid)
259        assert_equal(list_entry["alternate_wtxids"], tx_info["alternate_wtxids"])
260
261    # Returns the finalized psbt transaction and its wtxid
262    def finalize_tx_variant(self, wallet, psbt, spend_path):
263        # First check the expected spend path is being used
264        sig_field = {"script": "taproot_script_path_sigs", "key": "taproot_key_path_sig"}
265        present, absent = sig_field[spend_path], sig_field["key" if spend_path == "script" else "script"]
266        psbt_input = self.nodes[0].decodepsbt(psbt)["inputs"][0]
267        assert present in psbt_input and absent not in psbt_input
268
269        # Then finalize and decode
270        tx = wallet.finalizepsbt(psbt)["hex"]
271        return tx, wallet.decoderawtransaction(tx)["hash"]
272
273    def test_alternate_witness_tx(self):
274        self.log.info("Test gettransaction and listtransactions report alternate witnesses and canonical variant")
275        self.nodes[0].createwallet("altwit")
276        default_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
277        wallet = self.nodes[0].get_wallet_rpc("altwit")
278
279        xprvs = [ExtendedPrivateKey.generate() for _ in range(0, 2)]
280        xpubs = [xprv.pubkey() for xprv in xprvs]
281
282        # Import a taproot descriptor with script paths
283        desc = descsum_create(f"tr({xpubs[0].to_string()}/*,pk({xprvs[1].to_string()}/*))")
284        assert_equal(wallet.importdescriptors([{"desc": desc, "active": True, "timestamp": "now"}])[0]["success"], True)
285        default_wallet.sendtoaddress(wallet.getnewaddress(address_type="bech32m"), 1)
286        self.generate(self.nodes[0], 1)
287        # Isolate node0 for later reorg coverage
288        self.disconnect_nodes(0, 1)
289        self.disconnect_nodes(0, 2)
290
291        # Create output psbt
292        psbt = wallet.walletcreatefundedpsbt(outputs=[{default_wallet.getnewaddress(): 0.5}])["psbt"]
293
294        # Create a script path spend and relay it. With only one variant known it
295        # is trivially canonical and has no alternates
296        self.log.info("Test the only known variant is canonical with no alternates")
297        script_path_psbt = wallet.walletprocesspsbt(psbt=psbt, finalize=False)["psbt"]
298        script_path_tx, script_path_wtxid = self.finalize_tx_variant(wallet, script_path_psbt, spend_path="script")
299        txid = self.nodes[0].sendrawtransaction(script_path_tx)
300        self.check_tx_variants(wallet, txid, script_path_tx, script_path_wtxid, alternate_wtxids=[])
301
302        # Make a key path spend separate from the wallet
303        key_path_desc = descsum_create(f"tr({xprvs[0].to_string()}/*,pk({xpubs[1].to_string()}/*))")
304        key_path_psbt = self.nodes[0].descriptorprocesspsbt(psbt=psbt, descriptors=[{"desc": key_path_desc}], finalize=False)["psbt"]
305        key_path_tx, key_path_wtxid = self.finalize_tx_variant(wallet, key_path_psbt, spend_path="key")
306
307        # Ensure variants share the same txid but differ in wtxid, and the key path is the lighter of the two
308        assert_equal(txid, self.nodes[0].decoderawtransaction(key_path_tx)["txid"])
309        assert_not_equal(script_path_wtxid, key_path_wtxid)
310        assert_greater_than(
311            self.nodes[0].decoderawtransaction(script_path_tx)["weight"],
312            self.nodes[0].decoderawtransaction(key_path_tx)["weight"],
313        )
314
315        # The wallet only learns the key path witness from a block (the mempool
316        # holds one transaction per txid). Mine the key path: a confirmed variant
317        # is canonical, with the script path now listed as its alternate.
318        block = self.generateblock(self.nodes[0], default_wallet.getnewaddress(), [key_path_tx], sync_fun=self.no_op)["hash"]
319        self.check_tx_variants(wallet, txid, key_path_tx, key_path_wtxid, alternate_wtxids=[script_path_wtxid])
320
321        # Reorg that block out so both variants are known and unconfirmed. With no
322        # confirmation to force the choice, the lighter key path is canonical.
323        self.log.info("Test the lighter variant is canonical when both are known and unconfirmed")
324        self.nodes[0].invalidateblock(block)
325        self.nodes[0].syncwithvalidationinterfacequeue()
326        assert_equal(wallet.gettransaction(txid)["confirmations"], 0)
327        self.check_tx_variants(wallet, txid, key_path_tx, key_path_wtxid, alternate_wtxids=[script_path_wtxid])
328
329        # The canonical choice and alternates survive a wallet reload
330        wallet.unloadwallet()
331        self.nodes[0].loadwallet("altwit")
332        self.check_tx_variants(wallet, txid, key_path_tx, key_path_wtxid, alternate_wtxids=[script_path_wtxid])
333
334        # Now confirm the heavier script path instead, on a longer competing chain
335        # from node1, and reconnect so node0 reorgs onto it. The confirmed variant
336        # is canonical even though it is the heavier one.
337        self.log.info("Test a confirmed variant is canonical even when it is the heavier one")
338        self.generate(self.nodes[1], 3, sync_fun=self.no_op)
339        block = self.generateblock(self.nodes[1], default_wallet.getnewaddress(), [script_path_tx], sync_fun=self.no_op)["hash"]
340        self.connect_nodes(0, 1)
341        self.connect_nodes(0, 2)
342        self.sync_all()
343        self.check_tx_variants(wallet, txid, script_path_tx, script_path_wtxid, alternate_wtxids=[key_path_wtxid])
344
345        # The confirmed-canonical choice survive a reload
346        wallet.unloadwallet()
347        self.nodes[0].loadwallet("altwit")
348        self.check_tx_variants(wallet, txid, script_path_tx, script_path_wtxid, alternate_wtxids=[key_path_wtxid])
349
350        self.log.info("Test canonical reverts to the lighter variant when the confirmed one is reorged out")
351        # Both variants are unconfirmed again, so the lighter key path is canonical once more
352        self.disconnect_nodes(0, 1)
353        self.disconnect_nodes(0, 2)
354        self.nodes[0].invalidateblock(block)
355        self.nodes[0].syncwithvalidationinterfacequeue()
356        assert_equal(wallet.gettransaction(txid)["confirmations"], 0)
357        self.check_tx_variants(wallet, txid, key_path_tx, key_path_wtxid, alternate_wtxids=[script_path_wtxid])
358
359        # listsinceblock "removed" entries reflect the wallet's current CWalletTx, not a
360        # snapshot of the detached block. The detached block contained the heavier script
361        # path variant, but "wtxid" reports the current canonical (key path) variant and
362        # the script path variant appears under "alternate_wtxids". A future improvement
363        # could track which specific variant was in the detached block and report that.
364        removed = next(e for e in wallet.listsinceblock(block)["removed"] if e["txid"] == txid)
365        assert_equal(removed["confirmations"], 0)
366        assert_equal(removed["wtxid"], key_path_wtxid)
367        assert_equal(removed["alternate_wtxids"], [script_path_wtxid])
368
369
370if __name__ == '__main__':
371    ListTransactionsTest(__file__).main()
372