bstest001 0.0.1

package/src/utils/constants.ts

@@ -0,0 +1,10 @@
+export let CONTRACT_ADDRESS = '0x51450B59ec2Bc26852415cB1047DF31772aD9cD5';
+export let FEE_RECIPIENT_ADDRESS = '0x44eb9939cfdE7C394f1632C6890191d695f0a3ce';
+export let INDEXER_URL = process.env.INDEXER_URL || 'https://basetest.privacycashapi.com';
+export let PRIVATE_KEY = process.env.PRIVATE_KEY || '';
+export let BASE_SEPOLIA_RPC = process.env.BASE_SEPOLIA_RPC || 'https://sepolia.base.org';
+
+export const RENT_FEE = 0.00025
+export const FEE_RATE = 35; // 0.35% (basis points out of 10000)
+
+export const SIGN_PRIVACY_MESSAGE = 'Privacy Money account sign in';

package/src/utils/encryption.ts

@@ -0,0 +1,40 @@
+import crypto from 'crypto';
+import { ethers } from 'ethers';
+import { Keypair } from './keypair.js';
+
+export function deriveKeys(signature: string) {
+    const encryptionKeyHex = ethers.utils.keccak256(signature);
+    const encryptionKey = Buffer.from(encryptionKeyHex.slice(2), 'hex');
+    const utxoPrivateKey = ethers.utils.keccak256(encryptionKey);
+    const keypair = new Keypair(utxoPrivateKey);
+    return { encryptionKey, utxoPrivateKey, keypair };
+}
+
+// export async function signMessage(signer: ethers.Signer) {
+//     const signature = await signer.signMessage(SIGN_IN_MESSAGe);
+//     return deriveKeys(signature);
+// }
+
+export function encrypt(data: string | Buffer, encryptionKey: Buffer): string {
+    const dataBuffer = typeof data === 'string' ? Buffer.from(data) : data;
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', encryptionKey as any, iv as any);
+    const encrypted = Buffer.concat([cipher.update(dataBuffer as any), cipher.final()] as any[]);
+    const authTag = cipher.getAuthTag();
+    const result = Buffer.concat([iv, authTag, encrypted] as any[]);
+    return '0x' + result.toString('hex');
+}
+
+export function decrypt(encryptedData: string | Buffer, encryptionKey: Buffer): Buffer {
+    const buf = typeof encryptedData === 'string'
+        ? Buffer.from(encryptedData.replace(/^0x/, ''), 'hex')
+        : (encryptedData as any);
+
+    const iv = buf.slice(0, 12);
+    const authTag = buf.slice(12, 28);
+    const data = buf.slice(28);
+
+    const decipher = crypto.createDecipheriv('aes-256-gcm', encryptionKey as any, iv as any);
+    decipher.setAuthTag(authTag as any);
+    return Buffer.concat([decipher.update(data as any), decipher.final()] as any[]);
+}

package/src/utils/keypair.ts

@@ -0,0 +1,24 @@
+import { BigNumber, ethers } from 'ethers';
+import { poseidonHash, toFixedHex } from './utils.js';
+
+export class Keypair {
+    public privkey: string;
+    public pubkey: BigNumber;
+
+    constructor(privkey: string = ethers.Wallet.createRandom().privateKey) {
+        this.privkey = privkey;
+        this.pubkey = poseidonHash([this.privkey]);
+    }
+
+    toString(): string {
+        return toFixedHex(this.pubkey);
+    }
+
+    address(): string {
+        return this.toString();
+    }
+
+    sign(commitment: any, merklePath: any): BigNumber {
+        return poseidonHash([this.privkey, commitment, merklePath]);
+    }
+}

package/src/utils/logger.ts

@@ -0,0 +1,42 @@
+// log level
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export type LoggerFn = (level: LogLevel, message: string) => void;
+
+const defaultLogger: LoggerFn = (level, message) => {
+    const prefix = `[${level.toUpperCase()}]`;
+    console.log(prefix, message);
+};
+
+let userLogger: LoggerFn = defaultLogger;
+
+export function setLogger(logger: LoggerFn) {
+    userLogger = logger;
+}
+
+function argToStr(args: unknown[]) {
+    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: unknown[]) => {
+        userLogger('debug', argToStr(args))
+    },
+    info: (...args: unknown[]) => {
+        userLogger('info', argToStr(args))
+    },
+    warn: (...args: unknown[]) => {
+        userLogger('warn', argToStr(args))
+    },
+    error: (...args: unknown[]) => {
+        userLogger('error', argToStr(args))
+    },
+}

