@veilo/sdk-core 0.1.17 → 0.3.3

package/dist/cjs/config.d.ts

@@ -0,0 +1,82 @@
+import { PublicKey } from "@solana/web3.js";
+/** Default relayer fee in basis points (50 = 0.5%). */
+export declare const DEFAULT_FEE_BPS = 50;
+/** Merkle tree depth - matches on-chain MerkleTreeAccount subtrees array size */
+export declare const MERKLE_TREE_DEPTH = 22;
+/** Root history size - matches on-chain MerkleTreeAccount root_history array size */
+export declare const ROOT_HISTORY_SIZE = 256;
+/** Native SOL mint address (Pubkey::default() = all zeros) */
+export declare const NATIVE_SOL_MINT: PublicKey;
+/** Convert SOL to lamports (e.g. `sol(1.5)` → `1_500_000_000n`). */
+export declare function sol(n: number): bigint;
+/** Configuration for initializing a privacy pool */
+export type PoolInitConfig = {
+    /** Fee in basis points (0-10000, where 10000 = 100%) */
+    feeBps?: number;
+    /** Token mint address (use NATIVE_SOL_MINT for SOL pools) */
+    mintAddress: PublicKey;
+    /** Minimum deposit amount in lamports/token units */
+    minDepositAmount?: bigint;
+    /** Maximum deposit amount in lamports/token units */
+    maxDepositAmount?: bigint;
+    /** Minimum withdrawal amount in lamports/token units */
+    minWithdrawAmount?: bigint;
+    /** Maximum withdrawal amount in lamports/token units */
+    maxWithdrawAmount?: bigint;
+};
+/** On-chain PrivacyConfig account structure */
+export type PrivacyConfigAccount = {
+    bump: number;
+    vaultBump: number;
+    admin: PublicKey;
+    feeBps: number;
+    feeErrorMarginBps: number;
+    minWithdrawalFee: bigint;
+    /** Minimum fee kept by relayer on swaps (in destination token base units) */
+    minSwapFee: bigint;
+    /** Fee rate applied to swap output in basis points */
+    swapFeeBps: number;
+    totalTvl: bigint;
+    mintAddress: PublicKey;
+    minDepositAmount: bigint;
+    maxDepositAmount: bigint;
+    minWithdrawAmount: bigint;
+    maxWithdrawAmount: bigint;
+    numRelayers: number;
+    relayers: PublicKey[];
+    numTrees: number;
+    nextTreeIndex: number;
+};
+/** On-chain GlobalConfig account structure */
+export type GlobalConfigAccount = {
+    bump: number;
+    admin: PublicKey;
+    relayerEnabled: boolean;
+};
+/**
+ * Compute the relayer fee for a withdrawal.
+ * Mirrors the formula in the relayer-server:
+ *   fee = max(amount * feeBps / 10_000, minWithdrawalFee)
+ *
+ * @returns fee in base token units, and the amount that reaches the recipient
+ */
+export declare function computeWithdrawalFee(amount: bigint, feeBps: number, minWithdrawalFee: bigint): {
+    fee: bigint;
+    toRecipient: bigint;
+};
+/**
+ * Compute the relayer fee for a cross-pool swap.
+ * Mirrors the formula in the relayer-server:
+ *   relayerFee = max(estimatedOutput * swapFeeBps / 10_000, minSwapFee)
+ *   destAmount  = minAmountOut - relayerFee
+ *
+ * @param estimatedOutput  Jupiter quote output amount
+ * @param swapFeeBps       From the destination pool's PrivacyConfigAccount
+ * @param minSwapFee       From the destination pool's PrivacyConfigAccount
+ * @param minAmountOut     User-agreed minimum swap output (after slippage)
+ * @returns relayerFee and the amount committed into the destination UTXO
+ */
+export declare function computeSwapFee(estimatedOutput: bigint, swapFeeBps: number, minSwapFee: bigint, minAmountOut: bigint): {
+    relayerFee: bigint;
+    destAmount: bigint;
+};

