@naculus/connect-appkit-react 0.1.2

package/src/hooks/useSignInWithX.test.ts

@@ -0,0 +1,210 @@
+/// <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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,151 @@
+/// <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

@@ -0,0 +1,65 @@
+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
+  };
+}