@vlayer/sdk 0.1.0-nightly-20250127-96fc5df → 0.1.0-nightly-20250128-0a32cfc

package/src/api/email/preverify.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, test } from "vitest";
+import { readFile } from "testHelpers/readFile";
+import { findIndicesOfMatchingDomains, preverifyEmail } from "./preverify";
+
+const rawEmail = readFile("./src/api/email/testdata/test_email.txt");
+
+describe("Preverify email: integration", () => {
+  test("adds dns record to email mime", async () => {
+    const preverifiedEmail = await preverifyEmail(
+      rawEmail,
+      "https://dns.google/resolve",
+    );
+    expect(preverifiedEmail.email).toBe(rawEmail);
+    expect(preverifiedEmail.dnsRecord).toMatchObject({
+      name: "20230601._domainkey.google.com.",
+      recordType: 16,
+      ttl: expect.any(BigInt), // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+      data: expect.stringContaining("v=DKIM1; k=rsa; p="), // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+    });
+    expect(preverifiedEmail.dnsRecord.data).toContain("v=DKIM1; k=rsa; p=");
+  });
+
+  test("throws error if DKIM not found", async () => {
+    const emailWithNoDkimHeader = 'From: "Alice"\n\nBody';
+    await expect(
+      preverifyEmail(emailWithNoDkimHeader, "https://dns.google/resolve"),
+    ).rejects.toThrow("No DKIM header found");
+  });
+
+  test("throws error if DNS could not be resolved", async () => {
+    const emailWithNoDkimHeader = readFile(
+      "./src/api/email/testdata/test_email_unknown_domain.txt",
+    );
+    await expect(
+      preverifyEmail(emailWithNoDkimHeader, "https://dns.google/resolve"),
+    ).rejects.toThrow();
+  });
+
+  describe("multiple DKIM headers", () => {
+    function addDkimWithDomain(domain: string, email: string) {
+      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: string, email: string) {
+      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"].reduce(
+        (email, domain) => addDkimWithDomain(domain, email),
+        rawEmail,
+      );
+      const email = await preverifyEmail(
+        emailWithAddedHeaders,
+        "https://dns.google/resolve",
+      );
+      expect(
+        email.email
+          .startsWith(`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=
+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=
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`),
+      ).toBeTruthy();
+      expect(email.dnsRecord.data).toEqual(
+        "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4zd3nfUoLHWFbfoPZzAb8bvjsFIIFsNypweLuPe4M+vAP1YxObFxRnpvLYz7Z+bORKLber5aGmgFF9iaufsH1z0+aw8Qex7uDaafzWoJOM/6lAS5iI0JggZiUkqNpRQLL7H6E7HcvOMC61nJcO4r0PwLDZKwEaCs8gUHiqRn/SS3wqEZX29v/VOUVcI4BjaOzOCLaz7V8Bkwmj4Rqq4kaLQQrbfpjas1naScHTAmzULj0Rdp+L1vVyGitm+dd460PcTIG3Pn+FYrgQQo2fvnTcGiFFuMa8cpxgfH3rJztf1YFehLWwJWgeXTriuIyuxUabGdRQu7vh7GrObTsHmIHwIDAQAB",
+      );
+    });
+
+    test("throws error if no DNS record domain matches the sender", async () => {
+      const emailWithOneDkimHeader = readFile(
+        "./src/api/email/testdata/test_email_unknown_domain.txt",
+      );
+      const emailWithAddedHeaders = addDkimWithDomain(
+        "otherdomain.com",
+        emailWithOneDkimHeader,
+      );
+      await expect(
+        preverifyEmail(emailWithAddedHeaders, "https://dns.google/resolve"),
+      ).rejects.toThrow("Found 0 DKIM headers matching the sender domain");
+    });
+
+    test("removes signatures from subdomain signers", async () => {
+      const email = await preverifyEmail(
+        addDkimWithDomain("subdomain.google.com", rawEmail),
+        "https://dns.google/resolve",
+      );
+      expect(
+        email.email
+          .startsWith(`X-DKIM-Signature: v=1; a=rsa-sha256; d=subdomain.google.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;\r
+ c=simple/simple; d=google.com;`),
+      ).toBeTruthy();
+    });
+
+    test("removes signatures with mismatching subdomains", async () => {
+      const emailWithAddedHeaders = addDkimWithDomain(
+        "subdomain.google.com",
+        readFile("./src/api/email/testdata/test_email_subdomain.txt"),
+      );
+      await expect(
+        preverifyEmail(emailWithAddedHeaders, "https://dns.google/resolve"),
+      ).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("google.com", rawEmail);
+      emailWithAddedHeaders = addDkimWithDomain(
+        "google.com",
+        emailWithAddedHeaders,
+      );
+      await expect(
+        preverifyEmail(emailWithAddedHeaders, "https://dns.google/resolve"),
+      ).rejects.toThrow("Found 3 DKIM headers matching the sender domain");
+    });
+
+    test("ignores x-dkim-signature headers", async () => {
+      const emailWithPrefixedDkim = addFakeDkimWithDomain(
+        "example.com",
+        addFakeDkimWithDomain("example.com", rawEmail),
+      );
+      const email = await preverifyEmail(
+        emailWithPrefixedDkim,
+        "https://dns.google/resolve",
+      );
+      expect(
+        email.email
+          .startsWith(`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: v=1; a=rsa-sha256; d=example.com;
+ s=selector; c=relaxed/relaxed; q=dns/txt; bh=; h=From:Subject:Date:To; b=
+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,
+        "https://dns.google/resolve",
+      );
+      expect(
+        email.email.startsWith(`WTF-IS-THIS-HEADER: DKIM-SIGNATURE;
+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=
+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,
+        "https://dns.google/resolve",
+      );
+      expect(
+        email.email
+          .startsWith(`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=
+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, "some@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/src/api/email/preverify.ts

@@ -0,0 +1,70 @@
+import {
+  type DkimDomainSelector,
+  getDkimSigners,
+  parseEmail,
+} from "./parseEmail";
+import { DnsResolver } from "./dnsResolver";
+import { prefixAllButNthSubstring } from "../utils/prefixAllButNthSubstring";
+
+export function findIndicesOfMatchingDomains(
+  signers: DkimDomainSelector[],
+  expectedOrigin: string,
+) {
+  return signers
+    .map(({ domain }) => expectedOrigin.endsWith(`@${domain}`))
+    .map((isMatch, index) => (isMatch ? index : -1))
+    .filter((index) => index !== -1);
+}
+
+function requireSameOrigin(
+  mimeEmail: string,
+  signers: DkimDomainSelector[],
+  fromAddress: string,
+) {
+  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]] as DkimDomainSelector[],
+  ] as const;
+}
+
+export async function preverifyEmail(
+  mimeEmail: string,
+  dnsResolverUrl: string,
+) {
+  const parsedEmail = await parseEmail(mimeEmail);
+  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");
+  }
+  [mimeEmail, signers] = requireSameOrigin(mimeEmail, signers, fromAddress);
+
+  const [{ domain, selector }] = signers;
+  const resolver = new DnsResolver(dnsResolverUrl);
+
+  const dnsResponse = await resolver.resolveDkimDns(selector, domain);
+
+  return {
+    email: mimeEmail,
+    ...dnsResponse,
+  };
+}

package/src/api/email/testdata/test_email.txt

@@ -0,0 +1,21 @@
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;
+ c=simple/simple; d=google.com;
+ h=Received:From:To:Subject:Date:Message-ID; i=joe@google.com;
+ s=20230601; t=1615825284; v=1;
+ b=Xh4Ujb2wv5x54gXtulCiy4C0e+plRm6pZ4owF+kICpYzs/8WkTVIDBrzhJP0DAYCpnL62T0G
+ k+0OH8pi/yqETVjKtKk+peMnNvKkut0GeWZMTze0bfq3/JUK3Ln3jTzzpXxrgVnvBxeY9EZIL4g
+ s4wwFRRKz/1bksZGSjD8uuSU=
+Received: from client1.football.example.com  [192.0.2.1]
+      by submitserver.example.com with SUBMISSION;
+      Fri, 11 Jul 2003 21:01:54 -0700 (PDT)
+From: Joe SixPack <joe@google.com>
+To: Suzie Q <suzie@shopping.example.net>
+Subject: Is dinner ready?
+Date: Fri, 11 Jul 2003 21:00:37 -0700 (PDT)
+Message-ID: <20030712040037.46341.5F8J@football.example.com>
+
+Hi.
+
+We lost the game. Are you hungry yet?
+
+Joe.

package/src/api/email/testdata/test_email_multiple_dkims.txt

@@ -0,0 +1,28 @@
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;
+ c=simple/simple; d=google.com;
+ h=Received:From:To:Subject:Date:Message-ID; i=joe@football.example.com;
+ s=20230601; t=1615825284; v=1;
+ b=Xh4Ujb2wv5x54gXtulCiy4C0e+plRm6pZ4owF+kICpYzs/8WkTVIDBrzhJP0DAYCpnL62T0G
+ k+0OH8pi/yqETVjKtKk+peMnNvKkut0GeWZMTze0bfq3/JUK3Ln3jTzzpXxrgVnvBxeY9EZIL4g
+ s4wwFRRKz/1bksZGSjD8uuSU=
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;
+ c=simple/simple; d=google.com;
+ h=Received:From:To:Subject:Date:Message-ID; i=joe@football.example.com;
+ s=20230601; t=1615825284; v=1;
+ b=Xh4Ujb2wv5x54gXtulCiy4C0e+plRm6pZ4owF+kICpYzs/8WkTVIDBrzhJP0DAYCpnL62T0G
+ k+0OH8pi/yqETVjKtKk+peMnNvKkut0GeWZMTze0bfq3/JUK3Ln3jTzzpXxrgVnvBxeY9EZIL4g
+ s4wwFRRKz/1bksZGSjD8uuSU=
+Received: from client1.football.example.com  [192.0.2.1]
+      by submitserver.example.com with SUBMISSION;
+      Fri, 11 Jul 2003 21:01:54 -0700 (PDT)
+From: Joe SixPack <joe@football.example.com>
+To: Suzie Q <suzie@shopping.example.net>
+Subject: Is dinner ready?
+Date: Fri, 11 Jul 2003 21:00:37 -0700 (PDT)
+Message-ID: <20030712040037.46341.5F8J@football.example.com>
+
+Hi.
+
+We lost the game. Are you hungry yet?
+
+Joe.

package/src/api/email/testdata/test_email_subdomain.txt

@@ -0,0 +1,21 @@
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;
+ c=simple/simple; d=subdomain.google.com;
+ h=Received:From:To:Subject:Date:Message-ID; i=joe@google.com;
+ s=20230601; t=1615825284; v=1;
+ b=Xh4Ujb2wv5x54gXtulCiy4C0e+plRm6pZ4owF+kICpYzs/8WkTVIDBrzhJP0DAYCpnL62T0G
+ k+0OH8pi/yqETVjKtKk+peMnNvKkut0GeWZMTze0bfq3/JUK3Ln3jTzzpXxrgVnvBxeY9EZIL4g
+ s4wwFRRKz/1bksZGSjD8uuSU=
+Received: from client1.football.example.com  [192.0.2.1]
+      by submitserver.example.com with SUBMISSION;
+      Fri, 11 Jul 2003 21:01:54 -0700 (PDT)
+From: Joe SixPack <joe@google.com>
+To: Suzie Q <suzie@shopping.example.net>
+Subject: Is dinner ready?
+Date: Fri, 11 Jul 2003 21:00:37 -0700 (PDT)
+Message-ID: <20030712040037.46341.5F8J@football.example.com>
+
+Hi.
+
+We lost the game. Are you hungry yet?
+
+Joe.

package/src/api/email/testdata/test_email_unknown_domain.txt

@@ -0,0 +1,21 @@
+DKIM-Signature: a=rsa-sha256; bh=2jUSOH9NhtVGCQWNr9BrIAPreKQjO6Sn7XIkfJVOzv8=;
+ c=simple/simple; d=foobar.xyz;
+ h=Received:From:To:Subject:Date:Message-ID; i=joe@football.example.com;
+ s=wertyu; t=1615825284; v=1;
+ b=Xh4Ujb2wv5x54gXtulCiy4C0e+plRm6pZ4owF+kICpYzs/8WkTVIDBrzhJP0DAYCpnL62T0G
+ k+0OH8pi/yqETVjKtKk+peMnNvKkut0GeWZMTze0bfq3/JUK3Ln3jTzzpXxrgVnvBxeY9EZIL4g
+ s4wwFRRKz/1bksZGSjD8uuSU=
+Received: from client1.football.example.com  [192.0.2.1]
+      by submitserver.example.com with SUBMISSION;
+      Fri, 11 Jul 2003 21:01:54 -0700 (PDT)
+From: Joe SixPack <joe@football.example.com>
+To: Suzie Q <suzie@shopping.example.net>
+Subject: Is dinner ready?
+Date: Fri, 11 Jul 2003 21:00:37 -0700 (PDT)
+Message-ID: <20030712040037.46341.5F8J@football.example.com>
+
+Hi.
+
+We lost the game. Are you hungry yet?
+
+Joe.

package/src/api/lib/client.test.ts

@@ -0,0 +1,261 @@
+import {
+  describe,
+  expect,
+  it,
+  vi,
+  beforeEach,
+  type MockInstance,
+  afterEach,
+} from "vitest";
+
+import { createExtensionWebProofProvider } from "../webProof";
+import { createVlayerClient } from "./client";
+import { type BrandedHash, type VlayerClient } from "types/vlayer";
+import { ZkProvingStatus } from "../../web-proof-commons";
+import createFetchMock from "vitest-fetch-mock";
+
+declare const global: {
+  chrome: object;
+};
+
+const fetchMocker = createFetchMock(vi);
+
+beforeEach(() => {
+  fetchMocker.enableMocks();
+  global.chrome = {
+    runtime: {
+      sendMessage: vi.fn(),
+      connect: vi.fn().mockImplementation(() => {
+        return {
+          onMessage: {
+            addListener: vi.fn(),
+          },
+          postMessage: vi.fn(),
+        };
+      }),
+    },
+  };
+});
+
+afterEach(() => {
+  fetchMocker.disableMocks();
+});
+
+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", () => {
+  let hashStr: string;
+  let zkProvingSpy: MockInstance<(status: ZkProvingStatus) => void>;
+  let vlayer: VlayerClient;
+
+  beforeEach(() => {
+    hashStr = generateRandomHash();
+    const webProofProvider = createExtensionWebProofProvider();
+    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: hashStr,
+        }),
+      };
+    });
+
+    const result = await vlayer.prove({
+      address: `0x${"a".repeat(40)}`,
+      functionName: "main",
+      proverAbi: [],
+      args: [],
+      chainId: 42,
+    });
+
+    expect(result.hash).toBe(hashStr);
+    expect(zkProvingSpy).toBeCalledTimes(1);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+  });
+  it("should send message to extension that zkproving is done", async () => {
+    fetchMocker.mockResponseOnce(() => {
+      return {
+        body: JSON.stringify({
+          result: hashStr,
+        }),
+      };
+    });
+
+    await vlayer.prove({
+      address: `0x${"a".repeat(40)}`,
+      functionName: "main",
+      proverAbi: [],
+      args: [],
+      chainId: 42,
+    });
+
+    fetchMocker.mockResponseOnce(() => {
+      return {
+        body: JSON.stringify({
+          result: {
+            state: "done",
+            status: 1,
+            metrics: {},
+            data: {},
+          },
+          jsonrpc: "2.0",
+          id: 1,
+        }),
+      };
+    });
+
+    const hash = { hash: hashStr } as BrandedHash<[], string>;
+    await vlayer.waitForProvingResult({ hash });
+
+    expect(zkProvingSpy).toBeCalledTimes(2);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Done);
+  });
+  it("should notify that zk-proving failed", async () => {
+    fetchMocker.mockResponseOnce(() => {
+      throw new Error("test");
+    });
+
+    const hash = { hash: hashStr } as BrandedHash<[], string>;
+    try {
+      await vlayer.waitForProvingResult({ hash });
+    } catch (e) {
+      console.log("Error waiting for proving result", e);
+    }
+
+    expect(zkProvingSpy).toBeCalledTimes(1);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Error);
+  });
+  it("should pass token if present", async () => {
+    const userToken = "deadbeef";
+
+    fetchMocker.mockResponseOnce((req) => {
+      const token = (req.headers.get("authorization") || "")
+        .split("Bearer ")
+        .at(1);
+      if (token !== undefined && token === userToken) {
+        return {
+          body: JSON.stringify({
+            result: hashStr,
+          }),
+        };
+      }
+      return {
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          error: {
+            code: -32603,
+            message:
+              "Gas meter error: RPC error: HTTP error: HTTP status client error (401 Unauthorized) for url (http://localhost:3000)",
+          },
+        }),
+      };
+    });
+
+    const result = await vlayer.prove({
+      address: `0x${"a".repeat(40)}`,
+      functionName: "main",
+      proverAbi: [],
+      args: [],
+      chainId: 42,
+      token: userToken,
+    });
+    expect(result.hash).toBe(hashStr);
+    expect(zkProvingSpy).toBeCalledTimes(1);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+  });
+});
+
+describe("Failed zk-proving", () => {
+  let zkProvingSpy: MockInstance<(status: ZkProvingStatus) => void>;
+  let vlayer: VlayerClient;
+  let hashStr: string;
+
+  beforeEach(() => {
+    hashStr = generateRandomHash();
+    const webProofProvider = createExtensionWebProofProvider();
+    zkProvingSpy = vi.spyOn(webProofProvider, "notifyZkProvingStatus");
+    vlayer = createVlayerClient({ webProofProvider });
+  });
+  it("should send message to extension that zkproving started and then that failed when server error 500", async () => {
+    fetchMocker.mockResponseOnce((req) => {
+      if (req.url === "http://127.0.0.1:3000/") {
+        return {
+          status: 500,
+        };
+      }
+      return {};
+    });
+
+    try {
+      const hash = await vlayer.prove({
+        address: `0x${"a".repeat(40)}`,
+        functionName: "main",
+        proverAbi: [],
+        args: [],
+        chainId: 42,
+      });
+      await vlayer.waitForProvingResult({ hash });
+    } catch (e) {
+      console.log("Error waiting for proving result", e);
+    }
+
+    expect(zkProvingSpy).toBeCalledTimes(2);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Error);
+  });
+  it("should send message to extension that zkproving started and then that failed when computation failed at any stage", async () => {
+    fetchMocker.mockResponseOnce(() => {
+      return {
+        body: JSON.stringify({
+          result: hashStr,
+        }),
+      };
+    });
+
+    const hash = await vlayer.prove({
+      address: `0x${"a".repeat(40)}`,
+      functionName: "main",
+      proverAbi: [],
+      args: [],
+      chainId: 42,
+    });
+
+    fetchMocker.mockResponseOnce(() => {
+      return {
+        body: JSON.stringify({
+          result: {
+            state: "preflight",
+            status: 0,
+            metrics: {},
+            error: "Preflight error: ...",
+          },
+          jsonrpc: "2.0",
+          id: 1,
+        }),
+      };
+    });
+
+    try {
+      await vlayer.waitForProvingResult({ hash });
+    } catch (e) {
+      expect((e as Error).message).toMatch(
+        "Preflight failed with error: Preflight error: ...",
+      );
+    }
+
+    expect(zkProvingSpy).toBeCalledTimes(2);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(1, ZkProvingStatus.Proving);
+    expect(zkProvingSpy).toHaveBeenNthCalledWith(2, ZkProvingStatus.Error);
+  });
+});