@vlayer/sdk 0.1.0-nightly-20241121-ee5bff1 → 0.1.0-nightly-20241125-3bf0279

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",
@@ -24,9 +18,9 @@ export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProv
 }) => {
     const resultHashMap = new Map();
     return {
-        prove: async ({ address, functionName, chainId, proverAbi, args }) => {
+        prove: async ({ address, functionName, chainId, gasLimit, proverAbi, args, }) => {
             webProofProvider.notifyZkProvingStatus(ZkProvingStatus.Proving);
-            const result_promise = prove(address, proverAbi, functionName, args, chainId, url)
+            const response = prove(address, proverAbi, functionName, args, chainId, gasLimit, 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, }) => {
@@ -53,5 +51,36 @@ export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProv
             }));
             return [proof, ...result];
         },
+        proveWeb: async function ({ address, proverAbi, functionName, chainId, args, }) {
+            const webProofPlaceholder = args[0];
+            const commitmentArgs = args.slice(1);
+            const webProof = await webProofProvider.getWebProof({
+                proverCallCommitment: {
+                    address,
+                    proverAbi,
+                    functionName,
+                    commitmentArgs,
+                    chainId,
+                },
+                logoUrl: webProofPlaceholder.logoUrl,
+                steps: webProofPlaceholder.steps,
+            });
+            const hash = await this.prove({
+                address,
+                functionName,
+                chainId,
+                proverAbi,
+                args: [
+                    {
+                        webProofJson: JSON.stringify({
+                            tls_proof: webProof,
+                            notary_pub_key: webProofPlaceholder.notaryPubKey,
+                        }),
+                    },
+                    ...commitmentArgs,
+                ],
+            });
+            return 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/viem.d.ts

@@ -4,5 +4,5 @@ type Without<T extends readonly unknown[], P> = T extends readonly [
     infer F,
     ...infer R
 ] ? F extends P ? Without<R, P> : readonly [F, ...Without<R, P>] : [];
-export type ContractFunctionArgsWithout<abi extends Abi, functionName extends ContractFunctionName<abi>, without> = AbiParametersToPrimitiveTypes<Without<ExtractAbiFunction<abi extends Abi ? abi : Abi, functionName>["inputs"], without>, "inputs"> extends infer args ? [args] extends [never] ? readonly unknown[] : args : readonly unknown[];
+export type ContractFunctionArgsWithout<abi extends Abi, functionName extends ContractFunctionName<abi>, without> = AbiParametersToPrimitiveTypes<Without<ExtractAbiFunction<abi extends Abi ? abi : Abi, functionName>["inputs"], without>, "inputs">;
 export {};

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

@@ -1,5 +1,7 @@
 import { Branded } from "../../../web-proof-commons/utils.js";
 import { Abi, AbiStateMutability, Address, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, Hex } from "viem";
+import { WebProofRequest } from "./webProofProvider.js";
+import { ContractFunctionArgsWithout } from "./viem.js";
 type Calldata = string;
 export type CallParams = {
     to: Address;
@@ -7,6 +9,7 @@ export type CallParams = {
 };
 export type CallContext = {
     chain_id: number;
+    gas_limit: number;
 };
 export type BrandedHash<T, F> = Branded<{
     hash: string;
@@ -27,6 +30,7 @@ export type Proof = {
     };
 };
 export interface VCallResult {
+    hash: Hex;
     evm_call_result: Hex;
     proof: Proof;
 }
@@ -41,8 +45,21 @@ export type VlayerClient = {
         proverAbi: T;
         functionName: F;
         chainId?: number;
+        gasLimit?: number;
         args: ContractFunctionArgs<T, AbiStateMutability, F>;
     }) => Promise<BrandedHash<T, F>>;
     waitForProvingResult: <T extends Abi, F extends ContractFunctionName<T>>(hash: BrandedHash<T, F>) => Promise<ContractFunctionReturnType<T, AbiStateMutability, F>>;
+    proveWeb: <T extends Abi, F extends ContractFunctionName<T>>(args: {
+        address: Hex;
+        proverAbi: T;
+        functionName: F;
+        chainId: number;
+        args: [
+            WebProofRequest,
+            ...ContractFunctionArgsWithout<T, F, {
+                name: "webProof";
+            }>
+        ];
+    }) => Promise<BrandedHash<T, F>>;
 };
 export {};

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

@@ -1,11 +1,12 @@
 import { Hex, Abi, ContractFunctionName } from "viem";
 import type { ContractFunctionArgsWithout } from "./viem.js";
