backport: bitcoin#24836, #25379, #25773, #25957, #25986, #26158, #26294, #26349, #26388, #26404, #26424, #26625, #26920, #27350

ci/dash/lint-tidy.sh

@@ -83,6 +83,7 @@ echo "=========================="
 
 cd "${BASE_ROOT_DIR}/build-ci/dashcore-${BUILD_TARGET}"
 iwyu_tool.py \
+  "src/common/url.cpp" \
   "src/compat" \
   "src/dbwrapper.cpp" \
   "src/init" \
@@ -110,7 +111,6 @@ iwyu_tool.py \
   "src/util/strencodings.cpp" \
   "src/util/syserror.cpp" \
   "src/util/threadinterrupt.cpp" \
-  "src/util/url.cpp" \
   "src/zmq" \
   -p . "${MAKEJOBS}" \
   -- -Xiwyu --cxx17ns -Xiwyu --mapping_file="${BASE_ROOT_DIR}/contrib/devtools/iwyu/bitcoin.core.imp" \

ci/test/00_setup_env_mac_native_x86_64.sh → ci/test/00_setup_env_mac_native_arm64.sh

@@ -7,10 +7,10 @@
 export LC_ALL=C.UTF-8
 
 export CONTAINER_NAME=ci_macos
-export HOST=x86_64-apple-darwin
-export PIP_PACKAGES="zmq lief"
+export HOST=arm64-apple-darwin
+export PIP_PACKAGES="zmq"
 export GOAL="install"
-export BITCOIN_CONFIG="--with-gui --enable-reduce-exports --disable-miner"
+export BITCOIN_CONFIG="--with-gui --with-miniupnpc --with-natpmp --enable-reduce-exports --disable-miner"
 export CI_OS_NAME="macos"
 export NO_DEPENDS=1
 export OSX_SDK=""

ci/test/04_install.sh

@@ -92,7 +92,7 @@ if [ -n "$PIP_PACKAGES" ]; then
   if [ "$CI_OS_NAME" == "macos" ]; then
     sudo -H pip3 install --upgrade pip
     # shellcheck disable=SC2086
-    IN_GETOPT_BIN="/usr/local/opt/gnu-getopt/bin/getopt" ${CI_RETRY_EXE} pip3 install --user $PIP_PACKAGES
+    IN_GETOPT_BIN="$(brew --prefix gnu-getopt)/bin/getopt" ${CI_RETRY_EXE} pip3 install --user $PIP_PACKAGES
   else
     # shellcheck disable=SC2086
     ${CI_RETRY_EXE} CI_EXEC pip3 install --user $PIP_PACKAGES

doc/descriptors.md

@@ -241,6 +241,6 @@ ones. For larger numbers of errors, or other types of errors, there is a
 roughly 1 in a trillion chance of not detecting the errors.
 
 All RPCs in Dash Core will include the checksum in their output. Only
-certain RPCs require checksums on input, including `deriveaddress` and
+certain RPCs require checksums on input, including `deriveaddresses` and
 `importmulti`. The checksum for a descriptor without one can be computed
 using the `getdescriptorinfo` RPC.

doc/release-notes-25957.md

@@ -0,0 +1,9 @@
+Wallet
+------
+
+- Rescans for descriptor wallets are now significantly faster if compact
+  block filters (BIP158) are available. Since those are not constructed
+  by default, the configuration option "-blockfilterindex=1" has to be
+  provided to take advantage of the optimization. This improves the
+  performance of the RPC calls `rescanblockchain`, `importdescriptors`
+  and `restorewallet`. (#25957)

src/Makefile.am

@@ -192,6 +192,7 @@ BITCOIN_CORE_H = \
   coins.h \
   common/bloom.h \
   common/run_command.h \
+  common/url.h \
   compat/assumptions.h \
   compat/byteswap.h \
   compat/compat.h \
@@ -432,7 +433,6 @@ BITCOIN_CORE_H = \
   util/translation.h \
   util/types.h \
   util/ui_change_type.h \
-  util/url.h \
   util/vector.h \
   util/wpipe.h \
   validation.h \
@@ -961,6 +961,11 @@ libbitcoin_common_a_SOURCES = \
   script/standard.cpp \
   warnings.cpp \
   $(BITCOIN_CORE_H)
+
+if USE_LIBEVENT
+libbitcoin_common_a_CPPFLAGS += $(EVENT_CFLAGS)
+libbitcoin_common_a_SOURCES += common/url.cpp
+endif
 #
 
 # util #
@@ -1016,10 +1021,6 @@ libbitcoin_util_a_SOURCES = \
   util/tokenpipe.cpp \
   util/wpipe.cpp \
   $(BITCOIN_CORE_H)
-
-if USE_LIBEVENT
-libbitcoin_util_a_SOURCES += util/url.cpp
-endif
 #
 
 # cli #

src/bench/addrman.cpp

@@ -167,9 +167,9 @@ static void AddrManAddThenGood(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AddrManAdd);
-BENCHMARK(AddrManSelect);
-BENCHMARK(AddrManSelectFromAlmostEmpty);
-BENCHMARK(AddrManSelectByNetwork);
-BENCHMARK(AddrManGetAddr);
-BENCHMARK(AddrManAddThenGood);
+BENCHMARK(AddrManAdd, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelect, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelectFromAlmostEmpty, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManSelectByNetwork, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManGetAddr, benchmark::PriorityLevel::HIGH);
+BENCHMARK(AddrManAddThenGood, benchmark::PriorityLevel::HIGH);

src/bench/base58.cpp

@@ -50,6 +50,6 @@ static void Base58Decode(benchmark::Bench& bench)
 }
 
 
