@veilo/sdk-core 0.1.17 → 0.4.0

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./client.js";
+export * from "./utxo.js";
+export * from "./config.js";
+export * from "./merkle.js";
+export * from "./proof.js";
+export * from "./events.js";
+export { createVeiloProgram, createReadonlyVeiloProgram, PRIVACY_POOL_IDL, PRIVACY_POOL_PROGRAM_ID, } from "./program.js";
+export * from "./shield/index.js";
+export { createTransactionProver, verifyProof } from "./prover.js";
+export type { CircuitArtifacts } from "./prover.js";
+export * from "./compactNote.js";
+export { randomBytes, randomBytes32 } from "./random.js";
+export * from "./relayer.js";
+export { withRpcRetry, DEFAULT_RPC_RETRY } from "./retry.js";
+export type { RpcRetryPolicy } from "./retry.js";
+export { initPoseidon, getPoseidon, BN254_FR_MODULUS, bytesToBigIntBE, bigIntToBytesBE, frToBigInt, poseidon1, poseidon2, poseidon3, poseidon4, pubkeyToField, } from "./poseidon.js";

package/dist/src/index.js

@@ -0,0 +1,67 @@
+"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 });
+exports.pubkeyToField = exports.poseidon4 = exports.poseidon3 = exports.poseidon2 = exports.poseidon1 = exports.frToBigInt = exports.bigIntToBytesBE = exports.bytesToBigIntBE = exports.BN254_FR_MODULUS = exports.getPoseidon = exports.initPoseidon = exports.DEFAULT_RPC_RETRY = exports.withRpcRetry = exports.randomBytes32 = exports.randomBytes = exports.verifyProof = exports.createTransactionProver = exports.PRIVACY_POOL_PROGRAM_ID = exports.PRIVACY_POOL_IDL = exports.createReadonlyVeiloProgram = exports.createVeiloProgram = void 0;
+// Core client functions
+__exportStar(require("./client.js"), exports);
+// UTXO types and functions (replaces note.ts)
+__exportStar(require("./utxo.js"), exports);
+// Configuration constants and types
+__exportStar(require("./config.js"), exports);
+// Merkle tree implementation
+__exportStar(require("./merkle.js"), exports);
+// Proof types and helpers
+__exportStar(require("./proof.js"), exports);
+// On-chain event scanning and tree reconstruction
+__exportStar(require("./events.js"), exports);
+// Program factory and IDL
+var program_js_1 = require("./program.js");
+Object.defineProperty(exports, "createVeiloProgram", { enumerable: true, get: function () { return program_js_1.createVeiloProgram; } });
+Object.defineProperty(exports, "createReadonlyVeiloProgram", { enumerable: true, get: function () { return program_js_1.createReadonlyVeiloProgram; } });
+Object.defineProperty(exports, "PRIVACY_POOL_IDL", { enumerable: true, get: function () { return program_js_1.PRIVACY_POOL_IDL; } });
+Object.defineProperty(exports, "PRIVACY_POOL_PROGRAM_ID", { enumerable: true, get: function () { return program_js_1.PRIVACY_POOL_PROGRAM_ID; } });
+// Wallet-agnostic shielding — build an unsigned deposit for any external wallet
+__exportStar(require("./shield/index.js"), exports);
+// Proof generation (requires snarkjs peer dependency)
+var prover_js_1 = require("./prover.js");
+Object.defineProperty(exports, "createTransactionProver", { enumerable: true, get: function () { return prover_js_1.createTransactionProver; } });
+Object.defineProperty(exports, "verifyProof", { enumerable: true, get: function () { return prover_js_1.verifyProof; } });
+// Compact note ciphers — the on-chain payload that makes notes recoverable
+// from chain data alone, without any relayer involvement.
+__exportStar(require("./compactNote.js"), exports);
+// Cross-platform CSPRNG (no node:crypto import — safe in browser bundles)
+var random_js_1 = require("./random.js");
+Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function () { return random_js_1.randomBytes; } });
+Object.defineProperty(exports, "randomBytes32", { enumerable: true, get: function () { return random_js_1.randomBytes32; } });
+// Relayer API client
+__exportStar(require("./relayer.js"), exports);
+// RPC retry / resilience
+var retry_js_1 = require("./retry.js");
+Object.defineProperty(exports, "withRpcRetry", { enumerable: true, get: function () { return retry_js_1.withRpcRetry; } });
+Object.defineProperty(exports, "DEFAULT_RPC_RETRY", { enumerable: true, get: function () { return retry_js_1.DEFAULT_RPC_RETRY; } });
+// Poseidon hash functions
+var poseidon_js_1 = require("./poseidon.js");
+Object.defineProperty(exports, "initPoseidon", { enumerable: true, get: function () { return poseidon_js_1.initPoseidon; } });
+Object.defineProperty(exports, "getPoseidon", { enumerable: true, get: function () { return poseidon_js_1.getPoseidon; } });
+Object.defineProperty(exports, "BN254_FR_MODULUS", { enumerable: true, get: function () { return poseidon_js_1.BN254_FR_MODULUS; } });
+Object.defineProperty(exports, "bytesToBigIntBE", { enumerable: true, get: function () { return poseidon_js_1.bytesToBigIntBE; } });
+Object.defineProperty(exports, "bigIntToBytesBE", { enumerable: true, get: function () { return poseidon_js_1.bigIntToBytesBE; } });
+Object.defineProperty(exports, "frToBigInt", { enumerable: true, get: function () { return poseidon_js_1.frToBigInt; } });
+Object.defineProperty(exports, "poseidon1", { enumerable: true, get: function () { return poseidon_js_1.poseidon1; } });
+Object.defineProperty(exports, "poseidon2", { enumerable: true, get: function () { return poseidon_js_1.poseidon2; } });
+Object.defineProperty(exports, "poseidon3", { enumerable: true, get: function () { return poseidon_js_1.poseidon3; } });
+Object.defineProperty(exports, "poseidon4", { enumerable: true, get: function () { return poseidon_js_1.poseidon4; } });
+Object.defineProperty(exports, "pubkeyToField", { enumerable: true, get: function () { return poseidon_js_1.pubkeyToField; } });

