@vlayer/sdk 0.1.0-nightly-20241205-223f353 → 0.1.0-nightly-20241209-52a03e4

package/dist/api/lib/client.js

@@ -1,4 +1,4 @@
-import { prove } from "../prover.js";
+import { prove, getProofReceipt } from "../prover.js";
 import { createExtensionWebProofProvider } from "../webProof/index.js";
 import { decodeFunctionResult, } from "viem";
 import { ZkProvingStatus } from "../../web-proof-commons/index.js";
@@ -10,7 +10,7 @@ function dropEmptyProofFromArgs(args) {
 }
 async function getHash(vcall_response) {
     const result = await vcall_response;
-    return [result.result.hash, result];
+    return result.result;
 }
 export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProvider = createExtensionWebProofProvider(), } = {
     url: "http://127.0.0.1:3000",
@@ -29,21 +29,17 @@ export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProv
                 webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Done);
                 return result;
             });
-            const [hash, result_promise] = await getHash(response);
-            resultHashMap.set(hash, [
-                Promise.resolve(result_promise),
-                proverAbi,
-                functionName,
-            ]);
+            const hash = await getHash(response);
+            resultHashMap.set(hash, [proverAbi, functionName]);
             return { hash };
         },
         waitForProvingResult: async ({ hash, }) => {
+            const { result: { proof, evm_call_result }, } = await getProofReceipt({ hash }, url);
             const savedProvingData = resultHashMap.get(hash);
             if (!savedProvingData) {
                 throw new Error("No result found for hash " + hash);
             }
-            const [result_promise, proverAbi, functionName] = savedProvingData;
-            const { result: { proof, evm_call_result }, } = await result_promise;
+            const [proverAbi, functionName] = savedProvingData;
             const result = dropEmptyProofFromArgs(decodeFunctionResult({
                 abi: proverAbi,
                 data: evm_call_result,

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

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { describe, expect, it, vi, beforeEach, beforeAll, } from "vitest";
 import { createExtensionWebProofProvider } from "../webProof/index.js";
 import { createVlayerClient } from "./client.js";
 import { ZkProvingStatus } from "src/web-proof-commons";
@@ -28,35 +28,46 @@ function generateRandomHash() {
     return hash;
 }
 describe("Success zk-proving", () => {
-    beforeEach(() => {
-        fetchMocker.mockResponseOnce((req) => {
-            if (req.url === "http://127.0.0.1:3000/") {
-                return {
-                    body: JSON.stringify({
-                        result: {
-                            hash: generateRandomHash(),
-                            proof: {},
-                        },
-                    }),
-                };
-            }
-            return {};
-        });
-    });
-    it("should send message to extension that zkproving started and then that is done", async () => {
+    let hash;
+    let zkProvingSpy;
+    let vlayer;
+    beforeAll(() => {
+        hash = generateRandomHash();
         const webProofProvider = createExtensionWebProofProvider();
-        const zkProvingSpy = vi.spyOn(webProofProvider, "notifyZkProvingStatus");
-        const vlayer = createVlayerClient({ webProofProvider });
-        const hash = await vlayer.prove({
+        zkProvingSpy = vi.spyOn(webProofProvider, "notifyZkProvingStatus");
+        vlayer = createVlayerClient({ webProofProvider });
+    });
+    it("should send message to extension that zkproving started", async () => {
+        fetchMocker.mockResponseOnce(() => {
+            return {
+                body: JSON.stringify({
+                    result: hash,
+                }),
+            };
+        });
+        const result = await vlayer.prove({
             address: `0x${"a".repeat(40)}`,
             functionName: "main",
             proverAbi: [],
             args: [],
             chainId: 42,
         });
-        await vlayer.waitForProvingResult(hash);
+        expect(result.hash).toBe(hash);
         expect(zkProvingSpy).toBeCalledTimes(2);
         expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+    });
+    it("should send message to extension that zkproving is done", async () => {
+        fetchMocker.mockResponseOnce(() => {
+            return {
+                body: JSON.stringify({
+                    result: {
+                        proof: {},
+                    },
+                }),
+            };
+        });
+        await vlayer.waitForProvingResult({ hash });
+        expect(zkProvingSpy).toBeCalledTimes(2);
         expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Done);
     });
 });

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

@@ -7,7 +7,7 @@ export type ContractSpec = {
     abi: Abi;
     bytecode: Bytecode;
 };
-export type ContractArg = number | string | boolean | bigint | number[] | string[] | boolean[] | bigint[] | Address[];
+export type ContractArg = number | string | boolean | bigint | number[] | string[] | boolean[] | bigint[] | Address[] | (string | bigint)[] | (string | bigint)[][];
 export type EthereumAddress = Branded<Hex, "EthereumAddress">;
 export type EthereumTxHash = Branded<Hex, "EthereumTxHash">;
 export declare function assertEthereumAddress(hash: string): asserts hash is EthereumAddress;

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

@@ -29,14 +29,22 @@ export type Proof = {
         settleBlockNumber: bigint;
     };
 };
-export interface VCallResult {
+export type VCallResult = Hex;
+export interface VCallResponse {
+    jsonrpc: string;
+    result: VCallResult;
+    id: number;
+}
+export type VGetProofReceiptParams = {
     hash: Hex;
+};
+export interface VGetProofReceiptResult {
     evm_call_result: Hex;
     proof: Proof;
 }
-export interface VCallResponse {
+export interface VGetProofReceiptResponse {
     jsonrpc: string;
-    result: VCallResult;
+    result: VGetProofReceiptResult;
     id: number;
 }
 export type VlayerClient = {

package/dist/api/prover.d.ts

@@ -1,5 +1,7 @@
 import { type Abi, AbiStateMutability, type Address, ContractFunctionArgs, ContractFunctionName } from "viem";
+import { type BrandedHash } from "./lib/types/vlayer.js";
 export interface ProveOptions {
     preverifyVersions?: boolean;
 }
 export declare function prove<T extends Abi, F extends ContractFunctionName<T>>(prover: Address, abi: T, functionName: F, args: ContractFunctionArgs<T, AbiStateMutability, F>, chainId?: number, gasLimit?: number, url?: string, options?: ProveOptions): Promise<import("./lib/types/vlayer.js").VCallResponse>;
+export declare function getProofReceipt<T extends Abi, F extends ContractFunctionName<T>>(hash: BrandedHash<T, F>, url?: string): Promise<import("./lib/types/vlayer.js").VGetProofReceiptResponse>;

package/dist/api/prover.js

@@ -1,5 +1,6 @@
 import { encodeFunctionData, } from "viem";
 import { v_call } from "./v_call.js";
+import { v_getProofReceipt } from "./v_getProofReceipt.js";
 import { foundry } from "viem/chains";
 import { v_versions } from "./v_versions.js";
 import { checkVersionCompatibility } from "./utils/versions.js";
@@ -25,3 +26,9 @@ export async function prove(prover, abi, functionName, args, chainId = foundry.i
     };
     return v_call(call, context, url);
 }
+export async function getProofReceipt(hash, url = "http://127.0.0.1:3000") {
+    const params = {
+        hash: hash.hash,
+    };
+    return v_getProofReceipt(params, url);
+}

package/dist/api/v_getProofReceipt.d.ts

@@ -0,0 +1,2 @@
+import { VGetProofReceiptParams, VGetProofReceiptResponse } from "./lib/types/vlayer.js";
+export declare function v_getProofReceipt(params: VGetProofReceiptParams, url?: string): Promise<VGetProofReceiptResponse>;

package/dist/api/v_getProofReceipt.js

@@ -0,0 +1,32 @@
+import { parseVCallResponseError } from "./lib/errors.js";
+function v_getProofReceiptBody(params) {
+    return {
+        method: "v_getProofReceipt",
+        params: params,
+        id: 1,
+        jsonrpc: "2.0",
+    };
+}
+export async function v_getProofReceipt(params, url = "http://127.0.0.1:3000") {
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(v_getProofReceiptBody(params)),
+        headers: { "Content-Type": "application/json" },
+    });
+    console.log("response", response);
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const response_json = await response.json();
+    console.log("response_json", response_json);
+    assertObject(response_json);
+    if ("error" in response_json) {
+        throw parseVCallResponseError(response_json.error);
+    }
+    return response_json;
+}
+function assertObject(x) {
+    if (typeof x !== "object") {
+        throw new Error("Expected object");
+    }
+}

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

@@ -31,6 +31,10 @@ class ExtensionWebProofProvider {
     connectToExtension() {
         if (!this.port) {
             this.port = chrome.runtime.connect(EXTENSION_ID);
+            this.port.onDisconnect.addListener(() => {
+                this.port = null;
+                this.connectToExtension();
+            });
             this.port.onMessage.addListener((message) => {
                 if (message.type === ExtensionMessageType.ProofDone) {
                     this.listeners[ExtensionMessageType.ProofDone]?.forEach((cb) => {

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

@@ -1,7 +1,29 @@
 import { createExtensionWebProofProvider } from "./extension.js";
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { expectUrl, startPage, notarize } from "../steps/index.js";
 import { StepValidationError } from "../../../web-proof-commons/index.js";
+const chrome = {
+    runtime: {
+        disconnectCallbacks: [],
+        connect: vi.fn().mockImplementation(() => ({
+            postMessage: vi.fn().mockImplementation(() => { }),
+            onMessage: {
+                addListener: vi.fn().mockImplementation(() => { }),
+            },
+            onDisconnect: {
+                addListener: vi.fn().mockImplementation((callback) => {
+                    chrome.runtime.disconnectCallbacks.push(callback);
+                }),
+            },
+        })),
+        disconnect: vi.fn().mockImplementation(() => {
+            chrome.runtime.disconnectCallbacks.forEach((callback) => {
+                callback();
+            });
+        }),
+    },
+};
+vi.stubGlobal("chrome", chrome);
 const defaults = {
     logoUrl: "https://example.com/logo.png",
     proverCallCommitment: {
@@ -60,6 +82,20 @@ describe("ExtensionWebProofProvider", () => {
                 expectUrl(validUrl, label),
                 notarize(validUrl, "GET", label),
             ],
-        })).not.toThrow(StepValidationError);
+        })).not.toThrow();
+    });
+    it("should reconnect extension on disconnect", () => {
+        const provider = createExtensionWebProofProvider();
+        provider.requestWebProof({
+            ...defaults,
+            steps: [
+                startPage(validUrl, label),
+                expectUrl(validUrlPattern, label),
+                notarize(validUrlPattern, "GET", label),
+            ],
+        });
+        chrome.runtime.connect.mockClear();
+        chrome.runtime.disconnect();
+        expect(chrome.runtime.connect).toHaveBeenCalled();
     });
 });

package/package.json

@@ -15,7 +15,7 @@
       "types": "./dist/config/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241205-223f353",
+  "version": "0.1.0-nightly-20241209-52a03e4",
   "scripts": {
     "build": "bun tsc && bun tsc-alias",
     "test:unit": "vitest --run",