Inside Bitcoin

501
502        assert_equal(decoded_tx["version"], 3)
503
504        assert confirmed_v3 in decoded_vin_txids
505        assert confirmed_v2 in decoded_vin_txids
506        assert unconfirmed_v3 in decoded_vin_txids
507        assert unconfirmed_v2 not in decoded_vin_txids
508
509        # Test that the only unconfirmed inputs this v2 tx spends are v2
510        tx_hex = self.alice.sendall([self.bob.getnewaddress()], version=2, add_to_wallet=False, minconf=0)["hex"]
511
512        decoded_tx = self.alice.decoderawtransaction(tx_hex)
513        decoded_vin_txids = [txin["txid"] for txin in decoded_tx["vin"]]
514
515        assert_equal(decoded_tx["version"], 2)
516
517        assert confirmed_v3 in decoded_vin_txids
518        assert confirmed_v2 in decoded_vin_txids
519        assert unconfirmed_v2 in decoded_vin_txids
520        assert unconfirmed_v3 not in decoded_vin_txids
521
522    @cleanup
523    def walletcreatefundedpsbt_v3(self):
524        self.log.info("Test setting version to 3 with walletcreatefundedpsbt")
525
526        outputs = {self.alice.getnewaddress() : 10}
527        psbt = self.charlie.walletcreatefundedpsbt(inputs=[], outputs=outputs, version=3)["psbt"]
528        assert_equal(self.charlie.decodepsbt(psbt)["tx_version"], 3)
529
530    @cleanup
531    def sendall_truc_weight_limit(self):
532        self.log.info("Test that sendall follows truc tx weight limit")
533        self.charlie.sendall([self.alice.getnewaddress() for _ in range(300)], add_to_wallet=False, version=2)
534
535        # check that error is only raised if version is 3
536        assert_raises_rpc_error(
537                -4,
538                "Transaction too large" ,
539                self.charlie.sendall,
540                [self.alice.getnewaddress() for _ in range(300)],
541                version=3
542            )
543
544    @cleanup
545    def sendall_truc_child_weight_limit(self):
546        self.log.info("Test that sendall follows spending unconfirmed truc tx weight limit")
547        outputs = {self.charlie.getnewaddress() : 2.0}
548        self.send_tx(self.charlie, [], outputs, 3)
549
550        self.charlie.sendall([self.alice.getnewaddress() for _ in range(50)], add_to_wallet=False)
551
552        assert_raises_rpc_error(
553                -4,
554                "Transaction too large" ,
555                self.charlie.sendall,
556                [self.alice.getnewaddress() for _ in range(50)],
557                version=3
558            )
559
560    @cleanup
561    def mix_non_truc_versions(self):
562        self.log.info("Test that we can mix non-truc versions when spending an unconfirmed output")
563
564        outputs = {self.bob.getnewaddress() : 2.0}
565        self.send_tx(self.charlie, [], outputs, 1)
566
567        assert_equal(self.bob.getbalances()["mine"]["trusted"], 0)
568        assert_greater_than(self.bob.getbalances()["mine"]["untrusted_pending"], 0)
569
570        outputs = {self.alice.getnewaddress() : 1.0}
571
572        raw_tx_v2 = self.bob.createrawtransaction(inputs=[], outputs=outputs, version=2)
573
574        # does not throw an error
575        self.bob.fundrawtransaction(raw_tx_v2, {'include_unsafe': True})["hex"]
576
577    @cleanup
578    def cant_spend_multiple_unconfirmed_truc_outputs(self):
579        self.log.info("Test that we can't spend multiple unconfirmed truc outputs")
580
581        outputs = {self.alice.getnewaddress(): 2.00001}
582        self.send_tx(self.charlie, [], outputs, 3)
583        self.send_tx(self.charlie, [], outputs, 3)
584
585        assert_equal(len(self.alice.listunspent(minconf=0)), 2)
586
587        outputs = {self.bob.getnewaddress() : 3.0}
588
589        raw_tx = self.alice.createrawtransaction(inputs=[], outputs=outputs, version=3)
590
591        assert_raises_rpc_error(
592                -4,
593                "Insufficient funds",
594                self.alice.fundrawtransaction,
595                raw_tx,
596                {'include_unsafe' : True}
597        )
598
599    @cleanup
600    def test_spend_third_generation(self):
601        self.log.info("Test that we can't spend an unconfirmed TRUC output that already has an unconfirmed parent")
602
603        # Generation 1: Consolidate all UTXOs into one output using sendall
604        self.charlie.sendall([self.charlie.getnewaddress()], version=3)
605        outputs1 = self.charlie.listunspent(minconf=0)
606        assert_equal(len(outputs1), 1)
607
608        # Generation 2: to ensure no change address is created, do another sendall
609        self.charlie.sendall([self.charlie.getnewaddress()], version=3)
610        outputs2 = self.charlie.listunspent(minconf=0)
611        assert_equal(len(outputs2), 1)
612        total_amount = sum([utxo['amount'] for utxo in outputs2])
613
614        # Generation 3: try to send half of total amount to Alice
615        outputs = {self.alice.getnewaddress(): total_amount / 2}
616        assert_raises_rpc_error(
617                -4,
618                "Insufficient funds",
619                self.charlie.send,
620                outputs,
621                version=3
622        )
623
624        # Also doesn't work with fundrawtransaction
625        raw_tx = self.charlie.createrawtransaction(inputs=[], outputs=outputs, version=3)
626        assert_raises_rpc_error(
627                -4,
628                "Insufficient funds",
629                self.charlie.fundrawtransaction,
630                raw_tx,
631                {'include_unsafe' : True}
632        )
633
634        # Also doesn't work with sendall
635        assert_raises_rpc_error(
636                -6,
637                "Total value of UTXO pool too low to pay for transaction",
638                self.charlie.sendall,
639                [self.alice.getnewaddress()],
640                version=3
641        )
642
643    @cleanup
644    def test_coins_availability_reorg(self):
645        self.log.info("Test coin availability after reorg with v2 parent and truc child")
646
647        # Prep fork blocks
648        fork_blocks = create_empty_fork(self.nodes[0])
649
650        # Send funds to alice so she can create transactions
651        outputs = {self.alice.getnewaddress(): 5.0}
652        self.send_tx(self.charlie, [], outputs, 2)
653        self.generate(self.nodes[0], 1)
654
655        # Alice creates a v2 transaction with 2 outputs
656        alice_unspent = self.alice.listunspent()[0]
657        v2_outputs = [
658            {self.alice.getnewaddress(): 2.5},
659            {self.alice.getnewaddress(): 2.4999},
660        ]
661        v2_txid = self.send_tx(self.alice, [alice_unspent], v2_outputs, 2)
662
663        # Mine the v2 transaction in one block
664        self.generate(self.nodes[0], 1)
665
666        # Get the output from the v2 transaction for chaining
667        v2_utxo = self.alice.listunspent(minconf=1)[0]
668        assert_equal(v2_utxo["txid"], v2_txid)
669
670        # Alice creates a truc child chaining from the v2 utxo
671        truc_outputs = {self.alice.getnewaddress(): v2_utxo["amount"] - Decimal("0.0001")}
672        truc_txid = self.send_tx(self.alice, [v2_utxo], truc_outputs, 3)
673
674        # Mine the truc transaction in a second block
675        self.generate(self.nodes[0], 1)
676
677        # Verify both transactions are confirmed
678        wallet_tx_v2 = self.alice.gettransaction(v2_txid)
679        wallet_tx_truc = self.alice.gettransaction(truc_txid)
680
681        assert_equal(wallet_tx_v2["confirmations"], 2)
682        assert_equal(wallet_tx_truc["confirmations"], 1)
683
684        # Check that their versions are correct
685        assert_equal(self.alice.decoderawtransaction(wallet_tx_v2["hex"])["version"], 2)
686        assert_equal(self.alice.decoderawtransaction(wallet_tx_truc["hex"])["version"], 3)
687
688        # Check listunspent before reorg - should have the truc output
689        unspent_before = self.alice.listunspent()
690        truc_output_txids = [u["txid"] for u in unspent_before]
691        assert truc_txid in truc_output_txids
692
693        # Trigger the reorg
694        self.trigger_reorg(fork_blocks)
695        # The TRUC transaction is now in a cluster of size 3, which is only permitted in a reorg.
696        assert_equal(self.nodes[0].getmempoolcluster(truc_txid)["txcount"], 3)
697
698        # After reorg, both transactions should be back in mempool
699        mempool = self.nodes[0].getrawmempool()
700        assert v2_txid in mempool
701        assert truc_txid in mempool
702
703        # Check listunspent after reorg - the truc output should still appear
704        # as unconfirmed since the transaction is in the mempool
705        unspent_after = self.alice.listunspent(minconf=0)
706        unspent_txids_after = [u["txid"] for u in unspent_after]
707        assert truc_txid in unspent_txids_after
708
709        total_unconfirmed_amount = sum([u["amount"] for u in self.alice.listunspent(minconf=0)])
710        # We cannot create a transaction spending both outputs, regardless of version.
711        output_too_high = {self.bob.getnewaddress(): total_unconfirmed_amount - Decimal("1")}
712        for version in [2, 3]:
713            raw_output_too_high = self.alice.createrawtransaction(inputs=[], outputs=output_too_high, version=version)
714            assert_raises_rpc_error(
715                    -4,
716                    "Insufficient funds",
717                    self.alice.fundrawtransaction,
718                    raw_output_too_high,
719                    {'include_unsafe' : True}
720            )
721
722        # Now try to create a v2 transaction - this triggers AvailableCoins with
723        # check_version_trucness=true. The v2 parent has truc_child_in_mempool set
724        # because the truc child is in mempool.
725        new_v2_outputs = {self.bob.getnewaddress(): 0.1}
726        raw_v2_child = self.alice.createrawtransaction(inputs=[], outputs=new_v2_outputs, version=2)
727        raw_v2_with_v3_sibling = self.alice.fundrawtransaction(raw_v2_child, {'include_unsafe': True})
728
729        # See that this transaction can be added to mempool
730        signed_raw_v2_with_v3_sibling = self.alice.signrawtransactionwithwallet(raw_v2_with_v3_sibling["hex"])
731        self.alice.sendrawtransaction(signed_raw_v2_with_v3_sibling["hex"])
732
733        # This TRUC transaction is in a cluster of size 4
734        assert_equal(self.nodes[0].getmempoolcluster(truc_txid)["txcount"], 4)
735
736
737
738if __name__ == '__main__':
739    WalletV3Test(__file__).main()
740