package/dist/cjs/config.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATIVE_SOL_MINT = exports.ROOT_HISTORY_SIZE = exports.MERKLE_TREE_DEPTH = exports.DEFAULT_FEE_BPS = void 0;
+exports.sol = sol;
+exports.computeWithdrawalFee = computeWithdrawalFee;
+exports.computeSwapFee = computeSwapFee;
+const web3_js_1 = require("@solana/web3.js");
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+/** Default relayer fee in basis points (50 = 0.5%). */
+exports.DEFAULT_FEE_BPS = 50;
+/** Merkle tree depth - matches on-chain MerkleTreeAccount subtrees array size */
+exports.MERKLE_TREE_DEPTH = 22;
+/** Root history size - matches on-chain MerkleTreeAccount root_history array size */
+exports.ROOT_HISTORY_SIZE = 256;
+/** Native SOL mint address (Pubkey::default() = all zeros) */
+exports.NATIVE_SOL_MINT = web3_js_1.PublicKey.default;
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+/** Convert SOL to lamports (e.g. `sol(1.5)` → `1_500_000_000n`). */
+function sol(n) {
+    return BigInt(n * web3_js_1.LAMPORTS_PER_SOL);
+}
+// -----------------------------------------------------------------------------
+// Fee Calculation Helpers
+// -----------------------------------------------------------------------------
+/**
+ * Compute the relayer fee for a withdrawal.
+ * Mirrors the formula in the relayer-server:
+ *   fee = max(amount * feeBps / 10_000, minWithdrawalFee)
+ *
+ * @returns fee in base token units, and the amount that reaches the recipient
+ */
+function computeWithdrawalFee(amount, feeBps, minWithdrawalFee) {
+    const computed = (amount * BigInt(feeBps)) / 10000n;
+    const fee = computed > minWithdrawalFee ? computed : minWithdrawalFee;
+    return { fee, toRecipient: amount - fee };
+}
+/**
+ * Compute the relayer fee for a cross-pool swap.
+ * Mirrors the formula in the relayer-server:
+ *   relayerFee = max(estimatedOutput * swapFeeBps / 10_000, minSwapFee)
+ *   destAmount  = minAmountOut - relayerFee
+ *
+ * @param estimatedOutput  Jupiter quote output amount
+ * @param swapFeeBps       From the destination pool's PrivacyConfigAccount
+ * @param minSwapFee       From the destination pool's PrivacyConfigAccount
+ * @param minAmountOut     User-agreed minimum swap output (after slippage)
+ * @returns relayerFee and the amount committed into the destination UTXO
+ */
+function computeSwapFee(estimatedOutput, swapFeeBps, minSwapFee, minAmountOut) {
+    const computed = (estimatedOutput * BigInt(swapFeeBps)) / 10000n;
+    const relayerFee = computed > minSwapFee ? computed : minSwapFee;
+    return { relayerFee, destAmount: minAmountOut - relayerFee };
+}

package/dist/cjs/events.d.ts

@@ -0,0 +1,77 @@
+import { PublicKey } from "@solana/web3.js";
+import { Program, Idl } from "@coral-xyz/anchor";
+import { MerkleTree } from "./merkle";
+/**
+ * On-chain CommitmentEvent emitted by `transact` and `transact_swap`.
+ * Mirrors the IDL CommitmentEvent struct.
+ */
+export type CommitmentEvent = {
+    commitment: Uint8Array;
+    leafIndex: number;
+    newRoot: Uint8Array;
+    timestamp: number;
+    mintAddress: PublicKey;
+    treeId: number;
+    txSignature: string;
+    slot: number;
+};
+/**
+ * On-chain NullifierSpent event emitted when a UTXO is consumed.
+ * Mirrors the IDL NullifierSpent struct.
+ */
+export type NullifierSpentEvent = {
+    nullifier: Uint8Array;
+    timestamp: number;
+    mintAddress: PublicKey;
+    treeId: number;
+    txSignature: string;
+    slot: number;
+};
+/**
+ * Fetch and parse CommitmentEvents for a program, optionally filtered by mint.
+ *
+ * @param program     - Anchor program instance
+ * @param mintAddress - Filter to a specific pool; omit to get all pools
+ * @param before      - Start paging before this signature (exclusive)
+ * @param until       - Stop paging at this signature (exclusive)
+ * @param limit       - Max signatures to fetch per page (default 1000)
+ */
+export declare function scanCommitmentEvents<T extends Idl>(params: {
+    program: Program<T>;
+    mintAddress?: PublicKey;
+    before?: string;
+    until?: string;
+    limit?: number;
+}): Promise<CommitmentEvent[]>;
+/**
+ * Fetch and parse NullifierSpent events for a program, optionally filtered by mint.
+ */
+export declare function scanNullifierEvents<T extends Idl>(params: {
+    program: Program<T>;
+    mintAddress?: PublicKey;
+    before?: string;
+    until?: string;
+    limit?: number;
+}): Promise<NullifierSpentEvent[]>;
+/**
+ * Rebuild a local MerkleTree from on-chain CommitmentEvents.
+ * Use this to get a valid inclusion proof for spending any UTXO.
+ *
+ * CommitmentEvents are sorted by (treeId, leafIndex) so the local tree
+ * matches the on-chain state exactly.
+ *
+ * @param program     - Anchor program instance
+ * @param mintAddress - Pool to reconstruct
+ * @param treeId      - Which tree to reconstruct (default 0)
+ * @param depth       - Merkle tree depth (default 22, must match on-chain)
+ */
+export declare function buildTreeFromEvents<T extends Idl>(params: {
+    program: Program<T>;
+    mintAddress: PublicKey;
+    treeId?: number;
+    depth?: number;
+}): Promise<{
+    tree: MerkleTree;
+    events: CommitmentEvent[];
+    latestSignature?: string;
+}>;

package/dist/cjs/events.js

