⚡ Bolt: [performance improvement] optimize IsHex early return for length

.jules/bolt.md

@@ -0,0 +1,58 @@
+
+## 2026-03-20 - Batching RPC calls in functional tests
+**Learning:** Functional tests that make sequential `getblock` or `getblockhash` RPC calls inside loops or comprehensions suffer from N+1 query bottlenecks, leading to slow execution times.
+**Action:** Use `node.batch([node.getblock.get_request(b) for b in blocks])` to batch RPC requests instead of iterating and calling them sequentially.
+
+## 2024-03-25 - Avoid Full Block Downloads for Metadata
+**Learning:** In functional tests, calling `node.getblock(hash)` defaults to returning the entire block including all transactions (verbosity=1). If the test only requires metadata from the header, like the block time or height, this introduces a performance bottleneck due to unnecessary JSON-RPC parsing and payload size.
+**Action:** Use `node.getblockheader(hash)` (or `node.getblockcount()`, `node.getbestblockhash()`) when only header fields are required to minimize test execution time.
+## 2024-11-20 - Optimize String Mutation and Searching
+**Learning:** String mutations using `+=` character-by-character, even with `reserve()`, are significantly slower than copying the string and mutating in-place due to bounds-checking overhead. Additionally, standard library functions like `.find()` on `std::string_view` are heavily optimized (often vectorized) compared to manual character iteration.
+**Action:** When transforming string cases, construct a copy and mutate in-place rather than building a new string character by character. Prefer standard library search functions like `.find()` over manual loops.
+## 2025-05-15 - [External Signer Fingerprint]
+**Learning:** Multiple external signers can be handled by filtering with their master key fingerprint.
+**Action:** Always provide fingerprint when multiple signers might be present.
+
+## 2024-04-22 - Optimize all() in functional tests
+**Learning:** Using list comprehensions within `all()` (e.g., `all([x in y for x in z])`) creates an intermediate list in memory before evaluating `all()`, which defeats the short-circuiting behavior of `all()`.
+**Action:** Use generator expressions instead of list comprehensions within `all()` (e.g., `all(x in y for x in z)`) to leverage short-circuiting and reduce memory allocations, as noted in the memory context.
+## 2026-05-02 - Optimize all() and any() in Python Functional Tests
+**Learning:** Using list comprehensions within `all()` or `any()` (e.g., `all([x in y for x in z])`) forces Python to evaluate the entire list and keep it in memory before applying the short-circuiting logic. This defeats the purpose of early exits and increases memory allocations unnecessarily.
+**Action:** Always use generator expressions instead (e.g., `all(x in y for x in z)`) to allow Python to evaluate items lazily, immediately exiting on the first failure/success and reducing memory overhead.
+## 2024-05-06 - Replace GetStrongRandBytes with GetRandBytes for transient values
+**Learning:** `GetStrongRandBytes` performs slow OS-level entropy gathering and is meant for long-term secure keys. Using it for transient values like network nonces or unique prefixes unnecessarily drains OS entropy and blocks execution, negatively impacting performance. `GetRandBytes` is a fast CSPRNG and is the correct choice for these transient values.
+**Action:** Always prefer `GetRandBytes` for fast, transient network values, and reserve `GetStrongRandBytes` for long-term keys or high-security persistent secrets.
+## 2024-05-14 - Pre-resizing String Encodings Avoids Reallocation Overhead
+**Learning:** When building strings with known or calculable upper-bound sizes, pre-resizing (`str.resize()`) and mutating by index (`str[pos++] = char`) avoids bounds-checking and reallocation overhead, leading to significant CPU efficiency gains compared to repeated character appending (`str += char`), providing an observed 25-35% speedup for string encoders.
+**Action:** For string construction with a predictable max size in performance-critical areas, prefer `resize()` over `reserve()` paired with index-based mutation over `+=` concatenation.
+## 2024-05-18 - Optimize std::regex_replace with string find and replace
+**Learning:** `std::regex_replace` can be extremely slow compared to a manual loop using `std::string::find` and `std::string::replace` when dealing with simple plain-text search and substitution.
+**Action:** Replace `std::regex_replace` with a manual string find and replace loop for plain string substitution where regex matching is not actually needed.
+## 2024-05-14 - Optimize UrlDecode
+**Learning:** The URL decoding path was doing character-by-character string append `+=` inside a loop which requires bounds checking and reallocation. In scenarios where URL encoding is absent or light, pre-sizing the buffer and mutating via index, combined with a `string_view::find()` fast path, provides a measurable CPU efficiency gain (3-4x faster for unencoded URLs).
+**Action:** For string building of known upper-bound size, pre-resize them and mutate via index (`str[pos++] = char`) instead of appending character-by-character.
+## 2024-05-24 - Optimize string concatenation in Base58 encoding
+**Learning:** Using `+=` to append characters in a loop for C++ strings introduces bounds-checking and reallocation overhead.
+**Action:** Pre-allocate the required string size and use iterators to write characters directly, improving performance substantially for hot encoding paths.
+## 2024-05-26 - Precompute lookup tables for character sanitization
+**Learning:** Using `std::string::find` for character filtering inside a loop results in redundant O(M) lookups. Replacing this with a precomputed static boolean array lookup reduces the complexity to O(1) and provides significant measurable speedups in core application string processing.
+**Action:** When filtering or validating strings against fixed character sets in hot paths, use a precomputed boolean array or bitset indexed by the character value instead of linear searches.
+## 2026-06-25 - Optimize util::Split with precomputed table
+**Learning:** The `util::Split` function in `src/util/string.h` was using `std::string_view::find` to search for separators inside a loop. This results in an O(M) lookup for each character, which is slow for a hot path function like string splitting.
+**Action:** Precompute a boolean array of size 256 for the separators, turning the search into an O(1) array lookup. Also optimize the single-character overload to avoid the overhead of building the array.
+## 2024-05-31 - [Pre-pack multi-byte sequences into native integers]
+**Learning:** In C++ performance-critical paths, when mapping a value to a small multi-byte sequence, packing the characters into a single native integer and handling byte order using `std::endian::native` enables the compiler to use a single scalar store instruction, reducing execution time.
+**Action:** Pre-pack characters into a native integer (e.g., `uint16_t`) and store using `memcpy` instead of separate 8-bit stores.
+
+## 2024-06-10 - O(N^2) string replace inside ReplaceAll
+**Learning:** Using std::string::replace inside a while loop causes O(N^2) memory operations because it has to shift the rest of the string on every replacement.
+**Action:** Pre-allocate a new string with reserve() and construct the result using append() to achieve O(N) complexity for multiple substitutions.
+## 2024-05-15 - Array lookup cache efficiency
+**Learning:** Using a boolean array lookup for `IsHex` proved to be slower than the original `HexDigit` check, because `HexDigit` relies on an array `p_util_hexdigit` that is a contiguous 256-element array of signed char and likely fits perfectly into cache.
+**Action:** Always benchmark array lookup vs existing static array lookups.
+## 2026-06-22 - Optimize TrimStringView
+**Learning:** Initializing a 256-element std::array on every function call for string processing in C++ incurs measurable overhead, especially for short strings or frequent calls. std::string_view's find_first_not_of and find_last_not_of are highly optimized and bypass this per-call initialization.
+**Action:** Use standard library string_view algorithms like find_first_not_of/find_last_not_of instead of manual loops with per-call boolean lookup array initializations for optimal string filtering performance.
+## 2024-05-18 - Early return for string length validation
+**Learning:** Functions that validate strings based on both character content and length constraints (like checking if it represents a valid hex sequence) often iterate over the entire string first. If the length constraints (e.g. must be even length) fail, the full iteration was computationally wasteful.
+**Action:** When a string validation function has cheap length or empty-state constraints, check them upfront before performing expensive character-by-character iteration. This provides an O(1) early rejection path.

