@veilo/sdk-core 0.4.0 → 0.5.0

package/dist/src/relayer.js

@@ -1,257 +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.VeiloRelayerClient = exports.VeiloApiError = void 0;
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const DEFAULT_RELAYER_URL = "https://relayer-server.onrender.com";
-// =============================================================================
-// Structured Error
-// =============================================================================
-/** Structured error thrown by VeiloRelayerClient on API failures. */
-class VeiloApiError extends Error {
-    constructor(code, message, status, details) {
-        super(message);
-        this.name = "VeiloApiError";
-        this.code = code;
-        this.status = status;
-        this.details = details;
-    }
-}
-exports.VeiloApiError = VeiloApiError;
-const DEFAULT_RETRY = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    retryableStatuses: [429, 502, 503, 504],
-};
-// =============================================================================
-// Base64 helpers (no dependency on tweetnacl-util)
-// =============================================================================
-function toBase64(bytes) {
-    if (typeof Buffer !== "undefined") {
-        return Buffer.from(bytes).toString("base64");
-    }
-    return btoa(String.fromCharCode(...bytes));
-}
-function fromBase64(str) {
-    if (typeof Buffer !== "undefined") {
-        return new Uint8Array(Buffer.from(str, "base64"));
-    }
-    const binary = atob(str);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++)
-        bytes[i] = binary.charCodeAt(i);
-    return bytes;
-}
-// =============================================================================
-// Encryption
-// =============================================================================
-/**
- * Encrypt a JSON-serializable payload for the relayer using NaCl box.
- * Layout: [ephemeralPubKey (32)] [nonce (24)] [ciphertext (...)]
- */
-function encryptForRelayer(data, relayerPublicKey) {
-    const ephemeral = tweetnacl_1.default.box.keyPair();
-    const message = new TextEncoder().encode(JSON.stringify(data));
-    const nonce = tweetnacl_1.default.randomBytes(tweetnacl_1.default.box.nonceLength);
-    const ciphertext = tweetnacl_1.default.box(message, nonce, relayerPublicKey, ephemeral.secretKey);
-    const payload = new Uint8Array(ephemeral.publicKey.length + nonce.length + ciphertext.length);
-    payload.set(ephemeral.publicKey, 0);
-    payload.set(nonce, ephemeral.publicKey.length);
-    payload.set(ciphertext, ephemeral.publicKey.length + nonce.length);
-    return toBase64(payload);
-}
-// =============================================================================
-// Relayer Client
-// =============================================================================
-/**
- * HTTP client for the Veilo relayer API.
- *
- * Handles auth, notes, merkle, and encrypted transact endpoints with
- * automatic retry on transient failures and NaCl box payload encryption.
- *
- * @example
- * ```ts
- * const client = new VeiloRelayerClient({
- *   apiKey: "your-api-key",
- *   relayerPublicKey: "<base64 NaCl public key>",
- * });
- * const root = await client.getMerkleRoot("So111...");
- * ```
- */
-class VeiloRelayerClient {
-    constructor(config, retry) {
-        this.baseUrl = (config.relayerUrl?.trim() || DEFAULT_RELAYER_URL).replace(/\/+$/, "");
-        this.apiKey = config.apiKey;
-        this.relayerPubKey = fromBase64(config.relayerPublicKey);
-        this.authToken = config.authToken;
-        this.retry = { ...DEFAULT_RETRY, ...retry };
-    }
-    /** Update the auth token (e.g. after register/restore). */
-    setAuthToken(token) {
-        this.authToken = token;
-    }
-    // ---------------------------------------------------------------------------
-    // Internal helpers
-    // ---------------------------------------------------------------------------
-    headers(authenticated) {
-        const h = {
-            "Content-Type": "application/json",
-        };
-        if (this.apiKey)
-            h["x-api-key"] = this.apiKey;
-        if (authenticated && this.authToken) {
-            h["Authorization"] = `Bearer ${this.authToken}`;
-        }
-        return h;
-    }
-    async request(method, path, opts = {}) {
-        const url = `${this.baseUrl}/api${path}`;
-        const { body, authenticated = false, retryable = true } = opts;
-        const maxAttempts = retryable ? this.retry.maxRetries + 1 : 1;
-        let lastError;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            if (attempt > 0) {
-                const delay = this.retry.baseDelayMs * Math.pow(2, attempt - 1) +
-                    Math.random() * 200;
-                await new Promise((r) => setTimeout(r, delay));
-            }
-            let res;
-            try {
-                res = await fetch(url, {
-                    method,
-                    headers: this.headers(authenticated),
-                    body: body != null ? JSON.stringify(body) : undefined,
-                });
-            }
-            catch (err) {
-                lastError = new VeiloApiError("NETWORK_ERROR", err.message || "Network request failed", 0);
-                continue;
-            }
-            const data = await res.json().catch(() => ({}));
-            if (res.ok && data.success !== false) {
-                return data;
-            }
-            lastError = new VeiloApiError(data.error || "UNKNOWN", data.message || data.error || `Request failed: ${res.status}`, res.status, data);
-            // Only retry on transient statuses
-            if (!this.retry.retryableStatuses.includes(res.status)) {
-                throw lastError;
-            }
-        }
-        throw lastError;
-    }
-    encrypt(data) {
-        return encryptForRelayer({
-            ...data,
-            timestamp: Date.now(),
-            nonce: toBase64(tweetnacl_1.default.randomBytes(32)),
-        }, this.relayerPubKey);
-    }
-    // ---------------------------------------------------------------------------
-    // Auth
-    // ---------------------------------------------------------------------------
-    /** Request a signature challenge for wallet authentication. */
-    async getChallenge(walletPublicKey) {
-        return this.request("POST", "/auth/challenge", {
-            body: { walletPublicKey },
-        });
-    }
-    /** Register a new account with a signed challenge. Returns a JWT auth token. */
-    async register(data) {
-        return this.request("POST", "/auth/register", { body: data });
-    }
-    /** Restore an existing account using a signed challenge. Returns a JWT auth token. */
-    async restore(data) {
-        return this.request("POST", "/auth/restore", { body: data });
-    }
-    /** Check whether a username is available for registration. */
-    async checkUsername(username) {
-        return this.request("GET", `/auth/checkUsername?username=${encodeURIComponent(username)}`);
-    }
-    /** Look up a user's Veilo public key by username or wallet public key. */
-    async getVeiloPublicKey(params) {
-        const query = "username" in params && params.username
-            ? `username=${encodeURIComponent(params.username)}`
-            : `publicKey=${encodeURIComponent(params.publicKey)}`;
-        return this.request("GET", `/auth/veiloPublicKey?${query}`);
-    }
-    /**
-     * Provision (or retrieve) the Veilo spend key paired with a Solana address.
-     * Public and idempotent; the response contains public key material only.
-     */
-    async preRegisterKey(solanaAddress) {
-        return this.request("POST", "/auth/pre-register-key", {
-            body: { solanaAddress },
-        });
-    }
-    // ---------------------------------------------------------------------------
-    // Notes
-    // ---------------------------------------------------------------------------
-    /** Save an encrypted note to the relayer's database. */
-    async saveEncryptedNote(data) {
-        return this.request("POST", "/notes/save", { body: data });
-    }
-    /** Query encrypted notes for the authenticated user. Requires auth token. */
-    async queryEncryptedNotes(params = {}) {
-        return this.request("POST", "/notes/query", {
-            body: params,
-            authenticated: true,
-        });
-    }
-    /** Delete all stored data for the authenticated user. Requires auth token. */
-    async deleteUserData() {
-        return this.request("POST", "/notes/delete", { authenticated: true });
-    }
-    // ---------------------------------------------------------------------------
-    // Merkle
-    // ---------------------------------------------------------------------------
-    /** Fetch the current Merkle root for a pool, optionally filtered by mint and tree ID. */
-    async getMerkleRoot(mintAddress, treeId) {
-        const params = new URLSearchParams();
-        if (mintAddress)
-            params.append("mintAddress", mintAddress);
-        if (treeId !== undefined)
-            params.append("treeId", treeId.toString());
-        const qs = params.toString();
-        return this.request("GET", `/merkle/root${qs ? `?${qs}` : ""}`);
-    }
-    /** Fetch the full Merkle tree (all leaves) for a pool. */
-    async getMerkleTree(mintAddress, treeId) {
-        const params = new URLSearchParams();
-        if (mintAddress)
-            params.append("mintAddress", mintAddress);
-        if (treeId !== undefined)
-            params.append("treeId", treeId.toString());
-        const qs = params.toString();
-        return this.request("GET", `/merkle/tree${qs ? `?${qs}` : ""}`);
-    }
-    // ---------------------------------------------------------------------------
-    // Transact (encrypted payloads)
-    // ---------------------------------------------------------------------------
-    /** Submit an encrypted withdrawal request to the relayer. Not retried on failure. */
-    async submitWithdraw(data) {
-        const encryptedPayload = this.encrypt(data);
-        return this.request("POST", "/transact/withdra", {
-            body: { encryptedPayload },
-            retryable: false,
-        });
-    }
-    /** Submit an encrypted private transfer request. Not retried on failure. */
-    async submitPrivateTransfer(data) {
-        const encryptedPayload = this.encrypt(data);
-        return this.request("POST", "/transact/private-transfer", {
-            body: { encryptedPayload },
-            retryable: false,
-        });
-    }
-    /** Submit an encrypted private swap request. Not retried on failure. */
-    async submitPrivateSwap(data) {
-        const encryptedPayload = this.encrypt(data);
-        return this.request("POST", "/transact/private-swap", {
-            body: { encryptedPayload },
-            retryable: false,
-        });
-    }
-}
-exports.VeiloRelayerClient = VeiloRelayerClient;

