A user receives Monero but wants to verify the payment without revealing their wallet address to a node operator. Traditional wallets require sending wallet information to a server to check balances and scan for incoming transactions. That server then knows an IP address, wallet activity timing, and potentially the user’s financial history. XMRWallet, as a non-custodial monero wallet, reverses that relationship by keeping private key material on the user’s device and using cryptographic view keys to scan transactions locally without exposing identity to blockchain infrastructure.

The distinction is not merely convenient. It is architectural. XMRWallet does not create accounts, store passwords on servers, or maintain access control lists. Instead, the wallet generates and derives cryptographic keys locally, then uses those keys to perform transaction scanning in isolation. A user’s ability to access the wallet depends entirely on possessing the recovery seed or encrypted wallet file—not on being granted permission by a service provider. This approach creates different security and privacy properties than traditional custodial systems, but it also requires users to understand how those keys function and what view keys actually reveal.

How view keys enable private transaction scanning

The core innovation in Monero’s privacy model is the separation of spend keys and view keys. A spend key allows a user to initiate outgoing transactions and prove ownership. A view key allows anyone holding it to scan the blockchain and identify payments received by that wallet, but does not permit spending or transferring funds. This asymmetry is the foundation of how XMRWallet maintains privacy during blockchain synchronization.

When a user creates or imports a monero wallet in XMRWallet, the wallet derives both the view key and spend key from the recovery seed. The spend key remains protected on the device and is used only when signing outgoing transactions. The view key, however, becomes the tool for scanning the Monero blockchain to find incoming payments. A third party given only the view key can see all incoming transactions to that wallet, but cannot spend those funds or prevent the owner from spending them. This is why view keys are sometimes described as “watch-only” keys, although that term underestimates their actual purpose in the transaction scanning workflow.

The technical process is straightforward in principle but significant in practice. As the wallet synchronizes with the blockchain, it derives key images from each transaction’s outputs. A key image is a one-way cryptographic commitment that proves knowledge of the private key without exposing the key itself. XMRWallet uses the view key to generate these key images locally and then searches the blockchain for matches. When a match is found, the wallet recognizes the transaction as incoming and updates the balance. All of this computation occurs on the user’s device. The node operator or network observer sees only that the wallet connected and requested blocks, not which specific transactions the user owns.

This is the critical difference from transparent blockchains or naive privacy designs. In Bitcoin or Ethereum, examining received transactions requires either revealing the wallet address to a node or downloading and scanning the entire blockchain on the user’s device. XMRWallet avoids both extremes through the view key mechanism. The wallet can connect to a remote or local Monero node and request blocks without exposing which transactions it is interested in. The node cannot determine ownership relationships or link transactions to an identity because the scanning happens on the client side using a mathematical construction that does not require revealing the wallet’s transaction interests.

Private view and spend key derivation on the device

XMRWallet generates all keys locally from the 25-word recovery seed. This recovery seed is the root secret from which the monero wallet derives both the view key and spend key. The derivation process follows Monero’s standard KDF (key derivation function), which means a user who has backed up the seed can reconstruct the exact same keys on any compatible device. No server interaction occurs during key generation.

The local derivation has immediate security implications. Because the seed and keys are generated on the user’s device, they are never transmitted to XMRWallet’s servers or intermediate services. The user’s responsibility is to protect the seed itself—through physical backup, encryption, or secure storage. Once the seed is protected, the keys derived from it are also implicitly secure so long as the device itself remains uncompromised.

Spend key isolation is equally important. During normal wallet operation, the spend key is used only when the user initiates a transaction. XMRWallet signs the transaction locally on the device and then broadcasts the signed transaction to a Monero node. The node receives only the signed transaction and has no access to the spend key itself. This is fundamentally different from accounts where a service provider holds or escrows access to private key material. In XMRWallet, the service provider cannot intercede in transaction signing even if requested to do so.

A user can optionally protect both the recovery seed and encrypted wallet file with a PIN or password. This second layer of protection ensures that physical possession of the device alone is not sufficient to access funds. An attacker would need both the device and the PIN. This protection is local and does not depend on any server-side password verification. XMRWallet simply encrypts the wallet file locally and requires the user to provide the correct PIN or password to decrypt it during startup.

