@vlayer/sdk 0.0.1

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.2/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @vlayer/sdk
+
+## 0.0.2
+
+### Patch Changes
+
+- added changesets

package/README.md

@@ -0,0 +1,7 @@
+# @vlayer/sdk
+
+## Install / usage
+Check our docs at our [Vanilla JS/TS docs](https://book.vlayer.xyz/javascript/javascript.html)
+
+## Bumping version 
+Learn more at our [JS contribution docs](https://book.vlayer.xyz/contributing/javascript.htm)

package/eslint.config.ts

@@ -0,0 +1,22 @@
+import js from "@eslint/js";
+import ts from "typescript-eslint";
+import prettierRecommended from "eslint-plugin-prettier/recommended";
+import globals from "globals";
+
+export default [
+  js.configs.recommended,
+  ...ts.configs.recommended,
+  prettierRecommended,
+  {
+    rules: {
+      "no-unused-vars": "warn",
+      "no-undef": "warn",
+    },
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        Bun: false,
+      },
+    },
+  },
+];

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@vlayer/sdk",
+  "type": "module",
+  "module": "src/index.ts",
+  "version": "0.0.1",
+  "scripts": {
+    "build": "npm run gen:types",
+    "test": "vitest --run",
+    "gen:types": "sh ../bash/build_ts_types.sh"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.7",
+    "@types/bun": "latest",
+    "@types/mailparser": "^3.4.4",
+    "abitype": "^1.0.6",
+    "vitest": "^2.1.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "mailparser": "^3.7.1",
+    "viem": "^2.21.0"
+  }
+}

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

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "vitest";
+import { resolveDkimDns } from "./dnsResolver.ts";
+
+describe("resolveDkimDns Integration", () => {
+  test("resolves VLayer DNS", async () => {
+    const resolved = await resolveDkimDns(
+      "vlayer-xyz.20230601.gappssmtp.com",
+      "20230601",
+    );
+    const expected =
+      "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3gWcOhCm99qzN+h7/2+LeP3CLsJkQQ4EP/2mrceXle5pKq8uZmBl1U4d2Vxn4w+pWFANDLmcHolLboESLFqEL5N6ae7u9b236dW4zn9AFkXAGenTzQEeif9VUFtLAZ0Qh2eV7OQgz/vPj5IaNqJ7h9hpM9gO031fe4v+J0DLCE8Rgo7hXbNgJavctc0983DaCDQaznHZ44LZ6TtZv9TBs+QFvsy4+UCTfsuOtHzoEqOOuXsVXZKLP6B882XbEnBpXEF8QzV4J26HiAJFUbO3mAqZL2UeKC0hhzoIZqZXNG0BfuzOF0VLpDa18GYMUiu+LhEJPJO9D8zhzvQIHNrpGwIDAQAB";
+    expect(resolved).toBe(expected);
+  });
+
+  test("throws error if dns not found", async () => {
+    await expect(resolveDkimDns("not-a-domain.com", "abcd")).rejects.toThrow();
+  });
+});

package/src/api/email/dnsResolver.ts

@@ -0,0 +1,14 @@
+import dns from "node:dns";
+
+export async function resolveDkimDns(domain: string, selector: string) {
+  return new Promise<string>((resolve, reject) => {
+    dns.resolveTxt(`${selector}._domainkey.${domain}`, (err, addresses) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+
+      resolve(addresses.flat()[0]);
+    });
+  });
+}

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

