fix: backup mmkv to filesystem and restore when mmkv file becomes corrupted

msalcala11 · msalcala11 · commit 2bacc4909ce4 · 2025-10-09T10:41:45.000-04:00
diff --git a/src/navigation/tabs/settings/about/screens/StorageUsage.tsx b/src/navigation/tabs/settings/about/screens/StorageUsage.tsx
@@ -15,6 +15,7 @@ import {useTranslation} from 'react-i18next';
 import {LogActions} from '../../../../../store/log';
 import {Black, Feather, LightBlack, White} from '../../../../../styles/colors';
 import {useAppDispatch, useAppSelector} from '../../../../../utils/hooks';
+import {storage} from '../../../../../store';
 
 const ScrollContainer = styled.ScrollView``;
 
@@ -46,6 +47,8 @@ const StorageUsage: React.FC = () => {
   const [customTokenStorage, setCustomTokenStorage] = useState<string>('');
   const [contactStorage, setContactStorage] = useState<string>('');
   const [ratesStorage, setRatesStorage] = useState<string>('');
+  const [backupStorage, setBackupStorage] = useState<string>('');
+  const [shopCatalogStorage, setShopCatalogStorage] = useState<string>('');
 
   const giftCards = useAppSelector(
     ({APP, SHOP}) => SHOP.giftCards[APP.network],
@@ -95,6 +98,51 @@ const StorageUsage: React.FC = () => {
         dispatch(LogActions.error('[setAppSize] Error ', errStr));
       }
     };
+    const _setShopCatalogStorage = async () => {
+      try {
+        const root = storage.getString('persist:root');
+        if (root) {
+          try {
+            const parsed = JSON.parse(root);
+            const data = parsed?.SHOP_CATALOG;
+            const bytes = data ? JSON.stringify(data).length : 0;
+            setShopCatalogStorage(formatBytes(bytes));
+          } catch (_) {
+            setShopCatalogStorage('0 Bytes');
+          }
+        } else {
+          setShopCatalogStorage('0 Bytes');
+        }
+      } catch (err) {
+        const errStr = err instanceof Error ? err.message : JSON.stringify(err);
+        dispatch(LogActions.error('[setShopCatalogStorage] Error ', errStr));
+      }
+    };
+    const _setBackupStorage = async () => {
+      try {
+        // Filesystem backup created by fs-backup.ts
+        const baseDir = RNFS.CachesDirectoryPath + '/bitpay/redux';
+        const finalFile = baseDir + '/persist-root.json';
+        const bakFile = finalFile + '.bak';
+
+        let bytes = 0;
+        const finalExists = await RNFS.exists(finalFile);
+        if (finalExists) {
+          const stat = await RNFS.stat(finalFile);
+          bytes = Number(stat.size) || 0;
+        } else {
+          const bakExists = await RNFS.exists(bakFile);
+          if (bakExists) {
+            const stat = await RNFS.stat(bakFile);
+            bytes = Number(stat.size) || 0;
+          }
+        }
+        setBackupStorage(formatBytes(bytes));
+      } catch (err) {
+        const errStr = err instanceof Error ? err.message : JSON.stringify(err);
+        dispatch(LogActions.error('[setBackupStorage] Error ', errStr));
+      }
+    };
     const _setDeviceStorage = async () => {
       try {
         // Device Storage
@@ -195,6 +243,8 @@ const StorageUsage: React.FC = () => {
     _setCustomTokensStorage();
     _setContactStorage();
     _setRatesStorage();
+    _setBackupStorage();
+    _setShopCatalogStorage();
   }, [dispatch]);
 
   return (
@@ -270,6 +320,20 @@ const StorageUsage: React.FC = () => {
 
             <Button buttonType="pill">{ratesStorage}</Button>
           </Setting>
+
+          <Hr />
+          <Setting>
+            <SettingTitle>{t('Shop Catalog')}</SettingTitle>
+
+            <Button buttonType="pill">{shopCatalogStorage}</Button>
+          </Setting>
+
+          <Hr />
+          <Setting>
+            <SettingTitle>{t('Filesystem Backup')}</SettingTitle>
+
+            <Button buttonType="pill">{backupStorage}</Button>
+          </Setting>
         </SettingsComponent>
       </ScrollContainer>
     </SettingsContainer>
diff --git a/src/store/backup/fs-backup.ts b/src/store/backup/fs-backup.ts
@@ -0,0 +1,125 @@
+import RNFS from 'react-native-fs';
+import {LogActions} from '../../store/log';
+import * as initLogs from '../../store/log/initLogs';
+import {getErrorString} from '../../utils/helper-methods';
+
+// Use cache directories (CachesDirectoryPath) so backups are NOT included in iCloud/Android Auto Backup
+const BASE_CACHE_DIR = RNFS.CachesDirectoryPath;
+const BASE_DIR = BASE_CACHE_DIR + '/bitpay/redux';
+const FINAL_FILE = BASE_DIR + '/persist-root.json';
+const BACKUP_FILE = BASE_DIR + '/persist-root.json.bak';
+const TEMP_FILE = BASE_DIR + '/persist-root.json.tmp';
+
+async function ensureDir(): Promise<void> {
+  try {
+    const exists = await RNFS.exists(BASE_DIR);
+    if (!exists) {
+      await RNFS.mkdir(BASE_DIR);
+    }
+  } catch (err) {
+    initLogs.add(
+      LogActions.persistLog(
+        LogActions.error(`Backup ensureDir failed - ${getErrorString(err)}`),
+      ),
+    );
+  }
+}
+
+export async function backupPersistRoot(rawJson: string): Promise<void> {
+  try {
+    let filtered = rawJson;
+    try {
+      const parsed = JSON.parse(rawJson);
+      delete parsed.RATE;
+      delete parsed.SHOP_CATALOG;
+      filtered = JSON.stringify(parsed);
+    } catch (_) {
+      // If parse fails, keep raw json — better to have a backup than none
+    }
+
+    await ensureDir();
+
+    // Write to temp file first
+    await RNFS.writeFile(TEMP_FILE, filtered, 'utf8');
+
+    // Rotate current to .bak if present
+    const finalExists = await RNFS.exists(FINAL_FILE);
+    if (finalExists) {
+      try {
+        // Remove old .bak if exists to keep only one rolling backup
+        const bakExists = await RNFS.exists(BACKUP_FILE);
+        if (bakExists) {
+          await RNFS.unlink(BACKUP_FILE);
+        }
+      } catch (_) {}
+      try {
+        await RNFS.moveFile(FINAL_FILE, BACKUP_FILE);
+      } catch (err) {
+        initLogs.add(
+          LogActions.persistLog(
+            LogActions.error(`Backup rotate failed - ${getErrorString(err)}`),
+          ),
+        );
+      }
+    }
+
+    // Atomically move temp to final
+    await RNFS.moveFile(TEMP_FILE, FINAL_FILE);
+  } catch (err) {
+    // Best-effort logging; avoid throwing to not impact primary persist
+    initLogs.add(
+      LogActions.persistLog(
+        LogActions.error(`Backup write failed - ${getErrorString(err)}`),
+      ),
+    );
+    // Cleanup temp if left behind
+    try {
+      const tmpExists = await RNFS.exists(TEMP_FILE);
+      if (tmpExists) {
+        await RNFS.unlink(TEMP_FILE);
+      }
+    } catch (_) {}
+  }
+}
+
+export async function readBackupPersistRoot(): Promise<string | null> {
+  try {
+    const finalExists = await RNFS.exists(FINAL_FILE);
+    if (finalExists) {
+      const data = await RNFS.readFile(FINAL_FILE, 'utf8');
+      try {
+        JSON.parse(data);
+        return data;
+      } catch (_) {
+        // Fall through to backup
+      }
+    }
+  } catch (err) {
+    initLogs.add(
+      LogActions.persistLog(
+        LogActions.error(`Backup read final failed - ${getErrorString(err)}`),
+      ),
+    );
+  }
+
+  try {
+    const bakExists = await RNFS.exists(BACKUP_FILE);
+    if (bakExists) {
+      const data = await RNFS.readFile(BACKUP_FILE, 'utf8');
+      try {
+        JSON.parse(data);
+        return data;
+      } catch (_) {
+        return null;
+      }
+    }
+  } catch (err) {
+    initLogs.add(
+      LogActions.persistLog(
+        LogActions.error(`Backup read bak failed - ${getErrorString(err)}`),
+      ),
+    );
+  }
+
+  return null;
+}
diff --git a/src/store/index.ts b/src/store/index.ts
@@ -7,7 +7,6 @@ import {
   combineReducers,
   legacy_createStore as createStore,
   Middleware,
-  StoreEnhancer,
 } from 'redux';
 import {composeWithDevTools} from 'redux-devtools-extension';
 import {createLogger} from 'redux-logger'; // https://github.com/LogRocket/redux-logger
@@ -18,6 +17,7 @@ import autoMergeLevel2 from 'redux-persist/lib/stateReconciler/autoMergeLevel2';
 import {encryptTransform} from 'redux-persist-transform-encrypt'; // https://github.com/maxdeviant/redux-persist-transform-encrypt
 import thunkMiddleware, {ThunkAction} from 'redux-thunk'; // https://github.com/reduxjs/redux-thunk
 import {Selector} from 'reselect';
+import {backupPersistRoot, readBackupPersistRoot} from './backup/fs-backup';
 import {
   bindWalletKeys,
   transformContacts,
@@ -49,6 +49,10 @@ import {
   swapCryptoReducer,
   swapCryptoReduxPersistBlackList,
 } from './swap-crypto/swap-crypto.reducer';
+import {
+  ZenledgerReduxPersistBlackList,
+  zenledgerReducer,
+} from './zenledger/zenledger.reducer';
 import {
   walletReducer,
   walletReduxPersistBlackList,
@@ -74,10 +78,6 @@ import {Storage} from 'redux-persist';
 import {MMKV} from 'react-native-mmkv';
 import {getErrorString} from '../utils/helper-methods';
 import {AppDispatch} from '../utils/hooks';
-import {
-  ZenledgerReduxPersistBlackList,
-  zenledgerReducer,
-} from './zenledger/zenledger.reducer';
 
 export const storage = new MMKV();
 
@@ -94,6 +94,37 @@ const addLog = (log: AddLog) => {
   } catch (_) {}
 };
 
+const restoreFromBackup = (reason: string): Promise<string | null> => {
+  const startTs = Date.now();
+  return readBackupPersistRoot()
+    .then(restored => {
+      if (restored) {
+        try {
+          // Write back to MMKV to repair store for future runs
+          storage.set('persist:root', restored);
+          addLog(
+            LogActions.info(
+              `MMKV persist:root ${reason} - restored from filesystem backup - durationMs:${
+                Date.now() - startTs
+              }`,
+            ),
+          );
+        } catch (err) {
+          addLog(
+            LogActions.persistLog(
+              LogActions.error(
+                `MMKV restore write-back failed - ${getErrorString(err)}`,
+              ),
+            ),
+          );
+        }
+        return restored;
+      }
+      return null;
+    })
+    .catch(() => null);
+};
+
 export const reduxStorage: Storage = {
   setItem: (key, value) => {
     try {
@@ -109,11 +140,20 @@ export const reduxStorage: Storage = {
         ),
       );
     }
+    try {
+      if (key === 'persist:root' && typeof value === 'string') {
+        backupPersistRoot(value);
+      }
+    } catch (_) {}
     return Promise.resolve();
   },
   getItem: key => {
     try {
       const value = storage.getString(key);
+      if (value == null && key === 'persist:root') {
+        // Attempt restore from backup if MMKV has been wiped or is missing
+        return restoreFromBackup('missing');
+      }
       return Promise.resolve(value);
     } catch (err) {
       addLog(
@@ -123,6 +163,10 @@ export const reduxStorage: Storage = {
           ),
         ),
       );
+      if (key === 'persist:root') {
+        // Try backup on MMKV get failure as well
+        return restoreFromBackup('getItem error');
+      }
       return Promise.resolve(null);
     }
   },
