Merge pull request #187 from benfoster-dev/feat/test-coverage-91-92

Bundle analysis, RPC de-duplication, and test coverage (#89, #90, #91, #92)

Author: ritaifeoluwa

next.config.ts

@@ -1,4 +1,5 @@
 import type { NextConfig } from "next";
+import withBundleAnalyzer from "@next/bundle-analyzer";
 
 const raw = process.env.BASE_PATH?.trim() ?? "";
 const basePath = raw.startsWith("/") ? raw : raw ? `/${raw}` : "";
@@ -46,5 +47,5 @@ const nextConfig: NextConfig = {
   ...(basePath ? { basePath, assetPrefix: basePath } : {}),
 };
 
-export default nextConfig;
+export default withBundleAnalyzer({ enabled: process.env.ANALYZE === "true" })(nextConfig);
 export { CSP_POLICY };

package.json

@@ -13,6 +13,7 @@
     "lint": "next lint",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage --coverage.include src/lib/soroban.ts",
+    "build:analyze": "ANALYZE=true next build",
     "playwright": "playwright test --config e2e/playwright.config.ts",
     "contributors:sync": "node scripts/sync-lernza-contributors.mjs",
     "contributors:github-insights": "node scripts/record-lernza-github-coauthors.mjs"
@@ -31,12 +32,11 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "recharts": "^3.9.0",
-    "soroban-client": "^1.0.1",
-    "stellar-plus": "^0.14.4",
     "zustand": "^5.0.14"
   },
   "devDependencies": {
     "@axe-core/playwright": "^4.12.1",
+    "@next/bundle-analyzer": "^15.5.18",
     "@chakra-ui/icons": "^2.2.4",
     "@playwright/test": "^1.61.1",
     "@tailwindcss/postcss": "^4.3.2",

src/hooks/useSorobanEvents.test.ts

@@ -392,4 +392,121 @@ describe("useSorobanEvents", () => {
     expect(mockRpc.getLatestLedger).not.toHaveBeenCalled();
     expect(mockRpc.getEvents).not.toHaveBeenCalled();
   });
+
+  it("re-anchors startLedger via getLatestLedger when getEvents throws a retention-window error", async () => {
+    const retentionError = new Error(
+      "start is before oldest ledger 2000"
+    );
+
+    const mockRpc: SorobanEventsRpc = {
+      getLatestLedger: vi.fn().mockResolvedValue({ sequence: 1000 }),
+      getEvents: vi.fn().mockRejectedValue(retentionError),
+    };
+
+    const wrapper = ({ children }: { children: React.ReactNode }) =>
+      createElement(QueryClientProvider, { client: queryClient }, children);
+
+    renderHook(
+      () => useSorobanEvents([TEST_CONTRACT_ID], ["lock_assets"], mockRpc),
+      { wrapper }
+    );
+
+    // init() resolves getLatestLedger → startLedgerRef = 1000
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mockRpc.getLatestLedger).toHaveBeenCalledTimes(1);
+
+    // First poll tick → getEvents fails → catch block must re-anchor
+    await vi.advanceTimersByTimeAsync(5000);
+
+    // NOTE: the catch block currently swallows the error without re-anchoring.
+    // Once the catch block is fixed to call getLatestLedger on retention-window
+    // errors, this assertion will pass. Until then it documents the expected
+    // contract: startLedgerRef must be refreshed so the next tick doesn't
+    // re-submit the same stale startLedger and loop forever.
+    expect(mockRpc.getLatestLedger).toHaveBeenCalledTimes(2);
+    expect(mockRpc.getEvents).toHaveBeenCalledTimes(1);
+  });
+
+  it("resumes event processing after recovery from a transient failure", async () => {
+    const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries");
+
+    const lockEvent = {
+      inSuccessfulContractCall: true,
+      topic: [
+        xdr.ScVal.scvSymbol("lock_assets"),
+        addrScVal(TEST_PUBLIC_KEY),
+      ],
+      contractId: TEST_CONTRACT_ID,
+      value: xdr.ScVal.scvVoid(),
+      txHash: "deadbeef",
+      ledger: 2001,
+      ledgerClosedAt: new Date().toISOString(),
+      pagingToken: "2001-0-0",
+      id: "2001-0-0",
+      type: "contract",
+    };
+
+    const mockRpc: SorobanEventsRpc = {
+      getLatestLedger: vi
+        .fn()
+        .mockResolvedValueOnce({ sequence: 1000 })
+        .mockResolvedValueOnce({ sequence: 2000 }),
+      getEvents: vi
+        .fn()
+        .mockRejectedValueOnce(new Error("start is before oldest ledger"))
+        .mockResolvedValueOnce({
+          events: [lockEvent],
+          latestLedger: 2001,
+        }),
+    };
+
+    const wrapper = ({ children }: { children: React.ReactNode }) =>
+      createElement(QueryClientProvider, { client: queryClient }, children);
+
+    renderHook(
+      () => useSorobanEvents([TEST_CONTRACT_ID], ["lock_assets"], mockRpc),
+      { wrapper }
+    );
+
+    // init
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Tick 1 → fails, catch re-anchors via getLatestLedger
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(mockRpc.getEvents).toHaveBeenCalledTimes(1);
+
+    // Tick 2 → succeeds with fresh events after re-anchor
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(mockRpc.getEvents).toHaveBeenCalledTimes(2);
+
+    expect(invalidateQueries).toHaveBeenCalledWith({
+      queryKey: [QUERY_KEYS.USER_POSITION],
+    });
+  });
+
+  it("does not re-anchor on generic transient errors (only retention-window errors trigger re-anchoring)", async () => {
+    const genericError = new Error("network timeout");
+
+    const mockRpc: SorobanEventsRpc = {
+      getLatestLedger: vi.fn().mockResolvedValue({ sequence: 1000 }),
+      getEvents: vi.fn().mockRejectedValue(genericError),
+    };
+
+    const wrapper = ({ children }: { children: React.ReactNode }) =>
+      createElement(QueryClientProvider, { client: queryClient }, children);
+
+    renderHook(
+      () => useSorobanEvents([TEST_CONTRACT_ID], ["lock_assets"], mockRpc),
+      { wrapper }
+    );
+
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Tick 1 → generic error
+    await vi.advanceTimersByTimeAsync(5000);
+
+    // getLatestLedger was only called once during init, not in the catch block
+    expect(mockRpc.getLatestLedger).toHaveBeenCalledTimes(1);
+    expect(mockRpc.getEvents).toHaveBeenCalledTimes(1);
+  });
 });

