@veilo/sdk-core 0.4.0 → 0.6.0

package/dist/src/utxo.js

@@ -1,407 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateKeypair = generateKeypair;
-exports.derivePublicKey = derivePublicKey;
-exports.keypairFromPrivateKey = keypairFromPrivateKey;
-exports.commitUTXO = commitUTXO;
-exports.createUTXO = createUTXO;
-exports.createOwnedUTXO = createOwnedUTXO;
-exports.createZeroUTXO = createZeroUTXO;
-exports.createOwnedZeroUTXO = createOwnedZeroUTXO;
-exports.computeSignature = computeSignature;
-exports.deriveNullifier = deriveNullifier;
-exports.inputUTXOToCircuitFormat = inputUTXOToCircuitFormat;
-exports.deriveEncryptionKeypair = deriveEncryptionKeypair;
-exports.encryptUTXONote = encryptUTXONote;
-exports.decryptUTXONote = decryptUTXONote;
-exports.kdfSHA512_256 = kdfSHA512_256;
-exports.ed25519SeedToX25519Private = ed25519SeedToX25519Private;
-exports.ed25519PublicKeyToX25519 = ed25519PublicKeyToX25519;
-exports.encryptBlindMailboxNote = encryptBlindMailboxNote;
-exports.decryptBlindMailboxNote = decryptBlindMailboxNote;
-exports.fetchAndDecryptNotes = fetchAndDecryptNotes;
-const random_js_1 = require("./random.js");
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const sha256_1 = require("@noble/hashes/sha256");
-const poseidon_js_1 = require("./poseidon.js");
-// -----------------------------------------------------------------------------
-// Keypair Functions
-// -----------------------------------------------------------------------------
-/**
- * Generate a random keypair.
- * Private key is a random 32-byte scalar.
- * Public key is derived via Poseidon: pubkey = Poseidon(privateKey)
- */
-function generateKeypair() {
-    const privateKeyBytes = new Uint8Array((0, random_js_1.randomBytes)(32));
-    const privateKey = (0, poseidon_js_1.bytesToBigIntBE)(privateKeyBytes) % poseidon_js_1.BN254_FR_MODULUS;
-    const publicKey = derivePublicKey(privateKey);
-    return { privateKey, publicKey };
-}
-/**
- * Derive public key from private key.
- * Matches circuit's Keypair template: publicKey = Poseidon(privateKey)
- */
-function derivePublicKey(privateKey) {
-    return (0, poseidon_js_1.poseidon1)(privateKey);
-}
-/**
- * Create keypair from a known private key.
- */
-function keypairFromPrivateKey(privateKey) {
-    return {
-        privateKey: privateKey % poseidon_js_1.BN254_FR_MODULUS,
-        publicKey: derivePublicKey(privateKey % poseidon_js_1.BN254_FR_MODULUS),
-    };
-}
-// -----------------------------------------------------------------------------
-// UTXO Commitment Functions
-// -----------------------------------------------------------------------------
-/**
- * Compute UTXO commitment.
- * Matches circuit's UTXOCommitment template:
- *   commitment = Poseidon(amount, pubkey, blinding, mintAddress)
- */
-function commitUTXO(utxo) {
-    const commitment = (0, poseidon_js_1.poseidon4)(utxo.amount, utxo.pubkey, utxo.blinding, utxo.mintAddress);
-    return (0, poseidon_js_1.bigIntToBytesBE)(commitment);
-}
-/**
- * Create a random UTXO with the given parameters.
- */
-function createUTXO(params) {
-    const blindingBytes = new Uint8Array((0, random_js_1.randomBytes)(32));
-    const blinding = (0, poseidon_js_1.bytesToBigIntBE)(blindingBytes) % poseidon_js_1.BN254_FR_MODULUS;
-    const utxo = {
-        amount: params.amount,
-        pubkey: params.pubkey,
-        blinding,
-        mintAddress: (0, poseidon_js_1.pubkeyToField)(params.mintAddress),
-    };
-    const commitment = commitUTXO(utxo);
-    return {
-        ...utxo,
-        commitment,
-    };
-}
-/**
- * Create a UTXO with a specified private key (for owned UTXOs).
- */
-function createOwnedUTXO(params) {
-    const keypair = keypairFromPrivateKey(params.privateKey);
-    const utxo = createUTXO({
-        amount: params.amount,
-        pubkey: keypair.publicKey,
-        mintAddress: params.mintAddress,
-    });
-    return {
-        ...utxo,
-        privateKey: keypair.privateKey,
-    };
-}
-/**
- * Create a zero UTXO (for deposits where no input exists).
- * Zero UTXOs have amount=0 and are used as placeholders in 2-in-2-out transactions.
- */
-function createZeroUTXO(pubkey, mintAddress) {
-    return createUTXO({
-        amount: 0n,
-        pubkey,
-        mintAddress,
-    });
-}
-/**
- * Create a zero UTXO with private key (for owned zero UTXOs).
- */
-function createOwnedZeroUTXO(privateKey, mintAddress) {
-    const keypair = keypairFromPrivateKey(privateKey);
-    const utxo = createZeroUTXO(keypair.publicKey, mintAddress);
-    return {
-        ...utxo,
-        privateKey: keypair.privateKey,
-    };
-}
-// -----------------------------------------------------------------------------
-// Nullifier Functions
-// -----------------------------------------------------------------------------
-/**
- * Compute signature for nullifier derivation.
- * Matches circuit's Signature template:
- *   signature = Poseidon(privateKey, commitment, pathIndex)
- */
-function computeSignature(privateKey, commitment, pathIndex) {
-    return (0, poseidon_js_1.poseidon3)(privateKey, commitment, pathIndex);
-}
-/**
- * Derive nullifier for a UTXO.
- * Matches circuit's UTXONullifier template:
- *   signature = Poseidon(privateKey, commitment, pathIndex)
- *   nullifier = Poseidon(commitment, pathIndex, signature)
- *
- * The signature-based nullifier ensures only the private key holder can spend.
- */
-function deriveNullifier(utxo, pathIndex, privateKey) {
-    const commitment = (0, poseidon_js_1.bytesToBigIntBE)(utxo.commitment) % poseidon_js_1.BN254_FR_MODULUS;
-    const pathIndexField = BigInt(pathIndex) % poseidon_js_1.BN254_FR_MODULUS;
-    const signature = computeSignature(privateKey, commitment, pathIndexField);
-    const nullifier = (0, poseidon_js_1.poseidon3)(commitment, pathIndexField, signature);
-    return (0, poseidon_js_1.bigIntToBytesBE)(nullifier);
-}
-/**
- * Convert InputUTXO to the format expected by the circuit.
- */
-function inputUTXOToCircuitFormat(input) {
-    return {
-        amount: input.amount,
-        pubkey: input.pubkey,
-        blinding: input.blinding,
-        pathElements: input.pathElements.map((e) => (0, poseidon_js_1.bytesToBigIntBE)(e) % poseidon_js_1.BN254_FR_MODULUS),
-        pathIndex: input.pathIndex,
-        privateKey: input.privateKey,
-    };
-}
-/**
- * Derive a NaCl X25519 encryption keypair from a UTXO private key.
- * The keypair is deterministic: same privateKey always yields the same pair.
- */
-function deriveEncryptionKeypair(privateKey) {
-    const seed = (0, sha256_1.sha256)((0, poseidon_js_1.bigIntToBytesBE)(privateKey));
-    return tweetnacl_1.default.box.keyPair.fromSecretKey(seed);
-}
-/**
- * Encrypt a UTXO so the recipient can recover it from on-chain events.
- *
- * Plaintext layout (72 bytes):
- *   [0..8]   amount  — 8-byte little-endian u64
- *   [8..40]  blinding — 32-byte big-endian field element
- *   [40..72] privateKey — 32-byte big-endian field element
- *
- * Uses ephemeral-key NaCl box so the sender key is single-use.
- */
-function encryptUTXONote(utxo, recipientEncPubkey) {
-    const nonce = tweetnacl_1.default.randomBytes(tweetnacl_1.default.box.nonceLength); // 24 bytes
-    const ephemeral = tweetnacl_1.default.box.keyPair();
-    const amountBuf = new Uint8Array(8);
-    let v = utxo.amount;
-    for (let i = 0; i < 8; i++) {
-        amountBuf[i] = Number(v & 0xffn);
-        v >>= 8n;
-    }
-    const plaintext = new Uint8Array(72);
-    plaintext.set(amountBuf, 0);
-    plaintext.set((0, poseidon_js_1.bigIntToBytesBE)(utxo.blinding), 8);
-    plaintext.set((0, poseidon_js_1.bigIntToBytesBE)(utxo.privateKey), 40);
-    const sharedKey = tweetnacl_1.default.box.before(recipientEncPubkey, ephemeral.secretKey);
-    const ciphertext = tweetnacl_1.default.box.after(plaintext, nonce, sharedKey);
-    return { nonce, ciphertext, senderEphemeralPubkey: ephemeral.publicKey };
-}
-/**
- * Try to decrypt an encrypted UTXO note using the recipient's private key.
- * Returns the SerializedUTXO if decryption succeeds and the commitment
- * matches, or `null` if the note was not intended for this key.
- */
-function decryptUTXONote(note, recipientPrivateKey, commitment, mintAddress) {
-    const { secretKey } = deriveEncryptionKeypair(recipientPrivateKey);
-    const sharedKey = tweetnacl_1.default.box.before(note.senderEphemeralPubkey, secretKey);
-    const plaintext = tweetnacl_1.default.box.open.after(note.ciphertext, note.nonce, sharedKey);
-    if (!plaintext || plaintext.length < 72)
-        return null;
-    let amount = 0n;
-    for (let i = 7; i >= 0; i--)
-        amount = (amount << 8n) | BigInt(plaintext[i]);
-    const blinding = (0, poseidon_js_1.bytesToBigIntBE)(plaintext.slice(8, 40)) % poseidon_js_1.BN254_FR_MODULUS;
-    const privateKey = (0, poseidon_js_1.bytesToBigIntBE)(plaintext.slice(40, 72)) % poseidon_js_1.BN254_FR_MODULUS;
-    const pubkey = derivePublicKey(privateKey);
-    const utxo = {
-        amount,
-        pubkey,
-        blinding,
-        mintAddress: (0, poseidon_js_1.pubkeyToField)(mintAddress),
-    };
-    const expectedCommitment = commitUTXO(utxo);
-    if (!expectedCommitment.every((b, i) => b === commitment[i]))
-        return null;
-    return { ...utxo, commitment, privateKey };
-}
-// -- Internal crypto helpers (no extra dependencies) --------------------------
-/** Derive 32-byte encryption key from a shared secret using SHA-512 truncated.
- *  Must match the production "sha256" helper which uses nacl.hash (SHA-512) [0:32].
- *
- *  DO NOT "fix" this to real SHA-256. The name in the sibling implementations
- *  (`sha256ForNotes`) is a misnomer, but the bytes are load-bearing: changing the
- *  KDF makes every historical note undecryptable.
- *
- *  @internal Exported for `compactNote.ts`. Not part of the stable public API. */
-function kdfSHA512_256(secret) {
-    return tweetnacl_1.default.hash(secret).slice(0, 32);
-}
-/** Convert an Ed25519 private seed (32 bytes) to an X25519 scalar.
- *  Equivalent to ed2curve.convertSecretKey(seed).
- *
- *  @internal Exported for `compactNote.ts`. Not part of the stable public API. */
-function ed25519SeedToX25519Private(seed) {
-    const h = tweetnacl_1.default.hash(seed); // SHA-512
-    const scalar = h.slice(0, 32);
-    scalar[0] &= 248;
-    scalar[31] &= 127;
-    scalar[31] |= 64;
-    return scalar;
-}
-const P25519 = (1n << 255n) - 19n;
-function modpow25519(b, e) {
-    let r = 1n;
-    b = b % P25519;
-    while (e > 0n) {
-        if (e & 1n)
-            r = (r * b) % P25519;
-        e >>= 1n;
-        b = (b * b) % P25519;
-    }
-    return r;
-}
-/** Convert an Ed25519 compressed public key (32 bytes) to X25519.
- *  Equivalent to ed2curve.convertPublicKey(pubkey).
- *  Edwards y-coord → Montgomery u via: u = (1 + y) / (1 - y) (mod p).
- *
- *  @internal Exported for `compactNote.ts`. Not part of the stable public API. */
-function ed25519PublicKeyToX25519(pubkey) {
-    const pk = new Uint8Array(pubkey);
-    pk[31] &= 0x7f; // clear sign bit to get y as LE integer
-    // Decode little-endian y
-    let y = 0n;
-    for (let i = 31; i >= 0; i--)
-        y = (y << 8n) | BigInt(pk[i]);
-    // u = (1 + y) / (1 - y) mod p
-    const num = (1n + y) % P25519;
-    const den = (((1n - y) % P25519) + P25519) % P25519;
-    const u = (num * modpow25519(den, P25519 - 2n)) % P25519;
-    // Encode as 32-byte LE
-    const out = new Uint8Array(32);
-    let v = u;
-    for (let i = 0; i < 32; i++) {
-        out[i] = Number(v & 0xffn);
-        v >>= 8n;
-    }
-    return out;
-}
-// -- Public API ---------------------------------------------------------------
-/**
- * Encrypt a UTXO note for a recipient identified by their Solana wallet public key.
- * Produces a blob the relayer will store and serve via POST /notes/save.
- *
- * @param recipientWalletPubkey  32-byte Ed25519 public key (wallet.publicKey.toBytes())
- * @param noteData               UTXO details to encrypt
- */
-function encryptBlindMailboxNote(recipientWalletPubkey, noteData) {
-    // 1. Generate ephemeral Ed25519 keypair seed
-    const ephemeralSeed = (0, random_js_1.randomBytes)(32);
-    // Ed25519 public key stored by relayer; dapp recovers X25519 via ed2curve.convertPublicKey()
-    const ephemeralEdPublicKey = tweetnacl_1.default.sign.keyPair.fromSeed(new Uint8Array(ephemeralSeed)).publicKey;
-    // X25519 scalar (ed2curve.convertSecretKey equivalent)
-    const ephemeralX25519Private = ed25519SeedToX25519Private(new Uint8Array(ephemeralSeed));
-    // X25519 public key (ed2curve.convertPublicKey equivalent)
-    const recipientX25519Public = ed25519PublicKeyToX25519(recipientWalletPubkey);
-    const sharedSecret = tweetnacl_1.default.scalarMult(ephemeralX25519Private, recipientX25519Public);
-    const key = kdfSHA512_256(sharedSecret);
-    // JSON format matches production relayer notes schema
-    const hexArr = (b) => Array.from(b)
-        .map((x) => x.toString(16).padStart(2, "0"))
-        .join("");
-    const noteJson = JSON.stringify({
-        blinding: hexArr(noteData.blinding),
-        leafIndex: noteData.leafIndex,
-        commitment: hexArr(noteData.commitment),
-        amount: noteData.amount.toString(),
-        mintAddress: noteData.mintAddress,
-        timestamp: Date.now(),
-        treeId: noteData.treeId,
-    });
-    const nonce = tweetnacl_1.default.randomBytes(24);
-    const plaintext = new TextEncoder().encode(noteJson);
-    const encrypted = tweetnacl_1.default.secretbox(plaintext, nonce, key);
-    const combined = new Uint8Array(nonce.length + encrypted.length);
-    combined.set(nonce);
-    combined.set(encrypted, nonce.length);
-    const encryptedBlob = Buffer.from(combined).toString("base64");
-    // Return Ed25519 public key (dapp calls ed2curve.convertPublicKey() to recover X25519)
-    return { ephemeralPublicKey: ephemeralEdPublicKey, encryptedBlob };
-}
-/**
- * Decrypt a Blind Mailbox note using the recipient's Solana wallet private seed.
- *
- * @param walletSecretKey  Full 64-byte wallet.secretKey — the first 32 bytes are the seed
- * @param ephemeralPublicKey  32-byte raw public key stored alongside the encrypted blob.
- *                            This may be either an Ed25519 pubkey (from Keypair.generate())
- *                            or a raw X25519 pubkey — the decryption path handles both:
- *                            if it is an Ed25519 key it is converted; otherwise used directly.
- * @param encryptedBlob      Base64 string as stored by the relayer
- */
-function decryptBlindMailboxNote(walletSecretKey, ephemeralPublicKey, encryptedBlob) {
-    // 1. Derive recipient X25519 from Ed25519 seed
-    const seed = walletSecretKey.slice(0, 32);
-    const myX25519Private = ed25519SeedToX25519Private(seed);
-    // ephemeralPublicKey may be an Ed25519 pubkey (dapp's Keypair.generate()) or raw X25519;
-    // try Ed25519→X25519 conversion first, fall back to using it directly.
-    let theirPublic;
-    try {
-        theirPublic = ed25519PublicKeyToX25519(ephemeralPublicKey);
-    }
-    catch {
-        theirPublic = ephemeralPublicKey; // already X25519
-    }
-    const sharedSecret = tweetnacl_1.default.scalarMult(myX25519Private, theirPublic);
-    const key = kdfSHA512_256(sharedSecret);
-    const combined = Buffer.from(encryptedBlob, "base64");
-    const nonce = combined.slice(0, 24);
-    const ciphertext = combined.slice(24);
-    const decrypted = tweetnacl_1.default.secretbox.open(new Uint8Array(ciphertext), new Uint8Array(nonce), key);
-    if (!decrypted) {
-        throw new Error("decryptBlindMailboxNote: decryption failed — wrong key or corrupted blob");
-    }
-    const parsed = JSON.parse(new TextDecoder().decode(decrypted));
-    const hexToBytes = (hex) => {
-        const out = new Uint8Array(hex.length / 2);
-        for (let i = 0; i < hex.length; i += 2)
-            out[i / 2] = parseInt(hex.slice(i, i + 2), 16);
-        return out;
-    };
-    return {
-        blinding: hexToBytes(parsed.blinding),
-        leafIndex: parsed.leafIndex,
-        commitment: hexToBytes(parsed.commitment),
-        amount: BigInt(parsed.amount),
-        timestamp: parsed.timestamp ?? 0,
-        mintAddress: parsed.mintAddress,
-        treeId: parsed.treeId,
-    };
-}
-/**
- * Fetch all encrypted notes for a wallet from the relayer's Blind Mailbox endpoint
- * and decrypt them using the wallet's secret key.
- *
- * @param walletPublicKey  Base58 wallet address used to query the relayer
- * @param walletSecretKey  Full 64-byte keypair.secretKey for decryption
- * @param relayerUrl       Relayer base URL (e.g. "https://relay.veilo.app")
- */
-async function fetchAndDecryptNotes(walletPublicKey, walletSecretKey, relayerUrl) {
-    const resp = await fetch(`${relayerUrl}/api/notes?recipientPublicKey=${walletPublicKey}`);
-    if (!resp.ok) {
-        throw new Error(`fetchAndDecryptNotes: ${resp.status} ${resp.statusText}`);
-    }
-    const { notes } = (await resp.json());
-    const results = [];
-    for (const note of notes) {
-        try {
-            const epk = Buffer.from(note.ephemeralPublicKey, "base64");
-            const decrypted = decryptBlindMailboxNote(walletSecretKey, new Uint8Array(epk), note.encryptedBlob);
-            results.push(decrypted);
-        }
-        catch {
-            // Note not for this key or corrupted — skip silently
-        }
-    }
-    return results;
-}

