Inside Bitcoin

251        txid = send_res["txid"]
252
253        tx = rbf_node.gettransaction(txid=txid, verbose=True)
254        assert_equal(len(tx["decoded"]["vout"]), 2)
255
256        change_pos = find_vout_for_address(rbf_node, txid, change_addr)
257        change_value = tx["decoded"]["vout"][change_pos]["value"]
258
259        bumped = rbf_node.bumpfee(txid, {"original_change_index": change_pos})
260        new_txid = bumped["txid"]
261
262        new_tx = rbf_node.gettransaction(txid=new_txid, verbose=True)
263        assert_equal(len(new_tx["decoded"]["vout"]), 2)
264        new_change_pos = find_vout_for_address(rbf_node, new_txid, change_addr)
265        new_change_value = new_tx["decoded"]["vout"][new_change_pos]["value"]
266
267        assert_greater_than(change_value, new_change_value)
268
269
270    def test_single_output(self):
271        self.log.info("Test that single output txs can be bumped")
272        node = self.nodes[1]
273
274        node.createwallet("single_out_rbf")
275        wallet = node.get_wallet_rpc("single_out_rbf")
276
277        addr = wallet.getnewaddress()
278        amount = Decimal("0.001")
279        # Make 2 UTXOs
280        self.nodes[0].sendtoaddress(addr, amount)
281        self.nodes[0].sendtoaddress(addr, amount)
282        self.generate(self.nodes[0], 1)
283        utxos = wallet.listunspent()
284
285        tx = wallet.sendall(recipients=[wallet.getnewaddress()], fee_rate=2, options={"inputs": [utxos[0]]})
286
287        # Set the only output with a crazy high feerate as change, should fail as the output would be dust
288        assert_raises_rpc_error(-4, "The transaction amount is too small to pay the fee", wallet.bumpfee, txid=tx["txid"], options={"fee_rate": 1100, "original_change_index": 0})
289
290        # Specify single output as change successfully
291        bumped = wallet.bumpfee(txid=tx["txid"], options={"fee_rate": 10, "original_change_index": 0})
292        bumped_tx = wallet.gettransaction(txid=bumped["txid"], verbose=True)
293        assert_equal(len(bumped_tx["decoded"]["vout"]), 1)
294        assert_equal(len(bumped_tx["decoded"]["vin"]), 1)
295        assert_equal(bumped_tx["decoded"]["vout"][0]["value"] + bumped["fee"], amount)
296        assert_fee_amount(bumped["fee"], bumped_tx["decoded"]["vsize"], Decimal(10) / Decimal(1e8) * 1000)
297
298        # Bumping without specifying change adds a new input and output
299        bumped = wallet.bumpfee(txid=bumped["txid"], options={"fee_rate": 20})
300        bumped_tx = wallet.gettransaction(txid=bumped["txid"], verbose=True)
301        assert_equal(len(bumped_tx["decoded"]["vout"]), 2)
302        assert_equal(len(bumped_tx["decoded"]["vin"]), 2)
303        assert_fee_amount(bumped["fee"], bumped_tx["decoded"]["vsize"], Decimal(20) / Decimal(1e8) * 1000)
304
305        wallet.unloadwallet()
306
307def test_simple_bumpfee_succeeds(self, mode, rbf_node, peer_node, dest_address):
308    self.log.info('Test simple bumpfee: {}'.format(mode))
309    rbfid = spend_one_input(rbf_node, dest_address)
310    rbftx = rbf_node.gettransaction(rbfid)
311    self.sync_mempools((rbf_node, peer_node))
312    assert rbfid in rbf_node.getrawmempool() and rbfid in peer_node.getrawmempool()
313    if mode == "fee_rate":
314        bumped_psbt = rbf_node.psbtbumpfee(rbfid, fee_rate=str(NORMAL))
315        bumped_tx = rbf_node.bumpfee(rbfid, fee_rate=NORMAL)
316    elif mode == "new_outputs":
317        new_address = peer_node.getnewaddress()
318        bumped_psbt = rbf_node.psbtbumpfee(rbfid, outputs={new_address: 0.0003})
319        bumped_tx = rbf_node.bumpfee(rbfid, outputs={new_address: 0.0003})
320    else:
321        bumped_psbt = rbf_node.psbtbumpfee(rbfid)
322        bumped_tx = rbf_node.bumpfee(rbfid)
323    assert_equal(bumped_tx["errors"], [])
324    assert bumped_tx["fee"] > -rbftx["fee"]
325    assert_equal(bumped_tx["origfee"], -rbftx["fee"])
326    assert "psbt" not in bumped_tx
327    assert_equal(bumped_psbt["errors"], [])
328    assert bumped_psbt["fee"] > -rbftx["fee"]
329    assert_equal(bumped_psbt["origfee"], -rbftx["fee"])
330    assert "psbt" in bumped_psbt
331    # check that bumped_tx propagates, original tx was evicted and has a wallet conflict
332    self.sync_mempools((rbf_node, peer_node))
333    assert bumped_tx["txid"] in rbf_node.getrawmempool()
334    assert bumped_tx["txid"] in peer_node.getrawmempool()
335    assert rbfid not in rbf_node.getrawmempool()
336    assert rbfid not in peer_node.getrawmempool()
337    oldwtx = rbf_node.gettransaction(rbfid)
338    assert len(oldwtx["walletconflicts"]) > 0
339    # check wallet transaction replaces and replaced_by values
340    bumpedwtx = rbf_node.gettransaction(bumped_tx["txid"])
341    assert_equal(oldwtx["replaced_by_txid"], bumped_tx["txid"])
342    assert_equal(bumpedwtx["replaces_txid"], rbfid)
343    # if this is a new_outputs test, check that outputs were indeed replaced
344    if mode == "new_outputs":
345        assert_equal(len(bumpedwtx["details"]), 1)
346        assert_equal(bumpedwtx["details"][0]["address"], new_address)
347    self.clear_mempool()
348
349
350def test_segwit_bumpfee_succeeds(self, rbf_node, dest_address):
351    self.log.info('Test that segwit-sourcing bumpfee works')
352    # Create a transaction with segwit output, then create an RBF transaction
353    # which spends it, and make sure bumpfee can be called on it.
354
355    segwit_out = rbf_node.getnewaddress(address_type='bech32')
356    segwitid = rbf_node.send({segwit_out: "0.0009"}, options={"change_position": 1})["txid"]
357
358    rbfraw = rbf_node.createrawtransaction([{
359        'txid': segwitid,
360        'vout': 0,
361        "sequence": MAX_BIP125_RBF_SEQUENCE
362    }], {dest_address: Decimal("0.0005"),
363         rbf_node.getrawchangeaddress(): Decimal("0.0003")})
364    rbfsigned = rbf_node.signrawtransactionwithwallet(rbfraw)
365    rbfid = rbf_node.sendrawtransaction(rbfsigned["hex"])
366    assert rbfid in rbf_node.getrawmempool()
367
368    bumped_tx = rbf_node.bumpfee(rbfid)
369    assert bumped_tx["txid"] in rbf_node.getrawmempool()
370    assert rbfid not in rbf_node.getrawmempool()
371    self.clear_mempool()
372
373
374def test_nonrbf_bumpfee_succeeds(self, peer_node, dest_address):
375    self.log.info("Test that we can replace a non RBF transaction")
376    not_rbfid = peer_node.sendtoaddress(dest_address, Decimal("0.00090000"))
377    peer_node.bumpfee(not_rbfid)
378    self.clear_mempool()
379
380
381def test_notmine_bumpfee(self, rbf_node, peer_node, dest_address):
382    self.log.info('Test that it cannot bump fee if non-owned inputs are included')
383    # here, the rbftx has a peer_node coin and then adds a rbf_node input
384    # Note that this test depends upon the RPC code checking input ownership prior to change outputs
385    # (since it can't use fundrawtransaction, it lacks a proper change output)
386    fee = Decimal("0.001")
387    utxos = [node.listunspent(minimumAmount=fee)[-1] for node in (rbf_node, peer_node)]
388    inputs = [{
389        "txid": utxo["txid"],
390        "vout": utxo["vout"],
391        "address": utxo["address"],
392        "sequence": MAX_BIP125_RBF_SEQUENCE
393    } for utxo in utxos]
394    output_val = sum(utxo["amount"] for utxo in utxos) - fee
395    rawtx = rbf_node.createrawtransaction(inputs, {dest_address: output_val})
396    signedtx = rbf_node.signrawtransactionwithwallet(rawtx)
397    signedtx = peer_node.signrawtransactionwithwallet(signedtx["hex"])
398    rbfid = rbf_node.sendrawtransaction(signedtx["hex"])
399    entry = rbf_node.getmempoolentry(rbfid)
400    old_fee = entry["fees"]["base"]
401    old_feerate = int(old_fee / entry["vsize"] * Decimal(1e8))
402    assert_raises_rpc_error(-4, "Transaction contains inputs that don't belong to this wallet",
403                            rbf_node.bumpfee, rbfid)
404
405    def finish_psbtbumpfee(psbt):
406        psbt = rbf_node.walletprocesspsbt(psbt)
407        psbt = peer_node.walletprocesspsbt(psbt["psbt"])
408        res = rbf_node.testmempoolaccept([psbt["hex"]])
409        assert res[0]["allowed"]
410        assert_greater_than(res[0]["fees"]["base"], old_fee)
411
412    self.log.info("Test that psbtbumpfee works for non-owned inputs")
413    psbt = rbf_node.psbtbumpfee(txid=rbfid)
414    finish_psbtbumpfee(psbt["psbt"])
415
416    psbt = rbf_node.psbtbumpfee(txid=rbfid, fee_rate=old_feerate + 10)
417    finish_psbtbumpfee(psbt["psbt"])
418
419    self.clear_mempool()
420
421
422def test_bumpfee_with_descendant_fails(self, rbf_node, rbf_node_address, dest_address):
423    self.log.info('Test that fee cannot be bumped when it has descendant')
424    # parent is send-to-self, so we don't have to check which output is change when creating the child tx
425    parent_id = spend_one_input(rbf_node, rbf_node_address)
426    tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.00020000})
427    tx = rbf_node.signrawtransactionwithwallet(tx)
428    rbf_node.sendrawtransaction(tx["hex"])
429    assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
430
431    # create tx with descendant in the mempool by using MiniWallet
432    miniwallet = MiniWallet(rbf_node)
433    parent_id = spend_one_input(rbf_node, miniwallet.get_address())
434    tx = rbf_node.gettransaction(txid=parent_id, verbose=True)['decoded']
435    miniwallet.scan_tx(tx)
436    miniwallet.send_self_transfer(from_node=rbf_node)
437    assert_raises_rpc_error(-8, "Transaction has descendants in the mempool", rbf_node.bumpfee, parent_id)
438    self.clear_mempool()
439
440
441def test_bumpfee_with_abandoned_descendant_succeeds(self, rbf_node, rbf_node_address, dest_address):
442    self.log.info('Test that fee can be bumped when it has abandoned descendant')
443    # parent is send-to-self, so we don't have to check which output is change when creating the child tx
444    parent_id = spend_one_input(rbf_node, rbf_node_address)
445    # Submit child transaction with low fee
446    child_id = rbf_node.send(outputs={dest_address: 0.00020000},
447                             options={"inputs": [{"txid": parent_id, "vout": 0}], "fee_rate": 2})["txid"]
448    assert child_id in rbf_node.getrawmempool()
449
450    # Restart the node with higher min relay fee so the descendant tx is no longer in mempool so that we can abandon it
451    self.restart_node(1, ['-minrelaytxfee=0.00005'] + self.extra_args[1])
452    rbf_node.walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)
453    self.connect_nodes(1, 0)
454    assert parent_id in rbf_node.getrawmempool()
455    assert child_id not in rbf_node.getrawmempool()
456    # Should still raise an error even if not in mempool
457    assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
458    # Now abandon the child transaction and bump the original
459    rbf_node.abandontransaction(child_id)
460    bumped_result = rbf_node.bumpfee(parent_id, {"fee_rate": HIGH})
461    assert bumped_result['txid'] in rbf_node.getrawmempool()
462    assert parent_id not in rbf_node.getrawmempool()
463    # Cleanup
464    self.restart_node(1, self.extra_args[1])
465    rbf_node.walletpassphrase(WALLET_PASSPHRASE, WALLET_PASSPHRASE_TIMEOUT)
466    self.connect_nodes(1, 0)
467    self.clear_mempool()
468
469
470def test_small_output_with_feerate_succeeds(self, rbf_node, dest_address):
471    self.log.info('Testing small output with feerate bump succeeds')
472
473    # Make sure additional inputs exist
474    self.generatetoaddress(rbf_node, COINBASE_MATURITY + 1, rbf_node.getnewaddress())
475    rbfid = spend_one_input(rbf_node, dest_address)
476    input_list = rbf_node.getrawtransaction(rbfid, 1)["vin"]
477    assert_equal(len(input_list), 1)
478    original_txin = input_list[0]
479    self.log.info('Keep bumping until transaction fee out-spends non-destination value')
480    tx_fee = 0
481    while True:
482        input_list = rbf_node.getrawtransaction(rbfid, 1)["vin"]
483        new_item = list(input_list)[0]
484        assert_equal(len(input_list), 1)
485        assert_equal(original_txin["txid"], new_item["txid"])
486        assert_equal(original_txin["vout"], new_item["vout"])
487        rbfid_new_details = rbf_node.bumpfee(rbfid)
488        rbfid_new = rbfid_new_details["txid"]
489        raw_pool = rbf_node.getrawmempool()
490        assert rbfid not in raw_pool
491        assert rbfid_new in raw_pool
492        rbfid = rbfid_new
493        tx_fee = rbfid_new_details["fee"]
494
495        # Total value from input not going to destination
496        if tx_fee > Decimal('0.00050000'):
497            break
498
499    # input(s) have been added
500    final_input_list = rbf_node.getrawtransaction(rbfid, 1)["vin"]