bstest001 0.0.4 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bstest001",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "",
   "main": "dist/index.js",
   "exports": {
@@ -17,7 +17,8 @@
     "ethers": "^5.0.0",
     "ffjavascript": "^0.2.36",
     "poseidon-lite": "^0.3.0",
-    "snarkjs": "^0.7.5"
+    "snarkjs": "^0.7.5",
+    "sqlite3": "^6.0.1"
   },
   "devDependencies": {
     "@types/node": "^25.3.3",

package/src/balance.ts

@@ -34,7 +34,8 @@ export async function getBalance({ provider: rawProvider, signature, address }:
     const unspent = await findUnspentUtxos({
         etherPool,
         encryptionKey,
-        keypair
+        keypair,
+        address
     });
 
     logger.debug(`Unspent UTXOs: ${unspent.length}`);

package/src/deposit.ts

@@ -63,7 +63,7 @@ export async function deposit({ provider: rawProvider, depositAmountInput, keyBa
     const unspent = await findUnspentUtxos({
         etherPool,
         encryptionKey,
-        keypair
+        keypair, address
     });
     logger.debug(`Unspent UTXOs found: ${unspent.length}`);
 

package/src/utils/db.ts

@@ -0,0 +1,151 @@
+
+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';
+export class UniversalStorage {
+    private adapter!: StorageAdapter;
+
+    constructor(
+        private dbName: string = 'PrivacyCash',
+        private storeName: string = 'evm'
+    ) { }
+
+    async init(): Promise<UniversalStorage> {
+        if (isBrowser) {
+            this.adapter = new BrowserIDBAdapter(this.dbName, this.storeName);
+        } else {
+            // Dynamically load adapter in Node.js environment
+            this.adapter = new NodeSQLiteAdapter(this.dbName);
+        }
+        await this.adapter.setup();
+        return this;
+    }
+
+    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, 1);
+            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 = await import('sqlite3');
+        const { Database } = sqlite3.default;
+        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));
+    }
+}

package/src/utils/utils.ts

@@ -2,10 +2,13 @@ import crypto from 'crypto';
 import { BigNumber, ethers } from 'ethers';
 import { poseidon1, poseidon2, poseidon3, poseidon4 } from 'poseidon-lite';
 import { INDEXER_URL } from './constants.js';
+import { UniversalStorage } from './db.js';
 import { logger } from './logger.js';
 import { prove } from './prover.js';
 import { Utxo } from './utxo.js';
 
+const storage = new UniversalStorage('PrivacyCashDB', 'evm');
+
 export const FIELD_SIZE = BigNumber.from(
     '21888242871839275222246405745257275088548364400416034343698204186575808495617',
 );
@@ -230,51 +233,86 @@ export async function prepareTransaction({
 }
 
 export async function findUnspentUtxos({
+    address,
     etherPool,
     encryptionKey,
     keypair,
+    start = 0,
 }: {
+    address: string;
     etherPool: ethers.Contract;
     encryptionKey: Buffer;
     keypair: any;
+    start?: number;
 }) {
-    let start = 0
-    const limit = 1000
-    let hasMore = true
-    const candidates: { utxo: Utxo; nullifier: string }[] = []
+    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<string, number>();
+    const candidates: { utxo: Utxo; nullifier: string }[] = [];
+
+    // 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.encrypted, item.index);
+        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 = `${INDEXER_URL}/get_encrypted?start=${start}&end=${start + limit}`
-        logger.debug(`Fetching encrypted UTXOs from indexer: ${url}`)
-        const res = await fetch(url)
+        let url = `${INDEXER_URL}/get_encrypted?start=${startIndex}&end=${startIndex + 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}`)
+            throw new Error(`Failed to fetch encrypted UTXOs: ${res.statusText}`);
         }
-        const data = await res.json()
-        const { encrypted_outputs, hasMore: more, start: realStart } = data
+        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 })
+                const index = (realStart ?? startIndex) + i;
+                if (!knownEncryptedOutputs.has(encryptedOutput)) {
+                    try {
+                        const utxo = Utxo.decrypt(encryptionKey, encryptedOutput, index, keypair);
+                        if (!utxo.amount.isZero()) {
+                            knownEncryptedOutputs.set(encryptedOutput, index);
+                            utxo.index = index;
+                            const nullifier = toFixedHex(utxo.getNullifier());
+                            candidates.push({ utxo, nullifier });
+                        }
+                    } catch {
+                        // Decryption failed — this output belongs to someone else
                     }
-                } catch {
-                    // Decryption failed — this output belongs to someone else
                 }
-            })
+            });
         }
 
-        hasMore = more
-        start += limit
+        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(([encrypted, index]) => ({ encrypted, index })));
 
     // log candidates length
-    logger.debug(`Found ${candidates.length} candidate UTXOs, checking which are unspent...`)
+    logger.debug(`Found ${candidates.length} candidate UTXOs, checking which are unspent...`);
 
     const unspent: Utxo[] = []
     const spentCheckChunkSize = 256

package/src/withdraw.ts

@@ -8,12 +8,13 @@ import { Utxo } from './utils/utxo.js';
 
 const FLAT_FEE = ethers.utils.parseEther(RENT_FEE.toString())
 
-export async function withdraw({ provider: rawProvider, withdrawAmountInput, recipient, keyBasePath, signature }: {
+export async function withdraw({ provider: rawProvider, withdrawAmountInput, recipient, keyBasePath, signature, address }: {
     provider: any,
     withdrawAmountInput: number,
     recipient: string,
     keyBasePath: string,
     signature: string,
+    address: string
 }) {
     const provider: ethers.providers.Provider = rawProvider?.request
         ? new ethers.providers.Web3Provider(rawProvider)
@@ -40,7 +41,8 @@ export async function withdraw({ provider: rawProvider, withdrawAmountInput, rec
     const unspent = await findUnspentUtxos({
         etherPool,
         encryptionKey,
-        keypair
+        keypair,
+        address
     });
     logger.debug(`Unspent UTXOs found: ${unspent.length}`);