@naculus/connect-appkit-react 0.1.8 → 0.2.0

package/src/hooks/useSignInWithX.test.ts

@@ -1,210 +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,
-}));
-
-const mockSignMessage = vi.fn();
-const mockGetClient = vi.fn();
-vi.mock("../client", () => ({
-  getClient: () => mockGetClient(),
-}));
-
-import { useSignInWithX } from "./useSignInWithX";
-
-function createEvmSession() {
-  return {
-    topic: "test-topic",
-    namespaces: {
-      eip155: {
-        chains: ["eip155:1"],
-        accounts: ["eip155:1:0x1234567890123456789012345678901234567890"],
-      },
-    },
-  };
-}
-
-function createSolanaSession() {
-  return {
-    topic: "test-topic",
-    namespaces: {
-      solana: {
-        chains: ["solana:4sGjMW1s"],
-        accounts: ["solana:4sGjMW1s:5JG7DPRQAxJVCLx3GxsHTxP1KZbSyLmPQBLkLhFZPGrH"],
-      },
-    },
-  };
-}
-
-describe("useSignInWithX", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should have initial idle state", () => {
-    mockUseWeb3.mockReturnValue({ session: null, chainId: null });
-    mockGetClient.mockReturnValue(null);
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    expect(result.current.isSigningIn).toBe(false);
-    expect(result.current.result).toBeNull();
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should throw when no session", async () => {
-    mockUseWeb3.mockReturnValue({ session: null, chainId: null });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    await expect(result.current.signIn()).rejects.toThrow("No active session");
-  });
-
-  it("should throw when client not initialized", async () => {
-    mockUseWeb3.mockReturnValue({ session: createEvmSession(), chainId: "eip155:1" });
-    mockGetClient.mockReturnValue(null);
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    await expect(result.current.signIn()).rejects.toThrow("Client not initialized");
-  });
-
-  it("should sign in with the first available account (EVM)", async () => {
-    const mockSignature = "0xgeneric_sig";
-    mockSignMessage.mockResolvedValue(mockSignature);
-    mockUseWeb3.mockReturnValue({
-      session: createEvmSession(),
-      chainId: "eip155:1",
-    });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    let siwxResult: Awaited<ReturnType<typeof result.current.signIn>> | undefined;
-
-    await act(async () => {
-      siwxResult = await result.current.signIn({
-        statement: "Generic SIWx sign in",
-      });
-    });
-
-    expect(siwxResult!).toBeDefined();
-    expect(siwxResult!.signature).toBe(mockSignature);
-    expect(siwxResult!.message.address).toBe(
-      "eip155:1:0x1234567890123456789012345678901234567890"
-    );
-    expect(mockSignMessage).toHaveBeenCalledTimes(1);
-  });
-
-  it("should sign in with the first available account (Solana)", async () => {
-    const mockSignature = "sol_gen_sig";
-    mockSignMessage.mockResolvedValue(mockSignature);
-    mockUseWeb3.mockReturnValue({
-      session: createSolanaSession(),
-      chainId: "solana:4sGjMW1s",
-    });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    let siwxResult: Awaited<ReturnType<typeof result.current.signIn>> | undefined;
-
-    await act(async () => {
-      siwxResult = await result.current.signIn();
-    });
-
-    expect(siwxResult!.message.address).toBe(
-      "solana:4sGjMW1s:5JG7DPRQAxJVCLx3GxsHTxP1KZbSyLmPQBLkLhFZPGrH"
-    );
-    expect(siwxResult!.message.chainId).toBe("solana:4sGjMW1s");
-  });
-
-  it("should set loading state during signing", async () => {
-    let resolvePromise: (v: string) => void;
-    const signPromise = new Promise<string>((resolve) => {
-      resolvePromise = resolve;
-    });
-    mockSignMessage.mockReturnValue(signPromise);
-    mockUseWeb3.mockReturnValue({
-      session: createEvmSession(),
-      chainId: "eip155:1",
-    });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    let callPromise: Promise<unknown>;
-    act(() => {
-      callPromise = result.current.signIn();
-    });
-
-    expect(result.current.isSigningIn).toBe(true);
-
-    await act(async () => {
-      resolvePromise!("0xsig");
-      await callPromise!;
-    });
-
-    expect(result.current.isSigningIn).toBe(false);
-  });
-
-  it("should capture error on failed signing", async () => {
-    mockSignMessage.mockRejectedValue(new Error("Signature rejected"));
-    mockUseWeb3.mockReturnValue({
-      session: createEvmSession(),
-      chainId: "eip155:1",
-    });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    await act(async () => {
-      try {
-        await result.current.signIn();
-      } catch {
-        // Expected
-      }
-    });
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error?.message).toBe("Signature rejected");
-  });
-
-  it("should set result after successful sign-in", async () => {
-    mockSignMessage.mockResolvedValue("0xsig");
-    mockUseWeb3.mockReturnValue({
-      session: createEvmSession(),
-      chainId: "eip155:1",
-    });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignInWithX());
-
-    let siwxResult: Awaited<ReturnType<typeof result.current.signIn>> | undefined;
-
-    await act(async () => {
-      siwxResult = await result.current.signIn();
-    });
-
-    expect(result.current.result).toBe(siwxResult);
-  });
-});