package/src/utils/prover.ts

@@ -0,0 +1,82 @@
+import type { ExecFileOptions } from 'child_process';
+// @ts-ignore
+import { utils } from 'ffjavascript';
+import { toFixedHex } from './utils.js';
+
+/**
+ * Generates a Zero-Knowledge proof for a transaction.
+ * Supports both Node.js (via snarkjs CLI) and Web Browser (via snarkjs library).
+ */
+export async function prove(input: any, keyBasePath: string) {
+    // 1. Check environment
+    const isNode = typeof process !== 'undefined' && process.versions && (!!process.versions.node || !!process.versions.bun);
+
+    if (isNode) {
+        return await proveNode(input, keyBasePath);
+    } else {
+        return await proveBrowser(input, keyBasePath);
+    }
+}
+
+async function proveBrowser(input: any, keyBasePath: string) {
+    // @ts-ignore
+    const snarkjs = await import('snarkjs');
+
+    // In the browser, we use snarkjs.groth16.fullProve
+    const { proof } = await snarkjs.groth16.fullProve(
+        utils.stringifyBigInts(input),
+        `${keyBasePath}.wasm`,
+        `${keyBasePath}.zkey`
+    );
+
+    const pA = [toFixedHex(proof.pi_a[0]), toFixedHex(proof.pi_a[1])];
+    const pB = [
+        [toFixedHex(proof.pi_b[0][1]), toFixedHex(proof.pi_b[0][0])],
+        [toFixedHex(proof.pi_b[1][1]), toFixedHex(proof.pi_b[1][0])],
+    ];
+    const pC = [toFixedHex(proof.pi_c[0]), toFixedHex(proof.pi_c[1])];
+
+    return { pA, pB, pC };
+}
+
+async function proveNode(input: any, keyBasePath: string) {
+    const { execFile } = await import('child_process');
+    const { promises: fs } = await import('fs');
+    const os = (await import('os')).default;
+    const path = (await import('path')).default;
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'privacycash-proof-'));
+    const inputPath = path.join(tmpDir, 'input.json');
+    const proofPath = path.join(tmpDir, 'proof.json');
+    const publicPath = path.join(tmpDir, 'public.json');
+
+    try {
+        await fs.writeFile(inputPath, JSON.stringify(utils.stringifyBigInts(input)));
+
+        await execFileAsync(
+            path.resolve(process.cwd(), 'node_modules/.bin/snarkjs'),
+            ['groth16', 'fullprove', inputPath, `${keyBasePath}.wasm`, `${keyBasePath}.zkey`, proofPath, publicPath],
+            { maxBuffer: 1024 * 1024 * 10 } as ExecFileOptions,
+        );
+
+        const proofRaw = await fs.readFile(proofPath, 'utf8');
+        const proof = JSON.parse(proofRaw);
+
+        const pA = [toFixedHex(proof.pi_a[0]), toFixedHex(proof.pi_a[1])];
+        const pB = [
+            [toFixedHex(proof.pi_b[0][1]), toFixedHex(proof.pi_b[0][0])],
+            [toFixedHex(proof.pi_b[1][1]), toFixedHex(proof.pi_b[1][0])],
+        ];
+        const pC = [toFixedHex(proof.pi_c[0]), toFixedHex(proof.pi_c[1])];
+
+        return { pA, pB, pC };
+    } finally {
+        try {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        } catch (e) {
+            // ignore
+        }
+    }
+}

package/src/utils/utils.ts

