@naculus/connect-appkit-react 0.1.8 → 0.2.0

package/src/hooks/useEmbeddedWallet.test.ts

@@ -1,266 +0,0 @@
-/// <reference types="vitest" />
-/// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-
-import { useEmbeddedWallet } from "./useEmbeddedWallet";
-
-// -- Mocks --
-
-const mockUseWeb3 = vi.fn();
-vi.mock("../provider/Web3ConnectProvider", () => ({
-  useWeb3: () => mockUseWeb3(),
-  Web3ConnectProvider: ({ children }: { children: React.ReactNode }) => children,
-}));
-
-const mockGetClient = vi.fn();
-vi.mock("../client", () => ({
-  getClient: () => mockGetClient(),
-}));
-
-const mockConnector = {
-  load: vi.fn(),
-  getWallet: vi.fn(),
-  generateWallet: vi.fn(),
-  importFromMnemonic: vi.fn(),
-  importFromPrivateKey: vi.fn(),
-  wipe: vi.fn(),
-};
-
-function mockStandardEmbedded() {
-  mockGetClient.mockReturnValue({ embeddedConnector: mockConnector });
-}
-
-describe("useEmbeddedWallet", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockStandardEmbedded();
-  });
-
-  it("should have initial idle state", () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    expect(result.current.hasWallet).toBe(false);
-    expect(result.current.address).toBeNull();
-    expect(result.current.seedPhrase).toBeNull();
-    expect(result.current.backupPending).toBe(false);
-    expect(result.current.isBusy).toBe(false);
-    expect(result.current.error).toBeNull();
-  });
-
-  it("connectEmbedded should call provider and set wallet", async () => {
-    const providerConnect = vi.fn().mockResolvedValue(undefined);
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: providerConnect,
-      status: "disconnected",
-    });
-
-    const fakeWallet = {
-      mnemonic: "test mnemonic phrase",
-      privateKey: "0xfake",
-      address: "0xfakeAddress",
-    };
-
-    mockConnector.load.mockReturnValue(false);
-    mockConnector.getWallet.mockReturnValue(fakeWallet);
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.connectEmbedded();
-    });
-
-    expect(providerConnect).toHaveBeenCalled();
-    expect(mockConnector.getWallet).toHaveBeenCalled();
-    expect(result.current.wallet).toEqual(fakeWallet);
-    expect(result.current.hasWallet).toBe(true);
-    expect(result.current.address).toBe("0xfakeAddress");
-    expect(result.current.isBusy).toBe(false);
-  });
-
-  it("generateWallet should create a new wallet and set backup pending", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    const newWallet = {
-      mnemonic: "actual random mnemonic",
-      privateKey: "0xnewPrivateKey",
-      address: "0xnewAddress",
-    };
-
-    mockConnector.generateWallet.mockResolvedValue({
-      mnemonic: newWallet.mnemonic,
-      privateKey: newWallet.privateKey,
-      address: newWallet.address,
-    });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.generateWallet();
-    });
-
-    expect(mockConnector.generateWallet).toHaveBeenCalled();
-    expect(result.current.wallet).toEqual(newWallet);
-    expect(result.current.seedPhrase).toBe(newWallet.mnemonic);
-    expect(result.current.backupPending).toBe(true);
-    expect(result.current.isBusy).toBe(false);
-  });
-
-  it("importFromMnemonic should import from seed phrase", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    const imported = {
-      mnemonic: "",
-      privateKey: "0ximportedKey",
-      address: "0ximportedAddr",
-    };
-
-    mockConnector.importFromMnemonic.mockResolvedValue({
-      mnemonic: imported.mnemonic,
-      privateKey: imported.privateKey,
-      address: imported.address,
-    });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.importFromMnemonic("my seed phrase");
-    });
-
-    expect(mockConnector.importFromMnemonic).toHaveBeenCalledWith("my seed phrase");
-    expect(result.current.wallet).toEqual(imported);
-    expect(result.current.seedPhrase).toBeNull();
-    expect(result.current.backupPending).toBe(false);
-  });
-
-  it("wipe should clear wallet and seed phrase", () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    mockConnector.getWallet.mockReturnValue({
-      mnemonic: "some mnemonic",
-      privateKey: "0xpk",
-      address: "0xaddr",
-    });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    act(() => {
-      result.current.wipe();
-    });
-
-    expect(mockConnector.wipe).toHaveBeenCalled();
-    expect(result.current.hasWallet).toBe(false);
-    expect(result.current.seedPhrase).toBeNull();
-    expect(result.current.backupPending).toBe(false);
-  });
-
-  it("confirmBackup should clear seed phrase from react state", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    mockConnector.getWallet.mockReturnValue({
-      mnemonic: "some mnemonic",
-      privateKey: "0xpk",
-      address: "0xaddr",
-    });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.connectEmbedded();
-    });
-
-    act(() => {
-      result.current.confirmBackup();
-    });
-
-    expect(result.current.seedPhrase).toBeNull();
-    expect(result.current.backupPending).toBe(false);
-  });
-
-  it("should handle error when embedded not enabled", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    mockGetClient.mockReturnValue({ embeddedConnector: null });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.connectEmbedded();
-    });
-
-    expect(result.current.error).not.toBeNull();
-    expect(result.current.isBusy).toBe(false);
-  });
-
-  it("clearError should reset error state", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    mockGetClient.mockReturnValue({ embeddedConnector: null });
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    await act(async () => {
-      await result.current.connectEmbedded();
-    });
-    expect(result.current.error).not.toBeNull();
-
-    act(() => {
-      result.current.clearError();
-    });
-    expect(result.current.error).toBeNull();
-  });
-
-  it("should set isBusy during operations", async () => {
-    mockUseWeb3.mockReturnValue({
-      connectEmbedded: vi.fn(),
-      status: "disconnected",
-    });
-
-    let resolveGen: (value: any) => void;
-    const genPromise = new Promise<any>((resolve) => { resolveGen = resolve; });
-    mockConnector.generateWallet.mockReturnValue(genPromise);
-
-    const { result } = renderHook(() => useEmbeddedWallet());
-
-    let callPromise: Promise<any>;
-    act(() => {
-      callPromise = result.current.generateWallet();
-    });
-
-    expect(result.current.isBusy).toBe(true);
-
-    await act(async () => {
-      resolveGen!({
-        mnemonic: "test",
-        privateKey: "0xtest",
-        address: "0xtest",
-      });
-      await callPromise!;
-    });
-
-    expect(result.current.isBusy).toBe(false);
-  });
-});