-BENCHMARK(Base58Encode);
-BENCHMARK(Base58CheckEncode);
-BENCHMARK(Base58Decode);
+BENCHMARK(Base58Encode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Base58CheckEncode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Base58Decode, benchmark::PriorityLevel::HIGH);

src/bench/bech32.cpp

@@ -32,5 +32,5 @@ static void Bech32Decode(benchmark::Bench& bench)
 }
 
 
-BENCHMARK(Bech32Encode);
-BENCHMARK(Bech32Decode);
+BENCHMARK(Bech32Encode, benchmark::PriorityLevel::HIGH);
+BENCHMARK(Bech32Decode, benchmark::PriorityLevel::HIGH);

src/bench/bench.h

@@ -76,7 +76,7 @@ class BenchRunner
 } // namespace benchmark
 
 // BENCHMARK(foo) expands to:  benchmark::BenchRunner bench_11foo("foo", foo, priority_level);
-#define BENCHMARK(n) \
-    benchmark::BenchRunner PASTE2(bench_, PASTE2(__LINE__, n))(STRINGIZE(n), n, benchmark::PriorityLevel::HIGH);
+#define BENCHMARK(n, priority_level) \
+    benchmark::BenchRunner PASTE2(bench_, PASTE2(__LINE__, n))(STRINGIZE(n), n, priority_level);
 
 #endif // BITCOIN_BENCH_BENCH_H

src/bench/bip324_ecdh.cpp

@@ -48,4 +48,4 @@ static void BIP324_ECDH(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(BIP324_ECDH);
+BENCHMARK(BIP324_ECDH, benchmark::PriorityLevel::HIGH);

src/bench/block_assemble.cpp

@@ -52,4 +52,4 @@ static void AssembleBlock(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(AssembleBlock);
+BENCHMARK(AssembleBlock, benchmark::PriorityLevel::HIGH);

src/bench/bls.cpp

@@ -358,17 +358,17 @@ static void BLS_Verify_BatchedParallel(benchmark::Bench& bench)
     blsWorker.Stop();
 }
 
-BENCHMARK(BLS_PubKeyAggregate_Normal)
-BENCHMARK(BLS_SecKeyAggregate_Normal)
-BENCHMARK(BLS_SignatureAggregate_Normal)
-BENCHMARK(BLS_Sign_Normal)
-BENCHMARK(BLS_Verify_Normal)
-BENCHMARK(BLS_Verify_LargeBlock100)
-BENCHMARK(BLS_Verify_LargeBlock1000)
-BENCHMARK(BLS_Verify_LargeBlockSelfAggregated100)
-BENCHMARK(BLS_Verify_LargeBlockSelfAggregated1000)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock100)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock1000)
-BENCHMARK(BLS_Verify_LargeAggregatedBlock1000PreVerified)
-BENCHMARK(BLS_Verify_Batched)
-BENCHMARK(BLS_Verify_BatchedParallel)
+BENCHMARK(BLS_PubKeyAggregate_Normal, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_SecKeyAggregate_Normal, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_SignatureAggregate_Normal, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Sign_Normal, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_Normal, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeBlock100, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeBlock1000, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeBlockSelfAggregated100, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeBlockSelfAggregated1000, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeAggregatedBlock100, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeAggregatedBlock1000, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_LargeAggregatedBlock1000PreVerified, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_Batched, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_Verify_BatchedParallel, benchmark::PriorityLevel::HIGH)

