@naculus/connect-appkit-react 0.1.8 → 0.2.0

package/src/client.test.ts

@@ -1,242 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// Need vi.hoisted because vi.mock is hoisted above variable declarations
-const { mockWalletConnectConnector, mockEmbeddedConnector, mockSolanaConnector } = vi.hoisted(() => {
-  const wc = {
-    id: "walletconnect",
-    name: "WalletConnect",
-    kind: "walletconnect",
-    connect: vi.fn().mockResolvedValue({ id: "wc-session" }),
-    disconnect: vi.fn().mockResolvedValue(undefined),
-    reconnect: vi.fn().mockResolvedValue({ id: "wc-session" }),
-    startPairing: vi.fn().mockResolvedValue("wc://uri?key=test"),
-    completePairing: vi.fn().mockResolvedValue({ id: "wc-session" }),
-    switchChain: vi.fn().mockResolvedValue(undefined),
-    getAccounts: vi.fn().mockResolvedValue([]),
-    signMessage: vi.fn(),
-  };
-
-  const embedded = {
-    id: "embedded",
-    name: "Embedded Wallet",
-    kind: "embedded",
-    connect: vi.fn().mockResolvedValue({ id: "embedded-session", walletType: "embedded" }),
-    disconnect: vi.fn().mockResolvedValue(undefined),
-    getAccounts: vi.fn().mockResolvedValue([]),
-  };
-
-  const solana = {
-    id: "solana",
-    name: "Solana",
-    kind: "solana" as const,
-    connect: vi.fn(),
-    disconnect: vi.fn().mockResolvedValue(undefined),
-    reconnect: vi.fn(),
-    startPairing: vi.fn(),
-    completePairing: vi.fn(),
-    switchChain: vi.fn(),
-    getAccounts: vi.fn().mockResolvedValue([]),
-    signMessage: vi.fn().mockResolvedValue("signed-message"),
-    sendTransaction: vi.fn().mockResolvedValue("tx-hash"),
-  };
-
-  return { mockWalletConnectConnector: wc, mockEmbeddedConnector: embedded, mockSolanaConnector: solana };
-});
-
-vi.mock("@naculus/connector-walletconnect", () => ({
-  createWalletConnectConnector: vi.fn(() => mockWalletConnectConnector),
-  WalletConnectConnector: vi.fn(),
-}));
-
-vi.mock("@naculus/connector-embedded", () => ({
-  createPocketConnector: vi.fn(() => mockEmbeddedConnector),
-}));
-
-vi.mock("@naculus/connector-solana", () => ({
-  solanaConnector: mockSolanaConnector,
-}));
-
-import {
-  createClient,
-  clearClient,
-  getClient,
-} from "./client";
-
-const defaultConfig = {
-  projectId: "test-project-id",
-  metadata: {
-    name: "Test App",
-    description: "Test Description",
-    url: "https://test.com",
-    icons: ["https://test.com/icon.png"],
-  },
-};
-
-describe("createClient", () => {
-  beforeEach(() => {
-    clearClient();
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    clearClient();
-  });
-
-  describe("basic client", () => {
-    it("should create a client", () => {
-      const client = createClient(defaultConfig);
-      expect(client).toBeDefined();
-      expect(client.connector).toBeDefined();
-    });
-
-    it("should return singleton", () => {
-      const client1 = createClient(defaultConfig);
-      const client2 = createClient(defaultConfig);
-      expect(client1).toBe(client2);
-    });
-
-    it("getClient should return null before creation", () => {
-      expect(getClient()).toBeNull();
-    });
-
-    it("getClient should return instance after creation", () => {
-      const client = createClient(defaultConfig);
-      expect(getClient()).toBe(client);
-    });
-
-    it("clearClient allows fresh instance", () => {
-      const client1 = createClient(defaultConfig);
-      clearClient();
-      expect(getClient()).toBeNull();
-      const client2 = createClient(defaultConfig);
-      expect(client2).not.toBe(client1);
-    });
-
-    it("should delegate connect() to WalletConnect", async () => {
-      const client = createClient(defaultConfig);
-      const session = await client.connect();
-      expect(mockWalletConnectConnector.connect).toHaveBeenCalledOnce();
-      expect(session).toEqual({ id: "wc-session" });
-    });
-
-    it("should delegate disconnect()", async () => {
-      const client = createClient(defaultConfig);
-      const session = { id: "test" } as any;
-      await client.disconnect(session);
-      expect(mockWalletConnectConnector.disconnect).toHaveBeenCalledWith(session);
-    });
-
-    it("should delegate reconnect()", async () => {
-      const client = createClient(defaultConfig);
-      const session = { id: "test" } as any;
-      const result = await client.reconnect(session);
-      expect(mockWalletConnectConnector.reconnect).toHaveBeenCalledWith(session);
-      expect(result).toEqual({ id: "wc-session" });
-    });
-
-    it("should delegate startPairing/completePairing", async () => {
-      const client = createClient(defaultConfig);
-      const uri = await client.startPairing();
-      expect(uri).toBe("wc://uri?key=test");
-      expect(await client.completePairing()).toEqual({ id: "wc-session" });
-    });
-
-    it("should throw on connectEmbedded when not enabled", async () => {
-      const client = createClient(defaultConfig);
-      await expect(client.connectEmbedded()).rejects.toThrow("not enabled");
-    });
-
-    it("should return 1 connector from getAllConnectors", () => {
-      const client = createClient(defaultConfig);
-      expect(client.getAllConnectors()).toHaveLength(1);
-    });
-  });
-
-  describe("with Embedded Wallet enabled", () => {
-    it("should connect embedded wallet", async () => {
-      const client = createClient({ ...defaultConfig, enableEmbedded: true });
-      const session = await client.connectEmbedded();
-      expect(session).toEqual({ id: "embedded-session", walletType: "embedded" });
-    });
-
-    it("should set embeddedConnector after connect", async () => {
-      const client = createClient({ ...defaultConfig, enableEmbedded: true });
-      await client.connectEmbedded();
-      expect(client.embeddedConnector).not.toBeNull();
-      expect(client.embeddedConnector!.id).toBe("embedded");
-    });
-
-    it("should include embedded in getAllConnectors", async () => {
-      const client = createClient({ ...defaultConfig, enableEmbedded: true });
-      await client.connectEmbedded();
-      const connectors = client.getAllConnectors();
-      expect(connectors.find((c) => c.kind === "embedded")).toBeDefined();
-    });
-  });
-
-  describe("with Solana enabled", () => {
-    it("signMessage routes to solana connector", async () => {
-      const client = createClient({ ...defaultConfig, enableSolana: false });
-      client._setSolanaConnector(mockSolanaConnector as any);
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      const result = await client.signMessage(session, { message: "hello" });
-
-      expect(mockSolanaConnector.signMessage).toHaveBeenCalledWith(session, { message: "hello" });
-      expect(result).toBe("signed-message");
-    });
-
-    it("signMessage awaits solanaInit before routing", async () => {
-      const client = createClient({ ...defaultConfig, enableSolana: true });
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      const result = await client.signMessage(session, { message: "hello" });
-
-      expect(mockSolanaConnector.signMessage).toHaveBeenCalled();
-      expect(result).toBe("signed-message");
-      expect(client.solanaConnector).toBe(mockSolanaConnector);
-    });
-
-    it("signMessage with no solana connector throws WalletError", async () => {
-      const client = createClient(defaultConfig);
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      await expect(
-        client.signMessage(session, { message: "hello" })
-      ).rejects.toThrow("Solana connector not available");
-    });
-
-    it("sendTransaction routes to solana connector", async () => {
-      const client = createClient({ ...defaultConfig, enableSolana: false });
-      client._setSolanaConnector(mockSolanaConnector as any);
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      const tx = { transaction: { from: "abc" } };
-      const result = await client.sendTransaction(session, tx);
-
-      expect(mockSolanaConnector.sendTransaction).toHaveBeenCalledWith(session, tx);
-      expect(result).toBe("tx-hash");
-    });
-
-    it("disconnect routes to solana connector", async () => {
-      const client = createClient({ ...defaultConfig, enableSolana: false });
-      client._setSolanaConnector(mockSolanaConnector as any);
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      await client.disconnect(session);
-
-      expect(mockSolanaConnector.disconnect).toHaveBeenCalledWith(session);
-    });
-
-    it("reconnect with solana walletType returns session as-is", async () => {
-      const client = createClient({ ...defaultConfig, enableSolana: false });
-      client._setSolanaConnector(mockSolanaConnector as any);
-
-      const session = { walletType: "solana", id: "sol-session", namespaces: {} } as any;
-      const result = await client.reconnect(session);
-
-      expect(result).toBe(session);
-    });
-  });
-});