package/dist/src/merkle.d.ts

@@ -0,0 +1,77 @@
+export type MerklePath = {
+    /** Index of the leaf in the tree (0-based) */
+    leafIndex: number;
+    /** Sibling hashes from leaf level up to (but not including) the root */
+    path: Uint8Array[];
+    /**
+     * 0 = current node is left child, sibling is right
+     * 1 = current node is right child, sibling is left
+     * (matches your Circom `pathIndices` semantics)
+     */
+    indices: number[];
+};
+/**
+ * Circuit-compatible Merkle path format.
+ * The pathIndex is used directly (circuit converts to bits internally via Num2Bits).
+ */
+export type CircuitMerklePath = {
+    /** Leaf index (circuit converts to bits internally) */
+    pathIndex: number;
+    /** Sibling hashes as field elements */
+    pathElements: bigint[];
+};
+export type Bytes32 = Uint8Array;
+/**
+ * Fixed-depth binary Merkle tree over BN254 Fr:
+ * - Leaves and internal nodes are 32-byte big-endian Fr elements.
+ * - Hash is Poseidon(2)(left, right).
+ * - Unfilled leaves use the Poseidon zero chain:
+ *     zero[0] = 0
+ *     zero[i+1] = Poseidon(zero[i], zero[i])
+ *
+ * Depth must match:
+ *   - Circom WithdrawCircuit(depth)
+ *   - Rust MERKLE_TREE_HEIGHT
+ */
+export declare class MerkleTree {
+    readonly depth: number;
+    readonly zeroes: Uint8Array[];
+    readonly layers: Uint8Array[][];
+    nextIndex: number;
+    constructor(depth?: number);
+    get capacity(): number;
+    get root(): Uint8Array;
+    /**
+     * Insert a leaf and recompute the path up to the root.
+     * Returns the leaf index and the new root.
+     */
+    insert(leaf: Uint8Array): {
+        index: number;
+        root: Uint8Array;
+    };
+    /**
+     * Return Merkle proof (path + indices) for a given leaf index.
+     * This feeds directly into the Circom `MerklePathVerifier(depth)`:
+     *  - `pathElements[i]` = sibling
+     *  - `pathIndices[i]`  = 0/1 as defined above
+     */
+    getPath(index: number): MerklePath;
+    /**
+     * Return Merkle proof in circuit-compatible format.
+     * The circuit uses pathIndex directly and converts to bits via Num2Bits(levels).
+     */
+    getCircuitPath(index: number): CircuitMerklePath;
+}
+/**
+ * The Poseidon zero chain: `z[0] = 0`, `z[i+1] = Poseidon(z[i], z[i])`.
+ *
+ * This is the `zeroes` array a `MerkleTree` builds in its constructor, without
+ * the tree. Deposits need a Merkle path for their dummy inputs, but the circuit
+ * disables the path check when a input amount is zero (`enabled <== 1 - IsZero(amount)`
+ * in transaction.circom), so the values are never constrained — only their
+ * count is.
+ *
+ * Allocating a full depth-22 `MerkleTree` for this costs ~130 MB and several
+ * seconds. This costs 22 hashes. Any deposit-shaped transaction should use it.
+ */
+export declare function poseidonZeroChain(depth?: number): Uint8Array[];

