@veilo/sdk-core 0.4.0 → 0.6.0

package/dist/esm/proofs/transaction.js

@@ -0,0 +1,105 @@
+import { BN254_FR_MODULUS, bigIntToBytesBE, bytesToBigIntBE, poseidon2, poseidon3, pubkeyToField, } from "../poseidon.js";
+import { deriveNullifier } from "../notes/nullifier.js";
+// -----------------------------------------------------------------------------
+// ExtData Hash Computation
+// -----------------------------------------------------------------------------
+/**
+ * Compute the external data hash.
+ * Matches on-chain computation:
+ *   hash1 = Poseidon(recipient, relayer)
+ *   hash2 = Poseidon(fee, refund)
+ *   extDataHash = Poseidon(hash1, hash2, claimant)
+ */
+export function computeExtDataHash(extData) {
+    const recipientField = pubkeyToField(extData.recipient);
+    const relayerField = pubkeyToField(extData.relayer);
+    const feeField = extData.fee % BN254_FR_MODULUS;
+    const refundField = extData.refund % BN254_FR_MODULUS;
+    const claimantField = pubkeyToField(extData.claimant);
+    const hash1 = poseidon2(recipientField, relayerField);
+    const hash2 = poseidon2(feeField, refundField);
+    const finalHash = poseidon3(hash1, hash2, claimantField);
+    return bigIntToBytesBE(finalHash);
+}
+// -----------------------------------------------------------------------------
+// Circuit Input Preparation
+// -----------------------------------------------------------------------------
+/**
+ * Convert i64 to field element (handles negative via modular arithmetic).
+ * For negative values, we add the field modulus to get the equivalent positive representation.
+ */
+export function i64ToField(value) {
+    if (value >= 0n) {
+        return value % BN254_FR_MODULUS;
+    }
+    return (BN254_FR_MODULUS + value) % BN254_FR_MODULUS;
+}
+/**
+ * Prepare transaction circuit inputs from high-level parameters.
+ * This converts the SDK types into the format expected by the circuit.
+ */
+export function prepareTransactionInputs(params) {
+    const { inputUTXOs, outputUTXOs, root, publicAmount, extData, mintAddress } = params;
+    const extDataHash = computeExtDataHash(extData);
+    const mintField = pubkeyToField(mintAddress);
+    // Prepare input UTXO data
+    const inAmount = [
+        inputUTXOs[0].amount,
+        inputUTXOs[1].amount,
+    ];
+    const inPubkey = [
+        inputUTXOs[0].pubkey,
+        inputUTXOs[1].pubkey,
+    ];
+    const inBlinding = [
+        inputUTXOs[0].blinding,
+        inputUTXOs[1].blinding,
+    ];
+    const inPathIndex = [
+        inputUTXOs[0].pathIndex,
+        inputUTXOs[1].pathIndex,
+    ];
+    const inPathElements = [
+        inputUTXOs[0].pathElements.map((e) => bytesToBigIntBE(e) % BN254_FR_MODULUS),
+        inputUTXOs[1].pathElements.map((e) => bytesToBigIntBE(e) % BN254_FR_MODULUS),
+    ];
+    const inPrivateKey = [
+        inputUTXOs[0].privateKey,
+        inputUTXOs[1].privateKey,
+    ];
+    // Prepare output UTXO data
+    const outAmount = [
+        outputUTXOs[0].amount,
+        outputUTXOs[1].amount,
+    ];
+    const outPubkey = [
+        outputUTXOs[0].pubkey,
+        outputUTXOs[1].pubkey,
+    ];
+    const outBlinding = [
+        outputUTXOs[0].blinding,
+        outputUTXOs[1].blinding,
+    ];
+    // Derive nullifiers for input UTXOs
+    const inputNullifiers = [
+        deriveNullifier(inputUTXOs[0], inputUTXOs[0].pathIndex, inputUTXOs[0].privateKey),
+        deriveNullifier(inputUTXOs[1], inputUTXOs[1].pathIndex, inputUTXOs[1].privateKey),
+    ];
+    return {
+        root,
+        publicAmount,
+        extDataHash,
+        mintAddress,
+        inputNullifiers,
+        outputCommitments: [outputUTXOs[0].commitment, outputUTXOs[1].commitment],
+        inAmount,
+        inPubkey,
+        inBlinding,
+        inPathIndex,
+        inPathElements,
+        inPrivateKey,
+        outAmount,
+        outPubkey,
+        outBlinding,
+    };
+}

