@vlayer/react 0.1.0-nightly-20250213-df4a6a3 → 0.1.0-nightly-20250217-9669344

package/src/useWaitForProvingResult/useWaitForProvingResult.test.ts

@@ -1,80 +0,0 @@
-import { renderHook, waitFor } from "@testing-library/react";
-import { describe, it, expect, vi } from "vitest";
-import {
-  useWaitForProvingResult,
-  WaitForProvingResultStatus,
-} from "./useWaitForProvingResult";
-import type { BrandedHash } from "@vlayer/sdk";
-import type { Abi } from "viem";
-
-const mockResult = { success: true };
-const mockError = new Error("Test error");
-const mockHash = "0x123";
-
-const mockVlayerClient = vi.hoisted(() => ({
-  waitForProvingResult: vi.fn().mockResolvedValue({ success: true }),
-}));
-vi.mock("../context", () => ({
-  useProofContext: () => ({
-    vlayerClient: mockVlayerClient,
-  }),
-}));
-
-describe("useWaitForProvingResult", () => {
-  it("should initialize properly", () => {
-    const { result } = renderHook(() => useWaitForProvingResult(null));
-
-    expect(result.current).toMatchObject({
-      status: WaitForProvingResultStatus.Idle,
-      isIdle: true,
-      error: null,
-    });
-  });
-
-  it("should handle successful proving result", async () => {
-    const { result } = renderHook(() =>
-      useWaitForProvingResult({ hash: "0x1234" } as BrandedHash<Abi, string>),
-    );
-
-    await waitFor(() => {
-      expect(result.current).toMatchObject({
-        data: mockResult,
-        status: WaitForProvingResultStatus.Ready,
-        isReady: true,
-        error: null,
-      });
-    });
-  });
-  it("should handle proving error", async () => {
-    mockVlayerClient.waitForProvingResult.mockRejectedValueOnce(mockError);
-
-    const { result } = renderHook(() =>
-      useWaitForProvingResult({ hash: mockHash } as BrandedHash<Abi, string>),
-    );
-
-    await waitFor(() => {
-      expect(result.current).toMatchObject({
-        status: WaitForProvingResultStatus.Error,
-        isError: true,
-        error: mockError,
-      });
-    });
-  });
-
-  it("should set pending status while waiting for result", async () => {
-    mockVlayerClient.waitForProvingResult.mockImplementation(
-      () =>
-        new Promise((resolve) => setTimeout(() => resolve(mockResult), 100)),
-    );
-
-    const { result } = renderHook(() =>
-      useWaitForProvingResult({ hash: mockHash } as BrandedHash<Abi, string>),
-    );
-    await waitFor(() => {
-      expect(result.current).toMatchObject({
-        status: WaitForProvingResultStatus.Pending,
-        isPending: true,
-      });
-    });
-  });
-});

package/src/useWaitForProvingResult/useWaitForProvingResult.ts

@@ -1,48 +0,0 @@
-import type { BrandedHash } from "@vlayer/sdk";
-import { useState, useEffect } from "react";
-import { useProofContext } from "../context";
-import type { Abi } from "viem";
-
-export enum WaitForProvingResultStatus {
-  Idle = "Idle",
-  Pending = "Pending",
-  Ready = "Ready",
-  Error = "Error",
-}
-
-export const useWaitForProvingResult = (
-  hash: BrandedHash<Abi, string> | null,
-) => {
-  const { vlayerClient } = useProofContext();
-  const [status, setStatus] = useState<WaitForProvingResultStatus>(
-    WaitForProvingResultStatus.Idle,
-  );
-  const [error, setError] = useState<Error | null>(null);
-  const [result, setResult] = useState<unknown>(null);
-  useEffect(() => {
-    if (!hash) {
-      return;
-    }
-    setStatus(WaitForProvingResultStatus.Pending);
-    vlayerClient
-      .waitForProvingResult({ hash })
-      .then((result) => {
-        setStatus(WaitForProvingResultStatus.Ready);
-        setResult(result);
-      })
-      .catch((e) => {
-        setError(e as Error);
-        setStatus(WaitForProvingResultStatus.Error);
-      });
-  }, [JSON.stringify(hash)]);
-
-  return {
-    status,
-    error,
-    isIdle: status === WaitForProvingResultStatus.Idle,
-    isPending: status === WaitForProvingResultStatus.Pending,
-    isReady: status === WaitForProvingResultStatus.Ready,
-    isError: status === WaitForProvingResultStatus.Error,
-    data: result,
-  };
-};

package/src/useWebproof/extension.mock.ts