@@ -0,0 +1,167 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommitmentEvents = scanCommitmentEvents;
+exports.scanNullifierEvents = scanNullifierEvents;
+exports.buildTreeFromEvents = buildTreeFromEvents;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const merkle_1 = require("./merkle");
+// -----------------------------------------------------------------------------
+// Event Scanning
+// -----------------------------------------------------------------------------
+/**
+ * Fetch and parse CommitmentEvents for a program, optionally filtered by mint.
+ *
+ * @param program     - Anchor program instance
+ * @param mintAddress - Filter to a specific pool; omit to get all pools
+ * @param before      - Start paging before this signature (exclusive)
+ * @param until       - Stop paging at this signature (exclusive)
+ * @param limit       - Max signatures to fetch per page (default 1000)
+ */
+async function scanCommitmentEvents(params) {
+    const { program, mintAddress, before, until, limit = 1000 } = params;
+    const out = [];
+    const eventParser = new anchor.EventParser(program.programId, new anchor.BorshCoder(program.idl));
+    const sigs = await program.provider.connection.getSignaturesForAddress(program.programId, { before, until, limit });
+    for (const sigInfo of sigs) {
+        if (sigInfo.err)
+            continue;
+        const tx = await program.provider.connection.getTransaction(sigInfo.signature, { commitment: "confirmed", maxSupportedTransactionVersion: 0 });
+        if (!tx)
+            continue;
+        const events = Array.from(eventParser.parseLogs(tx.meta?.logMessages ?? []));
+        for (const ev of events) {
+            if (ev.name !== "commitmentEvent")
+                continue;
+            const d = ev.data;
+            const evMint = d.mintAddress;
+            if (mintAddress && !evMint.equals(mintAddress))
+                continue;
+            out.push({
+                commitment: new Uint8Array(d.commitment),
+                leafIndex: Number(d.leafIndex),
+                newRoot: new Uint8Array(d.newRoot),
+                timestamp: Number(d.timestamp),
+                mintAddress: evMint,
+                treeId: Number(d.treeId),
+                txSignature: sigInfo.signature,
+                slot: sigInfo.slot,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Fetch and parse NullifierSpent events for a program, optionally filtered by mint.
+ */
+async function scanNullifierEvents(params) {
+    const { program, mintAddress, before, until, limit = 1000 } = params;
+    const out = [];
+    const eventParser = new anchor.EventParser(program.programId, new anchor.BorshCoder(program.idl));
+    const sigs = await program.provider.connection.getSignaturesForAddress(program.programId, { before, until, limit });
+    for (const sigInfo of sigs) {
+        if (sigInfo.err)
+            continue;
+        const tx = await program.provider.connection.getTransaction(sigInfo.signature, { commitment: "confirmed", maxSupportedTransactionVersion: 0 });
+        if (!tx)
+            continue;
+        const events = Array.from(eventParser.parseLogs(tx.meta?.logMessages ?? []));
+        for (const ev of events) {
+            if (ev.name !== "nullifierSpent")
+                continue;
+            const d = ev.data;
+            const evMint = d.mintAddress;
+            if (mintAddress && !evMint.equals(mintAddress))
+                continue;
+            out.push({
+                nullifier: new Uint8Array(d.nullifier),
+                timestamp: Number(d.timestamp),
+                mintAddress: evMint,
+                treeId: Number(d.treeId),
+                txSignature: sigInfo.signature,
+                slot: sigInfo.slot,
+            });
+        }
+    }
+    return out;
+}
+// -----------------------------------------------------------------------------
+// Tree Reconstruction
+// -----------------------------------------------------------------------------
+/**
+ * Rebuild a local MerkleTree from on-chain CommitmentEvents.
+ * Use this to get a valid inclusion proof for spending any UTXO.
+ *
+ * CommitmentEvents are sorted by (treeId, leafIndex) so the local tree
+ * matches the on-chain state exactly.
+ *
+ * @param program     - Anchor program instance
+ * @param mintAddress - Pool to reconstruct
+ * @param treeId      - Which tree to reconstruct (default 0)
+ * @param depth       - Merkle tree depth (default 22, must match on-chain)
+ */
+async function buildTreeFromEvents(params) {
+    const { program, mintAddress, treeId = 0, depth = 22 } = params;
+    // Fetch all commitment events for this pool (page until no more results).
+    // Oldest-first so we insert leaves in the correct order.
+    const allEvents = [];
+    let before;
+    while (true) {
+        const page = await scanCommitmentEvents({
+            program,
+            mintAddress,
+            before,
+            limit: 1000,
+        });
+        if (page.length === 0)
+            break;
+        allEvents.push(...page);
+        before = page[page.length - 1].txSignature;
+        if (page.length < 1000)
+            break;
+    }
+    // Keep only events for this treeId, sort by leafIndex ascending
+    const treeEvents = allEvents
+        .filter((e) => e.treeId === treeId)
+        .sort((a, b) => a.leafIndex - b.leafIndex);
+    const tree = new merkle_1.MerkleTree(depth);
+    for (const ev of treeEvents) {
+        tree.insert(ev.commitment);
+    }
+    const latestSignature = treeEvents.length > 0
+        ? treeEvents[treeEvents.length - 1].txSignature
+        : undefined;
+    return { tree, events: treeEvents, latestSignature };
+}