Blockchain synchronization without exposing transaction interest

When XMRWallet connects to a node for blockchain synchronization, the user can choose a remote node operated by a third party, run their own local node, or connect through Tor for additional network privacy. Regardless of the choice, the synchronization process preserves transaction privacy by never revealing which specific transactions the wallet owns.

The wallet requests blocks from the node in sequence. A node operator can observe that a user connected from a particular IP address at a particular time and requested certain blocks. However, the operator cannot determine which outputs within those blocks belong to the wallet’s owner. This is because XMRWallet performs the matching computation on the user’s device using the view key. The node never sees the view key or the wallet’s addresses. It simply receives block requests and returns block data.

This design creates a meaningful privacy boundary. A traditional custodial wallet or a poorly designed privacy wallet might send an address to a node and ask, “Does this address appear in the blockchain?” The node immediately learns the address and can link it to the user’s IP address and connection behavior. XMRWallet instead downloads sufficient blocks and scans them locally. The cost is that blockchain synchronization takes longer and uses more bandwidth, but the privacy benefit is that the node operator cannot determine wallet ownership.

Synchronization time depends on wallet age and network conditions. A newly created wallet syncs quickly because there are no prior transactions to match. A wallet that has been receiving payments for years requires scanning more of the blockchain history, which takes additional time and bandwidth. Users can accelerate synchronization by restoring from a known block height if they remember when the wallet was created. Local node synchronization is slowest but provides the strongest privacy, as the user operates their own infrastructure and requires no external service for transaction scanning.

Why nodes cannot determine wallet ownership

The mathematical reason for this privacy property lies in how Monero’s stealth addresses and one-time keys work. Each payment to a Monero wallet generates a unique, random public key that serves as the payment destination. Without the view key, it is computationally infeasible to determine whether a given output belongs to a given wallet. Even a node operator with complete visibility of all blockchain transactions cannot identify which ones are received by a particular wallet unless they possess the view key.

A compromised or dishonest node operator might attempt to infer wallet relationships through timing analysis, IP address correlation, or requests for the same blocks across multiple sessions. Tor can mitigate IP address exposure. Connection randomization and avoiding predictable patterns can reduce timing analysis. However, the fundamental protection is that the node operator has no cryptographic way to determine ownership even if they observe the connection.

This is why the distinction between remote node and local node is important but not decisive for transaction privacy. A remote node cannot identify your wallet’s transactions even if it wanted to. But a remote node can observe connection metadata such as when you connect and from which IP address. A local node run by the user eliminates this metadata exposure, though it requires more disk space and computational resources. Neither approach is “wrong”—the choice depends on the user’s threat model and tolerance for resource consumption.

Some users also employ Tor or I2P proxies to hide their IP address even when connecting to a remote node. This adds another layer by preventing the node operator from correlating wallet connections to network identity. The combination of client-side view key scanning, remote or local node options, and optional Tor routing provides multiple privacy controls that a user can combine according to their security requirements. XMRWallet as a monero wallet implements these options to give users transparent control over their privacy posture.

Local blockchain synchronization and wallet verification

A local node is a complete Monero blockchain copy that runs on the user’s device or a personal server. XMRWallet can connect to this local node and perform synchronization entirely within the user’s control. The advantage is that the user operates all infrastructure and requires no external service. The wallet scans blocks retrieved from the user’s own node, and all data remains on the user’s hardware.

Running a local node requires significant disk space (currently over 150 GB for the full Monero blockchain) and sufficient network bandwidth to initially download the blockchain. Synchronization is slower than connecting to a fast remote node, but the privacy and censorship-resistance benefits are substantial. A user with a local node cannot be prevented from checking their balance by node downtime or service restrictions. They also cannot leak transaction patterns to external parties.

Wallet verification in this context means confirming that the balance displayed matches the user’s understanding of received and sent transactions. XMRWallet displays the balance after scanning the blockchain with the view key. The user can verify this balance by reviewing the transaction history shown in the wallet and confirming that all expected payments are present. If the balance is incorrect or transactions are missing, the user knows the wallet has either not fully synchronized or encountered a problem retrieving data from the node.

