refactor(self-custodial): extract SDK event helpers, network validation and transaction appender

Author: esaugomez31

__tests__/self-custodial/config.spec.ts

@@ -65,4 +65,16 @@ describe("SparkConfig", () => {
     expect(SparkConfig.apiKey).toBe("my-key")
     expect(SparkConfig.tokenIdentifier).toBe("my-token")
   })
+
+  it("exports SparkNetworkLabel as 'mainnet' for mainnet", () => {
+    const { SparkNetworkLabel } = loadConfig()
+
+    expect(SparkNetworkLabel).toBe("mainnet")
+  })
+
+  it("exports SparkNetworkLabel as 'regtest' for regtest", () => {
+    const { SparkNetworkLabel } = loadConfig({ BREEZ_NETWORK: "regtest" })
+
+    expect(SparkNetworkLabel).toBe("regtest")
+  })
 })

__tests__/self-custodial/mappers/transaction-mapper.spec.ts

@@ -7,6 +7,7 @@ import {
 import { AccountType } from "@app/types/wallet.types"
 
 import {
+  mapCurrency,
   mapSelfCustodialTransaction,
   mapSelfCustodialTransactions,
 } from "@app/self-custodial/mappers/transaction-mapper"
@@ -160,6 +161,20 @@ describe("mapSelfCustodialTransactions", () => {
   })
 })
 
