@vlayer/sdk 0.1.0-nightly-20241204-02d2f89 → 0.1.0-nightly-20241206-b638b72

package/dist/api/email/parseEmail.d.ts

@@ -2,9 +2,10 @@ import { Email } from "postal-mime";
 export declare class DkimParsingError extends Error {
     constructor(message: string);
 }
-export declare function parseEmail(mime: string): Promise<Email>;
-export declare function getDkimSigners(mail: Email): {
+export interface DkimDomainSelector {
     domain: string;
     selector: string;
-}[];
+}
+export declare function parseEmail(mime: string): Promise<Email>;
+export declare function getDkimSigners(mail: Email): DkimDomainSelector[];
 export declare function parseParams(str: string): Record<string, string>;

package/dist/api/email/preverify.d.ts

@@ -1,3 +1,5 @@
+import { DkimDomainSelector } from "./parseEmail.js";
+export declare function findIndicesOfMatchingDomains(signers: DkimDomainSelector[], expectedOrigin: string): number[];
 export declare function preverifyEmail(mimeEmail: string): Promise<{
     email: string;
     dnsRecords: string[];

package/dist/api/email/preverify.js

@@ -1,13 +1,35 @@
-import { parseEmail, getDkimSigners } from "./parseEmail.js";
+import { getDkimSigners, parseEmail } from "./parseEmail.js";
 import { resolveDkimDns } from "./dnsResolver.js";
+import { prefixAllButNthSubstring } from "../utils/prefixAllButNthSubstring.js";
+export function findIndicesOfMatchingDomains(signers, expectedOrigin) {
+    return signers
+        .map(({ domain }) => expectedOrigin.endsWith(domain))
+        .map((isMatch, index) => (isMatch ? index : -1))
+        .filter((index) => index !== -1);
+}
+function requireSameOrigin(mimeEmail, signers, fromAddress) {
+    const matchingIndices = findIndicesOfMatchingDomains(signers, fromAddress);
+    if (matchingIndices.length != 1) {
+        throw new Error(`Found ${matchingIndices.length} DKIM headers matching the sender domain`);
+    }
+    const [matchingIndex] = matchingIndices;
+    return [
+        prefixAllButNthSubstring(mimeEmail, /^\s*dkim-signature/gim, signers.length, matchingIndex),
+        [signers[matchingIndex]],
+    ];
+}
 export async function preverifyEmail(mimeEmail) {
     const parsedEmail = await parseEmail(mimeEmail);
-    const signers = getDkimSigners(parsedEmail);
+    let signers = getDkimSigners(parsedEmail);
+    const fromAddress = parsedEmail.from.address;
+    if (!fromAddress) {
+        throw new Error("No from address found");
+    }
     if (signers.length === 0) {
         throw new Error("No DKIM header found");
     }
     if (signers.length > 1) {
-        throw new Error("Multiple DKIM headers found");
+        [mimeEmail, signers] = requireSameOrigin(mimeEmail, signers, fromAddress);
     }
     const [{ domain, selector }] = signers;
     const dnsRecord = await resolveDkimDns(domain, selector);

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

@@ -1,9 +1,9 @@
 import { describe, expect, test } from "vitest";
-import { preverifyEmail } from "./preverify.js";
 import { readFile } from "../../testHelpers/readFile.js";
+import { findIndicesOfMatchingDomains, preverifyEmail } from "./preverify.js";
+const rawEmail = readFile("./src/api/email/testdata/test_email.txt");
 describe("Preverify email: integration", () => {
     test("adds dns record to email mime", async () => {
-        const rawEmail = readFile("./src/api/email/testdata/test_email.txt");
         const preverifiedEmail = await preverifyEmail(rawEmail);
         expect(preverifiedEmail).toMatchObject({
             email: rawEmail,
@@ -18,8 +18,92 @@ describe("Preverify email: integration", () => {
         const emailWithNoDkimHeader = readFile("./src/api/email/testdata/test_email_unknown_domain.txt");
         await expect(preverifyEmail(emailWithNoDkimHeader)).rejects.toThrow();
     });
-    test("throws error if multiple DNS records found", async () => {
-        const emailWithNoDkimHeader = readFile("./src/api/email/testdata/test_email_multiple_dkims.txt");
-        await expect(preverifyEmail(emailWithNoDkimHeader)).rejects.toThrow("Multiple DKIM headers found");
+    describe("multiple DKIM headers", () => {
+        function addDkimWithDomain(domain, email) {
+            return `DKIM-Signature: v=1; a=rsa-sha256; d=${domain};
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+${email}`;
+        }
+        function addFakeDkimWithDomain(domain, email) {
+            return `X-${addDkimWithDomain(domain, email)}`;
+        }
+        test("looks for DKIM header with the domain matching the sender and removes all other DKIM headers", async () => {
+            const emailWithAddedHeaders = [
+                "example.com",
+                "hello.kitty",
+                "google.com",
+            ].reduce((email, domain) => addDkimWithDomain(domain, email), rawEmail);
+            const email = await preverifyEmail(emailWithAddedHeaders);
+            expect(email.email
+                .startsWith(`X-DKIM-Signature: v=1; a=rsa-sha256; d=google.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: v=1; a=rsa-sha256; d=hello.kitty;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+DKIM-Signature: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`)).toBeTruthy();
+            expect(email.dnsRecords).toStrictEqual(["v=DKIM1; p="]);
+        });
+        test("throws error if no DNS record domain matches the sender", async () => {
+            const emailWithAddedHeaders = addDkimWithDomain("otherdomain.com", rawEmail);
+            await expect(preverifyEmail(emailWithAddedHeaders)).rejects.toThrow("Found 0 DKIM headers matching the sender domain");
+        });
+        test("throws error if multiple DNS record domains match the sender", async () => {
+            let emailWithAddedHeaders = addDkimWithDomain("example.com", rawEmail);
+            emailWithAddedHeaders = addDkimWithDomain("example.com", emailWithAddedHeaders);
+            await expect(preverifyEmail(emailWithAddedHeaders)).rejects.toThrow("Found 2 DKIM headers matching the sender domain");
+        });
+        test("ignores x-dkim-signature headers", async () => {
+            const emailWithPrefixedDkim = addDkimWithDomain("example.com", addFakeDkimWithDomain("example.com", rawEmail));
+            const email = await preverifyEmail(emailWithPrefixedDkim);
+            expect(email.email
+                .startsWith(`DKIM-Signature: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`)).toBeTruthy();
+        });
+        test("ignores dkim-signature somewhere inside a header", async () => {
+            const headerWithDkim = `WTF-IS-THIS-HEADER: DKIM-SIGNATURE;`;
+            const emailWithDkimInHeader = `${headerWithDkim}\n${addDkimWithDomain("example.com", rawEmail)}`;
+            const email = await preverifyEmail(emailWithDkimInHeader);
+            expect(email.email.startsWith(`WTF-IS-THIS-HEADER: DKIM-SIGNATURE;
+DKIM-Signature: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`)).toBeTruthy();
+        });
+        test("ignores dkim-signature somewhere inside a body", async () => {
+            const emailWithAddedDkim = addDkimWithDomain("example.com", rawEmail);
+            const emailWithDkimsInBody = `${emailWithAddedDkim}\ndkim-signature   dkim-signature\r\ndkim-signature`;
+            const email = await preverifyEmail(emailWithDkimsInBody);
+            expect(email.email
+                .startsWith(`DKIM-Signature: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+X-DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`)).toBeTruthy();
+            expect(email.email.endsWith(`\ndkim-signature   dkim-signature\r\ndkim-signature`)).toBeTruthy();
+        });
+    });
+});
+describe("findIndicesOfMatchingDomains", () => {
+    test("returns indices of matching domains", () => {
+        const signers = [
+            { domain: "example.com", selector: "selector1" },
+            { domain: "other.other", selector: "selector2" },
+            { domain: "example.com", selector: "selector3" },
+        ];
+        expect(findIndicesOfMatchingDomains(signers, "example.com")).toStrictEqual([
+            0, 2,
+        ]);
+    });
+    test("returns empty array if no matching domains", () => {
+        const signers = [
+            { domain: "example.com", selector: "selector1" },
+            { domain: "example.org", selector: "selector2" },
+        ];
+        expect(findIndicesOfMatchingDomains(signers, "other.other")).toStrictEqual([]);
     });
 });

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/utils/prefixAllButNthSubstring.d.ts

@@ -0,0 +1 @@
+export declare function prefixAllButNthSubstring(str: string, pattern: RegExp, substringsCount: number, skippedIndex: number): string;

package/dist/api/utils/prefixAllButNthSubstring.js

@@ -0,0 +1,8 @@
+export function prefixAllButNthSubstring(str, pattern, substringsCount, skippedIndex) {
+    let occurrence = 0;
+    return str.replace(pattern, (match) => {
+        return occurrence++ === skippedIndex || occurrence > substringsCount
+            ? match
+            : `X-${match}`;
+    });
+}

package/dist/api/utils/prefixAllButNthSubstring.test.d.ts

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

package/dist/api/utils/prefixAllButNthSubstring.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "vitest";
+import { prefixAllButNthSubstring } from "./prefixAllButNthSubstring.js";
+describe("prefixAllButNthSubstring", () => {
+    test("adds 'X-' prefix to all matches except n-th (indexed from 0)", () => {
+        const str = "abc 123 abc 456 abc 789";
+        expect(prefixAllButNthSubstring(str, /abc/gi, 3, 0)).toBe("abc 123 X-abc 456 X-abc 789");
+        expect(prefixAllButNthSubstring(str, /abc/gi, 3, 1)).toBe("X-abc 123 abc 456 X-abc 789");
+        expect(prefixAllButNthSubstring(str, /abc/gi, 3, 2)).toBe("X-abc 123 X-abc 456 abc 789");
+    });
+    test("does not add prefix to substrings past total substring count", () => {
+        const str = "abc 123 abc 456 abc 789 abc abc";
+        expect(prefixAllButNthSubstring(str, /abc/gi, 3, 1)).toBe("X-abc 123 abc 456 X-abc 789 abc abc");
+    });
+});

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/package.json

@@ -15,7 +15,7 @@
       "types": "./dist/config/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241204-02d2f89",
+  "version": "0.1.0-nightly-20241206-b638b72",
   "scripts": {
     "build": "bun tsc && bun tsc-alias",
     "test:unit": "vitest --run",