package/dist/src/retry.d.ts

@@ -1,32 +0,0 @@
-/**
- * Configuration for retry behavior on Solana RPC calls.
- */
-export interface RpcRetryPolicy {
-    /** Maximum number of retry attempts (default: 3) */
-    maxRetries: number;
-    /** Base delay in ms for exponential backoff (default: 1000) */
-    baseDelayMs: number;
-    /** Maximum delay cap in ms (default: 10000) */
-    maxDelayMs: number;
-}
-export declare const DEFAULT_RPC_RETRY: RpcRetryPolicy;
-/**
- * Execute an async function with retries on transient RPC failures.
- *
- * Retries on: BlockhashNotFound, HTTP 429/502/503/504, timeouts, connection resets.
- * Does NOT retry on: program errors (6xxx), signature verification failures, or other
- * deterministic errors that would fail again.
- *
- * @param fn      The async operation to execute
- * @param policy  Retry configuration (uses sensible defaults if omitted)
- * @returns       The result of the async operation
- *
- * @example
- * ```ts
- * const txSig = await withRpcRetry(
- *   () => program.methods.transact(...).accounts({...}).signers([...]).rpc(),
- *   { maxRetries: 5 },
- * );
- * ```
- */
-export declare function withRpcRetry<T>(fn: () => Promise<T>, policy?: Partial<RpcRetryPolicy>): Promise<T>;

