@veilo/sdk-core 0.1.17 → 0.3.3

package/src/note.ts

@@ -1,193 +0,0 @@
-// sdk-core/src/note.ts
-import { PublicKey } from "@solana/web3.js";
-import {
-  createCipheriv,
-  createDecipheriv,
-  createHash,
-  randomBytes,
-} from "crypto";
-import { frToBigInt, getPoseidon } from "./poseidon";
-
-export type Note = {
-  value: bigint; // u64 on-chain, bigint off-chain
-  owner: PublicKey; // owner public key (later: spend key)
-  rho: Uint8Array; // 32 bytes random
-  r: Uint8Array; // 32 bytes random blinding
-};
-
-export type SerializedNote = {
-  value: bigint;
-  owner: PublicKey;
-  rho: Uint8Array;
-  r: Uint8Array;
-  commitment: Uint8Array; // 32 bytes, BN254 Fr element
-};
-
-export type EncryptedNotePlaintext = {
-  secret: Uint8Array; // 32 bytes
-  nullifier: Uint8Array; // 32 bytes
-  denomIndex: number; // 1 byte
-};
-
-export function encodeEncryptedNote(note: EncryptedNotePlaintext): Uint8Array {
-  const buf = new Uint8Array(32 + 32 + 1);
-  buf.set(note.secret, 0);
-  buf.set(note.nullifier, 32);
-  buf[64] = note.denomIndex;
-  return buf;
-}
-
-// Decode back
-export function decodeEncryptedNote(buf: Uint8Array): EncryptedNotePlaintext {
-  return {
-    secret: buf.slice(0, 32),
-    nullifier: buf.slice(32, 64),
-    denomIndex: buf[64],
-  };
-}
-
-export function encryptNote(
-  plaintext: EncryptedNotePlaintext,
-  sharedKey: Uint8Array // 32 bytes symmetric key (derived from recipient pubkey)
-): Uint8Array {
-  const iv = randomBytes(12); // ChaCha20/Poly1305 nonce
-  const cipher = createCipheriv("chacha20-poly1305", sharedKey, iv, {
-    authTagLength: 16,
-  });
-  const encoded = encodeEncryptedNote(plaintext);
-  const encrypted = Buffer.concat([cipher.update(encoded), cipher.final()]);
-  const authTag = cipher.getAuthTag();
-
-  // Return iv + ciphertext + tag
-  return Buffer.concat([iv, encrypted, authTag]);
-}
-
-export function decryptNote(
-  ciphertext: Uint8Array,
-  sharedKey: Uint8Array
-): EncryptedNotePlaintext {
-  const iv = ciphertext.slice(0, 12);
-  const authTag = ciphertext.slice(ciphertext.length - 16);
-  const enc = ciphertext.slice(12, ciphertext.length - 16);
-
-  const decipher = createDecipheriv("chacha20-poly1305", sharedKey, iv, {
-    authTagLength: 16,
-  });
-  decipher.setAuthTag(authTag);
-  const decrypted = Buffer.concat([decipher.update(enc), decipher.final()]);
-
-  return decodeEncryptedNote(decrypted);
-}
-
-function createOwnerHint(pubkey: PublicKey): Uint8Array {
-  // Simple: hash of recipient encryption pubkey
-  return createHash("sha256").update(pubkey.toBytes()).digest();
-}
-
-// -----------------------------------------------------------------------------
-// BN254 scalar field helpers (shared with merkle/proof)
-// -----------------------------------------------------------------------------
-
-// Standard BN254 scalar field modulus (same Fr as circom / Groth16)
-export const BN254_FR_MODULUS = BigInt(
-  "21888242871839275222246405745257275088548364400416034343698204186575808495617"
-);
-
-export function bytesToBigIntBE(bytes: Uint8Array): bigint {
-  let x = 0n;
-  for (const b of bytes) {
-    x = (x << 8n) | BigInt(b);
-  }
-  return x;
-}
-
-export function bigIntToBytesBE(x: bigint): Uint8Array {
-  const out = new Uint8Array(32);
-  let v = x;
-  for (let i = 31; i >= 0; i--) {
-    out[i] = Number(v & 0xffn);
-    v >>= 8n;
-  }
-  return out;
-}
-
-// -----------------------------------------------------------------------------
-// Note construction
-// -----------------------------------------------------------------------------
-
-export function createRandomNote(params: {
-  value: bigint;
-  owner: PublicKey;
-}): Note {
-  return {
-    value: params.value,
-    owner: params.owner,
-    rho: new Uint8Array(randomBytes(32)),
-    r: new Uint8Array(randomBytes(32)),
-  };
-}
-
-/**
- * Optional helper: deterministic encoding of a note into bytes:
- *  value (8 bytes, LE) || owner (32 bytes) || rho (32) || r (32)
- * Kept for compatibility / debugging.
- */
-export function encodeNoteToBytes(note: Note): Uint8Array {
-  const valueBuf = Buffer.alloc(8);
-  valueBuf.writeBigUInt64LE(note.value);
-
-  const ownerBuf = note.owner.toBytes();
-  if (ownerBuf.length !== 32) {
-    throw new Error("Owner pubkey must be 32 bytes");
-  }
-  if (note.rho.length !== 32 || note.r.length !== 32) {
-    throw new Error("rho and r must be 32 bytes each");
-  }
-
-  return Buffer.concat([
-    valueBuf,
-    Buffer.from(ownerBuf),
-    Buffer.from(note.rho),
-    Buffer.from(note.r),
-  ]);
-}
-
-/**
- * Circom-compatible commitment:
- *   commitment = Poseidon(value, owner, rho, r)
- *
- * All arguments are reduced into BN254 Fr before hashing.
- * This must match your Circom `NoteCommitment` template.
- */
-export function commitNote(note: Note): Uint8Array {
-  const poseidon = getPoseidon();
-
-  const valueField = note.value % BN254_FR_MODULUS;
-
-  const ownerField = bytesToBigIntBE(note.owner.toBytes()) % BN254_FR_MODULUS;
-
-  const rhoField = bytesToBigIntBE(note.rho) % BN254_FR_MODULUS;
-
-  const rField = bytesToBigIntBE(note.r) % BN254_FR_MODULUS;
-
-  const fe = poseidon([valueField, ownerField, rhoField, rField]);
-  const outBig = frToBigInt(fe) % BN254_FR_MODULUS;
-
-  return bigIntToBytesBE(outBig);
-}
-
-/**
- * Convenience: build a random note and its Poseidon commitment.
- */
-export function createNoteWithCommitment(params: {
-  value: bigint;
-  owner: PublicKey;
-}): SerializedNote {
-  const note = createRandomNote(params);
-  const commitment = commitNote(note);
-
-  return {
-    ...note,
-    commitment,
-  };
-}

