@veilo/sdk-core 0.5.0 → 0.7.0

package/dist/esm/predictions/pdas.js

@@ -0,0 +1,10 @@
+import { PublicKey } from "@solana/web3.js";
+import { assertBytes, utf8 } from "../identity/encoding.js";
+export function derivePredictionSlotPda(params) {
+    assertBytes(params.withdrawalId, 32, "prediction withdrawal ID");
+    return PublicKey.findProgramAddressSync([
+        utf8("prediction_slot_v1"),
+        params.mint.toBytes(),
+        params.withdrawalId,
+    ], params.programId)[0];
+}

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

@@ -0,0 +1,3 @@
+import type { PredictionOpenRequest, PredictionOpenResponse, PredictionReissueRequest, PredictionReissueResponse } from "./types.js";
+export declare function submitPredictionOpen(data: PredictionOpenRequest): Promise<PredictionOpenResponse>;
+export declare function submitPredictionReissue(data: PredictionReissueRequest): Promise<PredictionReissueResponse>;

package/dist/esm/predictions/relayer.js

@@ -0,0 +1,7 @@
+import { getInternalRelayerClient } from "../relayer/internal.js";
+export function submitPredictionOpen(data) {
+    return getInternalRelayerClient().submitPredictionOpen(data);
+}
+export function submitPredictionReissue(data) {
+    return getInternalRelayerClient().submitPredictionReissue(data);
+}

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

@@ -0,0 +1,178 @@
+import type { TransactNote } from "../relayer/types.js";
+export interface PredictionOpenRequest {
+    notes: TransactNote[];
+    /** USDC stake, raw 6-decimal units. */
+    depositAmount: string;
+    /** 32-byte prediction-slot withdrawal ID, hex. */
+    withdrawalId: string;
+    /** Deterministic ephemeral wallet and open-proof claimant, base58. */
+    claimantPublicKey: string;
+    userPublicKey: string;
+}
+export interface PredictionOpenResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        ephemeralWallet: string;
+        ephemeralTokenAccount: string;
+        changeAmount: string;
+        fee: string;
+        feeBps: number;
+        totalDebited: string;
+    };
+}
+export interface PredictionReissueRequest {
+    withdrawalId: string;
+    claimantSecretKey: string;
+    /** Kept for API compatibility; the relayer reads the real chain balance. */
+    reissueAmount: string;
+    veiloPublicKey: string;
+    userPublicKey: string;
+}
+export interface PredictionReissueResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string | null;
+        reissueAmount: string;
+        fee?: string;
+        tradeHappened?: boolean;
+    };
+}
+export interface PredictionMarketPricing {
+    buyYesPriceUsd: number;
+    sellYesPriceUsd: number;
+    buyNoPriceUsd: number;
+    sellNoPriceUsd: number;
+    volume: number;
+}
+export interface PredictionMarket {
+    provider: string;
+    marketId: string;
+    status: "open" | "closed" | "cancelled";
+    result: string | null;
+    title: string;
+    openTime: number;
+    closeTime: number;
+    rulesPrimary?: string;
+    imageUrl?: string;
+    clobTokenIds?: string[];
+    pricing: PredictionMarketPricing;
+}
+export interface PredictionEvent {
+    eventId: string;
+    isActive: boolean;
+    isLive: boolean;
+    category: string;
+    subcategory: string;
+    tags: string[];
+    metadata: {
+        title: string;
+        closeTime: string;
+        imageUrl?: string;
+        series?: string;
+        slug?: string;
+    };
+    volumeUsd: string;
+    volume24hr: string;
+    closeCondition?: string;
+    markets: PredictionMarket[];
+}
+export interface PredictionPosition {
+    pubkey: string;
+    owner: string;
+    marketId: string;
+    isYes: boolean;
+    contracts: string;
+    contractsDecimal: string;
+    totalCostUsd: string;
+    sizeUsd: string;
+    valueUsd: string;
+    avgPriceUsd: string;
+    markPriceUsd: string;
+    pnlUsd: string;
+    pnlUsdPercent: number;
+    feesPaidUsd: string;
+    claimed: boolean;
+    claimable: boolean;
+    payoutUsd: string;
+    sellPriceUsd: string;
+    settlementDate: number;
+    eventMetadata: {
+        title: string;
+        category: string;
+        imageUrl?: string;
+    };
+    marketMetadata: {
+        title: string;
+        result: string | null;
+        status: string;
+    };
+}
+export interface PlacePredictionOrderRequest {
+    ownerPubkey: string;
+    marketId: string;
+    isYes: boolean;
+    isBuy: true;
+    depositAmount: string;
+    depositMint: string;
+}
+export interface PredictionTransactionResponse {
+    transaction: string;
+    txMeta: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    };
+}
+export interface PlacePredictionOrderResponse extends PredictionTransactionResponse {
+    order: {
+        orderPubkey: string;
+        positionPubkey: string;
+        contracts: number;
+    };
+}
+export type PredictionOrderStatus = "pending" | "filled" | "partiallyfilled" | "failed";
+export interface PredictionOrderStatusResponse {
+    orderPubkey: string;
+    status: PredictionOrderStatus;
+    latestEventType: string;
+    latestSignature: string;
+    history: Array<{
+        eventType: string;
+        status: string;
+        rawStatus: string;
+        timestamp: number;
+        signature: string;
+    }>;
+}
+export interface PredictionHistoryEvent {
+    id: number;
+    eventType: string;
+    signature: string;
+    timestamp: number;
+    marketId: string;
+    isYes: boolean;
+    isBuy: boolean;
+    contractsDecimal: string;
+    avgFillPriceUsd?: string;
+    totalCostUsd?: string;
+    netProceedsUsd?: string;
+    realizedPnl?: string;
+    payoutAmountUsd?: string;
+    eventMetadata: {
+        title: string;
+        category?: string;
+        imageUrl?: string;
+    };
+    marketMetadata: {
+        title: string;
+        result: string | null;
+        status: string;
+    };
+}
+export type PredictionPriceInterval = "1d" | "1w" | "1m" | "max";
+export interface PredictionPricePoint {
+    t: number;
+    p: number;
+}

