Inside Bitcoin

751        self.test_importdesc({"desc": descsum_create(f"wsh(multi(2,{xprv1}/{change_derivation_path}/*,{xprv2}/{change_derivation_path}/*,{xprv3}/{change_derivation_path}/*))"),
752                            "active": True,
753                            "internal" : True,
754                            "range": 1000,
755                            "next_index": 0,
756                            "timestamp": "now"},
757                            success=True,
758                            wallet=wmulti_priv)
759
760        assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 1001) # Range end (1000) is inclusive, so 1001 addresses generated
761
762        addr = wmulti_priv.getnewaddress('', 'bech32') # uses receive 0
763        expected_addr = script_to_p2wsh(keys_to_multisig_script([k.derive_path("m/0").pubkey.get_bytes() for k in [acc_xpub1_key, acc_xpub2_key, acc_xpub3_key]], k=2))
764        assert_equal(addr, expected_addr) # Derived at m/84'/0'/0'/0
765
766        change_addr = wmulti_priv.getrawchangeaddress('bech32') # uses change 0
767        expected_change_addr = script_to_p2wsh(keys_to_multisig_script([k.derive_path("m/0").pubkey.get_bytes() for k in [chg_xpub1_key, chg_xpub2_key, chg_xpub3_key]], k=2))
768        assert_equal(change_addr, expected_change_addr)  # Derived at m/84'/1'/0'/0
769        assert_equal(wmulti_priv.getwalletinfo()['keypoolsize'], 1000)
770
771        txid = w0.sendtoaddress(addr, 10)
772        self.generate(self.nodes[0], 6)
773        send_txid = wmulti_priv.sendtoaddress(w0.getnewaddress(), 8) # uses change 1
774        decoded = wmulti_priv.gettransaction(txid=send_txid, verbose=True)['decoded']
775        assert_equal(len(decoded['vin'][0]['txinwitness']), 4)
776        self.sync_all()
777
778        self.nodes[1].createwallet(wallet_name="wmulti_pub", disable_private_keys=True, blank=True)
779        wmulti_pub = self.nodes[1].get_wallet_rpc("wmulti_pub")
780        assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 0)
781
782        self.test_importdesc({"desc": descsum_create(f"wsh(multi(2,[{xprv1_fingerprint}/{derivation_path}]{acc_xpub1}/*,[{xprv2_fingerprint}/{derivation_path}]{acc_xpub2}/*,[{xprv3_fingerprint}/{derivation_path}]{acc_xpub3}/*))"),
783                            "active": True,
784                            "range": 1000,
785                            "next_index": 0,
786                            "timestamp": "now"},
787                            success=True,
788                            wallet=wmulti_pub)
789        self.test_importdesc({"desc": descsum_create(f"wsh(multi(2,[{xprv1_fingerprint}/{change_derivation_path}]{chg_xpub1}/*,[{xprv2_fingerprint}/{change_derivation_path}]{chg_xpub2}/*,[{xprv3_fingerprint}/{change_derivation_path}]{chg_xpub3}/*))"),
790                            "active": True,
791                            "internal" : True,
792                            "range": 1000,
793                            "next_index": 0,
794                            "timestamp": "now"},
795                            success=True,
796                            wallet=wmulti_pub)
797
798        assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 1000) # The first one was already consumed by previous import and is detected as used
799        addr = wmulti_pub.getnewaddress('', 'bech32') # uses receive 1
800        expected_addr = script_to_p2wsh(keys_to_multisig_script([k.derive_path("m/1").pubkey.get_bytes() for k in [acc_xpub1_key, acc_xpub2_key, acc_xpub3_key]], k=2))
801        assert_equal(addr, expected_addr) # Derived at m/84'/0'/0'/1
802        assert_equal(wmulti_pub.getaddressinfo(addr)["desc"].count(f"{derivation_path}/1"), 3) # Derived at m/84h/0h/0h/1 for all three keys
803        change_addr = wmulti_pub.getrawchangeaddress('bech32') # uses change 2
804        expected_change_addr = script_to_p2wsh(keys_to_multisig_script([k.derive_path("m/2").pubkey.get_bytes() for k in [chg_xpub1_key, chg_xpub2_key, chg_xpub3_key]], k=2))
805        assert_equal(change_addr, expected_change_addr)  # Derived at m/84'/1'/0'/2
806        assert_equal(wmulti_pub.getaddressinfo(change_addr)["desc"].count(f"{change_derivation_path}/2"), 3) # Derived at m/84h/1h/0h/1 for all three keys
807        assert send_txid in self.nodes[0].getrawmempool(True)
808        assert send_txid in (x['txid'] for x in wmulti_pub.listunspent(0))
809        assert_equal(wmulti_pub.getwalletinfo()['keypoolsize'], 999)
810
811        # generate some utxos for next tests
812        utxo = self.create_outpoints(w0, outputs=[{addr: 10}])[0]
813
814        addr2 = wmulti_pub.getnewaddress('', 'bech32')
815        utxo2 = self.create_outpoints(w0, outputs=[{addr2: 10}])[0]
816
817        self.generate(self.nodes[0], 6)
818        assert_equal(wmulti_pub.getbalance(), wmulti_priv.getbalance())
819
820        # Make sure that descriptor wallets containing multiple xpubs in a single descriptor load correctly
821        wmulti_pub.unloadwallet()
822        self.nodes[1].loadwallet('wmulti_pub')
823
824        self.log.info("Multisig with distributed keys")
825        self.nodes[1].createwallet(wallet_name="wmulti_priv1")
826        wmulti_priv1 = self.nodes[1].get_wallet_rpc("wmulti_priv1")
827        res = wmulti_priv1.importdescriptors([
828        {
829            "desc": descsum_create(f"wsh(multi(2,{xprv1}/{derivation_path}/*,[{xprv2_fingerprint}/{derivation_path}]{acc_xpub2}/*,[{xprv3_fingerprint}/{derivation_path}]{acc_xpub3}/*))"),
830            "active": True,
831            "range": 1000,
832            "next_index": 0,
833            "timestamp": "now"
834        },
835        {
836            "desc": descsum_create(f"wsh(multi(2,{xprv1}/{change_derivation_path}/*,[{xprv2_fingerprint}/{change_derivation_path}]{chg_xpub2}/*,[{xprv3_fingerprint}/{change_derivation_path}]{chg_xpub3}/*))"),
837            "active": True,
838            "internal" : True,
839            "range": 1000,
840            "next_index": 0,
841            "timestamp": "now"
842        }])
843        assert_equal(res[0]['success'], True)
844        assert_equal(res[0]['warnings'][0], MISSING_KEYS_WARNING)
845        assert_equal(res[1]['success'], True)
846        assert_equal(res[1]['warnings'][0], MISSING_KEYS_WARNING)
847
848        self.nodes[1].createwallet(wallet_name='wmulti_priv2', blank=True)
849        wmulti_priv2 = self.nodes[1].get_wallet_rpc('wmulti_priv2')
850        res = wmulti_priv2.importdescriptors([
851        {
852            "desc": descsum_create(f"wsh(multi(2,[{xprv1_fingerprint}/{derivation_path}]{acc_xpub1}/*,{xprv2}/{derivation_path}/*,[{xprv3_fingerprint}/{derivation_path}]{acc_xpub3}/*))"),
853            "active": True,
854            "range": 1000,
855            "next_index": 0,
856            "timestamp": "now"
857        },
858        {
859            "desc": descsum_create(f"wsh(multi(2,[{xprv1_fingerprint}/{change_derivation_path}]{chg_xpub1}/*,{xprv2}/{change_derivation_path}/*,[{xprv3_fingerprint}/{change_derivation_path}]{chg_xpub3}/*))"),
860            "active": True,
861            "internal" : True,
862            "range": 1000,
863            "next_index": 0,
864            "timestamp": "now"
865        }])
866        assert_equal(res[0]['success'], True)
867        assert_equal(res[0]['warnings'][0], MISSING_KEYS_WARNING)
868        assert_equal(res[1]['success'], True)
869        assert_equal(res[1]['warnings'][0], MISSING_KEYS_WARNING)
870
871        rawtx = self.nodes[1].createrawtransaction([utxo], {w0.getnewaddress(): 9.999})
872        tx_signed_1 = wmulti_priv1.signrawtransactionwithwallet(rawtx)
873        assert_equal(tx_signed_1['complete'], False)
874        tx_signed_2 = wmulti_priv2.signrawtransactionwithwallet(tx_signed_1['hex'])
875        assert_equal(tx_signed_2['complete'], True)
876        self.nodes[1].sendrawtransaction(tx_signed_2['hex'])
877
878        self.log.info("We can create and use a huge multisig under P2WSH")
879        self.nodes[1].createwallet(wallet_name='wmulti_priv_big', blank=True)
880        wmulti_priv_big = self.nodes[1].get_wallet_rpc('wmulti_priv_big')
881        xprv = ExtendedPrivateKey.generate().to_string()
882        xkey = f"{xprv}/*"
883        xkey_int = f"{xprv}/1/*"
884        res = wmulti_priv_big.importdescriptors([
885        {
886            "desc": descsum_create(f"wsh(sortedmulti(20,{(xkey + ',') * 19}{xkey}))"),
887            "active": True,
888            "range": 1000,
889            "next_index": 0,
890            "timestamp": "now"
891        },
892        {
893            "desc": descsum_create(f"wsh(sortedmulti(20,{(xkey_int + ',') * 19}{xkey_int}))"),
894            "active": True,
895            "internal": True,
896            "range": 1000,
897            "next_index": 0,
898            "timestamp": "now"
899        }])
900        assert_equal(res[0]['success'], True)
901        assert_equal(res[1]['success'], True)
902
903        addr = wmulti_priv_big.getnewaddress()
904        w0.sendtoaddress(addr, 10)
905        self.generate(self.nodes[0], 1)
906        # It is standard and would relay.
907        txid = wmulti_priv_big.sendtoaddress(w0.getnewaddress(), 9.999)
908        decoded = wmulti_priv_big.gettransaction(txid=txid, verbose=True)['decoded']
909        # 20 sigs + dummy + witness script
910        assert_equal(len(decoded['vin'][0]['txinwitness']), 22)
911
912
913        self.log.info("Under P2SH, multisig are standard with up to 15 "
914                      "compressed keys")
915        self.nodes[1].createwallet(wallet_name='multi_priv_big_legacy',
916                                   blank=True)
917        multi_priv_big = self.nodes[1].get_wallet_rpc('multi_priv_big_legacy')
918        res = multi_priv_big.importdescriptors([
919        {
920            "desc": descsum_create(f"sh(multi(15,{(xkey + ',') * 14}{xkey}))"),
921            "active": True,
922            "range": 1000,
923            "next_index": 0,
924            "timestamp": "now"
925        },
926        {
927            "desc": descsum_create(f"sh(multi(15,{(xkey_int + ',') * 14}{xkey_int}))"),
928            "active": True,
929            "internal": True,
930            "range": 1000,
931            "next_index": 0,
932            "timestamp": "now"
933        }])
934        assert_equal(res[0]['success'], True)
935        assert_equal(res[1]['success'], True)
936
937        addr = multi_priv_big.getnewaddress("", "legacy")
938        w0.sendtoaddress(addr, 10)
939        self.generate(self.nodes[0], 6)
940        # It is standard and would relay.
941        txid = multi_priv_big.sendtoaddress(w0.getnewaddress(), 10, "", "", True)
942        decoded = multi_priv_big.gettransaction(txid=txid, verbose=True)['decoded']
943
944        self.log.info("Amending multisig with new private keys")
945        self.nodes[1].createwallet(wallet_name="wmulti_priv3")
946        wmulti_priv3 = self.nodes[1].get_wallet_rpc("wmulti_priv3")
947        res = wmulti_priv3.importdescriptors([
948            {
949                "desc": descsum_create(f"wsh(multi(2,{xprv1}/{derivation_path}/*,[{xprv2_fingerprint}/{derivation_path}]{acc_xpub2}/*,[{xprv3_fingerprint}/{derivation_path}]{acc_xpub3}/*))"),
950                "active": True,
951                "range": 1000,
952                "next_index": 0,
953                "timestamp": "now"
954            }])
955        assert_equal(res[0]['success'], True)
956        res = wmulti_priv3.importdescriptors([
957            {
958                "desc": descsum_create(f"wsh(multi(2,{xprv1}/{derivation_path}/*,[{xprv2_fingerprint}/{derivation_path}]{acc_xprv2}/*,[{xprv3_fingerprint}/{derivation_path}]{acc_xpub3}/*))"),
959                "active": True,
960                "range": 1000,
961                "next_index": 0,
962                "timestamp": "now"
963            }])
964        assert_equal(res[0]['success'], True)
965
966        rawtx = self.nodes[1].createrawtransaction([utxo2], {w0.getnewaddress(): 9.999})
967        tx = wmulti_priv3.signrawtransactionwithwallet(rawtx)
968        assert_equal(tx['complete'], True)
969        self.nodes[1].sendrawtransaction(tx['hex'])
970
971        self.log.info("Combo descriptors cannot be active")
972        self.test_importdesc({"desc": descsum_create(f"combo({ExtendedPrivateKey.generate().pubkey().to_string()}/*)"),
973                              "active": True,
974                              "range": 1,
975                              "timestamp": "now"},
976                              success=False,
977                              error_code=-4,
978                              error_message="Combo descriptors cannot be set to active")
979
980        self.log.info("Descriptors with no type cannot be active")
981        self.test_importdesc({"desc": descsum_create(f"pk({ExtendedPrivateKey.generate().pubkey().to_string()}/*)"),
982                              "active": True,
983                              "range": 1,
984                              "timestamp": "now"},
985                              success=True,
986                              warnings=["Unknown output type, cannot set descriptor to active."])
987
988        self.log.info("Test importing a descriptor to an encrypted wallet")
989
990        descriptor = {"desc": descsum_create("pkh(" + xpriv + "/1h/*h)"),
991                              "timestamp": "now",
992                              "active": True,
993                              "range": [0,4000],
994                              "next_index": 4000}
995
996        self.nodes[0].createwallet("temp_wallet", blank=True)
997        temp_wallet = self.nodes[0].get_wallet_rpc("temp_wallet")
998        temp_wallet.importdescriptors([descriptor])
999        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, temp_wallet.getnewaddress())
1000        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, temp_wallet.getnewaddress())