package/dist/esm/proofs/types.d.ts

@@ -0,0 +1,70 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * External data that gets hashed into ext_data_hash.
+ * These are public parameters that affect financial flows.
+ */
+export type ExtData = {
+    /** Who receives withdrawal (for withdrawals) */
+    recipient: PublicKey;
+    /** Who submits tx and gets fee */
+    relayer: PublicKey;
+    /** Fee to relayer in lamports/token units */
+    fee: bigint;
+    /** Refund to user in lamports/token units (for gas compensation) */
+    refund: bigint;
+    /** Claimant key committed into the proof */
+    claimant: PublicKey;
+};
+/**
+ * Transaction circuit inputs (8 public inputs, many private inputs).
+ * This structure is used to prepare inputs for the snarkjs prover.
+ */
+export type TransactionCircuitInputs = {
+    /** Merkle root of UTXO tree */
+    root: Uint8Array;
+    /** Net deposit/withdrawal amount (positive = deposit, negative = withdrawal) */
+    publicAmount: bigint;
+    /** Hash of external data (recipient, relayer, fee, refund) */
+    extDataHash: Uint8Array;
+    /** Token mint address */
+    mintAddress: PublicKey;
+    /** Nullifiers for the two input UTXOs */
+    inputNullifiers: [Uint8Array, Uint8Array];
+    /** Commitments for the two output UTXOs */
+    outputCommitments: [Uint8Array, Uint8Array];
+    inAmount: [bigint, bigint];
+    inPubkey: [bigint, bigint];
+    inBlinding: [bigint, bigint];
+    inPathIndex: [number, number];
+    inPathElements: [bigint[], bigint[]];
+    inPrivateKey: [bigint, bigint];
+    outAmount: [bigint, bigint];
+    outPubkey: [bigint, bigint];
+    outBlinding: [bigint, bigint];
+};
+/**
+ * Proof structure matching the on-chain TransactionProof struct.
+ * Total size: 256 bytes (64 + 128 + 64)
+ */
+export type TransactionProofStruct = {
+    /** G1 point A (64 bytes) */
+    proofA: number[];
+    /** G2 point B (128 bytes) */
+    proofB: number[];
+    /** G1 point C (64 bytes) */
+    proofC: number[];
+};
+/**
+ * Shape of a Groth16 proof produced by snarkjs.
+ */
+export type RawProof = {
+    pi_a: [string, string, string];
+    pi_b: [[string, string], [string, string], [string, string]];
+    pi_c: [string, string, string];
+    protocol: string;
+    curve: string;
+};
+/**
+ * Proof builder function type - takes circuit inputs and returns a raw snarkjs proof.
+ */
+export type TransactionProofBuilder = (inputs: TransactionCircuitInputs) => Promise<RawProof>;

package/dist/esm/proofs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/prover.d.ts

@@ -1,9 +1,12 @@
-import { TransactionProofBuilder, RawProof } from "./proof.js";
+import type { TransactionProofBuilder, RawProof } from "./proofs/types.js";
+import { type SwapProofBuilder } from "./proofs/swap.js";
 /**
  * Circuit artifact paths required by snarkjs.
  *
- * These files are large (10-100 MB) and should NOT be bundled in npm.
- * Host them on GitHub Releases, IPFS, or a CDN and download at runtime.
+ * These files are large (10-100 MB) and are NOT bundled in the npm package —
+ * `files` ships `dist/` only. Optional: omit them and the prover resolves a
+ * local copy (see `resolveCircuitArtifacts`). Supply them explicitly whenever
+ * the defaults cannot apply, which includes every browser build.
  *
  * For Node.js: pass file system paths (e.g. "./circuits/transaction.wasm").
  * For browsers: pass Uint8Array buffers or URLs that fetch returns as ArrayBuffer.
@@ -14,6 +17,27 @@ export interface CircuitArtifacts {
     /** Path or buffer for the Groth16 proving key (.zkey) */
     zkeyPath: string | Uint8Array;
 }
