@veilo/sdk-core 0.4.0 → 0.5.0

package/dist/src/shield/ix.js

@@ -1,119 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRANSACT_ACCOUNT_NAMES = void 0;
-exports.buildTransactInstruction = buildTransactInstruction;
-const anchor = __importStar(require("@coral-xyz/anchor"));
-const web3_js_1 = require("@solana/web3.js");
-const program_js_1 = require("../program.js");
-const errors_js_1 = require("./errors.js");
-const computeBudget_js_1 = require("./computeBudget.js");
-// Anchor is CommonJS and does not expose BN as a detectable named export to
-// Node ESM. Pull both runtime values from the namespace so CJS and ESM agree.
-const { BN, BorshInstructionCoder } = anchor;
-const IDL_TRANSACT = program_js_1.PRIVACY_POOL_IDL.instructions.find((i) => i.name === "transact");
-if (!IDL_TRANSACT) {
-    throw new Error("privacy_pool IDL has no `transact` instruction");
-}
-/** Account names in IDL order. Exported so callers can see what must be resolved. */
-exports.TRANSACT_ACCOUNT_NAMES = IDL_TRANSACT.accounts.map((a) => a.name);
-/**
- * Build the `transact` instruction.
- *
- * @throws ShieldError('UNRESOLVED_ACCOUNT') if the IDL declares an account the
- *         caller did not supply — a loud failure is the point, because the
- *         alternative is a misordered account list that fails opaquely on-chain.
- */
-function buildTransactInstruction(accounts, args, programId = program_js_1.PRIVACY_POOL_PROGRAM_ID) {
-    const keys = IDL_TRANSACT.accounts.map((a) => {
-        const pubkey = accounts[a.name];
-        if (!pubkey) {
-            throw new errors_js_1.ShieldError("UNRESOLVED_ACCOUNT", `The IDL declares account "${a.name}" for transact, but it was not resolved. ` +
-                `Expected accounts: ${exports.TRANSACT_ACCOUNT_NAMES.join(", ")}`, { context: { missing: a.name, supplied: Object.keys(accounts) } });
-        }
-        return {
-            pubkey,
-            isWritable: !!a.writable,
-            isSigner: !!a.signer,
-        };
-    });
-    const coder = new BorshInstructionCoder(program_js_1.PRIVACY_POOL_IDL);
-    const data = coder.encode("transact", toBorshArgs(args));
-    if (data.length !== computeBudget_js_1.TRANSACT_INSTRUCTION_DATA_BYTES) {
-        // Not fatal — the size budget assertion downstream is authoritative — but a
-        // change here means the size arithmetic in computeBudget.ts is stale.
-        console.warn(`[veilo] transact instruction data is ${data.length} bytes, expected ` +
-            `${computeBudget_js_1.TRANSACT_INSTRUCTION_DATA_BYTES}. The shield size budget may no longer hold.`);
-    }
-    return new web3_js_1.TransactionInstruction({ programId, keys, data });
-}
-/** Anchor's Borsh coder wants camelCase field names, BNs, and plain arrays. */
-function toBorshArgs(args) {
-    return {
-        root: Array.from(args.root),
-        input_tree_id: args.inputTreeId,
-        output_tree_id: args.outputTreeId,
-        public_amount: new BN(args.publicAmount.toString()),
-        ext_data_hash: Array.from(args.extDataHash),
-        mint_address: args.mintAddress,
-        input_nullifier_0: Array.from(args.inputNullifiers[0]),
-        input_nullifier_1: Array.from(args.inputNullifiers[1]),
-        output_commitment_0: Array.from(args.outputCommitments[0]),
-        output_commitment_1: Array.from(args.outputCommitments[1]),
-        deadline: new BN(args.deadline.toString()),
-        ext_data: {
-            recipient: args.extData.recipient,
-            relayer: args.extData.relayer,
-            fee: new BN(args.extData.fee.toString()),
-            refund: new BN(args.extData.refund.toString()),
-            claimant: args.extData.claimant,
-        },
-        proof: {
-            proof_a: args.proof.proofA,
-            proof_b: args.proof.proofB,
-            proof_c: args.proof.proofC,
-        },
-        note_ciphers: args.noteCiphers
-            ? {
-                note0_ephemeral_key: Array.from(args.noteCiphers.note0EphemeralKey),
-                note0_encrypted: Array.from(args.noteCiphers.note0Encrypted),
-                note0_view_tag: args.noteCiphers.note0ViewTag,
-                note1_ephemeral_key: Array.from(args.noteCiphers.note1EphemeralKey),
-                note1_encrypted: Array.from(args.noteCiphers.note1Encrypted),
-                note1_view_tag: args.noteCiphers.note1ViewTag,
-            }
-            : null,
-    };
-}

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

