Examples

Verify It Works

A complete offline demo that proves the cryptographic guarantees of the Cloak protocol — stealth address uniqueness, payment detection, spending key derivation, and privacy.

What this proves

1. Stealth addresses are unique

Each payment generates a different address, even for the same sender and receiver.

2. Recipients can detect payments

The scanning process correctly identifies payments addressed to you.

3. Recipients can spend funds

The derived spending key matches the stealth address exactly.

4. Others cannot detect your payments

A different meta-address correctly detects zero payments.

Complete demo

This runs entirely offline — no blockchain connection needed:

demo.rs

rust

use cloak_sdk::{
    StealthMetaAddress, PublicMetaAddress,
    StealthPayment, StealthKeypair,
    Scanner, Announcement,
};

fn main() -> anyhow::Result<()> {
    println!("=== Cloak SDK v1.0 Demo ===\n");

    // 1. Generate identities
    let alice = StealthMetaAddress::generate();
    let bob = StealthMetaAddress::generate();
    let alice_public = alice.to_public_string();
    println!("Alice's meta-address: {}...\n", &alice_public[..40]);

    // 2. Bob sends two payments to Alice
    let recipient = PublicMetaAddress::from_string(&alice_public)?;
    let payment1 = StealthPayment::create(&recipient, 1_000_000_000)?;
    let payment2 = StealthPayment::create(&recipient, 500_000_000)?;

    println!("Payment 1 → {}", payment1.stealth_address);
    println!("Payment 2 → {}", payment2.stealth_address);
    println!("Addresses are different: {}\n",
        payment1.stealth_address != payment2.stealth_address);

    // 3. Alice scans for payments
    let announcements = vec![
        Announcement {
            stealth_address: payment1.stealth_address,
            ephemeral_pubkey: payment1.ephemeral_pubkey,
            amount: payment1.amount,
            timestamp: 1709900000,
        },
        Announcement {
            stealth_address: payment2.stealth_address,
            ephemeral_pubkey: payment2.ephemeral_pubkey,
            amount: payment2.amount,
            timestamp: 1709900001,
        },
    ];

    let alice_scanner = Scanner::new(&alice);
    let detected = alice_scanner.scan_announcements_list(&announcements)?;
    println!("Alice detected {} payments ✓", detected.len());

    // 4. Alice derives spending keys
    for payment in &detected {
        let kp = StealthKeypair::derive(&alice, &payment.ephemeral_pubkey)?;
        println!("  {} → key derived ✓", kp.address());
        assert_eq!(kp.address(), payment.stealth_address);
    }

    // 5. Bob's scanner finds ZERO payments (privacy proof)
    let bob_scanner = Scanner::new(&bob);
    let bob_detected = bob_scanner.scan_announcements_list(&announcements)?;
    println!("\nBob detected {} payments (privacy ✓)", bob_detected.len());
    assert_eq!(bob_detected.len(), 0);

    println!("\n=== All checks passed ===");
    Ok(())
}

Expected output

Output

text

=== Cloak SDK v1.0 Demo ===

Alice's meta-address: stealth1:sol:a1b2c3d4e5f6...

Payment 1 → 7xKp...stealth address 1
Payment 2 → 9mNq...stealth address 2
Addresses are different: true

Alice detected 2 payments ✓
  7xKp... → key derived ✓
  9mNq... → key derived ✓

Bob detected 0 payments (privacy ✓)

=== All checks passed ===

Zero-knowledge proof demo

zk_demo.rs

rust

use cloak_sdk::zk::{self, AmountCommitment};

fn main() -> anyhow::Result<()> {
    println!("=== ZK Proof Demo ===\n");

    // Setup (one-time)
    let (pk, pvk) = zk::setup()?;

    // Commit to an amount
    let amount = 1_000_000_000; // 1 SOL
    let commitment = AmountCommitment::commit(amount);
    println!("Commitment: {} bytes", commitment.commitment_bytes.len());

    // Generate proof
    let proof = zk::prove(&pk, amount, &commitment)?;
    println!("Proof generated ✓");

    // Verify (no amount knowledge needed)
    let valid = zk::verify(&pvk, &proof)?;
    println!("Proof valid: {} ✓", valid);

    // Wrong amount fails
    let bad_commitment = AmountCommitment::commit(999);
    let bad_proof = zk::prove(&pk, amount, &bad_commitment);
    println!("Wrong commitment fails: {} ✓", bad_proof.is_err());

    println!("\n=== ZK checks passed ===");
    Ok(())
}

Test suite

Run the built-in test suite to verify all cryptographic operations:

Terminal

bash

# Run all SDK tests
cd crates/core
cargo test -- --nocapture

# Expected: 14+ tests covering:
# - Key generation and derivation
# - Stealth address computation
# - Payment detection (true positives)
# - Privacy verification (true negatives)
# - Viewing key delegation
# - Payment history
# - Batch scanning
# - File serialization/deserialization
# - Domain separation