@veilo/sdk-core 0.5.0 → 0.6.0

package/dist/cjs/relayer/internal.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInternalRelayerClient = getInternalRelayerClient;
+exports.createInternalRelayerClient = createInternalRelayerClient;
+const client_js_1 = require("./client.js");
+const RELAYER = new client_js_1.VeiloRelayerClient();
+/** @internal Shared stateless production client for public SDK helpers. */
+function getInternalRelayerClient() {
+    return RELAYER;
+}
+/** @internal Auth state is isolated per call to avoid cross-user token leaks. */
+function createInternalRelayerClient(options = {}) {
+    return new client_js_1.VeiloRelayerClient(options);
+}

package/dist/cjs/relayer/transport.d.ts

@@ -1,4 +1,5 @@
-import type { RetryPolicy, VeiloRelayerConfig } from "./types.js";
+import { type InternalRelayerClientOptions } from "./internal-config.js";
+import type { RetryPolicy } from "./types.js";
 export interface RelayerRequestOptions {
     body?: unknown;
     authenticated?: boolean;
@@ -10,7 +11,8 @@ export declare class RelayerHttpTransport {
     private readonly apiKey;
     private authToken;
     private readonly retry;
-    constructor(config: VeiloRelayerConfig, retry?: Partial<RetryPolicy>);
+    private readonly fetcher?;
+    constructor(config?: InternalRelayerClientOptions, retry?: Partial<RetryPolicy>);
     setAuthToken(token: string): void;
     request<T>(method: string, route: string, options?: RelayerRequestOptions): Promise<T>;
     private headers;

package/dist/cjs/relayer/transport.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelayerHttpTransport = void 0;
 const errors_js_1 = require("./errors.js");
-const DEFAULT_RELAYER_URL = "https://relayer-server.onrender.com";
+const internal_config_js_1 = require("./internal-config.js");
 const DEFAULT_RETRY = {
     maxRetries: 3,
     baseDelayMs: 1000,
@@ -10,11 +10,12 @@ const DEFAULT_RETRY = {
 };
 /** Owns HTTP authentication, retry, and response normalization. */
 class RelayerHttpTransport {
-    constructor(config, retry) {
-        this.baseUrl = (config.relayerUrl?.trim() || DEFAULT_RELAYER_URL).replace(/\/+$/, "");
-        this.apiKey = config.apiKey;
+    constructor(config = {}, retry) {
+        this.baseUrl = (config.baseUrl?.trim() || internal_config_js_1.VEILO_RELAYER_URL).replace(/\/+$/, "");
+        this.apiKey = config.apiKey ?? "";
         this.authToken = config.authToken;
         this.retry = { ...DEFAULT_RETRY, ...retry };
+        this.fetcher = config.fetch;
     }
     setAuthToken(token) {
         this.authToken = token;
@@ -31,7 +32,11 @@ class RelayerHttpTransport {
             }
             let response;
             try {
-                response = await fetch(url, {
+                const fetcher = this.fetcher ?? globalThis.fetch;
+                if (typeof fetcher !== "function") {
+                    throw new Error("This environment does not provide fetch");
+                }
+                response = await fetcher(url, {
                     method,
                     headers: this.headers(authenticated),
                     body: body == null ? undefined : JSON.stringify(body),

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

@@ -1,13 +1,3 @@
-export interface VeiloRelayerConfig {
-    /** Base URL of the relayer. Defaults to Veilo's production service. */
-    relayerUrl?: string;
-    /** API key sent as x-api-key header */
-    apiKey: string;
-    /** Relayer's NaCl box public key (base64-encoded, 32 bytes) */
-    relayerPublicKey: string;
-    /** Optional JWT auth token for authenticated endpoints */
-    authToken?: string;
-}
 /** Retry configuration for the relayer HTTP client. */
 export interface RetryPolicy {
     /** Max number of retry attempts (default: 3) */
@@ -49,6 +39,15 @@ export interface QueryNotesResponse {
     limit: number;
     offset: number;
 }
+/** Nullifiers to test for spend status. Max 200 per request, 64-char hex. */
+export interface CheckNullifiersRequest {
+    nullifiers: string[];
+}
+export interface CheckNullifiersResponse {
+    success: boolean;
+    /** The SPENT subset, lowercase hex. Absent entries are unspent. */
+    spent: string[];
+}
 export interface SaveEncryptedNoteRequest {
     commitment: string;
     ephemeralPublicKey: string;

package/dist/cjs/relayer/types.js

@@ -1,5 +1,5 @@
 "use strict";
 // =============================================================================
-// Configuration
+// Retry Policy
 // =============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shield/owner.js

@@ -17,10 +17,7 @@ const errors_js_2 = require("./errors.js");
  * inspectable. The two owner endpoints used below are intentionally public and
  * return public key material only.
  */
-const OWNER_RELAYER = new client_js_1.VeiloRelayerClient({
-    apiKey: "",
-    relayerPublicKey: "utVxnA7zax09qJCZ7UJsa8PAOoWLRcCwOkdxg/ZGmD4=",
-});
+const OWNER_RELAYER = new client_js_1.VeiloRelayerClient();
 /**
  * Resolve a shield recipient into the pair of keys that must belong to the same
  * account.

package/dist/esm/events/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./parsing.js";
+export * from "./position.js";
+export * from "./recovery.js";
+export * from "./scanning.js";
+export * from "./tree.js";

package/dist/esm/events/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./parsing.js";
+export * from "./position.js";
+export * from "./recovery.js";
+export * from "./scanning.js";
+export * from "./tree.js";

package/dist/esm/events/parsing.d.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from "@solana/web3.js";
+import { type VersionedPrivacyPoolIdl } from "../idl/index.js";
+import type { CommitmentEvent, NullifierSpentEvent, ParsedVeiloEvent } from "./types.js";
+/**
+ * Decode logs using the current, legacy, and legacy-2 IDLs.
+ *
+ * IDLs are evaluated in the relayer's current/legacy/legacy-2 order. Anchor's
+ * Borsh decoder accepts trailing bytes, however, so every successful parse is
+ * considered and the richest result wins. That preserves the compact fields
+ * in legacy-2 events instead of misclassifying them as the shorter legacy form.
+ * Ties retain the relayer's order.
+ */
+export declare function parseVeiloEventsWithFallback(logMessages: readonly string[] | null | undefined, programId: PublicKey, idls?: readonly VersionedPrivacyPoolIdl[]): ParsedVeiloEvent[];
+export declare function parseCommitmentEventsFromLogs(params: {
+    logMessages: readonly string[] | null | undefined;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+}): CommitmentEvent[];
+export declare function parseNullifierEventsFromLogs(params: {
+    logMessages: readonly string[] | null | undefined;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+}): NullifierSpentEvent[];

package/dist/esm/events/parsing.js

@@ -0,0 +1,120 @@
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { PRIVACY_POOL_IDLS, } from "../idl/index.js";
+/**
+ * Decode logs using the current, legacy, and legacy-2 IDLs.
+ *
+ * IDLs are evaluated in the relayer's current/legacy/legacy-2 order. Anchor's
+ * Borsh decoder accepts trailing bytes, however, so every successful parse is
+ * considered and the richest result wins. That preserves the compact fields
+ * in legacy-2 events instead of misclassifying them as the shorter legacy form.
+ * Ties retain the relayer's order.
+ */
+export function parseVeiloEventsWithFallback(logMessages, programId, idls = PRIVACY_POOL_IDLS) {
+    if (!logMessages?.length)
+        return [];
+    let best = [];
+    let bestScore = -1;
+    for (const candidate of idls) {
+        try {
+            const parser = new anchor.EventParser(programId, new anchor.BorshCoder(candidate.idl));
+            const parsed = Array.from(parser.parseLogs([...logMessages])).map((event) => ({
+                name: event.name,
+                data: event.data,
+                idlVersion: candidate.version,
+            }));
+            const score = parsed.reduce((total, event) => total + decodedFieldCount(event.data), 0);
+            if (score > bestScore) {
+                best = parsed;
+                bestScore = score;
+            }
+        }
+        catch {
+            // The discriminator is shared while historical payload lengths differ.
+        }
+    }
+    return best;
+}
+export function parseCommitmentEventsFromLogs(params) {
+    const { logMessages, programId, txSignature, slot } = params;
+    const out = [];
+    for (const event of parseVeiloEventsWithFallback(logMessages, programId)) {
+        if (event.name.toLowerCase() !== "commitmentevent")
+            continue;
+        const data = event.data;
+        const mintAddress = toPublicKey(field(data, "mintAddress", "mint_address"));
+        const ephemeralPublicKey = optionalBytes(field(data, "ephemeralPublicKey", "ephemeral_public_key"));
+        const encryptedBlob = optionalBytes(field(data, "encryptedBlob", "encrypted_blob"));
+        const rawViewTag = field(data, "viewTag", "view_tag");
+        out.push({
+            commitment: toBytes(field(data, "commitment"), 32, "commitment"),
+            leafIndex: toSafeNumber(field(data, "leafIndex", "leaf_index"), "leafIndex"),
+            newRoot: toBytes(field(data, "newRoot", "new_root"), 32, "newRoot"),
+            timestamp: toSafeNumber(field(data, "timestamp"), "timestamp"),
+            mintAddress,
+            treeId: toSafeNumber(field(data, "treeId", "tree_id"), "treeId"),
+            txSignature,
+            slot,
+            ...(ephemeralPublicKey ? { ephemeralPublicKey } : {}),
+            ...(encryptedBlob ? { encryptedBlob } : {}),
+            ...(rawViewTag !== undefined
+                ? { viewTag: toSafeNumber(rawViewTag, "viewTag") }
+                : {}),
+            source: "emitted",
+            idlVersion: event.idlVersion,
+        });
+    }
+    return out;
+}
+export function parseNullifierEventsFromLogs(params) {
+    const { logMessages, programId, txSignature, slot } = params;
+    const out = [];
+    for (const event of parseVeiloEventsWithFallback(logMessages, programId)) {
+        if (event.name.toLowerCase() !== "nullifierspent")
+            continue;
+        const data = event.data;
+        out.push({
+            nullifier: toBytes(field(data, "nullifier"), 32, "nullifier"),
+            timestamp: toSafeNumber(field(data, "timestamp"), "timestamp"),
+            mintAddress: toPublicKey(field(data, "mintAddress", "mint_address")),
+            treeId: toSafeNumber(field(data, "treeId", "tree_id"), "treeId"),
+            txSignature,
+            slot,
+            idlVersion: event.idlVersion,
+        });
+    }
+    return out;
+}
+function field(data, camel, snake) {
+    return data[camel] ?? (snake ? data[snake] : undefined);
+}
+function optionalBytes(value) {
+    return value === undefined || value === null
+        ? undefined
+        : new Uint8Array(value);
+}
+function decodedFieldCount(value) {
+    return value && typeof value === "object" ? Object.keys(value).length : 0;
+}
+function toBytes(value, length, label) {
+    const bytes = new Uint8Array(value);
+    if (bytes.length !== length) {
+        throw new Error(`${label} must be ${length} bytes, got ${bytes.length}`);
+    }
+    return bytes;
+}
+function toPublicKey(value) {
+    if (value instanceof PublicKey)
+        return value;
+    return new PublicKey(value);
+}
+function toSafeNumber(value, label) {
+    if (value === undefined || value === null) {
+        throw new Error(`Missing ${label} in decoded event`);
+    }
+    const numeric = typeof value === "number" ? value : Number(value);
+    if (!Number.isSafeInteger(numeric)) {
+        throw new Error(`${label} is outside JavaScript's safe integer range`);
+    }
+    return numeric;
+}

package/dist/esm/events/position.d.ts

@@ -0,0 +1,26 @@
+import type { Idl, Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import type { CommitmentEvent } from "./types.js";
+/**
+ * Privacy-pool mints copied from the relayer's global position-tree classifier.
+ * Position commitments use non-pool destination mints at the same tree ID.
+ */
+export declare const POSITION_TREE_POOL_MINTS: readonly PublicKey[];
+export declare function isGlobalPositionCommitment(event: CommitmentEvent): boolean;
+/**
+ * Rebuild the one global position tree shared across every position mint.
+ * This mirrors the relayer: scan all mints for the position tree ID, then drop
+ * normal privacy-pool mint events before sorting by the global leaf index.
+ */
+export declare function buildGlobalPositionTreeFromEvents<T extends Idl>(params: {
+    program: Program<T>;
+    positionTreeId?: number;
+    depth?: number;
+    additionalEvents?: readonly CommitmentEvent[];
+    includeProtectedEvents?: boolean;
+    strictLeafIndices?: boolean;
+}): Promise<{
+    tree: import("../merkle.js").MerkleTree;
+    events: CommitmentEvent[];
+    latestSignature: string;
+}>;

package/dist/esm/events/position.js

@@ -0,0 +1,48 @@
+import { PublicKey } from "@solana/web3.js";
+import { getAllProtectedCommitmentEvents } from "./recovery.js";
+import { scanAllCommitmentEvents } from "./scanning.js";
+import { dedupeCommitmentEvents, reconstructTreeFromCommitmentEvents, } from "./tree.js";
+/**
+ * Privacy-pool mints copied from the relayer's global position-tree classifier.
+ * Position commitments use non-pool destination mints at the same tree ID.
+ */
+export const POSITION_TREE_POOL_MINTS = [
+    PublicKey.default,
+    new PublicKey("So11111111111111111111111111111111111111112"),
+    new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+    new PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"),
+    new PublicKey("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB"),
+    new PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"),
+    new PublicKey("ARXwZkNAtzPfdcoqQiduJn8EPv9fKiDfGn2KyggyDrFs"),
+];
+const POOL_MINTS = new Set(POSITION_TREE_POOL_MINTS.map((mint) => mint.toBase58()));
+export function isGlobalPositionCommitment(event) {
+    return !POOL_MINTS.has(event.mintAddress.toBase58());
+}
+/**
+ * Rebuild the one global position tree shared across every position mint.
+ * This mirrors the relayer: scan all mints for the position tree ID, then drop
+ * normal privacy-pool mint events before sorting by the global leaf index.
+ */
+export async function buildGlobalPositionTreeFromEvents(params) {
+    const { program, positionTreeId = 0, depth = 22, additionalEvents = [], includeProtectedEvents = true, strictLeafIndices = true, } = params;
+    const emitted = await scanAllCommitmentEvents({ program });
+    const protectedEvents = includeProtectedEvents
+        ? getAllProtectedCommitmentEvents()
+        : [];
+    const events = dedupeCommitmentEvents([
+        ...emitted,
+        ...additionalEvents,
+        ...protectedEvents,
+    ])
+        .filter((event) => event.treeId === positionTreeId && isGlobalPositionCommitment(event))
+        .sort((a, b) => a.leafIndex - b.leafIndex);
+    return {
+        tree: reconstructTreeFromCommitmentEvents(events, {
+            depth,
+            strictLeafIndices,
+        }),
+        events,
+        latestSignature: events[events.length - 1]?.txSignature,
+    };
+}

package/dist/esm/events/recovery.d.ts

@@ -0,0 +1,87 @@
+import type { Connection } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
+import { MerkleTree } from "../merkle.js";
+import type { CommitmentEvent } from "./types.js";
+/**
+ * Historical leaves repaired manually in the relayer.
+ *
+ * The deployed `open_position` instruction appended these commitments without
+ * emitting CommitmentEvent. They must be retained when rebuilding history.
+ * Values are copied byte-for-byte from relayer-server/src/db/service.ts.
+ */
+export declare const PROTECTED_COMMITMENT_EVENTS: readonly [{
+    readonly leafIndex: 3738;
+    readonly commitmentHex: "0c7850c9360e041ceeba27297e0fd49fa6a224a651c2fff8c56b22c70a319a94";
+}, {
+    readonly leafIndex: 4;
+    readonly commitmentHex: "15e182d12e044ef2a469ccda88d903304a4e3e69f72765a29e4e6df9c206b0bf";
+    readonly mintAddressHex: "e272b88fb18eaf1994acb885bdba76820c567c3467300f0cd320a0c15ebf9d2f";
+    readonly onChainTreeId: 0;
+}];
+/** @deprecated Use PROTECTED_COMMITMENT_EVENTS. */
+export declare const PROTECTED_COMMITMENT_EVENT: {
+    readonly leafIndex: 3738;
+    readonly commitmentHex: "0c7850c9360e041ceeba27297e0fd49fa6a224a651c2fff8c56b22c70a319a94";
+};
+/** Return protected records as normal SDK events for a particular tree. */
+export declare function getProtectedCommitmentEvents(params: {
+    mintAddress: PublicKey;
+    treeId?: number;
+}): CommitmentEvent[];
+/** Return every protected leaf, including the global position-tree repair. */
+export declare function getAllProtectedCommitmentEvents(): CommitmentEvent[];
+/**
+ * Add the protected historical leaves without duplicating records already read
+ * from an indexer. A conflicting commitment at a protected index is rejected.
+ */
+export declare function mergeProtectedCommitmentEvents(events: readonly CommitmentEvent[], params: {
+    mintAddress: PublicKey;
+    treeId?: number;
+}): CommitmentEvent[];
+/**
+ * Insert expected commitments and prefer authoritative emitted metadata when it
+ * exists. Missing events are computed from the local tree exactly like the
+ * relayer's `insertAndPersistCommitments` fallback.
+ *
+ * This function mutates `tree`.
+ */
+export declare function resolveCommitmentEvents(params: {
+    commitments: readonly Uint8Array[];
+    tree: MerkleTree;
+    logMessages?: readonly string[] | null;
+    programId: PublicKey;
+    mintAddress: PublicKey;
+    treeId: number;
+    txSignature: string;
+    slot: number;
+    timestamp?: number;
+    requireAllInLogs?: boolean;
+}): CommitmentEvent[];
+export type EventlessOpenPositionCommitments = {
+    sourceMint: PublicKey;
+    sourceTreeId: number;
+    sourceCommitment: Uint8Array;
+    positionMint: PublicKey;
+    positionTreeId: number;
+    positionCommitment: Uint8Array;
+    positionPdaKey: Uint8Array;
+};
+/** Decode the two commitments hidden in a current `open_position` instruction. */
+export declare function decodeEventlessOpenPositionCommitments(instructionData: Uint8Array): EventlessOpenPositionCommitments | null;
+export declare function getPositionPda(programId: PublicKey, positionPdaKey: Uint8Array): PublicKey;
+/** Read PositionPDA.leaf_index at the same byte offset used by the relayer. */
+export declare function readPositionLeafIndex(accountData: Uint8Array): number;
+/**
+ * Recover the two events omitted by the deployed `open_position` instruction.
+ * The source tree must already contain every earlier source-mint commitment.
+ * This function inserts the source commitment into that tree.
+ */
+export declare function recoverEventlessOpenPositionEvents(params: {
+    instructionData: Uint8Array;
+    sourceTree: MerkleTree;
+    connection: Pick<Connection, "getAccountInfo">;
+    programId: PublicKey;
+    txSignature: string;
+    slot: number;
+    timestamp?: number;
+}): Promise<CommitmentEvent[]>;