package/src/poseidon.ts

@@ -1,62 +0,0 @@
-// sdk-core/src/poseidon.ts
-import {buildPoseidonReference} from "circomlibjs";
-
-export type PoseidonFn = ((inputs: bigint[]) => any) & {
-	F: { toObject: (e: any) => bigint };
-};
-
-let poseidonInstance: PoseidonFn | null = null;
-
-export async function initPoseidon() {
-	poseidonInstance = (await buildPoseidonReference()) as PoseidonFn;
-}
-
-export function getPoseidon(): PoseidonFn {
-	if (!poseidonInstance) {
-		throw new Error(
-			"Poseidon not initialized. Call initPoseidon() once before using note/merkle/proof helpers."
-		);
-	}
-	return poseidonInstance;
-}
-
-// Helpers for BN254 field
-export const BN254_FR_MODULUS = BigInt(
-	"21888242871839275222246405745257275088548364400416034343698204186575808495617"
-);
-
-export function bytesToBigIntBE(bytes: Uint8Array): bigint {
-	let x = 0n;
-	for (const b of bytes) {
-		x = (x << 8n) | BigInt(b);
-	}
-	return x;
-}
-
-export function bigIntToBytesBE(x: bigint): Uint8Array {
-	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 */
-export function frToBigInt(fe: any): bigint {
-	const poseidon = getPoseidon();
-	const F = (poseidon as any).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) as bigint;
-	}
-
-	// Fallback: treat as decimal string
-	return BigInt(fe.toString());
-}

