feat(spark): self-custodial payments and transaction history

__mocks__/@breeztech/breez-sdk-spark-react-native.js

@@ -18,11 +18,55 @@ const PaymentDetails_Tags = {
   Deposit: "Deposit",
 }
 
+const createInstanceOf = (targetTag) => ({
+  instanceOf: (obj) => obj?.tag === targetTag,
+})
+
+const PaymentDetails = {
+  Lightning: createInstanceOf("Lightning"),
+  Spark: createInstanceOf("Spark"),
+  Token: createInstanceOf("Token"),
+  Deposit: createInstanceOf("Deposit"),
+  Withdraw: createInstanceOf("Withdraw"),
+}
+
+const SdkError_Tags = {
+  SparkError: "SparkError",
+  InsufficientFunds: "InsufficientFunds",
+  InvalidUuid: "InvalidUuid",
+  InvalidInput: "InvalidInput",
+  NetworkError: "NetworkError",
+  StorageError: "StorageError",
+  ChainServiceError: "ChainServiceError",
+  MaxDepositClaimFeeExceeded: "MaxDepositClaimFeeExceeded",
+  MissingUtxo: "MissingUtxo",
+  LnurlError: "LnurlError",
+  Signer: "Signer",
+  Generic: "Generic",
+}
+
+const SdkError = {
+  instanceOf: (obj) =>
+    Boolean(obj) &&
+    typeof obj === "object" &&
+    typeof obj.tag === "string" &&
+    Object.values(SdkError_Tags).includes(obj.tag),
+}
+
 module.exports = {
   connect: jest.fn(),
   defaultConfig: jest.fn().mockReturnValue({}),
   initLogging: jest.fn(),
+  BitcoinNetwork: { Bitcoin: 0, Testnet3: 1, Testnet4: 2, Signet: 3, Regtest: 4 },
+  InputType_Tags: { SparkAddress: "SparkAddress", BitcoinAddress: "BitcoinAddress" },
   Network: { Mainnet: 0, Regtest: 1 },
+  OnchainConfirmationSpeed: { Fast: 0, Medium: 1, Slow: 2 },
+  SendPaymentOptions: {
+    BitcoinAddress: jest.fn().mockImplementation((args) => ({
+      tag: "BitcoinAddress",
+      ...args,
+    })),
+  },
   Seed: { Mnemonic: jest.fn().mockImplementation((args) => args) },
   StableBalanceActiveLabel: {
     Set: jest.fn().mockImplementation((args) => ({ tag: "Set", inner: args })),
@@ -40,4 +84,15 @@ module.exports = {
   PaymentStatus: { Completed: 0, Pending: 1, Failed: 2 },
   PaymentType: { Send: 0, Receive: 1 },
   PaymentDetails_Tags,
+  PaymentDetails,
+  SdkError,
+  SdkError_Tags,
+  ServiceStatus: {
+    Operational: 0,
+    Degraded: 1,
+    Partial: 2,
+    Unknown: 3,
+    Major: 4,
+  },
+  getSparkStatus: jest.fn().mockResolvedValue({ status: 0, lastUpdated: BigInt(0) }),
 }

__tests__/components/self-custodial-payment-offline-notice.spec.tsx

@@ -0,0 +1,77 @@
+import React from "react"
+import { fireEvent, render } from "@testing-library/react-native"
+import { ThemeProvider } from "@rn-vui/themed"
+
+import theme from "@app/rne-theme/theme"
+
+import { SelfCustodialPaymentOfflineNotice } from "@app/components/self-custodial-payment-offline-notice"
+
+const mockRefreshWallets = jest.fn()
+
+jest.mock("@app/self-custodial/providers/wallet-provider", () => ({
+  useSelfCustodialWallet: () => ({
+    refreshWallets: mockRefreshWallets,
+  }),
+}))
+
+jest.mock("@app/i18n/i18n-react", () => ({
+  useI18nContext: () => ({
+    LL: {
+      SelfCustodialOffline: {
+        title: () => "Wallet is offline",
+        description: () =>
+          "Your non-custodial wallet can't reach the network right now. Try again when you're back online.",
+        retry: () => "Try again",
+      },
+    },
+  }),
+}))
+
+const renderNotice = () =>
+  render(
+    <ThemeProvider theme={theme}>
+      <SelfCustodialPaymentOfflineNotice />
+    </ThemeProvider>,
+  )
+
+describe("SelfCustodialPaymentOfflineNotice", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("renders the offline title and description", () => {
+    const { getByText } = renderNotice()
+
+    expect(getByText("Wallet is offline")).toBeTruthy()
+    expect(
+      getByText(
+        "Your non-custodial wallet can't reach the network right now. Try again when you're back online.",
+      ),
+    ).toBeTruthy()
+  })
+
+  it("renders the retry button", () => {
+    const { getByTestId } = renderNotice()
+
+    expect(getByTestId("self-custodial-payment-offline-retry")).toBeTruthy()
+  })
+
+  it("calls refreshWallets when the retry button is pressed", () => {
+    const { getByTestId } = renderNotice()
+
+    fireEvent.press(getByTestId("self-custodial-payment-offline-retry"))
+
+    expect(mockRefreshWallets).toHaveBeenCalledTimes(1)
+  })
+
+  it("is idempotent: pressing retry multiple times fires a call each time", () => {
+    const { getByTestId } = renderNotice()
+
+    const retryButton = getByTestId("self-custodial-payment-offline-retry")
+    fireEvent.press(retryButton)
+    fireEvent.press(retryButton)
+    fireEvent.press(retryButton)
+
+    expect(mockRefreshWallets).toHaveBeenCalledTimes(3)
+  })
+})

__tests__/components/unclaimed-deposit-banner/unclaimed-deposit-banner.spec.tsx

@@ -0,0 +1,134 @@
+import React from "react"
+import { fireEvent, render, waitFor } from "@testing-library/react-native"
+import { ThemeProvider } from "@rn-vui/themed"
+
+import theme from "@app/rne-theme/theme"
+import { UnclaimedDepositBanner } from "@app/components/unclaimed-deposit-banner/unclaimed-deposit-banner"
+import { DepositStatus, type PendingDeposit } from "@app/types/payment.types"
+import { WalletCurrency } from "@app/graphql/generated"
+
+const mockNavigate = jest.fn()
+const mockListPendingDeposits = jest.fn()
+let mockWallets: unknown[] = []
+let mockListPendingDepositsImpl: typeof mockListPendingDeposits | undefined =
+  mockListPendingDeposits
+
+jest.mock("@react-navigation/native", () => ({
+  useNavigation: () => ({ navigate: mockNavigate }),
+  useFocusEffect: (cb: () => void) => {
+    cb()
+  },
+}))
+
+jest.mock("@app/hooks/use-payments", () => ({
+  usePayments: () => ({ listPendingDeposits: mockListPendingDepositsImpl }),
+}))
+
+jest.mock("@app/self-custodial/providers/wallet-provider", () => ({
+  useSelfCustodialWallet: () => ({ wallets: mockWallets }),
+}))
+
+jest.mock("@app/i18n/i18n-react", () => ({
+  useI18nContext: () => ({
+    LL: {
+      UnclaimedDeposit: {
+        title: ({ count }: { count: number }) => `${count} pending`,
+        description: ({ sats }: { sats: number }) => `${sats} sats`,
+      },
+    },
+  }),
+}))
+
+const buildDeposit = (overrides: Partial<PendingDeposit> = {}): PendingDeposit => ({
+  id: "deposit-1",
+  txid: "tx",
+  vout: 0,
+  amount: { amount: 1000, currency: WalletCurrency.Btc, currencyCode: "BTC" },
+  status: DepositStatus.Claimable,
+  errorReason: null,
+  ...overrides,
+})
+
+const renderBanner = () =>
+  render(
+    <ThemeProvider theme={theme}>
+      <UnclaimedDepositBanner />
+    </ThemeProvider>,
+  )
+
+describe("UnclaimedDepositBanner", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockWallets = []
+    mockListPendingDepositsImpl = mockListPendingDeposits
+    mockListPendingDeposits.mockResolvedValue({ deposits: [] })
+  })
+
+  it("renders nothing when there are no pending deposits", async () => {
+    const { queryByTestId } = renderBanner()
+
+    await waitFor(() => expect(mockListPendingDeposits).toHaveBeenCalled())
+
+    expect(queryByTestId("unclaimed-deposit-banner")).toBeNull()
+  })
+
+  it("renders count and total sats when deposits are pending", async () => {
+    mockListPendingDeposits.mockResolvedValue({
+      deposits: [
+        buildDeposit({
+          id: "1",
+          amount: { amount: 1000, currency: WalletCurrency.Btc, currencyCode: "BTC" },
+        }),
+        buildDeposit({
+          id: "2",
+          amount: { amount: 2500, currency: WalletCurrency.Btc, currencyCode: "BTC" },
+        }),
+      ],
+    })
+
+    const { findByText } = renderBanner()
+
+    expect(await findByText("2 pending")).toBeTruthy()
+    expect(await findByText("3500 sats")).toBeTruthy()
+  })
+
+  it("filters out refunded deposits from the count and total", async () => {
+    mockListPendingDeposits.mockResolvedValue({
+      deposits: [
+        buildDeposit({ id: "1", status: DepositStatus.Claimable }),
+        buildDeposit({
+          id: "2",
+          status: DepositStatus.Refunded,
+          amount: { amount: 9999, currency: WalletCurrency.Btc, currencyCode: "BTC" },
+        }),
+      ],
+    })
+
+    const { findByText } = renderBanner()
+
+    expect(await findByText("1 pending")).toBeTruthy()
+    expect(await findByText("1000 sats")).toBeTruthy()
+  })
+
+  it("navigates to the unclaimed-deposits screen on press", async () => {
+    mockListPendingDeposits.mockResolvedValue({
+      deposits: [buildDeposit()],
+    })
+
+    const { findByTestId } = renderBanner()
+    const banner = await findByTestId("unclaimed-deposit-banner")
+
+    fireEvent.press(banner)
+
+    expect(mockNavigate).toHaveBeenCalledWith("unclaimedDepositsScreen")
+  })
+
+  it("does nothing when listPendingDeposits is undefined (custodial / loading)", () => {
+    mockListPendingDepositsImpl = undefined
+
+    const { queryByTestId } = renderBanner()
+
+    expect(queryByTestId("unclaimed-deposit-banner")).toBeNull()
+    expect(mockListPendingDeposits).not.toHaveBeenCalled()
+  })
+})

