@vlayer/sdk 0.1.0-nightly-20241105-90d39b6 → 0.1.0-nightly-20241106-04bef04

package/dist/api/lib/client.js

@@ -1,6 +1,7 @@
 import { prove } from "../prover";
 import { createExtensionWebProofProvider } from "../webProof";
 import { decodeFunctionResult } from "viem";
+import { ZkProvingStatus } from "../../web-proof-commons";
 function dropEmptyProofFromArgs(args) {
     if (Array.isArray(args)) {
         return args.slice(1);
@@ -14,17 +15,27 @@ function generateRandomHash() {
     }
     return hash;
 }
+async function getHash() {
+    return Promise.resolve(generateRandomHash());
+}
 export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProvider = createExtensionWebProofProvider(), } = {
     url: "http://127.0.0.1:3000",
     webProofProvider: createExtensionWebProofProvider(),
 }) => {
-    console.log("createVlayerClient with", url, webProofProvider);
     const resultHashMap = new Map();
     return {
-        // eslint-disable-next-line @typescript-eslint/require-await
         prove: async ({ address, functionName, chainId, proverAbi, args }) => {
-            const result_promise = prove(address, proverAbi, functionName, args, chainId, url);
-            const hash = generateRandomHash();
+            webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Proving);
+            const result_promise = prove(address, proverAbi, functionName, args, chainId, url)
+                .catch((error) => {
+                webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Error);
+                throw error;
+            })
+                .then((result) => {
+                webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Done);
+                return result;
+            });
+            const hash = await getHash();
             resultHashMap.set(hash, [result_promise, proverAbi, functionName]);
             return { hash };
         },

package/dist/api/lib/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/lib/client.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { createExtensionWebProofProvider } from "../webProof";
+import { createVlayerClient } from "./client";
+import { ZkProvingStatus } from "src/web-proof-commons";
+import createFetchMock from "vitest-fetch-mock";
+const fetchMocker = createFetchMock(vi);
+fetchMocker.enableMocks();
+beforeEach(() => {
+    global.chrome = {
+        runtime: {
+            sendMessage: vi.fn(),
+            connect: vi.fn().mockImplementation(() => {
+                return {
+                    onMessage: {
+                        addListener: vi.fn(),
+                    },
+                    postMessage: vi.fn(),
+                };
+            }),
+        },
+    };
+});
+describe("Success zk-proving", () => {
+    beforeEach(() => {
+        fetchMocker.mockResponseOnce((req) => {
+            if (req.url === "http://127.0.0.1:3000/") {
+                return {
+                    body: JSON.stringify({
+                        result: {
+                            proof: {},
+                        },
+                    }),
+                };
+            }
+            return {};
+        });
+    });
+    it("should send message to extension that zkproving started and then that is done", async () => {
+        const webProofProvider = createExtensionWebProofProvider();
+        const zkProvingSpy = vi.spyOn(webProofProvider, "notifyZkProvingStatus");
+        const vlayer = createVlayerClient({ webProofProvider });
+        const { hash } = await vlayer.prove({
+            address: `0x${"a".repeat(40)}`,
+            functionName: "main",
+            proverAbi: [],
+            args: [],
+            chainId: 42,
+        });
+        await vlayer.waitForProvingResult({ hash });
+        expect(zkProvingSpy).toBeCalledTimes(2);
+        expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+        expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Done);
+    });
+});
+describe("Failed zk-proving", () => {
+    beforeEach(() => {
+        fetchMocker.mockResponseOnce((req) => {
+            if (req.url === "http://127.0.0.1:3000/") {
+                return {
+                    status: 500,
+                };
+            }
+            return {};
+        });
+    });
+    it("should send message to extension that zkproving started and then that failed ", async () => {
+        const webProofProvider = createExtensionWebProofProvider();
+        const zkProvingSpy = vi.spyOn(webProofProvider, "notifyZkProvingStatus");
+        const vlayer = createVlayerClient({ webProofProvider });
+        const { hash } = await vlayer.prove({
+            address: `0x${"a".repeat(40)}`,
+            functionName: "main",
+            proverAbi: [],
+            args: [],
+            chainId: 42,
+        });
+        try {
+            await vlayer.waitForProvingResult({ hash });
+        }
+        catch (e) {
+            console.log("Error waiting for proving result", e);
+        }
+        expect(zkProvingSpy).toBeCalledTimes(2);
+        expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+        expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Error);
+    });
+});