src/bench/bls_dkg.cpp

@@ -131,12 +131,12 @@ static void BLSDKG_GenerateContributions(benchmark::Bench& bench, uint32_t epoch
     blsWorker.Stop();
 }
 
-#define BENCH_GenerateContributions(name, quorumSize, epoch_iters) \
+#define BENCH_GenerateContributions(name, quorumSize, epoch_iters)                          \
     static void BLSDKG_GenerateContributions_##name##_##quorumSize(benchmark::Bench& bench) \
-    {                                                \
-        BLSDKG_GenerateContributions(bench, epoch_iters, quorumSize); \
-    } \
-    BENCHMARK(BLSDKG_GenerateContributions_##name##_##quorumSize)
+    {                                                                                       \
+        BLSDKG_GenerateContributions(bench, epoch_iters, quorumSize);                       \
+    }                                                                                       \
+    BENCHMARK(BLSDKG_GenerateContributions_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int quorumSize)
 {
@@ -149,42 +149,42 @@ static void BLSDKG_InitDKG(benchmark::Bench& bench, uint32_t epoch_iters, int qu
     });
 }
 
-#define BENCH_InitDKG(name, quorumSize, epoch_iters) \
+#define BENCH_InitDKG(name, quorumSize, epoch_iters)                          \
     static void BLSDKG_InitDKG_##name##_##quorumSize(benchmark::Bench& bench) \
-    {                                                \
-        BLSDKG_InitDKG(bench, epoch_iters, quorumSize); \
-    } \
-    BENCHMARK(BLSDKG_InitDKG_##name##_##quorumSize)
+    {                                                                         \
+        BLSDKG_InitDKG(bench, epoch_iters, quorumSize);                       \
+    }                                                                         \
+    BENCHMARK(BLSDKG_InitDKG_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
-#define BENCH_BuildQuorumVerificationVectors(name, quorumSize, epoch_iters) \
+#define BENCH_BuildQuorumVerificationVectors(name, quorumSize, epoch_iters)                          \
     static void BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize(benchmark::Bench& bench) \
-    { \
-        if (!bench.output()) { \
-            std::unique_ptr<DKG> ptr = std::make_unique<DKG>(1); \
-            ptr->Bench_BuildQuorumVerificationVectors(bench, 1); \
-            ptr.reset(); \
-            return; \
-        } \
-        std::unique_ptr<DKG> ptr = std::make_unique<DKG>(quorumSize); \
-        ptr->Bench_BuildQuorumVerificationVectors(bench, epoch_iters); \
-        ptr.reset(); \
-    } \
-    BENCHMARK(BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize)
+    {                                                                                                \
+        if (!bench.output()) {                                                                       \
+            std::unique_ptr<DKG> ptr = std::make_unique<DKG>(1);                                     \
+            ptr->Bench_BuildQuorumVerificationVectors(bench, 1);                                     \
+            ptr.reset();                                                                             \
+            return;                                                                                  \
+        }                                                                                            \
+        std::unique_ptr<DKG> ptr = std::make_unique<DKG>(quorumSize);                                \
+        ptr->Bench_BuildQuorumVerificationVectors(bench, epoch_iters);                               \
+        ptr.reset();                                                                                 \
+    }                                                                                                \
+    BENCHMARK(BLSDKG_BuildQuorumVerificationVectors_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 #define BENCH_VerifyContributionShares(name, quorumSize, invalidCount, aggregated, epoch_iters) \
-    static void BLSDKG_VerifyContributionShares_##name##_##quorumSize(benchmark::Bench& bench) \
-    { \
-        if (!bench.output()) { \
-            std::unique_ptr<DKG> ptr = std::make_unique<DKG>(1); \
-            ptr->Bench_VerifyContributionShares(bench, invalidCount, aggregated, 1); \
-            ptr.reset(); \
-            return; \
-        } \
-        std::unique_ptr<DKG> ptr = std::make_unique<DKG>(quorumSize); \
-        ptr->Bench_VerifyContributionShares(bench, invalidCount, aggregated, epoch_iters); \
-        ptr.reset(); \
-    } \
-    BENCHMARK(BLSDKG_VerifyContributionShares_##name##_##quorumSize)
+    static void BLSDKG_VerifyContributionShares_##name##_##quorumSize(benchmark::Bench& bench)  \
+    {                                                                                           \
+        if (!bench.output()) {                                                                  \
+            std::unique_ptr<DKG> ptr = std::make_unique<DKG>(1);                                \
+            ptr->Bench_VerifyContributionShares(bench, invalidCount, aggregated, 1);            \
+            ptr.reset();                                                                        \
+            return;                                                                             \
+        }                                                                                       \
+        std::unique_ptr<DKG> ptr = std::make_unique<DKG>(quorumSize);                           \
+        ptr->Bench_VerifyContributionShares(bench, invalidCount, aggregated, epoch_iters);      \
+        ptr.reset();                                                                            \
+    }                                                                                           \
+    BENCHMARK(BLSDKG_VerifyContributionShares_##name##_##quorumSize, benchmark::PriorityLevel::HIGH)
 
 BENCH_GenerateContributions(simple, 50, 50);
 BENCH_GenerateContributions(simple, 100, 5);

src/bench/bls_pubkey_agg.cpp

@@ -87,13 +87,13 @@ static void BLS_PubKeyAggregate_Iterative_200(benchmark::Bench& bench) { BLS_Pub
 static void BLS_PubKeyAggregate_Batch_200(benchmark::Bench& bench) { BLS_PubKeyAggregate_Batch(200, bench); }
 
 // Register all benchmarks
-BENCHMARK(BLS_PubKeyAggregate_Iterative_5)
-BENCHMARK(BLS_PubKeyAggregate_Batch_5)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_25)
-BENCHMARK(BLS_PubKeyAggregate_Batch_25)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_50)
-BENCHMARK(BLS_PubKeyAggregate_Batch_50)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_100)
-BENCHMARK(BLS_PubKeyAggregate_Batch_100)
-BENCHMARK(BLS_PubKeyAggregate_Iterative_200)
-BENCHMARK(BLS_PubKeyAggregate_Batch_200)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_5, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Batch_5, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_25, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Batch_25, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_50, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Batch_50, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_100, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Batch_100, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Iterative_200, benchmark::PriorityLevel::HIGH)
+BENCHMARK(BLS_PubKeyAggregate_Batch_200, benchmark::PriorityLevel::HIGH)

src/bench/ccoins_caching.cpp

@@ -50,4 +50,4 @@ static void CCoinsCaching(benchmark::Bench& bench)
     ECC_Stop();
 }
 
-BENCHMARK(CCoinsCaching);
+BENCHMARK(CCoinsCaching, benchmark::PriorityLevel::HIGH);

src/bench/chacha20.cpp

@@ -66,9 +66,9 @@ static void FSCHACHA20POLY1305_1MB(benchmark::Bench& bench)
     FSCHACHA20POLY1305(bench, BUFFER_SIZE_LARGE);
 }
 
