Monero

This is a small user-experience fix for the Monero wallet's auto-refresh feature. When a user turns on auto-refresh, the wallet will now refresh on the next idle tick instead of waiting a full period first. There is no security bug being fixed here based on the commit content.

This commit adds three new cryptographic generator points (named T, U, and V) to Monero's code. These are special numbers used in a new privacy feature called FCMP++. The commit also adds helper functions to recreate and access these generators. There is no indication of a security bug or vulnerability in this change; it is a straightforward addition of constants needed for future protocol work.

This commit adds a safety check in Monero's wallet code before accessing a list of 'additional derivations' by output index. Previously, if the list was shorter than expected, the code could read past its end (an out-of-bounds read). The patch throws a controlled wallet error instead of crashing or reading invalid memory. The most likely risk is a wallet crash or incorrect output detection when processing malformed or unusual transaction data, rather than direct theft of funds.

This commit adds a safety check in Monero's command-line wallet. When the wallet asks the network node (daemon) for details about certain transaction outputs, it now verifies that the daemon actually returned the same number of results that were requested. Without this check, a malicious or buggy daemon could return fewer (or conceivably different) output records than expected, which might cause the wallet to misread ring member data when displaying or analyzing transactions. The patch is small and defensive; it does not by itself prove an exploitable vulnerability, but it closes a trust boundary gap between the wallet and the daemon.

This patch changes how a Monero wallet waits for background worker threads while scanning incoming blocks. Previously, one shared waiter object was used across three separate multi-threaded stages. Now each stage gets its own waiter, so the wallet correctly waits for each batch of tasks to finish before starting the next stage. The commit title says it fixes 'task lifetime' issues, which suggests the old code could have allowed threads to keep running while later code already read or overwrote their data. That kind of bug can lead to crashes or incorrect wallet balance/transaction detection, but the patch does not by itself prove remote theft of funds is possible.

This commit removes the 'bootstrap mode' feature from the Monero daemon. Bootstrap mode let a not-yet-fully-synced local daemon forward wallet and mining RPC requests to a remote daemon. Removing it means wallets and miners now only get data from the local daemon. This is a hardening change: it shrinks the attack surface by eliminating a feature that could expose users to untrusted remote nodes, but it is not a fix for a specific known exploit.

This commit adds two new math helper functions that convert points between two related elliptic-curve formats used in cryptography (Ed25519 and X25519). It is a pure addition of utility code; there is no bug fix, no change to existing behavior, and no indication it addresses a security flaw. The code includes a safety check that rejects the special 'identity' (zero) point, which is a sensible defensive measure.

This is a one-line build-system change that adds a missing library dependency ('wire') so another component can compile and link correctly. There is no indication it fixes a security vulnerability; it appears to be a routine build fix.

This update adds safety checks to the Monero wallet software to detect and stop use of corrupted or tampered wallet cache data. Specifically, it verifies that internal indexes pointing to past transfers are not larger than the actual list of transfers. Without these checks, a damaged or maliciously crafted wallet cache could cause the wallet to read from invalid memory locations, potentially leading to crashes or unpredictable behavior. The change is defensive hardening rather than a fix for an active remote attack.

This commit removes compiler directives that forced certain cryptographic data structures to be packed tightly without padding, and replaces some direct multi-byte memory reads with safer memcpy operations. On some processors, reading a multi-byte value from a memory address that is not aligned to that value's size can cause a crash or reduced performance. The change makes the code safer and more portable across different CPU architectures, but it does not appear to fix an exploitable remote vulnerability in the Monero network itself.

This commit fixes a bug in Monero's wallet API where the recipientAddress() function only returned the first recipient of an unsigned transaction, even when the transaction had multiple recipients. Now it returns all recipients. This is primarily a correctness/functional bug fix. A possible minor security angle is that downstream code relying on recipientAddress() to verify all payment destinations could have been misled into thinking only one recipient existed, but the commit itself does not describe any security impact and no exploit path is evident from the diff.

This commit fixes the way a Monero cryptographic function for ARMv8 processors describes its inline assembly code to the C compiler. Previously, the assembly block did not properly tell the compiler which memory and CPU registers it reads and writes. This can lead to subtle bugs where the compiler optimizes code incorrectly around the assembly, potentially causing wrong hash results or memory corruption on ARMv8 devices. The fix adds proper input/output constraints and a clobber list so the compiler knows exactly what the assembly touches.

