@vlayer/sdk 0.1.0-nightly-20241122-7018b34 → 0.1.0-nightly-20241125-736efe7

package/dist/api/email/dnsResolver.js

@@ -2,5 +2,12 @@ import DnsResolver from "dns-over-http-resolver";
 export async function resolveDkimDns(domain, selector) {
     const resolver = new DnsResolver();
     const address = await resolver.resolveTxt(`${selector}._domainkey.${domain}`);
-    return address.flat()[0];
+    let record = address.flat().at(-1);
+    if (!record) {
+        throw new Error("No DKIM DNS record found");
+    }
+    if (record?.startsWith("p=")) {
+        record = ["v=DKIM1", "k=rsa", record].join("; ");
+    }
+    return record;
 }

package/dist/api/email/dnsResolver.test.js

@@ -6,6 +6,11 @@ describe("resolveDkimDns Integration", () => {
         const expected = "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3gWcOhCm99qzN+h7/2+LeP3CLsJkQQ4EP/2mrceXle5pKq8uZmBl1U4d2Vxn4w+pWFANDLmcHolLboESLFqEL5N6ae7u9b236dW4zn9AFkXAGenTzQEeif9VUFtLAZ0Qh2eV7OQgz/vPj5IaNqJ7h9hpM9gO031fe4v+J0DLCE8Rgo7hXbNgJavctc0983DaCDQaznHZ44LZ6TtZv9TBs+QFvsy4+UCTfsuOtHzoEqOOuXsVXZKLP6B882XbEnBpXEF8QzV4J26HiAJFUbO3mAqZL2UeKC0hhzoIZqZXNG0BfuzOF0VLpDa18GYMUiu+LhEJPJO9D8zhzvQIHNrpGwIDAQAB";
         expect(resolved).toBe(expected);
     });
+    test("resolves delegated dns", async () => {
+        const resolved = await resolveDkimDns("bolt.eu", "el7njvpsjxbr7wk7l7dss5ejzvijzoeu");
+        const expected = "v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQxwOEYMZS2rPORBB94iL47Ute8zb1SUNl7K0zCQMk+M83AJHcwKjnJVhA4F0rLbSxY7cxJgl57lN4Vp5k10HHOil00oIn1S0ChBKHiFCQAMHCNonwDOdJa6mXwe2VwEM7hnVpRc/Eo0F0acpNMeYJxyLcTcOuZBNzcPm6t+4uTwIDAQAB";
+        expect(resolved).toBe(expected);
+    });
     test("throws error if dns not found", async () => {
         await expect(resolveDkimDns("not-a-domain.com", "abcd")).rejects.toThrow();
     });

package/dist/api/lib/client.js

@@ -18,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 response = 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;
@@ -51,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/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;
@@ -42,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, ExtensionMessageType, ExtensionMessage, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
-export type WebProofSetupInput = {
+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,7 +20,7 @@ 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;

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

@@ -11,10 +11,21 @@ class ExtensionWebProofProvider {
     }
     notifyZkProvingStatus(status) {
         if (typeof chrome !== "undefined") {
-            chrome.runtime.sendMessage(EXTENSION_ID, {
-                action: "NotifyZkProvingStatus" /* 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() {
@@ -42,26 +53,26 @@ class ExtensionWebProofProvider {
         }
         this.listeners[messageType].push(listener);
     }
-    requestWebProof(webProofSetup) {
+    requestWebProof(webProofRequest) {
         this.connectToExtension().postMessage({
             action: "RequestWebProof" /* ExtensionAction.RequestWebProof */,
             payload: {
                 notaryUrl: this.notaryUrl,
                 wsProxyUrl: this.wsProxyUrl,
-                logoUrl: webProofSetup.logoUrl,
-                steps: webProofSetup.steps,
+                logoUrl: webProofRequest.logoUrl,
+                steps: webProofRequest.steps,
             },
         });
     }
-    async getWebProof(webProofSetup) {
+    async getWebProof(webProofRequest) {
         return new Promise((resolve, reject) => {
             chrome.runtime.sendMessage(EXTENSION_ID, {
                 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) => {

package/package.json

@@ -15,7 +15,7 @@
       "types": "./dist/config/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241122-7018b34",
+  "version": "0.1.0-nightly-20241125-736efe7",
   "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,
-    };
-};