The monero wallet’s transaction history becomes a record of what the view key recognized on the blockchain. If the wallet has scanned all blocks up to the current height and displays complete history, the user can trust the balance. If synchronization is incomplete, the balance may be understated. This is why users are encouraged to check the current blockchain height before and after synchronization—confirming that the wallet has caught up to the latest block prevents misunderstanding outdated balances.

Security implications of client-side scanning

Moving transaction scanning from server to client shifts certain responsibilities. A custodial service holds the view key and performs scanning for the user. The user trusts the service to return accurate results. A non-custodial wallet like XMRWallet requires the user to maintain the recovery seed and ensure synchronization completes correctly. This is more secure in some respects—the service cannot intercept or misuse the view key—but it also means the user bears responsibility for backup and device security.

If a recovery seed is lost without a backup, the wallet cannot be restored. If a device is stolen without PIN protection, an attacker can access the wallet. If a user connects to a malicious node, the node can refuse to serve correct blockchain data, though it still cannot determine which transactions the user owns. These are different risks from custodial services, not necessarily greater or lesser, but worth understanding before choosing a non-custodial architecture.

One subtle risk is that the device itself becomes critical infrastructure for the wallet. XMRWallet requires a reasonably functional operating system (Android or iOS) and adequate device storage. A very old phone or compromised operating system could affect security. Users should keep their device updated and avoid installing software from untrusted sources. The wallet’s own security is only as strong as the device environment that runs it.

Backup testing is often overlooked but essential. A user should periodically test restoring a backup to a fresh device to ensure the recovery procedure actually works. If a wallet is restored incorrectly or the seed is transcribed incorrectly, the user might not discover the problem until they need to recover funds. Testing in advance prevents panic during an actual recovery situation and confirms that the backup method chosen is reliable.

Comparing XMRWallet’s privacy model to other wallet designs

A custodial exchange or service wallet holds the user’s private keys on a server and may maintain detailed transaction records. Privacy depends on the service’s data retention policy and regulatory obligations. If the service is served with a law enforcement demand, all user transaction histories and balances can be disclosed. The service might claim it does not log metadata, but the architecture makes it possible to do so.

A light wallet that sends addresses to a node (as in some older Bitcoin designs) reveals the addresses to the node operator. The node can then link those addresses to the user’s IP address and monitor future transactions. This is observable privacy failure—the node directly knows which transactions belong to the user because the user asked about a specific address.

XMRWallet’s design avoids both problems through client-side scanning. The wallet never reveals addresses to the node, and XMRWallet does not hold private keys or transaction history on servers. The tradeoff is that bandwidth and synchronization time increase, and the user must manage backups. This is a conscious choice to prioritize privacy at the cost of convenience and device resource consumption.

Some users prefer the convenience of custodial services, and that is a legitimate choice. Others prioritize the strongest feasible privacy and accept the additional responsibility. XMRWallet is designed for the latter group—users willing to manage their own keys and verify their own synchronization in exchange for eliminating a trusted service provider from the transaction scanning pipeline.

Practical setup and ongoing verification

Creating a new wallet in XMRWallet is straightforward: the application generates a 25-word recovery seed and derives the keys locally. The user should write down this seed on paper stored securely. They can optionally add a PIN to protect the wallet file. Importing an existing Monero wallet requires the recovery seed or private keys, which XMRWallet will use to regenerate the same view and spend keys.

After setup, the user should connect to a node and allow the wallet to synchronize. Depending on wallet age and the node speed, this may take minutes to hours. Once synchronization completes, the wallet displays the current balance and transaction history. The user can then receive payments by sharing one of their wallet’s addresses or generate a new subaddress for each payment recipient to improve privacy and reduce address reuse.

Verification happens continuously during use. Each time the wallet syncs, it rescans recent blocks for new transactions. Users should confirm that their balance matches their expectations and that received payments appear in the transaction history. If a payment is delayed, it may not have confirmed on the blockchain yet, or the wallet may not have synchronized since the payment was broadcast. Allowing additional synchronization time will usually resolve this.

Over time, as users accumulate transactions, the wallet file grows and synchronization may become slower. This is normal and expected. Some users handle this by archiving older wallets and creating new ones for ongoing activity, though this is optional. The key point is to understand that the monero wallet is a local application that depends on user-initiated synchronization—not an automatic service that watches the blockchain in the background on the user’s behalf.