privacycash 1.0.6

package/dist/utils/logger.js

@@ -0,0 +1,35 @@
+const defaultLogger = (level, message) => {
+    const prefix = `[${level.toUpperCase()}]`;
+    console.log(prefix, message);
+};
+let userLogger = defaultLogger;
+export function setLogger(logger) {
+    userLogger = logger;
+}
+function argToStr(args) {
+    return args.map(arg => {
+        if (typeof arg === "object" && arg !== null) {
+            try {
+                return JSON.stringify(arg);
+            }
+            catch {
+                return String(arg);
+            }
+        }
+        return String(arg);
+    }).join(" ");
+}
+export const logger = {
+    debug: (...args) => {
+        userLogger('debug', argToStr(args));
+    },
+    info: (...args) => {
+        userLogger('info', argToStr(args));
+    },
+    warn: (...args) => {
+        userLogger('warn', argToStr(args));
+    },
+    error: (...args) => {
+        userLogger('error', argToStr(args));
+    },
+};

package/dist/utils/merkle_tree.d.ts

@@ -0,0 +1,92 @@
+import * as hasher from '@lightprotocol/hasher.rs';
+export declare const DEFAULT_ZERO = 0;
+/**
+ * @callback hashFunction
+ * @param left Left leaf
+ * @param right Right leaf
+ */
+/**
+ * Merkle tree
+ */
+export declare class MerkleTree {
+    /**
+     * Constructor
+     * @param {number} levels Number of levels in the tree
+     * @param {Array} [elements] Initial elements
+     * @param {Object} options
+     * @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
+     * @param [options.zeroElement] Value for non-existent leaves
+     */
+    levels: number;
+    capacity: number;
+    zeroElement: string;
+    _zeros: string[];
+    _layers: string[][];
+    _lightWasm: hasher.LightWasm;
+    constructor(levels: number, lightWasm: hasher.LightWasm, elements?: string[], { zeroElement }?: {
+        zeroElement?: number | undefined;
+    });
+    _rebuild(): void;
+    /**
+     * Get tree root
+     * @returns {*}
+     */
+    root(): string;
+    /**
+     * Insert new element into the tree
+     * @param element Element to insert
+     */
+    insert(element: string): void;
+    /**
+     * Insert multiple elements into the tree. Tree will be fully rebuilt during this operation.
+     * @param {Array} elements Elements to insert
+     */
+    bulkInsert(elements: string[]): void;
+    /**
+     * Change an element in the tree
+     * @param {number} index Index of element to change
+     * @param element Updated element value
+     */
+    update(index: number, element: string): void;
+    /**
+     * Get merkle path to a leaf
+     * @param {number} index Leaf index to generate path for
+     * @returns {{pathElements: number[], pathIndex: number[]}} An object containing adjacent elements and left-right index
+     */
+    path(index: number): {
+        pathElements: string[];
+        pathIndices: number[];
+    };
+    /**
+     * Find an element in the tree
+     * @param element An element to find
+     * @param comparator A function that checks leaf value equality
+     * @returns {number} Index if element is found, otherwise -1
+     */
+    indexOf(element: string, comparator?: Function | null): number;
+    /**
+     * Returns a copy of non-zero tree elements
+     * @returns {Object[]}
+     */
+    elements(): string[];
+    /**
+     * Serialize entire tree state including intermediate layers into a plain object
+     * Deserializing it back will not require to recompute any hashes
+     * Elements are not converted to a plain type, this is responsibility of the caller
+     */
+    serialize(): {
+        levels: number;
+        _zeros: string[];
+        _layers: string[][];
+    };
+    /**
+     * Deserialize data into a MerkleTree instance
+     * Make sure to provide the same hashFunction as was used in the source tree,
+     * otherwise the tree state will be invalid
+     *
+     * @param data
+     * @param hashFunction
+     * @returns {MerkleTree}
+     */
+    static deserialize(data: any, hashFunction: Function): any;
+}

