@vlayer/sdk 0.1.0-nightly-20241001-aa0406f → 0.1.0-nightly-20241002-4630acc

package/package.json

@@ -2,7 +2,8 @@
   "name": "@vlayer/sdk",
   "type": "module",
   "module": "src/index.ts",
-  "version": "0.1.0-nightly-20241001-aa0406f",
+  "version": "0.1.0-nightly-20241002-4630acc",
+  "types": "src/index.ts",
   "scripts": {
     "build": "npm run gen:types",
     "test": "vitest --run",
@@ -11,7 +12,6 @@
   "devDependencies": {
     "@changesets/cli": "^2.27.7",
     "@types/bun": "latest",
-    "@types/mailparser": "^3.4.4",
     "abitype": "^1.0.6",
     "vitest": "^2.1.1"
   },
@@ -19,7 +19,9 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "mailparser": "^3.7.1",
-    "viem": "^2.21.0"
+    "dns-over-http-resolver": "^3.0.3",
+    "postal-mime": "^2.3.2",
+    "viem": "^2.21.0",
+    "zod": "^3.23.8"
   }
 }

package/src/api/email/dnsResolver.ts

@@ -1,14 +1,7 @@
-import dns from "node:dns";
+import DnsResolver from "dns-over-http-resolver";
 
 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]);
-    });
-  });
+  const resolver = new DnsResolver();
+  const address = await resolver.resolveTxt(`${selector}._domainkey.${domain}`);
+  return address.flat()[0];
 }

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

@@ -1,7 +1,5 @@
-import assert from "node:assert";
 import { describe, expect, test } from "vitest";