This commit adds a type check in Monero's JSON deserialization code. Before the fix, when reading a RingCT signature from JSON, the code assumed the 'prunable' field was a JSON object and accessed it directly. If someone supplied a non-object value (like a number or string), the code could read memory incorrectly or crash. The patch now throws a clear error if the type is wrong.

This commit adds a new internal helper function in Monero's experimental FCMP++ (Forward-Commitment Membership Proof) code. It converts transaction output data into an intermediate mathematical representation called a 'pre-leaf tuple' by computing derivatives of elliptic-curve points. There is no user-facing change, no bug fix, and no security-relevant behavior described in the commit or diff.

This commit adds new code for an upcoming Monero privacy feature called FCMP++. It creates a helper function that converts an output's public key and commitment into a special three-part tuple used by the new system. The commit is defensive in nature: it carefully clears mathematical 'torsion' from points, rejects identity points, and explicitly avoids a subtle double-spend risk that could occur if the wrong version of a key were used around a network upgrade. There is no indication this commit fixes an active bug or vulnerability; it appears to be a building block for future functionality.

This Monero wallet patch changes how the wallet decides whether an encrypted payment ID is real or a dummy placeholder. Previously, the wallet relied on destination address data (cd.dests), which could be manipulated by a malicious signer or loaded transaction to make a real payment ID look fake, or a fake one look real. The patch now derives that status directly from the transaction's extra field, where the payment ID is actually stored, and adds a consistency check. This is a security fix for a potential information leak or user deception during multi-step transaction signing.

This commit simply deletes unused code from Monero's network synchronization module. It removes functions, macros, and declarations that were never called or had no definition. There is no change to active behavior, no bug fix, and no security-relevant change.

This commit simply deletes unused functions and one unused inline helper from Monero's RingCT code. The removed code was never called by any part of the program, so the change cannot introduce or fix a security vulnerability on its own. It is a routine cleanup that reduces clutter and maintenance burden.

This commit changes a single log message from 'Device inited...' to 'Device initiated...' in the Monero wallet code. It is purely a wording/spelling fix with no functional or security effect.

This is a small cleanup change in Monero's command-line wallet. It moves a call that retrieves a transaction's secret key so it only runs when the user actually asked to export keys. Previously, the key was retrieved for every exported transfer even if keys were not being exported. There is no direct security vulnerability here, but retrieving secret key material unnecessarily is a minor defensive-coding concern.

This commit is a test-infrastructure change for the Monero wallet API. It makes existing integration tests runnable under the automated CTest framework by spinning up a temporary local blockchain instead of relying on external testnet nodes. It also adds a few new test cases and exposes two small helper methods in the wallet API so tests can configure daemon-version mismatch tolerance and a custom ring database path. There is no obvious security vulnerability in the changes, and the commit does not describe itself as a security fix.

This commit updates the bundled RandomX library (used for Monero's mining proof-of-work) from one version to version 1.2.3. The actual code changes are not visible because the diff was not provided, and no security references were supplied. On its own, the commit message only says 'update to v1.2.3' and does not claim to fix any security issue.

This is a large internal cleanup commit in the Monero codebase. It replaces an older scope-guard helper (auto_scope_leave_caller) with a newer, simpler scope_guard type, trims unused #include lines, and replaces a few value-initialization macros with direct C++ syntax. There is no direct evidence in the commit message or diff that this fixes a security vulnerability; it appears to be a refactoring and code-quality improvement. The changes touch many files but do not alter program logic in a way that is obviously exploitable.

This commit removes a custom hash comparison helper that was used to sort transaction hashes in the memory pool data structure. The code now relies on Boost's default comparison for the hash type. There is no visible security change: the removed comparator behaved the same as the standard less-than comparison for the hash data, and no behavior or interface changes are apparent.

This commit adds new cryptographic routines to Monero and renames an existing one. It introduces a new way to derive 'key image generators' (used to prove a coin hasn't been spent twice) and a new 'unbiased' method for hashing data to an elliptic-curve point. The old method is now explicitly labeled 'biased' but remains in use for existing ring signatures. The changes are presented as a research-driven cryptographic improvement, not as a fix for an active bug or vulnerability.