@veilo/sdk-core 0.4.0 → 0.5.0

package/dist/cjs/relayer.js

@@ -1,257 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 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;
+// Backward-compatible entry point. Relayer responsibilities live in src/relayer.
+__exportStar(require("./relayer/index.js"), exports);

package/dist/cjs/shield/alt.js

@@ -8,7 +8,7 @@ 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 pdas_js_1 = require("../accounts/pdas.js");
 const program_js_1 = require("../program.js");
 const config_js_1 = require("../config.js");
 const errors_js_1 = require("./errors.js");
@@ -107,21 +107,21 @@ function explicitAlt(account) {
  */
 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 { config, vault, nullifiers } = (0, pdas_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: "globalConfig", address: (0, pdas_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) },
+        { label: "inputTree(0)", address: (0, pdas_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),
+            address: (0, pdas_js_1.getNoteTreePda)(programId, params.mint, params.outputTreeId),
         });
     }
     if (!params.mint.equals(config_js_1.NATIVE_SOL_MINT)) {
@@ -155,16 +155,16 @@ async function expectedDepositAltKeys(params) {
         { 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) },
+        { label: "globalConfig", address: (0, pdas_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);
+        const { config, vault, nullifiers } = (0, pdas_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),
+                address: (0, pdas_js_1.getNoteTreePda)(programId, mint, t),
             });
         }
         if (!mint.equals(config_js_1.NATIVE_SOL_MINT)) {

package/dist/cjs/shield/errors.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShieldError = void 0;
 exports.extractProgramCode = extractProgramCode;
 exports.mapShieldError = mapShieldError;
-const client_js_1 = require("../client.js");
+const errors_js_1 = require("../accounts/errors.js");
 class ShieldError extends Error {
     constructor(code, message, opts = {}) {
         super(message);
@@ -52,7 +52,7 @@ function mapShieldError(error) {
     const err = error;
     const raw = (err?.message ?? String(err ?? "")).toLowerCase();
     const programCode = extractProgramCode(err);
-    const readable = (0, client_js_1.parseOnChainError)(err);
+    const readable = (0, errors_js_1.parseOnChainError)(err);
     if (programCode !== null) {
         switch (programCode) {
             case 6000:

package/dist/cjs/shield/finalize.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.finalizeShield = finalizeShield;
 const anchor = __importStar(require("@coral-xyz/anchor"));
 const program_js_1 = require("../program.js");
-const utxo_js_1 = require("../utxo.js");
+const mailbox_js_1 = require("../notes/mailbox.js");
 const poseidon_js_1 = require("../poseidon.js");
 const errors_js_1 = require("./errors.js");
 /**
@@ -101,7 +101,7 @@ async function finalizeShield(params) {
     // sender→recipient association into the relayer's database AND removing the
     // note from the chain-recovery feed. For shield-to-someone-else, chain-only
     // discovery is usually the better default — see the plan's Phase 3 note.
-    const blob = (0, utxo_js_1.encryptBlindMailboxNote)(owner.noteViewingKey.toBytes(), {
+    const blob = (0, mailbox_js_1.encryptBlindMailboxNote)(owner.noteViewingKey.toBytes(), {
         blinding: (0, poseidon_js_1.bigIntToBytesBE)(note.blinding),
         leafIndex,
         commitment: note.commitment,

package/dist/cjs/shield/ix.d.ts

@@ -1,5 +1,5 @@
 import { PublicKey, TransactionInstruction } from "@solana/web3.js";
-import type { TransactionProofStruct } from "../proof.js";
+import type { TransactionProofStruct } from "../proofs/types.js";
 /**
  * `transact` instruction assembly, driven by the IDL rather than by a
  * hand-written account list.

package/dist/cjs/shield/owner.js

@@ -3,8 +3,9 @@ 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");
+const client_js_1 = require("../relayer/client.js");
+const errors_js_1 = require("../relayer/errors.js");
+const errors_js_2 = 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
@@ -16,7 +17,7 @@ const errors_js_1 = require("./errors.js");
  * inspectable. The two owner endpoints used below are intentionally public and
  * return public key material only.
  */
-const OWNER_RELAYER = new relayer_js_1.VeiloRelayerClient({
+const OWNER_RELAYER = new client_js_1.VeiloRelayerClient({
     apiKey: "",
     relayerPublicKey: "utVxnA7zax09qJCZ7UJsa8PAOoWLRcCwOkdxg/ZGmD4=",
 });
@@ -54,13 +55,13 @@ async function resolveShieldOwner(target) {
         // 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))) {
+            (e?.status === 404 || (e instanceof errors_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 });
+                throw new errors_js_2.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),
@@ -75,7 +76,7 @@ async function resolveShieldOwner(target) {
         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 ` +
+            throw new errors_js_2.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 });
         }
@@ -84,7 +85,7 @@ async function resolveShieldOwner(target) {
     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 ` +
+        throw new errors_js_2.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 } });
     }
@@ -93,7 +94,7 @@ async function resolveShieldOwner(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. " +
+        throw new errors_js_2.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"

package/dist/cjs/shield/ports.js

@@ -5,7 +5,7 @@ exports.staticTreeSource = staticTreeSource;
 exports.memoryCache = memoryCache;
 exports.noCache = noCache;
 const program_js_1 = require("../program.js");
-const client_js_1 = require("../client.js");
+const pdas_js_1 = require("../accounts/pdas.js");
 const config_js_1 = require("../config.js");
 const errors_js_1 = require("./errors.js");
 /**
@@ -36,7 +36,7 @@ function onChainTreeSource(connection, programId = program_js_1.PRIVACY_POOL_PRO
     return {
         async getDepositTarget(mint) {
             const program = (0, program_js_1.createReadonlyVeiloProgram)(connection);
-            const { config } = (0, client_js_1.getPoolPdas)(programId, mint);
+            const { config } = (0, pdas_js_1.getPoolPdas)(programId, mint);
             const cfg = await program.account.privacyConfig.fetch(config);
             const numTrees = Number(cfg.numTrees);
             if (!Number.isInteger(numTrees) || numTrees <= 0) {
@@ -44,7 +44,7 @@ function onChainTreeSource(connection, programId = program_js_1.PRIVACY_POOL_PRO
             }
             // 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 treePdas = Array.from({ length: numTrees }, (_, treeId) => (0, pdas_js_1.getNoteTreePda)(programId, mint, treeId));
             const infos = await connection.getMultipleAccountsInfo(treePdas, {
                 commitment: "confirmed",
             });

package/dist/cjs/shield/preflight.js

@@ -2,7 +2,7 @@
 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 pdas_js_1 = require("../accounts/pdas.js");
 const program_js_1 = require("../program.js");
 const config_js_1 = require("../config.js");
 const errors_js_1 = require("./errors.js");
@@ -27,7 +27,7 @@ async function preflightShield(params) {
     // --- Pool state ------------------------------------------------------------
     if (!options.skipPoolState) {
         const program = (0, program_js_1.createReadonlyVeiloProgram)(connection);
-        const { config } = (0, client_js_1.getPoolPdas)(programId, mint);
+        const { config } = (0, pdas_js_1.getPoolPdas)(programId, mint);
         let cfg;
         try {
             cfg = await program.account.privacyConfig.fetch(config);
@@ -103,7 +103,7 @@ async function preflightShield(params) {
         }
         // 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 { vault } = (0, pdas_js_1.getPoolPdas)(programId, mint);
         const vaultAta = await (0, spl_token_1.getAssociatedTokenAddress)(mint, vault, true);
         const vaultInfo = await connection.getAccountInfo(vaultAta);
         if (!vaultInfo) {

package/dist/cjs/shield/shield.js

@@ -8,14 +8,15 @@ exports.deserializeProofCache = deserializeProofCache;
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const program_js_1 = require("../program.js");
-const client_js_1 = require("../client.js");
+const pdas_js_1 = require("../accounts/pdas.js");
 const config_js_1 = require("../config.js");
 const poseidon_js_1 = require("../poseidon.js");
 Object.defineProperty(exports, "bytesToBigIntBE", { enumerable: true, get: function () { return poseidon_js_1.bytesToBigIntBE; } });
 Object.defineProperty(exports, "BN254_FR_MODULUS", { enumerable: true, get: function () { return poseidon_js_1.BN254_FR_MODULUS; } });
 const merkle_js_1 = require("../merkle.js");
-const utxo_js_1 = require("../utxo.js");
-const proof_js_1 = require("../proof.js");
+const model_js_1 = require("../notes/model.js");
+const transaction_js_1 = require("../proofs/transaction.js");
+const encoding_js_1 = require("../proofs/encoding.js");
 const compactNote_js_1 = require("../compactNote.js");
 const ix_js_1 = require("./ix.js");
 const alt_js_1 = require("./alt.js");
@@ -114,14 +115,14 @@ async function shield(params) {
     // --- 3. Outputs ------------------------------------------------------------
     // Output 0 carries the value and is owned by the recipient. Output 1 is a
     // zero-value dummy the 2-in-2-out circuit requires.
-    const outputNote = (0, utxo_js_1.createUTXO)({
+    const outputNote = (0, model_js_1.createUTXO)({
         amount,
         pubkey: owner.veiloPublicKey,
         mintAddress: mint,
     });
-    const dummyOutput = (0, utxo_js_1.createUTXO)({
+    const dummyOutput = (0, model_js_1.createUTXO)({
         amount: 0n,
-        pubkey: (0, utxo_js_1.generateKeypair)().publicKey,
+        pubkey: (0, model_js_1.generateKeypair)().publicKey,
         mintAddress: mint,
     });
     // --- 4. Dummy inputs -------------------------------------------------------
@@ -130,8 +131,8 @@ async function shield(params) {
     // blinding randomness; two keys make it structural.
     const zeroChain = (0, merkle_js_1.poseidonZeroChain)(22).slice(0, 22);
     const dummyInputs = [
-        toDummyInput((0, utxo_js_1.createOwnedZeroUTXO)((0, utxo_js_1.generateKeypair)().privateKey, mint), zeroChain),
-        toDummyInput((0, utxo_js_1.createOwnedZeroUTXO)((0, utxo_js_1.generateKeypair)().privateKey, mint), zeroChain),
+        toDummyInput((0, model_js_1.createOwnedZeroUTXO)((0, model_js_1.generateKeypair)().privateKey, mint), zeroChain),
+        toDummyInput((0, model_js_1.createOwnedZeroUTXO)((0, model_js_1.generateKeypair)().privateKey, mint), zeroChain),
     ];
     // --- 5. ExtData ------------------------------------------------------------
     // For a deposit these slots carry no payment semantics — no fee is taken and
@@ -144,9 +145,9 @@ async function shield(params) {
         refund: 0n,
         claimant: web3_js_1.SystemProgram.programId,
     };
-    const extDataHash = (0, proof_js_1.computeExtDataHash)(extData);
+    const extDataHash = (0, transaction_js_1.computeExtDataHash)(extData);
     // --- 6. Prove --------------------------------------------------------------
-    const circuitInputs = (0, proof_js_1.prepareTransactionInputs)({
+    const circuitInputs = (0, transaction_js_1.prepareTransactionInputs)({
         inputUTXOs: dummyInputs,
         outputUTXOs: [outputNote, dummyOutput],
         root: target.inputRoot,
@@ -156,7 +157,7 @@ async function shield(params) {
     });
     let proof;
     try {
-        proof = (0, proof_js_1.encodeSnarkjsProofToTransactionProof)(await prover(circuitInputs));
+        proof = (0, encoding_js_1.encodeSnarkjsProofToTransactionProof)(await prover(circuitInputs));
     }
     catch (e) {
         throw (0, errors_js_1.mapShieldError)(e);
@@ -176,8 +177,8 @@ async function shield(params) {
         outputTreeId: target.outputTreeId,
         inputNullifiers: circuitInputs.inputNullifiers,
         vaultTokenAccount: isToken
-            ? await (0, spl_token_1.getAssociatedTokenAddress)(mint, (0, client_js_1.getPoolPdas)(programId, mint).vault, true)
-            : (0, client_js_1.getPoolPdas)(programId, mint).vault,
+            ? await (0, spl_token_1.getAssociatedTokenAddress)(mint, (0, pdas_js_1.getPoolPdas)(programId, mint).vault, true)
+            : (0, pdas_js_1.getPoolPdas)(programId, mint).vault,
         isToken,
     });
     // --- 9. Cache everything needed to rebuild ---------------------------------
@@ -452,16 +453,16 @@ function toDummyInput(utxo, zeroChain) {
 }
 function resolveTransactAccounts(params) {
     const { programId, mint, signer } = params;
-    const { config, vault, nullifiers } = (0, client_js_1.getPoolPdas)(programId, mint);
+    const { config, vault, nullifiers } = (0, pdas_js_1.getPoolPdas)(programId, mint);
     return {
         config,
-        global_config: (0, client_js_1.getGlobalConfigPda)(programId),
+        global_config: (0, pdas_js_1.getGlobalConfigPda)(programId),
         vault,
-        input_tree: (0, client_js_1.getNoteTreePda)(programId, mint, params.inputTreeId),
-        output_tree: (0, client_js_1.getNoteTreePda)(programId, mint, params.outputTreeId),
+        input_tree: (0, pdas_js_1.getNoteTreePda)(programId, mint, params.inputTreeId),
+        output_tree: (0, pdas_js_1.getNoteTreePda)(programId, mint, params.outputTreeId),
         nullifiers,
-        nullifier_marker_0: (0, client_js_1.getNullifierMarkerPda)(programId, mint, params.inputNullifiers[0]),
-        nullifier_marker_1: (0, client_js_1.getNullifierMarkerPda)(programId, mint, params.inputNullifiers[1]),
+        nullifier_marker_0: (0, pdas_js_1.getNullifierMarkerPda)(programId, mint, params.inputNullifiers[0]),
+        nullifier_marker_1: (0, pdas_js_1.getNullifierMarkerPda)(programId, mint, params.inputNullifiers[1]),
         relayer: signer,
         // For a deposit nothing is withdrawn, so `recipient` is just the signer.
         // Pointing the unused token slots at accounts already in the transaction

package/dist/cjs/shield/types.d.ts

@@ -1,5 +1,5 @@
 import { AddressLookupTableAccount, Connection, PublicKey, VersionedTransaction } from "@solana/web3.js";
-import type { TransactionProofBuilder, TransactionProofStruct } from "../proof.js";
+import type { TransactionProofBuilder, TransactionProofStruct } from "../proofs/types.js";
 import type { CompactNoteCipher } from "../compactNote.js";
 /**
  * Who owns the resulting note. Both halves are required and neither is derived