@@ -0,0 +1,105 @@
+import assert from "node:assert";
+import { describe, expect, test } from "vitest";
+import { getDkimSigners, parseEmail } from "./parseEmail.ts";
+import { StructuredHeader } from "mailparser";
+
+const emailHeaders = `From: "John Doe" <john@d.oe>
+To: "Jane Doe" <jane@d.oe>
+Subject: Hello World
+Date: Thu, 1 Jan 1970 00:00:00 +0000
+`;
+
+const dkimHeader =
+  "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; h=from:to:subject; s=selector1; b=abcdef;";
+
+const body = "Hello, World!";
+
+const emailFixture = `${emailHeaders}${dkimHeader}\n\n${body}`;
+
+describe("parseEmail", () => {
+  test("should get dkim header from email", async () => {
+    const email = await parseEmail(emailFixture);
+    const dkim = email.headers.get("dkim-signature")!;
+    assert(typeof dkim === "object" && "params" in dkim);
+    expect(dkim.params.d).toBe("example.com");
+    expect(dkim.params.s).toBe("selector1");
+  });
+
+  test("correctly parses untrimmed email", async () => {
+    const untrimmed = `\n   ${emailFixture}    \n`;
+    const email = await parseEmail(untrimmed);
+    expect(email.headers.get("dkim-signature")).toBeDefined();
+  });
+
+  test("works well with multiple dkim headers", async () => {
+    const dkimHeader2 =
+      "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=second.signer; h=from:to:subject; s=selector2; b=abcdef;";
+
+    const email = await parseEmail(
+      `${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`,
+    );
+    const dkim = email.headers.get(
+      "dkim-signature",
+    )! as unknown as StructuredHeader[];
+    expect(dkim).toHaveLength(2);
+    expect(dkim[0].params.s).toBe("selector1");
+    expect(dkim[1].params.s).toBe("selector2");
+  });
+});
+
+describe("getDkimSigners", () => {
+  test("should get dkim signers from email", async () => {
+    const email = await parseEmail(emailFixture);
+    const dkim = getDkimSigners(email);
+    expect(dkim).toHaveLength(1);
+    expect(dkim[0].domain).toBe("example.com");
+    expect(dkim[0].selector).toBe("selector1");
+  });
+
+  test("should get multiple dkim signers from email", async () => {
+    const dkimHeader2 =
+      "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=second.signer; h=from:to:subject; s=selector2; b=abcdef;";
+    const email = await parseEmail(
+      `${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`,
+    );
+
+    const dkim = getDkimSigners(email);
+    expect(dkim).toHaveLength(2);
+    expect(dkim[0].domain).toBe("example.com");
+    expect(dkim[0].selector).toBe("selector1");
+    expect(dkim[1].domain).toBe("second.signer");
+    expect(dkim[1].selector).toBe("selector2");
+  });
+
+  test("should throw if no dkim header found", async () => {
+    const email = await parseEmail(emailHeaders);
+    expect(() => getDkimSigners(email)).toThrowError("No DKIM header found");
+  });
+
+  test("should throw if dkim header is invalid", async () => {
+    const email = await parseEmail(
+      `${emailHeaders}DKIM-Signature: invalid\n\n${body}`,
+    );
+    expect(() => getDkimSigners(email)).toThrowError(
+      "DKIM header missing domain",
+    );
+  });
+
+  test("should throw if dkim header is missing domain", async () => {
+    const email = await parseEmail(
+      `${emailHeaders}DKIM-Signature: v=1; s=selector\n\n${body}`,
+    );
+    expect(() => getDkimSigners(email)).toThrowError(
+      "DKIM header missing domain",
+    );
+  });
+
+  test("should throw if dkim header is missing selector", async () => {
+    const email = await parseEmail(
+      `${emailHeaders}DKIM-Signature: v=1; d=example.com\n\n${body}`,
+    );
+    expect(() => getDkimSigners(email)).toThrowError(
+      "DKIM header missing selector",
+    );
+  });
+});

package/src/api/email/parseEmail.ts

