dop-wallet-v6 1.2.21 → 1.3.1

package/dist/services/dop/core/react-native-init.d.ts

@@ -7,15 +7,24 @@ export declare class ReactNativeLevelDB {
     private db;
     private storageKey;
     private AsyncStorage;
+    private persistTimeout;
+    private isDirty;
     constructor(name: string);
-    open(callback: (error?: Error) => void): Promise<void>;
+    open(callbackOrOptions?: any, callback?: (error?: Error) => void): Promise<void>;
     close(callback: (error?: Error) => void): void;
-    put(key: any, value: any, callback: (error?: Error) => void): void;
-    get(key: any, callback: (error?: Error, value?: any) => void): void;
-    del(key: any, callback: (error?: Error) => void): void;
-    batch(operations: any[], callback: (error?: Error) => void): void;
+    forcePersist(): Promise<void>;
+    clearPersistedData(): Promise<void>;
+    put(key: any, value: any, optionsOrCallback?: any, callback?: (error?: Error) => void): void;
+    get(key: any, optionsOrCallback?: any, callback?: (error?: Error, value?: any) => void): void;
+    del(key: any, optionsOrCallback?: any, callback?: (error?: Error) => void): void;
+    clear(options: any, callback: (error?: Error) => void): void;
+    batch(operationsOrCallback?: any, optionsOrCallback?: any, callback?: (error?: Error) => void): any;
     iterator(options?: any): any;
+    private _schedulePersistence;
     private _persistData;
+    private _cleanupExtraChunks;
+    private _cleanupAllChunks;
+    private _cleanupOldChunks;
 }
 /**
  * Initialize DOP Engine specifically for React Native environments.

package/dist/services/dop/core/react-native-init.js

@@ -19,6 +19,8 @@ class ReactNativeLevelDB {
     db;
     storageKey;
     AsyncStorage;
+    persistTimeout = null;
+    isDirty = false;
     constructor(name) {
         this.storageKey = `leveldb_${name}`;
         this.db = memdown();
@@ -33,18 +35,87 @@ class ReactNativeLevelDB {
         }
     }
     // Implement AbstractLevelDOWN interface
-    async open(callback) {
+    async open(callbackOrOptions, callback) {
+        // Handle both open(callback) and open(options, callback) signatures
+        let cb;
+        if (typeof callbackOrOptions === 'function') {
+            // open(callback) signature
+            cb = callbackOrOptions;
+        }
+        else if (typeof callback === 'function') {
+            // open(options, callback) signature
+            cb = callback;
+        }
+        else {
+            // No callback provided - this shouldn't happen in AbstractLevelDOWN
+            throw new Error('No callback provided to open method');
+        }
         try {
             // Load persisted data from AsyncStorage (only if available)
             if (this.AsyncStorage) {
                 try {
-                    const persistedData = await this.AsyncStorage.getItem(this.storageKey);
+                    let persistedData = null;
+                    // Check if data is stored in chunks
+                    const chunksCount = await this.AsyncStorage.getItem(`${this.storageKey}_chunks`);
+                    if (chunksCount) {
+                        console.log(`📦 Loading database from ${String(chunksCount)} chunks...`);
+                        // Reassemble from chunks
+                        const chunks = [];
+                        const count = parseInt(chunksCount, 10);
+                        if (Number.isNaN(count) || count < 0 || count > 1000) {
+                            throw new Error(`Invalid chunk count: ${String(chunksCount)}`);
+                        }
+                        for (let i = 0; i < count; i += 1) {
+                            const chunk = await this.AsyncStorage.getItem(`${this.storageKey}_chunk_${i}`);
+                            if (chunk) {
+                                chunks.push(chunk);
+                            }
+                            else {
+                                console.warn(`⚠️ Missing chunk ${i} of ${count}, data may be incomplete`);
+                            }
+                        }
+                        if (chunks.length === 0) {
+                            throw new Error('No chunks found, but chunk count was set');
+                        }
+                        persistedData = chunks.join('');
+                        console.log(`📦 Reassembled ${chunks.length}/${count} chunks (${(persistedData.length / 1024 / 1024).toFixed(2)}MB)`);
+                    }
+                    else {
+                        // Try to get data directly
+                        persistedData = await this.AsyncStorage.getItem(this.storageKey);
+                        if (persistedData) {
+                            console.log(`📦 Loading database directly (${(persistedData.length / 1024).toFixed(2)}KB)`);
+                        }
+                    }
                     if (persistedData) {
-                        const data = JSON.parse(persistedData);
+                        // Validate JSON before parsing
+                        if (!persistedData.trim().startsWith('{') || !persistedData.trim().endsWith('}')) {
+                            throw new Error('Persisted data does not look like valid JSON (missing braces)');
+                        }
+                        let data;
+                        try {
+                            data = JSON.parse(persistedData);
+                        }
+                        catch (jsonError) {
+                            throw new Error(`JSON parse failed: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`);
+                        }
                         // Restore data to memdown instance
+                        const keys = Object.keys(data);
+                        console.log(`📦 Restoring ${keys.length} entries to database...`);
                         for (const [key, value] of Object.entries(data)) {
                             await new Promise((resolve, reject) => {
-                                this.db.put(key, value, (err) => {
+                                // Restore Buffer/Uint8Array types from base64 with type marker
+                                let restoredValue = value;
+                                if (value && typeof value === 'object' && '__type' in value) {
+                                    const typedValue = value;
+                                    if (typedValue.__type === 'Buffer' && typeof typedValue.data === 'string') {
+                                        restoredValue = Buffer.from(typedValue.data, 'base64');
+                                    }
+                                    else if (typedValue.__type === 'Uint8Array' && typeof typedValue.data === 'string') {
+                                        restoredValue = new Uint8Array(Buffer.from(typedValue.data, 'base64'));
+                                    }
+                                }
+                                this.db.put(key, restoredValue, (err) => {
                                     if (err)
                                         reject(err);
                                     else
@@ -52,58 +123,253 @@ class ReactNativeLevelDB {
                                 });
                             });
                         }
+                        console.log('✅ Successfully restored database from AsyncStorage');
+                    }
+                    else {
+                        console.log('ℹ️ No persisted data found, starting with empty database');
                     }
                 }
                 catch (asyncStorageError) {
-                    // AsyncStorage not available or failed - continue without persistence
+                    console.error('❌ Failed to load from AsyncStorage, clearing corrupted data and starting fresh:', asyncStorageError);
+                    // Clear corrupted data
+                    try {
+                        await this.AsyncStorage.removeItem(this.storageKey);
+                        await this.AsyncStorage.removeItem(`${this.storageKey}_chunks`);
+                        // Try to remove chunks (up to 100 chunks max)
+                        for (let i = 0; i < 100; i += 1) {
+                            const chunkKey = `${this.storageKey}_chunk_${i}`;
+                            const exists = await this.AsyncStorage.getItem(chunkKey);
+                            if (exists) {
+                                await this.AsyncStorage.removeItem(chunkKey);
+                            }
+                            else {
+                                break; // No more chunks
+                            }
+                        }
+                        console.log('🧹 Cleared corrupted AsyncStorage data');
+                    }
+                    catch (clearError) {
+                        console.warn('⚠️ Failed to clear corrupted data:', clearError);
+                    }
                 }
             }
             // Open the memdown database
-            this.db.open(callback);
+            this.db.open(cb);
         }
         catch (error) {
-            callback(error);
+            cb(error);
         }
     }
     close(callback) {
-        this.db.close(callback);
+        // Clear pending persistence timeout
+        if (this.persistTimeout) {
+            clearTimeout(this.persistTimeout);
+            this.persistTimeout = null;
+        }
+        // Force immediate persistence before closing if dirty
+        if (this.isDirty && this.AsyncStorage) {
+            console.log('💾 Persisting database before close...');
+            this.isDirty = false;
+            this._persistData()
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                .then(() => {
+                console.log('✅ Database persisted, closing...');
+                this.db.close(callback);
+            })
+                .catch((error) => {
+                console.warn('⚠️ Failed to persist on close:', error);
+                this.db.close(callback);
+            });
+        }
+        else {
+            this.db.close(callback);
+        }
+    }
+    // Public method to force immediate persistence (useful after scan completes)
+    async forcePersist() {
+        if (this.persistTimeout) {
+            clearTimeout(this.persistTimeout);
+            this.persistTimeout = null;
+        }
+        if (this.isDirty && this.AsyncStorage) {
+            this.isDirty = false;
+            await this._persistData();
+        }
     }
-    put(key, value, callback) {
+    // Public method to clear all persisted data (use when recovering from storage full errors)
+    async clearPersistedData() {
+        console.log('🧹 Clearing all persisted database data from AsyncStorage...');
+        await this._cleanupOldChunks();
+        console.log('✅ Cleared all persisted data');
+    }
+    put(key, value, optionsOrCallback, callback) {
+        // Handle both put(key, value, callback) and put(key, value, options, callback) signatures
+        let cb;
+        if (typeof optionsOrCallback === 'function') {
+            // put(key, value, callback) signature
+            cb = optionsOrCallback;
+        }
+        else if (typeof callback === 'function') {
+            // put(key, value, options, callback) signature
+            cb = callback;
+        }
+        else {
+            throw new Error('No callback provided to put method');
+        }
         this.db.put(key, value, (err) => {
             if (!err && this.AsyncStorage) {
-                // Persist to AsyncStorage in background
-                void this._persistData().catch(console.warn);
+                // Schedule throttled persistence
+                this._schedulePersistence();
             }
-            callback(err);
+            cb(err);
         });
     }
-    get(key, callback) {
-        this.db.get(key, callback);
+    get(key, optionsOrCallback, callback) {
+        // Handle both get(key, callback) and get(key, options, callback) signatures
+        let cb;
+        if (typeof optionsOrCallback === 'function') {
+            // get(key, callback) signature
+            cb = optionsOrCallback;
+        }
+        else if (typeof callback === 'function') {
+            // get(key, options, callback) signature
+            cb = callback;
+        }
+        else {
+            throw new Error('No callback provided to get method');
+        }
+        this.db.get(key, cb);
     }
-    del(key, callback) {
+    del(key, optionsOrCallback, callback) {
+        // Handle both del(key, callback) and del(key, options, callback) signatures
+        let cb;
+        if (typeof optionsOrCallback === 'function') {
+            // del(key, callback) signature
+            cb = optionsOrCallback;
+        }
+        else if (typeof callback === 'function') {
+            // del(key, options, callback) signature
+            cb = callback;
+        }
+        else {
+            throw new Error('No callback provided to del method');
+        }
         this.db.del(key, (err) => {
             if (!err && this.AsyncStorage) {
-                // Persist to AsyncStorage in background
-                void this._persistData().catch(console.warn);
+                // Schedule throttled persistence
+                this._schedulePersistence();
             }
-            callback(err);
+            cb(err);
         });
     }
-    batch(operations, callback) {
+    clear(options, callback) {
+        // Handle clear operation for deleting ranges of keys
+        // This is required by dop-engine-v3's clearNamespace function
+        const { gte, lte, gt, lt } = options || {};
+        if (!gte && !gt) {
+            callback(new Error('clear() requires gte or gt option'));
+            return;
+        }
+        // Use iterator to find all keys in the range and delete them
+        const keysToDelete = [];
+        const iterator = this.db.iterator({
+            gte,
+            lte,
+            gt,
+            lt,
+            keys: true,
+            values: false,
+        });
+        const processNext = () => {
+            iterator.next((err, key) => {
+                if (err) {
+                    iterator.end(() => {
+                        callback(err);
+                    });
+                    return;
+                }
+                if (key === undefined) {
+                    // No more keys - now delete all collected keys
+                    iterator.end(() => {
+                        if (keysToDelete.length === 0) {
+                            callback();
+                            return;
+                        }
+                        // Delete keys in batch
+                        const operations = keysToDelete.map(k => ({ type: 'del', key: k }));
+                        this.db.batch(operations, (batchErr) => {
+                            if (!batchErr && this.AsyncStorage) {
+                                this._schedulePersistence();
+                            }
+                            callback(batchErr);
+                        });
+                    });
+                    return;
+                }
+                keysToDelete.push(key);
+                processNext();
+            });
+        };
+        processNext();
+    }
+    batch(operationsOrCallback, optionsOrCallback, callback) {
+        // Handle multiple batch signatures:
+        // batch() - returns chained batch
+        // batch(operations, callback)
+        // batch(operations, options, callback)
+        if (arguments.length === 0) {
+            // batch() - return chained batch (not commonly used in LevelUp)
+            return this.db.batch();
+        }
+        // Handle batch operations with callback
+        const operations = operationsOrCallback;
+        let cb;
+        if (typeof optionsOrCallback === 'function') {
+            // batch(operations, callback) signature
+            cb = optionsOrCallback;
+        }
+        else if (typeof callback === 'function') {
+            // batch(operations, options, callback) signature  
+            cb = callback;
+        }
+        else {
+            throw new Error('No callback provided to batch method');
+        }
         this.db.batch(operations, (err) => {
             if (!err && this.AsyncStorage) {
-                // Persist to AsyncStorage in background
-                void this._persistData().catch(console.warn);
+                // Schedule throttled persistence
+                this._schedulePersistence();
             }
-            callback(err);
+            cb(err);
         });
     }
     iterator(options) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return this.db.iterator(options);
     }
+    _schedulePersistence() {
+        this.isDirty = true;
+        // Clear existing timeout
+        if (this.persistTimeout) {
+            clearTimeout(this.persistTimeout);
+        }
+        // Schedule persistence with longer throttling during heavy writes (every 30 seconds)
+        // This dramatically improves scan performance by reducing serialization overhead
+        this.persistTimeout = setTimeout(() => {
+            if (this.isDirty) {
+                this.isDirty = false;
+                void this._persistData().catch((error) => {
+                    console.error('⚠️ Scheduled persistence failed:', error?.message || error);
+                    // Don't log full stack trace to avoid cluttering console
+                });
+            }
+        }, 30000); // Increased from 5s to 30s
+    }
     async _persistData() {
         if (!this.AsyncStorage)
             return;
+        const startTime = Date.now();
+        let entryCount = 0;
         try {
             const data = {};
             const iterator = this.db.iterator();
@@ -118,16 +384,164 @@ class ReactNativeLevelDB {
                             iterator.end(() => resolve());
                             return;
                         }
-                        data[key.toString()] = value;
+                        entryCount += 1;
+                        // Preserve Buffer/Uint8Array types by converting to base64 with type marker
+                        if (Buffer.isBuffer(value)) {
+                            data[key.toString()] = {
+                                __type: 'Buffer',
+                                data: value.toString('base64'),
+                            };
+                        }
+                        else if (value instanceof Uint8Array) {
+                            data[key.toString()] = {
+                                __type: 'Uint8Array',
+                                data: Buffer.from(value).toString('base64'),
+                            };
+                        }
+                        else {
+                            data[key.toString()] = value;
+                        }
                         processNext();
                     });
                 };
                 processNext();
             });
-            await this.AsyncStorage.setItem(this.storageKey, JSON.stringify(data));
+            // Serialize data
+            let jsonData;
+            try {
+                jsonData = JSON.stringify(data);
+            }
+            catch (stringifyError) {
+                throw new Error(`Failed to stringify data: ${stringifyError instanceof Error ? stringifyError.message : String(stringifyError)}`);
+            }
+            const serializeTime = Date.now() - startTime;
+            const dataSizeMB = jsonData.length / 1024 / 1024;
+            // React Native AsyncStorage has a 6MB per-item limit and total quota limits
+            // Use 500KB chunks to stay well within limits and avoid SQLITE_FULL errors
+            const chunkSize = 512 * 1024; // 500KB chunks (conservative for Android)
+            if (jsonData.length > chunkSize) {
+                // Split large data into chunks
+                const chunks = [];
+                for (let i = 0; i < jsonData.length; i += chunkSize) {
+                    chunks.push(jsonData.slice(i, i + chunkSize));
+                }
+                console.log(`💾 Writing ${chunks.length} chunks (${dataSizeMB.toFixed(2)}MB)...`);
+                // Check if data is too large (warn if over 50MB)
+                if (dataSizeMB > 50) {
+                    console.warn(`⚠️ Database is very large (${dataSizeMB.toFixed(2)}MB). Consider clearing old data.`);
+                }
+                // Write chunks sequentially to avoid overwhelming AsyncStorage
+                // Parallel writes can cause SQLITE_FULL errors
+                for (let i = 0; i < chunks.length; i += 1) {
+                    try {
+                        await this.AsyncStorage.setItem(`${this.storageKey}_chunk_${i}`, chunks[i]);
+                    }
+                    catch (chunkError) {
+                        // If we hit storage quota, clean up partial writes and throw
+                        console.error(`❌ Failed to write chunk ${i}/${chunks.length}:`, chunkError);
+                        if (chunkError?.message?.includes('full') || chunkError?.code === 13) {
+                            console.error('💥 Storage quota exceeded! Cleaning up partial writes...');
+                            // Only clean up the chunks we just tried to write
+                            for (let j = 0; j <= i; j += 1) {
+                                await this.AsyncStorage.removeItem(`${this.storageKey}_chunk_${j}`).catch(() => { });
+                            }
+                            throw new Error('AsyncStorage quota exceeded. Please clear app data or restart the app.');
+                        }
+                        throw chunkError;
+                    }
+                }
+                // Clean up any extra chunks from previous saves (if we had more chunks before)
+                await this._cleanupExtraChunks(chunks.length);
+                // Only update chunk count after all chunks are written successfully
+                await this.AsyncStorage.setItem(`${this.storageKey}_chunks`, chunks.length.toString());
+                // Remove direct storage if it exists (migrating from direct to chunked)
+                await this.AsyncStorage.removeItem(this.storageKey).catch(() => { });
+                const totalTime = Date.now() - startTime;
+                console.log(`✅ Persisted ${entryCount} entries (${dataSizeMB.toFixed(2)}MB in ${chunks.length} chunks) in ${totalTime}ms (serialize: ${serializeTime}ms)`);
+            }
+            else {
+                // Small data, store directly
+                await this.AsyncStorage.setItem(this.storageKey, jsonData);
+                // Clean up chunked storage if it exists (migrating from chunked to direct)
+                await this._cleanupAllChunks();
+                const totalTime = Date.now() - startTime;
+                console.log(`✅ Persisted ${entryCount} entries (${(jsonData.length / 1024).toFixed(2)}KB) in ${totalTime}ms (serialize: ${serializeTime}ms)`);
+            }
         }
         catch (error) {
-            console.warn('Failed to persist data to AsyncStorage:', error);
+            console.error('❌ Failed to persist data to AsyncStorage:', error);
+            console.error('Error details:', {
+                message: error?.message,
+                code: error?.code,
+                stack: error?.stack?.split('\n')[0]
+            });
+            // If quota exceeded, clear everything to recover
+            if (error?.message?.includes('quota') || error?.message?.includes('full')) {
+                console.error('💥 Storage full! Clearing all AsyncStorage data for recovery...');
+                await this._cleanupAllChunks();
+            }
+            // Don't mark as dirty - if persistence fails, we don't want to retry infinitely
+            // The data is still in memory (memdown) so the app can continue working
+            // this.isDirty = true;
+            // Don't throw - this allows the app to continue even if persistence fails
+            // throw error;
+        }
+    }
+    async _cleanupExtraChunks(keepChunkCount) {
+        if (!this.AsyncStorage)
+            return;
+        try {
+            // Remove chunks beyond the new count (cleanup old data)
+            for (let i = keepChunkCount; i < 200; i += 1) {
+                const chunkKey = `${this.storageKey}_chunk_${i}`;
+                const exists = await this.AsyncStorage.getItem(chunkKey);
+                if (!exists) {
+                    break; // No more chunks to clean
+                }
+                await this.AsyncStorage.removeItem(chunkKey);
+            }
+        }
+        catch (cleanupError) {
+            console.warn('⚠️ Error during extra chunk cleanup:', cleanupError);
+        }
+    }
+    async _cleanupAllChunks() {
+        if (!this.AsyncStorage)
+            return;
+        try {
+            // Remove chunk metadata
+            await this.AsyncStorage.removeItem(`${this.storageKey}_chunks`);
+            // Remove all chunk entries (try up to 200 chunks)
+            for (let i = 0; i < 200; i += 1) {
+                const chunkKey = `${this.storageKey}_chunk_${i}`;
+                const exists = await this.AsyncStorage.getItem(chunkKey);
+                if (!exists) {
+                    break; // No more chunks to clean
+                }
+                await this.AsyncStorage.removeItem(chunkKey);
+            }
+        }
+        catch (cleanupError) {
+            console.warn('⚠️ Error during chunk cleanup:', cleanupError);
+        }
+    }
+    // Keep old method for clearing persisted data (full cleanup)
+    async _cleanupOldChunks() {
+        if (!this.AsyncStorage)
+            return;
+        try {
+            // Remove chunk metadata
+            await this.AsyncStorage.removeItem(`${this.storageKey}_chunks`);
+            // Remove old direct storage (if exists)
+            await this.AsyncStorage.removeItem(this.storageKey);
+            // Remove all chunk entries (try up to 200 chunks)
+            for (let i = 0; i < 200; i += 1) {
+                const chunkKey = `${this.storageKey}_chunk_${i}`;
+                await this.AsyncStorage.removeItem(chunkKey).catch(() => { });
+            }
+        }
+        catch (cleanupError) {
+            console.warn('⚠️ Error during full cleanup:', cleanupError);
         }
     }
 }
@@ -146,16 +560,17 @@ exports.ReactNativeLevelDB = ReactNativeLevelDB;
  * @param databaseName - Name for the database (used as prefix in AsyncStorage)
  */
 const startDopEngineReactNative = async (walletSource, shouldDebug, artifactStore, useNativeArtifacts = true, skipMerkletreeScans = false, verboseScanLogging = false, databaseName = 'dop-wallet-db') => {
-    // Create React Native compatible database instance
-    // const db = new ReactNativeLevelDB(databaseName);
+    // Create React Native compatible database instance with AsyncStorage persistence
+    const db = new ReactNativeLevelDB(databaseName);
     // Ensure database is opened before proceeding
-    // await new Promise<void>((resolve, reject) => {
-    //   db.open((error) => {
-    //     if (error) reject(error);
-    //     else resolve();
-    //   });
-    // });
-    const db = memdown(); // Use in-memory DB if AsyncStorage is not available
+    await new Promise((resolve, reject) => {
+        db.open((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
     // Initialize the DOP Engine with the React Native database
     return (0, init_1.startDopEngine)(walletSource, db, // Cast to any since TypeScript doesn't know about our custom implementation
     shouldDebug, artifactStore, useNativeArtifacts, skipMerkletreeScans, verboseScanLogging);