Wallet RPC Leak, UTXO Boltzmann Entropy & Address-Poisoning Auditor

The Two Invisible Leaks Destroying Self-Custody Privacy

Self-custody users routinely invest hundreds of dollars in hardware signing silicon while forfeiting 100% of their financial privacy across two unmonitored layers: pre-transaction network RPC telemetry and post-transaction on-chain value heuristics. Even worse, following the April 2024 takedown of the OXT and kycp.org (KnowYourCoinPrivacy) infrastructure, Bitcoin engineers and self-custody practitioners lost the primary public calculator for auditing Boltzmann UTXO partition entropy before broadcasting transactions.

This offline three-module workbench restores deterministic UTXO combinatorics alongside empirical multi-account JSON-RPC leak modeling (sourced directly from DT.gl's Self-Custody & Wallet Silicon Matrix) and vanity address-poisoning byte diffing, all operating under Content-Security-Policy: connect-src 'none' so zero wallet addresses, transaction amounts, or IP correlations are ever transmitted over the internet.

Module 1: Multi-Account HD Wallet JSON-RPC Correlation Mechanics

Under BIP-32 and BIP-44, a single master seed deterministically derives sequential accounts (m/44'/60'/0'/0/0, /1, /2, ... on EVM; m/84'/0'/0', /1', ... on Bitcoin Native SegWit). Users commonly compartmentalize identities across these indices: Account #0 holds a public ENS name or receives withdrawals from a KYC centralized exchange, whereas Account #1 and Account #2 are treated as "private" cold savings or governance vaults that never transact directly with Account #0 on-chain.

On-chain isolation is completely negated at the transport layer when a wallet coordinator batches state queries over a shared clearnet session:

1. HTTP/2 Connection & TLS JA4 Coalescing: Upon unlocking the vault, browser wallets (MetaMask, Rabby, Phantom) and companion apps (Ledger Live) open a persistent TLS 1.3 connection to Infura, Alchemy, DeBank Cloud, or vendor proxy APIs. Even if individual JSON-RPC eth_getBalance calls are sent in separate frames rather than a single JSON array, HTTP/2 stream multiplexing binds every address query to the exact same source IP, TCP ephemeral port, and TLS JA4 client-hello fingerprint within a 50 ms window.
2. Auxiliary Metadata Beacons: Simultaneously, unhardened wallets fetch token USD prices by contract list, resolve reverse ENS records, and auto-load NFT tokenURI images from attacker-controlled HTTP servers, allowing anyone who airdrops a single tracking NFT into Account #2 to harvest the holder's residential IP address the moment they open their "Collectibles" tab.
3. Electrum ScriptHash Indexing on Bitcoin: Standard Electrum servers index the blockchain by SHA256(scriptPubKey). When a desktop or mobile Bitcoin wallet connects to a public Electrum server without Tor stream isolation and subscribes to blockchain.scripthash.subscribe across 20 receive and 20 change addresses simultaneously, that public server learns the wallet's complete UTXO cluster instantly.

Module 2: Mathematical Formulation of UTXO Boltzmann Entropy

Chain surveillance suites (Chainalysis Reactor, TRM Labs, Elliptic) rely on two foundational UTXO clustering assumptions introduced in Meiklejohn et al. and formalized in LaurentMT's Boltzmann framework: the Common-Input-Ownership Heuristic (CIOH) and Subset-Sum Change Identification.

Consider a Bitcoin transaction T consuming m inputs I = [i_1, i_2, ..., i_m] and creating n outputs O = [o_1, o_2, ..., o_n] with miner fee F = sum(I) - sum(O) >= 0. Rather than assuming a single entity controlled every input, the Boltzmann partition solver asks: How many distinct ways (N) can (I, O) be decomposed into k >= 1 independent, value-conserving atomic sub-transactions (I_1, O_1), ..., (I_k, O_k)?

A candidate partition P = [(I_1, O_1), ..., (I_k, O_k)] is valid if and only if three invariants hold simultaneously:

1. Disjoint Exhaustive Coverage: The union across r = 1..k of I_r equals I and the union of O_r equals O, where I_r and I_s are strictly disjoint (I_r intersect I_s = empty), O_r and O_s are strictly disjoint for all r != s, and every subset I_r and O_r is non-empty.
2. Per-Component Value Conservation: Every sub-transaction pays a non-negative share of the miner fee without creating satoshis out of thin air (0 <= sum(I_r) - sum(O_r) <= F), summing across all k components to the exact total miner fee F.
3. Atomicity (Irreducibility): No component (I_r, O_r) can be split further into two valid value-conserving sub-components without double-counting coarser aggregations of an already-counted independent transfer.

From the total count of valid interpretations N, our offline solver derives four quantitative metrics:

• Boltzmann Entropy in Bits: Computed as E_bits = log2(N) alongside natural entropy E_nats = ln(N). A naive 1-input, 2-output payment (1,000,000 sats -> 150,000 sats + 848,500 sats) admits only N = 1 valid interpretation, yielding E = 0.000 bits and exposing deterministic value flow. By contrast, a 4-participant equal-output Whirlpool CoinJoin (4 x 1,000,000 sats) admits N = 4! = 24 valid bijections, yielding E = log2(24) = 4.585 bits (3.178 nats).
• Deterministic Link Probability Matrix P(i_a -> o_b): Across all N valid partitions, let L(a, b) denote the number of valid interpretations in which input i_a and output o_b belong to the same sub-transaction component. The link probability is P(i_a -> o_b) = L(a, b) / N. Any cell where P(i_a -> o_b) = 1.00 (100%) represents a deterministic link that chain-analysis algorithms assign with mathematical certainty.
• Structural Wallet Efficiency (eta): Compares realized entropy E_bits against the intrinsic maximum entropy E_max achievable by an optimal equal-denomination construction of identical input and output cardinality (eta = E_bits / E_max), revealing how much privacy was left on the table by unequal change outputs.

Comparative Privacy & Entropy Benchmarks Across Transaction Topologies

Module 3: Defeating GPU Vanity Address Poisoning & Unicode Homographs

Over $120 million in retail and institutional treasury funds have been lost to zero-value and counterfeit-token address poisoning across Ethereum, Arbitrum, Tron, and Bitcoin. Unlike smart-contract exploits, address poisoning requires zero vulnerability in wallet cryptography; it exploits human visual scanning shortcuts encouraged by modern UI design.

Because block explorers, wallet extensions, and multisig dashboards routinely abbreviate 42-character hexadecimal EVM addresses into 0x1234...abcd (showing only the leading 4 to 6 hex characters and trailing 4 to 6 hex characters), attackers run massive GPU clusters (profanity2 / custom OpenCL keccak256 kernels) to pre-compute billions of keypairs. Matching k hexadecimal nibbles (4k bits) across prefix and suffix combined requires 2^(4k) expected secp256k1 scalar additions:

• 8 Total Matched Hex Chars (4 prefix + 4 suffix = 32 bits): Roughly 4.29 billion hashes, solvable on a single consumer RTX 4090 GPU in under 0.4 seconds.
• 12 Total Matched Hex Chars (6 prefix + 6 suffix = 48 bits): Roughly 2.81 x 10^14 hashes, solvable on a modest 8-GPU rig in under 4 minutes.
• 16 Total Matched Hex Chars (8 prefix + 8 suffix = 64 bits): Reserved for high-value institutional whale targets (>$10M frequent counterparties), achievable via rented GPU fleets within hours.

Once the attacker generates a lookalike keypair matching a target whale's frequent treasury counterparty, an automated mempool bot watches for legitimate outbound USDT/USDC transfers from the victim. Within seconds of confirmation, the bot calls transferFrom(victim, vanity_poison_address, 0) (on tokens permitting zero-value transferFrom without allowance) or emits a Transfer event from a counterfeit ERC-20 contract with an identical USDC ticker symbol. The next time an operator opens their wallet's "Recent Activity" list and copies the top address without checking characters 10 through 34, funds are wired irreversibly to the attacker.

Hardened Network & Node Isolation Playbooks by Ecosystem

Eliminating wallet RPC correlation does not require abandoning modern hardware signers or multi-chain interfaces; it requires severing the link between your derived address graph, your residential IP / TLS JA4 session, and centralized API aggregators. Below are the deterministic isolation configurations benchmarked in our lab:

1. Bitcoin Self-Custody: Sparrow Wallet + Local Node or Tor Stream Isolation

On Bitcoin, pairing Sparrow Wallet with an air-gapped hardware signer (Coldcard Q, Trezor Safe 7, Keystone 3 Pro, or Blockstream Jade Plus) achieves an A+ RPC isolation grade when backed by one of three node topologies:

• Local Sovereign Full Node (Bitcoin Core + Electrs or Fulcrum): Sparrow connects over local loopback (127.0.0.1:50001) or an authenticated LAN tunnel to your own indexed full node, which syncs blocks over the Bitcoin P2P network (ideally with onlynet=onion or Tor/I2P peer diversity enabled in bitcoin.conf). Zero third-party servers ever observe your scriptHash subscriptions or extended public key (xpub/zpub) balances.
• Tor SOCKS5 Proxy with Circuit Isolation: When traveling without access to a home node, configure Sparrow to connect exclusively to .onion Electrum endpoints via a local Tor daemon (127.0.0.1:9050). Critically, never query two separate privacy-compartmentalized wallets during the same unrotated Tor circuit window, and broadcast raw signed PSBTv2 (BIP-370) hex over an isolated circuit distinct from balance-checking sessions.
• BIP-352 Silent Payments & Subaddress Hygiene: For public donation or merchant endpoints where publishing a static address is unavoidable, BIP-352 Silent Payments derives unique one-time Taproot (P2TR) on-chain outputs via secp256k1 Diffie-Hellman key exchange (P = B_spend + hash(a * B_scan) * G) using the sender's input keys, leaving zero static address reuse or OP_RETURN notification markers on the public ledger.

2. EVM & Multi-Chain Wallets: Pre-Import Custom RPCs & Private Mempool Relays

On Ethereum and Layer-2 rollups (Arbitrum, Optimism, Base), account-model state forces lighter clients to query external RPC nodes unless running a local execution + consensus client (Reth / Nethermind + Lighthouse or Helios light-client verification). To minimize off-chain correlation when using browser or desktop coordinators:

• Provision Clean Browser Profiles Per Identity: Never store a KYC/ENS-linked account (Account #0) and an unlinked pseudonymous vault (Account #1) inside the same browser extension instance. Isolate each identity in a separate Mullvad Browser or LibreWolf container profile routed through distinct VPN/Tor exit circuits.
• Disable Auxiliary Auto-Fetchers Before Wallet Import: Prior to importing any watch-only address or hardware account, disable automatic token discovery, third-party price feeds, phishing-URL cloud telemetry, and NFT media gateway preloading (IPFS/HTTP tokenURI auto-fetch).
• Broadcast Through Private Mempool Relays (MEV Blocker / Flashbots Protect): Standard eth_sendRawTransaction broadcasts gossip your signed transaction across the public P2P mempool, exposing you to both generalized front-running/sandwich bots and passive mempool spy nodes logging first-seen IP timestamps. Routing outbound transactions over Tor to a no-log private builder relay shields swap parameters until block inclusion while preventing P2P gossip triangulation.

Hardened Counterparty Verification Workflow

1. Ban History Copy-Pasting: Never source a recipient address from on-chain transaction history or wallet activity feeds. Maintain signed, out-of-band address books verified via hardware display or PGP/Signal safety numbers.
2. Audit All 42 Characters in Tab 3: Paste both your authoritative runbook address and the clipboard/invoice address into Tab 3 (Vanity Address-Poisoning Diff) above. The auditor highlights every mismatched middle nibble in crimson (is-danger), verifies EIP-55 mixed-case Keccak-256 checksum casing, and scans for injected zero-width spaces (U+200B), Bidi overrides (U+202E), and Cyrillic homographs (also covered deeply in our Metadata & Unicode MCP Sanitizer).
3. Freeze Toxic Dust UTXOs on Bitcoin: When tiny 546-sat dust UTXOs arrive at an existing Bitcoin address, immediately mark them Frozen / Do Not Spend in Sparrow Wallet so automated coin selection never merges them with your main vault via CIOH. Pair this practice with proper physical entropy generation in our Offline Seed & Multisig Quorum Lab.