Inside Bitcoin

501    assert_greater_than(len(final_input_list), 1)
502    # Original input is in final set
503    assert [txin for txin in final_input_list
504            if txin["txid"] == original_txin["txid"]
505            and txin["vout"] == original_txin["vout"]]
506
507    self.generatetoaddress(rbf_node, 1, rbf_node.getnewaddress())
508    assert_equal(rbf_node.gettransaction(rbfid)["confirmations"], 1)
509    self.clear_mempool()
510
511
512def test_dust_to_fee(self, rbf_node, dest_address):
513    self.log.info('Test that bumped output that is dust is dropped to fee')
514    rbfid = spend_one_input(rbf_node, dest_address, change_size=Decimal("0.00030000"), dest_amount=Decimal("0.00064730"))
515    fulltx = rbf_node.getrawtransaction(rbfid, 1)
516    # The DER formatting used by Bitcoin to serialize ECDSA signatures means that signatures can have a
517    # variable size of 70-72 bytes (or possibly even less), with most being 71 or 72 bytes. The signature
518    # in the witness is divided by 4 for the vsize, so this variance can take the weight across a 4-byte
519    # boundary. Thus expected transaction size (p2wpkh, 1 input, 2 outputs) is 140-141 vbytes, usually 141.
520    if not 140 <= fulltx["vsize"] <= 141:
521        raise AssertionError("Invalid tx vsize of {} (140-141 expected), full tx: {}".format(fulltx["vsize"], fulltx))
522    # Bump with fee_rate of 250 sat/vB. The leftover change is below the dust
523    # threshold, so it is dropped and folded into the fee.
524    # Target fee is 141 vbytes * 0.00250000 BTC / 1000 vbytes = 0.00035250 BTC (20 sat change left),
525    # or occasionally 140 vbytes * 0.00250000 BTC / 1000 vbytes = 0.00035000 BTC (270 sat change left).
526    # Either way the sub-dust change is added to the fee, giving 0.00035270 BTC.
527    bumped_tx = rbf_node.bumpfee(rbfid, fee_rate=250)
528    full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1)
529    assert_equal(bumped_tx["fee"], Decimal("0.00035270"))
530    assert_equal(len(fulltx["vout"]), 2)
531    assert_equal(len(full_bumped_tx["vout"]), 1)  # change output is eliminated
532    assert_equal(full_bumped_tx["vout"][0]['value'], Decimal("0.00064730"))
533    self.clear_mempool()
534
535def test_maxtxfee_fails(self, rbf_node, dest_address):
536    self.log.info('Test that bumpfee fails when it hits -maxtxfee')
537    # size of bumped transaction (p2wpkh, 1 input, 2 outputs): 141 vbytes
538    # expected bump fee of 141 vbytes * 0.00200000 BTC / 1000 vbytes = 0.00002820 BTC
539    # which exceeds maxtxfee and is expected to raise
540    self.restart_node(1, ['-maxtxfee=0.000025'] + self.extra_args[1])
541    rbf_node.walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)
542    rbfid = spend_one_input(rbf_node, dest_address)
543    assert_raises_rpc_error(-4, "Unable to create transaction. Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)", rbf_node.bumpfee, rbfid)
544    self.restart_node(1, self.extra_args[1])
545    rbf_node.walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)
546    self.connect_nodes(1, 0)
547    self.clear_mempool()
548
549
550def test_watchonly_psbt(self, peer_node, rbf_node, dest_address):
551    self.log.info('Test that PSBT is returned for bumpfee in watchonly wallets')
552    priv_rec_desc = descsum_create(f"wpkh([00000001/84'/1'/0']{ExtendedPrivateKey.generate().to_string()}/0/*)")
553    pub_rec_desc = rbf_node.getdescriptorinfo(priv_rec_desc)["descriptor"]
554    priv_change_desc = descsum_create(f"wpkh([00000001/84'/1'/0']{ExtendedPrivateKey.generate().to_string()}/1/*)")
555    pub_change_desc = rbf_node.getdescriptorinfo(priv_change_desc)["descriptor"]
556    # Create a wallet with private keys that can sign PSBTs
557    rbf_node.createwallet(wallet_name="signer", disable_private_keys=False, blank=True)
558    signer = rbf_node.get_wallet_rpc("signer")
559    assert signer.getwalletinfo()['private_keys_enabled']
560    reqs = [{
561        "desc": priv_rec_desc,
562        "timestamp": 0,
563        "range": [0,1],
564        "internal": False,
565        "keypool": False # Keys can only be imported to the keypool when private keys are disabled
566    },
567    {
568        "desc": priv_change_desc,
569        "timestamp": 0,
570        "range": [0, 0],
571        "internal": True,
572        "keypool": False
573    }]
574    result = signer.importdescriptors(reqs)
575    assert_equal(result, [{'success': True}, {'success': True}])
576
577    # Create another wallet with just the public keys, which creates PSBTs
578    rbf_node.createwallet(wallet_name="watcher", disable_private_keys=True, blank=True)
579    watcher = rbf_node.get_wallet_rpc("watcher")
580    assert not watcher.getwalletinfo()['private_keys_enabled']
581
582    reqs = [{
583        "desc": pub_rec_desc,
584        "timestamp": 0,
585        "range": [0, 10],
586        "internal": False,
587        "keypool": True,
588        "watchonly": True,
589        "active": True,
590    }, {
591        "desc": pub_change_desc,
592        "timestamp": 0,
593        "range": [0, 10],
594        "internal": True,
595        "keypool": True,
596        "watchonly": True,
597        "active": True,
598    }]
599    result = watcher.importdescriptors(reqs)
600    assert_equal(result, [{'success': True}, {'success': True}])
601
602    funding_address1 = watcher.getnewaddress(address_type='bech32')
603    funding_address2 = watcher.getnewaddress(address_type='bech32')
604    peer_node.sendmany("", {funding_address1: 0.001, funding_address2: 0.001})
605    self.generate(peer_node, 1)
606
607    # Create single-input PSBT for transaction to be bumped
608    # Ensure the payment amount + change can be fully funded using one of the 0.001BTC inputs.
609    psbt = watcher.walletcreatefundedpsbt([watcher.listunspent()[0]], {dest_address: 0.0005}, 0,
610            {"fee_rate": 1, "add_inputs": False}, True)['psbt']
611    psbt_signed = signer.walletprocesspsbt(psbt=psbt, sign=True, sighashtype="ALL", bip32derivs=True)
612    original_txid = watcher.sendrawtransaction(psbt_signed["hex"])
613    assert_equal(len(watcher.decodepsbt(psbt)["inputs"]), 1)
614
615    # bumpfee can't be used on watchonly wallets
616    assert_raises_rpc_error(-4, "bumpfee is not available with wallets that have private keys disabled. Use psbtbumpfee instead.", watcher.bumpfee, original_txid)
617
618    # Bump fee, obnoxiously high to add additional watchonly input
619    bumped_psbt = watcher.psbtbumpfee(original_txid, fee_rate=HIGH)
620    assert_greater_than(len(watcher.decodepsbt(bumped_psbt['psbt'])["inputs"]), 1)
621    assert "txid" not in bumped_psbt
622    assert_equal(bumped_psbt["origfee"], -watcher.gettransaction(original_txid)["fee"])
623    assert not watcher.finalizepsbt(bumped_psbt["psbt"])["complete"]
624
625    # Sign bumped transaction
626    bumped_psbt_signed = signer.walletprocesspsbt(psbt=bumped_psbt["psbt"], sign=True, sighashtype="ALL", bip32derivs=True)
627    assert bumped_psbt_signed["complete"]
628
629    # Broadcast bumped transaction
630    bumped_txid = watcher.sendrawtransaction(bumped_psbt_signed["hex"])
631    assert bumped_txid in rbf_node.getrawmempool()
632    assert original_txid not in rbf_node.getrawmempool()
633
634    rbf_node.unloadwallet("watcher")
635    rbf_node.unloadwallet("signer")
636    self.clear_mempool()
637
638
639def test_rebumping(self, rbf_node, dest_address):
640    self.log.info('Test that re-bumping the original tx fails, but bumping successor works')
641    rbfid = spend_one_input(rbf_node, dest_address)
642    bumped = rbf_node.bumpfee(rbfid, fee_rate=ECONOMICAL)
643    assert_raises_rpc_error(-4, f"Cannot bump transaction {rbfid} which was already bumped by transaction {bumped['txid']}",
644                            rbf_node.bumpfee, rbfid, fee_rate=NORMAL)
645    rbf_node.bumpfee(bumped["txid"], fee_rate=NORMAL)
646    self.clear_mempool()
647
648
649def test_rebumping_not_replaceable(self, rbf_node, dest_address):
650    self.log.info("Test that re-bumping non-replaceable passes")
651    rbfid = spend_one_input(rbf_node, dest_address)
652
653    def check_sequence(tx, seq_in):
654        tx = rbf_node.getrawtransaction(tx["txid"])
655        tx = rbf_node.decoderawtransaction(tx)
656        seq = [i["sequence"] for i in tx["vin"]]
657        assert_equal(seq, [seq_in])
658
659    bumped = rbf_node.bumpfee(rbfid, fee_rate=ECONOMICAL, replaceable=False)
660    check_sequence(bumped, MAX_SEQUENCE_NONFINAL)
661    bumped = rbf_node.bumpfee(bumped["txid"], {"fee_rate": NORMAL})
662    check_sequence(bumped, MAX_BIP125_RBF_SEQUENCE)
663
664    self.clear_mempool()
665
666
667def test_bumpfee_already_spent(self, rbf_node, dest_address):
668    self.log.info('Test that bumping tx with already spent coin fails')
669    txid = spend_one_input(rbf_node, dest_address)
670    self.generate(rbf_node, 1)  # spend coin simply by mining block with tx
671    spent_input = rbf_node.gettransaction(txid=txid, verbose=True)['decoded']['vin'][0]
672    assert_raises_rpc_error(-1, f"{spent_input['txid']}:{spent_input['vout']} is already spent",
673                            rbf_node.bumpfee, txid, fee_rate=NORMAL)
674
675
676def test_unconfirmed_not_spendable(self, rbf_node, rbf_node_address):
677    self.log.info('Test that unconfirmed outputs from bumped txns are not spendable')
678    rbfid = spend_one_input(rbf_node, rbf_node_address)
679    rbftx = rbf_node.gettransaction(rbfid)["hex"]
680    assert rbfid in rbf_node.getrawmempool()
681    bumpid = rbf_node.bumpfee(rbfid)["txid"]
682    assert bumpid in rbf_node.getrawmempool()
683    assert rbfid not in rbf_node.getrawmempool()
684
685    # check that outputs from the bump transaction are not spendable
686    # due to the replaces_txid check in CWallet::AvailableCoins
687    assert_equal([t for t in rbf_node.listunspent(minconf=0, include_unsafe=False) if t["txid"] == bumpid], [])
688
689    # submit a block with the rbf tx to clear the bump tx out of the mempool,
690    # then invalidate the block so the rbf tx will be put back in the mempool.
691    # This makes it possible to check whether the rbf tx outputs are
692    # spendable before the rbf tx is confirmed.
693    block = self.generateblock(rbf_node, output="raw(51)", transactions=[rbftx])
694    # Can not abandon conflicted tx
695    assert_raises_rpc_error(-5, 'Transaction not eligible for abandonment', lambda: rbf_node.abandontransaction(txid=bumpid))
696    rbf_node.invalidateblock(block["hash"])
697    # Call abandon to make sure the wallet doesn't attempt to resubmit
698    # the bump tx and hope the wallet does not rebroadcast before we call.
699    rbf_node.abandontransaction(bumpid)
700
701    tx_bump_abandoned = rbf_node.gettransaction(bumpid)
702    for tx in tx_bump_abandoned['details']:
703        assert_equal(tx['abandoned'], True)
704
705    assert bumpid not in rbf_node.getrawmempool()
706    assert rbfid in rbf_node.getrawmempool()
707
708    # check that outputs from the rbf tx are not spendable before the
709    # transaction is confirmed, due to the replaced_by_txid check in
710    # CWallet::AvailableCoins
711    assert_equal([t for t in rbf_node.listunspent(minconf=0, include_unsafe=False) if t["txid"] == rbfid], [])
712
713    # check that the main output from the rbf tx is spendable after confirmed
714    self.generate(rbf_node, 1, sync_fun=self.no_op)
715    assert_equal(
716        sum(1 for t in rbf_node.listunspent(minconf=0, include_unsafe=False)
717            if t["txid"] == rbfid and t["address"] == rbf_node_address and t["spendable"]), 1)
718    self.clear_mempool()
719
720
721def test_bumpfee_metadata(self, rbf_node, dest_address):
722    self.log.info('Test that bumped txn metadata persists to new txn record')
723    assert rbf_node.getbalance() < 49
724    self.generatetoaddress(rbf_node, 101, rbf_node.getnewaddress())
725    rbfid = rbf_node.sendtoaddress(dest_address, 49, "comment value", "to value")
726    bumped_tx = rbf_node.bumpfee(rbfid)
727    bumped_wtx = rbf_node.gettransaction(bumped_tx["txid"])
728    assert_equal(bumped_wtx["comment"], "comment value")
729    assert_equal(bumped_wtx["to"], "to value")
730    self.clear_mempool()
731
732
733def test_locked_wallet_fails(self, rbf_node, dest_address):
734    self.log.info('Test that locked wallet cannot bump txn')
735    rbfid = spend_one_input(rbf_node, dest_address)
736    rbf_node.walletlock()
737    assert_raises_rpc_error(-13, "Please enter the wallet passphrase with walletpassphrase first.",
738                            rbf_node.bumpfee, rbfid)
739    rbf_node.walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)
740    self.clear_mempool()
741
742
743def test_change_script_match(self, rbf_node, dest_address):
744    self.log.info('Test that the same change addresses is used for the replacement transaction when possible')
745
746    # Check that there is only one change output
747    rbfid = spend_one_input(rbf_node, dest_address)
748    change_addresses = get_change_address(rbfid, rbf_node)
749    assert_equal(len(change_addresses), 1)
750