@veilo/sdk-core 0.1.17 → 0.3.3

package/dist/esm/config.js

@@ -0,0 +1,51 @@
+import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+/** Default relayer fee in basis points (50 = 0.5%). */
+export const DEFAULT_FEE_BPS = 50;
+/** Merkle tree depth - matches on-chain MerkleTreeAccount subtrees array size */
+export const MERKLE_TREE_DEPTH = 22;
+/** Root history size - matches on-chain MerkleTreeAccount root_history array size */
+export const ROOT_HISTORY_SIZE = 256;
+/** Native SOL mint address (Pubkey::default() = all zeros) */
+export const NATIVE_SOL_MINT = PublicKey.default;
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+/** Convert SOL to lamports (e.g. `sol(1.5)` → `1_500_000_000n`). */
+export function sol(n) {
+    return BigInt(n * 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
+ */
+export 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
+ */
+export 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/esm/events.js

@@ -0,0 +1,129 @@
+import * as anchor from "@coral-xyz/anchor";
+import { MerkleTree } from "./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)
+ */
+export 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.
+ */
+export 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)
+ */
+export 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 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 };
+}