@@ -1,103 +0,0 @@
-import type { PresentationJSON, ZkProvingStatus } from "@vlayer/sdk";
-
-import {
-  ExtensionMessageType,
-  type ExtensionMessage,
-  type WebProofProvider,
-} from "@vlayer/sdk";
-
-export class MockExtensionWebProofProvider implements WebProofProvider {
-  private listeners: Partial<
-    Record<
-      ExtensionMessageType,
-      ((
-        args: Extract<ExtensionMessage, { type: ExtensionMessageType }>,
-      ) => void)[]
-    >
-  > = {};
-
-  constructor(
-    private mockBehavior: {
-      shouldSucceed?: boolean;
-      delayMs?: number;
-      mockProof?: PresentationJSON;
-      mockError?: string;
-    } = { shouldSucceed: true, delayMs: 100 },
-  ) {}
-
-  public notifyZkProvingStatus(status: ZkProvingStatus): void {
-    console.log("Mock: ZK proving status notification", status);
-  }
-
-  public addEventListeners<T extends ExtensionMessageType>(
-    messageType: T,
-    listener: (args: Extract<ExtensionMessage, { type: T }>) => void,
-  ): void {
-    if (!this.listeners[messageType]) {
-      this.listeners[messageType] = [];
-    }
-    this.listeners[messageType].push(
-      listener as (args: ExtensionMessage) => void,
-    );
-  }
-
-  public requestWebProof(): void {
-    // Simulate async response
-    setTimeout(() => {
-      if (this.mockBehavior.shouldSucceed) {
-        const mockProofDoneMessage: ExtensionMessage = {
-          type: ExtensionMessageType.ProofDone,
-          payload: {
-            presentationJson:
-              this.mockBehavior.mockProof ||
-              ({ mock: "proof" } as unknown as PresentationJSON),
-            decodedTranscript: {
-              sent: "mock sent",
-              recv: "mock recv",
-            },
-          },
-        };
-        this.listeners[ExtensionMessageType.ProofDone]?.forEach((listener) => {
-          console.log("Mock: ProofDone message", mockProofDoneMessage);
-          listener(mockProofDoneMessage);
-        });
-      } else {
-        const mockErrorMessage: ExtensionMessage = {
-          type: ExtensionMessageType.ProofError,
-          payload: {
-            error: this.mockBehavior.mockError || "Mock error occurred",
-          },
-        };
-        this.listeners[ExtensionMessageType.ProofError]?.forEach((listener) =>
-          listener(mockErrorMessage),
-        );
-      }
-    }, this.mockBehavior.delayMs);
-  }
-
-  public async getWebProof(): Promise<{
-    presentationJson: PresentationJSON;
-    decodedTranscript: {
-      sent: string;
-      recv: string;
-    };
-  }> {
-    await new Promise((resolve) =>
-      setTimeout(resolve, this.mockBehavior.delayMs),
-    );
-
-    if (this.mockBehavior.shouldSucceed) {
-      return {
-        presentationJson:
-          this.mockBehavior.mockProof ||
-          ({ mock: "proof" } as unknown as PresentationJSON),
-        decodedTranscript: {
-          sent: "mock sent",
-          recv: "mock recv",
-        },
-      };
-    } else {
-      throw new Error(this.mockBehavior.mockError || "Mock error occurred");
-    }
-  }
-}

package/src/useWebproof/useWebProof.test.tsx

@@ -1,142 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { it, expect, describe, vi, beforeEach } from "vitest";
-import { useWebProof } from "./useWebProof";
-import { ProofProvider } from "../context";
-import { MockExtensionWebProofProvider } from "./extension.mock";
-import { WebProofRequestStatus } from "../types";
-
-const mocks = vi.hoisted(() => ({
-  createExtensionWebProofProvider: vi.fn(),
-}));
-
-vi.mock("@vlayer/sdk/web_proof", () => ({
-  createExtensionWebProofProvider: mocks.createExtensionWebProofProvider,
-}));
-
-const stubWebProofRequest = {
-  proverCallCommitment: {
-    address: "0x" as `0x${string}`,
-    proverAbi: [
-      {
-        type: "function",
-        name: "mint",
-        inputs: [],
-        outputs: [],
-        stateMutability: "nonpayable",
-      },
-    ] as const,
-    chainId: 1,
-    functionName: "mint",
-    commitmentArgs: [] as [],
-  },
-  logoUrl: "http://twitterswap.com/logo.png",
-  steps: [],
-};
-
-describe("useWebproof", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  const VlayerMockContext = ({ children }: { children: React.ReactNode }) => (
-    <ProofProvider>{children}</ProofProvider>
-  );
-
-  const renderWebproofHook = () =>
-    renderHook(() => useWebProof(stubWebProofRequest), {
-      wrapper: VlayerMockContext,
-    });
-
-  const setupMockProvider = (options = {}) => {
-    mocks.createExtensionWebProofProvider.mockImplementation(
-      () => new MockExtensionWebProofProvider(options),
-    );
-    vi.runAllTimers();
-  };
-
-  it("should throw error if called outside of ProofProvider", () => {
-    expect(() => renderHook(() => useWebProof(stubWebProofRequest))).toThrow(
-      "useProofContext must be used within a ProofProvider",
-    );
-  });
-
-  it("should initialize with the correct state", () => {
-    setupMockProvider();
-    const { result } = renderWebproofHook();
-
-    expect(result.current).toEqual({
-      webProof: null,
-      status: WebProofRequestStatus.idle,
-      isIdle: true,
-      isError: false,
-      isSuccess: false,
-      isPending: false,
-      error: null,
-      requestWebProof: expect.any(Function) as () => void,
-    });
-  });
-
-  it("should request the web proof", () => {
-    const { result } = renderWebproofHook();
-    act(() => result.current.requestWebProof());
-
-    expect(result.current).toEqual({
-      webProof: null,
-      status: WebProofRequestStatus.pending,
-      isIdle: false,
-      isError: false,
-      isSuccess: false,
-      isPending: true,
-      error: null,
-      requestWebProof: expect.any(Function) as () => void,
-    });
-  });
-
-  it("should set the web proof when the request is successful", () => {
-    setupMockProvider({
-      shouldSucceed: true,
-      mockProof: { mock: "proof" },
-    });
-    const { result, rerender } = renderWebproofHook();
-
-    act(() => result.current.requestWebProof());
-    vi.advanceTimersByTime(1000);
-    rerender();
-
-    expect(result.current).toMatchObject({
-      webProof: {
-        webProofJson: JSON.stringify({ presentationJson: { mock: "proof" } }),
-      },
-      status: WebProofRequestStatus.success,
-      isIdle: false,
-      isPending: false,
-      isError: false,
-      isSuccess: true,
-      error: null,
-      requestWebProof: expect.any(Function) as () => void,
-    });
-  });
-
-  it("should set the error when the request fails", () => {
-    setupMockProvider({
-      shouldSucceed: false,
-      mockError: "Mock error occurred",
-    });
-    const { result, rerender } = renderWebproofHook();
-
-    act(() => result.current.requestWebProof());
-    vi.advanceTimersByTime(1000);
-    rerender();
-
-    expect(result.current).toEqual({
-      webProof: null,
-      status: WebProofRequestStatus.error,
-      isIdle: false,
-      isPending: false,
-      isError: true,
-      isSuccess: false,
-      error: new Error("Mock error occurred"),
-      requestWebProof: expect.any(Function) as () => void,
-    });
-  });
-});