+/** The circuits this package can resolve artifacts for. */
+export type CircuitName = "transaction" | "swap";
+/**
+ * Resolve circuit artifacts from disk when the caller did not supply them.
+ *
+ * Search order, first hit wins:
+ *
+ *   1. $VEILO_CIRCUITS_DIR                  explicit override
+ *   2. <package>/circuits                   populated by `npm run copy:circuits`
+ *   3. <cwd>/circuits
+ *   4. <cwd>/node_modules/@veilo/sdk-core/circuits
+ *
+ * NODE ONLY, AND DELIBERATELY LAZY. `node:fs` is imported inside the call, not
+ * at module scope: this module is reachable from the package root export, and a
+ * top-level `node:fs` import throws at bundle time in browser builds with no
+ * Node polyfill — the same reason `random.ts` avoids `node:crypto`. Browsers
+ * must pass `CircuitArtifacts` explicitly; there is nothing to resolve there.
+ *
+ * @throws when no candidate directory holds both files, listing what it tried
+ */
+export declare function resolveCircuitArtifacts(circuit: CircuitName): Promise<CircuitArtifacts>;
 /**
  * Create a proof builder function for the transaction circuit.
  *
@@ -40,7 +64,9 @@ export interface CircuitArtifacts {
  * const proof = await prover(circuitInputs);
  * ```
  */