package/dist/utils/merkle_tree.js

@@ -0,0 +1,186 @@
+export const DEFAULT_ZERO = 0;
+/**
+ * @callback hashFunction
+ * @param left Left leaf
+ * @param right Right leaf
+ */
+/**
+ * Merkle tree
+ */
+export class MerkleTree {
+    /**
+     * Constructor
+     * @param {number} levels Number of levels in the tree
+     * @param {Array} [elements] Initial elements
+     * @param {Object} options
+     * @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
+     * @param [options.zeroElement] Value for non-existent leaves
+     */
+    levels;
+    capacity;
+    zeroElement;
+    _zeros;
+    _layers;
+    _lightWasm;
+    constructor(levels, lightWasm, elements = [], { zeroElement = DEFAULT_ZERO } = {}) {
+        this.levels = levels;
+        this.capacity = 2 ** levels;
+        this.zeroElement = zeroElement.toString();
+        this._lightWasm = lightWasm;
+        if (elements.length > this.capacity) {
+            throw new Error("Tree is full");
+        }
+        this._zeros = [];
+        this._layers = [];
+        this._layers[0] = elements;
+        this._zeros[0] = this.zeroElement;
+        for (let i = 1; i <= levels; i++) {
+            this._zeros[i] = this._lightWasm.poseidonHashString([
+                this._zeros[i - 1],
+                this._zeros[i - 1],
+            ]);
+        }
+        this._rebuild();
+    }
+    _rebuild() {
+        for (let level = 1; level <= this.levels; level++) {
+            this._layers[level] = [];
+            for (let i = 0; i < Math.ceil(this._layers[level - 1].length / 2); i++) {
+                this._layers[level][i] = this._lightWasm.poseidonHashString([
+                    this._layers[level - 1][i * 2],
+                    i * 2 + 1 < this._layers[level - 1].length
+                        ? this._layers[level - 1][i * 2 + 1]
+                        : this._zeros[level - 1],
+                ]);
+            }
+        }
+    }
+    /**
+     * Get tree root
+     * @returns {*}
+     */
+    root() {
+        return this._layers[this.levels].length > 0
+            ? this._layers[this.levels][0]
+            : this._zeros[this.levels];
+    }
+    /**
+     * Insert new element into the tree
+     * @param element Element to insert
+     */
+    insert(element) {
+        if (this._layers[0].length >= this.capacity) {
+            throw new Error("Tree is full");
+        }
+        this.update(this._layers[0].length, element);
+    }
+    /**
+     * Insert multiple elements into the tree. Tree will be fully rebuilt during this operation.
+     * @param {Array} elements Elements to insert
+     */
+    bulkInsert(elements) {
+        if (this._layers[0].length + elements.length > this.capacity) {
+            throw new Error("Tree is full");
+        }
+        this._layers[0].push(...elements);
+        this._rebuild();
+    }
+    // TODO: update does not work debug
+    /**
+     * Change an element in the tree
+     * @param {number} index Index of element to change
+     * @param element Updated element value
+     */
+    update(index, element) {
+        // index 0 and 1 and element is the commitment hash
+        if (isNaN(Number(index)) ||
+            index < 0 ||
+            index > this._layers[0].length ||
+            index >= this.capacity) {
+            throw new Error("Insert index out of bounds: " + index);
+        }
+        this._layers[0][index] = element;
+        for (let level = 1; level <= this.levels; level++) {
+            index >>= 1;
+            this._layers[level][index] = this._lightWasm.poseidonHashString([
+                this._layers[level - 1][index * 2],
+                index * 2 + 1 < this._layers[level - 1].length
+                    ? this._layers[level - 1][index * 2 + 1]
+                    : this._zeros[level - 1],
+            ]);
+        }
+    }
+    /**
+     * Get merkle path to a leaf
+     * @param {number} index Leaf index to generate path for
+     * @returns {{pathElements: number[], pathIndex: number[]}} An object containing adjacent elements and left-right index
+     */
+    path(index) {
+        if (isNaN(Number(index)) || index < 0 || index >= this._layers[0].length) {
+            throw new Error("Index out of bounds: " + index);
+        }
+        const pathElements = [];
+        const pathIndices = [];
+        for (let level = 0; level < this.levels; level++) {
+            pathIndices[level] = index % 2;
+            pathElements[level] =
+                (index ^ 1) < this._layers[level].length
+                    ? this._layers[level][index ^ 1]
+                    : this._zeros[level];
+            index >>= 1;
+        }
+        return {
+            pathElements,
+            pathIndices,
+        };
+    }
+    /**
+     * Find an element in the tree
+     * @param element An element to find
+     * @param comparator A function that checks leaf value equality
+     * @returns {number} Index if element is found, otherwise -1
+     */
+    indexOf(element, comparator = null) {
+        if (comparator) {
+            return this._layers[0].findIndex((el) => comparator(element, el));
+        }
+        else {
+            return this._layers[0].indexOf(element);
+        }
+    }
+    /**
+     * Returns a copy of non-zero tree elements
+     * @returns {Object[]}
+     */
+    elements() {
+        return this._layers[0].slice();
+    }
+    /**
+     * Serialize entire tree state including intermediate layers into a plain object
+     * Deserializing it back will not require to recompute any hashes
+     * Elements are not converted to a plain type, this is responsibility of the caller
+     */
+    serialize() {
+        return {
+            levels: this.levels,
+            _zeros: this._zeros,
+            _layers: this._layers,
+        };
+    }
+    /**
+     * Deserialize data into a MerkleTree instance
+     * Make sure to provide the same hashFunction as was used in the source tree,
+     * otherwise the tree state will be invalid
+     *
+     * @param data
+     * @param hashFunction
+     * @returns {MerkleTree}
+     */
+    static deserialize(data, hashFunction) {
+        const instance = Object.assign(Object.create(this.prototype), data);
+        instance._hash = hashFunction;
+        instance.capacity = 2 ** instance.levels;
+        instance.zeroElement = instance._zeros[0];
+        return instance;
+    }
+}