@@ -1,36 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { ShieldOwner } from "./types.js";
-/**
- * Resolve a shield recipient into the pair of keys that must belong to the same
- * account.
- *
- * This is the only mechanism that makes the owner invariant safe. A note's
- * *spend* authority is a Poseidon field element and its *detection* authority is
- * an Ed25519 wallet key; nothing on-chain relates them, and if an integrator
- * sources them separately and gets them wrong, the note is spendable but
- * permanently invisible — the funds are gone from the owner's view with no error
- * raised anywhere in the stack.
- *
- * `GET /auth/veiloPublicKey` returns both halves in a single response, so
- * routing through this function makes the pairing structural rather than a
- * convention integrators are asked to remember.
- *
- * Prefer this over hand-building a {@link ShieldOwner} in all cases.
- */
-export declare function resolveShieldOwner(target: {
-    username: string;
-} | {
-    publicKey: string | PublicKey;
-}): Promise<ShieldOwner>;
-/**
- * Build a {@link ShieldOwner} from keys the caller already holds.
- *
- * Only correct when both keys provably belong to the same account. The explicit
- * flag is not ceremony — it is the last checkpoint before a class of bug whose
- * only symptom is a user's money quietly disappearing from their balance.
- */
-export declare function unsafeShieldOwner(params: {
-    veiloPublicKey: bigint;
-    noteViewingKey: PublicKey;
-    acknowledgeOwnerInvariant: true;
-}): ShieldOwner;