package/src/client.ts

@@ -1,265 +0,0 @@
-import { WalletConnectConnector, createWalletConnectConnector } from "@naculus/connector-walletconnect";
-import { eip6963Connector } from "@naculus/connector-evm-injected";
-import { logger, WalletError } from "@naculus/connect-core";
-import type { UniversalConnector, UniversalWalletSession, BatchCall, CallsStatus } from "@naculus/connect-core";
-import type { PocketConnectorClass as EmbeddedWalletConnector } from "@naculus/connector-embedded";
-import type PasskeysConnectorImpl from "@naculus/connector-passkeys";
-
-export type ClientConfig = {
-  projectId: string;
-  metadata: {
-    name: string;
-    description: string;
-    url: string;
-    icons: string[];
-  };
-  /** Enable embedded (self-custodial) wallet */
-  enableEmbedded?: boolean;
-
-  /** Enable passkeys (WebAuthn) connector */
-  enablePasskeys?: boolean;
-
-  /** Enable Solana injected wallet connector (Phantom, Solflare) */
-  enableSolana?: boolean;
-  /** Default Solana chain (e.g. "solana:0"). Only used when enableSolana is true. */
-  solanaDefaultChain?: string;
-};
-
-export interface Web3Client {
-  connector: WalletConnectConnector;
-  embeddedConnector: EmbeddedWalletConnector | null;
-  /** The Passkeys connector if enabled */
-  passkeysConnector: PasskeysConnectorImpl | null;
-  /** The Solana injected wallet connector if enabled */
-  solanaConnector: UniversalConnector | null;
-  connect: () => Promise<UniversalWalletSession>;
-  /** Connect via EIP-6963 injected wallet */
-  connectInjected: (walletId?: string) => Promise<UniversalWalletSession>;
-  connectEmbedded: () => Promise<UniversalWalletSession>;
-  /** Connect via passkeys (WebAuthn) */
-  connectPasskeys: () => Promise<UniversalWalletSession>;
-  reconnect: (session: UniversalWalletSession) => Promise<UniversalWalletSession>;
-  disconnect: (session: UniversalWalletSession) => Promise<void>;
-  /** Sign a message via the appropriate connector for the session */
-  signMessage: (session: UniversalWalletSession, input: { message: string; address?: string; chainId?: string }) => Promise<unknown>;
-  /** Send a transaction via the appropriate connector for the session */
-  sendTransaction: (session: UniversalWalletSession, input: { transaction: Record<string, unknown>; chainId?: string }) => Promise<unknown>;
-  /** Send batched calls (EIP-5792 wallet_sendCalls) via the appropriate connector */
-  sendCalls: (session: UniversalWalletSession, calls: BatchCall[], chainId?: string) => Promise<string>;
-  getCallsStatus: (session: UniversalWalletSession, bundleHash: string) => Promise<CallsStatus>;
-  startPairing: () => Promise<string>;
-  completePairing: () => Promise<UniversalWalletSession>;
-  getAllConnectors: () => UniversalConnector[];
-  /** @internal set embedded connector after lazy init */
-  _setEmbeddedConnector: (conn: EmbeddedWalletConnector) => void;
-  /** @internal set passkeys connector after lazy init */
-  _setPasskeysConnector: (conn: PasskeysConnectorImpl) => void;
-  /** @internal set solana connector after lazy init */
-  _setSolanaConnector: (conn: UniversalConnector) => void;
-}
-
-let clientInstance: Web3Client | null = null;
-
-export function createClient(config: ClientConfig): Web3Client {
-  if (clientInstance) return clientInstance;
-
-  const connector = createWalletConnectConnector({
-    projectId: config.projectId,
-    metadata: config.metadata
-  });
-
-  let _embeddedConnector: EmbeddedWalletConnector | null = null;
-  let embeddedInit: Promise<void> | null = null;
-
-  if (config.enableEmbedded) {
-      embeddedInit = import("@naculus/connector-embedded").then((mod) => {
-        const conn = mod.createPocketConnector();
-        _embeddedConnector = conn;
-        if (clientInstance) clientInstance._setEmbeddedConnector(_embeddedConnector);
-    }).catch((err) => {
-      logger.warn("react/client", "Embedded wallet connector not available:", err);
-      _embeddedConnector = null;
-    });
-  }
-
-  let _passkeysConnector: PasskeysConnectorImpl | null = null;
-  let passkeysInit: Promise<void> | null = null;
-
-  if (config.enablePasskeys) {
-      passkeysInit = import("@naculus/connector-passkeys").then((mod) => {
-        const conn = mod.createPasskeysConnector();
-        _passkeysConnector = conn;
-        if (clientInstance) clientInstance._setPasskeysConnector(_passkeysConnector);
-    }).catch((err) => {
-      logger.warn("react/client", "Passkeys connector not available:", err);
-      _passkeysConnector = null;
-    });
-  }
-
-  let _solanaConnector: UniversalConnector | null = null;
-  let solanaInit: Promise<void> | null = null;
-
-  if (config.enableSolana) {
-      solanaInit = import("@naculus/connector-solana").then((mod: any) => {
-        // Use the singleton instance so hooks (useSolanaAccount, etc.) and
-        // the client routing share the same activeSession state.
-        const conn = mod.solanaConnector as UniversalConnector;
-        if (config.solanaDefaultChain && "configure" in conn) {
-          (conn as any).configure({ defaultChain: config.solanaDefaultChain });
-        }
-        _solanaConnector = conn;
-        if (typeof window !== "undefined" && "startDiscovery" in conn) {
-          (conn as any).startDiscovery();
-        }
-        if (clientInstance) clientInstance._setSolanaConnector(_solanaConnector);
-    }).catch((err) => {
-      logger.warn("react/client", "Solana connector not available:", err);
-      _solanaConnector = null;
-    });
-  }
-
-  // Start EIP-6963 discovery eagerly so wallets are available when user clicks connect
-  if (typeof window !== "undefined") {
-    eip6963Connector.startDiscovery();
-  }
-
-  clientInstance = {
-    connector,
-    get embeddedConnector() { return _embeddedConnector; },
-    get passkeysConnector() { return _passkeysConnector; },
-    get solanaConnector() { return _solanaConnector; },
-    connect: () => connector.connect(),
-    connectInjected: async (walletId?: string) => {
-      return eip6963Connector.connect(walletId);
-    },
-    connectEmbedded: async () => {
-      if (embeddedInit) await embeddedInit;
-      if (!_embeddedConnector) {
-        throw new Error("Embedded wallet not enabled. Set enableEmbedded: true in config.");
-      }
-      return _embeddedConnector.connect();
-    },
-    connectPasskeys: async () => {
-      if (passkeysInit) await passkeysInit;
-      if (!_passkeysConnector) {
-        throw new Error("Passkeys connector not enabled. Set enablePasskeys: true in config.");
-      }
-      return _passkeysConnector.connect();
-    },
-    startPairing: () => connector.startPairing(),
-    completePairing: () => connector.completePairing(),
-    signMessage: async (session, input) => {
-      if (session.id?.startsWith("eip6963-")) {
-        return eip6963Connector.signMessage(session as any, input);
-      }
-      if (session.walletType === "passkeys" && _passkeysConnector) {
-        return _passkeysConnector.signMessage(session as any, input);
-      }
-      if (session.walletType === "solana") {
-        if (solanaInit) await solanaInit;
-        if (_solanaConnector) {
-          return (_solanaConnector as any).signMessage(session as any, input);
-        }
-        throw new WalletError("wallet_unavailable", "Solana connector not available. Ensure enableSolana is true and @naculus/connector-solana is installed.");
-      }
-      return connector.signMessage(session, input);
-    },
-    sendTransaction: async (session, input) => {
-      if (session.id?.startsWith("eip6963-")) {
-        return eip6963Connector.sendTransaction(session as any, input);
-      }
-      if (session.walletType === "passkeys" && _passkeysConnector) {
-        return _passkeysConnector.sendTransaction(session as any, input);
-      }
-      if (session.walletType === "solana") {
-        if (solanaInit) await solanaInit;
-        if (_solanaConnector) {
-          return (_solanaConnector as any).sendTransaction(session as any, input);
-        }
-        throw new WalletError("wallet_unavailable", "Solana connector not available. Ensure enableSolana is true and @naculus/connector-solana is installed.");
-      }
-      return connector.sendTransaction(session, input);
-    },
-    sendCalls: async (session, calls, chainId) => {
-      if (session.id?.startsWith("eip6963-")) {
-        return eip6963Connector.sendCalls!(session as any, calls, chainId);
-      }
-      if (session.walletType === "passkeys" && _passkeysConnector) {
-        return _passkeysConnector.sendCalls(session as any, calls, chainId);
-      }
-      if (session.walletType === "solana") {
-        if (solanaInit) await solanaInit;
-        if (_solanaConnector) {
-          return (_solanaConnector as any).sendCalls(session as any, calls, chainId);
-        }
-        throw new WalletError("wallet_unavailable", "Solana connector not available. Ensure enableSolana is true and @naculus/connector-solana is installed.");
-      }
-      if (session.walletType === "embedded" && _embeddedConnector && _embeddedConnector.sendCalls) {
-        return _embeddedConnector.sendCalls(session as any, calls, chainId);
-      }
-      if (!connector.sendCalls) {
-        throw new WalletError("method_not_allowed", "sendCalls not supported by this connector");
-      }
-      return connector.sendCalls(session, calls, chainId);
-    },
-    getCallsStatus: async (session, bundleHash) => {
-      if (session.id?.startsWith("eip6963-") && eip6963Connector.getCallsStatus) {
-        return eip6963Connector.getCallsStatus(session as any, bundleHash);
-      }
-      if (session.walletType === "passkeys" && _passkeysConnector?.getCallsStatus) {
-        return _passkeysConnector.getCallsStatus(session as any, bundleHash);
-      }
-      if (!connector.getCallsStatus) {
-        throw new WalletError("method_not_allowed", "getCallsStatus not supported by this connector");
-      }
-      return connector.getCallsStatus(session, bundleHash);
-    },
-    reconnect: async (session) => {
-      if (session.walletType === "eip6963") {
-        return eip6963Connector.reconnect(session);
-      }
-      if (session.walletType === "embedded") {
-        if (_embeddedConnector) {
-          return _embeddedConnector.reconnect(session);
-        }
-        return session;
-      }
-      if (session.walletType === "solana") {
-        // Solana injected wallet doesn't support reconnect (no persisted session).
-        // Return the saved session as-is; signing ops require wallet reconnection.
-        return session;
-      }
-      return connector.reconnect(session);
-    },
-    disconnect: async (session) => {
-      if (session.walletType === "solana") {
-        if (solanaInit) await solanaInit;
-        if (_solanaConnector) {
-          return _solanaConnector.disconnect(session);
-        }
-        throw new WalletError("wallet_unavailable", "Solana connector not available. Ensure enableSolana is true and @naculus/connector-solana is installed.");
-      }
-      return connector.disconnect(session);
-    },
-    getAllConnectors: () => {
-      const connectors: UniversalConnector[] = [connector];
-      if (_embeddedConnector) connectors.push(_embeddedConnector);
-      if (_passkeysConnector) connectors.push(_passkeysConnector);
-      if (_solanaConnector) connectors.push(_solanaConnector);
-      return connectors;
-    },
-    _setEmbeddedConnector: (conn: EmbeddedWalletConnector) => { _embeddedConnector = conn; },
-    _setPasskeysConnector: (conn: PasskeysConnectorImpl) => { _passkeysConnector = conn; },
-    _setSolanaConnector: (conn: UniversalConnector) => { _solanaConnector = conn; },
-  };
-
-  return clientInstance;
-}
-
-export function getClient(): Web3Client | null {
-  return clientInstance;
-}
-
-export function clearClient(): void {
-  clientInstance = null;
-}