package/dist/src/retry.js

@@ -1,75 +0,0 @@
-"use strict";
-// -----------------------------------------------------------------------------
-// RPC Retry / Resilience
-// -----------------------------------------------------------------------------
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_RPC_RETRY = void 0;
-exports.withRpcRetry = withRpcRetry;
-exports.DEFAULT_RPC_RETRY = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 10000,
-};
-/** Error messages / patterns that indicate a transient RPC failure worth retrying. */
-const RETRYABLE_PATTERNS = [
-    "blockhash not found",
-    "block height exceeded",
-    "blockhash already expired",
-    "node is behind",
-    "service unavailable",
-    "too many requests",
-    "429",
-    "502",
-    "503",
-    "504",
-    "timeout",
-    "timed out",
-    "econnreset",
-    "econnrefused",
-    "socket hang up",
-    "fetch failed",
-];
-function isRetryableError(error) {
-    const msg = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return RETRYABLE_PATTERNS.some((p) => msg.includes(p));
-}
-/**
- * Execute an async function with retries on transient RPC failures.
- *
- * Retries on: BlockhashNotFound, HTTP 429/502/503/504, timeouts, connection resets.
- * Does NOT retry on: program errors (6xxx), signature verification failures, or other
- * deterministic errors that would fail again.
- *
- * @param fn      The async operation to execute
- * @param policy  Retry configuration (uses sensible defaults if omitted)
- * @returns       The result of the async operation
- *
- * @example
- * ```ts
- * const txSig = await withRpcRetry(
- *   () => program.methods.transact(...).accounts({...}).signers([...]).rpc(),
- *   { maxRetries: 5 },
- * );
- * ```
- */
-async function withRpcRetry(fn, policy) {
-    const { maxRetries, baseDelayMs, maxDelayMs } = {
-        ...exports.DEFAULT_RPC_RETRY,
-        ...policy,
-    };
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt >= maxRetries || !isRetryableError(error)) {
-                throw error;
-            }
-            const delay = Math.min(baseDelayMs * Math.pow(2, attempt) + Math.random() * 200, maxDelayMs);
-            await new Promise((r) => setTimeout(r, delay));
-        }
-    }
-    throw lastError;
-}

package/dist/src/shield/alt.d.ts