package/src/hooks/useSignInWithX.ts

@@ -1,141 +0,0 @@
-import { useState, useCallback } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-import { getClient } from "../client";
-import { WalletError } from "@naculus/connect-core";
-import {
-  createSiwxMessage,
-  generateNonce,
-  nowISO,
-  getBlockchainName,
-  type SiwxResult,
-} from "@naculus/siwx";
-
-export interface UseSignInWithXOptions {
-  domain?: string;
-  statement?: string;
-  uri?: string;
-  chainId?: string;
-  expirySeconds?: number;
-  resources?: string[];
-  requestId?: string;
-}
-
-export interface UseSignInWithXReturn {
-  signIn: (options?: UseSignInWithXOptions) => Promise<SiwxResult>;
-  isSigningIn: boolean;
-  result: SiwxResult | null;
-  error: Error | null;
-  clearError: () => void;
-}
-
-function getDefaultDomain(): string {
-  if (typeof window !== "undefined") return window.location.host;
-  return "localhost";
-}
-
-function getDefaultUri(): string {
-  if (typeof window !== "undefined") return window.location.origin;
-  return "http://localhost";
-}
-
-export function useSignInWithX(): UseSignInWithXReturn {
-  const { session, chainId: currentChainId } = useWeb3();
-  const [isSigningIn, setIsSigningIn] = useState(false);
-  const [result, setResult] = useState<SiwxResult | null>(null);
-  const [error, setError] = useState<Error | null>(null);
-
-  const clearError = useCallback(() => setError(null), []);
-
-  const signIn = useCallback(
-    async (options?: UseSignInWithXOptions): Promise<SiwxResult> => {
-      if (!session) {
-        throw new WalletError("wallet_unavailable", "No active session");
-      }
-
-      const client = getClient();
-      if (!client) {
-        throw new WalletError("wallet_unavailable", "Client not initialized");
-      }
-
-      const allAccounts = Object.entries(session.namespaces).flatMap(
-        ([ns, info]) =>
-          info.accounts.map((acc: string) => ({ ns, acc }))
-      );
-
-      if (allAccounts.length === 0) {
-        throw new WalletError("wallet_unavailable", "No account found");
-      }
-
-      const { acc: address } = allAccounts[0];
-      const chainId = options?.chainId ?? currentChainId ?? "eip155:1";
-      const domain = options?.domain ?? getDefaultDomain();
-      const uri = options?.uri ?? getDefaultUri();
-      const nonce = generateNonce();
-      const issuedAt = nowISO();
-
-      const message = createSiwxMessage({
-        domain,
-        address,
-        uri,
-        version: 1,
-        chainId,
-        nonce,
-        issuedAt,
-        statement: options?.statement,
-        expirationTime: options?.expirySeconds
-          ? new Date(Date.now() + options.expirySeconds * 1000).toISOString()
-          : undefined,
-        resources: options?.resources,
-        requestId: options?.requestId,
-      });
-
-      setIsSigningIn(true);
-      setError(null);
-
-      try {
-        const signature = (await client.signMessage(session, {
-          message,
-          address,
-          chainId: chainId ?? undefined,
-        })) as string;
-
-        const expirationTime = options?.expirySeconds
-          ? new Date(Date.now() + options.expirySeconds * 1000).toISOString()
-          : null;
-
-        const siwxResult: SiwxResult = {
-          message: {
-            raw: message,
-            domain,
-            address,
-            statement: options?.statement ?? null,
-            uri,
-            version: 1,
-            chainId,
-            nonce,
-            issuedAt,
-            blockchain: getBlockchainName(chainId),
-            expirationTime,
-            notBefore: null,
-            resources: options?.resources ?? [],
-            requestId: options?.requestId ?? null,
-          },
-          signature,
-        };
-
-        setResult(siwxResult);
-        return siwxResult;
-      } catch (err) {
-        const wrappedErr =
-          err instanceof Error ? err : new Error("SIWx sign-in failed");
-        setError(wrappedErr);
-        throw wrappedErr;
-      } finally {
-        setIsSigningIn(false);
-      }
-    },
-    [session, currentChainId]
-  );
-
-  return { signIn, isSigningIn, result, error, clearError };
-}

package/src/hooks/useSignMessage.test.ts