package/src/hooks/useAccount.test.ts

@@ -1,67 +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,
-}));
-
-import { useAccount } from "./useAccount";
-
-describe("useAccount", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should return null accounts when not connected", () => {
-    mockUseWeb3.mockReturnValue({
-      accounts: [],
-      session: null,
-      isConnected: false,
-    });
-    const { result } = renderHook(() => useAccount());
-
-    expect(result.current.accounts).toBeNull();
-    expect(result.current.evmAccount).toBeNull();
-    expect(result.current.isConnected).toBe(false);
-  });
-
-  it("should return null when accounts array is empty even if connected", () => {
-    mockUseWeb3.mockReturnValue({
-      accounts: [],
-      session: { topic: "test" },
-      isConnected: true,
-    });
-    const { result } = renderHook(() => useAccount());
-
-    expect(result.current.accounts).toBeNull();
-    expect(result.current.evmAccount).toBeNull();
-  });
-
-  it("should identify EVM accounts", () => {
-    mockUseWeb3.mockReturnValue({
-      accounts: ["eip155:1:0x1234567890123456789012345678901234567890"],
-      session: { topic: "test" },
-      isConnected: true,
-    });
-    const { result } = renderHook(() => useAccount());
-
-    expect(result.current.accounts).toHaveLength(1);
-    expect(result.current.evmAccount).toBe("eip155:1:0x1234567890123456789012345678901234567890");
-  });
-
-  it("should identify plain 0x addresses as EVM", () => {
-    mockUseWeb3.mockReturnValue({
-      accounts: ["0xabcdef1234567890abcdef1234567890abcdef12"],
-      session: { topic: "test" },
-      isConnected: true,
-    });
-    const { result } = renderHook(() => useAccount());
-
-    expect(result.current.evmAccount).toBe("0xabcdef1234567890abcdef1234567890abcdef12");
-  });
-});

package/src/hooks/useAccount.ts

@@ -1,37 +0,0 @@
-import { useMemo } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-
-export function useAccount() {
-  const { accounts, session, isConnected } = useWeb3();
-
-  const accountData = useMemo(() => {
-    if (!isConnected || accounts.length === 0) {
-      return null;
-    }
-
-    return accounts.map((address) => {
-      // H12: Strengthened CAIP-10 / address detection
-      // Valid formats:
-      //   CAIP-10: "eip155:1:0x1234...5678" (namespace:chainId:address)
-      //   Plain:   "0x1234...5678" (42-char hex, 0x + 40 hex chars)
-      const isCaip10 = /^eip155:\d+:0x[0-9a-fA-F]{40}$/.test(address);
-      const isPlainHex = /^0x[0-9a-fA-F]{40}$/.test(address);
-      const isEvm = isCaip10 || isPlainHex;
-
-      return {
-        address,
-        isEVM: isEvm,
-      };
-    });
-  }, [accounts, isConnected]);
-
-  const evmAccount = accountData?.find((a) => a.isEVM)?.address ?? null;
-
-  return {
-    accounts: accountData,
-    evmAccount,
-    primaryAccount: accounts[0] ?? null,
-    isConnected,
-    count: accounts.length
-  };
-}