@vlayer/sdk 0.1.0-nightly-20241121-ee5bff1 → 0.1.0-nightly-20241122-7018b34

package/dist/api/lib/client.js

@@ -8,15 +8,9 @@ function dropEmptyProofFromArgs(args) {
     }
     return [];
 }
-function generateRandomHash() {
-    let hash = "0x";
-    for (let i = 0; i < 40; ++i) {
-        hash += Math.floor(Math.random() * 16).toString(16);
-    }
-    return hash;
-}
-async function getHash() {
-    return Promise.resolve(generateRandomHash());
+async function getHash(vcall_response) {
+    const result = await vcall_response;
+    return [result.result.hash, result];
 }
 export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProvider = createExtensionWebProofProvider(), } = {
     url: "http://127.0.0.1:3000",
@@ -26,7 +20,7 @@ export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProv
     return {
         prove: async ({ address, functionName, chainId, proverAbi, args }) => {
             webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Proving);
-            const result_promise = prove(address, proverAbi, functionName, args, chainId, url)
+            const response = prove(address, proverAbi, functionName, args, chainId, url)
                 .catch((error) => {
                 webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Error);
                 throw error;
@@ -35,8 +29,12 @@ export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProv
                 webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Done);
                 return result;
             });
-            const hash = await getHash();
-            resultHashMap.set(hash, [result_promise, proverAbi, functionName]);
+            const [hash, result_promise] = await getHash(response);
+            resultHashMap.set(hash, [
+                Promise.resolve(result_promise),
+                proverAbi,
+                functionName,
+            ]);
             return { hash };
         },
         waitForProvingResult: async ({ hash, }) => {

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

@@ -20,6 +20,13 @@ beforeEach(() => {
         },
     };
 });
