test(self-custodial): cover multi-account flows across providers, hooks and settings

Author: esaugomez31

__tests__/graphql/network-error-component.spec.tsx

@@ -20,6 +20,13 @@ jest.mock("@app/utils/toast")
 jest.mock("@react-navigation/native")
 jest.mock("@app/utils/storage/secureStorage")
 
+jest.mock("@app/hooks/use-active-wallet", () => ({
+  useActiveWallet: () => ({
+    isSelfCustodial: false,
+    activeWalletId: "current-custodial-id",
+  }),
+}))
+
 const mockClearNetworkError = jest.fn()
 const mockToastShow = toastShow as jest.Mock
 const mockLogout = jest.fn()

__tests__/hooks/use-account-registry.spec.ts

@@ -48,6 +48,11 @@ jest.mock("@app/hooks/use-app-config", () => ({
   }),
 }))
 
+const mockListSelfCustodialAccounts = jest.fn()
+jest.mock("@app/self-custodial/storage/account-index", () => ({
+  listSelfCustodialAccounts: () => mockListSelfCustodialAccounts(),
+}))
+
 let mockNonCustodialEnabled = false
 let mockActiveAccountId: string | undefined
 
@@ -56,6 +61,7 @@ describe("useAccountRegistry", () => {
     jest.clearAllMocks()
     mockNonCustodialEnabled = false
     mockActiveAccountId = undefined
+    mockListSelfCustodialAccounts.mockResolvedValue([])
   })
 
   it("returns custodial account when authenticated", () => {
@@ -78,15 +84,22 @@ describe("useAccountRegistry", () => {
     expect(result.current.activeAccount).toBeUndefined()
   })
 
-  it("includes self-custodial account when flag enabled", () => {
+  it("includes self-custodial accounts loaded from the index", async () => {
     mockUseIsAuthed.mockReturnValue(true)
     mockNonCustodialEnabled = true
+    mockListSelfCustodialAccounts.mockResolvedValue([
+      { id: "sc-uuid-1", lightningAddress: null },
+    ])
 
     const { result } = renderHook(() => useAccountRegistry())
 
+    await act(async () => {
+      await Promise.resolve()
+    })
+
     expect(result.current.accounts).toHaveLength(2)
     expect(result.current.accounts[1].type).toBe(AccountType.SelfCustodial)
-    expect(result.current.accounts[1].label).toBe("Spark")
+    expect(result.current.accounts[1].id).toBe("sc-uuid-1")
     expect(result.current.accounts[1].status).toBe(AccountStatus.RequiresRestore)
   })
 
@@ -99,14 +112,21 @@ describe("useAccountRegistry", () => {
     expect(result.current.activeAccount?.selected).toBe(true)
   })
 
-  it("selects account matching activeAccountId", () => {
+  it("selects account matching activeAccountId", async () => {
     mockUseIsAuthed.mockReturnValue(true)
     mockNonCustodialEnabled = true
-    mockActiveAccountId = "self-custodial-default"
+    mockActiveAccountId = "sc-uuid-1"
+    mockListSelfCustodialAccounts.mockResolvedValue([
+      { id: "sc-uuid-1", lightningAddress: null },
+    ])
 
     const { result } = renderHook(() => useAccountRegistry())
 
-    expect(result.current.activeAccount?.id).toBe("self-custodial-default")
+    await act(async () => {
+      await Promise.resolve()
+    })
+
+    expect(result.current.activeAccount?.id).toBe("sc-uuid-1")
     expect(result.current.activeAccount?.type).toBe(AccountType.SelfCustodial)
   })
 
@@ -134,14 +154,21 @@ describe("useAccountRegistry", () => {
     expect(mockSaveToken).toHaveBeenCalledWith("token")
   })
 
-  it("setActiveAccountId does not call saveToken for self-custodial", () => {
+  it("setActiveAccountId does not call saveToken for self-custodial", async () => {
     mockUseIsAuthed.mockReturnValue(true)
     mockNonCustodialEnabled = true
+    mockListSelfCustodialAccounts.mockResolvedValue([
+      { id: "sc-uuid-1", lightningAddress: null },
+    ])
 
     const { result } = renderHook(() => useAccountRegistry())
 
+    await act(async () => {
+      await Promise.resolve()
+    })
+
     act(() => {
-      result.current.setActiveAccountId("self-custodial-default")
+      result.current.setActiveAccountId("sc-uuid-1")
     })
 
     expect(mockSaveToken).not.toHaveBeenCalled()
@@ -162,9 +189,9 @@ describe("createCustodialDescriptor", () => {
 
 describe("createSelfCustodialDescriptor", () => {
   it("creates a self-custodial descriptor with correct defaults", () => {
-    const desc = createSelfCustodialDescriptor("Spark")
+    const desc = createSelfCustodialDescriptor("sc-id-1", "Spark")
 
-    expect(desc.id).toBe(DefaultAccountId.SelfCustodial)
+    expect(desc.id).toBe("sc-id-1")
     expect(desc.type).toBe(AccountType.SelfCustodial)
     expect(desc.label).toBe("Spark")
     expect(desc.selected).toBe(false)
@@ -175,11 +202,11 @@ describe("createSelfCustodialDescriptor", () => {
 describe("markSelected", () => {
   const accounts = [
     createCustodialDescriptor("Blink"),
-    createSelfCustodialDescriptor("Spark"),
+    createSelfCustodialDescriptor("sc-id-1", "Spark"),
   ]
 
   it("marks account matching activeId as selected", () => {
-    const result = markSelected(accounts, DefaultAccountId.SelfCustodial)
+    const result = markSelected(accounts, "sc-id-1")
 
     expect(result[0].selected).toBe(false)
     expect(result[1].selected).toBe(true)

__tests__/hooks/use-wallet-mnemonic.spec.ts

@@ -1,46 +1,74 @@
 import { renderHook, waitFor } from "@testing-library/react-native"
 
 import { useWalletMnemonic, useWalletMnemonicWords } from "@app/hooks/use-wallet-mnemonic"
+import { AccountType } from "@app/types/wallet.types"
 
-const mockGetMnemonic = jest.fn()
+const mockGetMnemonicForAccount = jest.fn()
+const mockUseActiveWallet = jest.fn()
+const mockUseAccountRegistry = jest.fn()
 
 jest.mock("@app/utils/storage/secureStorage", () => ({
   __esModule: true,
   default: {
-    getMnemonic: () => mockGetMnemonic(),
+    getMnemonicForAccount: (accountId: string) => mockGetMnemonicForAccount(accountId),
   },
 }))
 
+jest.mock("@app/hooks/use-active-wallet", () => ({
+  useActiveWallet: () => mockUseActiveWallet(),
+}))
+
+jest.mock("@app/hooks/use-account-registry", () => ({
+  useAccountRegistry: () => mockUseAccountRegistry(),
+}))
+
+const ACCOUNT_ID = "sc-uuid-1"
+
+const setActiveSelfCustodial = (): void => {
+  mockUseActiveWallet.mockReturnValue({ isSelfCustodial: true })
+  mockUseAccountRegistry.mockReturnValue({
+    activeAccount: { id: ACCOUNT_ID, type: AccountType.SelfCustodial },
+  })
+}
+
+const setNoActiveAccount = (): void => {
+  mockUseActiveWallet.mockReturnValue({ isSelfCustodial: false })
+  mockUseAccountRegistry.mockReturnValue({ activeAccount: undefined })
+}
+
 describe("useWalletMnemonic", () => {
   beforeEach(() => {
     jest.clearAllMocks()
   })
 
-  it("returns empty string initially", () => {
-    mockGetMnemonic.mockResolvedValue(null)
+  it("returns empty string when no self-custodial account is active", () => {
+    setNoActiveAccount()
 
     const { result } = renderHook(() => useWalletMnemonic())
 
     expect(result.current).toBe("")
   })
 
-  it("loads mnemonic from keychain", async () => {
-    mockGetMnemonic.mockResolvedValue("word1 word2 word3")
+  it("loads mnemonic from keychain for the active account", async () => {
+    setActiveSelfCustodial()
+    mockGetMnemonicForAccount.mockResolvedValue("word1 word2 word3")
 
     const { result } = renderHook(() => useWalletMnemonic())
 
     await waitFor(() => {
       expect(result.current).toBe("word1 word2 word3")
     })
+    expect(mockGetMnemonicForAccount).toHaveBeenCalledWith(ACCOUNT_ID)
   })
 
-  it("does not set state when keychain returns null", async () => {
-    mockGetMnemonic.mockResolvedValue(null)
+  it("keeps state empty when keychain returns null", async () => {
+    setActiveSelfCustodial()
+    mockGetMnemonicForAccount.mockResolvedValue(null)
 
     const { result } = renderHook(() => useWalletMnemonic())
 
     await waitFor(() => {
-      expect(mockGetMnemonic).toHaveBeenCalled()
+      expect(mockGetMnemonicForAccount).toHaveBeenCalled()
     })
 
     expect(result.current).toBe("")
@@ -53,15 +81,16 @@ describe("useWalletMnemonicWords", () => {
   })
 
   it("returns empty array when no mnemonic", () => {
-    mockGetMnemonic.mockResolvedValue(null)
+    setNoActiveAccount()
 
     const { result } = renderHook(() => useWalletMnemonicWords())
 
     expect(result.current).toEqual([])
   })
 
   it("splits mnemonic into words", async () => {
-    mockGetMnemonic.mockResolvedValue("alpha beta gamma")
+    setActiveSelfCustodial()
+    mockGetMnemonicForAccount.mockResolvedValue("alpha beta gamma")
 
     const { result } = renderHook(() => useWalletMnemonicWords())
 

__tests__/persistent-storage.spec.ts

@@ -25,20 +25,18 @@ it("returns default when schema is not present", async () => {
   expect(state).toEqual(defaultPersistentState)
 })
 
-it("migration from 5 to 7", async () => {
+it("migration from 5 to current", async () => {
   const state5 = {
     schemaVersion: 5,
     galoyInstance: { id: "Main" },
     galoyAuthToken: "myToken",
   }
 
-  const state7 = {
-    schemaVersion: 7,
-    galoyInstance: { id: "Main" },
-    galoyAuthToken: "myToken",
-  }
-
   const res = await migrateAndGetPersistentState(state5)
 
-  expect(res).toStrictEqual(state7)
+  expect(res).toStrictEqual({
+    schemaVersion: 9,
+    galoyInstance: { id: "Main" },
+    galoyAuthToken: "myToken",
+  })
 })