package/dist/src/merkle.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleTree = void 0;
+exports.poseidonZeroChain = poseidonZeroChain;
+const poseidon_js_1 = require("./poseidon.js");
+// Poseidon-based hash of two 32-byte field elements.
+function hashPair(left, right) {
+    if (left.length !== 32 || right.length !== 32) {
+        throw new Error("hashPair expects 32-byte inputs");
+    }
+    const poseidon = (0, poseidon_js_1.getPoseidon)();
+    const lf = (0, poseidon_js_1.bytesToBigIntBE)(left) % poseidon_js_1.BN254_FR_MODULUS;
+    const rf = (0, poseidon_js_1.bytesToBigIntBE)(right) % poseidon_js_1.BN254_FR_MODULUS;
+    const fe = poseidon([lf, rf]);
+    const outBig = (0, poseidon_js_1.frToBigInt)(fe) % poseidon_js_1.BN254_FR_MODULUS;
+    return (0, poseidon_js_1.bigIntToBytesBE)(outBig);
+}
+/**
+ * Fixed-depth binary Merkle tree over BN254 Fr:
+ * - Leaves and internal nodes are 32-byte big-endian Fr elements.
+ * - Hash is Poseidon(2)(left, right).
+ * - Unfilled leaves use the Poseidon zero chain:
+ *     zero[0] = 0
+ *     zero[i+1] = Poseidon(zero[i], zero[i])
+ *
+ * Depth must match:
+ *   - Circom WithdrawCircuit(depth)
+ *   - Rust MERKLE_TREE_HEIGHT
+ */
+class MerkleTree {
+    constructor(depth = 22) {
+        this.depth = depth;
+        this.zeroes = [];
+        this.layers = [];
+        // zero[0] = 0 (Fr), then zero[i+1] = Poseidon(zero[i], zero[i])
+        let zero = (0, poseidon_js_1.bigIntToBytesBE)(0n);
+        this.zeroes.push(zero);
+        for (let level = 1; level <= depth; level++) {
+            zero = hashPair(zero, zero);
+            this.zeroes.push(zero);
+        }
+        // Allocate layers:
+        //  level 0: 2^depth leaves
+        //  level 1: 2^(depth-1) parents
+        //  ...
+        //  level depth: 1 root
+        for (let level = 0; level <= depth; level++) {
+            const size = 1 << (depth - level);
+            if (!Number.isSafeInteger(size) || size <= 0) {
+                throw new Error(`Invalid MerkleTree depth=${depth}, level=${level}, size=${size}`);
+            }
+            const arr = new Array(size);
+            for (let i = 0; i < size; i++) {
+                arr[i] = this.zeroes[level];
+            }
+            this.layers.push(arr);
+        }
+        this.nextIndex = 0;
+    }
+    get capacity() {
+        return 1 << this.depth;
+    }
+    get root() {
+        return this.layers[this.depth][0];
+    }
+    /**
+     * Insert a leaf and recompute the path up to the root.
+     * Returns the leaf index and the new root.
+     */
+    insert(leaf) {
+        if (leaf.length !== 32) {
+            throw new Error("leaf must be 32 bytes");
+        }
+        const index = this.nextIndex;
+        if (index >= this.capacity) {
+            throw new Error("Merkle tree is full");
+        }
+        // Set leaf
+        this.layers[0][index] = leaf;
+        // Bubble up
+        let idx = index;
+        for (let level = 1; level <= this.depth; level++) {
+            const parentIndex = Math.floor(idx / 2);
+            const leftIndex = parentIndex * 2;
+            const rightIndex = leftIndex + 1;
+            const left = this.layers[level - 1][leftIndex];
+            const right = rightIndex < this.layers[level - 1].length
+                ? this.layers[level - 1][rightIndex]
+                : this.zeroes[level - 1];
+            this.layers[level][parentIndex] = hashPair(left, right);
+            idx = parentIndex;
+        }
+        this.nextIndex++;
+        return { index, root: this.root };
+    }
+    /**
+     * Return Merkle proof (path + indices) for a given leaf index.
+     * This feeds directly into the Circom `MerklePathVerifier(depth)`:
+     *  - `pathElements[i]` = sibling
+     *  - `pathIndices[i]`  = 0/1 as defined above
+     */
+    getPath(index) {
+        if (index < 0 || index >= this.capacity) {
+            throw new Error("index out of range");
+        }
+        const path = [];
+        const indices = [];
+        let idx = index;
+        for (let level = 0; level < this.depth; level++) {
+            const isRight = idx % 2 === 1;
+            const siblingIndex = isRight ? idx - 1 : idx + 1;
+            const sibling = siblingIndex < this.layers[level].length
+                ? this.layers[level][siblingIndex]
+                : this.zeroes[level];
+            path.push(sibling);
+            // 0 = current is left, 1 = current is right
+            indices.push(isRight ? 1 : 0);
+            idx = Math.floor(idx / 2);
+        }
+        return { leafIndex: index, path, indices };
+    }
+    /**
+     * Return Merkle proof in circuit-compatible format.
+     * The circuit uses pathIndex directly and converts to bits via Num2Bits(levels).
+     */
+    getCircuitPath(index) {
+        const merklePath = this.getPath(index);
+        return {
+            pathIndex: index,
+            pathElements: merklePath.path.map((p) => (0, poseidon_js_1.bytesToBigIntBE)(p) % poseidon_js_1.BN254_FR_MODULUS),
+        };
+    }
+}
+exports.MerkleTree = MerkleTree;
+/**
+ * The Poseidon zero chain: `z[0] = 0`, `z[i+1] = Poseidon(z[i], z[i])`.
+ *
+ * This is the `zeroes` array a `MerkleTree` builds in its constructor, without
+ * the tree. Deposits need a Merkle path for their dummy inputs, but the circuit
+ * disables the path check when a input amount is zero (`enabled <== 1 - IsZero(amount)`
+ * in transaction.circom), so the values are never constrained — only their
+ * count is.
+ *
+ * Allocating a full depth-22 `MerkleTree` for this costs ~130 MB and several
+ * seconds. This costs 22 hashes. Any deposit-shaped transaction should use it.
+ */
+function poseidonZeroChain(depth = 22) {
+    const zeroes = [];
+    let zero = (0, poseidon_js_1.bigIntToBytesBE)(0n);
+    zeroes.push(zero);
+    for (let level = 1; level <= depth; level++) {
+        zero = hashPair(zero, zero);
+        zeroes.push(zero);
+    }
+    return zeroes;
+}

