Merge branch '2025/10/test-fails'

Author: Sjors

AGENTS.md

@@ -3,6 +3,7 @@
 To keep the repository tidy and easy to maintain, automated agents should follow these principles:
 
 - **Follow established style.** Consult the developer guidelines in [`doc/developer-notes.md`](doc/developer-notes.md) before writing or editing code. Adhere to the documented formatting, naming, and documentation conventions unless the project maintainers request otherwise.
+- **Mind indentation-sensitive formats.** When touching YAML, Python, Markdown lists, or other whitespace-aware files, preserve the existing indentation levels and continuation alignment. Prefer editing tools like `apply_patch` that keep surrounding context intact, and re-read the affected block before saving to avoid shifting keys or breaking workflows.
 - **Delete obsolete source files.** When retiring code, prefer removing the corresponding files outright instead of leaving stub implementations (for example, those containing only `#error` guards).
 - **Confirm large refactors.** When a deletion task appears to require non-trivial refactoring elsewhere, pause and ask for confirmation first—consider whether removing the code you're about to refactor is a better alternative.
 - **Update build metadata.** After deleting files, ensure any build scripts, project files, or documentation lists referencing them are updated accordingly.

contrib/devtools/README.md

@@ -134,16 +134,6 @@ For example:
 BUILDDIR=$PWD/my-build-dir contrib/devtools/gen-manpages.py
 ```
 
-headerssync-params.py
-=====================
-
-A script to generate optimal parameters for the headerssync module (src/headerssync.cpp). It takes no command-line
-options, as all its configuration is set at the top of the file. It runs many times faster inside PyPy. Invocation:
-
-```bash
-pypy3 contrib/devtools/headerssync-params.py
-```
-
 gen-bitcoin-conf.sh
 ===================
 

contrib/devtools/headerssync-params.py

@@ -12,6 +12,9 @@
 #include <util/thread.h>
 #include <streams.h>
 
+#include <algorithm>
+#include <limits>
+
 Sv2TemplateProvider::Sv2TemplateProvider(interfaces::Mining& mining) : m_mining{mining}
 {
     // TODO: persist static key
@@ -72,11 +75,12 @@ Sv2TemplateProvider::Sv2TemplateProvider(interfaces::Mining& mining) : m_mining{
     LogTrace(BCLog::SV2, "Authority key: %s\n", HexStr(m_authority_pubkey));
 
     // Generate and sign certificate
-    auto now{GetTime<std::chrono::seconds>()};
-    uint16_t version = 0;
+    const int64_t now_seconds{std::max<int64_t>(GetTime<std::chrono::seconds>().count(), 0)};
     // Start validity a little bit in the past to account for clock difference
-    uint32_t valid_from = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(now).count()) - 3600;
-    uint32_t valid_to =  std::numeric_limits<unsigned int>::max(); // 2106
+    const int64_t backdated{std::max<int64_t>(now_seconds - int64_t{3600}, 0)};
+    const uint32_t valid_from{static_cast<uint32_t>(std::min<int64_t>(backdated, std::numeric_limits<uint32_t>::max()))};
+    const uint32_t valid_to{std::numeric_limits<uint32_t>::max()}; // 2106
+    uint16_t version = 0;
     Sv2SignatureNoiseMessage certificate = Sv2SignatureNoiseMessage(version, valid_from, valid_to, XOnlyPubKey(static_key.GetPubKey()), authority_key);
 
     m_connman = std::make_unique<Sv2Connman>(TP_SUBPROTOCOL, static_key, m_authority_pubkey, certificate);

src/sv2/template_provider.cpp

@@ -43,12 +43,10 @@ class ConnTester : Sv2EventsInterface {
         m_connman_authority_pubkey = XOnlyPubKey(authority_key.GetPubKey());
 
         // Generate and sign certificate
-        auto now{GetTime<std::chrono::seconds>()};
-        uint16_t version = 0;
-        // Start validity a little bit in the past to account for clock difference
-        uint32_t valid_from = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(now).count()) - 3600;
-        uint32_t valid_to =  std::numeric_limits<unsigned int>::max(); // 2106
-        Sv2SignatureNoiseMessage certificate{version, valid_from, valid_to, XOnlyPubKey(static_key.GetPubKey()), authority_key};
+        uint32_t now_secs{0};
+        uint32_t valid_from{0};
+        uint32_t valid_to{0};
+        Sv2SignatureNoiseMessage certificate = MakeSkewTolerantCertificate(static_key, authority_key, now_secs, valid_from, valid_to);
 
         m_connman = std::make_unique<Sv2Connman>(TP_SUBPROTOCOL, static_key, m_connman_authority_pubkey, certificate);
 

src/test/sv2_connman_tests.cpp

@@ -5,18 +5,18 @@
 #ifndef BITCOIN_TEST_SV2_MOCK_MINING_H
 #define BITCOIN_TEST_SV2_MOCK_MINING_H
 
-#include <interfaces/mining.h>
-#include <script/script.h>
-#include <sync.h>
-#include <uint256.h>
-#include <primitives/transaction.h>
-
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <queue>
 #include <vector>
 
+#include <interfaces/mining.h>
+#include <primitives/transaction.h>
+#include <script/script.h>
+#include <sync.h>
+#include <uint256.h>
+
 // Minimal mocks for the Mining IPC interface used by sv2 tests.
 
 struct MockEvent {

src/test/sv2_mock_mining.h

@@ -18,6 +18,9 @@ Sv2BasicTestingSetup::Sv2BasicTestingSetup()
     // Select a default chain for tests to satisfy BaseParams() users.
     SelectBaseParams(ChainType::REGTEST);
 
+    // Default mock time anchored to Bitcoin genesis so certificate helpers see a realistic clock.
+    SetMockTime(TEST_GENESIS_TIME);
+
     // Create an isolated temporary datadir for this test process.
     const auto micros = count_microseconds(Now<SteadyMicroseconds>().time_since_epoch());
     const std::string subdir = util::Join(std::array<std::string, 2>{"sv2_tests", util::ToString(micros)}, "");
@@ -37,6 +40,8 @@ Sv2BasicTestingSetup::Sv2BasicTestingSetup()
 
 Sv2BasicTestingSetup::~Sv2BasicTestingSetup()
 {
+    SetMockTime(std::chrono::seconds{0});
+
     try {
         fs::remove_all(m_tmp_root);
     } catch (const std::exception&) {

src/test/sv2_test_setup.cpp

@@ -5,15 +5,16 @@
 #ifndef BITCOIN_TEST_SV2_TEST_SETUP_H
 #define BITCOIN_TEST_SV2_TEST_SETUP_H
 
-#include <test/util/random.h>
-#include <util/fs.h>
-#include <memory>
+#include <algorithm>
 #include <chrono>
 #include <limits>
+#include <memory>
 
-// SV2 noise / keys
-#include <sv2/noise.h>
 #include <key.h>
+#include <sv2/noise.h>
+#include <test/util/random.h>
+#include <util/fs.h>
+#include <util/time.h>
 
 /**
  * Helper to build a skew-tolerant test certificate.
@@ -33,14 +34,22 @@ inline Sv2SignatureNoiseMessage MakeSkewTolerantCertificate(const CKey& static_k
                                                            uint32_t backdate_secs = 3600,
                                                            uint16_t version = 0)
 {
-    auto epoch_now = std::chrono::system_clock::now().time_since_epoch();
-    out_now = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(epoch_now).count());
-    out_valid_from = out_now - backdate_secs; // tolerate backward jumps / skew
+    const auto now = GetTime<std::chrono::seconds>();
+    const int64_t now_count = now.count();
+    const int64_t clamped_now = std::max<int64_t>(0, now_count);
+    out_now = static_cast<uint32_t>(clamped_now);
+
+    const int64_t backdated = std::max<int64_t>(0, clamped_now - static_cast<int64_t>(backdate_secs));
+    out_valid_from = static_cast<uint32_t>(backdated);
     out_valid_to = std::numeric_limits<unsigned int>::max();
+
     return Sv2SignatureNoiseMessage(version, out_valid_from, out_valid_to,
                                     XOnlyPubKey(static_key.GetPubKey()), authority_key);
 }
 
+//! Default mock time for SV2 unit tests: Bitcoin genesis block timestamp (2009-01-03).
+inline constexpr std::chrono::seconds TEST_GENESIS_TIME{1231006505};
+
 
 class ECC_Context;
 

src/test/sv2_test_setup.h

@@ -59,13 +59,10 @@ class Sv2TransportTester
         auto responder_authority_key{GenerateRandomKey()};
 
         // Create certificates
-        auto epoch_now = std::chrono::system_clock::now().time_since_epoch();
-        uint16_t version = 0;
-        uint32_t valid_from = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(epoch_now).count());
-        uint32_t valid_to =  std::numeric_limits<unsigned int>::max();
-
-        auto responder_certificate = Sv2SignatureNoiseMessage(version, valid_from, valid_to,
-                                    XOnlyPubKey(responder_static_key.GetPubKey()), responder_authority_key);
+        uint32_t now_secs{0};
+        uint32_t valid_from{0};
+        uint32_t valid_to{0};
+        auto responder_certificate = MakeSkewTolerantCertificate(responder_static_key, responder_authority_key, now_secs, valid_from, valid_to);
 
         if (test_initiator) {
             m_transport = std::make_unique<Sv2Transport>(initiator_static_key, XOnlyPubKey(responder_authority_key.GetPubKey()));