package/dist/utils/node-shim.d.ts

@@ -0,0 +1,5 @@
+import { LocalStorage } from "node-localstorage";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+export { LocalStorage, path, fs, fileURLToPath };

package/dist/utils/node-shim.js

@@ -0,0 +1,5 @@
+import { LocalStorage } from "node-localstorage";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+export { LocalStorage, path, fs, fileURLToPath };

package/dist/utils/prover.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ZK Proof Generation Utilities
+ *
+ * This file provides functions for generating zero-knowledge proofs for privacy-preserving
+ * transactions on Solana. It handles both snarkjs and zkutil proof generation workflows.
+ *
+ * Inspired by: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/prover.js
+ */
+interface Proof {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+    curve: string;
+}
+/**
+ * Generates a ZK proof using snarkjs and formats it for use on-chain
+ *
+ * @param input The circuit inputs to generate a proof for
+ * @param keyBasePath The base path for the circuit keys (.wasm and .zkey files)
+ * @returns A proof object with formatted proof elements and public signals
+ */
+declare function prove(input: any, keyBasePath: string): Promise<{
+    proof: Proof;
+    publicSignals: string[];
+}>;
+export declare function parseProofToBytesArray(proof: Proof, compressed?: boolean): {
+    proofA: number[];
+    proofB: number[][];
+    proofC: number[];
+};
+export declare function parseToBytesArray(publicSignals: string[]): number[][];
+export { prove, type Proof };

package/dist/utils/prover.js

