@veilo/sdk-core 0.1.17 → 0.4.0

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

@@ -0,0 +1,87 @@
+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/esm/shield/alt.js

@@ -0,0 +1,186 @@
+import { ComputeBudgetProgram, PublicKey, SystemProgram, } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddress, getAssociatedTokenAddressSync, } from "@solana/spl-token";
+import { getGlobalConfigPda, getNoteTreePda, getPoolPdas, } from "../client.js";
+import { PRIVACY_POOL_PROGRAM_ID } from "../program.js";
+import { NATIVE_SOL_MINT } from "../config.js";
+import { ShieldError } from "./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.
+ */
+export const SHARED_DEPOSIT_ALT = new PublicKey("3x2JxCgAPmv4U4EJonFBntm1q4W3xzpnB6aT1tCvxftk");
+/** Mints the shared table is provisioned for. */
+export const SHARED_ALT_MINTS = [
+    { symbol: "SOL", mint: NATIVE_SOL_MINT },
+    { symbol: "USDC", mint: new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") },
+    { symbol: "USDT", mint: new PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB") },
+    { symbol: "USD1", mint: new PublicKey("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB") },
+    { symbol: "JUP", mint: new PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN") },
+    { symbol: "ARX", mint: new 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.
+ */
+export function sharedDepositAlt(address = 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 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 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. */
+export 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.
+ */
+export function requiredAltKeys(params) {
+    const programId = params.programId ?? PRIVACY_POOL_PROGRAM_ID;
+    const { config, vault, nullifiers } = getPoolPdas(programId, params.mint);
+    const keys = [
+        { label: "programId", address: programId },
+        { label: "computeBudgetProgram", address: ComputeBudgetProgram.programId },
+        { label: "systemProgram", address: SystemProgram.programId },
+        { label: "globalConfig", address: getGlobalConfigPda(programId) },
+        { label: "config", address: config },
+        { label: "vault", address: vault },
+        { label: "nullifiers", address: nullifiers },
+        { label: "inputTree(0)", address: getNoteTreePda(programId, params.mint, 0) },
+    ];
+    if (params.outputTreeId !== 0) {
+        keys.push({
+            label: `outputTree(${params.outputTreeId})`,
+            address: getNoteTreePda(programId, params.mint, params.outputTreeId),
+        });
+    }
+    if (!params.mint.equals(NATIVE_SOL_MINT)) {
+        keys.push({ label: "tokenProgram", address: TOKEN_PROGRAM_ID }, {
+            label: "vaultAta",
+            address: 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.
+ */
+export async function expectedDepositAltKeys(params) {
+    const programId = params.programId ?? PRIVACY_POOL_PROGRAM_ID;
+    const mints = params.mints ?? SHARED_ALT_MINTS.map((m) => m.mint);
+    const maxTreeId = params.maxTreeId ?? 4;
+    const out = [
+        { label: "programId", address: programId },
+        { label: "computeBudgetProgram", address: ComputeBudgetProgram.programId },
+        { label: "systemProgram", address: SystemProgram.programId },
+        { label: "tokenProgram", address: TOKEN_PROGRAM_ID },
+        { label: "globalConfig", address: getGlobalConfigPda(programId) },
+    ];
+    for (const mint of mints) {
+        const label = mint.equals(NATIVE_SOL_MINT) ? "SOL" : mint.toBase58().slice(0, 4);
+        const { config, vault, nullifiers } = 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: getNoteTreePda(programId, mint, t),
+            });
+        }
+        if (!mint.equals(NATIVE_SOL_MINT)) {
+            out.push({
+                label: `${label}.vaultAta`,
+                address: await getAssociatedTokenAddress(mint, vault, true),
+            });
+        }
+    }
+    return out;
+}
+/** Diff the on-chain table against {@link expectedDepositAltKeys}. */
+export async function auditDepositAlt(connection, params = {}) {
+    const address = params.address ?? SHARED_DEPOSIT_ALT;
+    const res = await connection.getAddressLookupTable(address, {
+        commitment: "finalized",
+    });
+    if (!res.value) {
+        throw new 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 };
+}

package/dist/esm/shield/computeBudget.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Compute budget and transaction size constants for the shield path.
+ *
+ * These numbers are empirical and load-bearing. They are constants rather than
+ * inline literals so a future program change that invalidates them has one
+ * place to be fixed and one place to be read.
+ */
+/**
+ * Compute unit limit reserved for a shield.
+ *
+ * Measured usage for a deposit is ~377k CU; 700k leaves roughly 2× headroom
+ * while staying low enough that Phantom's Lighthouse guard still fits its own
+ * instructions alongside ours.
+ *
+ * Do NOT raise this to 1.4M (what the stale `client.ts` `deposit()` reserves).
+ * An oversized CU reservation is one of the signals that makes Phantom render
+ * the transaction with a malicious-dApp warning.
+ *
+ * Ported from veilo-dapp/features/transactions/handleDeposit.ts:673-681.
+ */
+export declare const SHIELD_COMPUTE_UNIT_LIMIT = 700000;
+/** Typical measured usage. If real usage approaches the limit above, revisit both. */
+export declare const SHIELD_COMPUTE_UNITS_MEASURED_TYPICAL = 377000;
+/** Default priority fee. Set to 0 to omit the instruction entirely (saves ~40 bytes). */
+export declare const SHIELD_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 50000;
+/** Solana's hard cap on a serialized transaction, signatures included. */
+export declare const MAX_TRANSACTION_BYTES = 1232;
+/** One ed25519 signature: 64 bytes plus the compact-array length prefix. */
+export declare const SIGNATURE_BYTES = 65;
+/**
+ * `NullifierMarker::LEN` (privacy-program .../lib.rs:415). Two markers are
+ * created per transact and paid for by the signer — see the note on sponsorship
+ * in the module docs of `shield.ts`.
+ */
+export declare const NULLIFIER_MARKER_ACCOUNT_BYTES = 10;
+/** Markers created per `transact` — one per circuit input. */
+export declare const NULLIFIER_MARKERS_PER_TRANSACT = 2;
+/** Default validity window for the on-chain `deadline` argument. */
+export declare const DEFAULT_DEADLINE_SECONDS = 3600;
+/**
+ * Serialized size of the `transact` instruction data, for reference:
+ *
+ *   8   discriminator
+ *  32   root
+ *   2   input_tree_id
+ *   2   output_tree_id
+ *   8   public_amount
+ *  32   ext_data_hash
+ *  32   mint_address
+ * 128   2 nullifiers + 2 commitments
+ *   8   deadline
+ * 112   ExtData (recipient, relayer, fee, refund, claimant)
+ * 256   Groth16 proof (a:64, b:128, c:64)
+ * 227   Option<NoteCiphers> (1 tag + 226)
+ * ---
+ * 847
+ *
+ * With 16 accounts this cannot fit in a legacy transaction (~1500 bytes), which
+ * is why the shield path is v0-with-ALT and not optional.
+ */
+export declare const TRANSACT_INSTRUCTION_DATA_BYTES = 847;

package/dist/esm/shield/computeBudget.js

@@ -0,0 +1,61 @@
+/**
+ * Compute budget and transaction size constants for the shield path.
+ *
+ * These numbers are empirical and load-bearing. They are constants rather than
+ * inline literals so a future program change that invalidates them has one
+ * place to be fixed and one place to be read.
+ */
+/**
+ * Compute unit limit reserved for a shield.
+ *
+ * Measured usage for a deposit is ~377k CU; 700k leaves roughly 2× headroom
+ * while staying low enough that Phantom's Lighthouse guard still fits its own
+ * instructions alongside ours.
+ *
+ * Do NOT raise this to 1.4M (what the stale `client.ts` `deposit()` reserves).
+ * An oversized CU reservation is one of the signals that makes Phantom render
+ * the transaction with a malicious-dApp warning.
+ *
+ * Ported from veilo-dapp/features/transactions/handleDeposit.ts:673-681.
+ */
+export const SHIELD_COMPUTE_UNIT_LIMIT = 700000;
+/** Typical measured usage. If real usage approaches the limit above, revisit both. */
+export const SHIELD_COMPUTE_UNITS_MEASURED_TYPICAL = 377000;
+/** Default priority fee. Set to 0 to omit the instruction entirely (saves ~40 bytes). */
+export const SHIELD_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 50000;
+/** Solana's hard cap on a serialized transaction, signatures included. */
+export const MAX_TRANSACTION_BYTES = 1232;
+/** One ed25519 signature: 64 bytes plus the compact-array length prefix. */
+export const SIGNATURE_BYTES = 65;
+/**
+ * `NullifierMarker::LEN` (privacy-program .../lib.rs:415). Two markers are
+ * created per transact and paid for by the signer — see the note on sponsorship
+ * in the module docs of `shield.ts`.
+ */
+export const NULLIFIER_MARKER_ACCOUNT_BYTES = 10;
+/** Markers created per `transact` — one per circuit input. */
+export const NULLIFIER_MARKERS_PER_TRANSACT = 2;
+/** Default validity window for the on-chain `deadline` argument. */
+export const DEFAULT_DEADLINE_SECONDS = 3600;
+/**
+ * Serialized size of the `transact` instruction data, for reference:
+ *
+ *   8   discriminator
+ *  32   root
+ *   2   input_tree_id
+ *   2   output_tree_id
+ *   8   public_amount
+ *  32   ext_data_hash
+ *  32   mint_address
+ * 128   2 nullifiers + 2 commitments
+ *   8   deadline
+ * 112   ExtData (recipient, relayer, fee, refund, claimant)
+ * 256   Groth16 proof (a:64, b:128, c:64)
+ * 227   Option<NoteCiphers> (1 tag + 226)
+ * ---
+ * 847
+ *
+ * With 16 accounts this cannot fit in a legacy transaction (~1500 bytes), which
+ * is why the shield path is v0-with-ALT and not optional.
+ */
+export const TRANSACT_INSTRUCTION_DATA_BYTES = 847;

package/dist/esm/shield/errors.d.ts

@@ -0,0 +1,58 @@
+import { TransactionInstruction } from "@solana/web3.js";
+/**
+ * Error taxonomy for the shield path.
+ *
+ * `parseOnChainError` already turns program codes into readable sentences. What
+ * it does not give you is a *decision*: can this be retried, and how? That is
+ * what integrators actually need, because the three retry classes have wildly
+ * different costs:
+ *
+ *   - `rebuild`  — reuse the proof, new blockhash. Milliseconds.
+ *   - `reshield` — the proof is stale, prove again. 10–30 seconds.
+ *   - `none`     — retrying cannot help; something must change first.
+ */
+export type ShieldRetryClass = "rebuild" | "reshield" | "none";
+export type ShieldErrorCode = "POOL_NOT_FOUND" | "POOL_PAUSED" | "AMOUNT_BELOW_MINIMUM" | "AMOUNT_ABOVE_MAXIMUM" | "TREE_FULL" | "INSUFFICIENT_SOL" | "INSUFFICIENT_TOKEN_BALANCE" | "TOKEN_ACCOUNT_MISSING" | "TOKEN_ACCOUNT_WRONG_MINT" | "TOKEN_ACCOUNT_WRONG_OWNER" | "TOKEN_ACCOUNT_DELEGATED" | "TOKEN_ACCOUNT_FROZEN" | "VAULT_ATA_MISSING" | "ALT_NOT_FOUND" | "ALT_INCOMPLETE" | "TX_TOO_LARGE" | "OWNER_INVARIANT_UNACKNOWLEDGED" | "UNRESOLVED_ACCOUNT" | "BLOCKHASH_EXPIRED" | "DEADLINE_EXPIRED" | "ROOT_STALE" | "NULLIFIER_COLLISION" | "COMPUTE_BUDGET_EXCEEDED" | "PROOF_REJECTED" | "UNKNOWN";
+export type ShieldErrorRemedy = {
+    /** Human-readable description of what would fix this. */
+    description: string;
+    /** Instructions that, once executed, clear the condition. */
+    instructions: TransactionInstruction[];
+};
+export declare class ShieldError extends Error {
+    readonly code: ShieldErrorCode;
+    /** Program error code (6000–6060) when this was derived from a chain error. */
+    readonly programCode?: number;
+    /** Whether and how a retry can succeed. */
+    readonly retryable: ShieldRetryClass;
+    /** Machine-readable detail: which account, what value, what was expected. */
+    readonly context?: Record<string, unknown>;
+    /** Present when the condition is fixable by executing instructions first. */
+    readonly remedy?: ShieldErrorRemedy;
+    readonly cause?: unknown;
+    constructor(code: ShieldErrorCode, message: string, opts?: {
+        programCode?: number;
+        retryable?: ShieldRetryClass;
+        context?: Record<string, unknown>;
+        remedy?: ShieldErrorRemedy;
+        cause?: unknown;
+    });
+}
+/** Extract a privacy_pool program error code from an arbitrary thrown value. */
+export declare function extractProgramCode(error: any): number | null;
+/**
+ * Map a submission failure onto the taxonomy.
+ *
+ * Two mappings here are not obvious and are worth stating plainly:
+ *
+ * **Nullifier collision means "already landed", not "already spent."** The
+ * marker PDAs are `init`, not `init_if_needed`, so a second submission of the
+ * same shield fails at account resolution. For a deposit the nullifiers derive
+ * from freshly generated random keys, so a genuine collision is impossible —
+ * in practice this only ever means the first attempt succeeded. Telling a user
+ * their funds were "already spent" here would be alarming and wrong.
+ *
+ * **`UnknownRoot` is recoverable but not by `rebuild()`.** The proof commits to
+ * the root, so a stale root needs a fresh proof, not a fresh blockhash.
+ */
+export declare function mapShieldError(error: unknown): ShieldError;

package/dist/esm/shield/errors.js

@@ -0,0 +1,115 @@
+import { parseOnChainError } from "../client.js";
+export class ShieldError extends Error {
+    constructor(code, message, opts = {}) {
+        super(message);
+        this.name = "ShieldError";
+        this.code = code;
+        this.programCode = opts.programCode;
+        this.retryable = opts.retryable ?? "none";
+        this.context = opts.context;
+        this.remedy = opts.remedy;
+        this.cause = opts.cause;
+    }
+}
+/** Extract a privacy_pool program error code from an arbitrary thrown value. */
+export function extractProgramCode(error) {
+    const raw = (error?.message ?? error?.toString() ?? "").toLowerCase();
+    const hex = raw.match(/custom program error:\s*0x([0-9a-f]+)/);
+    if (hex)
+        return parseInt(hex[1], 16);
+    const num = raw.match(/error number:\s*(\d+)/);
+    if (num)
+        return parseInt(num[1], 10);
+    if (typeof error?.error?.errorCode?.number === "number") {
+        return error.error.errorCode.number;
+    }
+    return null;
+}
+/**
+ * Map a submission failure onto the taxonomy.
+ *
+ * Two mappings here are not obvious and are worth stating plainly:
+ *
+ * **Nullifier collision means "already landed", not "already spent."** The
+ * marker PDAs are `init`, not `init_if_needed`, so a second submission of the
+ * same shield fails at account resolution. For a deposit the nullifiers derive
+ * from freshly generated random keys, so a genuine collision is impossible —
+ * in practice this only ever means the first attempt succeeded. Telling a user
+ * their funds were "already spent" here would be alarming and wrong.
+ *
+ * **`UnknownRoot` is recoverable but not by `rebuild()`.** The proof commits to
+ * the root, so a stale root needs a fresh proof, not a fresh blockhash.
+ */
+export function mapShieldError(error) {
+    if (error instanceof ShieldError)
+        return error;
+    const err = error;
+    const raw = (err?.message ?? String(err ?? "")).toLowerCase();
+    const programCode = extractProgramCode(err);
+    const readable = parseOnChainError(err);
+    if (programCode !== null) {
+        switch (programCode) {
+            case 6000:
+                return new ShieldError("POOL_PAUSED", readable, { programCode, cause: err });
+            case 6007:
+                return new ShieldError("ROOT_STALE", "The Merkle root this shield was proven against is no longer in the on-chain " +
+                    "history. Build a new shield — the proof cannot be reused.", { programCode, retryable: "reshield", cause: err });
+            case 6012:
+                return new ShieldError("PROOF_REJECTED", readable, { programCode, cause: err });
+            case 6013:
+                return new ShieldError("TREE_FULL", readable, {
+                    programCode,
+                    retryable: "reshield",
+                    cause: err,
+                });
+            case 6017:
+                return new ShieldError("TOKEN_ACCOUNT_WRONG_MINT", readable, {
+                    programCode,
+                    cause: err,
+                });
+            case 6029:
+                return new ShieldError("TOKEN_ACCOUNT_DELEGATED", "The source token account has an active delegate. Revoke it, then shield again.", { programCode, cause: err });
+            case 6033:
+                return new ShieldError("TOKEN_ACCOUNT_WRONG_OWNER", "The source token account is not owned by the signing wallet.", { programCode, cause: err });
+            case 6035:
+                return new ShieldError("AMOUNT_BELOW_MINIMUM", readable, { programCode, cause: err });
+            case 6036:
+                return new ShieldError("AMOUNT_ABOVE_MAXIMUM", readable, { programCode, cause: err });
+            case 6050:
+                return new ShieldError("VAULT_ATA_MISSING", readable, { programCode, cause: err });
+            case 6005:
+            case 6046:
+            case 6052:
+                return new ShieldError("NULLIFIER_COLLISION", ALREADY_SHIELDED_MESSAGE, {
+                    programCode,
+                    cause: err,
+                });
+            case 6060:
+                return new ShieldError("DEADLINE_EXPIRED", "The shield's deadline passed before it landed. Rebuild it — the proof is still valid.", { programCode, retryable: "rebuild", cause: err });
+            default:
+                return new ShieldError("UNKNOWN", readable, { programCode, cause: err });
+        }
+    }
+    // Non-program failures.
+    if (raw.includes("block height exceeded") ||
+        raw.includes("blockhash not found") ||
+        err?.name === "TransactionExpiredBlockheightExceededError") {
+        return new ShieldError("BLOCKHASH_EXPIRED", "The blockhash expired before the shield landed. Rebuild it — the proof is still valid.", { retryable: "rebuild", cause: err });
+    }
+    if (raw.includes("already in use")) {
+        return new ShieldError("NULLIFIER_COLLISION", ALREADY_SHIELDED_MESSAGE, { cause: err });
+    }
+    if (raw.includes("exceeded cus") ||
+        raw.includes("computational budget exceeded") ||
+        raw.includes("exceeded compute")) {
+        return new ShieldError("COMPUTE_BUDGET_EXCEEDED", `The shield exceeded its compute budget. Real usage has grown past the reserved ` +
+            `limit — SHIELD_COMPUTE_UNIT_LIMIT needs revisiting.`, { cause: err });
+    }
+    if (raw.includes("too large") || raw.includes("transaction too large")) {
+        return new ShieldError("TX_TOO_LARGE", readable, { cause: err });
+    }
+    return new ShieldError("UNKNOWN", readable, { cause: err });
+}
+const ALREADY_SHIELDED_MESSAGE = "This shield has already been submitted — check the transaction signature before " +
+    "retrying. (The nullifier markers already exist on-chain, which for a deposit means " +
+    "the original transaction landed; it does not mean the funds were spent.)";

package/dist/esm/shield/finalize.d.ts

@@ -0,0 +1,45 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { ShieldNote, ShieldOwner } from "./types.js";
+/**
+ * Read the authoritative leaf index for a landed shield, and produce the
+ * mailbox blob for optional relayer delivery.
+ *
+ * ## Why this is a separate step
+ *
+ * Every existing deposit implementation records `tree.nextIndex` read *before*
+ * submission as the note's leaf index. Under concurrent deposits into the same
+ * tree that value is wrong, and it is wrong permanently — the stored index is
+ * what a later withdrawal builds its Merkle path from, so the note becomes
+ * unspendable through the normal path.
+ *
+ * That race is rare for a single wallet and constant for an SDK: a platform
+ * batching shields for many users will hit it routinely. So `shield()` reports
+ * only a `predictedLeafIndex`, and the real one is read here from the
+ * transaction's own `CommitmentEvent` after it confirms.
+ *
+ * ## What is optional
+ *
+ * Everything, strictly. The note is recoverable from chain data alone via the
+ * on-chain compact cipher, so a caller that skips finalization has not lost the
+ * funds — only the fast path to finding them. Persist nothing that depends on a
+ * leaf index without calling this first.
+ */
+export declare function finalizeShield(params: {
+    connection: Connection;
+    signature: string;
+    note: ShieldNote;
+    owner: ShieldOwner;
+    programId?: PublicKey;
+    /** Defaults to "confirmed". Use "finalized" if the index will be persisted. */
+    commitment?: "confirmed" | "finalized";
+}): Promise<{
+    leafIndex: number;
+    newRoot: Uint8Array;
+    treeId: number;
+    slot: number;
+    /** Encrypted note blob, ready for POST /notes/save if the caller wants mailbox delivery. */
+    blob: {
+        ephemeralPublicKey: Uint8Array;
+        encryptedBlob: string;
+    };
+}>;