package/src/proof.ts

@@ -1,170 +0,0 @@
-// sdk-core/src/proof.ts
-import { PublicKey } from "@solana/web3.js";
-import {
-	SerializedNote,
-	BN254_FR_MODULUS,
-	bytesToBigIntBE,
-	bigIntToBytesBE,
-} from "./note";
-import { MerklePath } from "./merkle";
-import {frToBigInt, getPoseidon} from "./poseidon";
-
-// -----------------------------------------------------------------------------
-// Circuit inputs
-// -----------------------------------------------------------------------------
-
-export type WithdrawCircuitInputs = {
-	root: Uint8Array;
-	note: SerializedNote;
-	merklePath: MerklePath;
-	nullifier: Uint8Array;
-	denomIndex: number;
-	recipient: PublicKey;
-	relayer: PublicKey;
-	feeBps: number;
-};
-
-// -----------------------------------------------------------------------------
-// Nullifier helper – MUST match Circom:
-//   nullifier = Poseidon(owner, rho)
-// -----------------------------------------------------------------------------
-
-export function deriveNullifier(note: SerializedNote): Uint8Array {
-	const poseidon = getPoseidon();
-
-	const ownerField =
-		bytesToBigIntBE(note.owner.toBytes()) % BN254_FR_MODULUS;
-	const rhoField =
-		bytesToBigIntBE(note.rho) % BN254_FR_MODULUS;
-
-	const fe = poseidon([ownerField, rhoField]);
-	const outBig = frToBigInt(fe) % BN254_FR_MODULUS;
-
-	return bigIntToBytesBE(outBig);
-}
-
-// -----------------------------------------------------------------------------
-// Groth16 proof types & packing (shared with relayer & dapps)
-// -----------------------------------------------------------------------------
-
-// Shape of a Groth16 proof produced by snarkjs.groth16
-export type RawProof = {
-	pi_a: [string, string, string];
-	pi_b: [[string, string], [string, string], [string, string]];
-	pi_c: [string, string, string];
-	protocol: string;
-	curve: string;
-};
-
-/**
- * This matches the Rust struct:
- *
- *   pub struct WithdrawProof {
- *       pub proof_a: [u8; 64],
- *       pub proof_b: [u8; 128],
- *       pub proof_c: [u8; 64],
- *   }
- *
- * In Anchor TS, this is just an object with three number[] fields.
- */
-export type WithdrawProofStruct = {
-	proofA: number[]; // 64 bytes
-	proofB: number[]; // 128 bytes
-	proofC: number[]; // 64 bytes
-};
-
-// Builder now returns a RawProof (snarkjs output).
-export type ProofBuilder = (inputs: WithdrawCircuitInputs) => Promise<RawProof>;
-
-/**
- * Convert bigint -> 32-byte little-endian representation.
- * Used to pack proof coords into the 256-byte layout expected on-chain.
- */
-function bigintTo32BytesLE(x: bigint): Uint8Array {
-	const out = new Uint8Array(32);
-	let v = x;
-	for (let i = 0; i < 32; i++) {
-		out[i] = Number(v & 0xffn);
-		v >>= 8n;
-	}
-	return out;
-}
-
-/**
- * Turn a snarkjs Groth16 proof into 256 bytes:
- *   A(G1) | B(G2) | C(G1)
- * where:
- *   A = (ax, ay)
- *   B = (bx0, bx1; by0, by1)
- *   C = (cx, cy)
- *
- * Each field element is encoded as 32-byte LE.
- * We ignore the extra projective / z components snarkjs keeps.
- */
-export function packProofToBytes(proof: RawProof): Uint8Array {
-	const chunks: Uint8Array[] = [];
-
-	// A: [ax, ay, az]
-	const ax = BigInt(proof.pi_a[0]);
-	const ay = BigInt(proof.pi_a[1]);
-	chunks.push(bigintTo32BytesLE(ax), bigintTo32BytesLE(ay));
-
-	// B: [[bx0, bx1], [by0, by1], [bz0, bz1]]
-	// we only use x, y
-	const bx = proof.pi_b[0];
-	const by = proof.pi_b[1];
-
-	const bx0 = BigInt(bx[0]);
-	const bx1 = BigInt(bx[1]);
-	const by0 = BigInt(by[0]);
-	const by1 = BigInt(by[1]);
-
-	chunks.push(
-		bigintTo32BytesLE(bx0),
-		bigintTo32BytesLE(bx1),
-		bigintTo32BytesLE(by0),
-		bigintTo32BytesLE(by1),
-	);
-
-	// C: [cx, cy, cz]
-	const cx = BigInt(proof.pi_c[0]);
-	const cy = BigInt(proof.pi_c[1]);
-	chunks.push(bigintTo32BytesLE(cx), bigintTo32BytesLE(cy));
-
-	// Flatten into single Uint8Array (256 bytes)
-	const out = new Uint8Array(32 * (2 + 4 + 2)); // 256
-	let offset = 0;
-	for (const c of chunks) {
-		out.set(c, offset);
-		offset += c.length;
-	}
-	return out;
-}
-
-/**
- * Take a snarkjs proof and produce the JSON shape the Anchor program expects:
- *
- *   pub struct WithdrawProof {
- *       pub proof_a: [u8; 64],
- *       pub proof_b: [u8; 128],
- *       pub proof_c: [u8; 64],
- *   }
- */
-export function encodeSnarkjsProofToWithdrawProof(
-	proof: RawProof,
-): WithdrawProofStruct {
-	const full = packProofToBytes(proof);
-	if (full.length !== 256) {
-		throw new Error(`Expected 256 proof bytes, got ${full.length}`);
-	}
-
-	const proofA = full.slice(0, 64);
-	const proofB = full.slice(64, 192);
-	const proofC = full.slice(192, 256);
-
-	return {
-		proofA: Array.from(proofA),
-		proofB: Array.from(proofB),
-		proofC: Array.from(proofC),
-	};
-}