@@ -0,0 +1,123 @@
+/**
+ * ZK Proof Generation Utilities
+ *
+ * This file provides functions for generating zero-knowledge proofs for privacy-preserving
+ * transactions on Solana. It handles both snarkjs and zkutil proof generation workflows.
+ *
+ * Inspired by: https://github.com/tornadocash/tornado-nova/blob/f9264eeffe48bf5e04e19d8086ee6ec58cdf0d9e/src/prover.js
+ */
+/// <reference types="node" />
+import * as anchor from "@coral-xyz/anchor";
+import { wtns, groth16 } from 'snarkjs';
+import { FIELD_SIZE } from './constants.js';
+// @ts-ignore - ignore TypeScript errors for ffjavascript
+import { utils } from 'ffjavascript';
+// Cast imported modules to their types
+const wtnsTyped = wtns;
+const groth16Typed = groth16;
+const utilsTyped = utils;
+/**
+ * Generates a ZK proof using snarkjs and formats it for use on-chain
+ *
+ * @param input The circuit inputs to generate a proof for
+ * @param keyBasePath The base path for the circuit keys (.wasm and .zkey files)
+ * @returns A proof object with formatted proof elements and public signals
+ */
+async function prove(input, keyBasePath) {
+    return await groth16Typed.fullProve(utilsTyped.stringifyBigInts(input), `${keyBasePath}.wasm`, `${keyBasePath}.zkey`);
+}
+export function parseProofToBytesArray(proof, compressed = false) {
+    const proofJson = JSON.stringify(proof, null, 1);
+    const mydata = JSON.parse(proofJson.toString());
+    try {
+        for (const i in mydata) {
+            if (i == "pi_a" || i == "pi_c") {
+                for (const j in mydata[i]) {
+                    mydata[i][j] = Array.from(utils.leInt2Buff(utils.unstringifyBigInts(mydata[i][j]), 32)).reverse();
+                }
+            }
+            else if (i == "pi_b") {
+                for (const j in mydata[i]) {
+                    for (const z in mydata[i][j]) {
+                        mydata[i][j][z] = Array.from(utils.leInt2Buff(utils.unstringifyBigInts(mydata[i][j][z]), 32));
+                    }
+                }
+            }
+        }
+        if (compressed) {
+            const proofA = mydata.pi_a[0];
+            // negate proof by reversing the bitmask
+            const proofAIsPositive = yElementIsPositiveG1(new anchor.BN(mydata.pi_a[1]))
+                ? false
+                : true;
+            proofA[0] = addBitmaskToByte(proofA[0], proofAIsPositive);
+            const proofB = mydata.pi_b[0].flat().reverse();
+            const proofBY = mydata.pi_b[1].flat().reverse();
+            const proofBIsPositive = yElementIsPositiveG2(new anchor.BN(proofBY.slice(0, 32)), new anchor.BN(proofBY.slice(32, 64)));
+            proofB[0] = addBitmaskToByte(proofB[0], proofBIsPositive);
+            const proofC = mydata.pi_c[0];
+            const proofCIsPositive = yElementIsPositiveG1(new anchor.BN(mydata.pi_c[1]));
+            proofC[0] = addBitmaskToByte(proofC[0], proofCIsPositive);
+            return {
+                proofA,
+                proofB,
+                proofC,
+            };
+        }
+        return {
+            proofA: [mydata.pi_a[0], mydata.pi_a[1]].flat(),
+            proofB: [
+                mydata.pi_b[0].flat().reverse(),
+                mydata.pi_b[1].flat().reverse(),
+            ].flat(),
+            proofC: [mydata.pi_c[0], mydata.pi_c[1]].flat(),
+        };
+    }
+    catch (error) {
+        console.error("Error while parsing the proof.", error.message);
+        throw error;
+    }
+}
+// mainly used to parse the public signals of groth16 fullProve
+export function parseToBytesArray(publicSignals) {
+    const publicInputsJson = JSON.stringify(publicSignals, null, 1);
+    const publicInputsBytesJson = JSON.parse(publicInputsJson.toString());
+    try {
+        const publicInputsBytes = new Array();
+        for (const i in publicInputsBytesJson) {
+            const ref = Array.from([
+                ...utils.leInt2Buff(utils.unstringifyBigInts(publicInputsBytesJson[i]), 32),
+            ]).reverse();
+            publicInputsBytes.push(ref);
+        }
+        return publicInputsBytes;
+    }
+    catch (error) {
+        console.error("Error while parsing public inputs.", error.message);
+        throw error;
+    }
+}
+function yElementIsPositiveG1(yElement) {
+    return yElement.lte(FIELD_SIZE.sub(yElement));
+}
+function yElementIsPositiveG2(yElement1, yElement2) {
+    const fieldMidpoint = FIELD_SIZE.div(new anchor.BN(2));
+    // Compare the first component of the y coordinate
+    if (yElement1.lt(fieldMidpoint)) {
+        return true;
+    }
+    else if (yElement1.gt(fieldMidpoint)) {
+        return false;
+    }
+    // If the first component is equal to the midpoint, compare the second component
+    return yElement2.lt(fieldMidpoint);
+}
+function addBitmaskToByte(byte, yIsPositive) {
+    if (!yIsPositive) {
+        return (byte |= 1 << 7);
+    }
+    else {
+        return byte;
+    }
+}
+export { prove };