package/dist/tests/compact-note.test.d.ts

@@ -1 +0,0 @@
-import "mocha";

package/dist/tests/compact-note.test.js

@@ -1,173 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const src_1 = require("../src");
-const unhex = (s) => new Uint8Array(Buffer.from(s, "hex"));
-const hex = (u) => Buffer.from(u).toString("hex");
-function loadVectors() {
-    const candidates = [
-        (0, path_1.resolve)(process.cwd(), "tests/fixtures/compact-note-vectors.json"),
-        (0, path_1.resolve)(__dirname, "../../tests/fixtures/compact-note-vectors.json"),
-        (0, path_1.resolve)(__dirname, "fixtures/compact-note-vectors.json"),
-    ];
-    for (const p of candidates) {
-        if ((0, fs_1.existsSync)(p))
-            return JSON.parse((0, fs_1.readFileSync)(p, "utf8")).vectors;
-    }
-    throw new Error(`compact-note-vectors.json not found. Tried:\n  ${candidates.join("\n  ")}`);
-}
-describe("compact note ciphers", function () {
-    this.timeout(20000);
-    const vectors = loadVectors();
-    it("loads golden vectors", () => {
-        assert_1.strict.ok(vectors.length >= 8, "expected at least 8 golden vectors");
-    });
-    describe("byte-compatibility with the sibling implementations", () => {
-        for (const v of loadVectors()) {
-            it(`${v.name} (amount=${v.amount}) reproduces the sibling bytes exactly`, () => {
-                const out = (0, src_1.createCompactNoteCipher)(unhex(v.recipientWalletPubkey), unhex(v.blinding), BigInt(v.amount), { ephemeralSeed: unhex(v.ephemeralSeed), nonce: unhex(v.nonce) });
-                assert_1.strict.equal(hex(out.ephemeralPublicKey), v.expected.ephemeralPublicKey, "ephemeral public key drifted — scanners would derive the wrong shared secret");
-                assert_1.strict.equal(hex(out.compactBlob), v.expected.compactBlob, "compact blob drifted — existing clients could not decrypt new notes");
-                assert_1.strict.equal(out.viewTag, v.expected.viewTag, "view tag drifted — notes would be invisible to the scan loop");
-            });
-        }
-    });
-    describe("round trip", () => {
-        for (const v of loadVectors()) {
-            it(`${v.name} decrypts back to the original blinding and amount`, () => {
-                const recovered = (0, src_1.decryptCompactNoteCipher)(unhex(v.recipientSeed), unhex(v.expected.ephemeralPublicKey), unhex(v.expected.compactBlob));
-                assert_1.strict.ok(recovered, "decryption returned null for our own note");
-                assert_1.strict.equal(hex(recovered.blinding), v.blinding);
-                assert_1.strict.equal(recovered.amount.toString(), v.amount);
-            });
-        }
-        it("survives a randomized sweep", () => {
-            for (let i = 0; i < 32; i++) {
-                const recipient = tweetnacl_1.default.sign.keyPair();
-                const blinding = tweetnacl_1.default.randomBytes(32);
-                const amount = BigInt(Math.floor(Math.random() * 1e15));
-                const c = (0, src_1.createCompactNoteCipher)(recipient.publicKey, blinding, amount);
-                const back = (0, src_1.decryptCompactNoteCipher)(recipient.secretKey, c.ephemeralPublicKey, c.compactBlob);
-                assert_1.strict.ok(back, "failed to decrypt own note");
-                assert_1.strict.equal(hex(back.blinding), hex(blinding));
-                assert_1.strict.equal(back.amount, amount);
-            }
-        });
-        it("accepts a 32-byte seed and a 64-byte secret key interchangeably", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const seed = kp.secretKey.slice(0, 32);
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), 42n);
-            const viaSeed = (0, src_1.decryptCompactNoteCipher)(seed, c.ephemeralPublicKey, c.compactBlob);
-            const viaFull = (0, src_1.decryptCompactNoteCipher)(kp.secretKey, c.ephemeralPublicKey, c.compactBlob);
-            assert_1.strict.ok(viaSeed && viaFull);
-            assert_1.strict.equal(hex(viaSeed.blinding), hex(viaFull.blinding));
-        });
-    });
-    describe("isolation", () => {
-        it("a third party cannot decrypt someone else's note", () => {
-            const recipient = tweetnacl_1.default.sign.keyPair();
-            const stranger = tweetnacl_1.default.sign.keyPair();
-            const c = (0, src_1.createCompactNoteCipher)(recipient.publicKey, tweetnacl_1.default.randomBytes(32), 1000n);
-            assert_1.strict.equal((0, src_1.decryptCompactNoteCipher)(stranger.secretKey, c.ephemeralPublicKey, c.compactBlob), null, "a stranger decrypted a note that was not theirs");
-        });
-        it("returns null rather than throwing on a corrupted blob", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), 1n);
-            const corrupted = new Uint8Array(c.compactBlob);
-            corrupted[40] ^= 0xff;
-            assert_1.strict.equal((0, src_1.decryptCompactNoteCipher)(kp.secretKey, c.ephemeralPublicKey, corrupted), null);
-        });
-        it("returns null on a wrong-length blob", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            assert_1.strict.equal((0, src_1.decryptCompactNoteCipher)(kp.secretKey, kp.publicKey, new Uint8Array(79)), null);
-        });
-    });
-    describe("view tag scanning", () => {
-        it("matches for our own notes and yields a usable shared secret", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const blinding = tweetnacl_1.default.randomBytes(32);
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, blinding, 777n);
-            const { matches, sharedSecret } = (0, src_1.matchesViewTag)(kp.secretKey, c.ephemeralPublicKey, c.viewTag);
-            assert_1.strict.ok(matches, "our own note failed its own view tag");
-            const back = (0, src_1.decryptCompactNoteCipher)(kp.secretKey, c.ephemeralPublicKey, c.compactBlob, { sharedSecret });
-            assert_1.strict.ok(back);
-            assert_1.strict.equal(hex(back.blinding), hex(blinding));
-        });
-        it("rejects roughly 255/256 of foreign notes", () => {
-            const me = tweetnacl_1.default.sign.keyPair();
-            const x25519Private = (0, src_1.toX25519Private)(me.secretKey);
-            let falsePositives = 0;
-            const N = 512;
-            for (let i = 0; i < N; i++) {
-                const other = tweetnacl_1.default.sign.keyPair();
-                const c = (0, src_1.createCompactNoteCipher)(other.publicKey, tweetnacl_1.default.randomBytes(32), 1n);
-                if ((0, src_1.matchesViewTag)(me.secretKey, c.ephemeralPublicKey, c.viewTag, { x25519Private })
-                    .matches) {
-                    falsePositives++;
-                }
-            }
-            // Expect ~N/256 == 2. Anything near N means the tag carries no information.
-            assert_1.strict.ok(falsePositives < N / 16, `view tag filtered poorly: ${falsePositives}/${N} false positives`);
-        });
-        it("hoisted x25519Private agrees with the non-hoisted path", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), 5n);
-            const hoisted = (0, src_1.matchesViewTag)(kp.secretKey, c.ephemeralPublicKey, c.viewTag, {
-                x25519Private: (0, src_1.toX25519Private)(kp.secretKey),
-            });
-            const plain = (0, src_1.matchesViewTag)(kp.secretKey, c.ephemeralPublicKey, c.viewTag);
-            assert_1.strict.equal(hoisted.matches, plain.matches);
-            assert_1.strict.equal(hex(hoisted.sharedSecret), hex(plain.sharedSecret));
-        });
-    });
-    describe("shape and validation", () => {
-        it("produces a 32-byte key, an 80-byte blob and a u8 tag", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), 1n);
-            assert_1.strict.equal(c.ephemeralPublicKey.length, 32);
-            assert_1.strict.equal(c.compactBlob.length, src_1.COMPACT_BLOB_LENGTH);
-            assert_1.strict.ok(Number.isInteger(c.viewTag) && c.viewTag >= 0 && c.viewTag <= 255);
-        });
-        it("uses a fresh ephemeral key per note", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const blinding = tweetnacl_1.default.randomBytes(32);
-            const a = (0, src_1.createCompactNoteCipher)(kp.publicKey, blinding, 1n);
-            const b = (0, src_1.createCompactNoteCipher)(kp.publicKey, blinding, 1n);
-            assert_1.strict.notEqual(hex(a.ephemeralPublicKey), hex(b.ephemeralPublicKey), "ephemeral key reuse would link two notes to one sender");
-            assert_1.strict.notEqual(hex(a.compactBlob), hex(b.compactBlob));
-        });
-        it("rejects a malformed recipient key", () => {
-            assert_1.strict.throws(() => (0, src_1.createCompactNoteCipher)(new Uint8Array(31), tweetnacl_1.default.randomBytes(32), 1n), /32 bytes/);
-        });
-        it("rejects a short blinding", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            assert_1.strict.throws(() => (0, src_1.createCompactNoteCipher)(kp.publicKey, new Uint8Array(16), 1n), /at least 32 bytes/);
-        });
-        it("rejects an amount that does not fit in u64", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            assert_1.strict.throws(() => (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), 1n << 64n), /u64/);
-            assert_1.strict.throws(() => (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), -1n), /u64/);
-        });
-        it("round-trips u64::MAX", () => {
-            const kp = tweetnacl_1.default.sign.keyPair();
-            const max = 18446744073709551615n;
-            const c = (0, src_1.createCompactNoteCipher)(kp.publicKey, tweetnacl_1.default.randomBytes(32), max);
-            const back = (0, src_1.decryptCompactNoteCipher)(kp.secretKey, c.ephemeralPublicKey, c.compactBlob);
-            assert_1.strict.equal(back.amount, max);
-        });
-        it("emptyNoteCipher is all zeroes — the program's 'no note' sentinel", () => {
-            const e = (0, src_1.emptyNoteCipher)();
-            assert_1.strict.equal(e.viewTag, 0);
-            assert_1.strict.ok(e.ephemeralPublicKey.every((b) => b === 0));
-            assert_1.strict.ok(e.compactBlob.every((b) => b === 0));
-            assert_1.strict.equal(e.compactBlob.length, src_1.COMPACT_BLOB_LENGTH);
-        });
-    });
-});

package/dist/tests/config.test.d.ts

@@ -1 +0,0 @@
-import "mocha";