@hongming-wang/usdc-bridge-widget 0.1.0

package/src/__tests__/icons.test.tsx

@@ -0,0 +1,159 @@
+import { describe, it, expect } from "vitest";
+import { render } from "@testing-library/react";
+import React from "react";
+import {
+  ChevronDownIcon,
+  SwapIcon,
+  SpinnerIcon,
+  CheckIcon,
+  ErrorIcon,
+  ExternalLinkIcon,
+  WalletIcon,
+} from "../icons";
+
+describe("ChevronDownIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<ChevronDownIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+    expect(svg?.getAttribute("aria-hidden")).toBe("true");
+  });
+
+  it("applies default size", () => {
+    const { container } = render(<ChevronDownIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("width")).toBe("16");
+    expect(svg?.getAttribute("height")).toBe("16");
+  });
+
+  it("applies custom size", () => {
+    const { container } = render(<ChevronDownIcon size={24} />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("width")).toBe("24");
+    expect(svg?.getAttribute("height")).toBe("24");
+  });
+
+  it("applies custom color", () => {
+    const { container } = render(<ChevronDownIcon color="#ff0000" />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("stroke")).toBe("#ff0000");
+  });
+
+  it("applies custom style", () => {
+    const { container } = render(
+      <ChevronDownIcon style={{ opacity: 0.5 }} />
+    );
+    const svg = container.querySelector("svg");
+    expect(svg?.style.opacity).toBe("0.5");
+  });
+});
+
+describe("SwapIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<SwapIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has default size of 20", () => {
+    const { container } = render(<SwapIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("width")).toBe("20");
+  });
+});
+
+describe("SpinnerIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<SpinnerIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has animation style", () => {
+    const { container } = render(<SpinnerIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg?.style.animation).toContain("spin");
+  });
+});
+
+describe("CheckIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<CheckIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has check path", () => {
+    const { container } = render(<CheckIcon />);
+    const path = container.querySelector("path");
+    expect(path?.getAttribute("d")).toContain("5 13");
+  });
+});
+
+describe("ErrorIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<ErrorIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has X path", () => {
+    const { container } = render(<ErrorIcon />);
+    const path = container.querySelector("path");
+    expect(path?.getAttribute("d")).toContain("6 18");
+  });
+});
+
+describe("ExternalLinkIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<ExternalLinkIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has default size of 16", () => {
+    const { container } = render(<ExternalLinkIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("width")).toBe("16");
+  });
+});
+
+describe("WalletIcon", () => {
+  it("renders an SVG element", () => {
+    const { container } = render(<WalletIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg).toBeDefined();
+  });
+
+  it("has default size of 20", () => {
+    const { container } = render(<WalletIcon />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("width")).toBe("20");
+  });
+});
+
+describe("All icons", () => {
+  const icons = [
+    { Component: ChevronDownIcon, name: "ChevronDownIcon" },
+    { Component: SwapIcon, name: "SwapIcon" },
+    { Component: SpinnerIcon, name: "SpinnerIcon" },
+    { Component: CheckIcon, name: "CheckIcon" },
+    { Component: ErrorIcon, name: "ErrorIcon" },
+    { Component: ExternalLinkIcon, name: "ExternalLinkIcon" },
+    { Component: WalletIcon, name: "WalletIcon" },
+  ];
+
+  icons.forEach(({ Component, name }) => {
+    it(`${name} is accessible (aria-hidden)`, () => {
+      const { container } = render(<Component />);
+      const svg = container.querySelector("svg");
+      expect(svg?.getAttribute("aria-hidden")).toBe("true");
+    });
+
+    it(`${name} uses currentColor by default`, () => {
+      const { container } = render(<Component />);
+      const svg = container.querySelector("svg");
+      expect(svg?.getAttribute("stroke")).toBe("currentColor");
+    });
+  });
+});

package/src/__tests__/setup.ts

@@ -0,0 +1,8 @@
+import "@testing-library/jest-dom/vitest";
+
+// Mock ResizeObserver for tests
+(globalThis as typeof globalThis & { ResizeObserver: typeof ResizeObserver }).ResizeObserver = class ResizeObserver {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};