package/dist/api/lib/types/webProofProvider.d.ts

@@ -1,6 +1,6 @@
 import { Hex, Abi, ContractFunctionName } from "viem";
 import type { ContractFunctionArgsWithout } from "./viem";
-import { Branded, WebProof, WebProofStep } from "../../../web-proof-commons";
+import { Branded, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons";
 export type WebProofSetupInput = {
     logoUrl: string;
     steps: WebProofStep[];
@@ -22,6 +22,7 @@ export type GetWebProofArgs<T extends Abi, F extends ContractFunctionName<T>> =
 } & WebProofSetupInput;
 export type WebProofProvider = {
     getWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => Promise<WebProof>;
+    notifyZkProvingStatus: (status: ZkProvingStatus) => void;
 };
 export type WebProofProviderSetup = {
     notaryUrl?: string;

package/dist/api/v_call.js

@@ -16,7 +16,6 @@ export async function v_call(call, context, url = "http://127.0.0.1:3000") {
         throw new Error(`HTTP error! status: ${response.status}`);
     }
     const response_json = await response.json();
-    //TODO we should launch some schema validation here
     assertObject(response_json);
     if ("error" in response_json) {
         throw new Error(`Error response: ${response_json.error.message || "unknown error"}`);

package/dist/api/webProof/providers/extension.js

@@ -1,32 +1,53 @@
+import { ExtensionMessageType, } from "../../../web-proof-commons";
 // this id is fixed in the extension by the key in manifest.json
 const EXTENSION_ID = "jbchhcgphfokabmfacnkafoeeeppjmpl";
-export const createExtensionWebProofProvider = ({ notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.5/", wsProxyUrl = "wss://notary.pse.dev/proxy", } = {
-    notaryUrl: "https://notary.pse.dev/v0.1.0-alpha.5/",
-    wsProxyUrl: "wss://notary.pse.dev/proxy",
-}) => {
-    return {
-        getWebProof: async function (webProofSetup) {
-            return new Promise((resolve, reject) => {
-                chrome.runtime.sendMessage(EXTENSION_ID, {
-                    action: 0 /* ExtensionAction.RequestWebProof */,
-                    payload: {
-                        notaryUrl,
-                        wsProxyUrl,
-                        logoUrl: webProofSetup.logoUrl,
-                        steps: webProofSetup.steps,
-                    },
-                });
-                const port = chrome.runtime.connect(EXTENSION_ID);
-                // TODO: validate message in runtime
-                port.onMessage.addListener((message) => {
-                    if (message.type === "ProofDone" /* ExtensionMessageType.ProofDone */) {
-                        resolve(message.proof);
-                    }
-                    if (message.type === "ProofError" /* ExtensionMessageType.ProofError */) {
-                        reject(new Error(message.error));
-                    }
-                });
+class ExtensionWebProofProvider {
+    notaryUrl;
+    wsProxyUrl;
+    port = null;
+    constructor(notaryUrl, wsProxyUrl) {
+        this.notaryUrl = notaryUrl;
+        this.wsProxyUrl = wsProxyUrl;
+    }
+    notifyZkProvingStatus(status) {
+        if (typeof chrome !== "undefined") {
+            this.connectToExtension().postMessage({
+                action: 1 /* ExtensionAction.NotifyZkProvingStatus */,
+                payload: { status },
             });
-        },
-    };
+        }
+        else {
+            console.log("Run out of chrome context");
+        }
+    }
+    connectToExtension() {
+        if (!this.port) {
+            this.port = chrome.runtime.connect(EXTENSION_ID);
+        }
+        return this.port;
+    }
+    async getWebProof(webProofSetup) {
+        return new Promise((resolve, reject) => {
+            chrome.runtime.sendMessage(EXTENSION_ID, {
+                action: 0 /* ExtensionAction.RequestWebProof */,
+                payload: {
+                    notaryUrl: this.notaryUrl,
+                    wsProxyUrl: this.wsProxyUrl,
+                    logoUrl: webProofSetup.logoUrl,
+                    steps: webProofSetup.steps,
+                },
+            });
+            this.connectToExtension().onMessage.addListener((message) => {
+                if (message.type === ExtensionMessageType.ProofDone) {
+                    resolve(message.proof);
+                }
+                if (message.type === ExtensionMessageType.ProofError) {
+                    reject(new Error(message.error));
+                }
+            });
+        });
+    }
+}
+export const createExtensionWebProofProvider = ({ notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.5/", wsProxyUrl = "wss://notary.pse.dev/proxy", } = {}) => {
+    return new ExtensionWebProofProvider(notaryUrl, wsProxyUrl);
 };

package/dist/web-proof-commons/types/message.d.ts

@@ -7,13 +7,24 @@ export declare const EXTENSION_STEP: {
 };
 export type ExtensionStep = (typeof EXTENSION_STEP)[keyof typeof EXTENSION_STEP];
 export declare const enum ExtensionAction {
-    RequestWebProof = 0
+    RequestWebProof = 0,
+    NotifyZkProvingStatus = 1
+}
+export declare enum ZkProvingStatus {
+    Proving = "proving",
+    Done = "done",
+    Error = "error"
 }
 export type MessageToExtension = {
-    action: ExtensionAction;
+    action: ExtensionAction.RequestWebProof;
     payload: WebProverSessionConfig;
+} | {
+    action: ExtensionAction.NotifyZkProvingStatus;
+    payload: {
+        status: ZkProvingStatus;
+    };
 };
-export declare const enum ExtensionMessageType {
+export declare enum ExtensionMessageType {
     ProofDone = "ProofDone",
     ProofError = "ProofError",
     RedirectBack = "RedirectBack",

package/dist/web-proof-commons/types/message.js

@@ -3,3 +3,16 @@ export const EXTENSION_STEP = {
     startPage: "startPage",
     notarize: "notarize",
 };
+export var ZkProvingStatus;
+(function (ZkProvingStatus) {
+    ZkProvingStatus["Proving"] = "proving";
+    ZkProvingStatus["Done"] = "done";
+    ZkProvingStatus["Error"] = "error";
+})(ZkProvingStatus || (ZkProvingStatus = {}));
+export var ExtensionMessageType;
+(function (ExtensionMessageType) {
+    ExtensionMessageType["ProofDone"] = "ProofDone";
+    ExtensionMessageType["ProofError"] = "ProofError";
+    ExtensionMessageType["RedirectBack"] = "RedirectBack";
+    ExtensionMessageType["TabOpened"] = "TabOpened";
+})(ExtensionMessageType || (ExtensionMessageType = {}));

package/package.json

@@ -11,7 +11,7 @@
       "types": "./dist/api/webProof/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241105-90d39b6",
+  "version": "0.1.0-nightly-20241106-04bef04",
   "scripts": {
     "build": "bun tsc",
     "test:unit": "vitest --run",
@@ -22,7 +22,8 @@
     "@changesets/cli": "^2.27.7",
     "@types/bun": "latest",
     "abitype": "^1.0.6",
-    "vitest": "^2.1.1"
+    "vitest": "^2.1.1",
+    "vitest-fetch-mock": "^0.4.1"
   },
   "peerDependencies": {
     "typescript": "^5.6.3"