-import { Branded, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
-export type WebProofSetupInput = {
+import { Branded, ExtensionMessageType, ExtensionMessage, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
+export type WebProofRequestInput = {
     logoUrl: string;
     steps: WebProofStep[];
+    notaryPubKey?: string;
 };
-export type WebProofSetup = Branded<WebProofSetupInput & {
+export type WebProofRequest = Branded<WebProofRequestInput & {
     isWebProof: true;
 }, "webProof">;
 export type ProverCallCommitment<T extends Abi, F extends ContractFunctionName<T>> = {
@@ -19,10 +20,14 @@ export type ProverCallCommitment<T extends Abi, F extends ContractFunctionName<T
 };
 export type GetWebProofArgs<T extends Abi, F extends ContractFunctionName<T>> = {
     proverCallCommitment: ProverCallCommitment<T, F>;
-} & WebProofSetupInput;
+} & WebProofRequestInput;
 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/prover.d.ts

@@ -1,2 +1,2 @@
 import { type Abi, AbiStateMutability, type Address, ContractFunctionArgs, ContractFunctionName } from "viem";
-export declare function prove<T extends Abi, F extends ContractFunctionName<T>>(prover: Address, abi: T, functionName: F, args: ContractFunctionArgs<T, AbiStateMutability, F>, chainId?: number, url?: string): Promise<import("./lib/types/vlayer.js").VCallResponse>;
+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): Promise<import("./lib/types/vlayer.js").VCallResponse>;

package/dist/api/prover.js

@@ -1,7 +1,7 @@
 import { encodeFunctionData, } from "viem";
 import { v_call } from "./v_call.js";
 import { foundry } from "viem/chains";
-export async function prove(prover, abi, functionName, args, chainId = foundry.id, url = "http://127.0.0.1:3000") {
+export async function prove(prover, abi, functionName, args, chainId = foundry.id, gasLimit = 1_000_000, url = "http://127.0.0.1:3000") {
     const calldata = encodeFunctionData({
         abi: abi,
         functionName: functionName,
@@ -10,6 +10,7 @@ export async function prove(prover, abi, functionName, args, chainId = foundry.i
     const call = { to: prover, data: calldata };
     const context = {
         chain_id: chainId,
+        gas_limit: gasLimit,
     };
     return v_call(call, context, url);
 }

package/dist/api/webProof/createWebProofRequest.d.ts

@@ -0,0 +1,2 @@
+import { WebProofRequest, WebProofRequestInput } from "../lib/types/webProofProvider.js";
+export declare const createWebProofRequest: ({ logoUrl, steps, notaryPubKey, }: WebProofRequestInput) => WebProofRequest;

package/dist/api/webProof/createWebProofRequest.js

@@ -0,0 +1,9 @@
+const NOTARY_PUB_KEY = "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAExpX/4R4z40gI6C/j9zAM39u58LJu\n3Cx5tXTuqhhu/tirnBi5GniMmspOTEsps4ANnPLpMmMSfhJ+IFHbc3qVOA==\n-----END PUBLIC KEY-----\n";
+export const createWebProofRequest = ({ logoUrl, steps, notaryPubKey = NOTARY_PUB_KEY, }) => {
+    return {
+        logoUrl,
+        steps,
+        notaryPubKey,
+        isWebProof: true,
+    };
+};

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

@@ -1,3 +1,3 @@
-export * from "./createWebProof.js";
+export * from "./createWebProofRequest.js";
 export * from "./steps/index.js";
 export * from "./providers/index.js";

package/dist/api/webProof/index.js

@@ -1,3 +1,3 @@
-export * from "./createWebProof.js";
+export * from "./createWebProofRequest.js";
 export * from "./steps/index.js";
 export * from "./providers/index.js";

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

@@ -1,45 +1,86 @@
 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;
     }
     notifyZkProvingStatus(status) {
         if (typeof chrome !== "undefined") {
-            chrome.runtime.sendMessage(EXTENSION_ID, {
-                action: 1 /* ExtensionAction.NotifyZkProvingStatus */,
-                payload: { status },
-            });
+            // Chrome does not provide reliable api to check if given extension is installed
+            // what we could do is to use management api but
+            // 1) this will need to provided extra permission
+            // 2) still is not reliable because this api becomes defined when first extension that uses it is installed
+            // so still will need to try catch
+            try {
+                chrome.runtime.sendMessage(EXTENSION_ID, {
+                    action: "NotifyZkProvingStatus" /* ExtensionAction.NotifyZkProvingStatus */,
+                    payload: { status },
+                });
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                console.log("Cant send message", "look that extension is not installed ");
+            }
         }
     }
     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;
     }
-    async getWebProof(webProofSetup) {
+    addEventListeners(messageType, listener) {
+        this.connectToExtension();
+        if (!this.listeners[messageType]) {
+            this.listeners[messageType] = [];
+        }
+        this.listeners[messageType].push(listener);
+    }
+    requestWebProof(webProofRequest) {
+        this.connectToExtension().postMessage({
+            action: "RequestWebProof" /* ExtensionAction.RequestWebProof */,
+            payload: {
+                notaryUrl: this.notaryUrl,
+                wsProxyUrl: this.wsProxyUrl,
+                logoUrl: webProofRequest.logoUrl,
+                steps: webProofRequest.steps,
+            },
+        });
+    }
+    async getWebProof(webProofRequest) {
         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,
-                    logoUrl: webProofSetup.logoUrl,
-                    steps: webProofSetup.steps,
+                    logoUrl: webProofRequest.logoUrl,
+                    steps: webProofRequest.steps,
                 },
             });
             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-20241125-3bf0279",
   "scripts": {
     "build": "bun tsc && bun tsc-alias",
     "test:unit": "vitest --run",

package/dist/api/webProof/createWebProof.d.ts

@@ -1,2 +0,0 @@
-import { WebProofSetup, WebProofSetupInput } from "../lib/types/webProofProvider.js";
-export declare const createWebProof: ({ logoUrl, steps }: WebProofSetupInput) => WebProofSetup;

package/dist/api/webProof/createWebProof.js

@@ -1,7 +0,0 @@
-export const createWebProof = ({ logoUrl, steps }) => {
-    return {
-        logoUrl,
-        steps,
-        isWebProof: true,
-    };
-};