testprivacycash-evm 1.2.0

package/dist/utils/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const CONTRACT_ADDRESS: string;
+export declare const FEE_RECIPIENT_ADDRESS: string;
+export declare const INDEXER_URL: string;
+export declare const BASE_SEPOLIA_RPC: string;
+export declare const SIGN_PRIVACY_MESSAGE = "Privacy Money account sign in";
+export declare const PRIVATE_USDC_CONTRACT_ADDRESS: string;
+export declare const USDC_CONTRACT_ADDRESS: string;
+export declare const USDC_DECIMALS = 6;

package/dist/utils/constants.js

@@ -0,0 +1,11 @@
+import { BASE_NETWORK } from './networkConfig.js';
+// Backward-compatible re-exports — all resolve to the Base network.
+// For multi-chain support, pass a `network` (NetworkConfig | chainId) to SDK functions.
+export const CONTRACT_ADDRESS = BASE_NETWORK.etherPoolAddress;
+export const FEE_RECIPIENT_ADDRESS = BASE_NETWORK.feeRecipientAddress;
+export const INDEXER_URL = BASE_NETWORK.indexerUrl;
+export const BASE_SEPOLIA_RPC = BASE_NETWORK.rpcUrl;
+export const SIGN_PRIVACY_MESSAGE = 'Privacy Money account sign in';
+export const PRIVATE_USDC_CONTRACT_ADDRESS = BASE_NETWORK.usdcPoolAddress;
+export const USDC_CONTRACT_ADDRESS = BASE_NETWORK.usdcTokenAddress;
+export const USDC_DECIMALS = 6;

package/dist/utils/db.d.ts

@@ -0,0 +1,17 @@
+export interface StorageAdapter {
+    setup(): Promise<void>;
+    set(key: string, value: any): Promise<void>;
+    get(key: string): Promise<any | null>;
+    getAll(): Promise<any[]>;
+}
+export declare class UniversalStorage {
+    private dbName;
+    private storeName;
+    private adapter;
+    constructor(dbName: string, storeName: string);
+    init(): Promise<UniversalStorage>;
+    private createServerAdapter;
+    set(key: string, value: any): Promise<void>;
+    get<T = any>(key: string): Promise<T | null>;
+    getAll<T = any>(): Promise<T[]>;
+}

package/dist/utils/db.js