@@ -1,151 +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,
-}));
-
-const mockSignMessage = vi.fn();
-const mockGetClient = vi.fn();
-vi.mock("../client", () => ({
-  getClient: () => mockGetClient(),
-}));
-
-import { useSignMessage } from "./useSignMessage";
-
-function createMockSession() {
-  return {
-    topic: "test-topic",
-    namespaces: {
-      eip155: {
-        chains: ["eip155:1"],
-        accounts: ["eip155:1:0x1234567890123456789012345678901234567890"],
-      },
-    },
-  };
-}
-
-describe("useSignMessage", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should have initial idle state", () => {
-    mockUseWeb3.mockReturnValue({ session: null, chainId: null });
-    mockGetClient.mockReturnValue(null);
-
-    const { result } = renderHook(() => useSignMessage());
-
-    expect(result.current.isSigning).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should throw when no session", async () => {
-    mockUseWeb3.mockReturnValue({ session: null, chainId: null });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignMessage());
-
-    await expect(async () => {
-      await act(async () => {
-        await result.current.signMessage("hello");
-      });
-    }).rejects.toThrow("No active session");
-
-    // Pre-condition checks throw directly without setting state
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should throw when client not initialized", async () => {
-    mockUseWeb3.mockReturnValue({ session: createMockSession(), chainId: "eip155:1" });
-    mockGetClient.mockReturnValue(null);
-
-    const { result } = renderHook(() => useSignMessage());
-
-    await expect(async () => {
-      await act(async () => {
-        await result.current.signMessage("hello");
-      });
-    }).rejects.toThrow("Client not initialized");
-  });
-
-  it("should sign a message successfully", async () => {
-    mockSignMessage.mockResolvedValue("0xsignature123");
-    mockUseWeb3.mockReturnValue({ session: createMockSession(), chainId: "eip155:1" });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignMessage());
-
-    let signature: string;
-    await act(async () => {
-      signature = await result.current.signMessage("hello");
-    });
-
-    expect(signature!).toBe("0xsignature123");
-    expect(mockSignMessage).toHaveBeenCalledTimes(1);
-    expect(mockSignMessage).toHaveBeenCalledWith(createMockSession(), {
-      message: "hello",
-      address: "eip155:1:0x1234567890123456789012345678901234567890",
-      chainId: "eip155:1",
-    });
-    expect(result.current.isSigning).toBe(false);
-  });
-
-  it("should set loading state during signing", async () => {
-    let resolvePromise: (v: string) => void;
-    const signPromise = new Promise<string>((resolve) => {
-      resolvePromise = resolve;
-    });
-    mockSignMessage.mockReturnValue(signPromise);
-    mockUseWeb3.mockReturnValue({ session: createMockSession(), chainId: "eip155:1" });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignMessage());
-
-    let callPromise: Promise<string>;
-    act(() => {
-      callPromise = result.current.signMessage("hello");
-    });
-
-    expect(result.current.isSigning).toBe(true);
-
-    await act(async () => {
-      resolvePromise!("0xsig");
-      await callPromise!;
-    });
-
-    expect(result.current.isSigning).toBe(false);
-  });
-
-  it("should capture error on failed signing", async () => {
-    mockSignMessage.mockRejectedValue(new Error("User rejected"));
-    mockUseWeb3.mockReturnValue({ session: createMockSession(), chainId: "eip155:1" });
-    mockGetClient.mockReturnValue({
-      signMessage: mockSignMessage,
-    });
-
-    const { result } = renderHook(() => useSignMessage());
-
-    await act(async () => {
-      try {
-        await result.current.signMessage("hello");
-      } catch {
-        // Expected
-      }
-    });
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.error?.message).toBe("User rejected");
-  });
-});

package/src/hooks/useSignMessage.ts

@@ -1,65 +0,0 @@
-import { useState, useCallback } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-import { getClient } from "../client";
-import { WalletError } from "@naculus/connect-core";
-
-export function useSignMessage() {
-  const { session, chainId } = useWeb3();
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const signMessage = useCallback(
-    async (message: string): Promise<string> => {
-      // Precondition checks — set error state before throwing (consistent with useSendTransaction pattern)
-      if (!session) {
-        const err = new WalletError("wallet_unavailable", "No active session");
-        setError(err);
-        throw err;
-      }
-
-      const client = getClient();
-      if (!client) {
-        const err = new WalletError("wallet_unavailable", "Client not initialized");
-        setError(err);
-        throw err;
-      }
-
-      const address = Object.values(session.namespaces)
-        .flatMap((ns) => ns.accounts)
-        .find((acc) => acc.includes("0x")) ?? Object.values(session.namespaces)[0]?.accounts[0];
-
-      if (!address) {
-        const err = new WalletError("wallet_unavailable", "No account found");
-        setError(err);
-        throw err;
-      }
-
-      setIsLoading(true);
-      setError(null);
-
-      try {
-        const result = (await client.signMessage(session, {
-          message,
-          address,
-          chainId: chainId ?? undefined
-        })) as string;
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : "Signing failed";
-        const error = err instanceof Error ? err : new Error(errorMessage);
-        setError(error);
-        throw error;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [session, chainId]
-  );
-
-  return {
-    signMessage,
-    isSigning: isLoading,
-    error
-  };
-}