friend class CAddrManTest;         nTried -= nLost;          // Store positions in the new table buckets to apply later (if possible).-        std::map<int, int> entryToBucket; // Represents which entry belonged to which bucket when serializing--        for (int bucket = 0; bucket < nUBuckets; bucket++) {-            int nSize = 0;-            s >> nSize;-            for (int n = 0; n < nSize; n++) {-                int nIndex = 0;-                s >> nIndex;-                if (nIndex >= 0 && nIndex < nNew) {-                    entryToBucket[nIndex] = bucket;+        // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,+        // so we store all bucket-entry_index pairs to iterate through later.+        std::vector<std::pair<int, int>> bucket_entries;++        for (int bucket = 0; bucket < nUBuckets; ++bucket) {+            int num_entries{0};+            s >> num_entries;+            for (int n = 0; n < num_entries; ++n) {+                int entry_index{0};+                s >> entry_index;+                if (entry_index >= 0 && entry_index < nNew) {+                    bucket_entries.emplace_back(bucket, entry_index);                 }             }         } -        uint256 supplied_asmap_version;+        // If the bucket count and asmap checksum haven't changed, then attempt+        // to restore the entries to the buckets/positions they were in before+        // serialization.+        uint256 supplied_asmap_checksum;         if (m_asmap.size() != 0) {-            supplied_asmap_version = SerializeHash(m_asmap);+            supplied_asmap_checksum = SerializeHash(m_asmap);         }-        uint256 serialized_asmap_version;+        uint256 serialized_asmap_checksum;         if (format >= Format::V2_ASMAP) {-            s >> serialized_asmap_version;+            s >> serialized_asmap_checksum;         }+        const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&+                                     serialized_asmap_checksum == supplied_asmap_checksum}; -        for (int n = 0; n < nNew; n++) {-            CAddrInfo &info = mapInfo[n];-            int bucket = entryToBucket[n];-            int nUBucketPos = info.GetBucketPosition(nKey, true, bucket);-            if (format >= Format::V2_ASMAP && nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && vvNew[bucket][nUBucketPos] == -1 &&-                info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS && serialized_asmap_version == supplied_asmap_version) {+        for (auto bucket_entry : bucket_entries) {+            int bucket{bucket_entry.first};+            const int entry_index{bucket_entry.second};+            CAddrInfo& info = mapInfo[entry_index];++            // The entry shouldn't appear in more than+            // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip+            // this bucket_entry.+            if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;++            int bucket_position = info.GetBucketPosition(nKey, true, bucket);+            if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {

 friend class CAddrManTest;         nTried -= nLost;          // Store positions in the new table buckets to apply later (if possible).-        std::map<int, int> entryToBucket; // Represents which entry belonged to which bucket when serializing--        for (int bucket = 0; bucket < nUBuckets; bucket++) {-            int nSize = 0;-            s >> nSize;-            for (int n = 0; n < nSize; n++) {-                int nIndex = 0;-                s >> nIndex;-                if (nIndex >= 0 && nIndex < nNew) {-                    entryToBucket[nIndex] = bucket;+        // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,+        // so we store all bucket-entry_index pairs to iterate through later.+        std::vector<std::pair<int, int>> bucket_entries;++        for (int bucket = 0; bucket < nUBuckets; ++bucket) {+            int num_entries{0};+            s >> num_entries;+            for (int n = 0; n < num_entries; ++n) {+                int entry_index{0};+                s >> entry_index;+                if (entry_index >= 0 && entry_index < nNew) {+                    bucket_entries.emplace_back(bucket, entry_index);                 }             }         } -        uint256 supplied_asmap_version;+        // If the bucket count and asmap checksum haven't changed, then attempt+        // to restore the entries to the buckets/positions they were in before+        // serialization.+        uint256 supplied_asmap_checksum;         if (m_asmap.size() != 0) {-            supplied_asmap_version = SerializeHash(m_asmap);+            supplied_asmap_checksum = SerializeHash(m_asmap);         }-        uint256 serialized_asmap_version;+        uint256 serialized_asmap_checksum;         if (format >= Format::V2_ASMAP) {-            s >> serialized_asmap_version;+            s >> serialized_asmap_checksum;         }+        const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&+                                     serialized_asmap_checksum == supplied_asmap_checksum}; -        for (int n = 0; n < nNew; n++) {-            CAddrInfo &info = mapInfo[n];-            int bucket = entryToBucket[n];-            int nUBucketPos = info.GetBucketPosition(nKey, true, bucket);-            if (format >= Format::V2_ASMAP && nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && vvNew[bucket][nUBucketPos] == -1 &&-                info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS && serialized_asmap_version == supplied_asmap_version) {+        for (auto bucket_entry : bucket_entries) {+            int bucket{bucket_entry.first};+            const int entry_index{bucket_entry.second};+            CAddrInfo& info = mapInfo[entry_index];++            // The entry shouldn't appear in more than+            // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip+            // this bucket_entry.+            if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;++            int bucket_position = info.GetBucketPosition(nKey, true, bucket);+            if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {                 // Bucketing has not changed, using existing bucket positions for the new table-                vvNew[bucket][nUBucketPos] = n;-                info.nRefCount++;+                vvNew[bucket][bucket_position] = entry_index;+                ++info.nRefCount;             } else {-                // In case the new table data cannot be used (format unknown, bucket count wrong or new asmap),+                // In case the new table data cannot be used (bucket count wrong or new asmap),                 // try to give them a reference based on their primary source address.                 LogPrint(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");

 friend class CAddrManTest;      * Notice that vvTried, mapAddr and vVector are never encoded explicitly;      * they are instead reconstructed from the other information.      *-     * vvNew is serialized, but only used if ADDRMAN_UNKNOWN_BUCKET_COUNT didn't change,-     * otherwise it is reconstructed as well.+     * vvNew is serialized, but only used if ADDRMAN_NEW_BUCKET_COUNT and the asmap checksum+     * didn't change, otherwise it is reconstructed as well.

 def run_test(self):         self.nodes[1].createwallet(wallet_name="w1")         w1 = self.nodes[1].get_wallet_rpc("w1")         # w2 contains the private keys for w3-        self.nodes[1].createwallet(wallet_name="w2")+        self.nodes[1].createwallet(wallet_name="w2", blank=True)         w2 = self.nodes[1].get_wallet_rpc("w2")+        xpriv = "tprv8ZgxMBicQKsPfHCsTwkiM1KT56RXbGGTqvc2hgqzycpwbHqqpcajQeMRZoBD35kW4RtyCemu6j34Ku5DEspmgjKdt2qe4SvRch5Kk8B8A2v"

 def run_test(self):         self.nodes[1].createwallet(wallet_name="w1")         w1 = self.nodes[1].get_wallet_rpc("w1")         # w2 contains the private keys for w3-        self.nodes[1].createwallet(wallet_name="w2")+        self.nodes[1].createwallet(wallet_name="w2", blank=True)         w2 = self.nodes[1].get_wallet_rpc("w2")+        xpriv = "tprv8ZgxMBicQKsPfHCsTwkiM1KT56RXbGGTqvc2hgqzycpwbHqqpcajQeMRZoBD35kW4RtyCemu6j34Ku5DEspmgjKdt2qe4SvRch5Kk8B8A2v"+        xpub = "tpubD6NzVbkrYhZ4YkEfMbRJkQyZe7wTkbTNRECozCtJPtdLRn6cT1QKb8yHjwAPcAr26eHBFYs5iLiFFnCbwPRsncCKUKCfubHDMGKzMVcN1Jg"+        if self.options.descriptors:+            w2.importdescriptors([{+                "desc": descsum_create("wpkh(" + xpriv + "/0/0/*)"),+                "timestamp": "now",+                "range": [0, 100],+                "active": True+            },{+                "desc": descsum_create("wpkh(" + xpriv + "/0/1/*)"),+                "timestamp": "now",+                "range": [0, 100],+                "active": True,+                "internal": True+            }])+        else:+            w2.sethdseed(True)+         # w3 is a watch-only wallet, based on w2         self.nodes[1].createwallet(wallet_name="w3", disable_private_keys=True)         w3 = self.nodes[1].get_wallet_rpc("w3")-        for _ in range(3):-            a2_receive = w2.getnewaddress()-            a2_change = w2.getrawchangeaddress() # doesn't actually use change derivation-            res = w3.importmulti([{-                "desc": w2.getaddressinfo(a2_receive)["desc"],+        if self.options.descriptors:+            # Match the privkeys in w2 for descriptors+            res = w3.importdescriptors([{+                "desc": descsum_create("wpkh(" + xpub + "/0/0/*)"),                 "timestamp": "now",+                "range": [0, 100],                 "keypool": True,+                "active": True,                 "watchonly": True             },{-                "desc": w2.getaddressinfo(a2_change)["desc"],+                "desc": descsum_create("wpkh(" + xpub + "/0/1/*)"),                 "timestamp": "now",+                "range": [0, 100],                 "keypool": True,+                "active": True,                 "internal": True,                 "watchonly": True             }])             assert_equal(res, [{"success": True}, {"success": True}]) -        w0.sendtoaddress(a2_receive, 10) # fund w3-        self.nodes[0].generate(1)-        self.sync_blocks()--        # w4 has private keys enabled, but only contains watch-only keys (from w2)-        self.nodes[1].createwallet(wallet_name="w4", disable_private_keys=False)-        w4 = self.nodes[1].get_wallet_rpc("w4")         for _ in range(3):             a2_receive = w2.getnewaddress()-            res = w4.importmulti([{-                "desc": w2.getaddressinfo(a2_receive)["desc"],-                "timestamp": "now",-                "keypool": False,-                "watchonly": True-            }])-            assert_equal(res, [{"success": True}])+            if not self.options.descriptors:+                # Because legacy wallets use exclusively hardened derivation, we can't do a ranged import like we do for descriptors+                a2_change = w2.getrawchangeaddress() # doesn't actually use change derivation+                res = w3.importmulti([{+                    "desc": w2.getaddressinfo(a2_receive)["desc"],+                    "timestamp": "now",+                    "keypool": True,+                    "watchonly": True+                },{+                    "desc": w2.getaddressinfo(a2_change)["desc"],+                    "timestamp": "now",+                    "keypool": True,+                    "internal": True,+                    "watchonly": True+                }])+                assert_equal(res, [{"success": True}, {"success": True}]) -        w0.sendtoaddress(a2_receive, 10) # fund w4+        w0.sendtoaddress(a2_receive, 10) # fund w3         self.nodes[0].generate(1)         self.sync_blocks() +        if not self.options.descriptors:+            # w4 has private keys enabled, but only contains watch-only keys (from w2)+            # This is legacy wallet behavior only

 def run_test(self):         res = w2.walletprocesspsbt(res["psbt"])         assert res["complete"] -        self.log.info("Create PSBT from wallet w4 with watch-only keys, sign with w2...")-        self.test_send(from_wallet=w4, to_wallet=w1, amount=1, expect_error=(-4, "Insufficient funds"))-        res = self.test_send(from_wallet=w4, to_wallet=w1, amount=1, include_watching=True, add_to_wallet=False)-        res = w2.walletprocesspsbt(res["psbt"])-        assert res["complete"]+        if not self.options.descriptors:+            # This tests legacy watch-only behavior only.

 class MempoolCompatibilityTest(BitcoinTestFramework):     def set_test_params(self):         self.num_nodes = 2         self.wallet_names = [None]+        self.requires_wallet = True

 def skip_test_if_missing_module(self):         self.skip_if_no_bitcoind_zmq()      def run_test(self):+        if self.is_wallet_compiled():+            self.nodes[0].createwallet(wallet_name=self.default_wallet_name, descriptors=self.options.descriptors, load_on_startup=True)+            self.nodes[0].importprivkey(privkey=self.nodes[0].get_deterministic_priv_key().key, label='coinbase')+            self.nodes[1].createwallet(wallet_name=self.default_wallet_name, descriptors=self.options.descriptors, load_on_startup=True)+            self.nodes[1].importprivkey(privkey=self.nodes[1].get_deterministic_priv_key().key, label='coinbase')

 def set_test_params(self):         self.supports_cli = False      def run_test(self):+        self.wallet = MiniWallet(self.nodes[0])

 def run_test(self):          self.log.info("Test -getinfo returns expected network and blockchain info")         if self.is_wallet_compiled():+            self.nodes[0].createwallet(wallet_name=self.default_wallet_name, descriptors=self.options.descriptors)+            self.nodes[0].importprivkey(privkey=self.nodes[0].get_deterministic_priv_key().key, label='coinbase')

 def setup_network(self):         super().setup_network()      def run_test(self):+        if self.is_wallet_compiled():+            # Setup the descriptors to be imported to the wallet

 def import_deterministic_coinbase_privkeys(self):             self.init_wallet(i)      def init_wallet(self, i):+        if not self.requires_wallet:

 def parse_args(self):         parser.add_argument('--timeout-factor', dest="timeout_factor", type=float, default=1.0, help='adjust test timeouts by a factor. Setting it to 0 disables all timeouts')          group = parser.add_mutually_exclusive_group()-        group.add_argument("--descriptors", default=False, action="store_true",+        group.add_argument("--descriptors", action='store_const', const=True,                             help="Run test using a descriptor wallet", dest='descriptors')-        group.add_argument("--legacy-wallet", default=False, action="store_false",+        group.add_argument("--legacy-wallet", action='store_const', const=False,                             help="Run test using legacy wallets", dest='descriptors')          self.add_options(parser)         self.options = parser.parse_args()         self.options.previous_releases_path = previous_releases_path +        config = configparser.ConfigParser()+        config.read_file(open(self.options.configfile))+        self.config = config++        if self.options.descriptors is None:+            # Prefer BDB unless it isn't available+            if self.is_bdb_compiled():+                self.options.descriptors = False+            elif self.is_sqlite_compiled():+                self.options.descriptors = True+            # If neither are compiled, tests requiring a wallet will be skipped and the value of self.options.descriptors won't matter

 def parse_args(self):         parser.add_argument('--timeout-factor', dest="timeout_factor", type=float, default=1.0, help='adjust test timeouts by a factor. Setting it to 0 disables all timeouts')          group = parser.add_mutually_exclusive_group()-        group.add_argument("--descriptors", default=False, action="store_true",+        group.add_argument("--descriptors", action='store_const', const=True,                             help="Run test using a descriptor wallet", dest='descriptors')-        group.add_argument("--legacy-wallet", default=False, action="store_false",+        group.add_argument("--legacy-wallet", action='store_const', const=False,                             help="Run test using legacy wallets", dest='descriptors')          self.add_options(parser)         self.options = parser.parse_args()         self.options.previous_releases_path = previous_releases_path +        config = configparser.ConfigParser()+        config.read_file(open(self.options.configfile))+        self.config = config

 export LC_ALL=C.UTF-8  export CONTAINER_NAME=ci_win64-export DOCKER_NAME_TAG=ubuntu:18.04  # Check that bionic can cross-compile to win64 (bionic is used in the gitian build as well)+export DOCKER_NAME_TAG=ubuntu:20.04

 BOOST_AUTO_TEST_CASE(GetFeeTest)     feeRate = CFeeRate(1000);     altFeeRate = CFeeRate(feeRate);     BOOST_CHECK_EQUAL(feeRate.GetFee(100), altFeeRate.GetFee(100));+    BOOST_CHECK(!altFeeRate.IsZero()); }  BOOST_AUTO_TEST_CASE(CFeeRateConstructorTest) {     // Test CFeeRate(CAmount fee_rate, size_t bytes) constructor     // full constructor+    BOOST_CHECK(CFeeRate(CAmount(0), 0).IsZero());

 BOOST_AUTO_TEST_CASE(GetFeeTest)     CFeeRate(MAX_MONEY, std::numeric_limits<size_t>::max() >> 1).GetFeePerK(); } +BOOST_AUTO_TEST_CASE(CFeeRateNamedConstructorsTest)+{+    // Test CFeerate(CAmount fee_rate, FeeEstimatemode mode) constructor+    // with BTC/kvB, returns same values as CFeeRate(amount) or CFeeRate(amount, 1000)+    BOOST_CHECK(CFeeRate::FromBtcKb(CAmount(-1)) == CFeeRate(-1));+    BOOST_CHECK(CFeeRate::FromBtcKb(CAmount(-1)) == CFeeRate(-1, 1000));

 class CFeeRate     SERIALIZE_METHODS(CFeeRate, obj) { READWRITE(obj.nSatoshisPerK); } }; +/** Construct a CFeeRate from a CAmount in sat/vB */+inline CFeeRate CFeeRate::FromSatB(CAmount fee_rate) { return CFeeRate(fee_rate, COIN); }

 def setup_network(self):         super().setup_network()      def run_test(self):+        if self.is_wallet_compiled():+            # Setup the descriptors to be imported to the wallet+            seed = "cTdGmKFWpbvpKQ7ejrdzqYT2hhjyb3GPHnLAK7wdi5Em67YLwSm9"+            xpriv = "tprv8ZgxMBicQKsPfHCsTwkiM1KT56RXbGGTqvc2hgqzycpwbHqqpcajQeMRZoBD35kW4RtyCemu6j34Ku5DEspmgjKdt2qe4SvRch5Kk8B8A2v"