@@ -0,0 +1,45 @@
+import { simpleParser, HeaderValue, type ParsedMail } from "mailparser";
+
+export class DkimParsingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DkimParsingError";
+  }
+}
+
+export async function parseEmail(mime: string) {
+  return simpleParser(mime.trim(), {
+    skipHtmlToText: true,
+    skipTextToHtml: true,
+    skipTextLinks: true,
+    skipImageLinks: true,
+  });
+}
+
+export function getDkimSigners(mail: ParsedMail) {
+  const dkimHeader = mail.headers.get("dkim-signature");
+  if (!dkimHeader) throw new DkimParsingError("No DKIM header found");
+  if (Array.isArray(dkimHeader)) {
+    return dkimHeader.map(parseHeader);
+  }
+  return [parseHeader(dkimHeader)];
+}
+
+function parseHeader(header: HeaderValue) {
+  if (typeof header === "string" || !("params" in header)) {
+    throw new DkimParsingError(`Invalid DKIM header ${header}`);
+  }
+
+  if (!header.params.d) {
+    throw new DkimParsingError("DKIM header missing domain");
+  }
+
+  if (!header.params.s) {
+    throw new DkimParsingError("DKIM header missing selector");
+  }
+
+  return {
+    domain: header.params.d,
+    selector: header.params.s,
+  };
+}

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

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "vitest";
+import { preverifyEmail } from "./preverify.ts";
+import { readFile } from "testHelpers/readFile";
+
+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,
+      dnsRecords: [expect.stringContaining("v=DKIM1; k=rsa; p=")],
+    });
+  });
+
+  test("throws error if DKIM not found", async () => {
+    const emailWithNoDkimHeader = 'From: "Alice"\n\nBody';
+    await expect(preverifyEmail(emailWithNoDkimHeader)).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)).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",
+    );
+  });
+});

package/src/api/email/preverify.ts

@@ -0,0 +1,19 @@
+import { parseEmail, getDkimSigners } from "./parseEmail.ts";
+import { resolveDkimDns } from "./dnsResolver.ts";
+
+export async function preverifyEmail(mimeEmail: string) {
+  const parsedEmail = await parseEmail(mimeEmail);
+  const signers = getDkimSigners(parsedEmail);
+  if (signers.length === 0) {
+    throw new Error("No DKIM header found");
+  }
+  if (signers.length > 1) {
+    throw new Error("Multiple DKIM headers found");
+  }
+  const [{ domain, selector }] = signers;
+  const dnsRecord = await resolveDkimDns(domain, selector);
+  return {
+    email: mimeEmail,
+    dnsRecords: [dnsRecord],
+  };
+}

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@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_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_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/helpers.ts

