fix: wallet reset issue

.changeset/brown-walls-rescue.md

@@ -0,0 +1,5 @@
+---
+"fuels-wallet": patch
+---
+
+refactor: accountMachine should not handle isLogged operations and should not have parallel states running

.changeset/cool-goats-teach.md

@@ -0,0 +1,5 @@
+---
+"fuels-wallet": patch
+---
+
+set isLogged when opening the db

.changeset/sharp-beans-exist.md

@@ -0,0 +1,5 @@
+---
+"fuels-wallet": patch
+---
+
+feat: cleaning now waits for localStorage

.vscode/extensions.json

@@ -1,7 +1,6 @@
 {
   "recommendations": [
     "FuelLabs.sway-vscode-plugin",
-    "statelyai.stately-vscode",
-    "firsttris.vscode-jest-runner"
+    "statelyai.stately-vscode"
   ]
 }

.vscode/settings.json

@@ -9,5 +9,10 @@
   },
   "[typescript]": {
     "editor.defaultFormatter": "biomejs.biome"
-  }
+  },
+  "typescript.suggest.autoImports": true,
+  "javascript.suggest.autoImports": true,
+  "typescript.suggest.paths": true,
+  "typescript.suggest.enabled": true,
+  "typescript.suggest.completeFunctionCalls": true,
 }

packages/app/src/systems/Account/hooks/useAccounts.tsx

@@ -81,14 +81,6 @@ export function useAccounts() {
     return accountStatus === status;
   }
 