@@ -1,87 +0,0 @@
-import { AddressLookupTableAccount, Connection, PublicKey } from "@solana/web3.js";
-import type { AltSource, ShieldCachePort } from "./types.js";
-/**
- * Address lookup table handling for the shield path.
- *
- * The ALT is not an optimisation here — it is load-bearing. A `transact` carries
- * 847 bytes of instruction data across 16 accounts, which is ~1500 bytes as a
- * legacy transaction and therefore unlandable. Compressing the constant pool
- * accounts to 1-byte indices is what brings it to ~1163 and leaves room for
- * Phantom's Lighthouse guard instructions.
- */
-/**
- * The shared, team-owned deposit table.
- *
- * Deliberately shared rather than per-wallet: creating a per-wallet table costs
- * the signer an extra signature and unrecoverable rent, which is unacceptable to
- * ask of an external wallet shielding once, and impossible to ask of a
- * third-party platform's managed wallet.
- */
-export declare const SHARED_DEPOSIT_ALT: PublicKey;
-/** Mints the shared table is provisioned for. */
-export declare const SHARED_ALT_MINTS: {
-    symbol: string;
-    mint: PublicKey;
-}[];
-/**
- * Load the shared table, and verify it actually covers this shield.
- *
- * The verification is the important part. Coverage is an *operational* property,
- * not a code property: the table is populated by a script, and if a mint or a
- * tree is missing, every one of its accounts falls back to a 32-byte static key
- * and the transaction silently grows past 1232. Failing here with a list of the
- * missing addresses is far better than failing at `signTransaction` with
- * "transaction too large" and no indication why.
- */
-export declare function sharedDepositAlt(address?: PublicKey, opts?: {
-    cache?: ShieldCachePort;
-    verifyCoverage?: boolean;
-}): AltSource;
-/** Use a table the caller already loaded. Skips both the RPC call and the coverage check. */
-export declare function explicitAlt(account: AddressLookupTableAccount): AltSource;
-type NamedKey = {
-    label: string;
-    address: PublicKey;
-};
-/**
- * Accounts that must be in the table for a shield of `mint` into `outputTreeId`
- * to fit.
- *
- * The signer, the two nullifier markers, and the user's token account are
- * deliberately excluded: markers are unique per transaction and the others are
- * per-user, so none can live in a shared table. They are the static keys the
- * size budget accounts for.
- */
-export declare function requiredAltKeys(params: {
-    mint: PublicKey;
-    outputTreeId: number;
-    programId?: PublicKey;
-}): NamedKey[];
-/**
- * Everything the shared table should contain across every supported mint and
- * every tree up to `maxTreeId`.
- *
- * Exported so this can be asserted in CI. The table currently only covers tree 0
- * per mint, which means the size budget quietly loses 32 bytes of headroom the
- * day tree 0 fills and `getBestTreeForDeposit` starts returning tree 1. That is
- * a scheduled failure, and this function is how it gets caught before a user
- * finds it.
- */
-export declare function expectedDepositAltKeys(params: {
-    mints?: PublicKey[];
-    maxTreeId?: number;
-    programId?: PublicKey;
-}): Promise<NamedKey[]>;
-/** Diff the on-chain table against {@link expectedDepositAltKeys}. */
-export declare function auditDepositAlt(connection: Connection, params?: {
-    address?: PublicKey;
-    mints?: PublicKey[];
-    maxTreeId?: number;
-    programId?: PublicKey;
-}): Promise<{
-    ok: boolean;
-    present: number;
-    missing: NamedKey[];
-    extra: string[];
-}>;
-export {};