package/dist/src/shield/owner.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveShieldOwner = resolveShieldOwner;
-exports.unsafeShieldOwner = unsafeShieldOwner;
-const web3_js_1 = require("@solana/web3.js");
-const relayer_js_1 = require("../relayer.js");
-const errors_js_1 = require("./errors.js");
-/**
- * Owner resolution is a Veilo protocol service, not an integrator-selected
- * transport. Keep the production endpoint and public encryption key inside the
- * SDK so callers cannot accidentally resolve the two owner keys from different
- * relayers.
- *
- * These values are public network coordinates, not credentials. In particular,
- * never put a secret API key here: browser/mobile package contents are always
- * inspectable. The two owner endpoints used below are intentionally public and
- * return public key material only.
- */
-const OWNER_RELAYER = new relayer_js_1.VeiloRelayerClient({
-    apiKey: "",
-    relayerPublicKey: "utVxnA7zax09qJCZ7UJsa8PAOoWLRcCwOkdxg/ZGmD4=",
-});
-/**
- * Resolve a shield recipient into the pair of keys that must belong to the same
- * account.
- *
- * This is the only mechanism that makes the owner invariant safe. A note's
- * *spend* authority is a Poseidon field element and its *detection* authority is
- * an Ed25519 wallet key; nothing on-chain relates them, and if an integrator
- * sources them separately and gets them wrong, the note is spendable but
- * permanently invisible — the funds are gone from the owner's view with no error
- * raised anywhere in the stack.
- *
- * `GET /auth/veiloPublicKey` returns both halves in a single response, so
- * routing through this function makes the pairing structural rather than a
- * convention integrators are asked to remember.
- *
- * Prefer this over hand-building a {@link ShieldOwner} in all cases.
- */
-async function resolveShieldOwner(target) {
-    const query = "username" in target
-        ? { username: target.username }
-        : {
-            publicKey: typeof target.publicKey === "string"
-                ? target.publicKey
-                : target.publicKey.toBase58(),
-        };
-    let response;
-    try {
-        response = await OWNER_RELAYER.getVeiloPublicKey(query);
-    }
-    catch (e) {
-        // A raw Solana address may not have a Veilo account yet. Provisioning is
-        // public and idempotent, and returns only the Poseidon spend key; the
-        // address we were given is the matching note-viewing key.
-        if ("publicKey" in target &&
-            (e?.status === 404 || (e instanceof relayer_js_1.VeiloApiError && e.status === 404))) {
-            const wallet = typeof target.publicKey === "string"
-                ? new web3_js_1.PublicKey(target.publicKey)
-                : target.publicKey;
-            const provisioned = await OWNER_RELAYER.preRegisterKey(wallet.toBase58());
-            if (!provisioned?.veiloPublicKey) {
-                throw new errors_js_1.ShieldError("UNKNOWN", "The relayer pre-registered the recipient but returned no Veilo public key.", { context: { publicKey: wallet.toBase58(), response: provisioned }, cause: e });
-            }
-            return {
-                veiloPublicKey: BigInt(provisioned.veiloPublicKey),
-                noteViewingKey: wallet,
-                acknowledgeOwnerInvariant: true,
-            };
-        }
-        // A pre-registered account is one someone else created on the recipient's
-        // behalf; the recipient has never proved ownership, so the relayer refuses
-        // to resolve it by username. Shielding to them still works, but the caller
-        // must address them by Solana address instead.
-        if (e?.body?.preRegistered ||
-            e?.details?.preRegistered ||
-            /preregistered/i.test(String(e?.message ?? ""))) {
-            throw new errors_js_1.ShieldError("UNKNOWN", `"${"username" in target ? target.username : "that account"}" is pre-registered ` +
-                `and cannot be resolved by username. Resolve it by Solana address instead — ` +
-                `resolveShieldOwner({ publicKey }).`, { context: { preRegistered: true }, cause: e });
-        }
-        throw e;
-    }
-    const veiloPublicKeyRaw = response?.veiloPublicKey;
-    const walletRaw = response?.pubK;
-    if (!veiloPublicKeyRaw || !walletRaw) {
-        throw new errors_js_1.ShieldError("UNKNOWN", `The relayer did not return both keys for this recipient ` +
-            `(veiloPublicKey=${!!veiloPublicKeyRaw}, pubK=${!!walletRaw}). ` +
-            `Shielding without both would create a note the owner cannot find.`, { context: { response } });
-    }
-    const noteViewingKey = new web3_js_1.PublicKey(walletRaw);
-    if ("publicKey" in target &&
-        !noteViewingKey.equals(typeof target.publicKey === "string"
-            ? new web3_js_1.PublicKey(target.publicKey)
-            : target.publicKey)) {
-        throw new errors_js_1.ShieldError("UNKNOWN", "The Veilo owner service returned a different wallet than the one requested. " +
-            "Shielding was stopped to prevent creating a note for the wrong recipient.", {
-            context: {
-                requested: typeof target.publicKey === "string"
-                    ? target.publicKey
-                    : target.publicKey.toBase58(),
-                returned: noteViewingKey.toBase58(),
-            },
-        });
-    }
-    return {
-        veiloPublicKey: BigInt(veiloPublicKeyRaw),
-        noteViewingKey,
-        // Safe to assert: both halves came from one response about one account.
-        acknowledgeOwnerInvariant: true,
-    };
-}
-/**
- * Build a {@link ShieldOwner} from keys the caller already holds.
- *
- * Only correct when both keys provably belong to the same account. The explicit
- * flag is not ceremony — it is the last checkpoint before a class of bug whose
- * only symptom is a user's money quietly disappearing from their balance.
- */
-function unsafeShieldOwner(params) {
-    return {
-        veiloPublicKey: params.veiloPublicKey,
-        noteViewingKey: params.noteViewingKey,
-        acknowledgeOwnerInvariant: true,
-    };
-}

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

