Monero

This commit changes a default setting for how many threads Monero uses when preparing block hashes. Previously it was hardcoded to 4 threads; now it uses the number of CPU cores the computer reports (falling back to 4 if that number can't be determined). This is a performance tuning change, not a security fix. There is no direct evidence in the commit that it addresses a vulnerability.

This commit changes only a single word in the help text of the Monero command-line wallet's 'transfer' command. It swaps the order of two placeholders in the description from 'Transfer <amount> to <address>' to 'Transfer <address> <amount>' so the wording matches the actual command syntax. There is no code change, no security fix, and no behavior change.

This commit is a performance optimization for Monero's transaction memory pool. When one node asks another for transactions it is missing, the old code compared every requested hash against every pool transaction one-by-one, which becomes extremely slow when the pool is large (tens of thousands of transactions). The new code sorts the requested hashes once and uses binary search, cutting the work by roughly 99.8%. The main security-relevant angle is that the old code could be abused to make a node waste CPU time, potentially contributing to a denial-of-service condition.

This commit simply deletes two old build-system patch files that are no longer used. The patches were designed to make builds more reproducible by removing timestamps and real git revision numbers from compiled tools. Removing the patches does not change any active code or build behavior, because the patches were already unused. There is no security issue here.

This commit removes a recently added C preprocessor helper that automatically inserted commas before extra macro arguments. It reverts two serialization macros back to older, simpler forms that no longer accept extra trailing arguments. The change likely fixes build or compatibility problems caused by the new helper, especially on compilers that handle variadic macros differently. There is no direct evidence in the commit that this fixes an exploitable security vulnerability.

This commit simply removes an optional developer-only CMake target called 'iwyu' (include-what-you-use). It was a helper for cleaning up C++ #include statements and was never part of the compiled Monero software that users run. There is no security issue here.

This commit changes how a Monero node announces a newly found block to peers. Previously, the node would fetch and attach the actual transaction data to the announcement. After the change, it sends an 'empty fluffy block' announcement that contains only the block header and a list of transaction hashes, leaving peers to request missing transactions themselves. This is a network-efficiency optimization, but it removes a local consistency check and shifts responsibility for transaction availability to peers.

This fix corrects a bookkeeping bug in Monero's transaction memory pool. The pool tracks its total weight (size) and prunes transactions when it thinks it is too full. Because the same transaction could be counted twice—once when relayed privately and again when received from another peer—the pool could believe it was over its weight limit and remove transactions prematurely. This could make the node behave differently from honest nodes, potentially affecting transaction relay and network consistency, but it does not directly steal funds or break cryptography.

This change hardens how the Monero wallet software talks to a Ledger hardware wallet. Previously, if the user rejected exporting the secret view key from the Ledger, the software silently accepted a fake placeholder key and continued with reduced functionality. Now the software throws a clear error and stops. This prevents a scenario where the wallet might proceed in a confused state after the user explicitly denied key export.

This patch fixes a deadlock bug in Monero's logging system. A deadlock is a situation where two or more parts of the program get stuck waiting on each other forever, which can freeze the software. The fix changes how log messages are built so that user-provided code (which might itself use locks) is evaluated before the logger takes its own internal lock, preventing the logger's lock and user locks from being held at the same time in a way that could cause a freeze. The commit includes a new test that reproduces the deadlock scenario.

This patch fixes a bookkeeping bug in how Monero decides which blockchain blocks to request next from peers. Previously, when two requested block ranges overlapped, the node could incorrectly think it already had a block it did not have, causing it to skip asking for that block. That could stall synchronization or leave a node stuck on an older chain. The fix correctly merges overlapping or adjacent ranges when calculating the next missing height.

This commit is a routine maintenance update that adds a new blockchain checkpoint and updates version references in documentation. Checkpoints are a normal mechanism that help Monero nodes agree on the correct chain history and speed up initial synchronization. There is no indication of a security fix, vulnerability, or malicious change in the diff.

This change makes Monero's blockchain rewind operation stop early if the user sends an interrupt signal (Ctrl-C). Previously, the code would keep popping blocks even after being told to cancel, which could leave the blockchain database in an inconsistent or poorly defined state. The fix is a one-line check of a cancellation flag inside the loop that removes blocks.

This commit is titled 'rpc: remove COMMAND_RPC_SUBMIT_RAW_TX', but the actual diff supplied is not an RPC removal. It is a massive initial import or re-import of the entire Monero repository (693,211 added lines across 1,360 files). No security-relevant code change is visible in the provided diff, and the diff does not show the removal of any RPC command. The supplied materials are inconsistent with the commit title.

This Monero commit changes how payment IDs are handled when the wallet receives money. Previously, the user-facing wallet interface (simplewallet) decrypted the payment ID itself from transaction data. Now, the core wallet engine (wallet2) decrypts or extracts the payment ID earlier in processing and passes the already-decrypted value to the interface. This is mostly a code cleanup and consistency improvement. It does not appear to be a security fix on its own, but it touches privacy-sensitive payment ID handling and removes duplicated decryption logic.

This commit removes compiler directives that forced a tightly packed memory layout for Monero peer list data structures. The old packing caused shared-pointer fields inside network addresses to be stored at unaligned memory addresses, which can trigger crashes or subtle memory corruption on some CPU architectures. The fix restores normal alignment. It is a stability/reliability fix with possible security side effects rather than a clearly exploitable vulnerability.