test(self-custodial): cover Important assertion gaps I3, I5, I6, I7, I8, I9, I10

Author: esaugomez31

__tests__/self-custodial/auto-convert/executor.spec.ts

@@ -97,6 +97,22 @@ describe("waitForPaymentCompleted", () => {
     expect(settled).toBe(true)
     expect(sdk.getPayment).toHaveBeenCalledTimes(2)
   })
+
+  it("does not sleep when maxAttempts is 1 (Important #9)", async () => {
+    const setTimeoutSpy = jest.spyOn(global, "setTimeout")
+    setTimeoutSpy.mockClear()
+    const sdk = {
+      getPayment: jest.fn().mockResolvedValue({ payment: { status: "Pending" } }),
+    }
+
+    await waitForPaymentCompleted(sdk as never, "pid", { maxAttempts: 1, intervalMs: 10 })
+
+    // The `if (attempt < options.maxAttempts - 1)` guard prevents the sleep
+    // on the final attempt, so the degenerate single-attempt case has no
+    // setTimeout call at all.
+    expect(setTimeoutSpy).not.toHaveBeenCalled()
+    setTimeoutSpy.mockRestore()
+  })
 })
 
 describe("fetchAutoConvertMinSats", () => {

__tests__/self-custodial/auto-convert/storage.spec.ts

@@ -195,6 +195,22 @@ describe("auto-convert storage", () => {
       expect(mockGetItem).toHaveBeenCalledWith(STORAGE_KEY)
       expect(mockSetItem.mock.calls[0][0]).toBe(STORAGE_KEY)
     })
+
+    it("withWriteLock keeps draining when a prior write rejects (Important #6)", async () => {
+      // First setItem rejects; the chain must absorb the rejection so the
+      // next write still gets through instead of deadlocking the queue.
+      mockSetItem
+        .mockRejectedValueOnce(new Error("storage transient"))
+        .mockResolvedValue(undefined)
+      mockGetItem.mockResolvedValue(null)
+
+      await addPendingAutoConvert(makeRecord({ paymentRequest: "lnbc1A" }))
+      await addPendingAutoConvert(makeRecord({ paymentRequest: "lnbc1B" }))
+
+      // Two writes attempted (both reached AsyncStorage.setItem); the chain
+      // didn't get stuck on the first rejection.
+      expect(mockSetItem).toHaveBeenCalledTimes(2)
+    })
   })
 
   describe("AutoConvertPairings (Critical #2 dedup correlation)", () => {

__tests__/self-custodial/bridge/convert.spec.ts

@@ -153,6 +153,23 @@ describe("createGetConversionQuote — BTC → USD", () => {
 
     expect(quote).not.toBeNull()
   })
+
+  it("clamps the discovery destination up to minToAmount when it dominates (Important #8)", async () => {
+    // Target=2000 cents → halfDestination=1000; minFromAmount=0 → fromMin=0;
+    // minToAmount=1500 dominates the Math.max so the discovery destination
+    // is the to-side floor (1500 cents → 15_000_000 token base units at 6 decimals).
+    mockFetchLimits.mockResolvedValue({ minFromAmount: 0, minToAmount: 1500 })
+    const sdk = createSdk()
+
+    await createGetConversionQuote(sdk as never)({
+      fromAmount: toBtcMoneyAmount(5000),
+      toAmount: toUsdMoneyAmount(2000),
+      direction: ConvertDirection.BtcToUsd,
+    })
+
+    const prepArg = sdk.prepareSendPayment.mock.calls[0][0]
+    expect(prepArg.amount).toBe(BigInt(1500 * 10 ** 4))
+  })
 })
 
 describe("createGetConversionQuote — USD → BTC", () => {

__tests__/self-custodial/components/auto-convert-listener-mount.spec.tsx

@@ -23,4 +23,16 @@ describe("AutoConvertListenerMount", () => {
     const { toJSON } = render(<AutoConvertListenerMount />)
     expect(toJSON()).toBeNull()
   })
+
+  it("does not swallow errors thrown by the listener hook (Important #10)", () => {
+    // The wrapper has no try/catch around the hook; a crash must propagate
+    // to React rather than be silently absorbed by the wrapper.
+    mockListener.mockImplementationOnce(() => {
+      throw new Error("listener crashed")
+    })
+
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {})
+    expect(() => render(<AutoConvertListenerMount />)).toThrow("listener crashed")
+    consoleErrorSpy.mockRestore()
+  })
 })