@@ -1,43 +0,0 @@
-import { Connection, PublicKey } from "@solana/web3.js";
-import type { DepositTarget, ShieldCachePort, TreeSource } from "./types.js";
-/**
- * Injection points for the shield path.
- *
- * The three production deposit implementations (extension, wallet-app,
- * veilo-dapp) are ~85% identical and diverge on exactly these axes: where
- * proofs come from, where the tree comes from, which lookup table to use, and
- * what to cache into. Making each an explicit port is what lets one
- * implementation serve all of them — and lets a third-party integrator supply
- * their own without forking anything.
- *
- * Proof generation is deliberately NOT redefined here: `TransactionProofBuilder`
- * from `proof.ts` already has the right shape, and a second prover abstraction
- * would be exactly the kind of duplication this module exists to avoid.
- */
-/**
- * Read the target tree and root directly from chain.
- *
- * Note the account decoding: `MerkleTreeAccount::EXPECTED_SIZE` (9107) does not
- * match the size its declared fields sum to (8987), a 120-byte discrepancy that
- * is unexplained. Until it is, hand-slicing this account at fixed byte offsets
- * is unsafe. Anchor's coder reads declared fields from the front and ignores the
- * tail, so `.fetch()` stays correct regardless.
- */
-export declare function onChainTreeSource(connection: Connection, programId?: PublicKey): TreeSource;
-/**
- * Fixed values, for tests and offline builds.
- *
- * Also the escape hatch for an integrator who already tracks the tree state and
- * does not want the SDK making RPC calls on their behalf.
- */
-export declare function staticTreeSource(target: DepositTarget): TreeSource;
-/**
- * In-memory cache with TTL. The default.
- *
- * Persistent storage is deliberately the caller's problem — `localStorage`,
- * `chrome.storage`, and `AsyncStorage` are three different answers in three
- * different apps, and none of them belongs in a published SDK.
- */
-export declare function memoryCache(): ShieldCachePort;
-/** A cache that never stores anything. Useful for tests that assert fetch counts. */
-export declare function noCache(): ShieldCachePort;