package/src/__tests__/theme.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect } from "vitest";
+import {
+  defaultTheme,
+  mergeTheme,
+  themePresets,
+  THEME_COLORS,
+  THEME_SIZING,
+  THEME_FONTS,
+} from "../theme";
+
+describe("THEME_COLORS", () => {
+  it("has all required color keys", () => {
+    expect(THEME_COLORS.primary).toBeDefined();
+    expect(THEME_COLORS.secondary).toBeDefined();
+    expect(THEME_COLORS.success).toBeDefined();
+    expect(THEME_COLORS.error).toBeDefined();
+    expect(THEME_COLORS.text).toBeDefined();
+    expect(THEME_COLORS.mutedText).toBeDefined();
+    expect(THEME_COLORS.border).toBeDefined();
+    expect(THEME_COLORS.background).toBeDefined();
+    expect(THEME_COLORS.hover).toBeDefined();
+  });
+
+  it("has valid hex color for primary", () => {
+    expect(THEME_COLORS.primary).toMatch(/^#[0-9a-fA-F]{6}$/);
+  });
+
+  it("has valid rgba color for background", () => {
+    expect(THEME_COLORS.background).toContain("rgba");
+  });
+});
+
+describe("THEME_SIZING", () => {
+  it("has border radius as number", () => {
+    expect(typeof THEME_SIZING.borderRadius).toBe("number");
+    expect(THEME_SIZING.borderRadius).toBeGreaterThan(0);
+  });
+
+  it("has valid max width", () => {
+    expect(THEME_SIZING.maxWidth).toBe("480px");
+  });
+});
+
+describe("THEME_FONTS", () => {
+  it("has font family string", () => {
+    expect(typeof THEME_FONTS.family).toBe("string");
+    expect(THEME_FONTS.family.length).toBeGreaterThan(0);
+  });
+
+  it("has font sizes object", () => {
+    expect(THEME_FONTS.sizes.xs).toBeDefined();
+    expect(THEME_FONTS.sizes.sm).toBeDefined();
+    expect(THEME_FONTS.sizes.base).toBeDefined();
+    expect(THEME_FONTS.sizes.lg).toBeDefined();
+  });
+
+  it("has font weights object", () => {
+    expect(THEME_FONTS.weights.normal).toBe(400);
+    expect(THEME_FONTS.weights.medium).toBe(500);
+    expect(THEME_FONTS.weights.semibold).toBe(600);
+    expect(THEME_FONTS.weights.bold).toBe(700);
+  });
+});
+
+describe("defaultTheme", () => {
+  it("has all required properties", () => {
+    expect(defaultTheme.primaryColor).toBeDefined();
+    expect(defaultTheme.secondaryColor).toBeDefined();
+    expect(defaultTheme.backgroundColor).toBeDefined();
+    expect(defaultTheme.cardBackgroundColor).toBeDefined();
+    expect(defaultTheme.textColor).toBeDefined();
+    expect(defaultTheme.mutedTextColor).toBeDefined();
+    expect(defaultTheme.borderColor).toBeDefined();
+    expect(defaultTheme.successColor).toBeDefined();
+    expect(defaultTheme.errorColor).toBeDefined();
+    expect(defaultTheme.hoverColor).toBeDefined();
+    expect(defaultTheme.borderRadius).toBeDefined();
+    expect(defaultTheme.fontFamily).toBeDefined();
+  });
+
+  it("uses THEME_COLORS values", () => {
+    expect(defaultTheme.primaryColor).toBe(THEME_COLORS.primary);
+    expect(defaultTheme.successColor).toBe(THEME_COLORS.success);
+    expect(defaultTheme.errorColor).toBe(THEME_COLORS.error);
+    expect(defaultTheme.hoverColor).toBe(THEME_COLORS.hover);
+  });
+});
+
+describe("mergeTheme", () => {
+  it("returns default theme when no override provided", () => {
+    const result = mergeTheme();
+    expect(result).toEqual(defaultTheme);
+  });
+
+  it("returns default theme when undefined provided", () => {
+    const result = mergeTheme(undefined);
+    expect(result).toEqual(defaultTheme);
+  });
+
+  it("merges partial theme with defaults", () => {
+    const result = mergeTheme({ primaryColor: "#ff0000" });
+    expect(result.primaryColor).toBe("#ff0000");
+    expect(result.secondaryColor).toBe(defaultTheme.secondaryColor);
+    expect(result.backgroundColor).toBe(defaultTheme.backgroundColor);
+  });
+
+  it("overrides multiple properties", () => {
+    const result = mergeTheme({
+      primaryColor: "#ff0000",
+      borderRadius: 20,
+      fontFamily: "Arial",
+    });
+    expect(result.primaryColor).toBe("#ff0000");
+    expect(result.borderRadius).toBe(20);
+    expect(result.fontFamily).toBe("Arial");
+  });
+});
+
+describe("themePresets", () => {
+  it("has dark preset matching default", () => {
+    expect(themePresets.dark).toEqual(defaultTheme);
+  });
+
+  it("has light preset with inverted colors", () => {
+    expect(themePresets.light.textColor).not.toBe(defaultTheme.textColor);
+    expect(themePresets.light.backgroundColor).not.toBe(
+      defaultTheme.backgroundColor
+    );
+  });
+
+  it("has blue preset with blue primary color", () => {
+    expect(themePresets.blue.primaryColor).toBe("#3b82f6");
+  });
+
+  it("has green preset with green primary color", () => {
+    expect(themePresets.green.primaryColor).toBe("#10b981");
+  });
+
+  it("all presets have complete theme properties", () => {
+    Object.values(themePresets).forEach((preset) => {
+      expect(preset.primaryColor).toBeDefined();
+      expect(preset.secondaryColor).toBeDefined();
+      expect(preset.backgroundColor).toBeDefined();
+      expect(preset.hoverColor).toBeDefined();
+      expect(preset.borderRadius).toBeDefined();
+    });
+  });
+});

package/src/__tests__/useBridge.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useBridge, useBridgeQuote, getBridgeChain, getChainName } from "../useBridge";
+
+// Mock wagmi
+vi.mock("wagmi", () => ({
+  useAccount: vi.fn(() => ({
+    connector: {
+      getProvider: vi.fn().mockResolvedValue({
+        request: vi.fn(),
+      }),
+    },
+    isConnected: true,
+  })),
+}));
+
+// Mock Circle Bridge Kit
+vi.mock("@circle-fin/bridge-kit", () => ({
+  BridgeKit: vi.fn().mockImplementation(() => ({
+    on: vi.fn(),
+    bridge: vi.fn().mockResolvedValue({ txHash: "0x123" }),
+  })),
+  BridgeChain: {
+    Ethereum: "Ethereum",
+    Arbitrum: "Arbitrum",
+    Avalanche: "Avalanche",
+    Base: "Base",
+    Optimism: "Optimism",
+    Polygon: "Polygon",
+    Linea: "Linea",
+    Unichain: "Unichain",
+    Sonic: "Sonic",
+    World_Chain: "World_Chain",
+    Monad: "Monad",
+    Sei: "Sei",
+    XDC: "XDC",
+    HyperEVM: "HyperEVM",
+    Ink: "Ink",
+    Plume: "Plume",
+    Codex: "Codex",
+  },
+}));
+
+// Mock adapter
+vi.mock("@circle-fin/adapter-viem-v2", () => ({
+  createViemAdapterFromProvider: vi.fn().mockResolvedValue({}),
+}));
+
+describe("getBridgeChain", () => {
+  it("returns correct BridgeChain for known chain IDs", () => {
+    expect(getBridgeChain(1)).toBe("Ethereum");
+    expect(getBridgeChain(42161)).toBe("Arbitrum");
+    expect(getBridgeChain(8453)).toBe("Base");
+    expect(getBridgeChain(10)).toBe("Optimism");
+    expect(getBridgeChain(137)).toBe("Polygon");
+  });
+
+  it("returns undefined for unknown chain IDs", () => {
+    expect(getBridgeChain(99999)).toBeUndefined();
+    expect(getBridgeChain(0)).toBeUndefined();
+  });
+});
+
+describe("getChainName", () => {
+  it("returns chain name for known chains", () => {
+    expect(getChainName(1)).toBe("Ethereum");
+    expect(getChainName(42161)).toBe("Arbitrum");
+  });
+
+  it("returns fallback name for unknown chains", () => {
+    expect(getChainName(99999)).toBe("Chain_99999");
+  });
+});
+
+describe("useBridge", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("initializes with idle state", () => {
+    const { result } = renderHook(() => useBridge());
+
+    expect(result.current.state.status).toBe("idle");
+    expect(result.current.state.events).toEqual([]);
+    expect(result.current.state.txHash).toBeUndefined();
+    expect(result.current.state.error).toBeUndefined();
+  });
+
+  it("provides bridge function", () => {
+    const { result } = renderHook(() => useBridge());
+    expect(typeof result.current.bridge).toBe("function");
+  });
+
+  it("provides reset function", () => {
+    const { result } = renderHook(() => useBridge());
+    expect(typeof result.current.reset).toBe("function");
+  });
+
+  it("reset clears state back to idle", () => {
+    const { result } = renderHook(() => useBridge());
+
+    act(() => {
+      result.current.reset();
+    });
+
+    expect(result.current.state.status).toBe("idle");
+    expect(result.current.state.events).toEqual([]);
+  });
+});
+
+describe("useBridgeQuote", () => {
+  it("returns null quote when inputs are invalid", () => {
+    const { result } = renderHook(() =>
+      useBridgeQuote(undefined, undefined, "")
+    );
+
+    expect(result.current.quote).toBeNull();
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("returns null quote for zero amount", () => {
+    const { result } = renderHook(() => useBridgeQuote(1, 8453, "0"));
+
+    expect(result.current.quote).toBeNull();
+  });
+
+  it("returns null quote for negative amount", () => {
+    const { result } = renderHook(() => useBridgeQuote(1, 8453, "-100"));
+
+    expect(result.current.quote).toBeNull();
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from "vitest";
+import {
+  formatNumber,
+  parseUSDCAmount,
+  isValidPositiveAmount,
+  getErrorMessage,
+  validateAmountInput,
+  validateChainConfig,
+  validateChainConfigs,
+  MAX_USDC_AMOUNT,
+} from "../utils";
+import type { BridgeChainConfig } from "../types";
+
+describe("formatNumber", () => {
+  it("formats integers with decimal places", () => {
+    expect(formatNumber(1000)).toBe("1,000.00");
+  });
+
+  it("formats decimal numbers", () => {
+    expect(formatNumber(1234.567, 2)).toBe("1,234.57");
+  });
+
+  it("formats string numbers", () => {
+    expect(formatNumber("1000.5", 2)).toBe("1,000.50");
+  });
+
+  it("returns '0' for NaN", () => {
+    expect(formatNumber("invalid")).toBe("0");
+    expect(formatNumber(NaN)).toBe("0");
+  });
+
+  it("respects custom decimal places", () => {
+    expect(formatNumber(1234.56789, 4)).toBe("1,234.5679");
+    expect(formatNumber(1234.5, 0)).toBe("1,235");
+  });
+
+  it("handles zero correctly", () => {
+    expect(formatNumber(0)).toBe("0.00");
+    expect(formatNumber("0")).toBe("0.00");
+  });
+});
+
+describe("parseUSDCAmount", () => {
+  it("parses valid amount strings", () => {
+    expect(parseUSDCAmount("100")).toBe(100000000n);
+    expect(parseUSDCAmount("1.5")).toBe(1500000n);
+    expect(parseUSDCAmount("0.000001")).toBe(1n);
+  });
+
+  it("returns null for empty string", () => {
+    expect(parseUSDCAmount("")).toBe(null);
+  });
+
+  it("returns null for negative amounts", () => {
+    expect(parseUSDCAmount("-100")).toBe(null);
+  });
+
+  it("returns null for invalid strings", () => {
+    expect(parseUSDCAmount("abc")).toBe(null);
+    expect(parseUSDCAmount("1.2.3")).toBe(null);
+  });
+
+  it("handles zero", () => {
+    expect(parseUSDCAmount("0")).toBe(0n);
+  });
+});
+
+describe("isValidPositiveAmount", () => {
+  it("returns true for positive numbers", () => {
+    expect(isValidPositiveAmount("100")).toBe(true);
+    expect(isValidPositiveAmount("0.001")).toBe(true);
+  });
+
+  it("returns false for zero", () => {
+    expect(isValidPositiveAmount("0")).toBe(false);
+  });
+
+  it("returns false for negative numbers", () => {
+    expect(isValidPositiveAmount("-100")).toBe(false);
+  });
+
+  it("returns false for empty string", () => {
+    expect(isValidPositiveAmount("")).toBe(false);
+  });
+
+  it("returns false for invalid strings", () => {
+    expect(isValidPositiveAmount("abc")).toBe(false);
+  });
+});
+
+describe("getErrorMessage", () => {
+  it("extracts message from Error objects", () => {
+    expect(getErrorMessage(new Error("Test error"))).toBe("Test error");
+  });
+
+  it("returns string errors as-is", () => {
+    expect(getErrorMessage("String error")).toBe("String error");
+  });
+
+  it("extracts message from error-like objects", () => {
+    expect(getErrorMessage({ message: "Object error" })).toBe("Object error");
+  });
+
+  it("returns default message for unknown errors", () => {
+    expect(getErrorMessage(null)).toBe("An unknown error occurred");
+    expect(getErrorMessage(undefined)).toBe("An unknown error occurred");
+    expect(getErrorMessage(123)).toBe("An unknown error occurred");
+  });
+});
+
+describe("validateAmountInput", () => {
+  it("accepts empty string", () => {
+    const result = validateAmountInput("");
+    expect(result.isValid).toBe(true);
+    expect(result.sanitized).toBe("");
+  });
+
+  it("accepts valid decimal numbers", () => {
+    expect(validateAmountInput("100").isValid).toBe(true);
+    expect(validateAmountInput("100.50").isValid).toBe(true);
+    expect(validateAmountInput("0.000001").isValid).toBe(true);
+  });
+
+  it("rejects scientific notation", () => {
+    const result = validateAmountInput("1e6");
+    expect(result.isValid).toBe(false);
+    expect(result.error).toBe("Scientific notation not allowed");
+  });
+
+  it("rejects negative values", () => {
+    const result = validateAmountInput("-100");
+    expect(result.isValid).toBe(false);
+    expect(result.error).toBe("Negative values not allowed");
+  });
+
+  it("accepts partial input like '.' and '0.'", () => {
+    expect(validateAmountInput(".").isValid).toBe(true);
+    expect(validateAmountInput("0.").isValid).toBe(true);
+  });
+
+  it("truncates to max 6 decimal places", () => {
+    const result = validateAmountInput("1.12345678");
+    expect(result.isValid).toBe(false);
+    expect(result.sanitized).toBe("1.123456");
+    expect(result.error).toBe("Maximum 6 decimal places");
+  });
+
+  it("removes leading zeros", () => {
+    const result = validateAmountInput("007");
+    expect(result.isValid).toBe(true);
+    expect(result.sanitized).toBe("7");
+  });
+
+  it("preserves 0. prefix", () => {
+    const result = validateAmountInput("0.5");
+    expect(result.isValid).toBe(true);
+    expect(result.sanitized).toBe("0.5");
+  });
+});
+
+describe("validateChainConfig", () => {
+  const validConfig: BridgeChainConfig = {
+    chain: { id: 1, name: "Ethereum" } as BridgeChainConfig["chain"],
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    tokenMessengerAddress: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+  };
+
+  it("accepts valid chain config", () => {
+    const result = validateChainConfig(validConfig);
+    expect(result.isValid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("rejects missing chain object", () => {
+    const result = validateChainConfig({
+      chain: undefined as unknown as BridgeChainConfig["chain"],
+      usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    });
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain("Chain object is required");
+  });
+
+  it("rejects invalid chain ID", () => {
+    const result = validateChainConfig({
+      ...validConfig,
+      chain: { id: -1, name: "Test" } as BridgeChainConfig["chain"],
+    });
+    expect(result.isValid).toBe(false);
+    expect(result.errors.some((e) => e.includes("Invalid chain ID"))).toBe(true);
+  });
+
+  it("rejects missing USDC address", () => {
+    const result = validateChainConfig({
+      chain: { id: 1, name: "Ethereum" } as BridgeChainConfig["chain"],
+      usdcAddress: "" as `0x${string}`,
+    });
+    expect(result.isValid).toBe(false);
+    expect(result.errors.some((e) => e.includes("USDC address is required"))).toBe(true);
+  });
+
+  it("rejects invalid USDC address format", () => {
+    const result = validateChainConfig({
+      ...validConfig,
+      usdcAddress: "invalid-address" as `0x${string}`,
+    });
+    expect(result.isValid).toBe(false);
+    expect(result.errors.some((e) => e.includes("Invalid USDC address"))).toBe(true);
+  });
+});
+
+describe("validateChainConfigs", () => {
+  const validConfigs: BridgeChainConfig[] = [
+    {
+      chain: { id: 1, name: "Ethereum" } as BridgeChainConfig["chain"],
+      usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    },
+    {
+      chain: { id: 8453, name: "Base" } as BridgeChainConfig["chain"],
+      usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    },
+  ];
+
+  it("accepts valid chain configs array", () => {
+    const result = validateChainConfigs(validConfigs);
+    expect(result.isValid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("rejects non-array input", () => {
+    const result = validateChainConfigs("not an array" as unknown as BridgeChainConfig[]);
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain("Chain configs must be an array");
+  });
+
+  it("rejects empty array", () => {
+    const result = validateChainConfigs([]);
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain("At least one chain configuration is required");
+  });
+
+  it("rejects single chain (need at least 2 for bridging)", () => {
+    const result = validateChainConfigs([validConfigs[0]]);
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain("At least two chains are required for bridging");
+  });
+
+  it("rejects duplicate chain IDs", () => {
+    const result = validateChainConfigs([
+      validConfigs[0],
+      { ...validConfigs[0] }, // Same chain ID
+    ]);
+    expect(result.isValid).toBe(false);
+    expect(result.errors.some((e) => e.includes("Duplicate chain ID"))).toBe(true);
+  });
+});