-BENCHMARK(CHACHA20_64BYTES);
-BENCHMARK(CHACHA20_256BYTES);
-BENCHMARK(CHACHA20_1MB);
-BENCHMARK(FSCHACHA20POLY1305_64BYTES);
-BENCHMARK(FSCHACHA20POLY1305_256BYTES);
-BENCHMARK(FSCHACHA20POLY1305_1MB);
+BENCHMARK(CHACHA20_64BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(CHACHA20_256BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(CHACHA20_1MB, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_64BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_256BYTES, benchmark::PriorityLevel::HIGH);
+BENCHMARK(FSCHACHA20POLY1305_1MB, benchmark::PriorityLevel::HIGH);

src/bench/checkblock.cpp

@@ -56,5 +56,5 @@ static void DeserializeAndCheckBlockTest(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(DeserializeBlockTest);
-BENCHMARK(DeserializeAndCheckBlockTest);
+BENCHMARK(DeserializeBlockTest, benchmark::PriorityLevel::HIGH);
+BENCHMARK(DeserializeAndCheckBlockTest, benchmark::PriorityLevel::HIGH);

src/bench/checkqueue.cpp

@@ -70,4 +70,4 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::Bench& bench)
     queue.StopWorkerThreads();
     ECC_Stop();
 }
-BENCHMARK(CCheckQueueSpeedPrevectorJob);
+BENCHMARK(CCheckQueueSpeedPrevectorJob, benchmark::PriorityLevel::HIGH);

src/bench/coin_selection.cpp

@@ -118,5 +118,5 @@ static void BnBExhaustion(benchmark::Bench& bench)
     });
 }
 
-BENCHMARK(CoinSelection);
-BENCHMARK(BnBExhaustion);
+BENCHMARK(CoinSelection, benchmark::PriorityLevel::HIGH);
+BENCHMARK(BnBExhaustion, benchmark::PriorityLevel::HIGH);