feat: migrate old embedded LND bbolt wallets to SQLite automatically

Author: a-khushal

locales/en.json

@@ -443,6 +443,7 @@
     "views.Wallet.Wallet.loadingAccount": "Zeus is loading your account.",
     "views.Wallet.Wallet.startingNode": "Zeus is starting your node.",
     "views.Wallet.Wallet.expressGraphSync": "Zeus is running express graph sync. Hang tight.",
+    "views.Wallet.Wallet.migratingDatabase": "Zeus is upgrading your database. This may take a moment.",
     "views.Wallet.startupSlowTitle": "Startup is taking longer than expected",
     "views.Wallet.startupSlowMsg.ios": "We recommend either viewing the LND logs for more details, or restarting the app manually.",
     "views.Wallet.startupSlowMsg.android": "We recommend either viewing the LND logs for more details, or restarting the app directly from here.",

utils/LndMobileUtils.ts

@@ -278,6 +278,85 @@ export async function initializeLnd({
     await initialize();
 }
 
+export async function migrateBboltToSqlite({
+    lndDir = 'lnd',
+    isTestnet,
+    walletPassword
+}: {
+    lndDir: string;
+    isTestnet?: boolean;
+    walletPassword: string;
+}): Promise<boolean> {
+    try {
+        console.log(`Starting bbolt to SQLite migration for wallet: ${lndDir}`);
+
+        await stopLnd();
+
+        await sleep(1000);
+
+        await writeLndConfig({
+            lndDir,
+            isTestnet,
+            isSqlite: true
+        });
+
+        const { initialize, checkStatus } = lndMobile.index;
+        await initialize();
+
+        await sleep(1000);
+
+        const status = await checkStatus();
+        if (
+            (status & ELndMobileStatusCodes.STATUS_PROCESS_STARTED) !==
+            ELndMobileStatusCodes.STATUS_PROCESS_STARTED
+        ) {
+            await startLnd({
+                lndDir,
+                walletPassword,
+                isTorEnabled: false,
+                isTestnet: isTestnet || false
+            });
+        }
+
+        await sleep(2000);
+
+        const finalStatus = await checkStatus();
+        const isRunning =
+            (finalStatus & ELndMobileStatusCodes.STATUS_PROCESS_STARTED) ===
+            ELndMobileStatusCodes.STATUS_PROCESS_STARTED;
+
+        if (isRunning) {
+            console.log(`Migration successful for wallet: ${lndDir}`);
+            return true;
+        } else {
+            console.error(
+                `Migration failed - LND did not start for wallet: ${lndDir}`
+            );
+            await writeLndConfig({
+                lndDir,
+                isTestnet,
+                isSqlite: false
+            });
+            return false;
+        }
+    } catch (error) {
+        console.error(
+            `Error during bbolt to SQLite migration for wallet ${lndDir}:`,
+            error
+        );
+        try {
+            await writeLndConfig({
+                lndDir,
+                isTestnet,
+                isSqlite: false
+            });
+        } catch (rollbackError) {
+            console.error('Error rolling back config:', rollbackError);
+        }
+        return false;
+    }
+}
+
 export async function stopLnd() {
     const { checkStatus, stopLnd } = lndMobile.index;
     try {

utils/MigrationUtils.ts

@@ -78,6 +78,7 @@ export const IS_BACKED_UP_KEY = 'backup-complete-v2';
 
 const KEYCHAIN_MIGRATION_KEY = 'ios-keychain-cloud-sync-migration';
 const CASHU_MIGRATION_KEY = 'ios-keychain-cashu-fix';
+const BBOLT_TO_SQLITE_MIGRATION_KEY = 'bbolt-to-sqlite-migration-v1';
 
 import EncryptedStorage from 'react-native-encrypted-storage';
 import Storage from '../storage';
@@ -965,6 +966,75 @@ class MigrationsUtils {
             console.error('Error during keychain cloud sync migration:', error);
         }
     }
+
+    public async hasDatabaseMigrationBeenAttempted(
+        lndDir: string
+    ): Promise<boolean> {
+        try {
+            const key = `${BBOLT_TO_SQLITE_MIGRATION_KEY}:${lndDir}`;
+            const attempted = await EncryptedStorage.getItem(key);
+            return attempted === 'true';
+        } catch (error) {
+            console.error(
+                'Error checking bbolt to SQLite migration status:',
+                error
+            );
+            return false;
+        }
+    }
+
+    public async markDatabaseMigrationAttempted(lndDir: string): Promise<void> {
+        try {
+            const key = `${BBOLT_TO_SQLITE_MIGRATION_KEY}:${lndDir}`;
+            await EncryptedStorage.setItem(key, 'true');
+        } catch (error) {
+            console.error(
+                'Error marking bbolt to SQLite migration as attempted:',
+                error
+            );
+        }
+    }
+
+    public async checkBboltWalletExists(
+        lndDir: string,
+        isSqlite?: boolean
+    ): Promise<boolean> {
+        if (isSqlite === true) {
+            return false;
+        }
+
+        try {
+            const settingsJson = await Storage.getItem(STORAGE_KEY);
+            if (!settingsJson) {
+                return false;
+            }
+
+            const settings = JSON.parse(settingsJson);
+            if (!settings.nodes || !Array.isArray(settings.nodes)) {
+                return false;
+            }
+
+            const node = settings.nodes.find(
+                (n: any) =>
+                    n.implementation === 'embedded-lnd' &&
+                    (n.lndDir || 'lnd') === lndDir
+            );
+
+            if (!node) {
+                return false;
+            }
+
+            const nodeIsBbolt =
+                node.isSqlite === false || node.isSqlite === undefined;
+            const hasWalletData =
+                node.seedPhrase || node.adminMacaroon || node.walletPassword;
+
+            return nodeIsBbolt && hasWalletData;
+        } catch (error) {
+            console.error('Error checking bbolt wallet existence:', error);
+            return false;
+        }
+    }
 }
 
 const migrationsUtils = new MigrationsUtils();

views/Wallet/Wallet.tsx

@@ -49,11 +49,12 @@ import {
     initializeLnd,
     startLnd,
     stopLnd,
-    expressGraphSync
+    expressGraphSync,
+    migrateBboltToSqlite
 } from '../../utils/LndMobileUtils';
 import { localeString, bridgeJavaStrings } from '../../utils/LocaleUtils';
 import { isBatterySaverEnabled } from '../../utils/BatteryUtils';
-import { IS_BACKED_UP_KEY } from '../../utils/MigrationUtils';
+import MigrationsUtils, { IS_BACKED_UP_KEY } from '../../utils/MigrationUtils';
 import { protectedNavigation } from '../../utils/NavigationUtils';
 import { isLightTheme, themeColor } from '../../utils/ThemeUtils';
 import { restartNeeded } from '../../utils/RestartUtils';
@@ -129,6 +130,7 @@ interface WalletState {
     initialLoad: boolean;
     loading: boolean;
     pendingShareIntent?: { qrData?: string; base64Image?: string };
+    migratingDatabase: boolean;
 }
 
 @inject(
@@ -169,7 +171,8 @@ export default class Wallet extends React.Component<WalletProps, WalletState> {
             unlocked: false,
             initialLoad: true,
             loading: false,
-            pendingShareIntent: undefined
+            pendingShareIntent: undefined,
+            migratingDatabase: false
         };
         this.pan = new Animated.ValueXY();
         this.panResponder = PanResponder.create({
@@ -475,12 +478,63 @@ export default class Wallet extends React.Component<WalletProps, WalletState> {
                     await CashuStore.initializeWallets();
 
                 console.log('lndDir', lndDir);
+                const currLndDir = lndDir || 'lnd';
+                const needsMigration =
+                    !isSqlite &&
+                    (await MigrationsUtils.checkBboltWalletExists(
+                        currLndDir,
+                        isSqlite
+                    )) &&
+                    !(await MigrationsUtils.hasDatabaseMigrationBeenAttempted(
+                        currLndDir
+                    ));
+
+                if (needsMigration) {
+                    this.setState({ migratingDatabase: true });
+                    try {
+                        const success = await migrateBboltToSqlite({
+                            lndDir: currLndDir,
+                            isTestnet: embeddedLndNetwork === 'Testnet',
+                            walletPassword: walletPassword || ''
+                        });
+
+                        if (success) {
+                            await MigrationsUtils.markDatabaseMigrationAttempted(
+                                currLndDir
+                            );
+                            const nodes = settings?.nodes || [];
+                            const nodeIndex = nodes.findIndex(
+                                (n: any) =>
+                                    n.implementation === 'embedded-lnd' &&
+                                    (n.lndDir || 'lnd') === currLndDir
+                            );
+                            if (nodeIndex !== -1) {
+                                const updatedNodes = [...nodes];
+                                updatedNodes[nodeIndex] = {
+                                    ...updatedNodes[nodeIndex],
+                                    isSqlite: true
+                                };
+                                await updateSettings({
+                                    nodes: updatedNodes
+                                });
+                            }
+                        }
+                    } catch (error) {
+                        console.error(
+                            'Error during database migration:',
+                            error
+                        );
+                    } finally {
+                        this.setState({ migratingDatabase: false });
+                    }
+                }
+
                 await initializeLnd({
-                    lndDir: lndDir || 'lnd',
+                    lndDir: currLndDir,
                     isTestnet: embeddedLndNetwork === 'Testnet',
                     rescan,
                     compactDb,
-                    isSqlite
+                    isSqlite: needsMigration ? true : isSqlite
                 });
 
                 // on initial load, do not run EGS
@@ -1250,7 +1304,11 @@ export default class Wallet extends React.Component<WalletProps, WalletState> {
                                             padding: 8
                                         }}
                                     >
-                                        {CashuStore.initializing
+                                        {this.state.migratingDatabase
+                                            ? localeString(
+                                                  'views.Wallet.Wallet.migratingDatabase'
+                                              ).replace('Zeus', 'ZEUS')
+                                            : CashuStore.initializing
                                             ? CashuStore.loadingMsg
                                             : settings.nodes &&
                                               loggedIn &&