+function generateRandomHash() {
+    let hash = "0x";
+    for (let i = 0; i < 40; ++i) {
+        hash += Math.floor(Math.random() * 16).toString(16);
+    }
+    return hash;
+}
 describe("Success zk-proving", () => {
     beforeEach(() => {
         fetchMocker.mockResponseOnce((req) => {
@@ -27,6 +34,7 @@ describe("Success zk-proving", () => {
                 return {
                     body: JSON.stringify({
                         result: {
+                            hash: generateRandomHash(),
                             proof: {},
                         },
                     }),
@@ -67,14 +75,14 @@ describe("Failed zk-proving", () => {
         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 {
+            const hash = await vlayer.prove({
+                address: `0x${"a".repeat(40)}`,
+                functionName: "main",
+                proverAbi: [],
+                args: [],
+                chainId: 42,
+            });
             await vlayer.waitForProvingResult(hash);
         }
         catch (e) {

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

@@ -27,6 +27,7 @@ export type Proof = {
     };
 };
 export interface VCallResult {
+    hash: Hex;
     evm_call_result: Hex;
     proof: Proof;
 }

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

@@ -1,6 +1,6 @@
 import { Hex, Abi, ContractFunctionName } from "viem";
 import type { ContractFunctionArgsWithout } from "./viem.js";
-import { Branded, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
+import { Branded, ExtensionMessageType, ExtensionMessage, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
 export type WebProofSetupInput = {
     logoUrl: string;
     steps: WebProofStep[];
@@ -22,7 +22,11 @@ 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>;
+    requestWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => void;
     notifyZkProvingStatus: (status: ZkProvingStatus) => void;
+    addEventListeners: <T extends ExtensionMessageType>(messageType: T, listener: (args: Extract<ExtensionMessage, {
+        type: T;
+    }>) => void) => void;
 };
 export type WebProofProviderSetup = {
     notaryUrl?: string;

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

@@ -1,10 +1,10 @@
 import { ExtensionMessageType, } from "../../../web-proof-commons/index.js";
-// this id is fixed in the extension by the key in manifest.json
 const EXTENSION_ID = "jbchhcgphfokabmfacnkafoeeeppjmpl";
 class ExtensionWebProofProvider {
     notaryUrl;
     wsProxyUrl;
     port = null;
+    listeners = {};
     constructor(notaryUrl, wsProxyUrl) {
         this.notaryUrl = notaryUrl;
         this.wsProxyUrl = wsProxyUrl;
@@ -12,7 +12,7 @@ class ExtensionWebProofProvider {
     notifyZkProvingStatus(status) {
         if (typeof chrome !== "undefined") {
             chrome.runtime.sendMessage(EXTENSION_ID, {
-                action: 1 /* ExtensionAction.NotifyZkProvingStatus */,
+                action: "NotifyZkProvingStatus" /* ExtensionAction.NotifyZkProvingStatus */,
                 payload: { status },
             });
         }
@@ -20,13 +20,43 @@ class ExtensionWebProofProvider {
     connectToExtension() {
         if (!this.port) {
             this.port = chrome.runtime.connect(EXTENSION_ID);
+            this.port.onMessage.addListener((message) => {
+                if (message.type === ExtensionMessageType.ProofDone) {
+                    this.listeners[ExtensionMessageType.ProofDone]?.forEach((cb) => {
+                        cb(message);
+                    });
+                }
+                if (message.type === ExtensionMessageType.ProofError) {
+                    this.listeners[ExtensionMessageType.ProofError]?.forEach((cb) => {
+                        cb(message);
+                    });
+                }
+            });
         }
         return this.port;
     }
+    addEventListeners(messageType, listener) {
+        this.connectToExtension();
+        if (!this.listeners[messageType]) {
+            this.listeners[messageType] = [];
+        }
+        this.listeners[messageType].push(listener);
+    }
+    requestWebProof(webProofSetup) {
+        this.connectToExtension().postMessage({
+            action: "RequestWebProof" /* ExtensionAction.RequestWebProof */,
+            payload: {
+                notaryUrl: this.notaryUrl,
+                wsProxyUrl: this.wsProxyUrl,
+                logoUrl: webProofSetup.logoUrl,
+                steps: webProofSetup.steps,
+            },
+        });
+    }
     async getWebProof(webProofSetup) {
         return new Promise((resolve, reject) => {
             chrome.runtime.sendMessage(EXTENSION_ID, {
-                action: 0 /* ExtensionAction.RequestWebProof */,
+                action: "RequestWebProof" /* ExtensionAction.RequestWebProof */,
                 payload: {
                     notaryUrl: this.notaryUrl,
                     wsProxyUrl: this.wsProxyUrl,
@@ -36,10 +66,10 @@ class ExtensionWebProofProvider {
             });
             this.connectToExtension().onMessage.addListener((message) => {
                 if (message.type === ExtensionMessageType.ProofDone) {
-                    resolve(message.proof);
+                    resolve(message.payload.proof);
                 }
                 if (message.type === ExtensionMessageType.ProofError) {
-                    reject(new Error(message.error));
+                    reject(new Error(message.payload.error));
                 }
             });
         });

package/dist/api/webProof/steps/index.d.ts

@@ -2,8 +2,8 @@ import { expectUrl } from "./expectUrl.js";
 import { startPage } from "./startPage.js";
 import { notarize } from "./notarize.js";
 declare const steps: {
-    expectUrl: (url: string, label: string) => import("../../../web-proof-commons/index.js").WebProofStepExpectUrl;
-    startPage: (url: string, label: string) => import("../../../web-proof-commons/index.js").WebProofStepStartPage;
-    notarize: (url: string, method: string | undefined, label: string) => import("../../../web-proof-commons/index.js").WebProofStepNotarize;
+    expectUrl: (url: string, label: string) => import("../../../index.js").WebProofStepExpectUrl;
+    startPage: (url: string, label: string) => import("../../../index.js").WebProofStepStartPage;
+    notarize: (url: string, method: string | undefined, label: string) => import("../../../index.js").WebProofStepNotarize;
 };
 export { expectUrl, startPage, notarize, steps };

package/dist/config/createContext.d.ts

@@ -2,7 +2,7 @@ import { type Chain, type CustomTransport, custom } from "viem";
 import { Config } from "./getConfig.js";
 export declare const customTransport: typeof custom;
 export { Chain };
-export declare const createContext: (config: Config, transport?: CustomTransport) => Promise<{
+export declare const createContext: (config: Config, transport?: CustomTransport) => {
     chain: Chain;
     account: {
         address: import("viem").Address;
@@ -4952,4 +4952,4 @@ export declare const createContext: (config: Config, transport?: CustomTransport
     chainName: string;
     proverUrl: string;
     privateKey: `0x${string}`;
-}>;
+};

package/dist/config/createContext.js

@@ -1,9 +1,9 @@
 import { createWalletClient, http, publicActions, custom, } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { getChainConfirmations } from "./getChainConfirmations.js";
-const getChainSpecs = async (chainName) => {
+import * as chains from "viem/chains";
+const getChainSpecs = (chainName) => {
     try {
-        const chains = await import("viem/chains");
         return chains[chainName];
     }
     catch {
@@ -15,8 +15,8 @@ const createEthClient = (chain, jsonRpcUrl, transport) => createWalletClient({
     chain,
     transport: transport || http(jsonRpcUrl),
 }).extend(publicActions);
-export const createContext = async (config, transport) => {
-    const chain = await getChainSpecs(config.chainName);
+export const createContext = (config, transport) => {
+    const chain = getChainSpecs(config.chainName);
     const jsonRpcUrl = config.jsonRpcUrl ?? chain.rpcUrls.default.http[0];
     return {
         ...config,

package/dist/config/deploy.js

@@ -2,7 +2,7 @@ import { getConfig } from "./getConfig.js";
 import { createContext } from "./createContext.js";
 import { getChainConfirmations } from "./getChainConfirmations.js";
 export const waitForContractDeploy = async ({ hash, }) => {
-    const { ethClient: client } = await createContext(getConfig());
+    const { ethClient: client } = createContext(getConfig());
     const receipt = await client.waitForTransactionReceipt({
         hash,
         confirmations: getChainConfirmations(client.chain?.name),
@@ -15,7 +15,7 @@ export const waitForContractDeploy = async ({ hash, }) => {
     return receipt.contractAddress;
 };
 export const waitForTransactionReceipt = async ({ hash, }) => {
-    const { ethClient } = await createContext(getConfig());
+    const { ethClient } = createContext(getConfig());
     return ethClient.waitForTransactionReceipt({
         hash,
         confirmations: getChainConfirmations(ethClient.chain?.name),
@@ -26,7 +26,7 @@ export const waitForTransactionReceipt = async ({ hash, }) => {
 export const deployVlayerContracts = async ({ proverSpec, verifierSpec, proverArgs, verifierArgs, }) => {
     console.log("Starting contract deployment process...");
     const config = getConfig();
-    const { chain, ethClient, account } = await createContext(config);
+    const { chain, ethClient, account } = createContext(config);
     console.log("Deploying prover contract...");
     const proverHash = await ethClient.deployContract({
         chain,

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export { createVlayerClient } from "./api/lib/client.js";
 export * from "./api/lib/types/index.js";
 export * from "./web-proof-commons/types/webProof.js";
 export * from "./web-proof-commons/utils.js";
+export * from "./web-proof-commons/types/message.js";

package/dist/index.js

@@ -4,3 +4,4 @@ export { createVlayerClient } from "./api/lib/client.js";
 export * from "./api/lib/types/index.js";
 export * from "./web-proof-commons/types/webProof.js";
 export * from "./web-proof-commons/utils.js";
+export * from "./web-proof-commons/types/message.js";

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

@@ -7,8 +7,8 @@ export declare const EXTENSION_STEP: {
 };
 export type ExtensionStep = (typeof EXTENSION_STEP)[keyof typeof EXTENSION_STEP];
 export declare const enum ExtensionAction {
-    RequestWebProof = 0,
-    NotifyZkProvingStatus = 1
+    RequestWebProof = "RequestWebProof",
+    NotifyZkProvingStatus = "NotifyZkProvingStatus"
 }
 export declare enum ZkProvingStatus {
     NotStarted = "NotStarted",
@@ -29,19 +29,31 @@ export declare enum ExtensionMessageType {
     ProofDone = "ProofDone",
     ProofError = "ProofError",
     RedirectBack = "RedirectBack",
-    TabOpened = "TabOpened"
+    TabOpened = "TabOpened",
+    ProofProcessing = "ProofProcessing"
 }
 export type ExtensionMessage = {
     type: ExtensionMessageType.ProofDone;
-    proof: WebProof;
+    payload: {
+        proof: WebProof;
+    };
 } | {
     type: ExtensionMessageType.ProofError;
-    error: string;
+    payload: {
+        error: string;
+    };
 } | {
     type: ExtensionMessageType.RedirectBack;
 } | {
     type: ExtensionMessageType.TabOpened;
-    tabId: number;
+    payload: {
+        tabId: number;
+    };
+} | {
+    type: ExtensionMessageType.ProofProcessing;
+    payload: {
+        progress?: number;
+    };
 };
 export type WebProverSessionConfig = {
     notaryUrl: string | null;

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

@@ -16,4 +16,5 @@ export var ExtensionMessageType;
     ExtensionMessageType["ProofError"] = "ProofError";
     ExtensionMessageType["RedirectBack"] = "RedirectBack";
     ExtensionMessageType["TabOpened"] = "TabOpened";
+    ExtensionMessageType["ProofProcessing"] = "ProofProcessing";
 })(ExtensionMessageType || (ExtensionMessageType = {}));

package/package.json

@@ -15,7 +15,7 @@
       "types": "./dist/config/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241121-ee5bff1",
+  "version": "0.1.0-nightly-20241122-7018b34",
   "scripts": {
     "build": "bun tsc && bun tsc-alias",
     "test:unit": "vitest --run",