package/dist/esm/predictions/types.js

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

package/dist/esm/program.d.ts

@@ -1,6 +1,8 @@
 import { Program, Idl, Wallet } from "@coral-xyz/anchor";
 import { Connection, PublicKey } from "@solana/web3.js";
+import { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY2_IDL, PRIVACY_POOL_LEGACY_IDL } from "./idl/index.js";
 export declare const PRIVACY_POOL_IDL: Idl;
+export { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY_IDL, PRIVACY_POOL_LEGACY2_IDL, };
 /** Deployed program ID extracted from the bundled IDL. */
 export declare const PRIVACY_POOL_PROGRAM_ID: PublicKey;
 /**

package/dist/esm/program.js

@@ -1,10 +1,11 @@
 import { Program, AnchorProvider } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-import IDL_JSON from "./idl/privacy_pool.js";
+import { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY2_IDL, PRIVACY_POOL_LEGACY_IDL, } from "./idl/index.js";
 // Re-export so consumers can access the raw IDL if needed
-export const PRIVACY_POOL_IDL = IDL_JSON;
+export const PRIVACY_POOL_IDL = PRIVACY_POOL_CURRENT_IDL;
+export { PRIVACY_POOL_CURRENT_IDL, PRIVACY_POOL_IDLS, PRIVACY_POOL_LEGACY_IDL, PRIVACY_POOL_LEGACY2_IDL, };
 /** Deployed program ID extracted from the bundled IDL. */