@@ -0,0 +1,169 @@
+import {
+  type Abi,
+  type Address,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+  createTestClient,
+  type Hex,
+  http,
+  HttpTransport,
+  publicActions,
+  PublicClient,
+  walletActions,
+} from "viem";
+
+import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
+import { foundry } from "viem/chains";
+
+import type { ContractSpec, ContractArg } from "types/ethereum";
+
+export const testChainId1 = 100001;
+export const testChainId2 = 100002;
+
+const rpcUrls: Map<number, HttpTransport> = new Map([
+  [testChainId1, http()],
+  [testChainId2, http("http://127.0.0.1:8546")],
+]);
+
+export const chainIds = [testChainId1, testChainId2];
+
+export function client(
+  chainId: number = testChainId1,
+): ReturnType<typeof walletActions> & PublicClient {
+  const transport = rpcUrls.get(chainId);
+  if (transport == undefined) {
+    throw Error(`No url for chainId ${chainId}`);
+  }
+
+  return createTestClient({
+    chain: foundry,
+    mode: "anvil",
+    transport: transport,
+  })
+    .extend(publicActions)
+    .extend(walletActions);
+}
+
+export async function deployContract(
+  contractSpec: ContractSpec,
+  args: ContractArg[] = [],
+  chainId: number = testChainId1,
+): Promise<Address> {
+  const ethClient = client(chainId);
+
+  const [deployer] = await ethClient.getAddresses();
+
+  const txHash = await ethClient.deployContract({
+    abi: contractSpec.abi,
+    bytecode: contractSpec.bytecode.object,
+    account: deployer,
+    args,
+    chain: foundry,
+  });
+
+  const receipt = await ethClient.waitForTransactionReceipt({ hash: txHash });
+
+  if (receipt.status != "success") {
+    throw new Error(
+      `Contract deployment failed with status: ${receipt.status}`,
+    );
+  }
+
+  return receipt.contractAddress as Address;
+}
+
+type DeploySpec<T extends Abi> = {
+  abi: T;
+  bytecode: {
+    object: Hex;
+  };
+};
+
+type Tail<T> = T extends readonly [unknown, ...infer U] ? U : [];
+
+export async function deployProverVerifier<P extends Abi, V extends Abi>(
+  proverSpec: DeploySpec<P>,
+  verifierSpec: DeploySpec<V>,
+  args: {
+    prover?: ContractArg[];
+    verifier?: Tail<ContractArg>[];
+  } = {},
+  chainId: number = testChainId1,
+) {
+  console.log("Deploying prover");
+  const proverAddress = await deployContract(
+    proverSpec,
+    args.prover ?? [],
+    chainId,
+  );
+  console.log(`Prover has been deployed on ${proverAddress} address`);
+
+  console.log("Deploying verifier");
+  const verifierAddress = await deployContract(
+    verifierSpec,
+    [proverAddress, ...(args.verifier ?? [])],
+    chainId,
+  );
+  console.log(`Verifier has been deployed on ${verifierAddress} address`);
+
+  return [proverAddress, verifierAddress];
+}
+
+export async function call<
+  T extends Abi,
+  F extends ContractFunctionName<T, "pure" | "view">,
+>(
+  abi: T,
+  address: Address,
+  functionName: F,
+  args?: ContractFunctionArgs<T, "pure" | "view", F>,
+  chainId: number = testChainId1,
+) {
+  const ethClient = client(chainId);
+
+  return ethClient.readContract({
+    abi,
+    address,
+    functionName,
+    args,
+  });
+}
+
+export async function writeContract<
+  T extends Abi,
+  F extends ContractFunctionName<T, "payable" | "nonpayable">,
+>(
+  address: Address,
+  abi: T,
+  functionName: F,
+  args: ContractFunctionArgs<T, "payable" | "nonpayable", F>,
+  sender?: Address,
+  chainId: number = testChainId1,
+) {
+  const ethClient = client(chainId);
+  const selectedSender = sender || (await ethClient.getAddresses())[0];
+
+  const txHash = await ethClient.writeContract({
+    abi,
+    address,
+    functionName,
+    args,
+    account: selectedSender,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any);
+  // TODO: fix any to viem type
+
+  const txReceipt = await ethClient.waitForTransactionReceipt({ hash: txHash });
+
+  if (txReceipt.status != "success") {
+    throw new Error(`Transaction failed with status: ${txReceipt.status}`);
+  }
+
+  return txReceipt;
+}
+
+export const getTestAccount = () => privateKeyToAccount(generatePrivateKey());
+
+export const getTestAddresses = (
+  chainId: number = testChainId1,
+): Promise<Address[]> => client(chainId).getAddresses();

package/src/api/lib/client.ts

@@ -0,0 +1,18 @@
+import { VlayerClient } from "types/vlayer";
+import { WebProofProvider } from "types/webProof";
+
+export const createVlayerClient = ({
+  url,
+  webProofProvider,
+}: {
+  url: string;
+  webProofProvider: WebProofProvider;
+}): VlayerClient => {
+  return {
+    prove: async () => {
+      console.log("prove");
+      console.log("url", url);
+      console.log("webProofProvider", webProofProvider);
+    },
+  };
+};

package/src/api/lib/types/ethereum.ts

@@ -0,0 +1,43 @@
+import { Abi, Address, Hex } from "viem";
+import { Branded } from "./utils";
+export type Bytecode = {
+  object: Hex;
+};
+
+export type ContractSpec = {
+  abi: Abi;
+  bytecode: Bytecode;
+};
+
+export type ContractArg =
+  | number
+  | string
+  | boolean
+  | bigint
+  | Address
+  | number[]
+  | string[]
+  | boolean[]
+  | bigint[]
+  | Address[];
+
+export type EthereumAddress = Branded<Hex, "EthereumAddress">;
+export type EthereumTxHash = Branded<Hex, "EthereumTxHash">;
+
+export function assertEthereumAddress(
+  hash: string,
+): asserts hash is EthereumAddress {
+  const regex = /^(0x)?[0-9a-fA-F]{40}$/;
+  if (!regex.test(hash)) {
+    throw new Error(`Invalid ethereum account ${hash}`);
+  }
+}
+
+export function assertEthereumTxHash(
+  hash: string,
+): asserts hash is EthereumTxHash {
+  const regex = /^(0x)?[0-9a-fA-F]{64}$/;
+  if (!regex.test(hash)) {
+    throw new Error(`Invalid ethereum tx hash ${hash}`);
+  }
+}

package/src/api/lib/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./ethereum";
+export * from "./webProof";

package/src/api/lib/types/utils.ts

@@ -0,0 +1,3 @@
+declare const __brand: unique symbol;
+type Brand<B> = { [__brand]: B };
+export type Branded<T, B> = T & Brand<B>;

package/src/api/lib/types/vlayer.ts

@@ -0,0 +1,55 @@
+import { Address, Hex } from "viem";
+
+type Calldata = string;
+
+export type CallParams = {
+  to: Address;
+  data: Calldata;
+};
+
+export type CallContext = {
+  chain_id: number; // 31337
+};
+
+export interface Proof {
+  length: bigint;
+  seal: {
+    verifierSelector: Hex;
+    seal: [Hex, Hex, Hex, Hex, Hex, Hex, Hex, Hex];
+    mode: number;
+  };
+  dynamicParamsOffsets: [
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+  ];
+  commitment: {
+    proverContractAddress: Address;
+    functionSelector: Hex;
+    settleBlockHash: Hex;
+    settleBlockNumber: bigint;
+  };
+}
+
+export interface VCallResult {
+  evm_call_result: Hex;
+  proof: Proof;
+}
+
+export interface VCallResponse {
+  jsonrpc: string;
+  result: VCallResult;
+  id: number;
+}
+
+// Add more methods here
+export type VlayerClient = {
+  prove: () => void;
+};

package/src/api/lib/types/webProof.ts

@@ -0,0 +1,106 @@
+//NOTE : this is copied from tlsn-js 5.4
+// for some reason newest vertsions doesnt not export this type (clarification is in progress)
+// probaly it should be reexported from tlsn-js
+
+export interface WebProof {
+  session: Session;
+  substrings: Substrings;
+  notaryUrl: string;
+}
+
+export interface Session {
+  header: Header;
+  signature: Signature;
+  session_info: SessionInfo;
+}
+
+export interface SessionInfo {
+  server_name: ServerName;
+  handshake_decommitment: HandshakeDecommitment;
+}
+
+export interface HandshakeDecommitment {
+  nonce: number[];
+  data: Data;
+}
+
+export interface Data {
+  server_cert_details: ServerCERTDetails;
+  server_kx_details: ServerKxDetails;
+  client_random: number[];
+  server_random: number[];
+}
+
+export interface ServerCERTDetails {
+  cert_chain: Array<number[]>;
+  ocsp_response: number[];
+  scts: null;
+}
+
+export interface ServerKxDetails {
+  kx_params: number[];
+  kx_sig: KxSig;
+}
+
+export interface KxSig {
+  scheme: string;
+  sig: number[];
+}
+
+export interface Header {
+  encoder_seed: number[];
+  merkle_root: number[];
+  sent_len: number;
+  recv_len: number;
+  handshake_summary: HandshakeSummary;
+}
+
+export interface HandshakeSummary {
+  time: number;
+  server_public_key: ServerPublicKey;
+  handshake_commitment: number[];
+}
+
+export interface ServerPublicKey {
+  group: string;
+  key: number[];
+}
+
+export interface ServerName {
+  Dns: string;
+}
+
+export interface Signature {
+  P256: string;
+}
+
+export interface Substrings {
+  openings: { [key: string]: Opening[] };
+  inclusion_proof: InclusionProof;
+}
+
+export interface InclusionProof {
+  proof: unknown[];
+  total_leaves: number;
+}
+
+export interface Opening {
+  kind?: string;
+  ranges?: Range[];
+  direction?: string;
+  Blake3?: Blake3;
+}
+
+export interface Blake3 {
+  data: number[];
+  nonce: number[];
+}
+
+export interface Range {
+  start: number;
+  end: number;
+}
+
+export type WebProofProvider = {
+  requestProof: (url: string) => Promise<WebProof>;
+};

package/src/api/prover.ts

@@ -0,0 +1,73 @@
+import {
+  type Abi,
+  AbiFunction,
+  AbiStateMutability,
+  type Address,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  decodeFunctionResult,
+  encodeFunctionData,
+} from "viem";
+
+import { type CallContext, type CallParams, Proof } from "types/vlayer";
+import { v_call } from "./v_call";
+import { testChainId1 } from "./helpers";
+import { ContractSpec } from "types/ethereum";
+
+export async function getContractSpec(file: string): Promise<ContractSpec> {
+  return Bun.file(file).json();
+}
+
+export async function prove<
+  T extends readonly [AbiFunction, ...Abi[number][]],
+  F extends ContractFunctionName<T>,
+>(
+  prover: Address,
+  abi: T,
+  functionName: F,
+  args: ContractFunctionArgs<T, AbiStateMutability, F>,
+  chainId = testChainId1,
+) {
+  const calldata = encodeFunctionData({
+    abi: abi as Abi,
+    functionName: functionName as string,
+    args: args as readonly unknown[],
+  });
+
+  const call: CallParams = { to: prover, data: calldata };
+  const context: CallContext = {
+    chain_id: chainId,
+  };
+
+  const {
+    result: { proof, evm_call_result },
+  } = await v_call(call, context);
+
+  const returnValue = decodeFunctionResult({
+    abi: abi as Abi,
+    data: evm_call_result,
+    functionName: functionName as string,
+  });
+
+  addDynamicParamsOffsets(abi, functionName, proof);
+
+  return { proof, returnValue: returnValue as `0x${string}`[] };
+}
+
+function addDynamicParamsOffsets(
+  abi: Abi,
+  functionName: string | undefined,
+  proof: Proof,
+) {
+  const proverFunction = abi.find(
+    (f) => f.type === "function" && f.name === functionName,
+  ) as AbiFunction;
+
+  if (proverFunction?.outputs && proverFunction.outputs.length > 0) {
+    const secondVerifyMethodParamType = proverFunction.outputs[0].type;
+
+    if (secondVerifyMethodParamType === "string") {
+      proof.dynamicParamsOffsets[0] = BigInt(32);
+    }
+  }
+}

package/src/api/v_call.ts

@@ -0,0 +1,44 @@
+import { CallContext, CallParams, VCallResponse } from "types/vlayer";
+
+function v_callBody(call: CallParams, context: CallContext) {
+  return {
+    method: "v_call",
+    params: [call, context],
+    id: 1,
+    jsonrpc: "2.0",
+  };
+}
+
+export async function v_call(
+  call: CallParams,
+  context: CallContext,
+): Promise<VCallResponse> {
+  const response = await fetch("http://127.0.0.1:3000", {
+    method: "POST",
+    body: JSON.stringify(v_callBody(call, context)),
+    headers: { "Content-Type": "application/json" },
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+
+  const response_json = await response.json();
+
+  //TODO we should launch some schema validation here
+  assertObject(response_json);
+
+  if ("error" in response_json) {
+    throw new Error(
+      `Error response: ${(response_json.error as { message: string }).message || "unknown error"}`,
+    );
+  }
+
+  return response_json as Promise<VCallResponse>;
+}
+
+function assertObject(x: unknown): asserts x is object {
+  if (typeof x !== "object") {
+    throw new Error("Expected object");
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { v_call } from "./api/v_call";
+export type { CallParams, CallContext } from "types/vlayer";
+export type { ContractSpec } from "types/ethereum";
+
+export { getContractSpec, prove } from "./api/prover";
+export * as testHelpers from "./api/helpers";
+export { client as createTestClient } from "./api/helpers";
+export { preverifyEmail } from "./api/email/preverify.ts";

package/src/testHelpers/readFile.ts

@@ -0,0 +1,3 @@
+import fs from "fs";
+
+export const readFile = (path: string) => fs.readFileSync(path).toString();

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "noEmit": true,
+    "composite": true,
+    "types": [
+      "bun" // add Bun global
+    ],
+    "baseUrl": "./",
+    "paths": {
+      "types/*": ["./src/api/lib/types/*"],
+      "testHelpers/*": ["./src/testHelpers/*"],
+    },
+
+  }
+}