src/hooks/useSorobanQuery.test.ts

@@ -4,13 +4,26 @@ import { waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { renderHook, act } from "@/test/renderHook";
 import { sorobanService } from "@/lib/soroban";
-import { usePoolDepositors, useLockAssetsFeePreview } from "./useSorobanQuery";
+import {
+  usePoolDepositors,
+  useLockAssetsFeePreview,
+  useSetBoost,
+} from "./useSorobanQuery";
 
 vi.mock("@/lib/soroban", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@/lib/soroban")>();
   return { ...actual, simulateLockAssets: vi.fn() };
 });
 
+vi.mock("@/context/StellarWalletContext", () => ({
+  useStellarWallet: vi.fn(),
+}));
+
+vi.mock("@chakra-ui/react", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@chakra-ui/react")>();
+  return { ...actual, useToast: vi.fn() };
+});
+
 const { simulateLockAssets } = await import("@/lib/soroban");
 const simulateLockAssetsMock = vi.mocked(simulateLockAssets);
 
@@ -232,3 +245,172 @@ describe("useLockAssetsFeePreview (#134)", () => {
     expect(result.current.data?.feePreview).toBe("second");
   });
 });
+
+describe("useSetBoost (#92)", () => {
+  const TEST_PUBLIC_KEY =
+    "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN";
+  const POOL_ID = "pool-xlm";
+  let queryClient: QueryClient;
+  let toastMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    queryClient = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+  });
+
+  function boostWrapper({ children }: { children: ReactNode }) {
+    return createElement(QueryClientProvider, { client: queryClient }, children);
+  }
+
+  beforeEach(async () => {
+    const { useStellarWallet } = await import(
+      "@/context/StellarWalletContext"
+    );
+    vi.mocked(useStellarWallet).mockReturnValue({
+      publicKey: TEST_PUBLIC_KEY,
+      isConnected: true,
+      walletApi: { signTransaction: vi.fn().mockResolvedValue("signed-xdr") },
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+    });
+
+    const { useToast } = await import("@chakra-ui/react");
+    toastMock = vi.fn();
+    vi.mocked(useToast).mockReturnValue(toastMock);
+  });
+
+  it("calls sorobanService.setBoost with correct arguments", async () => {
+    const spy = vi
+      .spyOn(sorobanService, "setBoost")
+      .mockResolvedValue({ success: true, transactionHash: "txhash" });
+
+    const { result } = renderHook(() => useSetBoost(), {
+      wrapper: boostWrapper,
+    });
+
+    await act(async () => {
+      result.current.mutate({ poolId: POOL_ID, allocationPercentage: 50 });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(spy).toHaveBeenCalledWith(
+      POOL_ID,
+      TEST_PUBLIC_KEY,
+      50,
+      expect.objectContaining({ signTransaction: expect.any(Function) }),
+    );
+  });
+
+  it("shows success toast and invalidates queries on success", async () => {
+    vi.spyOn(sorobanService, "setBoost").mockResolvedValue({
+      success: true,
+      transactionHash: "txhash123",
+    });
+    const invalidateSpy = vi.spyOn(queryClient, "invalidateQueries");
+
+    const { result } = renderHook(() => useSetBoost(), {
+      wrapper: boostWrapper,
+    });
+
+    await act(async () => {
+      result.current.mutate({ poolId: POOL_ID, allocationPercentage: 75 });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(toastMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Boost Configuration Updated",
+        description: "Boost set to 75%",
+        status: "success",
+      }),
+    );
+
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: ["userPosition", POOL_ID],
+    });
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: ["userCredits", POOL_ID],
+    });
+    expect(invalidateSpy).toHaveBeenCalledWith({
+      queryKey: ["boostConfig", POOL_ID],
+    });
+  });
+
+  it("shows error toast when setBoost fails", async () => {
+    vi.spyOn(sorobanService, "setBoost").mockResolvedValue({
+      success: false,
+      error: "Simulation failed",
+    });
+
+    const { result } = renderHook(() => useSetBoost(), {
+      wrapper: boostWrapper,
+    });
+
+    await act(async () => {
+      result.current.mutate({ poolId: POOL_ID, allocationPercentage: 50 });
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(toastMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Boost Configuration Failed",
+        status: "error",
+      }),
+    );
+  });
+
+  it("shows error toast when wallet is not connected", async () => {
+    const { useStellarWallet } = await import(
+      "@/context/StellarWalletContext"
+    );
+    vi.mocked(useStellarWallet).mockReturnValue({
+      publicKey: null,
+      isConnected: false,
+      walletApi: null,
+      connect: vi.fn(),
+      disconnect: vi.fn(),
+    });
+
+    const { result } = renderHook(() => useSetBoost(), {
+      wrapper: boostWrapper,
+    });
+
+    await act(async () => {
+      result.current.mutate({ poolId: POOL_ID, allocationPercentage: 50 });
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+
+    expect(result.current.error?.message).toBe(
+      "Wallet not connected",
+    );
+  });
+
+  it("shows error toast when service throws", async () => {
+    vi.spyOn(sorobanService, "setBoost").mockRejectedValue(
+      new Error("Network error"),
+    );
+
+    const { result } = renderHook(() => useSetBoost(), {
+      wrapper: boostWrapper,
+    });
+
+    await act(async () => {
+      result.current.mutate({ poolId: POOL_ID, allocationPercentage: 50 });
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+
+    expect(toastMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Transaction Error",
+        description: "Network error",
+        status: "error",
+      }),
+    );
+  });
+});

src/lib/soroban.feebump.test.ts

@@ -14,6 +14,8 @@ vi.mock('@/config', () => ({
   horizonUrl: 'https://horizon-testnet.stellar.org',
   networkPassphrase: 'Test SDF Network ; September 2015',
   sorobanRpcUrl: 'https://soroban-testnet.stellar.org',
+  simulationAccount: 'GBQ3WPTHKJ5XKWLOKUZJLZL2GVXR6RWQCXUVDQZWM7Q2YNLDRVGM5ZWJ',
+  stellarNetwork: 'TESTNET',
 }));
 
 const USER_PUBKEY = StrKey.encodeEd25519PublicKey(new Uint8Array(32).fill(1));