-export const PRIVACY_POOL_PROGRAM_ID = new PublicKey(IDL_JSON.address);
+export const PRIVACY_POOL_PROGRAM_ID = new PublicKey(PRIVACY_POOL_CURRENT_IDL.address);
 /**
  * Create an Anchor `Program` instance for the Veilo Privacy Pool.
  *

package/dist/esm/prover.d.ts

@@ -3,8 +3,10 @@ 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.
@@ -15,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.
  *
@@ -41,9 +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;
+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,91 @@
 import { formatInputsForSnarkjs } from "./proofs/formatting.js";
 import { formatSwapInputsForSnarkjs, } from "./proofs/swap.js";
-/** Lazy-load snarkjs — works in both CJS and ESM contexts. */
-async function loadSnarkjs() {
+/**
+ * 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.
@@ -37,18 +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();
-        const { proof } = await snarkjs.groth16.fullProve(formatSwapInputsForSnarkjs(inputs), artifacts.wasmPath, artifacts.zkeyPath);
+        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;
     };
 }
@@ -63,18 +152,20 @@ export function createSwapProver(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,41 @@
+import type { CheckNullifiersResponse, CompactScanResponse, FetchByCommitmentRequest, FetchByCommitmentResponse, 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>;
+/** One page of the public compact-note feed. Prefer `scanCompactNotes`. */
+export declare function compactScan(params?: {
+    limit?: number;
+    cursor?: string;
+}): Promise<CompactScanResponse>;
+/**
+ * One fetch-by-commitment request, capped at 50 commitments by the server.
+ * Prefer `fetchNotesByCommitment` from the notes module, which chunks for you.
+ */
+export declare function fetchNotesByCommitmentPage(data: FetchByCommitmentRequest): Promise<FetchByCommitmentResponse>;
+/** 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,66 @@
+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();
+}
+/** One page of the public compact-note feed. Prefer `scanCompactNotes`. */
+export function compactScan(params = {}) {
+    return getInternalRelayerClient().compactScan(params);
+}
+/**
+ * One fetch-by-commitment request, capped at 50 commitments by the server.
+ * Prefer `fetchNotesByCommitment` from the notes module, which chunks for you.
+ */
+export function fetchNotesByCommitmentPage(data) {
+    return getInternalRelayerClient().fetchNotesByCommitment(data);
+}
+/** 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

@@ -1,23 +1,13 @@
-import type { ChallengeResponse, CheckUsernameResponse, DeleteUserDataResponse, MerkleRootResponse, MerkleTreeResponse, PreRegisterKeyResponse, PrivateSwapRequest, PrivateSwapResponse, PrivateTransferRequest, PrivateTransferResponse, QueryNotesRequest, QueryNotesResponse, RegisterRequest, RegisterResponse, RestoreRequest, RestoreResponse, RetryPolicy, SaveEncryptedNoteRequest, SaveEncryptedNoteResponse, VeiloPublicKeyResponse, VeiloRelayerConfig, WithdrawRequest, WithdrawResponse } from "./types.js";
-/**
- * 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...");
- * ```
- */
+import type { CheckNullifiersResponse, CompactScanResponse, FetchByCommitmentRequest, FetchByCommitmentResponse, 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: VeiloRelayerConfig, retry?: Partial<RetryPolicy>);
+    constructor(config?: InternalRelayerClientOptions, retry?: Partial<RetryPolicy>);
     /** Update the auth token (e.g. after register/restore). */
     setAuthToken(token: string): void;
     private encryptPayload;
@@ -47,6 +37,27 @@ export declare class VeiloRelayerClient {
     /** 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. */
+    /**
+     * One page of the public compact-note feed.
+     *
+     * Unauthenticated by design: rows carry only ciphertext and a one-byte view
+     * tag, so scanning reveals nothing without the recipient's key. The feed
+     * excludes spent notes and any note already claimed by a wallet.
+     */
+    compactScan(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<CompactScanResponse>;
+    /** Look up stored notes by commitment. Max 50 per request. */
+    fetchNotesByCommitment(data: FetchByCommitmentRequest): Promise<FetchByCommitmentResponse>;
+    /**
+     * 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>;
@@ -58,4 +69,18 @@ export declare class VeiloRelayerClient {
     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;
 }