@@ -0,0 +1,276 @@
+const isBrowser = typeof window !== 'undefined' && typeof indexedDB !== 'undefined';
+const isNodeRuntime = typeof process !== 'undefined' &&
+    typeof process.versions !== 'undefined' &&
+    !!process.versions.node;
+const isBunRuntime = typeof process !== 'undefined' &&
+    typeof process.versions !== 'undefined' &&
+    !!process.versions.bun;
+const isDenoRuntime = typeof globalThis.Deno !== 'undefined';
+export class UniversalStorage {
+    dbName;
+    storeName;
+    adapter;
+    constructor(dbName, storeName) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+    }
+    async init() {
+        if (isBrowser) {
+            this.adapter = new BrowserIDBAdapter(this.dbName, this.storeName);
+            await this.adapter.setup();
+        }
+        else {
+            this.adapter = await this.createServerAdapter();
+        }
+        return this;
+    }
+    async createServerAdapter() {
+        // Prefer sqlite on Node.js when available because it is durable and scalable.
+        if (isNodeRuntime) {
+            const sqliteAdapter = new NodeSQLiteAdapter(this.dbName);
+            try {
+                await sqliteAdapter.setup();
+                return sqliteAdapter;
+            }
+            catch (error) {
+                if (!isSqliteUnavailableError(error)) {
+                    throw error;
+                }
+            }
+        }
+        // Bun/Deno/other runtimes can still persist using a JSON file.
+        const fileAdapter = new ServerFileAdapter(this.dbName, this.storeName);
+        try {
+            await fileAdapter.setup();
+            return fileAdapter;
+        }
+        catch {
+            // Last resort for restricted server runtimes (e.g. no filesystem access).
+            const memoryAdapter = new ServerMemoryAdapter();
+            await memoryAdapter.setup();
+            return memoryAdapter;
+        }
+    }
+    async set(key, value) {
+        return await this.adapter.set(key, value);
+    }
+    async get(key) {
+        return await this.adapter.get(key);
+    }
+    async getAll() {
+        return await this.adapter.getAll();
+    }
+}
+class BrowserIDBAdapter {
+    dbName;
+    storeName;
+    db = null;
+    constructor(dbName, storeName) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+    }
+    setup() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 3);
+            request.onupgradeneeded = (e) => {
+                const db = e.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    db.createObjectStore(this.storeName);
+                }
+            };
+            request.onsuccess = (e) => {
+                this.db = e.target.result;
+                resolve();
+            };
+            request.onerror = () => reject(new Error("IndexedDB initialization failed"));
+        });
+    }
+    async set(key, value) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const tx = this.db.transaction(this.storeName, 'readwrite');
+        const store = tx.objectStore(this.storeName);
+        return new Promise((res, rej) => {
+            const req = store.put(value, key);
+            tx.oncomplete = () => res();
+            tx.onerror = () => rej(tx.error);
+        });
+    }
+    async get(key) {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const tx = this.db.transaction(this.storeName, 'readonly');
+        const store = tx.objectStore(this.storeName);
+        return new Promise((res) => {
+            const req = store.get(key);
+            req.onsuccess = () => res(req.result || null);
+        });
+    }
+    async getAll() {
+        if (!this.db)
+            throw new Error("Database not initialized");
+        const tx = this.db.transaction(this.storeName, 'readonly');
+        const store = tx.objectStore(this.storeName);
+        return new Promise((res) => {
+            const req = store.getAll();
+            req.onsuccess = () => res(req.result || []);
+        });
+    }
+}
+class NodeSQLiteAdapter {
+    db;
+    fileName;
+    constructor(dbName) {
+        this.fileName = `./cache/${dbName}.db`;
+    }
+    async setup() {
+        const sqlite3 = loadNodeSqlite();
+        const { Database } = sqlite3;
+        this.db = new Database(this.fileName);
+        await this.run('CREATE TABLE IF NOT EXISTS storage (key TEXT PRIMARY KEY, value TEXT)');
+    }
+    run(sql, ...params) {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    queryGet(sql, ...params) {
+        return new Promise((resolve, reject) => {
+            this.db.get(sql, params, (err, row) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(row);
+            });
+        });
+    }
+    queryAll(sql, ...params) {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    async set(key, value) {
+        await this.run('INSERT OR REPLACE INTO storage (key, value) VALUES (?, ?)', key, JSON.stringify(value));
+    }
+    async get(key) {
+        const row = await this.queryGet('SELECT value FROM storage WHERE key = ?', key);
+        return row ? JSON.parse(row.value) : null;
+    }
+    async getAll() {
+        const rows = await this.queryAll('SELECT value FROM storage');
+        return rows.map((row) => JSON.parse(row.value));
+    }
+}
+function loadNodeSqlite() {
+    // Use indirect eval so bundlers don't try to include sqlite3 in browser builds.
+    const nodeRequire = (0, eval)('typeof require !== "undefined" ? require : undefined');
+    if (!nodeRequire) {
+        const error = new Error('sqlite3 is only available when Node.js require is present');
+        error.code = 'SQLITE_UNAVAILABLE';
+        throw error;
+    }
+    try {
+        return nodeRequire('sqlite3');
+    }
+    catch (error) {
+        if (error && /Cannot find module 'sqlite3'|Cannot find module \"sqlite3\"/i.test(String(error.message))) {
+            error.code = 'SQLITE_UNAVAILABLE';
+        }
+        throw error;
+    }
+}
+function isSqliteUnavailableError(error) {
+    return error?.code === 'SQLITE_UNAVAILABLE';
+}
+class ServerFileAdapter {
+    fileName;
+    data = {};
+    constructor(dbName, storeName) {
+        this.fileName = `./cache/${dbName}.${storeName}.json`;
+    }
+    async setup() {
+        await ensureCacheDir();
+        const raw = await readFileSafe(this.fileName);
+        this.data = raw ? JSON.parse(raw) : {};
+    }
+    async set(key, value) {
+        this.data[key] = value;
+        await writeFileSafe(this.fileName, JSON.stringify(this.data));
+    }
+    async get(key) {
+        return key in this.data ? this.data[key] : null;
+    }
+    async getAll() {
+        return Object.values(this.data);
+    }
+}
+class ServerMemoryAdapter {
+    data = new Map();
+    async setup() {
+        return;
+    }
+    async set(key, value) {
+        this.data.set(key, value);
+    }
+    async get(key) {
+        return this.data.has(key) ? this.data.get(key) : null;
+    }
+    async getAll() {
+        return Array.from(this.data.values());
+    }
+}
+async function ensureCacheDir() {
+    if (isDenoRuntime) {
+        await globalThis.Deno.mkdir('./cache', { recursive: true });
+        return;
+    }
+    if (isNodeRuntime || isBunRuntime) {
+        const fs = await import('node:fs/promises');
+        await fs.mkdir('./cache', { recursive: true });
+        return;
+    }
+    throw new Error('Filesystem storage is not available in this runtime');
+}
+async function readFileSafe(path) {
+    try {
+        if (isDenoRuntime) {
+            return await globalThis.Deno.readTextFile(path);
+        }
+        if (isNodeRuntime || isBunRuntime) {
+            const fs = await import('node:fs/promises');
+            return await fs.readFile(path, 'utf8');
+        }
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    throw new Error('Filesystem storage is not available in this runtime');
+}
+async function writeFileSafe(path, content) {
+    if (isDenoRuntime) {
+        await globalThis.Deno.writeTextFile(path, content);
+        return;
+    }
+    if (isNodeRuntime || isBunRuntime) {
+        const fs = await import('node:fs/promises');
+        await fs.writeFile(path, content, 'utf8');
+        return;
+    }
+    throw new Error('Filesystem storage is not available in this runtime');
+}
+function isMissingFileError(error) {
+    return error?.code === 'ENOENT' || error?.name === 'NotFound';
+}

package/dist/utils/encryption.d.ts

@@ -0,0 +1,8 @@
+import { Keypair } from './keypair.js';
+export declare function deriveKeys(signature: string): {
+    encryptionKey: Buffer<ArrayBuffer>;
+    utxoPrivateKey: string;
+    keypair: Keypair;
+};
+export declare function encrypt(data: string | Buffer, encryptionKey: Buffer): string;
+export declare function decrypt(encryptedData: string | Buffer, encryptionKey: Buffer): Buffer;

package/dist/utils/encryption.js

@@ -0,0 +1,34 @@
+import crypto from 'crypto';
+import { ethers } from 'ethers';
+import { Keypair } from './keypair.js';
+export function deriveKeys(signature) {
+    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, encryptionKey) {
+    const dataBuffer = typeof data === 'string' ? Buffer.from(data) : data;
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', encryptionKey, iv);
+    const encrypted = Buffer.concat([cipher.update(dataBuffer), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    const result = Buffer.concat([iv, authTag, encrypted]);
+    return '0x' + result.toString('hex');
+}
+export function decrypt(encryptedData, encryptionKey) {
+    const buf = typeof encryptedData === 'string'
+        ? Buffer.from(encryptedData.replace(/^0x/, ''), 'hex')
+        : encryptedData;
+    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, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([decipher.update(data), decipher.final()]);
+}

package/dist/utils/keypair.d.ts

@@ -0,0 +1,9 @@
+import { BigNumber } from 'ethers';
+export declare class Keypair {
+    privkey: string;
+    pubkey: BigNumber;
+    constructor(privkey?: string);
+    toString(): string;
+    address(): string;
+    sign(commitment: any, merklePath: any): BigNumber;
+}

package/dist/utils/keypair.js

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

package/dist/utils/logger.d.ts

@@ -0,0 +1,9 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LoggerFn = (level: LogLevel, message: string) => void;
+export declare function setLogger(logger: LoggerFn): void;
+export declare const logger: {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};

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/networkConfig.d.ts

@@ -0,0 +1,54 @@
+export type Erc20Token = 'usdc' | 'usdt';
+export type NativeToken = 'eth' | 'bnb';
+export type PrivacyToken = NativeToken | Erc20Token;
+export type SupportedChain = 'base' | 'eth' | 'bnb';
+export interface NetworkConfig {
+    chainId: number;
+    /** Short identifier used in API calls and DB table prefixes. */
+    chainKey: SupportedChain;
+    rpcUrl: string;
+    indexerUrl: string;
+    etherPoolAddress: string;
+    usdcPoolAddress: string;
+    usdcTokenAddress: string;
+    usdcDecimals: number;
+    usdtPoolAddress: string;
+    usdtTokenAddress: string;
+    usdtDecimals: number;
+    feeRecipientAddress: string;
+    /** Namespace prefix for local UTXO cache files. Base keeps legacy names. */
+    cachePrefix: string;
+    /** Average block time in ms — used to scale confirmation polling timeouts. */
+    blockTimeMs: number;
+    /** Native token used by this chain. */
+    nativeToken?: NativeToken;
+    /** Human-readable native token symbol used in logs and errors. */
+    nativeSymbol?: 'ETH' | 'BNB';
+    /** Optional block explorer base URL. */
+    blockExplorerUrl?: string;
+}
+export declare const BASE_NETWORK: NetworkConfig;
+export declare const ETH_NETWORK: NetworkConfig;
+export declare const BNB_NETWORK: NetworkConfig;
+export declare const NETWORKS: Record<number, NetworkConfig>;
+export declare function getNetworkConfig(chainId: number): NetworkConfig;
+/** Returns the default network driven by NEXT_PUBLIC_CHAIN_ID env var, falling back to Base. */
+export declare function getDefaultNetworkConfig(): NetworkConfig;
+/** Resolve a NetworkConfig from an object, a chain ID number, or the env-driven default. */
+export declare function resolveNetwork(network?: NetworkConfig | number): NetworkConfig;
+/** Resolve an omitted token to the selected chain's native token and reject cross-chain native symbols. */
+export declare function resolvePrivacyToken(net: NetworkConfig, token?: PrivacyToken): PrivacyToken;
+export declare function isNativeToken(net: NetworkConfig, token: PrivacyToken): boolean;
+export declare function getErc20TokenConfig(net: NetworkConfig, token: PrivacyToken): {
+    token: "usdc";
+    symbol: "USDC";
+    poolAddress: string;
+    tokenAddress: string;
+    decimals: number;
+} | {
+    token: "usdt";
+    symbol: "USDT";
+    poolAddress: string;
+    tokenAddress: string;
+    decimals: number;
+} | null;

package/dist/utils/networkConfig.js

@@ -0,0 +1,126 @@
+const EVM_INDEXER_URL = process.env.NEXT_PUBLIC_EVM_INDEXER_URL || process.env.EVM_INDEXER_URL || 'https://evm.privacycash.org';
+function getIndexerRpcUrl(chain) {
+    return `${EVM_INDEXER_URL.replace(/\/$/, '')}/rpc/${chain}`;
+}
+export const BASE_NETWORK = {
+    chainId: 8453,
+    chainKey: 'base',
+    rpcUrl: process.env.NEXT_PUBLIC_BASE_RPC || process.env.BASE_RPC || getIndexerRpcUrl('base'),
+    indexerUrl: EVM_INDEXER_URL,
+    etherPoolAddress: '0x7F673790C08Ddf27c0Aa6fa9526CCC8dAaB081Ec',
+    usdcPoolAddress: '0xe91dd4AB03909f5CEb87f42B4308B222995a905b',
+    usdcTokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    usdcDecimals: 6,
+    usdtPoolAddress: '',
+    usdtTokenAddress: '',
+    usdtDecimals: 6,
+    feeRecipientAddress: '0x8D772A68f2327409a7bb3F96f549297AEdf9312B',
+    cachePrefix: 'base',
+    blockTimeMs: 2000,
+    nativeToken: 'eth',
+    nativeSymbol: 'ETH',
+};
+export const ETH_NETWORK = {
+    chainId: 1,
+    chainKey: 'eth',
+    rpcUrl: process.env.NEXT_PUBLIC_ETH_RPC || process.env.ETH_RPC || getIndexerRpcUrl('eth'),
+    indexerUrl: EVM_INDEXER_URL,
+    etherPoolAddress: process.env.NEXT_PUBLIC_ETH_ETHER_POOL_ADDRESS || '0x77A10AE3E513c2D73D73eb52212c6918C8830dd0',
+    usdcPoolAddress: '',
+    usdcTokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    usdcDecimals: 6,
+    usdtPoolAddress: process.env.NEXT_PUBLIC_ETH_USDT_POOL_ADDRESS || '0xC88F4dF2B6EdDd6B6Bdf95A0177f50C90Fa7527f',
+    usdtTokenAddress: process.env.NEXT_PUBLIC_ETH_USDT_TOKEN_ADDRESS || '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    usdtDecimals: 6,
+    feeRecipientAddress: process.env.NEXT_PUBLIC_ETH_FEE_RECIPIENT_ADDRESS || '0x8D772A68f2327409a7bb3F96f549297AEdf9312B',
+    cachePrefix: 'eth',
+    blockTimeMs: 12000,
+    nativeToken: 'eth',
+    nativeSymbol: 'ETH',
+};
+const BNB_ALCHEMY_RPC = process.env.ALCHEMY_KEY
+    ? `https://bnb-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_KEY}`
+    : getIndexerRpcUrl('bnb');
+export const BNB_NETWORK = {
+    chainId: 56,
+    chainKey: 'bnb',
+    rpcUrl: process.env.NEXT_PUBLIC_BNB_RPC || process.env.BNB_RPC || BNB_ALCHEMY_RPC,
+    indexerUrl: EVM_INDEXER_URL,
+    etherPoolAddress: '0x22D8509E7AF58b1EaFB311f8F76E81dC3a391F77',
+    usdcPoolAddress: '',
+    usdcTokenAddress: '',
+    usdcDecimals: 6,
+    usdtPoolAddress: '',
+    usdtTokenAddress: '',
+    usdtDecimals: 18,
+    feeRecipientAddress: '0x8D772A68f2327409a7bb3F96f549297AEdf9312B',
+    cachePrefix: 'bnb',
+    blockTimeMs: 1000,
+    nativeToken: 'bnb',
+    nativeSymbol: 'BNB',
+    blockExplorerUrl: 'https://bscscan.com/',
+};
+export const NETWORKS = {
+    8453: BASE_NETWORK,
+    1: ETH_NETWORK,
+    56: BNB_NETWORK,
+};
+export function getNetworkConfig(chainId) {
+    const config = NETWORKS[chainId];
+    if (!config) {
+        throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(NETWORKS).join(', ')}`);
+    }
+    return config;
+}
+/** Returns the default network driven by NEXT_PUBLIC_CHAIN_ID env var, falling back to Base. */
+export function getDefaultNetworkConfig() {
+    const chainId = Number(process.env.NEXT_PUBLIC_CHAIN_ID) || 8453;
+    return getNetworkConfig(chainId);
+}
+/** Resolve a NetworkConfig from an object, a chain ID number, or the env-driven default. */
+export function resolveNetwork(network) {
+    if (network === undefined || network === null)
+        return getDefaultNetworkConfig();
+    if (typeof network === 'number')
+        return getNetworkConfig(network);
+    return network;
+}
+/** Resolve an omitted token to the selected chain's native token and reject cross-chain native symbols. */
+export function resolvePrivacyToken(net, token) {
+    const nativeToken = net.nativeToken ?? (net.chainKey === 'bnb' ? 'bnb' : 'eth');
+    const resolved = token ?? nativeToken;
+    if ((resolved === 'eth' || resolved === 'bnb') && resolved !== nativeToken) {
+        throw new Error(`${resolved.toUpperCase()} is not supported on ${net.chainKey}`);
+    }
+    return resolved;
+}
+export function isNativeToken(net, token) {
+    const nativeToken = net.nativeToken ?? (net.chainKey === 'bnb' ? 'bnb' : 'eth');
+    return token === nativeToken;
+}
+export function getErc20TokenConfig(net, token) {
+    if (isNativeToken(net, token))
+        return null;
+    if (token === 'eth' || token === 'bnb') {
+        throw new Error(`${token.toUpperCase()} is not supported on ${net.chainKey}`);
+    }
+    const config = token === 'usdc'
+        ? {
+            token,
+            symbol: 'USDC',
+            poolAddress: net.usdcPoolAddress,
+            tokenAddress: net.usdcTokenAddress,
+            decimals: net.usdcDecimals,
+        }
+        : {
+            token,
+            symbol: 'USDT',
+            poolAddress: net.usdtPoolAddress,
+            tokenAddress: net.usdtTokenAddress,
+            decimals: net.usdtDecimals,
+        };
+    if (!config.poolAddress || !config.tokenAddress) {
+        throw new Error(`${token.toUpperCase()} is not supported on ${net.chainKey}`);
+    }
+    return config;
+}

package/dist/utils/prover.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a Zero-Knowledge proof for a transaction.
+ * Works across Node.js, Bun, Deno, and Browser — fully in-memory, no tmp files.
+ *
+ * Bun/Deno use single-threaded mode: passing { singleThread: true } to both
+ * wtnsCalcOptions (5th arg) and proverOptions (6th arg) of groth16.fullProve
+ * prevents snarkjs from spawning web-worker threads entirely, avoiding the
+ * Bun v1.3.x crash where worker threads dispatch plain Error objects to
+ * EventTarget.dispatchEvent (which requires a proper Event instance in Bun).
+ */
+export declare function prove(input: any, keyBasePath: string): Promise<{
+    pA: string[];
+    pB: string[][];
+    pC: string[];
+}>;

package/dist/utils/prover.js

@@ -0,0 +1,30 @@
+// @ts-ignore
+import { utils } from 'ffjavascript';
+import { toFixedHex } from './utils.js';
+/**
+ * Generates a Zero-Knowledge proof for a transaction.
+ * Works across Node.js, Bun, Deno, and Browser — fully in-memory, no tmp files.
+ *
+ * Bun/Deno use single-threaded mode: passing { singleThread: true } to both
+ * wtnsCalcOptions (5th arg) and proverOptions (6th arg) of groth16.fullProve
+ * prevents snarkjs from spawning web-worker threads entirely, avoiding the
+ * Bun v1.3.x crash where worker threads dispatch plain Error objects to
+ * EventTarget.dispatchEvent (which requires a proper Event instance in Bun).
+ */
+export async function prove(input, keyBasePath) {
+    // @ts-ignore
+    const useSingleThread = typeof Bun !== 'undefined' || typeof Deno !== 'undefined';
+    const singleThreadOpts = useSingleThread ? { singleThread: true } : undefined;
+    // @ts-ignore
+    const snarkjs = await import('snarkjs');
+    const { proof } = await snarkjs.groth16.fullProve(utils.stringifyBigInts(input), `${keyBasePath}.wasm`, `${keyBasePath}.zkey`, undefined, // logger
+    singleThreadOpts, // wtnsCalcOptions: controls witness calculation threading
+    singleThreadOpts);
+    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 };
+}