package/dist/src/poseidon.d.ts

@@ -0,0 +1,29 @@
+import { PublicKey } from "@solana/web3.js";
+/** Poseidon hash function type from circomlibjs. */
+export type PoseidonFn = ((inputs: bigint[]) => any) & {
+    F: {
+        toObject: (e: any) => bigint;
+    };
+};
+/** Initialize the Poseidon hash instance. Must be called once before using any UTXO/merkle/proof helpers. */
+export declare function initPoseidon(): Promise<void>;
+/** Get the initialized Poseidon instance. Throws if `initPoseidon()` has not been called. */
+export declare function getPoseidon(): PoseidonFn;
+/** The BN254 (alt_bn128) scalar field modulus. All Poseidon outputs are reduced modulo this value. */
+export declare const BN254_FR_MODULUS: bigint;
+/** Convert a big-endian byte array to a bigint. */
+export declare function bytesToBigIntBE(bytes: Uint8Array): bigint;
+/** Convert a bigint to a 32-byte big-endian array. */
+export declare function bigIntToBytesBE(x: bigint): Uint8Array;
+/** Convert ffjavascript field element → bigint safely */
+export declare function frToBigInt(fe: any): bigint;
+/** Poseidon hash with 1 input - used for keypair derivation: pubkey = Poseidon(privateKey) */
+export declare function poseidon1(a: bigint): bigint;
+/** Poseidon hash with 2 inputs */
+export declare function poseidon2(a: bigint, b: bigint): bigint;
+/** Poseidon hash with 3 inputs - used for signature: Poseidon(privateKey, commitment, pathIndex) */
+export declare function poseidon3(a: bigint, b: bigint, c: bigint): bigint;
+/** Poseidon hash with 4 inputs - used for UTXO commitment: Poseidon(amount, pubkey, blinding, mintAddress) */
+export declare function poseidon4(a: bigint, b: bigint, c: bigint, d: bigint): bigint;
+/** Convert a Solana PublicKey to a BN254 field element */
+export declare function pubkeyToField(pubkey: PublicKey): bigint;

