Gate balance effects and FIO refresh on engine readiness

With the core's wallet cache (wallet cache v2 phase 1), wallet objects
exist before their engines load, and waitForAllWallets resolves in that
window. Three login-path surfaces consumed engine state immediately:

- The action queue's address-balance effect read balanceMap right after
  awaiting the wallet, which could evaluate a balance effect against
  cached, possibly stale balances. It now reports not-yet-effective
  until the engine has fully synced, matching the conservatism the loan
  flow already applies.
- The FIO address refresh called otherMethods on pre-engine wallets,
  which is {} in that window. Services now waits for each FIO wallet's
  engine-backed otherMethods (bounded by a generous safety-valve
  timeout) before refreshing.
- FioService's periodic expired-domain check called
  otherMethods.getFioAddresses the same way (caught live on the sim).
  It now skips pre-engine wallets and lets the next 30s cycle retry,
  which also avoids wedging its one-shot expiredChecking latch.

Author: j0ntz

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased (develop)
 
+- changed: Gate action-queue balance-effect checks and the login FIO address refresh on engine readiness, so wallets emitted from the core's new wallet cache (before their engines load) cannot mis-evaluate balance effects or crash the FIO refresh.
+
 ## 4.50.0 (staging)
 
 - added: Changelly swap provider

eslint.config.mjs

@@ -330,7 +330,6 @@ export default [
       'src/components/services/DeepLinkingManager.tsx',
       'src/components/services/EdgeContextCallbackManager.tsx',
 
-      'src/components/services/FioService.ts',
       'src/components/services/LoanManagerService.ts',
       'src/components/services/NetworkActivity.ts',
       'src/components/services/PasswordReminderService.ts',

src/components/services/FioService.ts

@@ -28,7 +28,7 @@ interface Props {
 
 type NameDates = Record<string, Date>
 
-export const FioService = (props: Props) => {
+export const FioService = (props: Props): null => {
   const { account, navigation } = props
   const dispatch = useDispatch()
 
@@ -65,10 +65,19 @@ export const FioService = (props: Props) => {
     }
 
     if (expiredChecking.current) return
+
+    // Wallet objects can exist before their engines do (wallet cache),
+    // and refreshFioNames calls engine-backed otherMethods.
+    // Skip pre-engine wallets and let the next cycle retry them:
+    const readyWallets = fioWallets.current.filter(
+      fioWallet => fioWallet.otherMethods.getFioAddresses != null
+    )
+    if (readyWallets.length === 0) return
+
     expiredChecking.current = true
 
     const walletsToCheck: EdgeCurrencyWallet[] = []
-    for (const fioWallet of fioWallets.current) {
+    for (const fioWallet of readyWallets) {
       if (!walletsCheckedForExpired.current[fioWallet.id]) {
         walletsToCheck.push(fioWallet)
       }
@@ -130,7 +139,10 @@ export const FioService = (props: Props) => {
   return null
 }
 
-function arraysEqual(arr1: EdgeCurrencyWallet[], arr2: EdgeCurrencyWallet[]) {
+function arraysEqual(
+  arr1: EdgeCurrencyWallet[],
+  arr2: EdgeCurrencyWallet[]
+): boolean {
   if (arr1.length !== arr2.length) return false
 
   arr1.sort((a, b) => a.id.localeCompare(b.id))

src/components/services/Services.tsx

@@ -27,6 +27,7 @@ import {
   width
 } from '../../util/scaling'
 import { snooze } from '../../util/utils'
+import { waitForWalletOtherMethods } from '../../util/waitForWalletOtherMethods'
 import { AlertDropdown } from '../navigation/AlertDropdown'
 import { AccountCallbackManager } from './AccountCallbackManager'
 import { ActionQueueService } from './ActionQueueService'
@@ -88,6 +89,20 @@ export const Services: React.FC<Props> = props => {
         console.warn('registerNotificationsV2 error:', error)
       })
 
+      // Wallet objects can exist before their engines do (wallet cache),
+      // and the FIO refreshes below call engine-backed otherMethods,
+      // so wait for each FIO wallet's engine first:
+      const fioWallets = Object.values(account.currencyWallets).filter(
+        wallet => wallet.currencyInfo.pluginId === 'fio'
+      )
+      await Promise.all(
+        fioWallets.map(async wallet => {
+          await waitForWalletOtherMethods(wallet)
+        })
+      ).catch((error: unknown) => {
+        console.warn('waitForWalletOtherMethods error:', error)
+      })
+
       await dispatch(refreshConnectedWallets).catch((error: unknown) => {
         console.warn(error)
       })

src/controllers/action-queue/runtime/checkActionEffect.ts

@@ -120,6 +120,17 @@ export async function checkActionEffect(
       // TODO: Use effect.address when we can check address balances
       const { aboveAmount, belowAmount, tokenId, walletId } = effect
       const wallet = await account.waitForCurrencyWallet(walletId)
+
+      // The wallet object can exist before its engine loads (wallet cache),
+      // so don't evaluate the effect against cached, possibly stale
+      // balances. Report "not yet effective" until the engine has synced:
+      if (wallet.syncStatus.totalRatio < 1) {
+        return {
+          delay: 15000,
+          isEffective: false
+        }
+      }
+
       const walletBalance = wallet.balanceMap.get(tokenId) ?? '0'
 
       return {

src/util/waitForWalletOtherMethods.ts

@@ -0,0 +1,37 @@
+import type { EdgeCurrencyWallet } from 'edge-core-js'
+
+// Engine creation for a large account can take minutes on login,
+// matching how long waitForAllWallets used to take before the wallet
+// cache existed, so this is a safety valve rather than a deadline:
+const OTHER_METHODS_TIMEOUT_MS = 10 * 60 * 1000
+
+/**
+ * Waits for a wallet's engine-backed `otherMethods` to arrive.
+ *
+ * The core's wallet cache emits wallet objects before their engines
+ * exist, and `wallet.otherMethods` is guaranteed to be `{}` until the
+ * engine loads. Rejects after a timeout so a wallet whose engine never
+ * loads cannot hang callers forever.
+ */
+export async function waitForWalletOtherMethods(
+  wallet: EdgeCurrencyWallet,
+  timeoutMs: number = OTHER_METHODS_TIMEOUT_MS
+): Promise<void> {
+  if (Object.keys(wallet.otherMethods).length > 0) return
+
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      unsubscribe()
+      reject(
+        new Error(`Timed out waiting for wallet ${wallet.id} engine methods`)
+      )
+    }, timeoutMs)
+    const unsubscribe = wallet.watch('otherMethods', otherMethods => {
+      if (Object.keys(otherMethods).length > 0) {
+        clearTimeout(timeout)
+        unsubscribe()
+        resolve()
+      }
+    })
+  })
+}