testprivacycash-evm 1.2.0

package/src/utils/constants.ts

@@ -0,0 +1,15 @@
+
+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/src/utils/db.ts

@@ -0,0 +1,311 @@
+
+export interface StorageAdapter {
+    setup(): Promise<void>;
+    set(key: string, value: any): Promise<void>;
+    get(key: string): Promise<any | null>;
+    getAll(): Promise<any[]>;
+}
+
+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 as any).bun;
+const isDenoRuntime = typeof (globalThis as any).Deno !== 'undefined';
+
+export class UniversalStorage {
+    private adapter!: StorageAdapter;
+
+    constructor(
+        private dbName: string,
+        private storeName: string
+    ) { }
+
+    async init(): Promise<UniversalStorage> {
+        if (isBrowser) {
+            this.adapter = new BrowserIDBAdapter(this.dbName, this.storeName);
+            await this.adapter.setup();
+        } else {
+            this.adapter = await this.createServerAdapter();
+        }
+        return this;
+    }
+
+    private async createServerAdapter(): Promise<StorageAdapter> {
+        // 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: any) {
+                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: string, value: any): Promise<void> {
+        return await this.adapter.set(key, value);
+    }
+
+    async get<T = any>(key: string): Promise<T | null> {
+        return await this.adapter.get(key);
+    }
+
+    async getAll<T = any>(): Promise<T[]> {
+        return await this.adapter.getAll();
+    }
+}
+
+class BrowserIDBAdapter implements StorageAdapter {
+    private db: IDBDatabase | null = null;
+
+    constructor(private dbName: string, private storeName: string) { }
+
+    setup(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, 3);
+            request.onupgradeneeded = (e: any) => {
+                const db = e.target.result as IDBDatabase;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    db.createObjectStore(this.storeName);
+                }
+            };
+            request.onsuccess = (e: any) => {
+                this.db = e.target.result;
+                resolve();
+            };
+            request.onerror = () => reject(new Error("IndexedDB initialization failed"));
+        });
+    }
+
+    async set(key: string, value: any): Promise<void> {
+        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: string): Promise<any | null> {
+        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(): Promise<any[]> {
+        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 implements StorageAdapter {
+    private db: any;
+    private fileName: string;
+
+    constructor(dbName: string) {
+        this.fileName = `./cache/${dbName}.db`;
+    }
+
+    async setup(): Promise<void> {
+        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)');
+    }
+
+    private run(sql: string, ...params: any[]): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, (err: any) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+    }
+
+    private queryGet(sql: string, ...params: any[]): Promise<any> {
+        return new Promise((resolve, reject) => {
+            this.db.get(sql, params, (err: any, row: any) => {
+                if (err) reject(err);
+                else resolve(row);
+            });
+        });
+    }
+
+    private queryAll(sql: string, ...params: any[]): Promise<any[]> {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err: any, rows: any[]) => {
+                if (err) reject(err);
+                else resolve(rows);
+            });
+        });
+    }
+
+    async set(key: string, value: any): Promise<void> {
+        await this.run('INSERT OR REPLACE INTO storage (key, value) VALUES (?, ?)', key, JSON.stringify(value));
+    }
+
+    async get(key: string): Promise<any | null> {
+        const row = await this.queryGet('SELECT value FROM storage WHERE key = ?', key);
+        return row ? JSON.parse(row.value) : null;
+    }
+
+    async getAll(): Promise<any[]> {
+        const rows = await this.queryAll('SELECT value FROM storage');
+        return rows.map((row: any) => JSON.parse(row.value));
+    }
+}
+
+function loadNodeSqlite(): any {
+    // 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 as any).code = 'SQLITE_UNAVAILABLE';
+        throw error;
+    }
+    try {
+        return nodeRequire('sqlite3');
+    } catch (error: any) {
+        if (error && /Cannot find module 'sqlite3'|Cannot find module \"sqlite3\"/i.test(String(error.message))) {
+            error.code = 'SQLITE_UNAVAILABLE';
+        }
+        throw error;
+    }
+}
+
+function isSqliteUnavailableError(error: any): boolean {
+    return error?.code === 'SQLITE_UNAVAILABLE';
+}
+
+class ServerFileAdapter implements StorageAdapter {
+    private readonly fileName: string;
+    private data: Record<string, any> = {};
+
+    constructor(dbName: string, storeName: string) {
+        this.fileName = `./cache/${dbName}.${storeName}.json`;
+    }
+
+    async setup(): Promise<void> {
+        await ensureCacheDir();
+        const raw = await readFileSafe(this.fileName);
+        this.data = raw ? JSON.parse(raw) : {};
+    }
+
+    async set(key: string, value: any): Promise<void> {
+        this.data[key] = value;
+        await writeFileSafe(this.fileName, JSON.stringify(this.data));
+    }
+
+    async get(key: string): Promise<any | null> {
+        return key in this.data ? this.data[key] : null;
+    }
+
+    async getAll(): Promise<any[]> {
+        return Object.values(this.data);
+    }
+}
+
+class ServerMemoryAdapter implements StorageAdapter {
+    private data = new Map<string, any>();
+
+    async setup(): Promise<void> {
+        return;
+    }
+
+    async set(key: string, value: any): Promise<void> {
+        this.data.set(key, value);
+    }
+
+    async get(key: string): Promise<any | null> {
+        return this.data.has(key) ? this.data.get(key) : null;
+    }
+
+    async getAll(): Promise<any[]> {
+        return Array.from(this.data.values());
+    }
+}
+
+async function ensureCacheDir(): Promise<void> {
+    if (isDenoRuntime) {
+        await (globalThis as any).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: string): Promise<string | null> {
+    try {
+        if (isDenoRuntime) {
+            return await (globalThis as any).Deno.readTextFile(path);
+        }
+
+        if (isNodeRuntime || isBunRuntime) {
+            const fs = await import('node:fs/promises');
+            return await fs.readFile(path, 'utf8');
+        }
+    } catch (error: any) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+
+    throw new Error('Filesystem storage is not available in this runtime');
+}
+
+async function writeFileSafe(path: string, content: string): Promise<void> {
+    if (isDenoRuntime) {
+        await (globalThis as any).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: any): boolean {
+    return error?.code === 'ENOENT' || error?.name === 'NotFound';
+}

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

@@ -0,0 +1,169 @@
+export type Erc20Token = 'usdc' | 'usdt';
+export type NativeToken = 'eth' | 'bnb';
+export type PrivacyToken = NativeToken | Erc20Token;
+export type SupportedChain = 'base' | 'eth' | 'bnb';
+
+const EVM_INDEXER_URL = process.env.NEXT_PUBLIC_EVM_INDEXER_URL || process.env.EVM_INDEXER_URL || 'https://evm.privacycash.org';
+
+function getIndexerRpcUrl(chain: SupportedChain) {
+    return `${EVM_INDEXER_URL.replace(/\/$/, '')}/rpc/${chain}`;
+}
+
+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 const BASE_NETWORK: NetworkConfig = {
+    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: NetworkConfig = {
+    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: NetworkConfig = {
+    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: Record<number, NetworkConfig> = {
+    8453: BASE_NETWORK,
+    1: ETH_NETWORK,
+    56: BNB_NETWORK,
+};
+
+export function getNetworkConfig(chainId: number): NetworkConfig {
+    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(): NetworkConfig {
+    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?: NetworkConfig | number): NetworkConfig {
+    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: NetworkConfig, token?: PrivacyToken): PrivacyToken {
+    const nativeToken: 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: NetworkConfig, token: PrivacyToken): boolean {
+    const nativeToken: NativeToken = net.nativeToken ?? (net.chainKey === 'bnb' ? 'bnb' : 'eth');
+    return token === nativeToken;
+}
+
+export function getErc20TokenConfig(net: NetworkConfig, token: PrivacyToken) {
+    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' as const,
+            poolAddress: net.usdcPoolAddress,
+            tokenAddress: net.usdcTokenAddress,
+            decimals: net.usdcDecimals,
+        }
+        : {
+            token,
+            symbol: 'USDT' as const,
+            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/src/utils/prover.ts

@@ -0,0 +1,39 @@
+// @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: any, keyBasePath: string) {
+    // @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, // proverOptions:   controls proving threading
+    );
+
+    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 };
+}

package/src/utils/remoteConfig.ts

@@ -0,0 +1,49 @@
+import { logger } from './logger.js';
+import { NetworkConfig, PrivacyToken, resolveNetwork } 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;
+}
+
+const CACHE_TTL_MS = 60 * 1000; // 1 minute
+
+type CacheEntry = { config: RemoteConfig; expiresAt: number };
+const configCache = new Map<number, CacheEntry>();
+
+export async function getRemoteConfig(network?: NetworkConfig | number, options?: { forceRefresh?: boolean }): Promise<RemoteConfig> {
+    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() as RemoteConfig;
+    configCache.set(net.chainId, { config: data, expiresAt: now + CACHE_TTL_MS });
+    logger.debug('Remote config loaded successfully');
+    return data;
+}