package/dist/utils/utils.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Utility functions for ZK Cash
+ *
+ * Provides common utility functions for the ZK Cash system
+ * Based on: https://github.com/tornadocash/tornado-nova
+ */
+import BN from 'bn.js';
+import { Utxo } from '../models/utxo.js';
+import { PublicKey } from '@solana/web3.js';
+/**
+ * Calculate deposit fee based on deposit amount and fee rate
+ * @param depositAmount Amount being deposited in lamports
+ * @returns Fee amount in lamports
+ */
+export declare function calculateDepositFee(depositAmount: number): Promise<number>;
+/**
+ * Calculate withdrawal fee based on withdrawal amount and fee rate
+ * @param withdrawalAmount Amount being withdrawn in lamports
+ * @returns Fee amount in lamports
+ */
+export declare function calculateWithdrawalFee(withdrawalAmount: number): Promise<number>;
+/**
+ * Mock encryption function - in real implementation this would be proper encryption
+ * For testing, we just return a fixed prefix to ensure consistent extDataHash
+ * @param value Value to encrypt
+ * @returns Encrypted string representation
+ */
+export declare function mockEncrypt(value: Utxo): string;
+/**
+ * Calculates the hash of ext data using Borsh serialization
+ * @param extData External data object containing recipient, amount, encrypted outputs, fee, fee recipient, and mint address
+ * @returns The hash as a Uint8Array (32 bytes)
+ */
+export declare function getExtDataHash(extData: {
+    recipient: string | PublicKey;
+    extAmount: string | number | BN;
+    encryptedOutput1?: string | Uint8Array;
+    encryptedOutput2?: string | Uint8Array;
+    fee: string | number | BN;
+    feeRecipient: string | PublicKey;
+    mintAddress: string | PublicKey;
+}): Uint8Array;
+export declare function fetchMerkleProof(commitment: string): Promise<{
+    pathElements: string[];
+    pathIndices: number[];
+}>;
+export declare function findNullifierPDAs(proof: any): {
+    nullifier0PDA: PublicKey;
+    nullifier1PDA: PublicKey;
+};
+export declare function findCommitmentPDAs(proof: any): {
+    commitment0PDA: PublicKey;
+    commitment1PDA: PublicKey;
+};
+export declare function queryRemoteTreeState(): Promise<{
+    root: string;
+    nextIndex: number;
+}>;
+export declare function getProgramAccounts(): {
+    treeAccount: PublicKey;
+    treeTokenAccount: PublicKey;
+    globalConfigAccount: PublicKey;
+};
+export declare function findCrossCheckNullifierPDAs(proof: any): {
+    nullifier2PDA: PublicKey;
+    nullifier3PDA: PublicKey;
+};