__tests__/hooks/use-payments.spec.ts

@@ -4,10 +4,32 @@ import { AccountType } from "@app/types/wallet.types"
 
 import { usePayments } from "@app/hooks/use-payments"
 
+const mockActiveAccount = jest.fn()
+
 jest.mock("@app/hooks/use-account-registry", () => ({
   useAccountRegistry: () => ({
-    activeAccount: { id: "custodial-default", type: "custodial" },
+    activeAccount: mockActiveAccount(),
+  }),
+}))
+
+const mockSdk = {}
+const mockSelfCustodialWallet = jest.fn()
+
+jest.mock("@app/self-custodial/providers/wallet-provider", () => ({
+  useSelfCustodialWallet: () => mockSelfCustodialWallet(),
+}))
+
+jest.mock("@app/self-custodial/bridge", () => ({
+  createSendPayment: jest.fn().mockReturnValue(jest.fn()),
+  createGetFee: jest.fn().mockReturnValue(jest.fn()),
+  createReceiveLightning: jest.fn().mockReturnValue(jest.fn()),
+  createReceiveOnchain: jest.fn().mockReturnValue(jest.fn()),
+  createListPendingDeposits: jest.fn().mockReturnValue(jest.fn()),
+  createClaimDeposit: jest.fn().mockReturnValue({
+    getClaimFee: jest.fn(),
+    claimDeposit: jest.fn(),
   }),
+  createConvert: jest.fn().mockReturnValue(jest.fn()),
 }))
 
 jest.mock("@app/custodial/adapters/payment-adapter", () => ({
@@ -20,6 +42,11 @@ jest.mock("@app/custodial/adapters/payment-adapter", () => ({
 }))
 
 describe("usePayments", () => {
+  beforeEach(() => {
+    mockActiveAccount.mockReturnValue({ id: "custodial-default", type: "custodial" })
+    mockSelfCustodialWallet.mockReturnValue({ sdk: undefined })
+  })
+
   it("returns accountType as custodial by default", () => {
     const { result } = renderHook(() => usePayments())
 
@@ -69,4 +96,52 @@ describe("usePayments", () => {
 
     expect(result.current.receiveOnchain).toBeUndefined()
   })
+
+  it("returns self-custodial adapters when self-custodial account with SDK", () => {
+    mockActiveAccount.mockReturnValue({
+      id: "self-custodial-default",
+      type: AccountType.SelfCustodial,
+    })
+    mockSelfCustodialWallet.mockReturnValue({ sdk: mockSdk })
+
+    const { result } = renderHook(() => usePayments())
+
+    expect(result.current.accountType).toBe(AccountType.SelfCustodial)
+    expect(result.current.sendPayment).toBeDefined()
+    expect(result.current.getFee).toBeDefined()
+    expect(result.current.receiveLightning).toBeDefined()
+    expect(result.current.receiveOnchain).toBeDefined()
+  })
+
+  it("returns no adapters while a self-custodial account is loading its SDK (regression Critical #5)", () => {
+    mockActiveAccount.mockReturnValue({
+      id: "self-custodial-default",
+      type: AccountType.SelfCustodial,
+    })
+    mockSelfCustodialWallet.mockReturnValue({ sdk: undefined })
+
+    const { result } = renderHook(() => usePayments())
+
+    expect(result.current.accountType).toBe(AccountType.SelfCustodial)
+    expect(result.current.sendPayment).toBeUndefined()
+    expect(result.current.getFee).toBeUndefined()
+    expect(result.current.receiveLightning).toBeUndefined()
+    expect(result.current.receiveOnchain).toBeUndefined()
+    expect(result.current.listPendingDeposits).toBeUndefined()
+    expect(result.current.claimDeposit).toBeUndefined()
+    expect(result.current.convert).toBeUndefined()
+  })
+
+  it("returns no adapters and undefined accountType while activeAccount is missing (loading window)", () => {
+    mockActiveAccount.mockReturnValue(undefined)
+    mockSelfCustodialWallet.mockReturnValue({ sdk: undefined })
+
+    const { result } = renderHook(() => usePayments())
+
+    expect(result.current.accountType).toBeUndefined()
+    expect(result.current.sendPayment).toBeUndefined()
+    expect(result.current.listPendingDeposits).toBeUndefined()
+    expect(result.current.claimDeposit).toBeUndefined()
+    expect(result.current.convert).toBeUndefined()
+  })
 })