Stealth Address Generator

The Stealth Address Generator is a cryptographic engine that enables Crosterix to create a unique, unlinkable address for every transaction. It ensures that no two transactions from the same user can be correlated on-chain, even when executed from a single master wallet.

Stealth addresses are the foundation of Crosterix’s privacy layer, protecting users from blockchain surveillance, transaction tracing, and wallet fingerprinting.

Concept Overview

In a standard blockchain transaction, a user’s public wallet address (e.g., 0x123...abc) is visible to everyone. Over time, this address becomes associated with a user’s entire on-chain activity — token holdings, swaps, transfers, and more.

The Stealth Address Generator solves this by using Elliptic-Curve Diffie-Hellman (ECDH) key derivation to generate a new one-time address for every operation (swap, transfer, or file share). Only the intended receiver or the original sender can identify and recover the stealth address through their private key.

How It Works (Technical Flow)

Below is the detailed cryptographic and execution flow.

1. Key Components

Component	Description
Public Key (P_user)	Derived from the user’s main wallet address (compressed ECDSA key on secp256k1 curve).
Ephemeral Key (E_tx)	A random key pair generated locally per transaction session.
Shared Secret (S)	Result of ECDH between P_user and E_tx.
Stealth Address (A_stealth)	Generated using a hash of S added to the base public key on the curve.

---

2. Address Derivation Process

1. Sender generates an ephemeral key pair:

   const ePriv = randomBytes(32);
   const ePub = getPublicKey(ePriv);

2. Receiver’s public key (P_user) is obtained from their main wallet.

3. Shared secret computation (ECDH):

   const sharedSecret = ecdh(ePriv, P_user);

   This secret is known only to the sender and receiver.

4. Stealth address generation: The stealth public key is derived as:

   P_stealth = P_user + H(sharedSecret) * G

   where G is the curve base point and H() is a cryptographic hash function (e.g., keccak256).

   The resulting address is:

   A_stealth = keccak256(P_stealth)[12:]

5. Sender includes E_tx (the ephemeral public key) in the transaction metadata or encrypted payload. The receiver can later recompute sharedSecret using:

   S = ecdh(pPriv, E_tx)

   and recover A_stealth to identify incoming assets.

---

3. Transaction Flow Diagram

+-----------------------+
|  User Wallet          |
|  (MetaMask / Rainbow) |
+----------+------------+
           |
           | 1. Generate Ephemeral Keypair (E_tx)
           |
           v
+-----------------------+
|  Stealth Address Engine (Crosterix SDK) |
|  - Compute shared secret (ECDH)         |
|  - Derive new address (A_stealth)       |
+-----------------------+
           |
           | 2. Use A_stealth for Transaction
           v
+-----------------------+
|  Ethereum / EVM Chain |
|  - Records transaction to A_stealth     |
|  - No link to user’s base wallet        |
+-----------------------+

Every new transaction therefore uses a fresh, unlinkable address, effectively breaking the traceability chain on-chain analytics rely on.

Integration with Wallets

Crosterix integrates seamlessly with:

• MetaMask

• Rainbow

• WalletConnect v2

The SDK detects the connected wallet provider, fetches the current public key, and performs stealth derivation locally in the browser.

Example snippet:

import { generateStealthAddress } from "@crosterix/sdk";

const stealthAddress = await generateStealthAddress({
  recipientPubKey: userPublicKey,
});
console.log("New Stealth Address:", stealthAddress);

Developers can embed this directly into payment flows, private swaps, or encrypted file delivery systems, ensuring that every outgoing transaction uses a different address while remaining verifiable by the intended receiver.

Security Properties

Property	Description
Unlinkability	Each stealth address is mathematically independent. No entity can link multiple stealth addresses back to the same wallet.
Forward Secrecy	Even if an ephemeral key is compromised, past and future addresses remain secure.
Client-Side Only	Key generation and ECDH derivation occur locally. No private key leaves the browser.
Compatibility	Works across all EVM chains Ethereum, BSC, Polygon, Avalanche, Arbitrum, etc.