@veilo/sdk-core 0.3.3 → 0.5.0

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

@@ -0,0 +1,5 @@
+/**
+ * Encrypt a JSON-serializable payload for the relayer using NaCl box.
+ * Layout: [ephemeralPubKey (32)] [nonce (24)] [ciphertext (...)]
+ */
+export declare function encryptForRelayer(data: unknown, relayerPublicKey: Uint8Array): string;

package/dist/cjs/relayer/crypto.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptForRelayer = encryptForRelayer;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const encoding_js_1 = require("./encoding.js");
+// =============================================================================
+// 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 (0, encoding_js_1.toBase64)(payload);
+}

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

@@ -0,0 +1,2 @@
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function fromBase64(str: string): Uint8Array;

package/dist/cjs/relayer/encoding.js

@@ -0,0 +1,23 @@
+"use strict";
+// =============================================================================
+// Base64 helpers (no dependency on tweetnacl-util)
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+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;
+}

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

@@ -0,0 +1,7 @@
+/** Structured error thrown by VeiloRelayerClient on API failures. */
+export declare class VeiloApiError extends Error {
+    code: string;
+    status: number;
+    details?: unknown;
+    constructor(code: string, message: string, status: number, details?: unknown);
+}

package/dist/cjs/relayer/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+// =============================================================================
+// Structured Error
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeiloApiError = void 0;
+/** 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;

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

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./client.js";

package/dist/cjs/relayer/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __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 });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./client.js"), exports);

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

@@ -0,0 +1,17 @@
+import type { RetryPolicy, VeiloRelayerConfig } from "./types.js";
+export interface RelayerRequestOptions {
+    body?: unknown;
+    authenticated?: boolean;
+    retryable?: boolean;
+}
+/** Owns HTTP authentication, retry, and response normalization. */
+export declare class RelayerHttpTransport {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private authToken;
+    private readonly retry;
+    constructor(config: VeiloRelayerConfig, 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

@@ -0,0 +1,63 @@
+"use strict";
+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 DEFAULT_RETRY = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    retryableStatuses: [429, 502, 503, 504],
+};
+/** 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;
+        this.authToken = config.authToken;
+        this.retry = { ...DEFAULT_RETRY, ...retry };
+    }
+    setAuthToken(token) {
+        this.authToken = token;
+    }
+    async request(method, route, options = {}) {
+        const url = `${this.baseUrl}/api${route}`;
+        const { body, authenticated = false, retryable = true } = options;
+        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((resolve) => setTimeout(resolve, delay));
+            }
+            let response;
+            try {
+                response = await fetch(url, {
+                    method,
+                    headers: this.headers(authenticated),
+                    body: body == null ? undefined : JSON.stringify(body),
+                });
+            }
+            catch (error) {
+                lastError = new errors_js_1.VeiloApiError("NETWORK_ERROR", error instanceof Error ? error.message : "Network request failed", 0);
+                continue;
+            }
+            const data = await response.json().catch(() => ({}));
+            if (response.ok && data.success !== false)
+                return data;
+            lastError = new errors_js_1.VeiloApiError(data.error || "UNKNOWN", data.message || data.error || `Request failed: ${response.status}`, response.status, data);
+            if (!this.retry.retryableStatuses.includes(response.status))
+                throw lastError;
+        }
+        throw lastError;
+    }
+    headers(authenticated) {
+        const headers = { "Content-Type": "application/json" };
+        if (this.apiKey)
+            headers["x-api-key"] = this.apiKey;
+        if (authenticated && this.authToken) {
+            headers.Authorization = `Bearer ${this.authToken}`;
+        }
+        return headers;
+    }
+}
+exports.RelayerHttpTransport = RelayerHttpTransport;

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

@@ -0,0 +1,276 @@
+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) */
+    maxRetries: number;
+    /** Base delay in ms for exponential backoff (default: 1000) */
+    baseDelayMs: number;
+    /** HTTP status codes that trigger a retry (default: [429, 502, 503, 504]) */
+    retryableStatuses: number[];
+}
+export interface RelayerEncryptedNote {
+    noteId: string;
+    commitment: string;
+    ephemeralPublicKey: string;
+    encryptedBlob: string;
+    timestamp: number;
+    blockHeight?: number;
+    txSignature?: string;
+    spent?: boolean;
+    onchainId?: string;
+    spentTx?: string;
+    spentAt?: number;
+    compactEphemeralKey?: string | null;
+    compactBlob?: string | null;
+    viewTag?: number | null;
+    leafIndex?: number | null;
+    mintAddress?: string | null;
+    treeId?: number | null;
+}
+export interface QueryNotesRequest {
+    lastCheckedTimestamp?: number;
+    limit?: number;
+    offset?: number;
+    walletPublicKey?: string;
+}
+export interface QueryNotesResponse {
+    success: boolean;
+    notes: RelayerEncryptedNote[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface SaveEncryptedNoteRequest {
+    commitment: string;
+    ephemeralPublicKey: string;
+    encryptedBlob: string;
+    timestamp: number;
+    blockHeight?: number;
+    txSignature?: string;
+    recipientWalletPublicKey?: string;
+    compactEphemeralKey?: string | null;
+    compactBlob?: string | null;
+    viewTag?: number | null;
+    leafIndex?: number;
+    newRoot?: string;
+    mintAddress?: string;
+    treeId?: number;
+    amountRaw?: string;
+}
+export interface SaveEncryptedNoteResponse {
+    success: boolean;
+    noteId?: string;
+    message?: string;
+    error?: string;
+}
+export interface MerkleRootResponse {
+    success: boolean;
+    data: {
+        root: string;
+        nextIndex: number;
+        treeId: number;
+        onChainTreeId: number;
+        mintAddress: string;
+    };
+}
+export interface MerkleTreeResponse {
+    success: boolean;
+    data: {
+        treeId: number;
+        onChainTreeId: number;
+        mintAddress: string;
+        height: number;
+        nextIndex: number;
+        root: string;
+        totalCommitments: number;
+        leaves: Array<{
+            commitment: string;
+            index: number;
+            txSignature: string;
+            slot: number;
+            timestamp: string;
+        }>;
+        reconstructionInfo: {
+            instructions: string;
+            treeHeight: number;
+            hashFunction?: string;
+        };
+    };
+}
+export interface TransactNote {
+    /** Relayer database identifier when the note came from relayer sync. */
+    id?: string;
+    /** Client-side alias used by the dapp, wallet, and extension. */
+    noteId?: string;
+    amount: string;
+    commitment: string;
+    root?: string;
+    nullifier: string;
+    blinding: string;
+    privateKey: string;
+    publicKey: string;
+    /** Optional because the relayer corrects it against commitment events. */
+    leafIndex?: number;
+    timestamp?: number;
+    spent?: boolean;
+    spentAt?: number;
+    txSignature?: string;
+    treeId?: number;
+    mintAddress?: string;
+    merklePath?: {
+        pathElements: string[];
+        pathIndices: number[];
+    };
+}
+export interface WithdrawRequest {
+    notes: TransactNote[];
+    recipient: string;
+    amount: string;
+    userPublicKey: string;
+    mintAddress: string;
+    feeOnTop?: boolean;
+}
+export interface WithdrawResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        withdrawRecipient: string;
+        withdrawAmount: number;
+        fee: number;
+        feeBps: number;
+        feeOnTop: boolean;
+        totalDebited: number;
+        changeAmount: number;
+        changeNote: {
+            commitment: string;
+            amount: string;
+            leafIndex: number;
+        };
+        savedNoteId?: string;
+    };
+}
+export interface PrivateTransferRequest {
+    notes: TransactNote[];
+    amount: string;
+    recipientUsername: string;
+    userPublicKey?: string;
+    mintAddress?: string;
+    mode?: "merge";
+    recipientSolanaAddress?: string;
+    /** Legacy extension field; current relayer resolves the key itself. */
+    recipientShieldedKey?: string;
+}
+export interface PrivateTransferResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        merged: false;
+    } | {
+        recipient: string;
+        transferAmount: number;
+        senderChangeAmount: number;
+        txSignature: string;
+        recipientNote: {
+            commitment: string;
+            amount: string;
+            leafIndex: number;
+            savedNoteId: string;
+        };
+        senderChangeNote: {
+            commitment: string;
+            amount: string;
+            leafIndex: number;
+        } | null;
+    };
+}
+export interface PrivateSwapRequest {
+    notes: TransactNote[];
+    sourceMintAddress: string;
+    destMintAddress: string;
+    sourceJupiterMint?: string;
+    destJupiterMint?: string;
+    swapAmountRaw: string;
+    minAmountOut: string;
+    slippageBps: number;
+    userPublicKey: string;
+    veiloPublicKey: string;
+    /** Optional veilo-connect intent forwarded by the browser extension. */
+    intentCommit?: {
+        origin: string;
+        fromMint: string;
+        toMint: string;
+        amountIn: string;
+        minAmountOut: string;
+        deadline: number;
+        nonce: string;
+    };
+    intentHash?: string;
+    intentDeadlineMs?: number;
+}
+export interface PrivateSwapResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        txSignature: string;
+        swapAmountRaw: string;
+        outputAmount: string;
+        minAmountOut: string;
+        changeAmount: string;
+    };
+}
+export interface ChallengeResponse {
+    success: boolean;
+    challenge: string;
+    expiresAt: number;
+}
+export interface RegisterRequest {
+    username: string;
+    walletPublicKey: string;
+    signature: string;
+    challenge: string;
+    veiloPublicKey: string;
+}
+export interface RegisterResponse {
+    success: boolean;
+    token: string;
+    message?: string;
+}
+export interface RestoreRequest {
+    walletPublicKey: string;
+    signature: string;
+    challenge: string;
+}
+export interface RestoreResponse {
+    success: boolean;
+    token: string;
+    username: string;
+    veiloPublicKey: string;
+}
+export interface CheckUsernameResponse {
+    success: boolean;
+    available: boolean;
+}
+export interface VeiloPublicKeyResponse {
+    success: boolean;
+    username: string;
+    pubK: string;
+    veiloPublicKey: string;
+}
+export interface PreRegisterKeyResponse {
+    success: boolean;
+    veiloPublicKey: string;
+}
+export interface DeleteUserDataResponse {
+    success: boolean;
+    message: string;
+    deletedCount?: number;
+}

package/dist/cjs/relayer/types.js

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