.jules/sentinel.md

@@ -0,0 +1,60 @@
+## 2024-05-14 - [Auth] Use Strong Randomness for RPC Cookies
+**Vulnerability:** Weak randomness used for generating RPC authentication cookies.
+**Learning:** `GetRandBytes` is designed for 'fast' seeding and does not guarantee strong OS entropy, which is required for cryptographic tokens. `GetStrongRandBytes` must be used.
+**Prevention:** Audit all generation of authentication tokens or secret keys to ensure they use `GetStrongRandBytes`.
+
+## 2024-05-18 - Missing OS-level entropy for secp256k1 blinding seed
+**Vulnerability:** The random blinding seed passed to the `secp256k1` context in `ECC_Start` used `GetRandBytes()` instead of `GetStrongRandBytes()`.
+**Learning:** Using `GetRandBytes()` instead of `GetStrongRandBytes()` for cryptographically secure random values fails to provide OS-level entropy, potentially exposing blinding scalar multiplications to side-channel attacks.
+**Prevention:** Always use `GetStrongRandBytes()` when generating cryptographically secure random values (such as authentication cookies or keys) to ensure OS-level entropy.
+
+## 2024-05-18 - [HTTP] Add Security Headers
+**Vulnerability:** Missing HTTP security headers (X-Frame-Options, X-Content-Type-Options, Content-Security-Policy).
+**Learning:** The HTTP RPC server was vulnerable to clickjacking, MIME-sniffing, and potentially XSS. These headers must be set globally on all responses.
+**Prevention:** Always set global security headers for all responses in the core HTTP handling logic (`HTTPRequest::WriteReply`).
+## 2024-05-15 - [P2P Denial of Service via Unhandled Statuses]
+**Vulnerability:** A generic catch-all `if (status != READ_STATUS_OK)` implicitly ignored specific error states (`READ_STATUS_INVALID`) returned by `PartiallyDownloadedBlock::InitData`, missing the opportunity to penalize malicious peers sending invalid compact blocks via `Misbehaving`.
+**Learning:** Code blocks annotated with "TODO: don't ignore failures" often mask real DoS vectors. Security by disconnection relies on active policing of protocol anomalies.
+**Prevention:** Always handle specific return codes representing explicitly malicious data or protocol violations (e.g., `READ_STATUS_INVALID`) before relying on generic error exits to ensure robust network defense.
+## 2024-04-14 - Fix fail-open vulnerability in compact block initialization
+**Vulnerability:** Unrecognized or new `ReadStatus` enum values in `PartiallyDownloadedBlock::InitData` caused a fail-open state where initialization failures were ignored, processing potentially uninitialized compact blocks.
+**Learning:** Generic error handlers must use an outer `if (status != READ_STATUS_OK)` fallback rather than explicitly checking for specific known error conditions, to ensure safe fail-closed behavior if new errors are added.
+**Prevention:** Always maintain a secure fail-closed pattern (`if (status != OK) return;`) outside of specific status checks.
+## 2026-04-18 - Fix fail-open error handling in net_processing
+**Vulnerability:** The error handling for compact block construction in `src/net_processing.cpp` used an explicit equality check `if (status == READ_STATUS_INVALID)` and `if (status == READ_STATUS_FAILED)`. If a new `ReadStatus` value was added, it would fall through to the block success path, improperly parsing and applying invalid/malicious data.
+**Learning:** Checking for equality of explicit failure enums causes insecure, fail-open vulnerabilities if the enum expands over time.
+**Prevention:** Instead of explicit comparisons, default to securely closing the error scope using a negated check: `if (status != READ_STATUS_OK)`.
+## 2024-05-24 - SQLite PRAGMA Parameterization
+**Vulnerability:** SQL injection potential due to using `strprintf` to construct PRAGMA statements with unsanitized user inputs.
+**Learning:** SQLite PRAGMA statements do not support standard `?` parameter binding. This requires manual string construction which is prone to injection if not done safely.
+**Prevention:** Construct PRAGMA statements using `sqlite3_mprintf` with `%w` for identifiers and `%Q` for values, then free the resulting pointer with `sqlite3_free`.
+## 2025-05-23 - [Harden Notification Command Execution]
+**Vulnerability:** Command Injection in shell-executed notifications.
+**Learning:** Functions like AlertNotify were manually sanitizing and quoting interpolated strings, which is brittle and potentially bypassable compared to standard escaping utilities.
+**Prevention:** Use ShellEscape for all data interpolation in shell commands on supported platforms, and explicitly warn against unescaped interpolation in any code path that executes commands via the shell.
+
+## 2026-05-16 - Prevent Argument Splitting in Windows Shell Executions
+**Vulnerability:** Windows cmd.exe single-quote argument injection. The safeStatus interpolation used single quotes (`'`), which cmd.exe treats as literal characters rather than string delimiters. This causes spaces in the sanitized string to be parsed as argument separators.
+**Learning:** Unlike POSIX shells, Windows cmd.exe does not support single quotes for string escaping or grouping. When using `_wsystem()` on Windows, single-quoted strings containing spaces will be split into multiple arguments, potentially altering command behavior.
+**Prevention:** Always use double quotes (`"`) when interpolating strings into Windows shell commands, or omit quoting entirely if the input is guaranteed to be safe and without spaces (like hex strings).
+## 2024-05-18 - Missing Failure Handling in Compact Blocks
+**Vulnerability:** Ignored initialization failures (READ_STATUS_INVALID) when processing optimistic compact blocks from peers.
+**Learning:** Returning early without penalizing peers on invalid data permits misbehaving nodes to evade bans, exposing the node to denial of service or resource exhaustion risks.
+**Prevention:** Always implement explicit failure modes in catch-all error handling blocks; invalid peer data must trigger `Misbehaving()` to protect network resources.
+## 2024-05-24 - [State Inconsistency] Missing Error Return on Block Flush
+**Vulnerability:** The node ignored failures when flushing block files to disk in `Chainstate::FlushStateToDisk`, allowing it to proceed with flushing the coins database. This could lead to inconsistent state on restart.
+**Learning:** In critical disk I/O operations, failing to handle errors can cause cascading failures and corrupt state. Critical failures must halt progression.
+**Prevention:** Always handle failures in critical disk I/O operations (like `FlushChainstateBlockFile`) by returning `FatalError` to prevent the node from entering an inconsistent state.
+## 2024-05-30 - Fix fail-open enum handling in net_processing.cpp
+**Vulnerability:** Switch-like enum checks on `ReadStatus` without a default failure branch allowed unrecognized error states to return silently instead of triggering `Misbehaving()`.
+**Learning:** Explicitly checking for all known error states and failing silently otherwise creates fail-open vulnerabilities if the enum expands over time.
+**Prevention:** Use a negated check against the success state and ensure the inner logic uses a default `else` block to securely handle all unrecognized failure modes as severe errors.
+
+## 2024-06-16 - [DoS] Fix fail-open enum handling in net_processing.cpp
+**Vulnerability:** Explicit switch-like checks on the `ReadStatus` enum (e.g. `if (status == READ_STATUS_OK)`) failed to penalize peers when returning unexpected values, leading to a fail-open DoS vulnerability.
+**Learning:** Checking for equality of explicit failure enums causes insecure, fail-open vulnerabilities if the enum expands over time. A negated success check is necessary to ensure new unhandled states trigger safe, closed behavior.
+**Prevention:** Default to securely closing the error scope using a negated check: `if (status != READ_STATUS_OK)`. Ensure inner scopes correctly handle `READ_STATUS_FAILED` separately from explicitly malicious states that must invoke `Misbehaving`.
+## 2024-06-21 - [Fix fail-open vulnerability in ReadStatus handling]
+**Vulnerability:** Missing default `else` block and missing early `return` for unrecognized `ReadStatus` enum states, potentially leading to fail-open vulnerabilities.
+**Learning:** When handling enum-based status codes in C++, explicit equality checks or missing default handlers for error conditions can cause vulnerabilities if the enum expands.
+**Prevention:** Use a negated check against the success state and ensure the inner logic uses a default `else` block with an early `return` to securely handle all unrecognized failure modes.

src/base58.cpp

@@ -118,11 +118,10 @@ std::string EncodeBase58(std::span<const unsigned char> input)
     while (it != b58.end() && *it == 0)
         it++;
     // Translate the result into a string.
-    std::string str;
-    str.reserve(zeroes + (b58.end() - it));
-    str.assign(zeroes, '1');
+    std::string str(zeroes + (b58.end() - it), '1');
+    auto out_it = str.begin() + zeroes;
     while (it != b58.end())
-        str += pszBase58[*(it++)];
+        *(out_it++) = pszBase58[*(it++)];
     return str;
 }
 

src/bench/wallet_create.cpp

@@ -46,7 +46,7 @@ static void WalletCreate(benchmark::Bench& bench, bool encrypted)
 
     auto wallet_path = fs::PathToString(test_setup->m_path_root / "test_wallet");
     bench.run([&] {
-        auto wallet = CreateWallet(context, wallet_path, /*load_on_start=*/std::nullopt, options, status, error_string, warnings);
+        auto wallet = CreateWallet(context, wallet_path, /*load_on_start=*/std::nullopt, options, status, error_string, warnings, /*account=*/0);
         assert(status == DatabaseStatus::SUCCESS);
         assert(wallet != nullptr);