@vlayer/sdk 0.1.0-nightly-20241001-f254bee → 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-f254bee",
+  "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"
   },
@@ -20,8 +20,8 @@
   },
   "dependencies": {
     "dns-over-http-resolver": "^3.0.3",
-    "mailparser": "^3.7.1",
     "postal-mime": "^2.3.2",
-    "viem": "^2.21.0"
+    "viem": "^2.21.0",
+    "zod": "^3.23.8"
   }
 }

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";