package/test-tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": ".",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true   // 👈 add this
-  },
-  "include": [
-    "src/**/*.ts",
-    "tests/**/*.test.ts"
-  ]
-}

package/tests/note.test.ts

@@ -1,50 +0,0 @@
-// tests/note.test.ts
-import "mocha";
-import { strict as assert } from "assert";
-import { Keypair } from "@solana/web3.js";
-import {
-	createRandomNote,
-	encodeNoteToBytes,
-	commitNote,
-	createNoteWithCommitment,
-} from "../src";
-
-describe("note helpers", () => {
-	it("creates a random note with correct sizes", () => {
-		const owner = Keypair.generate().publicKey;
-		const value = 123n;
-
-		const note = createRandomNote({ value, owner });
-
-		assert.equal(note.value, value);
-		assert.equal(note.owner.toBase58(), owner.toBase58());
-		assert.equal(note.rho.length, 32);
-		assert.equal(note.r.length, 32);
-	});
-
-	it("encodes and commits deterministically", () => {
-		const owner = Keypair.generate().publicKey;
-		const value = 42n;
-
-		const note1 = createRandomNote({ value, owner });
-		const note2 = { ...note1 };
-
-		const enc1 = encodeNoteToBytes(note1);
-		const enc2 = encodeNoteToBytes(note2);
-
-		assert.equal(enc1.length, enc2.length);
-		assert.equal(enc1.length, 8 + 32 + 32 + 32);
-
-		const c1 = commitNote(note1);
-		const c2 = commitNote(note2);
-
-		assert.equal(c1.length, 32);
-		assert.equal(Buffer.compare(Buffer.from(c1), Buffer.from(c2)), 0);
-	});
-
-	it("createNoteWithCommitment returns 32-byte commitment", () => {
-		const owner = Keypair.generate().publicKey;
-		const note = createNoteWithCommitment({ value: 10n, owner });
-		assert.equal(note.commitment.length, 32);
-	});
-});