__tests__/self-custodial/hooks/use-auto-convert-listener.spec.ts

@@ -724,4 +724,79 @@ describe("useAutoConvertListener — mount replay", () => {
     })
     expect(mockExecuteAutoConvert).toHaveBeenCalledTimes(1)
   })
+
+  it("processes pending records sequentially via reduce, not in parallel (Important #3)", async () => {
+    const sdk = makeSdk({
+      listPayments: jest.fn().mockResolvedValue({
+        payments: [
+          {
+            id: "pid-A",
+            amount: 5000n,
+            details: { tag: "Lightning", inner: { invoice: "lnbc1A" } },
+          },
+          {
+            id: "pid-B",
+            amount: 5000n,
+            details: { tag: "Lightning", inner: { invoice: "lnbc1B" } },
+          },
+        ],
+      }),
+    })
+    setupDefaults(sdk)
+    mockListPendingAutoConverts.mockResolvedValue([
+      makeRecord({ paymentRequest: "lnbc1A" }),
+      makeRecord({ paymentRequest: "lnbc1B" }),
+    ])
+
+    let resolveFirst!: (value: boolean) => void
+    const firstSettled = new Promise<boolean>((resolve) => {
+      resolveFirst = resolve
+    })
+    mockWaitForPaymentCompleted
+      .mockImplementationOnce(() => firstSettled)
+      .mockResolvedValueOnce(true)
+
+    renderHook(() => useAutoConvertListener())
+
+    // The reduce chain awaits the first record's processing before starting
+    // the second; until we resolve the first, the second must not have started.
+    await new Promise((resolve) => {
+      setTimeout(resolve, 10)
+    })
+    expect(mockWaitForPaymentCompleted).toHaveBeenCalledTimes(1)
+
+    resolveFirst(true)
+
+    await waitFor(() => {
+      expect(mockWaitForPaymentCompleted).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  it("removes the record on SkippedBelowMin without firing the success toast (Important #7)", async () => {
+    const sdk = makeSdk({
+      listPayments: jest.fn().mockResolvedValue({
+        payments: [
+          {
+            id: "pid-low",
+            amount: 100n,
+            details: { tag: "Lightning", inner: { invoice: "lnbc1low" } },
+          },
+        ],
+      }),
+    })
+    setupDefaults(sdk)
+    mockListPendingAutoConverts.mockResolvedValue([
+      makeRecord({ paymentRequest: "lnbc1low" }),
+    ])
+    mockExecuteAutoConvert.mockResolvedValue({
+      status: AutoConvertStatus.SkippedBelowMin,
+    })
+
+    renderHook(() => useAutoConvertListener())
+
+    await waitFor(() => {
+      expect(mockRemovePendingAutoConvert).toHaveBeenCalledWith("lnbc1low")
+    })
+    expect(mockToastShow).not.toHaveBeenCalled()
+  })
 })

__tests__/self-custodial/hooks/use-receive-asset-mode.spec.ts

@@ -55,6 +55,22 @@ describe("useReceiveAssetMode", () => {
       expect(result.current.assetMode).toBe("dollar")
       expect(result.current.isToggleDisabled).toBe(true)
     })
+
+    it("does NOT reset Dollar to Bitcoin when stable balance toggles OFF (Important #5)", () => {
+      // Asymmetry is intentional: ON re-aligns to Dollar to enforce the new
+      // sweep policy, but OFF preserves the user's last explicit choice so a
+      // future "fix" that resets to BTC would silently regress receive intent.
+      mockSelfCustodialWallet.mockReturnValue({ isStableBalanceActive: true })
+      const { result, rerender } = renderHook(() => useReceiveAssetMode())
+
+      expect(result.current.assetMode).toBe("dollar")
+
+      mockSelfCustodialWallet.mockReturnValue({ isStableBalanceActive: false })
+      rerender({})
+
+      expect(result.current.assetMode).toBe("dollar")
+      expect(result.current.isToggleDisabled).toBe(false)
+    })
   })
 
   describe("loading flag (Critical #7 boot window)", () => {