package/dist/src/shield/ports.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onChainTreeSource = onChainTreeSource;
-exports.staticTreeSource = staticTreeSource;
-exports.memoryCache = memoryCache;
-exports.noCache = noCache;
-const program_js_1 = require("../program.js");
-const client_js_1 = require("../client.js");
-const config_js_1 = require("../config.js");
-const errors_js_1 = require("./errors.js");
-/**
- * Injection points for the shield path.
- *
- * The three production deposit implementations (extension, wallet-app,
- * veilo-dapp) are ~85% identical and diverge on exactly these axes: where
- * proofs come from, where the tree comes from, which lookup table to use, and
- * what to cache into. Making each an explicit port is what lets one
- * implementation serve all of them — and lets a third-party integrator supply
- * their own without forking anything.
- *
- * Proof generation is deliberately NOT redefined here: `TransactionProofBuilder`
- * from `proof.ts` already has the right shape, and a second prover abstraction
- * would be exactly the kind of duplication this module exists to avoid.
- */
-// -- TreeSource ---------------------------------------------------------------
-/**
- * Read the target tree and root directly from chain.
- *
- * Note the account decoding: `MerkleTreeAccount::EXPECTED_SIZE` (9107) does not
- * match the size its declared fields sum to (8987), a 120-byte discrepancy that
- * is unexplained. Until it is, hand-slicing this account at fixed byte offsets
- * is unsafe. Anchor's coder reads declared fields from the front and ignores the
- * tail, so `.fetch()` stays correct regardless.
- */
-function onChainTreeSource(connection, programId = program_js_1.PRIVACY_POOL_PROGRAM_ID) {
-    return {
-        async getDepositTarget(mint) {
-            const program = (0, program_js_1.createReadonlyVeiloProgram)(connection);
-            const { config } = (0, client_js_1.getPoolPdas)(programId, mint);
-            const cfg = await program.account.privacyConfig.fetch(config);
-            const numTrees = Number(cfg.numTrees);
-            if (!Number.isInteger(numTrees) || numTrees <= 0) {
-                throw new errors_js_1.ShieldError("TREE_FULL", `Pool ${mint.toBase58()} has no deposit tree.`, { context: { mint: mint.toBase58(), numTrees } });
-            }
-            // Fetch every tree in one RPC call. The older getBestTreeForDeposit path
-            // fetched them serially, then fetched the chosen trees a second time.
-            const treePdas = Array.from({ length: numTrees }, (_, treeId) => (0, client_js_1.getNoteTreePda)(programId, mint, treeId));
-            const infos = await connection.getMultipleAccountsInfo(treePdas, {
-                commitment: "confirmed",
-            });
-            const capacity = 2 ** config_js_1.MERKLE_TREE_DEPTH;
-            const trees = infos.map((info, treeId) => {
-                if (!info)
-                    return null;
-                // Anchor camel-cases the IDL's `MerkleTreeAccount` name when it builds
-                // the Borsh account-layout map (the same key exposed as
-                // `program.account.merkleTreeAccount`).
-                const decoded = program.coder.accounts.decode("merkleTreeAccount", info.data);
-                const nextIndex = Number(decoded.nextIndex);
-                return {
-                    treeId,
-                    decoded,
-                    nextIndex,
-                    remainingCapacity: capacity - nextIndex,
-                };
-            });
-            const inputTree = trees[0];
-            if (!inputTree) {
-                throw new errors_js_1.ShieldError("POOL_NOT_FOUND", `Pool ${mint.toBase58()} is missing its input Merkle tree (tree 0).`, { context: { mint: mint.toBase58(), tree: treePdas[0].toBase58() } });
-            }
-            const available = trees.filter((tree) => !!tree && tree.nextIndex < capacity);
-            if (available.length === 0) {
-                throw new errors_js_1.ShieldError("TREE_FULL", `All ${numTrees} Merkle trees for ${mint.toBase58()} are full.`, { context: { mint: mint.toBase58(), numTrees, capacity } });
-            }
-            const minCapacity = Math.floor(capacity * 0.0001);
-            const preferred = available
-                .filter((tree) => tree.remainingCapacity >= minCapacity)
-                .sort((a, b) => a.treeId - b.treeId);
-            const outputTree = preferred[0] ??
-                available.sort((a, b) => b.remainingCapacity - a.remainingCapacity)[0];
-            return {
-                inputTreeId: 0,
-                inputRoot: extractRoot(inputTree.decoded),
-                outputTreeId: outputTree.treeId,
-                outputNextIndex: outputTree.nextIndex,
-            };
-        },
-    };
-}
-/**
- * Fixed values, for tests and offline builds.
- *
- * Also the escape hatch for an integrator who already tracks the tree state and
- * does not want the SDK making RPC calls on their behalf.
- */
-function staticTreeSource(target) {
-    return { async getDepositTarget() { return target; } };
-}
-/**
- * Read the root from a decoded `MerkleTreeAccount`.
- *
- * Uses `root_history[root_index]` rather than the `root` field. Both are written
- * to the same value by `append` (merkle_tree.rs:108-111) so they agree, but the
- * history read is what all three production implementations use and is therefore
- * the one that is actually exercised against mainnet.
- */
-function extractRoot(tree) {
-    const history = tree.rootHistory ?? tree.root_history;
-    const index = Number(tree.rootIndex ?? tree.root_index ?? 0);
-    if (Array.isArray(history) && history[index]) {
-        return new Uint8Array(history[index]);
-    }
-    const root = tree.root;
-    if (root)
-        return new Uint8Array(root);
-    throw new Error("could not read a Merkle root from the tree account");
-}
-// -- Cache --------------------------------------------------------------------
-/**
- * In-memory cache with TTL. The default.
- *
- * Persistent storage is deliberately the caller's problem — `localStorage`,
- * `chrome.storage`, and `AsyncStorage` are three different answers in three
- * different apps, and none of them belongs in a published SDK.
- */
-function memoryCache() {
-    const store = new Map();
-    return {
-        async get(key) {
-            const hit = store.get(key);
-            if (!hit)
-                return undefined;
-            if (hit.expiresAt !== 0 && hit.expiresAt < Date.now()) {
-                store.delete(key);
-                return undefined;
-            }
-            return hit.value;
-        },
-        async set(key, value, ttlMs) {
-            store.set(key, {
-                value,
-                expiresAt: ttlMs && ttlMs > 0 ? Date.now() + ttlMs : 0,
-            });
-        },
-    };
-}
-/** A cache that never stores anything. Useful for tests that assert fetch counts. */
-function noCache() {
-    return {
-        async get() { return undefined; },
-        async set() { },
-    };
-}

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

