Inside Bitcoin

501        outputs = {mSigObj:1.1}
502        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
503        fundedTx = self.nodes[0].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
504
505        # Create same transaction over sendtoaddress.
506        txId = self.nodes[0].sendtoaddress(mSigObj, 1.1, fee_rate=self.fee_rate_sats_per_vb)
507        signedFee = self.nodes[0].getmempoolentry(txId)['fees']['base']
508
509        # Compare fee.
510        feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
511        assert feeDelta >= 0 and feeDelta <= self.fee_tolerance
512
513        self.unlock_utxos(self.nodes[0])
514
515    def test_fee_4of5(self):
516        """Compare fee of a standard pubkeyhash transaction."""
517        self.log.info("Test fundrawtxn fee with 4-of-5 addresses")
518        self.lock_outputs_type(self.nodes[0], "p2pkh")
519
520        # Create 4-of-5 addr.
521        addr1 = self.nodes[1].getnewaddress()
522        addr2 = self.nodes[1].getnewaddress()
523        addr3 = self.nodes[1].getnewaddress()
524        addr4 = self.nodes[1].getnewaddress()
525        addr5 = self.nodes[1].getnewaddress()
526
527        addr1Obj = self.nodes[1].getaddressinfo(addr1)
528        addr2Obj = self.nodes[1].getaddressinfo(addr2)
529        addr3Obj = self.nodes[1].getaddressinfo(addr3)
530        addr4Obj = self.nodes[1].getaddressinfo(addr4)
531        addr5Obj = self.nodes[1].getaddressinfo(addr5)
532
533        mSigObj = self.nodes[1].createmultisig(
534            4,
535            [
536                addr1Obj['pubkey'],
537                addr2Obj['pubkey'],
538                addr3Obj['pubkey'],
539                addr4Obj['pubkey'],
540                addr5Obj['pubkey'],
541            ]
542        )['address']
543
544        inputs = []
545        outputs = {mSigObj:1.1}
546        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
547        fundedTx = self.nodes[0].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
548
549        # Create same transaction over sendtoaddress.
550        txId = self.nodes[0].sendtoaddress(mSigObj, 1.1, fee_rate=self.fee_rate_sats_per_vb)
551        signedFee = self.nodes[0].getmempoolentry(txId)['fees']['base']
552
553        # Compare fee.
554        feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
555        assert feeDelta >= 0 and feeDelta <= self.fee_tolerance
556
557        self.unlock_utxos(self.nodes[0])
558
559    def test_spend_2of2(self):
560        """Spend a 2-of-2 multisig transaction over fundraw."""
561        self.log.info("Test fundpsbt spending 2-of-2 multisig")
562
563        # Create 2-of-2 addr.
564        addr1 = self.nodes[2].getnewaddress()
565        addr2 = self.nodes[2].getnewaddress()
566
567        addr1Obj = self.nodes[2].getaddressinfo(addr1)
568        addr2Obj = self.nodes[2].getaddressinfo(addr2)
569
570        self.nodes[2].createwallet(wallet_name='wmulti', disable_private_keys=True)
571        wmulti = self.nodes[2].get_wallet_rpc('wmulti')
572        w2 = self.nodes[2].get_wallet_rpc(self.default_wallet_name)
573        mSigObj = self.nodes[2].createmultisig(
574            2,
575            [
576                addr1Obj['pubkey'],
577                addr2Obj['pubkey'],
578            ]
579        )
580        import_res = wmulti.importdescriptors([{"desc": mSigObj["descriptor"], "timestamp": "now"}])
581        assert_equal(import_res[0]["success"], True)
582
583        # Send 1.2 BTC to msig addr.
584        self.nodes[0].sendtoaddress(mSigObj["address"], 1.2, fee_rate=self.fee_rate_sats_per_vb)
585        self.generate(self.nodes[0], 1)
586
587        oldBalance = self.nodes[1].getbalance()
588        inputs = []
589        outputs = {self.nodes[1].getnewaddress():1.1}
590        funded_psbt = wmulti.walletcreatefundedpsbt(inputs=inputs, outputs=outputs, changeAddress=w2.getrawchangeaddress())['psbt']
591
592        signed_psbt = w2.walletprocesspsbt(funded_psbt)
593        self.nodes[2].sendrawtransaction(signed_psbt['hex'])
594        self.generate(self.nodes[2], 1)
595
596        # Make sure funds are received at node1.
597        assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance())
598
599        wmulti.unloadwallet()
600
601    def test_locked_wallet(self):
602        self.log.info("Test fundrawtxn with locked wallet and hardened derivation")
603
604        df_wallet = self.nodes[1].get_wallet_rpc(self.default_wallet_name)
605        self.nodes[1].createwallet(wallet_name="locked_wallet")
606        wallet = self.nodes[1].get_wallet_rpc("locked_wallet")
607
608        # Add some balance to the wallet (this will be reverted at the end of the test)
609        df_wallet.sendall(recipients=[wallet.getnewaddress()])
610        self.generate(self.nodes[1], 1)
611
612        # Encrypt wallet and import descriptors
613        wallet.encryptwallet("test")
614
615        with WalletUnlock(wallet, "test"):
616            wallet.importdescriptors([{
617                'desc': descsum_create(f'wpkh({ExtendedPrivateKey.generate().to_string()}/0h/*h)'),
618                'timestamp': 'now',
619                'active': True
620            },
621            {
622                'desc': descsum_create(f'wpkh({ExtendedPrivateKey.generate().to_string()}/1h/*h)'),
623                'timestamp': 'now',
624                'active': True,
625                'internal': True
626            }])
627
628        # Drain the keypool.
629        wallet.getnewaddress()
630        wallet.getrawchangeaddress()
631
632        # Choose input
633        inputs = wallet.listunspent()
634
635        # Deduce exact fee to produce a changeless transaction
636        tx_size = 110  # Total tx size: 110 vbytes, p2wpkh -> p2wpkh. Input 68 vbytes + rest of tx is 42 vbytes.
637        value = inputs[0]["amount"] - get_fee(tx_size, self.min_relay_tx_fee)
638
639        outputs = {self.nodes[0].getnewaddress():value}
640        rawtx = wallet.createrawtransaction(inputs, outputs)
641        # fund a transaction that does not require a new key for the change output
642        funded_tx = wallet.fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
643        assert_equal(funded_tx["changepos"], -1)
644
645        # fund a transaction that requires a new key for the change output
646        # creating the key must be impossible because the wallet is locked
647        outputs = {self.nodes[0].getnewaddress():value - Decimal("0.1")}
648        rawtx = wallet.createrawtransaction(inputs, outputs)
649        assert_raises_rpc_error(-4, "Transaction needs a change address, but we can't generate it.", wallet.fundrawtransaction, rawtx)
650
651        # Refill the keypool.
652        with WalletUnlock(wallet, "test"):
653            wallet.keypoolrefill(8) #need to refill the keypool to get an internal change address
654
655        assert_raises_rpc_error(-13, "walletpassphrase", wallet.sendtoaddress, self.nodes[0].getnewaddress(), 1.2)
656
657        oldBalance = self.nodes[0].getbalance()
658
659        inputs = []
660        outputs = {self.nodes[0].getnewaddress():1.1}
661        rawtx = wallet.createrawtransaction(inputs, outputs)
662
663        fundedTx = wallet.fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
664        assert_not_equal(fundedTx["changepos"], -1)
665
666        # Now we need to unlock.
667        with WalletUnlock(wallet, "test"):
668            signedTx = wallet.signrawtransactionwithwallet(fundedTx['hex'])
669            wallet.sendrawtransaction(signedTx['hex'])
670            self.generate(self.nodes[1], 1)
671
672            # Make sure funds are received at node1.
673            assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance())
674
675            # Restore pre-test wallet state
676            wallet.sendall(recipients=[df_wallet.getnewaddress(), df_wallet.getnewaddress(), df_wallet.getnewaddress()], fee_rate=self.fee_rate_sats_per_vb)
677        wallet.unloadwallet()
678        self.generate(self.nodes[1], 1)
679
680    def test_many_inputs_fee(self):
681        """Multiple (~19) inputs tx test | Compare fee."""
682        self.log.info("Test fundrawtxn fee with many inputs")
683
684        # Empty node1, send some small coins from node0 to node1.
685        self.nodes[1].sendall(recipients=[self.nodes[0].getnewaddress()], fee_rate=self.fee_rate_sats_per_vb)
686        self.generate(self.nodes[1], 1)
687
688        for _ in range(20):
689            self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01, fee_rate=self.fee_rate_sats_per_vb)
690        self.generate(self.nodes[0], 1)
691
692        # Fund a tx with ~20 small inputs.
693        inputs = []
694        outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
695        rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
696        fundedTx = self.nodes[1].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
697
698        # Create same transaction over sendtoaddress.
699        txId = self.nodes[1].sendmany("", outputs, fee_rate=self.fee_rate_sats_per_vb)
700        signedFee = self.nodes[1].getmempoolentry(txId)['fees']['base']
701
702        # Compare fee.
703        feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
704        assert feeDelta >= 0 and feeDelta <= self.fee_tolerance * 19  #~19 inputs
705
706    def test_many_inputs_send(self):
707        """Multiple (~19) inputs tx test | sign/send."""
708        self.log.info("Test fundrawtxn sign+send with many inputs")
709
710        # Again, empty node1, send some small coins from node0 to node1.
711        self.nodes[1].sendall(recipients=[self.nodes[0].getnewaddress()], fee_rate=self.fee_rate_sats_per_vb)
712        self.generate(self.nodes[1], 1)
713
714        for _ in range(20):
715            self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01, fee_rate=self.fee_rate_sats_per_vb)
716        self.generate(self.nodes[0], 1)
717
718        # Fund a tx with ~20 small inputs.
719        oldBalance = self.nodes[0].getbalance()
720
721        inputs = []
722        outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
723        rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
724        fundedTx = self.nodes[1].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
725        fundedAndSignedTx = self.nodes[1].signrawtransactionwithwallet(fundedTx['hex'])
726        self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
727        self.generate(self.nodes[1], 1)
728        assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()) #0.19+block reward
729
730    def test_op_return(self):
731        self.log.info("Test fundrawtxn with OP_RETURN and no vin")
732
733        rawtx   = "0100000000010000000000000000066a047465737400000000"
734        dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
735
736        assert_equal(len(dec_tx['vin']), 0)
737        assert_equal(len(dec_tx['vout']), 1)
738
739        rawtxfund = self.nodes[2].fundrawtransaction(rawtx, fee_rate=self.fee_rate_sats_per_vb)
740        dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
741
742        assert_greater_than(len(dec_tx['vin']), 0) # at least one vin
743        assert_equal(len(dec_tx['vout']), 2) # one change output added
744
745    def test_watchonly(self):
746        self.log.info("Test fundrawtxn using only watchonly")
747
748        inputs = []
749        outputs = {self.nodes[2].getnewaddress(): self.watchonly_amount / 2}
750        rawtx = self.nodes[3].createrawtransaction(inputs, outputs)