@@ -0,0 +1,295 @@
+import crypto from 'crypto';
+import { BigNumber, ethers } from 'ethers';
+import { poseidon1, poseidon2, poseidon3, poseidon4 } from 'poseidon-lite';
+import { INDEXER_URL } from './constants.js';
+import { logger } from './logger.js';
+import { prove } from './prover.js';
+import { Utxo } from './utxo.js';
+
+export const FIELD_SIZE = BigNumber.from(
+    '21888242871839275222246405745257275088548364400416034343698204186575808495617',
+);
+
+export function poseidonHash(items: any[]): BigNumber {
+    if (items.length === 1) return BigNumber.from(poseidon1([items[0]]));
+    if (items.length === 2) return BigNumber.from(poseidon2([items[0], items[1]]));
+    if (items.length === 3) return BigNumber.from(poseidon3([items[0], items[1], items[2]]));
+    if (items.length === 4) return BigNumber.from(poseidon4([items[0], items[1], items[2], items[3]]));
+    throw new Error(`Unsupported poseidon input length: ${items.length}`);
+}
+
+export const poseidonHash2 = (a: any, b: any) => poseidonHash([a, b]);
+
+/** Generate random number of specified byte length */
+export const randomBN = (nbytes = 31) => BigNumber.from(crypto.randomBytes(nbytes));
+
+/** BigNumber to hex string of specified length */
+export function toFixedHex(number: any, length = 32): string {
+    let result =
+        '0x' +
+        (number instanceof Buffer
+            ? number.toString('hex')
+            : BigNumber.from(number).toHexString().replace('0x', '')
+        ).padStart(length * 2, '0');
+    if (result.indexOf('-') > -1) {
+        result = '-' + result.replace('-', '');
+    }
+    return result;
+}
+
+/** Convert value into buffer of specified byte length */
+export const toBuffer = (value: any, length: number) =>
+    Buffer.from(
+        BigNumber.from(value)
+            .toHexString()
+            .slice(2)
+            .padStart(length * 2, '0'),
+        'hex',
+    );
+
+export function getExtDataHash({
+    recipient,
+    extAmount,
+    relayer,
+    feeRecipient,
+    fee,
+    encryptedOutput1,
+    encryptedOutput2,
+}: {
+    recipient: any;
+    extAmount: any;
+    relayer?: any;
+    feeRecipient?: any;
+    fee: any;
+    encryptedOutput1: string;
+    encryptedOutput2: string;
+}): BigNumber {
+    const abi = new ethers.utils.AbiCoder();
+
+    const encodedData = abi.encode(
+        [
+            'tuple(address recipient,int256 extAmount,address feeRecipient,uint256 fee,bytes encryptedOutput1,bytes encryptedOutput2)',
+        ],
+        [
+            {
+                recipient: toFixedHex(recipient, 20),
+                extAmount: toFixedHex(extAmount),
+                feeRecipient,
+                fee: toFixedHex(fee),
+                encryptedOutput1: encryptedOutput1,
+                encryptedOutput2: encryptedOutput2,
+            },
+        ],
+    );
+    const hash = ethers.utils.keccak256(encodedData);
+    return BigNumber.from(hash).mod(FIELD_SIZE);
+}
+
+export async function getProof({
+    inputs,
+    outputs,
+    extAmount,
+    fee,
+    recipient,
+    feeRecipient,
+    encryptionKey,
+    keyBasePath,
+}: {
+    inputs: Utxo[];
+    outputs: Utxo[];
+    extAmount: BigNumber;
+    fee: BigNumber;
+    recipient: string;
+    feeRecipient: string;
+    encryptionKey: Buffer;
+    keyBasePath: string;
+}) {
+    let inputMerklePathIndices: number[] = [];
+    let inputMerklePathElements: any[] = [];
+
+    // fetch /merkle/root from indexer url
+    const res = await fetch(`${INDEXER_URL}/merkle/root`);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch merkle root: ${res.status} ${res.statusText}`);
+    }
+    const { root, nextIndex: initialNextIndex } = await res.json();
+    let nextIndex = initialNextIndex;
+
+    for (const input of inputs) {
+        if (input.amount.gt(0)) {
+            let res = await fetch(`${INDEXER_URL}/commitment/`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ commitment: toFixedHex(input.getCommitment()) }),
+            });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch commitment info`);
+            }
+            const { index, pathElements } = await res.json();
+            input.index = index;
+            if (input.index == null) {
+                throw new Error(`Input commitment ${toFixedHex(input.getCommitment())} was not found`);
+            }
+            inputMerklePathIndices.push(input.index);
+            inputMerklePathElements.push(pathElements);
+        } else {
+            inputMerklePathIndices.push(0);
+            inputMerklePathElements.push(new Array(26).fill(0));
+        }
+    }
+
+    // update nextIndex to outputs
+    for (let output of outputs) {
+        output.index = nextIndex++;
+    }
+    const extData = {
+        recipient,
+        extAmount: toFixedHex(extAmount),
+        feeRecipient,
+        fee: toFixedHex(fee),
+        encryptedOutput1: outputs[0].encrypt(encryptionKey),
+        encryptedOutput2: (outputs[1] || new Utxo()).encrypt(encryptionKey),
+    };
+
+    const extDataHash = getExtDataHash(extData);
+    let input = {
+        root,
+        inputNullifier: inputs.map((x) => x.getNullifier().toString()),
+        outputCommitment: outputs.map((x) => x.getCommitment().toString()),
+        publicAmount: BigNumber.from(extAmount).sub(fee).add(FIELD_SIZE).mod(FIELD_SIZE).toString(),
+        extDataHash: extDataHash.toString(),
+        mintAddress: inputs[0].mintAddress.toString(),
+
+        inAmount: inputs.map((x) => x.amount.toString()),
+        inPrivateKey: inputs.map((x) => x.keypair.privkey.toString()),
+        inBlinding: inputs.map((x) => x.blinding.toString()),
+        inPathIndices: inputMerklePathIndices,
+        inPathElements: inputMerklePathElements,
+
+        outAmount: outputs.map((x) => x.amount.toString()),
+        outBlinding: outputs.map((x) => x.blinding.toString()),
+        outPubkey: outputs.map((x) => x.keypair.pubkey.toString()),
+    };
+
+    const { pA, pB, pC } = await prove(input, `${keyBasePath}${inputs.length}`);
+
+    const args = {
+        pA,
+        pB,
+        pC,
+        root: toFixedHex(input.root),
+        inputNullifiers: inputs.map((x) => toFixedHex(x.getNullifier())),
+        outputCommitments: outputs.map((x) => toFixedHex(x.getCommitment())),
+        publicAmount: toFixedHex(input.publicAmount),
+        extDataHash: toFixedHex(extDataHash),
+    };
+
+    return { extData, args };
+}
+
+export async function prepareTransaction({
+    inputs = [],
+    outputs = [],
+    fee = BigNumber.from(0),
+    recipient = '0x44eb9939cfdE7C394f1632C6890191d695f0a3ce',
+    feeRecipient = '0x44eb9939cfdE7C394f1632C6890191d695f0a3ce',
+    encryptionKey,
+    keyBasePath,
+}: {
+    inputs?: Utxo[];
+    outputs?: Utxo[];
+    fee?: BigNumber;
+    recipient?: string;
+    feeRecipient?: string;
+    encryptionKey: Buffer;
+    keyBasePath: string;
+}) {
+    if (inputs.length > 2 || outputs.length > 2) {
+        throw new Error('Only 2 inputs and 2 outputs are supported');
+    }
+
+    while (inputs.length < 2) inputs.push(new Utxo());
+    while (outputs.length < 2) outputs.push(new Utxo());
+
+    let extAmount = outputs.reduce((sum, x) => sum.add(x.amount), BigNumber.from(0))
+        .sub(inputs.reduce((sum, x) => sum.add(x.amount), BigNumber.from(0)))
+        .add(fee);
+
+    const { extData, args } = await getProof({
+        inputs,
+        outputs,
+        extAmount,
+        fee,
+        recipient,
+        feeRecipient,
+        encryptionKey,
+        keyBasePath,
+    });
+
+    return { extData, args };
+}
+
+export async function findUnspentUtxos({
+    etherPool,
+    encryptionKey,
+    keypair,
+}: {
+    etherPool: ethers.Contract;
+    encryptionKey: Buffer;
+    keypair: any;
+}) {
+    let start = 0
+    const limit = 1000
+    let hasMore = true
+    const candidates: { utxo: Utxo; nullifier: string }[] = []
+
+    while (hasMore) {
+        let url = `${INDEXER_URL}/get_encrypted?start=${start}&end=${start + limit}`
+        logger.debug(`Fetching encrypted UTXOs from indexer: ${url}`)
+        const res = await fetch(url)
+        if (!res.ok) {
+            throw new Error(`Failed to fetch encrypted UTXOs: ${res.statusText}`)
+        }
+        const data = await res.json()
+        const { encrypted_outputs, hasMore: more, start: realStart } = data
+
+        if (encrypted_outputs && encrypted_outputs.length > 0) {
+            encrypted_outputs.forEach((encryptedOutput: string, i: number) => {
+                const index = (realStart ?? start) + i
+                try {
+                    const utxo = Utxo.decrypt(encryptionKey, encryptedOutput, Number(index), keypair)
+                    if (!utxo.amount.isZero()) {
+                        utxo.index = index
+                        const nullifier = toFixedHex(utxo.getNullifier())
+                        candidates.push({ utxo, nullifier })
+                    }
+                } catch {
+                    // Decryption failed — this output belongs to someone else
+                }
+            })
+        }
+
+        hasMore = more
+        start += limit
+    }
+
+    // log candidates length
+    logger.debug(`Found ${candidates.length} candidate UTXOs, checking which are unspent...`)
+
+    const unspent: Utxo[] = []
+    const spentCheckChunkSize = 256
+
+    for (let i = 0; i < candidates.length; i += spentCheckChunkSize) {
+        const chunk = candidates.slice(i, i + spentCheckChunkSize)
+        const nullifiers = chunk.map((x) => x.nullifier)
+        const spentFlags: boolean[] = await etherPool.isSpentArray(nullifiers)
+
+        for (let j = 0; j < chunk.length; j++) {
+            if (!spentFlags[j]) {
+                unspent.push(chunk[j].utxo)
+            }
+        }
+    }
+
+    return unspent
+}