package/dist/src/poseidon.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BN254_FR_MODULUS = void 0;
+exports.initPoseidon = initPoseidon;
+exports.getPoseidon = getPoseidon;
+exports.bytesToBigIntBE = bytesToBigIntBE;
+exports.bigIntToBytesBE = bigIntToBytesBE;
+exports.frToBigInt = frToBigInt;
+exports.poseidon1 = poseidon1;
+exports.poseidon2 = poseidon2;
+exports.poseidon3 = poseidon3;
+exports.poseidon4 = poseidon4;
+exports.pubkeyToField = pubkeyToField;
+const circomlibjs_1 = require("circomlibjs");
+let poseidonInstance = null;
+/** Initialize the Poseidon hash instance. Must be called once before using any UTXO/merkle/proof helpers. */
+async function initPoseidon() {
+    poseidonInstance = (await (0, circomlibjs_1.buildPoseidonReference)());
+}
+/** Get the initialized Poseidon instance. Throws if `initPoseidon()` has not been called. */
+function getPoseidon() {
+    if (!poseidonInstance) {
+        throw new Error("Poseidon not initialized. Call initPoseidon() once before using utxo/merkle/proof helpers.");
+    }
+    return poseidonInstance;
+}
+/** The BN254 (alt_bn128) scalar field modulus. All Poseidon outputs are reduced modulo this value. */
+exports.BN254_FR_MODULUS = BigInt("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+/** Convert a big-endian byte array to a bigint. */
+function bytesToBigIntBE(bytes) {
+    let x = 0n;
+    for (const b of bytes) {
+        x = (x << 8n) | BigInt(b);
+    }
+    return x;
+}
+/** Convert a bigint to a 32-byte big-endian array. */
+function bigIntToBytesBE(x) {
+    const out = new Uint8Array(32);
+    let v = x;
+    for (let i = 31; i >= 0; i--) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+/** Convert ffjavascript field element → bigint safely */
+function frToBigInt(fe) {
+    const poseidon = getPoseidon();
+    const F = poseidon.F;
+    if (typeof fe === "bigint") {
+        return fe;
+    }
+    if (F && typeof F.toObject === "function") {
+        // This is how ffjavascript exposes the underlying BigInt
+        return F.toObject(fe);
+    }
+    // Fallback: treat as decimal string
+    return BigInt(fe.toString());
+}
+// -----------------------------------------------------------------------------
+// Helper functions for variable-arity Poseidon hashing
+// -----------------------------------------------------------------------------
+/** Poseidon hash with 1 input - used for keypair derivation: pubkey = Poseidon(privateKey) */
+function poseidon1(a) {
+    const poseidon = getPoseidon();
+    const fe = poseidon([a % exports.BN254_FR_MODULUS]);
+    return frToBigInt(fe) % exports.BN254_FR_MODULUS;
+}
+/** Poseidon hash with 2 inputs */
+function poseidon2(a, b) {
+    const poseidon = getPoseidon();
+    const fe = poseidon([a % exports.BN254_FR_MODULUS, b % exports.BN254_FR_MODULUS]);
+    return frToBigInt(fe) % exports.BN254_FR_MODULUS;
+}
+/** Poseidon hash with 3 inputs - used for signature: Poseidon(privateKey, commitment, pathIndex) */
+function poseidon3(a, b, c) {
+    const poseidon = getPoseidon();
+    const fe = poseidon([
+        a % exports.BN254_FR_MODULUS,
+        b % exports.BN254_FR_MODULUS,
+        c % exports.BN254_FR_MODULUS,
+    ]);
+    return frToBigInt(fe) % exports.BN254_FR_MODULUS;
+}
+/** Poseidon hash with 4 inputs - used for UTXO commitment: Poseidon(amount, pubkey, blinding, mintAddress) */
+function poseidon4(a, b, c, d) {
+    const poseidon = getPoseidon();
+    const fe = poseidon([
+        a % exports.BN254_FR_MODULUS,
+        b % exports.BN254_FR_MODULUS,
+        c % exports.BN254_FR_MODULUS,
+        d % exports.BN254_FR_MODULUS,
+    ]);
+    return frToBigInt(fe) % exports.BN254_FR_MODULUS;
+}
+/** Convert a Solana PublicKey to a BN254 field element */
+function pubkeyToField(pubkey) {
+    return bytesToBigIntBE(pubkey.toBytes()) % exports.BN254_FR_MODULUS;
+}

package/dist/src/program.d.ts

@@ -0,0 +1,37 @@
+import { Program, Idl, Wallet } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare const PRIVACY_POOL_IDL: Idl;
+/** Deployed program ID extracted from the bundled IDL. */
+export declare const PRIVACY_POOL_PROGRAM_ID: PublicKey;
+/**
+ * Create an Anchor `Program` instance for the Veilo Privacy Pool.
+ *
+ * @param connection  Solana RPC connection
+ * @param wallet      Anchor-compatible wallet (must implement `publicKey` and `signTransaction`)
+ * @param opts        Optional commitment level (default: "confirmed")
+ *
+ * @example
+ * ```ts
+ * import { createVeiloProgram } from "@veilo/sdk-core";
+ * import { Connection } from "@solana/web3.js";
+ *
+ * const program = createVeiloProgram(
+ *   new Connection("https://api.devnet.solana.com"),
+ *   wallet,
+ * );
+ * ```
+ */
+export declare function createVeiloProgram(connection: Connection, wallet: Wallet, opts?: {
+    commitment?: "processed" | "confirmed" | "finalized";
+}): Program;
+/**
+ * Create a `Program` for reading on-chain accounts, with no wallet.
+ *
+ * The shield path never signs, so requiring a `Wallet` just to decode a
+ * `MerkleTreeAccount` would force integrators to invent a dummy one. This is
+ * safe for `program.account.*.fetch` and the coders; anything that would submit
+ * a transaction will fail, which is the intent.
+ */
+export declare function createReadonlyVeiloProgram(connection: Connection, opts?: {
+    commitment?: "processed" | "confirmed" | "finalized";
+}): Program;

package/dist/src/program.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIVACY_POOL_PROGRAM_ID = exports.PRIVACY_POOL_IDL = void 0;
+exports.createVeiloProgram = createVeiloProgram;
+exports.createReadonlyVeiloProgram = createReadonlyVeiloProgram;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const privacy_pool_js_1 = __importDefault(require("./idl/privacy_pool.js"));
+// Re-export so consumers can access the raw IDL if needed
+exports.PRIVACY_POOL_IDL = privacy_pool_js_1.default;
+/** Deployed program ID extracted from the bundled IDL. */
+exports.PRIVACY_POOL_PROGRAM_ID = new web3_js_1.PublicKey(privacy_pool_js_1.default.address);
+/**
+ * Create an Anchor `Program` instance for the Veilo Privacy Pool.
+ *
+ * @param connection  Solana RPC connection
+ * @param wallet      Anchor-compatible wallet (must implement `publicKey` and `signTransaction`)
+ * @param opts        Optional commitment level (default: "confirmed")
+ *
+ * @example
+ * ```ts
+ * import { createVeiloProgram } from "@veilo/sdk-core";
+ * import { Connection } from "@solana/web3.js";
+ *
+ * const program = createVeiloProgram(
+ *   new Connection("https://api.devnet.solana.com"),
+ *   wallet,
+ * );
+ * ```
+ */
+function createVeiloProgram(connection, wallet, opts) {
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {
+        commitment: opts?.commitment ?? "confirmed",
+    });
+    return new anchor_1.Program(exports.PRIVACY_POOL_IDL, provider);
+}
+/**
+ * Create a `Program` for reading on-chain accounts, with no wallet.
+ *
+ * The shield path never signs, so requiring a `Wallet` just to decode a
+ * `MerkleTreeAccount` would force integrators to invent a dummy one. This is
+ * safe for `program.account.*.fetch` and the coders; anything that would submit
+ * a transaction will fail, which is the intent.
+ */
+function createReadonlyVeiloProgram(connection, opts) {
+    const provider = new anchor_1.AnchorProvider(connection, 
+    // No signing surface: reads only.
+    {
+        publicKey: web3_js_1.PublicKey.default,
+        signTransaction: () => {
+            throw new Error("createReadonlyVeiloProgram: this program cannot sign");
+        },
+        signAllTransactions: () => {
+            throw new Error("createReadonlyVeiloProgram: this program cannot sign");
+        },
+    }, { commitment: opts?.commitment ?? "confirmed" });
+    return new anchor_1.Program(exports.PRIVACY_POOL_IDL, provider);
+}