-import { getDkimSigners, parseEmail } from "./parseEmail.ts";
-import { StructuredHeader } from "mailparser";
+import { getDkimSigners, parseEmail, parseParams } from "./parseEmail.ts";
 
 const emailHeaders = `From: "John Doe" <john@d.oe>
 To: "Jane Doe" <jane@d.oe>
@@ -17,18 +15,12 @@ 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("should get dkim header from email", async () => {});
 
   test("correctly parses untrimmed email", async () => {
     const untrimmed = `\n   ${emailFixture}    \n`;
     const email = await parseEmail(untrimmed);
-    expect(email.headers.get("dkim-signature")).toBeDefined();
+    expect(email.headers.find((h) => h.key === "dkim-signature")).toBeDefined();
   });
 
   test("works well with multiple dkim headers", async () => {
@@ -38,12 +30,11 @@ describe("parseEmail", () => {
     const email = await parseEmail(
       `${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`,
     );
-    const dkim = email.headers.get(
-      "dkim-signature",
-    )! as unknown as StructuredHeader[];
+    const dkim = email.headers.filter((h) => h.key === "dkim-signature")!;
+
     expect(dkim).toHaveLength(2);
-    expect(dkim[0].params.s).toBe("selector1");
-    expect(dkim[1].params.s).toBe("selector2");
+    expect(parseParams(dkim[0].value).s).toBe("selector1");
+    expect(parseParams(dkim[1].value).s).toBe("selector2");
   });
 });
 
@@ -103,3 +94,40 @@ describe("getDkimSigners", () => {
     );
   });
 });
+
+describe("parseParams", () => {
+  test("should parse single parameter", () => {
+    const params = parseParams("a=b");
+    expect(params).toEqual({ a: "b" });
+  });
+
+  test("should parse multiple parameters", () => {
+    const params = parseParams("a=b; c=d; e=f");
+    expect(params).toEqual({ a: "b", c: "d", e: "f" });
+  });
+
+  test("should trim spaces around parameters", () => {
+    const params = parseParams(" a = b ; c = d ; e = f ");
+    expect(params).toEqual({ a: "b", c: "d", e: "f" });
+  });
+
+  test("should handle empty values", () => {
+    const params = parseParams("a=; b=c");
+    expect(params).toEqual({ a: "", b: "c" });
+  });
+
+  test("should handle missing values", () => {
+    const params = parseParams("a; b=c");
+    expect(params).toEqual({ a: undefined, b: "c" });
+  });
+
+  test("should handle empty string", () => {
+    const params = parseParams("");
+    expect(params).toEqual({});
+  });
+
+  test("should handle parameters with extra semicolons", () => {
+    const params = parseParams("a=b;; c=d;");
+    expect(params).toEqual({ a: "b", c: "d" });
+  });
+});

package/src/api/email/parseEmail.ts

@@ -1,4 +1,4 @@
-import { simpleParser, HeaderValue, type ParsedMail } from "mailparser";
+import PostalMime, { Email, Header } from "postal-mime";
 
 export class DkimParsingError extends Error {
   constructor(message: string) {
@@ -8,38 +8,42 @@ export class DkimParsingError extends Error {
 }
 
 export async function parseEmail(mime: string) {
-  return simpleParser(mime.trim(), {
-    skipHtmlToText: true,
-    skipTextToHtml: true,
-    skipTextLinks: true,
-    skipImageLinks: true,
-  });
+  return await PostalMime.parse(mime.trim());
 }
 
-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)];
+export function getDkimSigners(mail: Email) {
+  const dkimHeader = mail.headers.filter((h) => h.key === "dkim-signature");
+  if (dkimHeader.length === 0)
+    throw new DkimParsingError("No DKIM header found");
+  return dkimHeader.map(parseHeader);
+}
+
+export function parseParams(str: string) {
+  return Object.fromEntries(
+    str.split(";").map((s) =>
+      s
+        .trim()
+        .split("=")
+        .map((v) => v && v.trim()),
+    ),
+  );
 }
 
-function parseHeader(header: HeaderValue) {
-  if (typeof header === "string" || !("params" in header)) {
+function parseHeader(header: Header) {
+  const params = parseParams(header.value);
+  if (!params) {
     throw new DkimParsingError(`Invalid DKIM header ${header}`);
   }
 
-  if (!header.params.d) {
+  if (!params.d) {
     throw new DkimParsingError("DKIM header missing domain");
   }
 
-  if (!header.params.s) {
+  if (!params.s) {
     throw new DkimParsingError("DKIM header missing selector");
   }
-
   return {
-    domain: header.params.d,
-    selector: header.params.s,
+    domain: params.d,
+    selector: params.s,
   };
 }

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
 import { preverifyEmail } from "./preverify.ts";
-import { readFile } from "testHelpers/readFile";
+import { readFile } from "../../testHelpers/readFile";
 
 describe("Preverify email: integration", () => {
   test("adds dns record to email mime", async () => {

package/src/api/helpers.ts

@@ -18,14 +18,10 @@ 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")],
-]);
+const rpcUrls: Map<number, HttpTransport> = new Map([[testChainId1, http()]]);
 
-export const chainIds = [testChainId1, testChainId2];
+export const chainIds = [testChainId1];
 
 export function client(
   chainId: number = testChainId1,

package/src/api/lib/client.ts

@@ -1,6 +1,7 @@
 import { VlayerClient } from "types/vlayer";
-import { WebProofProvider } from "types/webProof";
+import { WebProofProvider } from "types/webProofProvider";
 
+import { prove } from "../prover";
 export const createVlayerClient = ({
   url,
   webProofProvider,
@@ -8,11 +9,11 @@ export const createVlayerClient = ({
   url: string;
   webProofProvider: WebProofProvider;
 }): VlayerClient => {
+  // TODO : implement high level api
+  console.log("createVlayerClient with", url, webProofProvider);
   return {
-    prove: async () => {
-      console.log("prove");
-      console.log("url", url);
-      console.log("webProofProvider", webProofProvider);
+    prove: async ({ address, functionName, chainId, proverAbi, args }) => {
+      return prove(address, proverAbi, functionName, args, chainId);
     },
   };
 };

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

@@ -1,2 +1,5 @@
 export * from "./ethereum";
 export * from "./webProof";
+export * from "./utils";
+export * from "./vlayer";
+export * from "./webProofProvider";

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

@@ -0,0 +1,28 @@
+import { Abi, ContractFunctionName } from "viem";
+import { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
+
+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[];

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

@@ -1,4 +1,14 @@
-import { Address, Hex } from "viem";
+import {
+  Abi,
+  AbiFunction,
+  AbiStateMutability,
+  Address,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  Hex,
+} from "viem";
+
+import { type ProverCallCommitment } from "types/webProofProvider.ts";
 
 type Calldata = string;
 
@@ -30,7 +40,7 @@ export interface Proof {
     bigint,
     bigint,
   ];
-  commitment: {
+  assumptions: {
     proverContractAddress: Address;
     functionSelector: Hex;
     settleBlockHash: Hex;
@@ -51,5 +61,17 @@ export interface VCallResponse {
 
 // Add more methods here
 export type VlayerClient = {
-  prove: () => void;
+  prove: <
+    T extends readonly [AbiFunction, ...Abi[number][]],
+    F extends ContractFunctionName<T>,
+  >(
+    args: VlayerClientProveArgs<T, F>,
+  ) => void;
+};
+
+export type VlayerClientProveArgs<
+  T extends readonly [AbiFunction, ...Abi[number][]],
+  F extends ContractFunctionName<T>,
+> = ProverCallCommitment<T, F> & {
+  args: ContractFunctionArgs<T, AbiStateMutability, F>;
 };

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

@@ -1,6 +1,6 @@
-//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
+// NOTE : this is copied from tlsn-js 5.4
+// for some reason newest versions doesn't export this type (clarification is in progress)
+// probably it should be reexported from tlsn-js
 
 export interface WebProof {
   session: Session;
@@ -100,7 +100,12 @@ export interface Range {
   start: number;
   end: number;
 }
-
-export type WebProofProvider = {
-  requestProof: (url: string) => Promise<WebProof>;
+export const assertWebProof = function (candidate: {
+  notaryUrl?: string;
+}): asserts candidate is WebProof {
+  //for now only thing we check is notary url
+  //TODO: implement later once we known the conteact with tlsn-js
+  if (!candidate.notaryUrl) {
+    throw new Error("Missing required parameter");
+  }
 };

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

@@ -0,0 +1,93 @@
+import { WebProof } from "types/webProof.ts";
+import { AbiFunction, Hex, Abi, ContractFunctionName } from "viem";
+import { Branded } from "types/utils.ts";
+import type { ContractFunctionArgsWithout } from "./viem";
+
+export const EXTENSION_STEP = {
+  expectUrl: "expectUrl",
+  startPage: "startPage",
+  notarize: "notarize",
+} as const;
+
+export const EXTENSION_ACTION = {
+  requestWebProof: "requestWebProof",
+} as const;
+
+export const EXTENSION_MESSAGE = {
+  proofDone: "proofDone",
+  proofError: "proofError",
+} as const;
+
+export type ExtensionStep =
+  (typeof EXTENSION_STEP)[keyof typeof EXTENSION_STEP];
+
+export type WebProofStepNotarize = Branded<
+  {
+    url: string;
+    method: string;
+    label: string;
+    step: typeof EXTENSION_STEP.notarize;
+  },
+  "notarize"
+>;
+
+export type WebProofStepExpectUrl = Branded<
+  {
+    url: string;
+    label: string;
+    step: typeof EXTENSION_STEP.expectUrl;
+  },
+  "expectUrl"
+>;
+
+export type WebProofStepStartPage = Branded<
+  {
+    url: string;
+    label: string;
+    step: typeof EXTENSION_STEP.startPage;
+  },
+  "startPage"
+>;
+
+export type WebProofSetupInput = {
+  logoUrl: string;
+  steps: [WebProofStepExpectUrl, WebProofStepStartPage, WebProofStepStartPage];
+};
+
+export type WebProofSetup = Branded<
+  WebProofSetupInput & {
+    isWebProof: true;
+  },
+  "webProof"
+>;
+
+export type ProverCallCommitment<
+  T extends readonly [AbiFunction, ...Abi[number][]],
+  F extends ContractFunctionName<T>,
+> = {
+  address: Hex;
+  proverAbi: T;
+  functionName: F;
+  commitmentArgs: ContractFunctionArgsWithout<T, F, { name: "webProof" }>;
+  chainId: number;
+};
+export type GetWebProofArgs<
+  T extends readonly [AbiFunction, ...Abi[number][]],
+  F extends ContractFunctionName<T>,
+> = {
+  proverCallCommitment: ProverCallCommitment<T, F>;
+} & WebProofSetupInput;
+
+export type WebProofProvider = {
+  getWebProof: <
+    T extends readonly [AbiFunction, ...Abi[number][]],
+    F extends ContractFunctionName<T>,
+  >(
+    args: GetWebProofArgs<T, F>,
+  ) => Promise<WebProof>;
+};
+
+export type WebProofProviderSetup = {
+  notaryUrl?: string;
+  wsProxyUrl?: string;
+};

package/src/api/prover.ts

@@ -9,7 +9,7 @@ import {
   encodeFunctionData,
 } from "viem";
 
-import { type CallContext, type CallParams, Proof } from "types/vlayer";
+import { type CallContext, type CallParams } from "types/vlayer";
 import { v_call } from "./v_call";
 import { testChainId1 } from "./helpers";
 import { ContractSpec } from "types/ethereum";
@@ -43,31 +43,12 @@ export async function prove<
     result: { proof, evm_call_result },
   } = await v_call(call, context);
 
-  const returnValue = decodeFunctionResult({
+  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;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }) as any[];
 
-    if (secondVerifyMethodParamType === "string") {
-      proof.dynamicParamsOffsets[0] = BigInt(32);
-    }
-  }
+  return { proof, returnValue };
 }

package/src/api/webProof/createWebProof.ts

@@ -0,0 +1,9 @@
+import { WebProofSetup, WebProofSetupInput } from "types/webProofProvider.ts";
+
+export const createWebProof = ({ logoUrl, steps }: WebProofSetupInput) => {
+  return {
+    logoUrl,
+    steps,
+    isWebProof: true,
+  } as WebProofSetup;
+};

package/src/api/webProof/index.ts

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

package/src/api/webProof/providers/extension.ts

@@ -0,0 +1,73 @@
+import {
+  EXTENSION_ACTION,
+  EXTENSION_MESSAGE,
+  type WebProofProvider,
+  type WebProofProviderSetup,
+  type WebProofSetupInput,
+} from "../../lib/types/webProofProvider";
+
+import { WebProof } from "../../lib/types/webProof";
+
+// NOTE @types/chrome and webextension-polyfill work only in the extension context
+// and looks that there is no community driven package providing typings for chrome.runtime
+// or polyfill logic for the browser APIs available in the browser context
+// we intentionally use chrome here instead of browser as we support only chrome for now
+// and there could be some differences in the API between browsers
+
+declare const chrome: {
+  runtime: {
+    sendMessage: (extensionId: string | undefined, message: unknown) => void;
+    connect: (extensionId: string) => {
+      onMessage: {
+        addListener: (message: unknown) => void;
+      };
+    };
+  };
+};
+
+export const createExtensionWebProofProvider = ({
+  notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.5/",
+  wsProxyUrl = "wss://notary.pse.dev/proxy",
+}: WebProofProviderSetup): WebProofProvider => {
+  return {
+    getWebProof: async function (webProofSetup: WebProofSetupInput) {
+      // TODO: we cant assume that developer is using vite
+      // EXTESION_ID value should be injected by the build system
+
+      return new Promise<WebProof>((resolve, reject) => {
+        chrome.runtime.sendMessage(import.meta.env.VITE_EXTENSION_ID, {
+          action: EXTENSION_ACTION.requestWebProof,
+          payload: {
+            notaryUrl,
+            wsProxyUrl,
+            logoUrl: webProofSetup.logoUrl,
+            steps: webProofSetup.steps,
+          },
+        });
+        const EXTENSION_ID = import.meta.env.VITE_EXTENSION_ID as string;
+        const port = chrome.runtime.connect(EXTENSION_ID);
+        //TODO : validate message in runtime
+        port.onMessage.addListener(
+          (
+            message:
+              | {
+                  type: typeof EXTENSION_MESSAGE.proofDone;
+                  proof: WebProof;
+                }
+              | {
+                  type: typeof EXTENSION_MESSAGE.proofError;
+                  error: { message: string };
+                },
+          ) => {
+            if (message.type === EXTENSION_MESSAGE.proofDone) {
+              resolve(message.proof);
+            }
+            if (message.type === EXTENSION_MESSAGE.proofError) {
+              reject(message.error);
+            }
+          },
+        );
+      });
+    },
+  };
+};

package/src/api/webProof/providers/index.ts

@@ -0,0 +1 @@
+export * from "./extension";

package/src/api/webProof/steps/expectUrl.ts

@@ -0,0 +1,12 @@
+import {
+  EXTENSION_STEP,
+  WebProofStepExpectUrl,
+} from "../../../api/lib/types/webProofProvider";
+
+export const expectUrl = (url: string, label: string) => {
+  return {
+    url,
+    label,
+    step: EXTENSION_STEP.expectUrl,
+  } as WebProofStepExpectUrl;
+};

package/src/api/webProof/steps/index.ts

@@ -0,0 +1,11 @@
+import { expectUrl } from "./expectUrl.ts";
+import { startPage } from "./startPage.ts";
+import { notarize } from "./notarize.ts";
+
+const steps = {
+  expectUrl,
+  startPage,
+  notarize,
+};
+
+export { expectUrl, startPage, notarize, steps };

package/src/api/webProof/steps/notarize.ts

@@ -0,0 +1,17 @@
+import {
+  EXTENSION_STEP,
+  WebProofStepNotarize,
+} from "../../../api/lib/types/webProofProvider";
+
+export const notarize = (
+  url: string,
+  method: string = "GET",
+  label: string,
+) => {
+  return {
+    url,
+    method,
+    label,
+    step: EXTENSION_STEP.notarize,
+  } as WebProofStepNotarize;
+};

package/src/api/webProof/steps/startPage.ts

@@ -0,0 +1,12 @@
+import {
+  EXTENSION_STEP,
+  WebProofStepStartPage,
+} from "../../../api/lib/types/webProofProvider";
+
+export const startPage = (url: string, label: string) => {
+  return {
+    url,
+    label,
+    step: EXTENSION_STEP.startPage,
+  } as WebProofStepStartPage;
+};

package/src/index.ts

@@ -6,3 +6,6 @@ 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";
+
+export * from "./api/webProof";
+export * from "./api/lib/types";