@naculus/connect-appkit-react 0.1.8 → 0.2.0

package/src/hooks/useChain.test.ts

@@ -1,160 +0,0 @@
-/// <reference types="vitest" />
-/// @vitest-environment jsdom
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook } from "@testing-library/react";
-
-const mockUseWeb3 = vi.fn();
-vi.mock("../provider/Web3ConnectProvider", () => ({
-  useWeb3: () => mockUseWeb3(),
-  Web3ConnectProvider: ({ children }: { children: React.ReactNode }) => children,
-}));
-
-vi.mock("../utils/chains", () => {
-  const chains = [
-    { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-    { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-  ];
-  return {
-    getDefaultChains: () => chains,
-    getChainById: (ch: typeof chains, chainId: string) =>
-      ch.find((c: typeof chains[0]) => {
-        const ns = chainId.startsWith("eip155:")
-          ? "eip155" : null;
-        if (!ns) return false;
-        const num = chainId.includes(":") ? parseInt(chainId.split(":")[1], 10) : parseInt(chainId, 10);
-        return c.namespace === ns && c.id === num;
-      }),
-  };
-});
-
-import { useChain } from "./useChain";
-
-describe("useChain", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should return null chainId and null chainInfo when not connected", () => {
-    mockUseWeb3.mockReturnValue({
-      chainId: null,
-      session: null,
-      switchChain: vi.fn(),
-      chains: [
-        { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-        { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-      ],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    expect(result.current.chainId).toBeNull();
-    expect(result.current.currentChain).toBeNull();
-    expect(result.current.chainInfo).toBeNull();
-    // availableChains now returns all configured chains regardless of session
-    expect(result.current.availableChains).toHaveLength(2);
-  });
-
-  it("should identify EVM chain", () => {
-    mockUseWeb3.mockReturnValue({
-      chainId: "eip155:1",
-      session: {
-        topic: "test",
-        namespaces: {
-          eip155: {
-            chains: ["eip155:1"],
-            accounts: ["eip155:1:0x1234"],
-          },
-        },
-      },
-      switchChain: vi.fn(),
-      chains: [
-        { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-        { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-      ],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    expect(result.current.isEvm).toBe(true);
-    expect(result.current.currentChain?.name).toBe("Ethereum");
-    expect(result.current.chainInfo?.name).toBe("Ethereum");
-  });
-
-  it("should return chainInfo as null when no session", () => {
-    mockUseWeb3.mockReturnValue({
-      chainId: "eip155:137",
-      session: null,
-      switchChain: vi.fn(),
-      chains: [
-        { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-        { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-      ],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    expect(result.current.chainInfo).toBeNull();
-    expect(result.current.currentChain?.name).toBe("Polygon");
-  });
-
-  it("should return all configured chains as available", () => {
-    mockUseWeb3.mockReturnValue({
-      chainId: "eip155:1",
-      session: null,
-      switchChain: vi.fn(),
-      chains: [
-        { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-        { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-      ],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    // availableChains now returns all configured chains regardless of session
-    expect(result.current.availableChains.length).toBeGreaterThanOrEqual(2);
-    expect(result.current.availableChains.map((c: { name: string }) => c.name)).toEqual(
-      expect.arrayContaining(["Ethereum", "Polygon"])
-    );
-  });
-
-  it("should pass through switchChain function", () => {
-    const switchChain = vi.fn();
-    mockUseWeb3.mockReturnValue({
-      chainId: null,
-      session: null,
-      switchChain,
-      chains: [],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    result.current.switchChain("eip155:137");
-    expect(switchChain).toHaveBeenCalledWith("eip155:137");
-  });
-
-  it("should return chainInfo with selected=true", () => {
-    mockUseWeb3.mockReturnValue({
-      chainId: "eip155:137",
-      session: {
-        topic: "test",
-        namespaces: {
-          eip155: {
-            chains: ["eip155:137"],
-            accounts: ["eip155:137:0x5678"],
-          },
-        },
-      },
-      switchChain: vi.fn(),
-      chains: [
-        { id: 1, namespace: "eip155", name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", token: "ETH" },
-        { id: 137, namespace: "eip155", name: "Polygon", rpcUrl: "https://polygon-rpc.com", token: "MATIC" },
-      ],
-    });
-
-    const { result } = renderHook(() => useChain());
-
-    expect(result.current.chainInfo?.selected).toBe(true);
-    expect(result.current.chainInfo?.namespace).toBe("eip155");
-  });
-});

package/src/hooks/useChain.ts

@@ -1,53 +0,0 @@
-import { useMemo } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-import { getChainById } from "../utils/chains";
-import type { WalletChain, ChainInfo } from "../types";
-
-export function useChain() {
-  const { chainId, session, switchChain, chains } = useWeb3();
-
-  const currentChain = useMemo(() => {
-    if (!chainId) return null;
-    return getChainById(chains, chainId) ?? null;
-  }, [chainId, chains]);
-
-  const chainInfo = useMemo<ChainInfo | null>(() => {
-    if (!chainId || !session) return null;
-
-    const namespace = chainId.startsWith("eip155:")
-      ? "eip155"
-      : null;
-
-    if (!namespace) return null;
-
-    const chainNum = chainId.includes(":")
-      ? parseInt(chainId.split(":")[1], 10)
-      : parseInt(chainId, 10);
-
-    const chain = chains.find((c) => c.namespace === namespace && c.id === chainNum);
-
-    return {
-      namespace,
-      chainId,
-      name: chain?.name ?? `Chain ${chainNum}`,
-      selected: true
-    };
-  }, [chainId, session, chains]);
-
-  const availableChains = useMemo<WalletChain[]>(() => {
-    // Return all default EVM chains so users can see and switch to any supported chain
-    // The session namespace only contains the current/approved chain, but we want to
-    // make all configured chains available for switching.
-    return chains;
-  }, [chains]);
-
-  return {
-    chainId,
-    currentChain,
-    chainInfo,
-    availableChains,
-    chains: availableChains,
-    isEvm: chainId?.startsWith("eip155:"),
-    switchChain
-  };
-}

package/src/hooks/useConnect.test.ts

@@ -1,112 +0,0 @@
-/// <reference types="vitest" />
-/// @vitest-environment jsdom
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-
-const mockUseWeb3 = vi.fn();
-vi.mock("../provider/Web3ConnectProvider", () => ({
-  useWeb3: () => mockUseWeb3(),
-  Web3ConnectProvider: ({ children }: { children: React.ReactNode }) => children,
-}));
-
-import { useConnect } from "./useConnect";
-
-function mockWeb3(overrides: Record<string, unknown> = {}) {
-  return {
-    connect: vi.fn(),
-    status: "disconnected" as const,
-    ...overrides,
-  };
-}
-
-describe("useConnect", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should have initial idle state", () => {
-    mockUseWeb3.mockReturnValue(mockWeb3());
-    const { result } = renderHook(() => useConnect());
-
-    expect(result.current.isConnecting).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should call connect and succeed", async () => {
-    const connect = vi.fn().mockResolvedValue(undefined);
-    mockUseWeb3.mockReturnValue(mockWeb3({ connect }));
-
-    const { result } = renderHook(() => useConnect());
-
-    await act(async () => {
-      await result.current.connect();
-    });
-
-    expect(connect).toHaveBeenCalledTimes(1);
-    expect(result.current.isConnecting).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should set connecting state during connect", async () => {
-    let resolvePromise: () => void;
-    const connectPromise = new Promise<void>((resolve) => {
-      resolvePromise = resolve;
-    });
-    const connect = vi.fn().mockReturnValue(connectPromise);
-    mockUseWeb3.mockReturnValue(mockWeb3({ connect }));
-
-    const { result } = renderHook(() => useConnect());
-
-    let connectCallPromise: Promise<void>;
-    act(() => {
-      connectCallPromise = result.current.connect();
-    });
-
-    expect(result.current.isConnecting).toBe(true);
-
-    await act(async () => {
-      resolvePromise!();
-      await connectCallPromise!;
-    });
-
-    expect(result.current.isConnecting).toBe(false);
-  });
-
-  it("should capture error on failed connect", async () => {
-    const testError = new Error("Connection rejected");
-    const connect = vi.fn().mockRejectedValue(testError);
-    mockUseWeb3.mockReturnValue(mockWeb3({ connect }));
-
-    const { result } = renderHook(() => useConnect());
-
-    await act(async () => {
-      await result.current.connect();
-    });
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error?.message).toBe("Connection rejected");
-  });
-
-  it("should capture wallet error on failed connect", async () => {
-    const { WalletError } = await import("@naculus/connect-core");
-    const walletError = new WalletError("user_rejected", "User rejected");
-    const connect = vi.fn().mockRejectedValue(walletError);
-    mockUseWeb3.mockReturnValue(mockWeb3({ connect }));
-
-    const { result } = renderHook(() => useConnect());
-
-    await act(async () => {
-      await result.current.connect();
-    });
-
-    expect(result.current.error).toBeInstanceOf(WalletError);
-  });
-
-  it("should reflect connecting status from Web3Provider", () => {
-    mockUseWeb3.mockReturnValue(mockWeb3({ status: "connecting" }));
-    const { result } = renderHook(() => useConnect());
-
-    expect(result.current.isConnecting).toBe(true);
-  });
-});

package/src/hooks/useConnect.ts

@@ -1,29 +0,0 @@
-import { useCallback, useState } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-import { WalletError } from "@naculus/connect-core";
-
-export function useConnect() {
-  const { connect, status } = useWeb3();
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const handleConnect = useCallback(async () => {
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      await connect();
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Connection failed";
-      setError(err instanceof WalletError ? err : new Error(errorMessage));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [connect]);
-
-  return {
-    connect: handleConnect,
-    isConnecting: isLoading || status === "connecting",
-    error
-  };
-}

package/src/hooks/useDisconnect.test.ts

@@ -1,75 +0,0 @@
-/// <reference types="vitest" />
-/// @vitest-environment jsdom
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-
-const mockUseWeb3 = vi.fn();
-vi.mock("../provider/Web3ConnectProvider", () => ({
-  useWeb3: () => mockUseWeb3(),
-  Web3ConnectProvider: ({ children }: { children: React.ReactNode }) => children,
-}));
-
-import { useDisconnect } from "./useDisconnect";
-
-function mockWeb3(overrides: Record<string, unknown> = {}) {
-  return {
-    disconnect: vi.fn(),
-    status: "connected" as const,
-    ...overrides,
-  };
-}
-
-describe("useDisconnect", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should have initial idle state", () => {
-    mockUseWeb3.mockReturnValue(mockWeb3());
-    const { result } = renderHook(() => useDisconnect());
-
-    expect(result.current.isDisconnecting).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should call disconnect and succeed when connected", async () => {
-    const disconnect = vi.fn().mockResolvedValue(undefined);
-    mockUseWeb3.mockReturnValue(mockWeb3({ disconnect }));
-
-    const { result } = renderHook(() => useDisconnect());
-
-    await act(async () => {
-      await result.current.disconnect();
-    });
-
-    expect(disconnect).toHaveBeenCalledTimes(1);
-  });
-
-  it("should not call disconnect if already disconnected", async () => {
-    const disconnect = vi.fn();
-    mockUseWeb3.mockReturnValue(mockWeb3({ disconnect, status: "disconnected" }));
-
-    const { result } = renderHook(() => useDisconnect());
-
-    await act(async () => {
-      await result.current.disconnect();
-    });
-
-    expect(disconnect).not.toHaveBeenCalled();
-  });
-
-  it("should capture error on failed disconnect", async () => {
-    const disconnect = vi.fn().mockRejectedValue(new Error("Disconnect failed"));
-    mockUseWeb3.mockReturnValue(mockWeb3({ disconnect }));
-
-    const { result } = renderHook(() => useDisconnect());
-
-    await act(async () => {
-      await result.current.disconnect();
-    });
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error?.message).toBe("Disconnect failed");
-  });
-});

package/src/hooks/useDisconnect.ts

@@ -1,32 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-
-export function useDisconnect() {
-  const { disconnect, status } = useWeb3();
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const mountedRef = useRef(true);
-
-  const handleDisconnect = useCallback(async () => {
-    if (status === "disconnected") return;
-
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      await disconnect();
-    } catch (err) {
-      if (!mountedRef.current) return;
-      setError(err instanceof Error ? err : new Error("Disconnect failed"));
-    } finally {
-      if (mountedRef.current) setIsLoading(false);
-    }
-  }, [disconnect, status]);
-
-  return {
-    disconnect: handleDisconnect,
-    isDisconnecting: isLoading,
-    error,
-    cleanup: () => { mountedRef.current = false; },
-  };
-}

package/src/hooks/useERC20Allowance.ts

@@ -1,93 +0,0 @@
-import { useState, useCallback, useEffect, useRef, useMemo } from "react";
-import { useViemClient } from "./useViemClient";
-import { ERC20_MIN_ABI } from "@naculus/connect-core";
-import type { TokenConfig } from "@naculus/connect-core";
-import type { Address } from "viem";
-
-// ── Types ─────────────────────────────────────────────────────────
-
-export interface UseERC20AllowanceOptions {
-  token: TokenConfig;
-  owner: Address;
-  spender: Address;
-  refreshInterval?: number;
-}
-
-export interface UseERC20AllowanceReturn {
-  allowance: string | null;
-  allowanceRaw: bigint | null;
-  isFetching: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-}
-
-// ── Hook ──────────────────────────────────────────────────────────
-
-export function useERC20Allowance(
-  options: UseERC20AllowanceOptions,
-): UseERC20AllowanceReturn {
-  const { publicClient } = useViemClient();
-  const [allowanceRaw, setAllowanceRaw] = useState<bigint | null>(null);
-  const [isFetching, setIsFetching] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
-
-  const fetchAllowance = useCallback(async () => {
-    if (!publicClient) return;
-
-    setIsFetching(true);
-    setError(null);
-
-    try {
-      const raw = await publicClient.readContract({
-        address: options.token.address,
-        abi: ERC20_MIN_ABI,
-        functionName: "allowance",
-        args: [options.owner, options.spender],
-      });
-      setAllowanceRaw(raw as bigint);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to fetch allowance"));
-      setAllowanceRaw(null);
-    } finally {
-      setIsFetching(false);
-    }
-  }, [publicClient, options.token.address, options.owner, options.spender]);
-
-  // Initial fetch
-  useEffect(() => {
-    fetchAllowance().catch((e) => console.warn("useERC20Allowance: initial fetch failed:", e));
-  }, [fetchAllowance]);
-
-  // Auto-refresh interval
-  useEffect(() => {
-    if (options.refreshInterval && options.refreshInterval > 0) {
-      intervalRef.current = setInterval(fetchAllowance, options.refreshInterval);
-    }
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    };
-  }, [options.refreshInterval, fetchAllowance]);
-
-  const allowance = useMemo(() => {
-    if (allowanceRaw === null) return null;
-    const decimals = options.token.decimals ?? 18;
-    const str = allowanceRaw.toString();
-    const padded = str.padStart(decimals + 1, "0");
-    const dotPos = padded.length - decimals;
-    let intPart = padded.slice(0, dotPos).replace(/^0+/, "") || "0";
-    let fracPart = padded.slice(dotPos).replace(/0+$/, "");
-    return fracPart ? `${intPart}.${fracPart}` : intPart;
-  }, [allowanceRaw, options.token.decimals]);
-
-  return {
-    allowance,
-    allowanceRaw,
-    isFetching,
-    error,
-    refetch: fetchAllowance,
-  };
-}