package/dist/src/shield/alt.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHARED_ALT_MINTS = exports.SHARED_DEPOSIT_ALT = void 0;
-exports.sharedDepositAlt = sharedDepositAlt;
-exports.explicitAlt = explicitAlt;
-exports.requiredAltKeys = requiredAltKeys;
-exports.expectedDepositAltKeys = expectedDepositAltKeys;
-exports.auditDepositAlt = auditDepositAlt;
-const web3_js_1 = require("@solana/web3.js");
-const spl_token_1 = require("@solana/spl-token");
-const client_js_1 = require("../client.js");
-const program_js_1 = require("../program.js");
-const config_js_1 = require("../config.js");
-const errors_js_1 = require("./errors.js");
-/**
- * Address lookup table handling for the shield path.
- *
- * The ALT is not an optimisation here — it is load-bearing. A `transact` carries
- * 847 bytes of instruction data across 16 accounts, which is ~1500 bytes as a
- * legacy transaction and therefore unlandable. Compressing the constant pool
- * accounts to 1-byte indices is what brings it to ~1163 and leaves room for
- * Phantom's Lighthouse guard instructions.
- */
-/**
- * The shared, team-owned deposit table.
- *
- * Deliberately shared rather than per-wallet: creating a per-wallet table costs
- * the signer an extra signature and unrecoverable rent, which is unacceptable to
- * ask of an external wallet shielding once, and impossible to ask of a
- * third-party platform's managed wallet.
- */
-exports.SHARED_DEPOSIT_ALT = new web3_js_1.PublicKey("3x2JxCgAPmv4U4EJonFBntm1q4W3xzpnB6aT1tCvxftk");
-/** Mints the shared table is provisioned for. */
-exports.SHARED_ALT_MINTS = [
-    { symbol: "SOL", mint: config_js_1.NATIVE_SOL_MINT },
-    { symbol: "USDC", mint: new web3_js_1.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") },
-    { symbol: "USDT", mint: new web3_js_1.PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB") },
-    { symbol: "USD1", mint: new web3_js_1.PublicKey("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB") },
-    { symbol: "JUP", mint: new web3_js_1.PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN") },
-    { symbol: "ARX", mint: new web3_js_1.PublicKey("ARXwZkNAtzPfdcoqQiduJn8EPv9fKiDfGn2KyggyDrFs") },
-];
-const ALT_CACHE_TTL_MS = 10 * 60000;
-/**
- * Load the shared table, and verify it actually covers this shield.
- *
- * The verification is the important part. Coverage is an *operational* property,
- * not a code property: the table is populated by a script, and if a mint or a
- * tree is missing, every one of its accounts falls back to a 32-byte static key
- * and the transaction silently grows past 1232. Failing here with a list of the
- * missing addresses is far better than failing at `signTransaction` with
- * "transaction too large" and no indication why.
- */
-function sharedDepositAlt(address = exports.SHARED_DEPOSIT_ALT, opts = {}) {
-    return {
-        async resolve({ connection, mint, outputTreeId, programId }) {
-            const key = `alt:${address.toBase58()}`;
-            let account = await opts.cache?.get(key);
-            if (!account) {
-                // "finalized" so every RPC the signer's wallet might simulate against
-                // has already seen the table. A table read at "processed" can be
-                // invisible to the wallet's own simulator.
-                const res = await connection.getAddressLookupTable(address, {
-                    commitment: "finalized",
-                });
-                if (!res.value) {
-                    throw new errors_js_1.ShieldError("ALT_NOT_FOUND", `Deposit address lookup table ${address.toBase58()} was not found at ` +
-                        `finalized commitment. Without it a shield cannot fit in 1232 bytes.`, { context: { address: address.toBase58() } });
-                }
-                account = res.value;
-                await opts.cache?.set(key, account, ALT_CACHE_TTL_MS);
-            }
-            if (opts.verifyCoverage !== false) {
-                const missing = missingCoverage(account, {
-                    mint,
-                    outputTreeId,
-                    programId,
-                });
-                if (missing.length > 0) {
-                    throw new errors_js_1.ShieldError("ALT_INCOMPLETE", `The deposit lookup table does not cover this shield: ${missing.length} ` +
-                        `required account(s) are absent, so the transaction would exceed 1232 ` +
-                        `bytes. Extend the table before shielding this mint/tree.`, {
-                        context: {
-                            alt: address.toBase58(),
-                            mint: mint.toBase58(),
-                            outputTreeId,
-                            missing: missing.map((m) => `${m.label} (${m.address.toBase58()})`),
-                        },
-                    });
-                }
-            }
-            return account;
-        },
-    };
-}
-/** Use a table the caller already loaded. Skips both the RPC call and the coverage check. */
-function explicitAlt(account) {
-    return { async resolve() { return account; } };
-}
-/**
- * Accounts that must be in the table for a shield of `mint` into `outputTreeId`
- * to fit.
- *
- * The signer, the two nullifier markers, and the user's token account are
- * deliberately excluded: markers are unique per transaction and the others are
- * per-user, so none can live in a shared table. They are the static keys the
- * size budget accounts for.
- */
-function requiredAltKeys(params) {
-    const programId = params.programId ?? program_js_1.PRIVACY_POOL_PROGRAM_ID;
-    const { config, vault, nullifiers } = (0, client_js_1.getPoolPdas)(programId, params.mint);
-    const keys = [
-        { label: "programId", address: programId },
-        { label: "computeBudgetProgram", address: web3_js_1.ComputeBudgetProgram.programId },
-        { label: "systemProgram", address: web3_js_1.SystemProgram.programId },
-        { label: "globalConfig", address: (0, client_js_1.getGlobalConfigPda)(programId) },
-        { label: "config", address: config },
-        { label: "vault", address: vault },
-        { label: "nullifiers", address: nullifiers },
-        { label: "inputTree(0)", address: (0, client_js_1.getNoteTreePda)(programId, params.mint, 0) },
-    ];
-    if (params.outputTreeId !== 0) {
-        keys.push({
-            label: `outputTree(${params.outputTreeId})`,
-            address: (0, client_js_1.getNoteTreePda)(programId, params.mint, params.outputTreeId),
-        });
-    }
-    if (!params.mint.equals(config_js_1.NATIVE_SOL_MINT)) {
-        keys.push({ label: "tokenProgram", address: spl_token_1.TOKEN_PROGRAM_ID }, {
-            label: "vaultAta",
-            address: (0, spl_token_1.getAssociatedTokenAddressSync)(params.mint, vault, true),
-        });
-    }
-    return keys;
-}
-function missingCoverage(account, params) {
-    const present = new Set(account.state.addresses.map((a) => a.toBase58()));
-    return requiredAltKeys(params).filter((k) => !present.has(k.address.toBase58()));
-}
-/**
- * Everything the shared table should contain across every supported mint and
- * every tree up to `maxTreeId`.
- *
- * Exported so this can be asserted in CI. The table currently only covers tree 0
- * per mint, which means the size budget quietly loses 32 bytes of headroom the
- * day tree 0 fills and `getBestTreeForDeposit` starts returning tree 1. That is
- * a scheduled failure, and this function is how it gets caught before a user
- * finds it.
- */
-async function expectedDepositAltKeys(params) {
-    const programId = params.programId ?? program_js_1.PRIVACY_POOL_PROGRAM_ID;
-    const mints = params.mints ?? exports.SHARED_ALT_MINTS.map((m) => m.mint);
-    const maxTreeId = params.maxTreeId ?? 4;
-    const out = [
-        { label: "programId", address: programId },
-        { label: "computeBudgetProgram", address: web3_js_1.ComputeBudgetProgram.programId },
-        { label: "systemProgram", address: web3_js_1.SystemProgram.programId },
-        { label: "tokenProgram", address: spl_token_1.TOKEN_PROGRAM_ID },
-        { label: "globalConfig", address: (0, client_js_1.getGlobalConfigPda)(programId) },
-    ];
-    for (const mint of mints) {
-        const label = mint.equals(config_js_1.NATIVE_SOL_MINT) ? "SOL" : mint.toBase58().slice(0, 4);
-        const { config, vault, nullifiers } = (0, client_js_1.getPoolPdas)(programId, mint);
-        out.push({ label: `${label}.config`, address: config }, { label: `${label}.vault`, address: vault }, { label: `${label}.nullifiers`, address: nullifiers });
-        for (let t = 0; t <= maxTreeId; t++) {
-            out.push({
-                label: `${label}.tree(${t})`,
-                address: (0, client_js_1.getNoteTreePda)(programId, mint, t),
-            });
-        }
-        if (!mint.equals(config_js_1.NATIVE_SOL_MINT)) {
-            out.push({
-                label: `${label}.vaultAta`,
-                address: await (0, spl_token_1.getAssociatedTokenAddress)(mint, vault, true),
-            });
-        }
-    }
-    return out;
-}
-/** Diff the on-chain table against {@link expectedDepositAltKeys}. */
-async function auditDepositAlt(connection, params = {}) {
-    const address = params.address ?? exports.SHARED_DEPOSIT_ALT;
-    const res = await connection.getAddressLookupTable(address, {
-        commitment: "finalized",
-    });
-    if (!res.value) {
-        throw new errors_js_1.ShieldError("ALT_NOT_FOUND", `Deposit ALT ${address.toBase58()} not found`, { context: { address: address.toBase58() } });
-    }
-    const present = new Set(res.value.state.addresses.map((a) => a.toBase58()));
-    const expected = await expectedDepositAltKeys(params);
-    const expectedSet = new Set(expected.map((e) => e.address.toBase58()));
-    const missing = expected.filter((e) => !present.has(e.address.toBase58()));
-    const extra = [...present].filter((p) => !expectedSet.has(p));
-    return { ok: missing.length === 0, present: present.size, missing, extra };
-}