-  store.useUpdateMachineConfig(Services.accounts, {
-    actions: {
-      refreshApplication() {
-        window.location.reload();
-      },
-    },
-  });
-
   useEffect(() => {
     if (shouldListen.current) {
       shouldListen.current = false;

packages/app/src/systems/Account/machines/accountsMachine.tsx

@@ -14,6 +14,9 @@ type MachineContext = {
   needsRecovery?: boolean;
   account?: AccountWithBalance;
   error?: unknown;
+  isFetchingAccounts?: boolean;
+  isLoggingOut?: boolean;
+  skipLoading?: boolean;
 };
 
 type MachineServices = {
@@ -41,31 +44,31 @@ export type AccountsMachineEvents =
       input: AccountInputs['updateAccount'];
     };
 
-const fetchingAccountsState = 
-{
+const fetchingAccountsState = {
   initial: 'fetchingAccounts',
+  entry: 'assignIsFetching',
+  exit: 'assignIsntFetching',
   states: {
     fetchingAccounts: {
       invoke: {
         src: 'fetchAccounts',
         onDone: [
-        {
-          target: 'recoveringWallet',
-          actions: ['assignAccounts', 'setIsLogged'],
-          cond: 'hasAccountsOrNeedsRecovery',
-        },
-        {
-          target: 'fetchingAccount',
-          actions: ['assignAccounts'],
-        },
-      ],
-      onError: [
-        {
-          actions: 'assignError',
-          target: '#(machine).failed',
-        },
-      ],
-    },
+          {
+            actions: 'assignError',
+            target: '#(machine).failed',
+            cond: FetchMachine.hasError,
+          },
+          {
+            target: 'recoveringWallet',
+            actions: ['assignAccounts'],
+            cond: 'hasAccountsOrNeedsRecovery',
+          },
+          {
+            target: 'fetchingAccount',
+            actions: ['assignAccounts'],
+          },
+        ],
+      },
     },
     recoveringWallet: {
       invoke: {
@@ -93,13 +96,7 @@ const fetchingAccountsState =
           },
           {
             target: '#(machine).idle',
-            actions: ['assignAccount'],
-          },
-        ],
-        onError: [
-          {
-            actions: 'assignError',
-            target: '#(machine).failed',
+            actions: ['assignAccount', 'assignSkipLoadingTrue'],
           },
         ],
       },
@@ -117,27 +114,29 @@ export const accountsMachine = createMachine(
     },
     predictableActionArguments: true,
     id: '(machine)',
-    initial: 'fetchingAccounts',
+    initial: 'checkStartFetching',
     states: {
       idle: {
-        on: {
-          SET_CURRENT_ACCOUNT: {
-            target: 'settingCurrentAccount',
+        after: {
+          TIMEOUT: {
+            target: 'checkStartFetching',
           },
-          TOGGLE_HIDE_ACCOUNT: {
-            actions: ['toggleHideAccount', 'notifyUpdateAccounts'],
+        },
+      },
+      checkStartFetching: {
+        always: [
+          {
+            cond: 'isLoggingOut',
             target: 'idle',
           },
-        },
-        after: {
-          /**
-           * Update accounts every 5 seconds
-           */
-          TIMEOUT: {
+          {
+            cond: 'shouldSkipLoading',
             target: 'refreshingAccounts',
-            cond: 'isLoggedIn',
           },
-        },
+          {
+            target: 'fetchingAccounts',
+          },
+        ],
       },
       fetchingAccounts: {
         tags: ['loading'],
@@ -159,12 +158,33 @@ export const accountsMachine = createMachine(
               cond: FetchMachine.hasError,
             },
             {
-              actions: ['notifyUpdateAccounts', 'redirectToHome'],
-              target: 'fetchingAccounts',
+              actions: [
+                'notifyUpdateAccounts',
+                'redirectToHome',
+                'assignSkipLoadingFalse',
+              ],
+              target: 'checkStartFetching',
             },
           ],
         },
       },
+      checkLogout: {
+        // this state enters on a "lock" state where fetching will not be performed
+        // also it will wait til fetching is not happening anymore
+        tags: ['loading'],
+        entry: 'assignIsLoggingOut',
+        always: [
+          {
+            cond: 'isntFetchingAccounts',
+            target: 'loggingout',
+          },
+        ],
+        after: {
+          LOOP_TRY_LOGOUT: {
+            target: 'checkLogout',
+          },
+        },
+      },
       loggingout: {
         tags: ['loading'],
         invoke: {
@@ -176,40 +196,51 @@ export const accountsMachine = createMachine(
               target: 'failed',
             },
             {
-              actions: ['clearContext', 'refreshApplication'],
-              target: 'idle',
+              actions: ['clearContext'],
+              target: 'stopAll',
             },
           ],
         },
       },
+      stopAll: {
+        type: 'final',
+      },
       failed: {
         after: {
-          INTERVAL: {
-            target: 'fetchingAccounts', // retry
-            cond: 'isLoggedIn',
-          },
+          INTERVAL: [
+            {
+              target: 'checkStartFetching', // retry
+            },
+            {
+              target: 'idle',
+            },
+          ],
         },
       },
     },
     on: {
       LOGOUT: {
-        target: 'loggingout',
+        target: 'checkLogout',
+      },
+      SET_CURRENT_ACCOUNT: {
+        target: 'settingCurrentAccount',
+      },
+      TOGGLE_HIDE_ACCOUNT: {
+        actions: ['toggleHideAccount', 'notifyUpdateAccounts'],
       },
       REFRESH_ACCOUNTS: [
         {
-          cond: 'shouldSkipLoading',
-          target: 'refreshingAccounts',
+          actions: ['assignSkipLoading'],
+          target: 'checkStartFetching',
         },
-        {
-          target: 'fetchingAccounts',
-        }
       ],
     },
   },
   {
     delays: {
       INTERVAL: 2000,
-      TIMEOUT: 5000,
+      TIMEOUT: 2000,
+      LOOP_TRY_LOGOUT: 100,
     },
     actions: {
       assignAccounts: assign({
@@ -226,15 +257,30 @@ export const accountsMachine = createMachine(
       toggleHideAccount: (_, ev) => {
         AccountService.updateAccount(ev.input);
       },
-      setIsLogged: () => {
-        Storage.setItem(IS_LOGGED_KEY, true);
-      },
       notifyUpdateAccounts: () => {
         store.refreshAccounts();
       },
       redirectToHome: () => {
         store.closeOverlay();
-      }
+      },
+      assignIsFetching: assign({
+        isFetchingAccounts: () => true,
+      }),
+      assignIsntFetching: assign({
+        isFetchingAccounts: () => false,
+      }),
+      assignIsLoggingOut: assign({
+        isLoggingOut: () => true,
+      }),
+      assignSkipLoading: assign({
+        skipLoading: (_, ev) => !!ev.input?.skipLoading,
+      }),
+      assignSkipLoadingTrue: assign({
+        skipLoading: () => true,
+      }),
+      assignSkipLoadingFalse: assign({
+        skipLoading: () => false,
+      }),
     },
     services: {
       fetchAccounts: FetchMachine.create<
@@ -305,9 +351,6 @@ export const accountsMachine = createMachine(
       }),
     },
     guards: {
-      isLoggedIn: () => {
-        return !!Storage.getItem(IS_LOGGED_KEY);
-      },
       hasAccountsOrNeedsRecovery: (ctx, ev) => {
         const hasAccounts = Boolean(
           (ev.data.accounts || ctx?.accounts || []).length
@@ -317,8 +360,14 @@ export const accountsMachine = createMachine(
         );
         return hasAccounts || needsRecovery;
       },
-      shouldSkipLoading: (_, ev) => {
-        return !!ev.input?.skipLoading;
+      shouldSkipLoading: (ctx) => {
+        return !!ctx.skipLoading;
+      },
+      isLoggingOut: (ctx) => {
+        return !!ctx.isLoggingOut;
+      },
+      isntFetchingAccounts: (ctx) => {
+        return !ctx.isFetchingAccounts;
       },
     },
   }

packages/app/src/systems/Account/services/account.ts

@@ -261,7 +261,9 @@ export class AccountService {
         // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         const dataToLog: any = {};
         try {
-          dataToLog.backupAccounts = JSON.stringify(backupAccounts?.map((account) => account?.data?.address) || []);
+          dataToLog.backupAccounts = JSON.stringify(
+            backupAccounts?.map((account) => account?.data?.address) || []
+          );
           dataToLog.backupNetworks = JSON.stringify(backupNetworks || []);
           // try getting data from indexedDB (outside of dexie) to check if it's also corrupted
           const testNoDexieDbData = await getTestNoDexieDbData();

packages/app/src/systems/Account/utils/storage.tsx

@@ -28,8 +28,6 @@ export class IndexedDBStorage implements StorageAbstract {
   }
 
   async clear() {
-    await chromeStorage.vaults.clear();
-    await chromeStorage.accounts.clear();
     await db.transaction('rw', db.vaults, db.accounts, async () => {
       await db.vaults.clear();
       await db.accounts.clear();

packages/app/src/systems/Core/services/core.ts

@@ -1,18 +1,26 @@
-import { toast } from '@fuel-ui/react';
 import { VaultService } from '~/systems/Vault';
-import { delay } from '../utils';
 import { db } from '../utils/database';
 import { Storage } from '../utils/storage';
 import { chromeStorage } from './chromeStorage';
+import { clearParallelDb } from '~/systems/Core/utils/databaseNoDexie';
+import { IS_LOGGED_KEY } from '~/config';
 
 // biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
 export class CoreService {
   static async clear() {
-    toast.success('Your wallet will be reset');
-    await delay(1500);
     await chromeStorage.clear();
     await VaultService.clear();
     await db.clear();
-    await Storage.clear();
+    Storage.clear();
+    await clearParallelDb();
+    const reloadAfterCleanCompleted = () => {
+      const isLogged = Storage.getItem(IS_LOGGED_KEY);
+      if (!isLogged) {
+        window.location.reload();
+        return;
+      }
+      setTimeout(() => reloadAfterCleanCompleted(), 50);
+    };
+    reloadAfterCleanCompleted();
   }
 }