@@ -1,30 +0,0 @@
-import { Connection, PublicKey } from "@solana/web3.js";
-import type { PreflightOptions, ShieldCachePort } from "./types.js";
-/**
- * Checks that run before the prover.
- *
- * Proving costs 10–30 seconds. Every check here is a single RPC call, and each
- * one pre-empts an on-chain failure whose message tells the user nothing they
- * can act on. The delegate check is the clearest example: the program requires
- * `user_token.delegate.is_none()`, so anyone who ever approved a DEX has a
- * permanently broken deposit path that reports only "Invalid token account
- * authority" — with no hint that revoking a delegate would fix it.
- *
- * These are advisory in the sense that the chain enforces them anyway. They are
- * not advisory in the sense that skipping them produces a materially worse
- * product.
- */
-export declare function preflightShield(params: {
-    connection: Connection;
-    amount: bigint;
-    mint: PublicKey;
-    signer: {
-        publicKey: PublicKey;
-        tokenAccount: PublicKey;
-    };
-    programId?: PublicKey;
-    options?: PreflightOptions;
-    cache?: ShieldCachePort;
-    computeUnitLimit?: number;
-    computeUnitPriceMicroLamports?: number;
-}): Promise<void>;

package/dist/src/shield/preflight.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preflightShield = preflightShield;
-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");
-const computeBudget_js_1 = require("./computeBudget.js");
-/**
- * Checks that run before the prover.
- *
- * Proving costs 10–30 seconds. Every check here is a single RPC call, and each
- * one pre-empts an on-chain failure whose message tells the user nothing they
- * can act on. The delegate check is the clearest example: the program requires
- * `user_token.delegate.is_none()`, so anyone who ever approved a DEX has a
- * permanently broken deposit path that reports only "Invalid token account
- * authority" — with no hint that revoking a delegate would fix it.
- *
- * These are advisory in the sense that the chain enforces them anyway. They are
- * not advisory in the sense that skipping them produces a materially worse
- * product.
- */
-async function preflightShield(params) {
-    const { connection, amount, mint, signer, programId = program_js_1.PRIVACY_POOL_PROGRAM_ID, options = {}, } = params;
-    const isToken = !mint.equals(config_js_1.NATIVE_SOL_MINT);
-    // --- Pool state ------------------------------------------------------------
-    if (!options.skipPoolState) {
-        const program = (0, program_js_1.createReadonlyVeiloProgram)(connection);
-        const { config } = (0, client_js_1.getPoolPdas)(programId, mint);
-        let cfg;
-        try {
-            cfg = await program.account.privacyConfig.fetch(config);
-        }
-        catch (e) {
-            throw new errors_js_1.ShieldError("POOL_NOT_FOUND", `No privacy pool exists for mint ${mint.toBase58()}.`, { context: { mint: mint.toBase58(), config: config.toBase58() }, cause: e });
-        }
-        if (cfg.paused) {
-            throw new errors_js_1.ShieldError("POOL_PAUSED", "The pool is paused. Try again later.");
-        }
-        const min = BigInt(cfg.minDepositAmount?.toString() ?? "0");
-        const max = BigInt(cfg.maxDepositAmount?.toString() ?? "0");
-        if (min > 0n && amount < min) {
-            throw new errors_js_1.ShieldError("AMOUNT_BELOW_MINIMUM", `Amount ${amount} is below the pool minimum of ${min}.`, { context: { amount: amount.toString(), minimum: min.toString() } });
-        }
-        if (max > 0n && amount > max) {
-            throw new errors_js_1.ShieldError("AMOUNT_ABOVE_MAXIMUM", `Amount ${amount} exceeds the pool maximum of ${max}.`, { context: { amount: amount.toString(), maximum: max.toString() } });
-        }
-    }
-    // --- Source token account (SPL only) --------------------------------------
-    if (isToken && !options.skipTokenAccount) {
-        let account;
-        try {
-            account = await (0, spl_token_1.getAccount)(connection, signer.tokenAccount);
-        }
-        catch (e) {
-            if (e instanceof spl_token_1.TokenAccountNotFoundError || /could not find/i.test(String(e))) {
-                // Deliberately no "create the ATA" remedy: an ATA that does not exist
-                // holds zero tokens, so creating it would only move the failure to
-                // INSUFFICIENT_TOKEN_BALANCE. Say the true thing instead.
-                throw new errors_js_1.ShieldError("TOKEN_ACCOUNT_MISSING", `The signer has no token account for ${mint.toBase58()}, so there is nothing to shield.`, { context: { tokenAccount: signer.tokenAccount.toBase58() }, cause: e });
-            }
-            throw e;
-        }
-        if (!account.mint.equals(mint)) {
-            throw new errors_js_1.ShieldError("TOKEN_ACCOUNT_WRONG_MINT", `Token account ${signer.tokenAccount.toBase58()} holds ${account.mint.toBase58()}, not ${mint.toBase58()}.`, { context: { expected: mint.toBase58(), actual: account.mint.toBase58() } });
-        }
-        if (!account.owner.equals(signer.publicKey)) {
-            throw new errors_js_1.ShieldError("TOKEN_ACCOUNT_WRONG_OWNER", `Token account ${signer.tokenAccount.toBase58()} is owned by ${account.owner.toBase58()}, ` +
-                `not by the signing wallet. The program requires the signer to own the source account outright.`, {
-                context: {
-                    tokenAccount: signer.tokenAccount.toBase58(),
-                    owner: account.owner.toBase58(),
-                    signer: signer.publicKey.toBase58(),
-                },
-            });
-        }
-        if (account.isFrozen) {
-            throw new errors_js_1.ShieldError("TOKEN_ACCOUNT_FROZEN", `Token account ${signer.tokenAccount.toBase58()} is frozen.`, { context: { tokenAccount: signer.tokenAccount.toBase58() } });
-        }
-        // The program checks `delegate.is_none()`, NOT the delegated amount — so a
-        // stale delegate with zero allowance still fails. This is the single most
-        // common avoidable failure on this path, and it is entirely fixable.
-        if (account.delegate) {
-            throw new errors_js_1.ShieldError("TOKEN_ACCOUNT_DELEGATED", `Token account ${signer.tokenAccount.toBase58()} has an active delegate ` +
-                `(${account.delegate.toBase58()}). The pool rejects deposits from delegated ` +
-                `accounts even when the delegated amount is zero. Revoke the delegate, then shield.`, {
-                context: {
-                    tokenAccount: signer.tokenAccount.toBase58(),
-                    delegate: account.delegate.toBase58(),
-                    delegatedAmount: account.delegatedAmount.toString(),
-                },
-                remedy: {
-                    description: `Revoke the delegate on ${signer.tokenAccount.toBase58()}`,
-                    instructions: [
-                        (0, spl_token_1.createRevokeInstruction)(signer.tokenAccount, signer.publicKey),
-                    ],
-                },
-            });
-        }
-        if (account.amount < amount) {
-            throw new errors_js_1.ShieldError("INSUFFICIENT_TOKEN_BALANCE", `Token account holds ${account.amount} but ${amount} is required.`, { context: { balance: account.amount.toString(), required: amount.toString() } });
-        }
-        // The vault's ATA must already exist — the program requires the canonical
-        // one and will not create it.
-        const { vault } = (0, client_js_1.getPoolPdas)(programId, mint);
-        const vaultAta = await (0, spl_token_1.getAssociatedTokenAddress)(mint, vault, true);
-        const vaultInfo = await connection.getAccountInfo(vaultAta);
-        if (!vaultInfo) {
-            throw new errors_js_1.ShieldError("VAULT_ATA_MISSING", `The pool vault has no associated token account for ${mint.toBase58()}. ` +
-                `This is a pool provisioning issue, not something the signer can fix.`, { context: { vault: vault.toBase58(), vaultAta: vaultAta.toBase58() } });
-        }
-    }
-    // --- Signer balance --------------------------------------------------------
-    if (!options.skipBalance) {
-        const rentPer = await cachedRent(connection, params.cache);
-        const rent = BigInt(rentPer) * BigInt(computeBudget_js_1.NULLIFIER_MARKERS_PER_TRANSACT);
-        const computeUnitLimit = params.computeUnitLimit ?? computeBudget_js_1.SHIELD_COMPUTE_UNIT_LIMIT;
-        const computeUnitPriceMicroLamports = params.computeUnitPriceMicroLamports ?? computeBudget_js_1.SHIELD_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS;
-        const priorityFee = (BigInt(computeUnitLimit) * BigInt(computeUnitPriceMicroLamports)) /
-            1000000n;
-        const baseFee = 5000n;
-        // The signer pays the marker rent regardless of the mint — it is SOL either
-        // way, and it is burned, not refunded.
-        const required = rent + priorityFee + baseFee + (isToken ? 0n : amount);
-        const balance = BigInt(await connection.getBalance(signer.publicKey));
-        if (balance < required) {
-            throw new errors_js_1.ShieldError("INSUFFICIENT_SOL", `The signing wallet has ${balance} lamports but needs ${required} ` +
-                `(${isToken ? "" : `${amount} shielded + `}${rent} nullifier-marker rent + ` +
-                `${priorityFee + baseFee} fees). Note that the marker rent is burned, not refunded, ` +
-                `and the program forces it onto the signer — it cannot be sponsored.`, {
-                context: {
-                    balance: balance.toString(),
-                    required: required.toString(),
-                    breakdown: {
-                        amount: isToken ? "0" : amount.toString(),
-                        nullifierMarkerRent: rent.toString(),
-                        priorityFee: priorityFee.toString(),
-                        baseFee: baseFee.toString(),
-                    },
-                },
-            });
-        }
-    }
-}
-async function cachedRent(connection, cache) {
-    const key = `rent:${computeBudget_js_1.NULLIFIER_MARKER_ACCOUNT_BYTES}`;
-    const hit = await cache?.get(key);
-    if (hit !== undefined)
-        return hit;
-    const value = await connection.getMinimumBalanceForRentExemption(computeBudget_js_1.NULLIFIER_MARKER_ACCOUNT_BYTES);
-    await cache?.set(key, value, 60 * 60000);
-    return value;
-}