Merge branch 'auxpow-30.x' into 30.x

domob1812 · domob1812 · commit 6d2c8e6e15a6 · 2025-09-22T09:23:48.000+02:00
diff --git a/ci/test/00_setup_env_i686_no_ipc.sh b/ci/test/00_setup_env_i686_no_ipc.sh
@@ -13,6 +13,7 @@ export CI_IMAGE_PLATFORM="linux/amd64"
 export PACKAGES="llvm clang g++-multilib"
 export DEP_OPTS="DEBUG=1 NO_IPC=1"
 export GOAL="install"
+export CI_LIMIT_STACK_SIZE=1
 export TEST_RUNNER_EXTRA="--v2transport --usecli"
 export BITCOIN_CONFIG="\
  -DCMAKE_BUILD_TYPE=Debug \
diff --git a/ci/test/01_base_install.sh b/ci/test/01_base_install.sh
@@ -56,10 +56,9 @@ if [ -n "$PIP_PACKAGES" ]; then
 fi
 
 if [[ -n "${USE_INSTRUMENTED_LIBCPP}" ]]; then
+  ${CI_RETRY_EXE} git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-21.1.1" /llvm-project
+
   if [ -n "${APT_LLVM_V}" ]; then
-    ${CI_RETRY_EXE} git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-$( clang --version | sed --silent 's@.*clang version \([0-9.]*\).*@\1@p' )" /llvm-project
-  else
-    ${CI_RETRY_EXE} git clone --depth=1 https://github.com/llvm/llvm-project -b "llvmorg-21.1.0" /llvm-project
 
     cmake -G Ninja -B /clang_build/ \
       -DLLVM_ENABLE_PROJECTS="clang" \
diff --git a/cmake/module/FindUSDT.cmake b/cmake/module/FindUSDT.cmake
@@ -36,6 +36,10 @@ if(USDT_INCLUDE_DIR)
   include(CheckCXXSourceCompiles)
   set(CMAKE_REQUIRED_INCLUDES ${USDT_INCLUDE_DIR})
   check_cxx_source_compiles("
+    #if defined(__arm__)
+    #  define STAP_SDT_ARG_CONSTRAINT g
+    #endif
+
     // Setting SDT_USE_VARIADIC lets systemtap (sys/sdt.h) know that we want to use
     // the optional variadic macros to define tracepoints.
     #define SDT_USE_VARIADIC 1
diff --git a/cmake/secp256k1.cmake b/cmake/secp256k1.cmake
@@ -2,6 +2,8 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or https://opensource.org/license/mit/.
 
+enable_language(C)
+
 function(add_secp256k1 subdir)
   message("")
   message("Configuring secp256k1 subtree...")
@@ -30,7 +32,6 @@ function(add_secp256k1 subdir)
   string(STRIP "${SECP256K1_APPEND_LDFLAGS} ${APPEND_LDFLAGS}" SECP256K1_APPEND_LDFLAGS)
   set(SECP256K1_APPEND_LDFLAGS ${SECP256K1_APPEND_LDFLAGS} CACHE STRING "" FORCE)
   # We want to build libsecp256k1 with the most tested RelWithDebInfo configuration.
-  enable_language(C)
   foreach(config IN LISTS CMAKE_BUILD_TYPE CMAKE_CONFIGURATION_TYPES)
     if(config STREQUAL "")
       continue()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -304,7 +304,7 @@ if(BUILD_BITCOIN_BIN)
   add_windows_resources(bitcoin bitcoin-res.rc)
   add_windows_application_manifest(bitcoin)
   target_link_libraries(bitcoin core_interface bitcoin_util)
-  install_binary_component(bitcoin)
+  install_binary_component(bitcoin HAS_MANPAGE)
 endif()
 
 # Bitcoin Core bitcoind.
diff --git a/src/net.cpp b/src/net.cpp
@@ -574,9 +574,9 @@ void CNode::CloseSocketDisconnect()
     m_i2p_sam_session.reset();
 }
 