-export declare function createTransactionProver(artifacts: CircuitArtifacts): TransactionProofBuilder;
+export declare function createTransactionProver(artifacts?: CircuitArtifacts): TransactionProofBuilder;
+/** Create a proof builder for the current `swap.circom` witness shape. */
+export declare function createSwapProver(artifacts?: CircuitArtifacts): SwapProofBuilder;
 /**
  * Verify a Groth16 proof against public signals and a verification key.
  *

package/dist/esm/prover.js

@@ -1,14 +1,92 @@
-import { formatInputsForSnarkjs, } from "./proof.js";
-/** Lazy-load snarkjs — works in both CJS and ESM contexts. */
-async function loadSnarkjs() {
+import { formatInputsForSnarkjs } from "./proofs/formatting.js";
+import { formatSwapInputsForSnarkjs, } from "./proofs/swap.js";
+/**
+ * Lazy-load snarkjs — works in both CJS and ESM contexts.
+ *
+ * The import is built through `Function` so TypeScript cannot rewrite it into a
+ * `require()` in the CommonJS build, and bundlers cannot follow it into browser
+ * output. Never call `require("snarkjs")` directly here: `require` is not
+ * defined in the ESM build, so it throws ReferenceError instead of this
+ * message.
+ */
+async function loadSnarkjs(purpose = "proof generation") {
     try {
         // Dynamic import works in both CJS (Node 12+) and ESM
         return await Function('return import("snarkjs")')();
     }
     catch {
-        throw new Error("snarkjs is required for proof generation. Install it: npm install snarkjs");
+        throw new Error(`snarkjs is required for ${purpose}. Install it: npm install snarkjs`);
     }
 }
+/** Layout produced by `npm run copy:circuits`, relative to a circuits root. */
+const ARTIFACT_LAYOUT = {
+    transaction: {
+        wasm: "transaction/transaction_js/transaction.wasm",
+        zkey: "transaction/transaction_final.zkey",
+    },
+    swap: {
+        wasm: "swap/swap_js/swap.wasm",
+        zkey: "swap/swap_final.zkey",
+    },
+};
+/**
+ * Resolve circuit artifacts from disk when the caller did not supply them.
+ *
+ * Search order, first hit wins:
+ *
+ *   1. $VEILO_CIRCUITS_DIR                  explicit override
+ *   2. <package>/circuits                   populated by `npm run copy:circuits`
+ *   3. <cwd>/circuits
+ *   4. <cwd>/node_modules/@veilo/sdk-core/circuits
+ *
+ * NODE ONLY, AND DELIBERATELY LAZY. `node:fs` is imported inside the call, not
+ * at module scope: this module is reachable from the package root export, and a
+ * top-level `node:fs` import throws at bundle time in browser builds with no
+ * Node polyfill — the same reason `random.ts` avoids `node:crypto`. Browsers
+ * must pass `CircuitArtifacts` explicitly; there is nothing to resolve there.
+ *
+ * @throws when no candidate directory holds both files, listing what it tried
+ */
+export async function resolveCircuitArtifacts(circuit) {
+    let fs;
+    let path;
+    try {
+        fs = await Function('return import("node:fs")')();
+        path = await Function('return import("node:path")')();
+    }
+    catch {
+        throw new Error(`Cannot resolve ${circuit} circuit artifacts: no filesystem available. ` +
+            "Pass CircuitArtifacts explicitly (browsers must supply buffers or URLs).");
+    }
+    const layout = ARTIFACT_LAYOUT[circuit];
+    if (!layout) {
+        throw new Error(`Unknown circuit ${JSON.stringify(circuit)}. Known circuits: ` +
+            `${Object.keys(ARTIFACT_LAYOUT).join(", ")}.`);
+    }
+    const cwd = typeof process !== "undefined" ? process.cwd() : ".";
+    // __dirname exists in the CJS build; the ESM build falls back to cwd-relative
+    // candidates. dist/cjs/prover.js → ../../circuits is the package root copy.
+    const packageDir = typeof __dirname !== "undefined"
+        ? path.resolve(__dirname, "..", "..", "circuits")
+        : undefined;
+    const roots = [
+        process.env?.VEILO_CIRCUITS_DIR,
+        packageDir,
+        path.resolve(cwd, "circuits"),
+        path.resolve(cwd, "node_modules", "@veilo", "sdk-core", "circuits"),
+    ].filter((root) => Boolean(root));
+    for (const root of roots) {
+        const wasmPath = path.resolve(root, layout.wasm);
+        const zkeyPath = path.resolve(root, layout.zkey);
+        if (fs.existsSync(wasmPath) && fs.existsSync(zkeyPath)) {
+            return { wasmPath, zkeyPath };
+        }
+    }
+    throw new Error(`Cannot resolve ${circuit} circuit artifacts. Looked for ${layout.wasm} ` +
+        `and ${layout.zkey} under:\n  ${roots.join("\n  ")}\n` +
+        "Run `npm run copy:circuits` in the SDK, set VEILO_CIRCUITS_DIR, or pass " +
+        "CircuitArtifacts explicitly.");
+}
 /**
  * Create a proof builder function for the transaction circuit.
  *
@@ -36,10 +114,30 @@ async function loadSnarkjs() {
  * ```
  */
 export function createTransactionProver(artifacts) {
+    // Resolved on first use, not at factory time: constructing a prover must stay
+    // free of filesystem access so browser bundles can import this module.
+    let resolved;
     return async (inputs) => {
         const snarkjs = await loadSnarkjs();
+        resolved ?? (resolved = artifacts
+            ? Promise.resolve(artifacts)
+            : resolveCircuitArtifacts("transaction"));
+        const { wasmPath, zkeyPath } = await resolved;
         const formattedInputs = formatInputsForSnarkjs(inputs);
-        const { proof } = await snarkjs.groth16.fullProve(formattedInputs, artifacts.wasmPath, artifacts.zkeyPath);
+        const { proof } = await snarkjs.groth16.fullProve(formattedInputs, wasmPath, zkeyPath);
+        return proof;
+    };
+}
+/** Create a proof builder for the current `swap.circom` witness shape. */
+export function createSwapProver(artifacts) {
+    let resolved;
+    return async (inputs) => {
+        const snarkjs = await loadSnarkjs();
+        resolved ?? (resolved = artifacts
+            ? Promise.resolve(artifacts)
+            : resolveCircuitArtifacts("swap"));
+        const { wasmPath, zkeyPath } = await resolved;
+        const { proof } = await snarkjs.groth16.fullProve(formatSwapInputsForSnarkjs(inputs), wasmPath, zkeyPath);
         return proof;
     };
 }
@@ -54,18 +152,20 @@ export function createTransactionProver(artifacts) {
  * @returns true if the proof is valid
  */
 export async function verifyProof(proof, publicSignals, vkey) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    let snarkjs;
-    try {
-        snarkjs = require("snarkjs");
-    }
-    catch {
-        throw new Error('snarkjs is required for proof verification. Install it: npm install snarkjs');
-    }
+    const snarkjs = await loadSnarkjs("proof verification");
     let vkeyObj;
     if (typeof vkey === "string") {
-        // Node.js file path — read and parse
-        const fs = await import("fs");
+        // Node.js file path — read and parse. Same hidden import as
+        // resolveCircuitArtifacts: a plain `await import("fs")` is followed by
+        // bundlers and breaks browser builds that have no Node polyfill.
+        let fs;
+        try {
+            fs = await Function('return import("node:fs")')();
+        }
+        catch {
+            throw new Error("Reading a verification key from a path requires Node. Pass the parsed " +
+                "verification key object instead.");
+        }
         vkeyObj = JSON.parse(fs.readFileSync(vkey, "utf-8"));
     }
     else {

package/dist/esm/relayer/api.d.ts

@@ -0,0 +1,31 @@
+import type { CheckNullifiersResponse, ChallengeResponse, CheckUsernameResponse, DeleteUserDataResponse, MerkleRootResponse, MerkleTreeResponse, PreRegisterKeyResponse, PrivateSwapRequest, PrivateSwapResponse, PrivateTransferRequest, PrivateTransferResponse, QueryNotesRequest, QueryNotesResponse, RegisterRequest, RegisterResponse, RestoreRequest, RestoreResponse, SaveEncryptedNoteRequest, SaveEncryptedNoteResponse, VeiloPublicKeyResponse, WithdrawRequest, WithdrawResponse } from "./types.js";
+/** Request a wallet-authentication challenge from Veilo. */
+export declare function getChallenge(walletPublicKey: string): Promise<ChallengeResponse>;
+/** Register a Veilo account and receive its auth token. */
+export declare function register(data: RegisterRequest): Promise<RegisterResponse>;
+/** Restore a Veilo account and receive its auth token. */
+export declare function restore(data: RestoreRequest): Promise<RestoreResponse>;
+export declare function checkUsername(username: string): Promise<CheckUsernameResponse>;
+export declare function getVeiloPublicKey(params: {
+    username: string;
+    publicKey?: never;
+} | {
+    publicKey: string;
+    username?: never;
+}): Promise<VeiloPublicKeyResponse>;
+export declare function preRegisterKey(solanaAddress: string): Promise<PreRegisterKeyResponse>;
+export declare function saveEncryptedNote(data: SaveEncryptedNoteRequest): Promise<SaveEncryptedNoteResponse>;
+/** Query notes with an explicit per-call token; no auth state is shared. */
+export declare function queryEncryptedNotes(authToken: string, params?: QueryNotesRequest): Promise<QueryNotesResponse>;
+/** Delete the authenticated user's stored data without retaining their token. */
+export declare function deleteUserData(authToken: string): Promise<DeleteUserDataResponse>;
+/** Raw check-batch call. Prefer `checkNullifiersSpent`, which chunks for you. */
+export declare function checkNullifiers(nullifiers: string[]): Promise<CheckNullifiersResponse>;
+export declare function getMerkleRoot(mintAddress?: string, treeId?: number): Promise<MerkleRootResponse>;
+export declare function getMerkleTree(mintAddress?: string, treeId?: number): Promise<MerkleTreeResponse>;
+export declare function submitWithdraw(data: WithdrawRequest): Promise<WithdrawResponse>;
+export declare function submitPrivateTransfer(data: PrivateTransferRequest): Promise<PrivateTransferResponse>;
+export declare function submitPrivateSwap(data: PrivateSwapRequest): Promise<PrivateSwapResponse>;
+export { submitClosePosition, submitMergePositions, submitOpenPosition, } from "../positions/relayer.js";
+export { submitJperpCancelTrigger, submitJperpClose, submitJperpOpen, submitJperpRecoverNative, submitJperpRecoverSeed, submitJperpReissue, submitJperpSetTpsl, submitJperpUpdateTpsl, } from "../perps/relayer.js";
+export { submitPredictionOpen, submitPredictionReissue, } from "../predictions/relayer.js";

package/dist/esm/relayer/api.js

@@ -0,0 +1,55 @@
+import { createInternalRelayerClient, getInternalRelayerClient, } from "./internal.js";
+/** Request a wallet-authentication challenge from Veilo. */
+export function getChallenge(walletPublicKey) {
+    return getInternalRelayerClient().getChallenge(walletPublicKey);
+}
+/** Register a Veilo account and receive its auth token. */
+export function register(data) {
+    return getInternalRelayerClient().register(data);
+}
+/** Restore a Veilo account and receive its auth token. */
+export function restore(data) {
+    return getInternalRelayerClient().restore(data);
+}
+export function checkUsername(username) {
+    return getInternalRelayerClient().checkUsername(username);
+}
+export function getVeiloPublicKey(params) {
+    return getInternalRelayerClient().getVeiloPublicKey(params);
+}
+export function preRegisterKey(solanaAddress) {
+    return getInternalRelayerClient().preRegisterKey(solanaAddress);
+}
+export function saveEncryptedNote(data) {
+    return getInternalRelayerClient().saveEncryptedNote(data);
+}
+/** Query notes with an explicit per-call token; no auth state is shared. */
+export function queryEncryptedNotes(authToken, params = {}) {
+    return createInternalRelayerClient({ authToken }).queryEncryptedNotes(params);
+}
+/** Delete the authenticated user's stored data without retaining their token. */
+export function deleteUserData(authToken) {
+    return createInternalRelayerClient({ authToken }).deleteUserData();
+}
+/** Raw check-batch call. Prefer `checkNullifiersSpent`, which chunks for you. */
+export function checkNullifiers(nullifiers) {
+    return getInternalRelayerClient().checkNullifiers(nullifiers);
+}
+export function getMerkleRoot(mintAddress, treeId) {
+    return getInternalRelayerClient().getMerkleRoot(mintAddress, treeId);
+}
+export function getMerkleTree(mintAddress, treeId) {
+    return getInternalRelayerClient().getMerkleTree(mintAddress, treeId);
+}
+export function submitWithdraw(data) {
+    return getInternalRelayerClient().submitWithdraw(data);
+}
+export function submitPrivateTransfer(data) {
+    return getInternalRelayerClient().submitPrivateTransfer(data);
+}
+export function submitPrivateSwap(data) {
+    return getInternalRelayerClient().submitPrivateSwap(data);
+}
+export { submitClosePosition, submitMergePositions, submitOpenPosition, } from "../positions/relayer.js";
+export { submitJperpCancelTrigger, submitJperpClose, submitJperpOpen, submitJperpRecoverNative, submitJperpRecoverSeed, submitJperpReissue, submitJperpSetTpsl, submitJperpUpdateTpsl, } from "../perps/relayer.js";
+export { submitPredictionOpen, submitPredictionReissue, } from "../predictions/relayer.js";

package/dist/esm/relayer/client.d.ts

@@ -0,0 +1,73 @@
+import type { CheckNullifiersResponse, ChallengeResponse, CheckUsernameResponse, DeleteUserDataResponse, MerkleRootResponse, MerkleTreeResponse, PreRegisterKeyResponse, PrivateSwapRequest, PrivateSwapResponse, PrivateTransferRequest, PrivateTransferResponse, QueryNotesRequest, QueryNotesResponse, RegisterRequest, RegisterResponse, RestoreRequest, RestoreResponse, RetryPolicy, SaveEncryptedNoteRequest, SaveEncryptedNoteResponse, VeiloPublicKeyResponse, WithdrawRequest, WithdrawResponse } from "./types.js";
+import { type InternalRelayerClientOptions } from "./internal-config.js";
+import type { ClosePositionRequest, ClosePositionResponse, MergePositionsRequest, MergePositionsResponse, OpenPositionRequest, OpenPositionResponse } from "../positions/types.js";
+import type { JperpCancelTriggerRequest, JperpCancelTriggerResponse, JperpCloseRequest, JperpDecreaseResponse, JperpOpenRequest, JperpOpenResponse, JperpRecoverNativeRequest, JperpRecoverNativeResponse, JperpRecoverSeedRequest, JperpRecoverSeedResponse, JperpReissueRequest, JperpReissueResponse, JperpSetTpslRequest, JperpUpdateTpslRequest } from "../perps/types.js";
+import type { PredictionOpenRequest, PredictionOpenResponse, PredictionReissueRequest, PredictionReissueResponse } from "../predictions/types.js";
+/** @internal Relayer transport behind the SDK's functional helpers. */
+export declare class VeiloRelayerClient {
+    private readonly transport;
+    private readonly relayerPubKey;
+    constructor(config?: InternalRelayerClientOptions, retry?: Partial<RetryPolicy>);
+    /** Update the auth token (e.g. after register/restore). */
+    setAuthToken(token: string): void;
+    private encryptPayload;
+    /** Request a signature challenge for wallet authentication. */
+    getChallenge(walletPublicKey: string): Promise<ChallengeResponse>;
+    /** Register a new account with a signed challenge. Returns a JWT auth token. */
+    register(data: RegisterRequest): Promise<RegisterResponse>;
+    /** Restore an existing account using a signed challenge. Returns a JWT auth token. */
+    restore(data: RestoreRequest): Promise<RestoreResponse>;
+    /** Check whether a username is available for registration. */
+    checkUsername(username: string): Promise<CheckUsernameResponse>;
+    /** Look up a user's Veilo public key by username or wallet public key. */
+    getVeiloPublicKey(params: {
+        username: string;
+        publicKey?: never;
+    } | {
+        publicKey: string;
+        username?: never;
+    }): Promise<VeiloPublicKeyResponse>;
+    /**
+     * Provision (or retrieve) the Veilo spend key paired with a Solana address.
+     * Public and idempotent; the response contains public key material only.
+     */
+    preRegisterKey(solanaAddress: string): Promise<PreRegisterKeyResponse>;
+    /** Save an encrypted note to the relayer's database. */
+    saveEncryptedNote(data: SaveEncryptedNoteRequest): Promise<SaveEncryptedNoteResponse>;
+    /** Query encrypted notes for the authenticated user. Requires auth token. */
+    queryEncryptedNotes(params?: QueryNotesRequest): Promise<QueryNotesResponse>;
+    /** Delete all stored data for the authenticated user. Requires auth token. */
+    /**
+     * Ask which of these nullifiers the relayer has seen spent.
+     *
+     * Caller must respect MAX_NULLIFIERS_PER_CHECK; `checkNullifiersSpent` in
+     * notes/spent.ts does the chunking. Unauthenticated: a nullifier reveals
+     * nothing about ownership on its own.
+     */
+    checkNullifiers(nullifiers: string[]): Promise<CheckNullifiersResponse>;
+    deleteUserData(): Promise<DeleteUserDataResponse>;
+    /** Fetch the current Merkle root for a pool, optionally filtered by mint and tree ID. */
+    getMerkleRoot(mintAddress?: string, treeId?: number): Promise<MerkleRootResponse>;
+    /** Fetch the full Merkle tree (all leaves) for a pool. */
+    getMerkleTree(mintAddress?: string, treeId?: number): Promise<MerkleTreeResponse>;
+    /** Submit an encrypted withdrawal request to the relayer. Not retried on failure. */
+    submitWithdraw(data: WithdrawRequest): Promise<WithdrawResponse>;
+    /** Submit an encrypted private transfer request. Not retried on failure. */
+    submitPrivateTransfer(data: PrivateTransferRequest): Promise<PrivateTransferResponse>;
+    /** Submit an encrypted private swap request. Not retried on failure. */
+    submitPrivateSwap(data: PrivateSwapRequest): Promise<PrivateSwapResponse>;
+    submitOpenPosition(data: OpenPositionRequest): Promise<OpenPositionResponse>;
+    submitClosePosition(data: ClosePositionRequest): Promise<ClosePositionResponse>;
+    submitMergePositions(data: MergePositionsRequest): Promise<MergePositionsResponse>;
+    submitJperpOpen(data: JperpOpenRequest): Promise<JperpOpenResponse>;
+    submitJperpClose(data: JperpCloseRequest): Promise<JperpDecreaseResponse>;
+    submitJperpSetTpsl(data: JperpSetTpslRequest): Promise<JperpDecreaseResponse>;
+    submitJperpUpdateTpsl(data: JperpUpdateTpslRequest): Promise<JperpDecreaseResponse>;
+    submitJperpCancelTrigger(data: JperpCancelTriggerRequest): Promise<JperpCancelTriggerResponse>;
+    submitJperpReissue(data: JperpReissueRequest): Promise<JperpReissueResponse>;
+    submitJperpRecoverSeed(data: JperpRecoverSeedRequest): Promise<JperpRecoverSeedResponse>;
+    submitJperpRecoverNative(data: JperpRecoverNativeRequest): Promise<JperpRecoverNativeResponse>;
+    submitPredictionOpen(data: PredictionOpenRequest): Promise<PredictionOpenResponse>;
+    submitPredictionReissue(data: PredictionReissueRequest): Promise<PredictionReissueResponse>;
+    private submitEncrypted;
+}