testprivacycash-evm 1.2.0

package/dist/utils/remoteConfig.d.ts

@@ -0,0 +1,21 @@
+import { NetworkConfig, PrivacyToken } from './networkConfig.js';
+export interface FeeSnapshot {
+    id: string;
+    chain: 'eth';
+    feeRateBps: number;
+    validFrom: number;
+    expiresAt: number;
+    rentFeeUnits: Partial<Record<PrivacyToken, string>>;
+    rentFees?: Partial<Record<PrivacyToken, number>>;
+}
+export interface RemoteConfig {
+    prices: Partial<Record<PrivacyToken, number>>;
+    minimum_withdrawal: Record<PrivacyToken, number>;
+    minimum_deposit: Record<PrivacyToken, number>;
+    rent_fees: Record<PrivacyToken, number>;
+    fee_rate: number;
+    feeSnapshot?: FeeSnapshot | null;
+}
+export declare function getRemoteConfig(network?: NetworkConfig | number, options?: {
+    forceRefresh?: boolean;
+}): Promise<RemoteConfig>;

package/dist/utils/remoteConfig.js

@@ -0,0 +1,24 @@
+import { logger } from './logger.js';
+import { resolveNetwork } from './networkConfig.js';
+const CACHE_TTL_MS = 60 * 1000; // 1 minute
+const configCache = new Map();
+export async function getRemoteConfig(network, options) {
+    const net = resolveNetwork(network);
+    const now = Date.now();
+    const cached = configCache.get(net.chainId);
+    if (!options?.forceRefresh && cached && now < cached.expiresAt)
+        return cached.config;
+    if (!net.indexerUrl) {
+        throw new Error(`No indexer URL configured for chain ${net.chainId} (${net.chainKey})`);
+    }
+    const configUrl = new URL(`${net.indexerUrl.replace(/\/$/, '')}/config`);
+    configUrl.searchParams.set('chain', net.chainKey);
+    const res = await fetch(configUrl.toString());
+    if (!res.ok) {
+        throw new Error(`Failed to fetch remote config: HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    configCache.set(net.chainId, { config: data, expiresAt: now + CACHE_TTL_MS });
+    logger.debug('Remote config loaded successfully');
+    return data;
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,83 @@
+import { BigNumber, ethers } from 'ethers';
+import { NetworkConfig, PrivacyToken } from './networkConfig.js';
+import { Utxo } from './utxo.js';
+export declare const FIELD_SIZE: BigNumber;
+export declare function poseidonHash(items: any[]): BigNumber;
+export declare const poseidonHash2: (a: any, b: any) => BigNumber;
+/** Generate random number of specified byte length */
+export declare const randomBN: (nbytes?: number) => BigNumber;
+/** BigNumber to hex string of specified length */
+export declare function toFixedHex(number: any, length?: number): string;
+/** Convert value into buffer of specified byte length */
+export declare const toBuffer: (value: any, length: number) => Buffer<ArrayBuffer>;
+export declare function getProof({ inputs, outputs, extAmount, fee, recipient, feeRecipient, encryptionKey, keyBasePath, token, network }: {
+    inputs: Utxo[];
+    outputs: Utxo[];
+    extAmount: BigNumber;
+    fee: BigNumber;
+    recipient: string;
+    feeRecipient: string;
+    encryptionKey: Buffer;
+    keyBasePath: string;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+}): Promise<{
+    extData: {
+        recipient: string;
+        extAmount: string;
+        feeRecipient: string;
+        fee: string;
+        encryptedOutput1: string;
+        encryptedOutput2: string;
+    };
+    args: {
+        pA: string[];
+        pB: string[][];
+        pC: string[];
+        root: string;
+        inputNullifiers: string[];
+        outputCommitments: string[];
+        publicAmount: string;
+        extDataHash: string;
+    };
+}>;
+export declare function prepareTransaction({ inputs, outputs, fee, recipient, feeRecipient, encryptionKey, keyBasePath, token, network }: {
+    inputs?: Utxo[];
+    outputs?: Utxo[];
+    fee?: BigNumber;
+    recipient?: string;
+    feeRecipient?: string;
+    encryptionKey: Buffer;
+    keyBasePath: string;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+}): Promise<{
+    extData: {
+        recipient: string;
+        extAmount: string;
+        feeRecipient: string;
+        fee: string;
+        encryptedOutput1: string;
+        encryptedOutput2: string;
+    };
+    args: {
+        pA: string[];
+        pB: string[][];
+        pC: string[];
+        root: string;
+        inputNullifiers: string[];
+        outputCommitments: string[];
+        publicAmount: string;
+        extDataHash: string;
+    };
+}>;
+export declare function findUnspentUtxos({ address, etherPool, encryptionKey, keypair, start, token, network }: {
+    address: string;
+    etherPool: ethers.Contract;
+    encryptionKey: Buffer;
+    keypair: any;
+    start?: number;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+}): Promise<Utxo[]>;
+export declare function clearCache(address: string, token?: PrivacyToken, network?: NetworkConfig | number): Promise<void>;

package/dist/utils/utils.js

@@ -0,0 +1,275 @@
+import crypto from 'crypto';
+import { BigNumber, ethers } from 'ethers';
+import { poseidon1, poseidon2, poseidon3, poseidon4 } from 'poseidon-lite';
+import { UniversalStorage } from './db.js';
+import { logger } from './logger.js';
+import { getErc20TokenConfig, isNativeToken, resolveNetwork, resolvePrivacyToken } from './networkConfig.js';
+import { prove } from './prover.js';
+import { Utxo } from './utxo.js';
+const storageCache = new Map();
+/**
+ * Returns the local UTXO cache store for the given chain+token combination.
+ * Base keeps legacy store names ('evmProd', 'evmUsdcProd') to preserve existing caches.
+ * Ethereum and future chains use prefixed names ('eth_evmProd', 'eth_evmUsdtProd').
+ */
+function getStorage(token, net) {
+    getErc20TokenConfig(net, token);
+    const baseName = isNativeToken(net, token) ? 'evmProd' : token === 'usdc' ? 'evmUsdcProd' : 'evmUsdtProd';
+    const storeName = net.chainId === 8453 ? baseName : `${net.cachePrefix}_${baseName}`;
+    const key = `PrivacyCashDB_${storeName}`;
+    if (!storageCache.has(key)) {
+        storageCache.set(key, new UniversalStorage('PrivacyCashDB', storeName));
+    }
+    return storageCache.get(key);
+}
+export const FIELD_SIZE = BigNumber.from('21888242871839275222246405745257275088548364400416034343698204186575808495617');
+export function poseidonHash(items) {
+    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, b) => 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, length = 32) {
+    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, length) => Buffer.from(BigNumber.from(value)
+    .toHexString()
+    .slice(2)
+    .padStart(length * 2, '0'), 'hex');
+function getExtDataHash({ recipient, extAmount, feeRecipient, fee, encryptedOutput1, encryptedOutput2, }) {
+    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, token = 'eth', network, }) {
+    const net = resolveNetwork(network);
+    let inputMerklePathIndices = [];
+    let inputMerklePathElements = [];
+    // fetch /merkle/root from indexer url
+    const res = await fetch(`${net.indexerUrl}/merkle/root?token=${token}&chain=${net.chainKey}`);
+    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(`${net.indexerUrl}/commitment/`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ commitment: toFixedHex(input.getCommitment()), token, chain: net.chainKey }),
+            });
+            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, token, network, }) {
+    const net = resolveNetwork(network);
+    const resolvedToken = resolvePrivacyToken(net, token);
+    if (inputs.length > 2 || outputs.length > 2) {
+        throw new Error('Only 2 inputs and 2 outputs are supported');
+    }
+    // Derive mintAddress from actual UTXOs so dummy padding doesn't break circuit constraints
+    const effectiveMintAddress = inputs.find(u => u.amount.gt(0))?.mintAddress ??
+        outputs.find(u => u.amount.gt(0))?.mintAddress ??
+        BigNumber.from(0);
+    while (inputs.length < 2)
+        inputs.push(new Utxo({ mintAddress: effectiveMintAddress }));
+    while (outputs.length < 2)
+        outputs.push(new Utxo({ mintAddress: effectiveMintAddress }));
+    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,
+        token: resolvedToken,
+        network: net,
+    });
+    return { extData, args };
+}
+export async function findUnspentUtxos({ address, etherPool, encryptionKey, keypair, start = 0, token, network, }) {
+    const net = resolveNetwork(network);
+    const resolvedToken = resolvePrivacyToken(net, token);
+    const storage = getStorage(resolvedToken, net);
+    await storage.init();
+    const offsetKey = `offset_${address}`;
+    const knownKey = `keo_${address}`;
+    const cachedOffset = (await storage.get(offsetKey)) || start;
+    const cachedKnown = (await storage.get(knownKey)) || [];
+    let knownEncryptedOutputs = new Map();
+    const candidates = [];
+    // print number of knownEncryptedOutputs
+    logger.debug(`Cached offset: ${cachedOffset}`);
+    logger.debug(`Cached known encrypted outputs: ${cachedKnown.length}`);
+    // Process cached known encrypted outputs
+    for (const item of cachedKnown) {
+        knownEncryptedOutputs.set(item.index, item.encrypted);
+        try {
+            const utxo = Utxo.decrypt(encryptionKey, item.encrypted, item.index, keypair);
+            if (!utxo.amount.isZero()) {
+                utxo.index = item.index;
+                const nullifier = toFixedHex(utxo.getNullifier());
+                candidates.push({ utxo, nullifier });
+            }
+        }
+        catch {
+            // Decryption failed — this output belongs to someone else
+        }
+    }
+    let startIndex = cachedOffset;
+    const limit = 1000;
+    let hasMore = true;
+    while (hasMore) {
+        let url = `${net.indexerUrl}/get_encrypted?start=${startIndex}&end=${startIndex + limit}&token=${resolvedToken}&chain=${net.chainKey}`;
+        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, total } = data;
+        logger.info(`decrypting utxo ${startIndex}/${total}`);
+        if (encrypted_outputs && encrypted_outputs.length > 0) {
+            encrypted_outputs.forEach((encryptedOutput, i) => {
+                const index = (realStart ?? startIndex) + i;
+                if (!knownEncryptedOutputs.has(index)) {
+                    try {
+                        const utxo = Utxo.decrypt(encryptionKey, encryptedOutput, index, keypair);
+                        if (!utxo.amount.isZero()) {
+                            knownEncryptedOutputs.set(index, encryptedOutput);
+                            utxo.index = index;
+                            const nullifier = toFixedHex(utxo.getNullifier());
+                            candidates.push({ utxo, nullifier });
+                        }
+                    }
+                    catch {
+                        // Decryption failed — this output belongs to someone else
+                    }
+                }
+            });
+        }
+        hasMore = more;
+        startIndex += encrypted_outputs.length;
+    }
+    // Cache the updated offset and known encrypted outputs
+    await storage.set(offsetKey, startIndex);
+    await storage.set(knownKey, Array.from(knownEncryptedOutputs.entries()).map(([index, encrypted]) => ({ encrypted, index })));
+    // log candidates length
+    logger.debug(`Found ${candidates.length} candidate UTXOs, checking which are unspent...`);
+    const unspent = [];
+    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);
+        try {
+            const spentFlags = await etherPool.isSpentArray(nullifiers);
+            for (let j = 0; j < chunk.length; j++) {
+                if (!spentFlags[j]) {
+                    unspent.push(chunk[j].utxo);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to check spent status of UTXOs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return unspent;
+}
+export async function clearCache(address, token, network) {
+    const net = resolveNetwork(network);
+    const resolvedToken = resolvePrivacyToken(net, token);
+    const storage = getStorage(resolvedToken, net);
+    await storage.init();
+    await storage.set(`offset_${address}`, 0);
+    await storage.set(`keo_${address}`, []);
+}

package/dist/utils/utxo.d.ts

@@ -0,0 +1,20 @@
+import { BigNumber } from 'ethers';
+import { Keypair } from './keypair.js';
+export declare class Utxo {
+    amount: BigNumber;
+    blinding: BigNumber;
+    keypair: Keypair;
+    index: number | null;
+    mintAddress: BigNumber;
+    constructor({ amount, keypair, blinding, index, mintAddress }?: {
+        amount?: any;
+        keypair?: Keypair;
+        blinding?: any;
+        index?: number | null;
+        mintAddress?: any;
+    });
+    getCommitment(): BigNumber;
+    getNullifier(): BigNumber;
+    encrypt(encryptionKey: Buffer): string;
+    static decrypt(encryptionKey: Buffer, data: string, index: number, keypair: Keypair): Utxo;
+}

package/dist/utils/utxo.js

@@ -0,0 +1,55 @@
+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 {
+    amount;
+    blinding;
+    keypair;
+    index;
+    mintAddress;
+    constructor({ amount = 0, keypair = new Keypair(), blinding = randomBN(), index = null, mintAddress = DUMMY_MINT, } = {}) {
+        this.amount = BigNumber.from(amount);
+        this.blinding = BigNumber.from(blinding);
+        this.keypair = keypair;
+        this.index = index;
+        this.mintAddress = BigNumber.from(mintAddress);
+    }
+    getCommitment() {
+        return poseidonHash([this.amount, this.keypair.pubkey, this.blinding, this.mintAddress]);
+    }
+    getNullifier() {
+        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) {
+        const utxoString = `${this.amount.toString()}|${this.blinding.toString()}|${this.index || 0}|${this.mintAddress.toString()}`;
+        return encrypt(utxoString, encryptionKey);
+    }
+    static decrypt(encryptionKey, data, index, keypair) {
+        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),
+        });
+    }
+}

package/dist/withdraw.d.ts

@@ -0,0 +1,12 @@
+import { NetworkConfig, PrivacyToken } from './utils/networkConfig.js';
+import type { FeeSnapshot } from './utils/remoteConfig.js';
+export declare function withdraw({ withdrawAmountInput, recipient, keyBasePath, signature, address, token, network, feeSnapshot }: {
+    withdrawAmountInput: number;
+    recipient: string;
+    keyBasePath: string;
+    signature: string;
+    address: string;
+    token?: PrivacyToken;
+    network?: NetworkConfig | number;
+    feeSnapshot?: FeeSnapshot | null;
+}): Promise<any>;