+describe("mapCurrency", () => {
+  it("maps Token payment details to USD", () => {
+    expect(mapCurrency({ tag: "Token", inner: {} } as never)).toBe(WalletCurrency.Usd)
+  })
+
+  it("maps Lightning payment details to BTC", () => {
+    expect(mapCurrency({ tag: "Lightning", inner: {} } as never)).toBe(WalletCurrency.Btc)
+  })
+
+  it("defaults to BTC when details are undefined", () => {
+    expect(mapCurrency(undefined)).toBe(WalletCurrency.Btc)
+  })
+})
+
 describe("edge cases", () => {
   it("handles zero-amount payment", () => {
     const payment = createPayment({ amount: BigInt(0) })

__tests__/self-custodial/providers/sdk-events.spec.ts

@@ -0,0 +1,47 @@
+import {
+  extractPaymentId,
+  REFRESH_EVENTS,
+  PAYMENT_RECEIVED_EVENTS,
+} from "@app/self-custodial/providers/sdk-events"
+
+describe("sdk-events", () => {
+  describe("REFRESH_EVENTS", () => {
+    it("includes expected event tags", () => {
+      expect(REFRESH_EVENTS.size).toBeGreaterThanOrEqual(5)
+    })
+
+    it("does not include PaymentFailed", () => {
+      const tags = [...REFRESH_EVENTS]
+      expect(tags).not.toContain("PaymentFailed")
+    })
+  })
+
+  describe("PAYMENT_RECEIVED_EVENTS", () => {
+    it("has at least 2 events", () => {
+      expect(PAYMENT_RECEIVED_EVENTS.size).toBe(2)
+    })
+  })
+
+  describe("extractPaymentId", () => {
+    it("extracts id from payment event", () => {
+      const event = {
+        tag: "PaymentSucceeded",
+        inner: { payment: { id: "pay-123" } },
+      }
+
+      expect(extractPaymentId(event)).toBe("pay-123")
+    })
+
+    it("returns null when no inner", () => {
+      expect(extractPaymentId({ tag: "Synced" })).toBeNull()
+    })
+
+    it("returns null when inner has no payment", () => {
+      expect(extractPaymentId({ tag: "Synced", inner: { other: "data" } })).toBeNull()
+    })
+
+    it("returns null when inner is not an object", () => {
+      expect(extractPaymentId({ tag: "Synced", inner: "string" })).toBeNull()
+    })
+  })
+})

__tests__/self-custodial/providers/validate-network.spec.ts

@@ -0,0 +1,47 @@
+import { validateStoredNetwork } from "@app/self-custodial/providers/validate-network"
+
+const mockGetMnemonicNetwork = jest.fn()
+
+jest.mock("@app/utils/storage/secureStorage", () => ({
+  __esModule: true,
+  default: {
+    getMnemonicNetwork: () => mockGetMnemonicNetwork(),
+  },
+}))
+
+jest.mock("@app/self-custodial/config", () => ({
+  SparkNetworkLabel: "regtest",
+}))
+
+jest.mock("@app/self-custodial/logging", () => ({
+  logSdkEvent: jest.fn(),
+  SdkLogLevel: { Error: "error" },
+}))
+
+jest.mock("@react-native-firebase/crashlytics", () => () => ({
+  recordError: jest.fn(),
+}))
+
+describe("validateStoredNetwork", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("returns true when no stored network (legacy wallets)", async () => {
+    mockGetMnemonicNetwork.mockResolvedValue(null)
+
+    expect(await validateStoredNetwork()).toBe(true)
+  })
+
+  it("returns true when stored network matches config", async () => {
+    mockGetMnemonicNetwork.mockResolvedValue("regtest")
+
+    expect(await validateStoredNetwork()).toBe(true)
+  })
+
+  it("returns false on network mismatch", async () => {
+    mockGetMnemonicNetwork.mockResolvedValue("mainnet")
+
+    expect(await validateStoredNetwork()).toBe(false)
+  })
+})

__tests__/self-custodial/providers/wallet-provider.spec.tsx

@@ -1,6 +1,6 @@
 import React from "react"
 import { Text } from "react-native"
-import { render, renderHook, waitFor } from "@testing-library/react-native"
+import { act, render, renderHook, waitFor } from "@testing-library/react-native"
 
 import { AccountType, ActiveWalletStatus } from "@app/types/wallet.types"
 
@@ -60,10 +60,17 @@ jest.mock("@react-native-firebase/crashlytics", () => () => ({
 
 jest.mock("@app/self-custodial/config", () => ({
   SparkConfig: { network: 1 },
+  SparkNetworkLabel: "regtest",
+}))
+
+jest.mock("@app/self-custodial/providers/validate-network", () => ({
+  validateStoredNetwork: jest.fn().mockResolvedValue(true),
 }))
 
 jest.mock("@app/self-custodial/providers/wallet-snapshot", () => ({
   getSelfCustodialWalletSnapshot: jest.fn().mockResolvedValue([]),
+  loadMoreTransactions: jest.fn().mockResolvedValue({ transactions: [], hasMore: false }),
+  appendTransactions: jest.fn().mockImplementation((wallets: unknown) => wallets),
 }))
 
 const wrapper = ({ children }: { children: React.ReactNode }) => (
@@ -119,8 +126,11 @@ describe("SelfCustodialWalletProvider", () => {
   })
 
   it("sets error status on network mismatch", async () => {
+    const mockValidate = jest.requireMock(
+      "@app/self-custodial/providers/validate-network",
+    ).validateStoredNetwork
+    mockValidate.mockResolvedValueOnce(false)
     mockGetMnemonic.mockResolvedValue("word1 word2 word3")
-    mockGetMnemonicNetwork.mockResolvedValue("mainnet")
 
     const { result } = renderHook(() => useSelfCustodialWallet(), { wrapper })
 
@@ -131,9 +141,8 @@ describe("SelfCustodialWalletProvider", () => {
     expect(mockInitSdk).not.toHaveBeenCalled()
   })
 
-  it("allows null stored network (legacy wallets)", async () => {
+  it("initializes SDK when network validation passes", async () => {
     mockGetMnemonic.mockResolvedValue("word1 word2 word3")
-    mockGetMnemonicNetwork.mockResolvedValue(null)
     mockInitSdk.mockRejectedValue(new Error("SDK not available"))
 
     renderHook(() => useSelfCustodialWallet(), { wrapper })
@@ -348,4 +357,99 @@ describe("SelfCustodialWalletProvider", () => {
 
     expect(mockDisconnectSdk).toHaveBeenCalledWith(mockSdk)
   })
+
+  it("updates lastReceivedPaymentId when a PaymentSucceeded event carries a payment id", async () => {
+    const mockSnapshot = jest.requireMock(
+      "@app/self-custodial/providers/wallet-snapshot",
+    ).getSelfCustodialWalletSnapshot
+    mockSnapshot.mockResolvedValue({ wallets: [], hasMore: false })
+
+    let capturedListener: (event: { tag: string; inner?: unknown }) => Promise<void>
+    mockAddSdkEventListener.mockImplementation(
+      (
+        _sdk: unknown,
+        onEvent: (event: { tag: string; inner?: unknown }) => Promise<void>,
+      ) => {
+        capturedListener = onEvent
+        return Promise.resolve("id")
+      },
+    )
+
+    mockGetMnemonic.mockResolvedValue("word1 word2 word3")
+    mockInitSdk.mockResolvedValue({})
+
+    const { result } = renderHook(() => useSelfCustodialWallet(), { wrapper })
+
+    await waitFor(() => {
+      expect(mockAddSdkEventListener).toHaveBeenCalled()
+    })
+
+    await act(async () => {
+      await capturedListener!({
+        tag: "PaymentSucceeded",
+        inner: { payment: { id: "pay-new-42" } },
+      })
+    })
+
+    expect(result.current.lastReceivedPaymentId).toBe("pay-new-42")
+  })
+
+  it("does not update lastReceivedPaymentId for non-payment refresh events", async () => {
+    const mockSnapshot = jest.requireMock(
+      "@app/self-custodial/providers/wallet-snapshot",
+    ).getSelfCustodialWalletSnapshot
+    mockSnapshot.mockResolvedValue({ wallets: [], hasMore: false })
+
+    let capturedListener: (event: { tag: string }) => Promise<void>
+    mockAddSdkEventListener.mockImplementation(
+      (_sdk: unknown, onEvent: (event: { tag: string }) => Promise<void>) => {
+        capturedListener = onEvent
+        return Promise.resolve("id")
+      },
+    )
+
+    mockGetMnemonic.mockResolvedValue("word1 word2 word3")
+    mockInitSdk.mockResolvedValue({})
+
+    const { result } = renderHook(() => useSelfCustodialWallet(), { wrapper })
+
+    await waitFor(() => {
+      expect(mockAddSdkEventListener).toHaveBeenCalled()
+    })
+
+    await act(async () => {
+      await capturedListener!({ tag: "Synced" })
+    })
+
+    expect(result.current.lastReceivedPaymentId).toBeNull()
+  })
+
+  it("loadMore calls loadMoreTransactions and appends via appendTransactions", async () => {
+    const snapshot = jest.requireMock("@app/self-custodial/providers/wallet-snapshot")
+    snapshot.getSelfCustodialWalletSnapshot.mockResolvedValue({
+      wallets: [],
+      hasMore: true,
+    })
+    snapshot.loadMoreTransactions.mockResolvedValue({
+      transactions: [{ id: "tx-new" }],
+      hasMore: false,
+    })
+
+    mockGetMnemonic.mockResolvedValue("word1 word2 word3")
+    mockInitSdk.mockResolvedValue({})
+
+    const { result } = renderHook(() => useSelfCustodialWallet(), { wrapper })
+
+    await waitFor(() => {
+      expect(result.current.hasMoreTransactions).toBe(true)
+    })
+
+    await act(async () => {
+      await result.current.loadMore()
+    })
+
+    expect(snapshot.loadMoreTransactions).toHaveBeenCalled()
+    expect(snapshot.appendTransactions).toHaveBeenCalled()
+    expect(result.current.hasMoreTransactions).toBe(false)
+  })
 })

__tests__/self-custodial/providers/wallet-snapshot.spec.ts

@@ -1,6 +1,12 @@
 import { WalletCurrency } from "@app/graphql/generated"
+import { toWalletMoneyAmount } from "@app/types/amounts"
+import type { NormalizedTransaction } from "@app/types/transaction.types"
+import { AccountType, toWalletId, type WalletState } from "@app/types/wallet.types"
 
-import { getSelfCustodialWalletSnapshot } from "@app/self-custodial/providers/wallet-snapshot"
+import {
+  appendTransactions,
+  getSelfCustodialWalletSnapshot,
+} from "@app/self-custodial/providers/wallet-snapshot"
 
 jest.mock("@app/self-custodial/config", () => ({
   SparkToken: { Label: "USDB", Ticker: "USDB" },
@@ -82,3 +88,68 @@ describe("getSelfCustodialWalletSnapshot", () => {
     expect(wallets[0].transactions.length).toBeGreaterThanOrEqual(0)
   })
 })
+
+const buildTx = (id: string, currency: WalletCurrency): NormalizedTransaction => ({
+  id,
+  amount: toWalletMoneyAmount(1, currency),
+  direction: "receive",
+  status: "completed",
+  timestamp: 1,
+  paymentType: "lightning",
+  sourceAccountType: AccountType.SelfCustodial,
+})
+
+const buildWallet = (
+  currency: WalletCurrency,
+  transactions: NormalizedTransaction[] = [],
+): WalletState => ({
+  id: toWalletId(`wallet-${currency}`),
+  walletCurrency: currency,
+  balance: toWalletMoneyAmount(0, currency),
+  transactions,
+})
+
+describe("appendTransactions", () => {
+  it("appends BTC txs only to BTC wallet and USD txs only to USD wallet", () => {
+    const wallets = [buildWallet(WalletCurrency.Btc), buildWallet(WalletCurrency.Usd)]
+    const newTxs = [
+      buildTx("btc-1", WalletCurrency.Btc),
+      buildTx("usd-1", WalletCurrency.Usd),
+    ]
+
+    const result = appendTransactions(wallets, newTxs)
+
+    expect(result[0].transactions.map((t) => t.id)).toEqual(["btc-1"])
+    expect(result[1].transactions.map((t) => t.id)).toEqual(["usd-1"])
+  })
+
+  it("preserves existing transactions and appends new ones at the end", () => {
+    const existing = buildTx("existing-btc", WalletCurrency.Btc)
+    const wallets = [buildWallet(WalletCurrency.Btc, [existing])]
+    const newTxs = [buildTx("new-btc", WalletCurrency.Btc)]
+
+    const result = appendTransactions(wallets, newTxs)
+
+    expect(result[0].transactions.map((t) => t.id)).toEqual(["existing-btc", "new-btc"])
+  })
+
+  it("returns a new array without mutating the input wallets", () => {
+    const wallets = [buildWallet(WalletCurrency.Btc)]
+    const newTxs = [buildTx("btc-1", WalletCurrency.Btc)]
+
+    const result = appendTransactions(wallets, newTxs)
+
+    expect(result).not.toBe(wallets)
+    expect(result[0]).not.toBe(wallets[0])
+    expect(wallets[0].transactions).toHaveLength(0)
+  })
+
+  it("handles empty newTxs without changing transaction lists", () => {
+    const existing = buildTx("existing-btc", WalletCurrency.Btc)
+    const wallets = [buildWallet(WalletCurrency.Btc, [existing])]
+
+    const result = appendTransactions(wallets, [])
+
+    expect(result[0].transactions).toEqual([existing])
+  })
+})