-void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr, const std::vector<NetWhitelistPermissions>& ranges) const {
+void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const {
     for (const auto& subnet : ranges) {
-        if (subnet.m_subnet.Match(addr)) {
+        if (addr.has_value() && subnet.m_subnet.Match(addr.value())) {
             NetPermissions::AddFlag(flags, subnet.m_flags);
         }
     }
@@ -1768,7 +1768,11 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
 {
     int nInbound = 0;
 
-    AddWhitelistPermissionFlags(permission_flags, addr, vWhitelistedRangeIncoming);
+    const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
+
+    // Tor inbound connections do not reveal the peer's actual network address.
+    // Therefore do not apply address-based whitelist permissions to them.
+    AddWhitelistPermissionFlags(permission_flags, inbound_onion ? std::optional<CNetAddr>{} : addr, vWhitelistedRangeIncoming);
 
     {
         LOCK(m_nodes_mutex);
@@ -1823,7 +1827,6 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
     NodeId id = GetNewNodeId();
     uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();
 
-    const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();
     // The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is
     // detected, so use it whenever we signal NODE_P2P_V2.
     ServiceFlags local_services = GetLocalServices();
diff --git a/src/net.h b/src/net.h
@@ -1383,7 +1383,7 @@ class CConnman
 
     bool AttemptToEvictConnection();
     CNode* ConnectNode(CAddress addrConnect, const char *pszDest, bool fCountFailure, ConnectionType conn_type, bool use_v2transport) EXCLUSIVE_LOCKS_REQUIRED(!m_unused_i2p_sessions_mutex);
-    void AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr, const std::vector<NetWhitelistPermissions>& ranges) const;
+    void AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const;
 
     void DeleteNode(CNode* pnode);
 
diff --git a/src/qt/forms/debugwindow.ui b/src/qt/forms/debugwindow.ui
@@ -573,7 +573,7 @@
         </layout>
        </item>
        <item>
-        <widget class="QTextEdit" name="messagesWidget">
+        <widget class="PlainCopyTextEdit" name="messagesWidget">
          <property name="minimumSize">
           <size>
            <width>0</width>
@@ -1868,6 +1868,10 @@
     <slot>clear()</slot>
    </slots>
   </customwidget>
+  <customwidget>
+   <class>PlainCopyTextEdit</class>
+   <extends>QTextEdit</extends>
+  </customwidget>
  </customwidgets>
  <resources>
   <include location="../bitcoin.qrc"/>
diff --git a/src/qt/rpcconsole.h b/src/qt/rpcconsole.h
@@ -15,6 +15,9 @@
 
 #include <QByteArray>
 #include <QCompleter>
+#include <QMimeData>
+#include <QTextDocumentFragment>
+#include <QTextEdit>
 #include <QThread>
 #include <QWidget>
 
@@ -191,4 +194,20 @@ private Q_SLOTS:
     void updateAlerts(const QString& warnings);
 };
 
+/**
+ * A version of QTextEdit that only populates plaintext mime data from a
+ * selection, this avoids some bad behavior in QT's HTML->Markdown conversion.
+ */
+class PlainCopyTextEdit : public QTextEdit {
+    Q_OBJECT
+public:
+    using QTextEdit::QTextEdit;
+protected:
+    QMimeData* createMimeDataFromSelection() const override {
+        auto md = new QMimeData();
+        md->setText(textCursor().selection().toPlainText());
+        return md;
+    }
+};
+
 #endif // BITCOIN_QT_RPCCONSOLE_H
diff --git a/src/test/node_init_tests.cpp b/src/test/node_init_tests.cpp
@@ -11,7 +11,12 @@
 
 using node::NodeContext;
 
-BOOST_FIXTURE_TEST_SUITE(node_init_tests, BasicTestingSetup)
+//! Like BasicTestingSetup, but using regtest network instead of mainnet.
+struct InitTestSetup : BasicTestingSetup {
+    InitTestSetup() : BasicTestingSetup{ChainType::REGTEST} {}
+};
+
+BOOST_FIXTURE_TEST_SUITE(node_init_tests, InitTestSetup)
 
 //! Custom implementation of interfaces::Init for testing.
 class TestInit : public interfaces::Init
diff --git a/src/util/trace.h b/src/util/trace.h
@@ -9,6 +9,13 @@
 
 #ifdef ENABLE_TRACING
 
+// Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103395
+// systemtap 4.6 on 32-bit ARM triggers internal compiler error
+// (this workaround is included in systemtap 4.7+)
+#if defined(__arm__)
+#  define STAP_SDT_ARG_CONSTRAINT g
+#endif
+
 // Setting SDT_USE_VARIADIC lets systemtap (sys/sdt.h) know that we want to use
 // the optional variadic macros to define tracepoints.
 #define SDT_USE_VARIADIC 1
diff --git a/src/wallet/receive.cpp b/src/wallet/receive.cpp
@@ -245,7 +245,10 @@ void CachedTxGetAmounts(const CWallet& wallet, const CWalletTx& wtx,
 
 bool CachedTxIsFromMe(const CWallet& wallet, const CWalletTx& wtx)
 {
-    return (CachedTxGetDebit(wallet, wtx, /*avoid_reuse=*/false) > 0);
+    if (!wtx.m_cached_from_me.has_value()) {
+        wtx.m_cached_from_me = wallet.IsFromMe(*wtx.tx);
+    }
+    return wtx.m_cached_from_me.value();
 }
 
 // NOLINTNEXTLINE(misc-no-recursion)
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
@@ -1532,7 +1532,6 @@ RPCHelpMan sendall()
                 CoinFilterParams coins_params;
                 coins_params.min_amount = 0;
                 for (const COutput& output : AvailableCoins(*pwallet, &coin_control, fee_rate, coins_params).All()) {
-                    CHECK_NONFATAL(output.input_bytes > 0);
                     if (send_max && fee_rate.GetFee(output.input_bytes) > output.txout.nValue) {
                         continue;
                     }
@@ -1555,6 +1554,9 @@ RPCHelpMan sendall()
 
             // estimate final size of tx
             const TxSize tx_size{CalculateMaximumSignedTxSize(CTransaction(rawTx), pwallet.get())};
+            if (tx_size.vsize == -1) {
+                throw JSONRPCError(RPC_WALLET_ERROR, "Unable to determine the size of the transaction, the wallet contains unsolvable descriptors");
+            }
             const CAmount fee_from_size{fee_rate.GetFee(tx_size.vsize)};
             const std::optional<CAmount> total_bump_fees{pwallet->chain().calculateCombinedBumpFee(outpoints_spent, fee_rate)};
             CAmount effective_value = total_input_value - fee_from_size - total_bump_fees.value_or(0);
diff --git a/src/wallet/transaction.h b/src/wallet/transaction.h
@@ -232,6 +232,8 @@ class CWalletTx
      * CWallet::ComputeTimeSmart().
      */
     unsigned int nTimeSmart;
+    // Cached value for whether the transaction spends any inputs known to the wallet
+    mutable std::optional<bool> m_cached_from_me{std::nullopt};
     int64_t nOrderPos; //!< position in ordered transaction list
     std::multimap<int64_t, CWalletTx*>::const_iterator m_it_wtxOrdered;
 
@@ -339,6 +341,7 @@ class CWalletTx
         m_amounts[CREDIT].Reset();
         fChangeCached = false;
         m_is_cache_empty = true;
+        m_cached_from_me = std::nullopt;
     }
 
     /** True if only scriptSigs are different */
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -1656,7 +1656,18 @@ bool CWallet::IsMine(const COutPoint& outpoint) const
 
 bool CWallet::IsFromMe(const CTransaction& tx) const
 {
-    return (GetDebit(tx) > 0);
+    LOCK(cs_wallet);
+    for (const CTxIn& txin : tx.vin) {
+        const auto txo = GetTXO(txin.prevout);
+        /* We only want to class a transaction as "from me" if it spends
+           coins.  If it is only sending a name, this is an edge case e.g.
+           for atomic name transactions.  If we classed this as from me, then
+           it would break some other logic (e.g. fee calculation in the
+           gettransaction() RPC).  */
+        if (txo && !CNameScript(txo->GetTxOut().scriptPubKey).isNameOp())
+            return true;
+    }
+    return false;
 }
 
 CAmount CWallet::GetDebit(const CTransaction& tx) const
diff --git a/test/functional/interface_ipc.py b/test/functional/interface_ipc.py
@@ -7,7 +7,7 @@
 from io import BytesIO
 from pathlib import Path
 import shutil
-from test_framework.messages import (CBlock, CTransaction, ser_uint256)
+from test_framework.messages import (CBlock, CTransaction, ser_uint256, COIN)
 from test_framework.test_framework import (BitcoinTestFramework, assert_equal)
 from test_framework.wallet import MiniWallet
 
@@ -73,6 +73,12 @@ async def parse_and_deserialize_block(self, block_template, ctx):
         block.deserialize(block_data)
         return block
 
+    async def parse_and_deserialize_coinbase_tx(self, block_template, ctx):
+        coinbase_data = BytesIO((await block_template.result.getCoinbaseTx(ctx)).result)
+        tx = CTransaction()
+        tx.deserialize(coinbase_data)
+        return tx
+
     def run_echo_test(self):
         self.log.info("Running echo test")
         async def async_routine():
@@ -170,6 +176,41 @@ async def async_routine():
             self.log.debug("Wait for another, but time out, since the fee threshold is set now")
             template7 = await template6.result.waitNext(ctx, waitoptions)
             assert_equal(template7.to_dict(), {})
+
+            current_block_height = self.nodes[0].getchaintips()[0]["height"]
+            check_opts = self.capnp_modules['mining'].BlockCheckOptions()
+            template = await mining.result.createNewBlock(opts)
+            block = await self.parse_and_deserialize_block(template, ctx)
+            coinbase = await self.parse_and_deserialize_coinbase_tx(template, ctx)
+            balance = miniwallet.get_balance()
+            coinbase.vout[0].scriptPubKey = miniwallet.get_output_script()
+            coinbase.vout[0].nValue = COIN
+            block.vtx[0] = coinbase
+            block.hashMerkleRoot = block.calc_merkle_root()
+            original_version = block.nVersion
+            self.log.debug("Submit a block with a bad version")
+            block.nVersion = 0
+            block.solve()
+            res = await mining.result.checkBlock(block.serialize(), check_opts)
+            assert_equal(res.result, False)
+            assert_equal(res.reason, "bad-version(0x00000000)")
+            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
+            assert_equal(res.result, False)
+            self.log.debug("Submit a valid block")
+            block.nVersion = original_version
+            block.solve()
+            res = await mining.result.checkBlock(block.serialize(), check_opts)
+            assert_equal(res.result, True)
+            res = await template.result.submitSolution(ctx, block.nVersion, block.nTime, block.nNonce, coinbase.serialize())
+            assert_equal(res.result, True)
+            assert_equal(self.nodes[0].getchaintips()[0]["height"], current_block_height + 1)
+            miniwallet.rescan_utxos()
+            assert_equal(miniwallet.get_balance(), balance + 1)
+            self.log.debug("Check block should fail now, since it is a duplicate")
+            res = await mining.result.checkBlock(block.serialize(), check_opts)
+            assert_equal(res.result, False)
+            assert_equal(res.reason, "inconclusive-not-best-prevblk")
+
             self.log.debug("Destroy template objects")
             template.result.destroy(ctx)
             template2.result.destroy(ctx)
diff --git a/test/functional/rpc_misc.py b/test/functional/rpc_misc.py
@@ -30,6 +30,13 @@ def run_test(self):
             lambda: node.echo(arg9='trigger_internal_bug'),
         )
 
+        self.log.info("test max arg size")
+        ARG_SZ_COMMON = 131071  # Common limit, used previously in the test framework, serves as a regression test
+        ARG_SZ_LARGE = 8 * 1024 * 1024  # A large size, which should be rare to hit in practice
+        for arg_sz in [0, 1, 100, ARG_SZ_COMMON, ARG_SZ_LARGE]:
+            arg_string = 'a' * arg_sz
+            assert_equal([arg_string, arg_string], node.echo(arg_string, arg_string))
+
         self.log.info("test getmemoryinfo")
         memory = node.getmemoryinfo()['locked']
         assert_greater_than(memory['used'], 0)
diff --git a/test/functional/test_framework/script_util.py b/test/functional/test_framework/script_util.py
@@ -66,6 +66,7 @@
 assert len(DUMMY_MIN_OP_RETURN_SCRIPT) == MIN_PADDING
 
 PAY_TO_ANCHOR = CScript([OP_1, bytes.fromhex("4e73")])
+ANCHOR_ADDRESS = "ncrt1pfeesjnvuq8"
 
 def key_to_p2pk_script(key):
     key = check_key(key)
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
@@ -49,7 +49,12 @@
 # The size of the blocks xor key
 # from InitBlocksdirXorKey::xor_key.size()
 NUM_XOR_BYTES = 8
-CLI_MAX_ARG_SIZE = 131071 # many systems have a 128kb limit per arg (MAX_ARG_STRLEN)
+# Many systems have a 128kB limit for a command size. Depending on the
+# platform, this limit may be larger or smaller. Moreover, when using the
+# 'bitcoin' command, it may internally insert more args, which must be
+# accounted for. There is no need to pick the largest possible value here
+# anyway and it should be fine to set it to 1kB in tests.
+TEST_CLI_MAX_ARG_SIZE = 1024
 
 # The null blocks key (all 0s)
 NULL_BLK_XOR_KEY = bytes([0] * NUM_XOR_BYTES)
@@ -971,10 +976,14 @@ def send_cli(self, clicommand=None, *args, **kwargs):
         if clicommand is not None:
             p_args += [clicommand]
         p_args += pos_args + named_args
-        max_arg_size = max(len(arg) for arg in p_args)
+
+        # TEST_CLI_MAX_ARG_SIZE is set low enough that checking the string
+        # length is enough and encoding to bytes is not needed before
+        # calculating the sum.
+        sum_arg_size = sum(len(arg) for arg in p_args)
         stdin_data = self.input
-        if max_arg_size > CLI_MAX_ARG_SIZE:
-            self.log.debug(f"Cli: Command size {max_arg_size} too large, using stdin")
+        if sum_arg_size >= TEST_CLI_MAX_ARG_SIZE:
+            self.log.debug(f"Cli: Command size {sum_arg_size} too large, using stdin")
             rpc_args = "\n".join([arg for arg in p_args[base_arg_pos:]])
             if stdin_data is not None:
                 stdin_data += "\n" + rpc_args
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
@@ -151,6 +151,7 @@
     'rpc_orphans.py',
     'wallet_listreceivedby.py',
     'wallet_abandonconflict.py',
+    'wallet_anchor.py',
     'feature_reindex.py',
     'feature_reindex_readonly.py',
     'wallet_labels.py',
diff --git a/test/functional/wallet_anchor.py b/test/functional/wallet_anchor.py
diff --git a/test/functional/wallet_listtransactions.py b/test/functional/wallet_listtransactions.py

Original file line number	Diff line number	Diff line change
`@@ -574,9 +574,9 @@ void CNode::CloseSocketDisconnect()`
`574`	`574`	`m_i2p_sam_session.reset();`
`575`	`575`	`}`
`576`	`576`
`577`		`-void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, const CNetAddr &addr, const std::vector<NetWhitelistPermissions>& ranges) const {`
	`577`	`+void CConnman::AddWhitelistPermissionFlags(NetPermissionFlags& flags, std::optional<CNetAddr> addr, const std::vector<NetWhitelistPermissions>& ranges) const {`
`578`	`578`	`for (const auto& subnet : ranges) {`
`579`		`- if (subnet.m_subnet.Match(addr)) {`
	`579`	`+ if (addr.has_value() && subnet.m_subnet.Match(addr.value())) {`
`580`	`580`	`NetPermissions::AddFlag(flags, subnet.m_flags);`
`581`	`581`	`}`
`582`	`582`	`}`
`@@ -1768,7 +1768,11 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,`
`1768`	`1768`	`{`
`1769`	`1769`	`int nInbound = 0;`
`1770`	`1770`
`1771`		`- AddWhitelistPermissionFlags(permission_flags, addr, vWhitelistedRangeIncoming);`
	`1771`	`+ const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();`
	`1772`	`+`
	`1773`	`+ // Tor inbound connections do not reveal the peer's actual network address.`
	`1774`	`+ // Therefore do not apply address-based whitelist permissions to them.`
	`1775`	`+ AddWhitelistPermissionFlags(permission_flags, inbound_onion ? std::optional<CNetAddr>{} : addr, vWhitelistedRangeIncoming);`
`1772`	`1776`
`1773`	`1777`	`{`
`1774`	`1778`	`LOCK(m_nodes_mutex);`
`@@ -1823,7 +1827,6 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,`
`1823`	`1827`	`NodeId id = GetNewNodeId();`
`1824`	`1828`	`uint64_t nonce = GetDeterministicRandomizer(RANDOMIZER_ID_LOCALHOSTNONCE).Write(id).Finalize();`
`1825`	`1829`
`1826`		`- const bool inbound_onion = std::find(m_onion_binds.begin(), m_onion_binds.end(), addr_bind) != m_onion_binds.end();`
`1827`	`1830`	`// The V2Transport transparently falls back to V1 behavior when an incoming V1 connection is`
`1828`	`1831`	`// detected, so use it whenever we signal NODE_P2P_V2.`
`1829`	`1832`	`ServiceFlags local_services = GetLocalServices();`