package/src/useWebproof/useWebProof.ts

@@ -1,52 +0,0 @@
-import { useEffect, useState } from "react";
-import { type Abi, type ContractFunctionName } from "viem";
-import { useProofContext } from "../context";
-import { WebProofRequestStatus } from "../types";
-import { ExtensionMessageType, type GetWebProofArgs } from "@vlayer/sdk";
-
-export const useWebProof = (
-  webProofRequest: GetWebProofArgs<Abi, ContractFunctionName>,
-) => {
-  const { webProofProvider } = useProofContext();
-  const [webProof, setWebProof] = useState<{
-    webProofJson: string;
-  } | null>(null);
-  const [error, setError] = useState<Error | null>(null);
-  const [status, setStatus] = useState<WebProofRequestStatus>(
-    WebProofRequestStatus.idle,
-  );
-
-  useEffect(() => {
-    webProofProvider.addEventListeners(
-      ExtensionMessageType.ProofDone,
-      ({ payload: { presentationJson } }) => {
-        setWebProof({
-          webProofJson: JSON.stringify({ presentationJson: presentationJson }),
-        });
-        setStatus(WebProofRequestStatus.success);
-      },
-    );
-
-    webProofProvider.addEventListeners(
-      ExtensionMessageType.ProofError,
-      ({ payload: { error } }) => {
-        setError(new Error(error));
-        setStatus(WebProofRequestStatus.error);
-      },
-    );
-  }, []);
-
-  return {
-    webProof,
-    error,
-    status,
-    isIdle: status === WebProofRequestStatus.idle,
-    isPending: status === WebProofRequestStatus.pending,
-    isError: status === WebProofRequestStatus.error,
-    isSuccess: status === WebProofRequestStatus.success,
-    requestWebProof: () => {
-      setStatus(WebProofRequestStatus.pending);
-      webProofProvider.requestWebProof(webProofRequest);
-    },
-  };
-};

package/tsconfig.base.json

@@ -1,26 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "lib": [
-      "ESNext",
-      "DOM"
-    ],
-    "jsx": "react-jsx",
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "moduleDetection": "force",
-    "downlevelIteration": true,
-    "forceConsistentCasingInFileNames": true,
-    "verbatimModuleSyntax": true,
-    "baseUrl": "./",
-    "types": [
-      "bun"
-    ]
-  }, 
-  "include": [
-    "src"
-  ]
-}

package/tsconfig.build.json

@@ -1,12 +0,0 @@
-{
-    "extends": "./tsconfig.base.json",
-    "exclude": [
-      "./src/**/*.test.ts"
-    ],
-    "compilerOptions": {
-      "noEmit": false,
-      "sourceMap": true,
-      "declaration": true,
-      "declarationMap": true
-    }
-  }

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "./tsconfig.base.json",
-  "tsc-alias" : {
-    "resolveFullPaths": true
-  }
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "jsdom",
-    include: ["src/**/*.test.ts", "src/**/*.test.tsx"],
-  },
-});