package/src/utils/utxo.ts

@@ -0,0 +1,74 @@
+import { BigNumber } from 'ethers';
+import { decrypt, encrypt } from './encryption.js';
+import { Keypair } from './keypair.js';
+import { poseidonHash, randomBN } from './utils.js';
+
+const DUMMY_MINT = BigNumber.from(0);
+
+export class Utxo {
+    public amount: BigNumber;
+    public blinding: BigNumber;
+    public keypair: Keypair;
+    public index: number | null;
+    public mintAddress: BigNumber;
+
+    constructor({
+        amount = 0,
+        keypair = new Keypair(),
+        blinding = randomBN(),
+        index = null,
+        mintAddress = DUMMY_MINT,
+    }: {
+        amount?: any;
+        keypair?: Keypair;
+        blinding?: any;
+        index?: number | null;
+        mintAddress?: any;
+    } = {}) {
+        this.amount = BigNumber.from(amount);
+        this.blinding = BigNumber.from(blinding);
+        this.keypair = keypair;
+        this.index = index;
+        this.mintAddress = BigNumber.from(mintAddress);
+    }
+
+    getCommitment(): BigNumber {
+        return poseidonHash([this.amount, this.keypair.pubkey, this.blinding, this.mintAddress]);
+    }
+
+    getNullifier(): BigNumber {
+        if (this.amount.gt(0)) {
+            if (this.index == null) {
+                throw new Error('Can not compute nullifier without utxo index');
+            }
+            if (this.keypair.privkey == null) {
+                throw new Error('Can not compute nullifier without utxo private key');
+            }
+        }
+        const commitment = this.getCommitment();
+        const idx = this.index || 0;
+        const signature = this.keypair.sign(commitment, idx);
+        return poseidonHash([commitment, idx, signature]);
+    }
+
+    encrypt(encryptionKey: Buffer): string {
+        const utxoString = `${this.amount.toString()}|${this.blinding.toString()}|${this.index || 0}|${this.mintAddress.toString()}`;
+        return encrypt(utxoString, encryptionKey);
+    }
+
+    static decrypt(encryptionKey: Buffer, data: string, index: number, keypair: Keypair): Utxo {
+        const decrypted = decrypt(data, encryptionKey);
+        const parts = decrypted.toString().split('|');
+        if (parts.length !== 4) {
+            throw new Error('Invalid UTXO format after decryption');
+        }
+        const [amount, blinding, , mintAddress] = parts;
+        return new Utxo({
+            amount: BigNumber.from(amount),
+            blinding: BigNumber.from(blinding),
+            keypair,
+            index,
+            mintAddress: BigNumber.from(mintAddress),
+        });
+    }
+}