@veilo/sdk-core 0.1.17 → 0.4.0

package/src/merkle.ts

@@ -1,178 +0,0 @@
-// sdk-core/src/merkle.ts
-import {
-	BN254_FR_MODULUS,
-	bytesToBigIntBE,
-	bigIntToBytesBE,
-} from "./note";
-import {
-	getPoseidon,
-	frToBigInt,
-} from "./poseidon";
-
-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[];
-};
-
-export type Bytes32 = Uint8Array;
-
-// Poseidon-based hash of two 32-byte field elements.
-function hashPair(left: Bytes32, right: Bytes32): Bytes32 {
-	if (left.length !== 32 || right.length !== 32) {
-		throw new Error("hashPair expects 32-byte inputs");
-	}
-
-	const poseidon = getPoseidon();
-
-	const lf = bytesToBigIntBE(left) % BN254_FR_MODULUS;
-	const rf = bytesToBigIntBE(right) % BN254_FR_MODULUS;
-
-	const fe = poseidon([lf, rf]);
-	const outBig = frToBigInt(fe) % BN254_FR_MODULUS;
-
-	return 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
- */
-export class MerkleTree {
-	readonly depth: number;
-	readonly zeroes: Uint8Array[];
-	readonly layers: Uint8Array[][];
-	nextIndex: number;
-
-	constructor(depth = 16) {
-		this.depth = depth;
-		this.zeroes = [];
-		this.layers = [];
-
-		// zero[0] = 0 (Fr), then zero[i+1] = Poseidon(zero[i], zero[i])
-		let zero = 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: Uint8Array[] = new Array(size);
-			for (let i = 0; i < size; i++) {
-				arr[i] = this.zeroes[level];
-			}
-			this.layers.push(arr);
-		}
-
-		this.nextIndex = 0;
-	}
-
-	get capacity(): number {
-		return 1 << this.depth;
-	}
-
-	get root(): Uint8Array {
-		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: Uint8Array): { index: number; root: Uint8Array } {
-		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: number): MerklePath {
-		if (index < 0 || index >= this.capacity) {
-			throw new Error("index out of range");
-		}
-
-		const path: Uint8Array[] = [];
-		const indices: number[] = [];
-
-		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 };
-	}
-}

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);
-	});
-});