package/tests/sdk.integration.test.ts

@@ -1,210 +0,0 @@
-import "mocha";
-import { strict as assert } from "assert";
-import * as anchor from "@coral-xyz/anchor";
-import type { Idl, Program } from "@coral-xyz/anchor";
-import {
-	Keypair,
-	LAMPORTS_PER_SOL,
-	PublicKey,
-} from "@solana/web3.js";
-import fs from "fs";
-import os from "os";
-import path from "path";
-
-import {
-	initializePool,
-	addRelayer,
-	getPoolPdas,
-	createNoteAndDeposit,
-	withdrawViaRelayer,
-	sol,
-} from "../src";
-
-// ---- IDL + Provider helpers ----
-
-function loadIdl(): Idl {
-	// NOTE: this path is relative to dist/tests at runtime
-	const idlPath = path.join(
-		__dirname,
-		"../../../privacy-pool/target/idl/privacy_pool.json"
-	);
-	const raw = fs.readFileSync(idlPath, "utf8");
-	return JSON.parse(raw);
-}
-
-function makeProvider(): anchor.AnchorProvider {
-	const url = process.env.ANCHOR_PROVIDER_URL ?? "http://127.0.0.1:8899";
-	const connection = new anchor.web3.Connection(url, "confirmed");
-
-	const keypairPath =
-		process.env.ANCHOR_WALLET ??
-		path.join(os.homedir(), ".config", "solana", "id.json");
-
-	const secret = JSON.parse(fs.readFileSync(keypairPath, "utf8"));
-	const kp = Keypair.fromSecretKey(Uint8Array.from(secret));
-	const wallet = new anchor.Wallet(kp);
-
-	return new anchor.AnchorProvider(connection, wallet, {
-		commitment: "confirmed",
-		preflightCommitment: "confirmed",
-	});
-}
-
-describe("privacy-pool SDK integration (Merkle v3, rolling root)", () => {
-	const provider = makeProvider();
-	anchor.setProvider(provider);
-
-	const idl = loadIdl();
-	const program = new anchor.Program(idl as Idl, provider) as Program<any>;
-	const wallet = provider.wallet as anchor.Wallet;
-
-	const connection = provider.connection;
-
-	// This MUST match what initializePool uses below.
-	const DENOM_INDEX = 0;
-	const DENOMS_LAMPORTS = [sol(1), sol(5)]; // 1 SOL, 5 SOL
-	const FEE_BPS = 50; // 0.5%
-
-	async function airdropAndConfirm(pubkey: PublicKey, lamports: number) {
-		const sig = await connection.requestAirdrop(pubkey, lamports);
-		await connection.confirmTransaction(sig, "confirmed");
-	}
-
-	it("initialize + deposit + withdraw via SDK", async () => {
-		const { config, vault, noteTree, nullifiers } = getPoolPdas(
-			program.programId
-		);
-
-		// 1) Make sure admin has SOL
-		await airdropAndConfirm(wallet.publicKey, 5 * LAMPORTS_PER_SOL);
-
-		// 2) Initialize pool if needed (idempotent-ish for localnet dev)
-		const existingConfig = await connection.getAccountInfo(config);
-		if (!existingConfig) {
-			await initializePool({
-				program,
-				admin: wallet,
-				denomsLamports: DENOMS_LAMPORTS,
-				feeBps: FEE_BPS,
-			});
-		} else {
-			console.log(
-				"Initialize skipped: config already exists on this cluster, continuing."
-			);
-		}
-
-		// Ground truth amounts come from what we passed into initializePool
-		const amountLamports = BigInt(DENOMS_LAMPORTS[DENOM_INDEX].toString());
-		const fee = (amountLamports * BigInt(FEE_BPS)) / 10_000n;
-		const toUser = amountLamports - fee;
-
-		// 3) Deposit one note via SDK helper
-		await createNoteAndDeposit({
-			program,
-			depositor: wallet,
-			denomIndex: DENOM_INDEX,
-			valueLamports: amountLamports,
-		});
-
-		// 4) Prepare relayer + recipient
-		const relayer = Keypair.generate();
-		const recipient = Keypair.generate();
-
-		await airdropAndConfirm(relayer.publicKey, 2 * LAMPORTS_PER_SOL);
-		await airdropAndConfirm(recipient.publicKey, 0.2 * LAMPORTS_PER_SOL);
-
-		// Admin adds relayer
-		await addRelayer({
-			program,
-			admin: wallet,
-			newRelayer: relayer.publicKey,
-		});
-
-		// 5) Fetch current Merkle root from NoteTree account.
-		const noteTreeAcc: any = await (program.account as any).noteTree.fetch(
-			noteTree
-		);
-
-		// Support all known shapes:
-		// - rolling history: { currentRootIndex, roots: number[][] }
-		// - single root (previous layout): { lastRoot: number[] }
-		// - current layout: { currentRoot: number[] }
-		let rootBytes: Uint8Array;
-
-		if (
-			noteTreeAcc &&
-			typeof noteTreeAcc.currentRootIndex !== "undefined" &&
-			typeof noteTreeAcc.roots !== "undefined"
-		) {
-			const idx: number = Number(noteTreeAcc.currentRootIndex);
-			const rootsArr: number[][] = noteTreeAcc.roots;
-			const rootArray: number[] = rootsArr[idx];
-			if (!rootArray) {
-				console.error("NoteTree account shape (roots):", noteTreeAcc);
-				throw new Error("NoteTree.roots[currentRootIndex] is undefined");
-			}
-			rootBytes = new Uint8Array(rootArray);
-		} else if (
-			noteTreeAcc &&
-			typeof noteTreeAcc.lastRoot !== "undefined"
-		) {
-			const rootArray: number[] = noteTreeAcc.lastRoot;
-			rootBytes = new Uint8Array(rootArray);
-		} else if (
-			noteTreeAcc &&
-			typeof noteTreeAcc.currentRoot !== "undefined"
-		) {
-			const rootArray: number[] = noteTreeAcc.currentRoot;
-			rootBytes = new Uint8Array(rootArray);
-		} else {
-			console.error("NoteTree account shape (unknown):", noteTreeAcc);
-			throw new Error("Unknown NoteTree layout in IDL / account");
-		}
-
-		const nullifier = new Uint8Array(32).fill(3); // demo nullifier
-
-		const beforeVault = BigInt(await connection.getBalance(vault));
-		const beforeRelayer = BigInt(
-			await connection.getBalance(relayer.publicKey)
-		);
-		const beforeRecipient = BigInt(
-			await connection.getBalance(recipient.publicKey)
-		);
-
-		// 6) Withdraw via SDK
-		await withdrawViaRelayer({
-			program,
-			relayer,
-			recipient: recipient.publicKey,
-			denomIndex: DENOM_INDEX,
-			root: rootBytes,
-			nullifier,
-		});
-
-		const afterVault = BigInt(await connection.getBalance(vault));
-		const afterRelayer = BigInt(
-			await connection.getBalance(relayer.publicKey)
-		);
-		const afterRecipient = BigInt(
-			await connection.getBalance(recipient.publicKey)
-		);
-
-		const vaultDelta = beforeVault - afterVault;
-		const relayerDelta = afterRelayer - beforeRelayer;
-		const recipientDelta = afterRecipient - beforeRecipient;
-
-		// 7) Assertions
-		assert(
-			vaultDelta === amountLamports,
-			`Vault did not decrease by amount: got ${vaultDelta.toString()} expected ${amountLamports.toString()}`
-		);
-		assert(
-			relayerDelta === fee,
-			`Relayer did not receive correct fee: got ${relayerDelta.toString()} expected ${fee.toString()}`
-		);
-		assert(
-			recipientDelta === toUser,
-			`Recipient did not receive correct amount: got ${recipientDelta.toString()} expected ${toUser.toString()}`
-		);
-	});
-});