Inside Bitcoin

251        self.add_utxos([19, 2])
252
253        assert_raises_rpc_error(
254                -8,
255                "Must provide at least one address without a specified amount" ,
256                self.wallet.sendall,
257                []
258            )
259
260    @cleanup
261    def sendall_fails_on_specific_inputs_with_send_max(self):
262        self.log.info("Test sendall fails because send_max is used while specific inputs are provided")
263        self.add_utxos([15, 6])
264        utxo = self.wallet.listunspent()[0]
265
266        assert_raises_rpc_error(-8,
267            "Cannot combine send_max with specific inputs.",
268            self.wallet.sendall,
269            recipients=[self.remainder_target],
270            inputs=[utxo], send_max=True)
271
272    @cleanup
273    def sendall_fails_on_high_fee(self):
274        self.log.info("Test sendall fails if the transaction fee exceeds the maxtxfee")
275        self.add_utxos([21])
276
277        assert_raises_rpc_error(
278                -4,
279                "Fee exceeds maximum configured by user",
280                self.wallet.sendall,
281                recipients=[self.remainder_target],
282                fee_rate=100000)
283
284    @cleanup
285    def sendall_fails_on_low_fee(self):
286        self.log.info("Test sendall fails if the transaction fee is lower than the minimum fee rate setting")
287        assert_raises_rpc_error(-8, "Fee rate (0.999 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)",
288        self.wallet.sendall, recipients=[self.recipient], fee_rate=0.999)
289
290    @cleanup
291    def sendall_watchonly_specific_inputs(self):
292        self.log.info("Test sendall with a subset of UTXO pool in a watchonly wallet")
293        self.add_utxos([17, 4])
294        utxo = self.wallet.listunspent()[0]
295
296        self.nodes[0].createwallet(wallet_name="watching", disable_private_keys=True)
297        watchonly = self.nodes[0].get_wallet_rpc("watching")
298
299        import_req = [{
300            "desc": utxo["desc"],
301            "timestamp": 0,
302        }]
303        watchonly.importdescriptors(import_req)
304
305        sendall_tx_receipt = watchonly.sendall(recipients=[self.remainder_target], inputs=[utxo])
306        psbt = sendall_tx_receipt["psbt"]
307        decoded = self.nodes[0].decodepsbt(psbt)
308        assert_equal(len(decoded["inputs"]), 1)
309        assert_equal(len(decoded["outputs"]), 1)
310        assert_equal(decoded["inputs"][0]["previous_txid"], utxo["txid"])
311        assert_equal(decoded["inputs"][0]["previous_vout"], utxo["vout"])
312        assert_equal(decoded["outputs"][0]["script"]["address"], self.remainder_target)
313
314    @cleanup
315    def sendall_with_minconf(self):
316        # utxo of 17 bicoin has 6 confirmations, utxo of 4 has 3
317        self.add_utxos([17])
318        self.generate(self.nodes[0], 2)
319        self.add_utxos([4])
320        self.generate(self.nodes[0], 2)
321
322        self.log.info("Test sendall fails because minconf is negative")
323
324        assert_raises_rpc_error(-8,
325            "Invalid minconf (minconf cannot be negative): -2",
326            self.wallet.sendall,
327            recipients=[self.remainder_target],
328            options={"minconf": -2})
329        self.log.info("Test sendall fails because minconf is used while specific inputs are provided")
330
331        utxo = self.wallet.listunspent()[0]
332        assert_raises_rpc_error(-8,
333            "Cannot combine minconf or maxconf with specific inputs.",
334            self.wallet.sendall,
335            recipients=[self.remainder_target],
336            options={"inputs": [utxo], "minconf": 2})
337
338        self.log.info("Test sendall fails because there are no utxos with enough confirmations specified by minconf")
339
340        assert_raises_rpc_error(-6,
341            "Total value of UTXO pool too low to pay for transaction. Try using lower feerate or excluding uneconomic UTXOs with 'send_max' option.",
342            self.wallet.sendall,
343            recipients=[self.remainder_target],
344            options={"minconf": 7})
345
346        self.log.info("Test sendall only spends utxos with a specified number of confirmations when minconf is used")
347        self.wallet.sendall(recipients=[self.remainder_target], fee_rate=300, options={"minconf": 6})
348
349        assert_equal(len(self.wallet.listunspent()), 1)
350        assert_equal(self.wallet.listunspent()[0]['confirmations'], 3)
351
352        # decrease minconf and show the remaining utxo is picked up
353        self.wallet.sendall(recipients=[self.remainder_target], fee_rate=300, options={"minconf": 3})
354        assert_equal(self.wallet.getbalance(), 0)
355
356    @cleanup
357    def sendall_with_maxconf(self):
358        # utxo of 17 bicoin has 6 confirmations, utxo of 4 has 3
359        self.add_utxos([17])
360        self.generate(self.nodes[0], 2)
361        self.add_utxos([4])
362        self.generate(self.nodes[0], 2)
363
364        self.log.info("Test sendall fails because there are no utxos with enough confirmations specified by maxconf")
365        assert_raises_rpc_error(-6,
366            "Total value of UTXO pool too low to pay for transaction. Try using lower feerate or excluding uneconomic UTXOs with 'send_max' option.",
367            self.wallet.sendall,
368            recipients=[self.remainder_target],
369            options={"maxconf": 1})
370
371        self.log.info("Test sendall only spends utxos with a specified number of confirmations when maxconf is used")
372        self.wallet.sendall(recipients=[self.remainder_target], fee_rate=300, options={"maxconf":4})
373        assert_equal(len(self.wallet.listunspent()), 1)
374        assert_equal(self.wallet.listunspent()[0]['confirmations'], 6)
375
376    @cleanup
377    def sendall_spends_unconfirmed_change(self):
378        self.log.info("Test that sendall spends unconfirmed change")
379        self.add_utxos([17])
380        self.wallet.sendtoaddress(self.remainder_target, 10)
381        assert_greater_than(self.wallet.getbalances()["mine"]["trusted"], 6)
382        self.test_sendall_success(sendall_args = [self.remainder_target])
383
384        assert_equal(self.wallet.getbalance(), 0)
385
386    @cleanup
387    def sendall_spends_unconfirmed_inputs_if_specified(self):
388        self.log.info("Test that sendall spends specified unconfirmed inputs")
389        self.def_wallet.sendtoaddress(self.wallet.getnewaddress(), 17)
390        self.wallet.syncwithvalidationinterfacequeue()
391        assert_equal(self.wallet.getbalances()["mine"]["untrusted_pending"], 17)
392        unspent = self.wallet.listunspent(minconf=0)[0]
393
394        self.wallet.sendall(recipients=[self.remainder_target], inputs=[unspent])
395        assert_equal(self.wallet.getbalance(), 0)
396
397    @cleanup
398    def sendall_does_ancestor_aware_funding(self):
399        self.log.info("Test that sendall does ancestor aware funding for unconfirmed inputs")
400
401        # higher parent feerate
402        self.def_wallet.sendtoaddress(address=self.wallet.getnewaddress(), amount=17, fee_rate=20)
403        self.wallet.syncwithvalidationinterfacequeue()
404
405        assert_equal(self.wallet.getbalances()["mine"]["untrusted_pending"], 17)
406        unspent = self.wallet.listunspent(minconf=0)[0]
407
408        parent_txid = unspent["txid"]
409        assert_equal(self.wallet.gettransaction(parent_txid)["confirmations"], 0)
410
411        res_1 = self.wallet.sendall(recipients=[self.def_wallet.getnewaddress()], inputs=[unspent], fee_rate=20, add_to_wallet=False, lock_unspents=True)
412        child_hex = res_1["hex"]
413
414        child_tx = self.wallet.decoderawtransaction(child_hex)
415        higher_parent_feerate_amount = child_tx["vout"][0]["value"]
416
417        # lower parent feerate
418        self.def_wallet.sendtoaddress(address=self.wallet.getnewaddress(), amount=17, fee_rate=10)
419        self.wallet.syncwithvalidationinterfacequeue()
420        assert_equal(self.wallet.getbalances()["mine"]["untrusted_pending"], 34)
421        unspent = self.wallet.listunspent(minconf=0)[0]
422
423        parent_txid = unspent["txid"]
424        assert_equal(self.wallet.gettransaction(parent_txid)["confirmations"], 0)
425
426        res_2 = self.wallet.sendall(recipients=[self.def_wallet.getnewaddress()], inputs=[unspent], fee_rate=20, add_to_wallet=False, lock_unspents=True)
427        child_hex = res_2["hex"]
428
429        child_tx = self.wallet.decoderawtransaction(child_hex)
430        lower_parent_feerate_amount = child_tx["vout"][0]["value"]
431
432        assert_greater_than(higher_parent_feerate_amount, lower_parent_feerate_amount)
433
434    @cleanup
435    def sendall_anti_fee_sniping(self):
436        self.log.info("Testing sendall does anti-fee-sniping when locktime is not specified")
437        self.add_utxos([10,11])
438        tx_from_wallet = self.test_sendall_success(sendall_args = [self.remainder_target], options={"replaceable":False})
439
440        # the locktime should be within 100 blocks of the
441        # block height
442        assert_greater_than_or_equal(tx_from_wallet["decoded"]["locktime"], tx_from_wallet["blockheight"] - 100)
443
444        self.log.info("Testing sendall does not do anti-fee-sniping when locktime is specified")
445        self.add_utxos([10,11])
446        txid = self.wallet.sendall(recipients=[self.remainder_target], options={"locktime":0})["txid"]
447        assert_equal(self.wallet.gettransaction(txid=txid, verbose=True)["decoded"]["locktime"], 0)
448
449        self.log.info("Testing sendall does not do anti-fee-sniping when even one of the sequences is final")
450        self.add_utxos([10, 11])
451        utxos = self.wallet.listunspent()
452        utxos[0]["sequence"] = SEQUENCE_FINAL
453        txid = self.wallet.sendall(recipients=[self.remainder_target], inputs=utxos)["txid"]
454        assert_equal(self.wallet.gettransaction(txid=txid, verbose=True)["decoded"]["locktime"], 0)
455
456    # This tests needs to be the last one otherwise @cleanup will fail with "Transaction too large" error
457    def sendall_fails_with_transaction_too_large(self):
458        self.log.info("Test that sendall fails if resulting transaction is too large")
459
460        # Force the wallet to bulk-generate the addresses we'll need
461        self.wallet.keypoolrefill(1600)
462
463        # create many inputs
464        outputs = {self.wallet.getnewaddress(): 0.000025 for _ in range(1600)}
465        self.def_wallet.sendmany(amounts=outputs)
466        self.generate(self.nodes[0], 1)
467
468        assert_raises_rpc_error(
469                -4,
470                "Transaction too large.",
471                self.wallet.sendall,
472                recipients=[self.remainder_target])
473
474    def run_test(self):
475        self.nodes[0].createwallet("activewallet")
476        self.wallet = self.nodes[0].get_wallet_rpc("activewallet")
477        self.def_wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
478        self.generate(self.nodes[0], 101)
479        self.recipient = self.def_wallet.getnewaddress() # payee for a specific amount
480        self.remainder_target = self.def_wallet.getnewaddress() # address that receives everything left after payments and fees
481        self.split_target = self.def_wallet.getnewaddress() # 2nd target when splitting rest
482
483        # Test cleanup
484        self.test_cleanup()
485
486        # Basic sweep: everything to one address
487        self.sendall_two_utxos()
488
489        # Split remainder to two addresses with equal amounts
490        self.sendall_split()
491
492        # Pay recipient and sweep remainder
493        self.sendall_and_spend()
494
495        # sendall fails if no recipient has unspecified amount
496        self.sendall_invalid_recipient_addresses()
497
498        # Sendall fails if same destination is provided twice
499        self.sendall_duplicate_recipient()
500