package/src/hooks/useEmbeddedWallet.ts

@@ -1,181 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import { useWeb3 } from "../provider/Web3ConnectProvider";
-import { getClient } from "../client";
-import type { WalletData } from "@naculus/connector-embedded";
-import { WalletError } from "@naculus/connect-core";
-
-export interface UseEmbeddedWalletReturn {
-  connectEmbedded: () => Promise<void>;
-  generateWallet: () => Promise<WalletData | null>;
-  importFromMnemonic: (mnemonic: string) => Promise<WalletData | null>;
-  importFromPrivateKey: (pk: `0x${string}`) => Promise<WalletData | null>;
-  wipe: () => void;
-  wallet: WalletData | null;
-  hasWallet: boolean;
-  address: string | null;
-  /** @deprecated Use getSeedPhrase() instead. This field will be removed. */
-  seedPhrase: string | null;
-  /** Get seed phrase once and clear from memory. Returns mnemonic or null. */
-  getSeedPhrase: () => string | null;
-  backupPending: boolean;
-  confirmBackup: () => void;
-  isBusy: boolean;
-  error: Error | null;
-  clearError: () => void;
-  /**
-   * Storage security tier (1-4).
-   *   1 = IndexedDB + AES-GCM,  2 = IndexedDB,
-   *   3 = localStorage + AES-GCM, 4 = localStorage plaintext
-   */
-  storageSecurityLevel: number;
-}
-
-export function useEmbeddedWallet(): UseEmbeddedWalletReturn {
-  const { connectEmbedded: providerConnectEmbedded } = useWeb3();
-  const [wallet, setWallet] = useState<WalletData | null>(null);
-  const seedPhraseRef = useRef<string | null>(null);
-  const [backupPending, setBackupPending] = useState(false);
-  const [isBusy, setIsBusy] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const clearError = () => setError(null);
-
-  /** Get seed phrase once and immediately clear from memory */
-  const getSeedPhrase = useCallback(() => {
-    const phrase = seedPhraseRef.current;
-    seedPhraseRef.current = null; // Clear immediately
-    return phrase;
-  }, []);
-
-  const getEmbeddedConnector = () => {
-    const client = getClient();
-    if (!client?.embeddedConnector) {
-      throw new WalletError("wallet_unavailable", "Embedded wallet not enabled.");
-    }
-    return client.embeddedConnector;
-  };
-
-  const handleConnectEmbedded = async () => {
-    setIsBusy(true);
-    setError(null);
-    try {
-      const connector = getEmbeddedConnector();
-      const loaded = await connector.load();
-      const w = connector.getWallet();
-      if (loaded && w) {
-        setWallet(w);
-        seedPhraseRef.current = w.mnemonic || null;
-        setBackupPending(!w.mnemonic);
-      }
-      await providerConnectEmbedded();
-      const w2 = connector.getWallet();
-      if (w2) {
-        setWallet(w2);
-        if (w2.mnemonic && !loaded) {
-          seedPhraseRef.current = w2.mnemonic;
-          setBackupPending(true);
-        }
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Embedded wallet connection failed"));
-    } finally {
-      setIsBusy(false);
-    }
-  };
-
-  const handleGenerateWallet = async (): Promise<WalletData | null> => {
-    setIsBusy(true);
-    setError(null);
-    try {
-      const connector = getEmbeddedConnector();
-      const w = await connector.generateWallet();
-      setWallet(w);
-      seedPhraseRef.current = w.mnemonic;
-      setBackupPending(true);
-      return w;
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to generate wallet"));
-      return null;
-    } finally {
-      setIsBusy(false);
-    }
-  };
-
-  const handleImportFromMnemonic = async (mnemonic: string): Promise<WalletData | null> => {
-    setIsBusy(true);
-    setError(null);
-    try {
-      const connector = getEmbeddedConnector();
-      const w = await connector.importFromMnemonic(mnemonic);
-      setWallet(w);
-      seedPhraseRef.current = null;
-      setBackupPending(false);
-      return w;
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to import wallet"));
-      return null;
-    } finally {
-      setIsBusy(false);
-    }
-  };
-
-  const handleImportFromPrivateKey = async (pk: `0x${string}`): Promise<WalletData | null> => {
-    setIsBusy(true);
-    setError(null);
-    try {
-      const connector = getEmbeddedConnector();
-      const w = await connector.importFromPrivateKey(pk);
-      setWallet(w);
-      seedPhraseRef.current = null;
-      setBackupPending(false);
-      return w;
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to import wallet"));
-      return null;
-    } finally {
-      setIsBusy(false);
-    }
-  };
-
-  const handleWipe = () => {
-    try {
-      const connector = getEmbeddedConnector();
-      connector.wipe();
-      setWallet(null);
-      seedPhraseRef.current = null;
-      setBackupPending(false);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Failed to wipe wallet"));
-    }
-  };
-
-  const handleConfirmBackup = () => {
-    seedPhraseRef.current = null;
-    setBackupPending(false);
-  };
-
-  return {
-    connectEmbedded: handleConnectEmbedded,
-    generateWallet: handleGenerateWallet,
-    importFromMnemonic: handleImportFromMnemonic,
-    importFromPrivateKey: handleImportFromPrivateKey,
-    wipe: handleWipe,
-    wallet,
-    hasWallet: wallet !== null,
-    address: wallet?.address ?? null,
-    seedPhrase: seedPhraseRef.current, // backward compat (deprecated)
-    getSeedPhrase,
-    backupPending,
-    confirmBackup: handleConfirmBackup,
-    isBusy,
-    error,
-    clearError,
-    storageSecurityLevel: (() => {
-      try {
-        return getEmbeddedConnector().getStorageSecurityLevel?.() ?? 4;
-      } catch {
-        return 4;
-      }
-    })(),
-  };
-}

package/src/hooks/useLastTx.test.ts

@@ -1,117 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import { useLastTx } from "./useLastTx";
-import type { TxMonitorLike, TxStatusEntry } from "./useTxMonitor";
-
-class MockMonitor implements TxMonitorLike {
-  private listeners = new Map<string, Set<Function>>();
-
-  async watchTx(): Promise<TxStatusEntry> { throw new Error("not implemented"); }
-  stopWatching(): void {}
-  getTxStatus(): TxStatusEntry | null { return null; }
-  async getTxHistory(): Promise<TxStatusEntry[]> { return []; }
-  async refreshTx(): Promise<void> {}
-
-  on(event: string, listener: Function): this {
-    const set = this.listeners.get(event) ?? new Set();
-    set.add(listener);
-    this.listeners.set(event, set);
-    return this;
-  }
-  off(event: string, listener: Function): this {
-    const set = this.listeners.get(event);
-    if (set) set.delete(listener);
-    return this;
-  }
-
-  emitConfirmed(entry: TxStatusEntry): void {
-    const set = this.listeners.get("confirmed");
-    if (set) set.forEach(fn => fn(entry));
-  }
-
-  emitFailed(entry: TxStatusEntry): void {
-    const set = this.listeners.get("failed");
-    if (set) set.forEach(fn => fn(entry));
-  }
-}
-
-describe("useLastTx", () => {
-  let monitor: MockMonitor;
-
-  beforeEach(() => {
-    monitor = new MockMonitor();
-  });
-
-  it("returns null initially", () => {
-    const { result } = renderHook(() => useLastTx(monitor));
-    expect(result.current.lastTx).toBeNull();
-    expect(result.current.lastConfirmedTx).toBeNull();
-    expect(result.current.lastFailedTx).toBeNull();
-  });
-
-  it("updates lastConfirmedTx on confirmed event", () => {
-    const { result } = renderHook(() => useLastTx(monitor));
-
-    const now = Date.now();
-    const entry: TxStatusEntry = {
-      hash: "0x" + "a".repeat(64), chainId: 1,
-      from: "", to: "", value: "0x0",
-      status: "confirmed", createdAt: now, updatedAt: now,
-      replacementCount: 0, confirmedAt: now,
-    };
-
-    act(() => {
-      monitor.emitConfirmed(entry);
-    });
-
-    expect(result.current.lastTx).not.toBeNull();
-    expect(result.current.lastTx!.hash).toBe(entry.hash);
-    expect(result.current.lastConfirmedTx).not.toBeNull();
-    expect(result.current.lastConfirmedTx!.hash).toBe(entry.hash);
-  });
-
-  it("updates lastFailedTx on failed event", () => {
-    const { result } = renderHook(() => useLastTx(monitor));
-
-    const now = Date.now();
-    const entry: TxStatusEntry = {
-      hash: "0x" + "b".repeat(64), chainId: 1,
-      from: "", to: "", value: "0x0",
-      status: "failed", createdAt: now, updatedAt: now,
-      replacementCount: 0, error: "reverted",
-    };
-
-    act(() => {
-      monitor.emitFailed(entry);
-    });
-
-    expect(result.current.lastTx).not.toBeNull();
-    expect(result.current.lastTx!.hash).toBe(entry.hash);
-    expect(result.current.lastFailedTx).not.toBeNull();
-    expect(result.current.lastFailedTx!.hash).toBe(entry.hash);
-  });
-
-  it("clears on clear() call", () => {
-    const { result } = renderHook(() => useLastTx(monitor));
-
-    const now = Date.now();
-    act(() => {
-      monitor.emitConfirmed({
-        hash: "0x" + "c".repeat(64), chainId: 1,
-        from: "", to: "", value: "0x0",
-        status: "confirmed", createdAt: now, updatedAt: now,
-        replacementCount: 0, confirmedAt: now,
-      });
-    });
-
-    expect(result.current.lastTx).not.toBeNull();
-
-    act(() => {
-      result.current.clear();
-    });
-
-    expect(result.current.lastTx).toBeNull();
-    expect(result.current.lastConfirmedTx).toBeNull();
-  });
-});

package/src/hooks/useLastTx.ts

@@ -1,73 +0,0 @@
-import { useState, useCallback, useRef } from "react";
-import type { TxMonitorLike, TxStatusEntry } from "./useTxMonitor";
-import { useTxMonitorProvider } from "./useTxMonitor";
-
-// ── Hook ──────────────────────────────────────────────────────────
-
-export interface UseLastTxResult {
-  /** Most recent transaction by createdAt */
-  lastTx: TxStatusEntry | null;
-  /** Most recent confirmed transaction */
-  lastConfirmedTx: TxStatusEntry | null;
-  /** Most recent failed transaction */
-  lastFailedTx: TxStatusEntry | null;
-  /** Clear cached lastTx state */
-  clear: () => void;
-}
-
-/**
- * Track the most recent transaction.
- * Automatically updates when a new transaction is sent (via statusChange events).
- */
-export function useLastTx(monitor?: TxMonitorLike): UseLastTxResult {
-  const ctxMonitor = useTxMonitorProvider();
-  const effectiveMonitor = monitor ?? ctxMonitor;
-
-  const [lastTx, setLastTx] = useState<TxStatusEntry | null>(null);
-  const [lastConfirmedTx, setLastConfirmedTx] = useState<TxStatusEntry | null>(null);
-  const [lastFailedTx, setLastFailedTx] = useState<TxStatusEntry | null>(null);
-  const lastTxRef = useRef<{ createdAt: number } | null>(null);
-
-  // Track confirmed and failed events
-  const confirmedHandlerRef = useRef<((entry: TxStatusEntry) => void) | null>(null);
-  const failedHandlerRef = useRef<((entry: TxStatusEntry) => void) | null>(null);
-
-  // Set up listeners
-  if (effectiveMonitor) {
-    if (!confirmedHandlerRef.current) {
-      confirmedHandlerRef.current = (entry: TxStatusEntry) => {
-        setLastConfirmedTx(entry);
-        if (!lastTxRef.current || entry.createdAt >= lastTxRef.current.createdAt) {
-          setLastTx(entry);
-          lastTxRef.current = entry;
-        }
-      };
-      effectiveMonitor.on("confirmed", confirmedHandlerRef.current);
-    }
-
-    if (!failedHandlerRef.current) {
-      failedHandlerRef.current = (entry: TxStatusEntry) => {
-        setLastFailedTx(entry);
-        if (!lastTxRef.current || entry.createdAt >= lastTxRef.current.createdAt) {
-          setLastTx(entry);
-          lastTxRef.current = entry;
-        }
-      };
-      effectiveMonitor.on("failed", failedHandlerRef.current);
-    }
-  }
-
-  const clear = useCallback(() => {
-    setLastTx(null);
-    setLastConfirmedTx(null);
-    setLastFailedTx(null);
-    lastTxRef.current = null;
-  }, []);
-
-  return {
-    lastTx,
-    lastConfirmedTx,
-    lastFailedTx,
-    clear,
-  };
-}