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

package/src/config/createContext.ts

@@ -0,0 +1,69 @@
+import {
+  type Chain,
+  createWalletClient,
+  http,
+  publicActions,
+  type CustomTransport,
+  custom,
+  type PrivateKeyAccount,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { getChainConfirmations } from "./getChainConfirmations";
+import * as chains from "viem/chains";
+import type { EnvConfig, VlayerContextConfig } from "./types";
+
+const getChainSpecs = (chainName: string): Chain => {
+  try {
+    return chains[chainName as keyof typeof chains] as Chain;
+  } catch {
+    throw Error(`Cannot import ${chainName} from viem/chains`);
+  }
+};
+
+export const customTransport = custom;
+
+const createEthClient = (
+  chain: Chain,
+  jsonRpcUrl: string,
+  transport?: CustomTransport,
+) =>
+  createWalletClient({
+    chain,
+    transport: transport || http(jsonRpcUrl),
+  }).extend(publicActions);
+
+export function createContext(config: EnvConfig): {
+  chain: Chain;
+  account: ReturnType<typeof privateKeyToAccount>;
+  jsonRpcUrl: string;
+  ethClient: ReturnType<typeof createEthClient>;
+  confirmations: number;
+} & EnvConfig;
+
+export function createContext(
+  config: VlayerContextConfig,
+  transport?: CustomTransport,
+): {
+  chain: Chain;
+  jsonRpcUrl: string;
+  account: PrivateKeyAccount;
+  ethClient: ReturnType<typeof createEthClient>;
+  confirmations: number;
+} & VlayerContextConfig;
+
+export function createContext(
+  config: VlayerContextConfig | EnvConfig,
+  transport?: CustomTransport,
+) {
+  const chain = getChainSpecs(config.chainName);
+  const jsonRpcUrl = config.jsonRpcUrl ?? chain.rpcUrls.default.http[0];
+
+  return {
+    ...config,
+    chain,
+    account: config.privateKey && privateKeyToAccount(config.privateKey),
+    jsonRpcUrl,
+    ethClient: createEthClient(chain, jsonRpcUrl, transport),
+    confirmations: getChainConfirmations(config.chainName),
+  };
+}

package/src/config/deploy.ts

@@ -0,0 +1,108 @@
+import { getConfig } from "./getConfig";
+import { createContext } from "./createContext";
+import { type ContractArg, type ContractSpec } from "types/ethereum";
+import { type Address } from "viem";
+import { getChainConfirmations } from "./getChainConfirmations";
+import debug from "debug";
+
+const log = debug("vlayer:prover");
+
+export const waitForContractDeploy = async ({
+  hash,
+}: {
+  hash: `0x${string}`;
+}): Promise<Address> => {
+  const { ethClient: client } = createContext(getConfig());
+  const receipt = await client.waitForTransactionReceipt({
+    hash,
+    confirmations: getChainConfirmations(client.chain?.name),
+    retryCount: 120,
+    retryDelay: 1000,
+  });
+
+  if (!receipt.contractAddress || receipt.status !== "success") {
+    throw new Error(
+      `Cannot get contract address from receipt: ${receipt.status}`,
+    );
+  }
+
+  return receipt.contractAddress;
+};
+
+export const waitForTransactionReceipt = async ({
+  hash,
+}: {
+  hash: `0x${string}`;
+}) => {
+  const { ethClient } = createContext(getConfig());
+  return ethClient.waitForTransactionReceipt({
+    hash,
+    confirmations: getChainConfirmations(ethClient.chain?.name),
+    retryCount: 120,
+    retryDelay: 1000,
+  });
+};
+
+export const deployProver = async ({
+  proverSpec,
+  proverArgs,
+}: {
+  proverSpec: ContractSpec;
+  proverArgs?: ContractArg[];
+}) => {
+  const config = getConfig();
+  const { ethClient, account, chain } = createContext(config);
+
+  const proverHash = await ethClient.deployContract({
+    chain,
+    account,
+    args: proverArgs,
+    abi: proverSpec.abi,
+    bytecode: proverSpec.bytecode.object,
+  });
+  log(`Prover hash: ${proverHash}`);
+  const prover = await waitForContractDeploy({ hash: proverHash });
+  return prover;
+};
+
+export const deployVlayerContracts = async ({
+  proverSpec,
+  verifierSpec,
+  proverArgs,
+  verifierArgs,
+}: {
+  proverSpec: ContractSpec;
+  verifierSpec: ContractSpec;
+  proverArgs?: ContractArg[];
+  verifierArgs?: ContractArg[];
+}) => {
+  log("Starting contract deployment process...");
+  const config = getConfig();
+  const { chain, ethClient, account } = createContext(config);
+
+  log("Deploying prover contract...");
+  const proverHash = await ethClient.deployContract({
+    chain,
+    account,
+    args: proverArgs,
+    abi: proverSpec.abi,
+    bytecode: proverSpec.bytecode.object,
+  });
+  log(`Prover hash: ${proverHash}`);
+  const prover = await waitForContractDeploy({ hash: proverHash });
+  log(`Prover contract deployed at: ${prover}`);
+
+  log("Deploying verifier contract...");
+  const verifierHash = await ethClient.deployContract({
+    chain,
+    account,
+    args: prover ? [prover, ...(verifierArgs ?? [])] : verifierArgs,
+    abi: verifierSpec.abi,
+    bytecode: verifierSpec.bytecode.object,
+  });
+  const verifier = await waitForContractDeploy({ hash: verifierHash });
+  log(`Verifier contract deployed at: ${verifier}`);
+
+  log("Contract deployment completed successfully");
+  return { prover, verifier };
+};

package/src/config/getChainConfirmations.ts

@@ -0,0 +1,6 @@
+export const getChainConfirmations = (chainName?: string): number => {
+  if (!chainName || chainName.toLowerCase() === "anvil") {
+    return 1;
+  }
+  return 6;
+};

package/src/config/getConfig.ts

@@ -0,0 +1,71 @@
+import dotenvflow from "dotenv-flow";
+import { type EnvConfig } from "./types";
+
+const ensureEnvVariable = (envVar: string) => {
+  if (!process.env[envVar]) {
+    if (envVar === "EXAMPLES_TEST_PRIVATE_KEY") {
+      throw new Error(
+        `${envVar} missing. Add a HEX private key with ETH in .env.local for deploy and verify transactions.`,
+      );
+    }
+    throw new Error(`${envVar} is not set`);
+  }
+  return process.env[envVar];
+};
+
+const ensureVlayerEnv = () => {
+  try {
+    if (!process.env.VLAYER_ENV) {
+      throw new Error("VLAYER_ENV is not set. Available options: testnet, dev");
+    }
+    if (!["testnet", "dev"].includes(process.env.VLAYER_ENV)) {
+      throw new Error(
+        `Invalid VLAYER_ENV: ${process.env.VLAYER_ENV}. Available options: testnet, anvil, mainnet`,
+      );
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (e) {
+    return "dev";
+  }
+
+  return process.env.VLAYER_ENV;
+};
+
+const dotEnvFlowConfig = () => {
+  dotenvflow.config({
+    node_env: ensureVlayerEnv(),
+  });
+};
+
+export const toCamelCase = (str: string) =>
+  str
+    .toLowerCase()
+    .replace(/([-_][a-z])/g, (group) =>
+      group.toUpperCase().replace("-", "").replace("_", ""),
+    );
+
+const envVars = [
+  { var: "CHAIN_NAME" },
+  { var: "PROVER_URL" },
+  { var: "JSON_RPC_URL" },
+  { var: "L2_JSON_RPC_URL", optional: true },
+  { var: "EXAMPLES_TEST_PRIVATE_KEY", to: "privateKey" },
+  { var: "VLAYER_API_TOKEN", to: "token", optional: true },
+];
+
+export const getConfig = () => {
+  dotEnvFlowConfig();
+  return envVars.reduce((config, envVar) => {
+    try {
+      return {
+        ...config,
+        [envVar.to ?? toCamelCase(envVar.var)]: ensureEnvVariable(envVar.var),
+      };
+    } catch (e) {
+      if (envVar.optional) {
+        return { ...config };
+      }
+      throw e;
+    }
+  }, {} as EnvConfig);
+};

package/src/config/index.ts

@@ -0,0 +1,5 @@
+export * from "./getConfig";
+export * from "./createContext";
+export * from "./deploy";
+export * from "./writeEnvVariables";
+export * from "./types";

package/src/config/types.ts

@@ -0,0 +1,26 @@
+// result of env parsing
+// mostly needed by the examples to be able to properly perform
+// pre run deployment
+
+export type EnvConfig = {
+  chainName: string;
+  proverUrl: string;
+  jsonRpcUrl: string;
+  l2JsonRpcUrl?: string;
+  privateKey: `0x${string}`;
+  token?: string;
+};
+
+// represents what is needed by client to properly
+// work in whole vlayer flow
+// privateKey is optional and used only for anvil
+// to avoid involving metamask into the flow
+
+export type VlayerContextConfig = {
+  chainName: string;
+  jsonRpcUrl: string;
+  proverUrl: string;
+  wsProxyUrl?: string;
+  notaryUrl?: string;
+  privateKey?: `0x${string}`;
+};

package/src/config/writeEnvVariables.ts

@@ -0,0 +1,28 @@
+import fs from "fs";
+import dotenv from "dotenv";
+import debug from "debug";
+
+const log = debug("vlayer:config");
+
+export const writeEnvVariables = async (
+  envPath: string,
+  overrides: { [key: string]: string | undefined },
+) => {
+  fs.appendFileSync(envPath, "");
+  const envFile = Bun.file(envPath);
+  let envContent = await envFile.text();
+
+  if (!envContent) {
+    envContent = "";
+  }
+
+  const newEnvs = Object.assign(dotenv.parse(envContent), overrides);
+
+  const envLines = Object.entries(newEnvs)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+
+  await Bun.write(envPath, envLines);
+
+  log(`Successfully updated the ${envPath} with: `, overrides);
+};

package/src/index.ts

@@ -0,0 +1,7 @@
+export { preverifyEmail } from "./api/email/preverify";
+export { createVlayerClient } from "./api/lib/client";
+
+export * from "./api/lib/types";
+
+export * from "./web-proof-commons/utils";
+export * from "./web-proof-commons/types/message";

package/src/testHelpers/readFile.ts

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

package/src/web-proof-commons/index.ts

@@ -0,0 +1,3 @@
+export * from "./types/message";
+export * from "./types/redaction";
+export * from "./utils";

package/src/web-proof-commons/types/message.ts

@@ -0,0 +1,176 @@
+import type { Branded } from "../utils";
+import { URLPattern } from "urlpattern-polyfill";
+import { type RedactionConfig } from "./redaction";
+import urlRegex from "url-regex";
+import type { PresentationJSON as TLSNPresentationJSON } from "tlsn-js/src/types";
+
+export const EXTENSION_STEP = {
+  expectUrl: "expectUrl",
+  startPage: "startPage",
+  notarize: "notarize",
+} as const;
+
+export type ExtensionStep =
+  (typeof EXTENSION_STEP)[keyof typeof EXTENSION_STEP];
+
+export const enum ExtensionAction {
+  RequestWebProof = "RequestWebProof",
+  NotifyZkProvingStatus = "NotifyZkProvingStatus",
+}
+
+export enum ZkProvingStatus {
+  NotStarted = "NotStarted",
+  Proving = "Proving",
+  Done = "Done",
+  Error = "Error",
+}
+
+export type MessageToExtension =
+  | {
+      action: ExtensionAction.RequestWebProof;
+      payload: WebProverSessionConfig;
+    }
+  | {
+      action: ExtensionAction.NotifyZkProvingStatus;
+      payload: {
+        status: ZkProvingStatus;
+      };
+    };
+
+export enum ExtensionMessageType {
+  ProofDone = "ProofDone",
+  ProofError = "ProofError",
+  RedirectBack = "RedirectBack",
+  TabOpened = "TabOpened",
+  ProofProcessing = "ProofProcessing",
+}
+
+export type PresentationJSON = TLSNPresentationJSON;
+
+export type ExtensionMessage =
+  | {
+      type: ExtensionMessageType.ProofDone;
+      payload: {
+        presentationJSON: PresentationJSON;
+        decodedTranscript: {
+          sent: string;
+          recv: string;
+        };
+      };
+    }
+  | { type: ExtensionMessageType.ProofError; payload: { error: string } }
+  | { type: ExtensionMessageType.RedirectBack }
+  | { type: ExtensionMessageType.TabOpened; payload: { tabId: number } }
+  | {
+      type: ExtensionMessageType.ProofProcessing;
+      payload: {
+        // as we dont have progress yet from tlsn this is optional
+        progress?: number;
+      };
+    };
+
+export type EmptyWebProverSessionConfig = {
+  notaryUrl: null;
+  wsProxyUrl: null;
+  logoUrl: null;
+  steps: never[];
+};
+
+export type WebProverSessionConfig =
+  | {
+      notaryUrl: string;
+      wsProxyUrl: string;
+      logoUrl: string;
+      steps: WebProofStep[];
+    }
+  | EmptyWebProverSessionConfig;
+
+export function isEmptyWebProverSessionConfig(
+  config: WebProverSessionConfig,
+): config is EmptyWebProverSessionConfig {
+  return (
+    config.notaryUrl === null &&
+    config.wsProxyUrl === null &&
+    config.logoUrl === null &&
+    config.steps.length === 0
+  );
+}
+
+export type WebProofStep =
+  | WebProofStepNotarize
+  | WebProofStepExpectUrl
+  | WebProofStepStartPage;
+
+export type UrlPattern = Branded<string, "UrlPattern">;
+
+export type Url = Branded<UrlPattern, "Url">;
+
+export type WebProofStepNotarize = Branded<
+  {
+    url: UrlPattern;
+    method: string;
+    label: string;
+    redact: RedactionConfig;
+    step: typeof EXTENSION_STEP.notarize;
+  },
+  "notarize"
+>;
+
+export type WebProofStepStartPage = Branded<
+  {
+    url: Url;
+    label: string;
+    step: typeof EXTENSION_STEP.startPage;
+  },
+  "startPage"
+>;
+
+export type WebProofStepExpectUrl = Branded<
+  {
+    url: UrlPattern;
+    label: string;
+    step: typeof EXTENSION_STEP.expectUrl;
+  },
+  "expectUrl"
+>;
+
+export enum StepValidationErrors {
+  InvalidUrl = "InvalidUrl",
+  InvalidUrlPattern = "InvalidUrlPattern",
+}
+
+export enum StepValidationErrorMessage {
+  InvalidUrl = "Wrong url",
+  InvalidUrlPattern = "Wrong url pattern",
+}
+
+export class StepValidationError extends Error {
+  constructor(message: string, name: StepValidationErrors) {
+    super(message);
+    this.name = name;
+  }
+}
+
+export function assertUrl(url: string): asserts url is Url {
+  const regex = urlRegex({ strict: true });
+  const isUrl = regex.test(url);
+  if (!isUrl) {
+    throw new StepValidationError(
+      `${StepValidationErrorMessage.InvalidUrl}: ${url}`,
+      StepValidationErrors.InvalidUrl,
+    );
+  }
+}
+
+export function assertUrlPattern(
+  urlPattern: string,
+): asserts urlPattern is UrlPattern {
+  try {
+    new URLPattern(urlPattern);
+  } catch {
+    throw new StepValidationError(
+      `${StepValidationErrorMessage.InvalidUrlPattern}: ${urlPattern} `,
+      StepValidationErrors.InvalidUrlPattern,
+    );
+  }
+}

package/src/web-proof-commons/types/redaction.test.ts

@@ -0,0 +1,97 @@
+import { describe, test, expect } from "vitest";
+import { RedactionItemsArray } from "./redaction";
+describe("RedactionConfig", () => {
+  test("accepts empty array", () => {
+    const testEmpty = RedactionItemsArray.parse([]);
+    expect(testEmpty).toBeDefined();
+  });
+
+  test("valid redaction config", () => {
+    const testValid = RedactionItemsArray.parse([
+      {
+        request: {
+          headers: ["Authorization"],
+        },
+      },
+      {
+        response: {
+          headers: ["Content-Type"],
+        },
+      },
+    ]);
+    console.log(testValid);
+    expect(testValid).toBeDefined();
+  });
+
+  test("invalid when using both request headers and headers_except", () => {
+    expect(() => {
+      RedactionItemsArray.parse([
+        {
+          request: {
+            headers: ["Authorization"],
+          },
+        },
+        {
+          request: {
+            headers_except: ["Authorization"],
+          },
+        },
+      ]);
+    }).toThrow("Cannot have both request headers and request headers_except");
+  });
+
+  test("invalid when using both response headers and headers_except", () => {
+    expect(() => {
+      RedactionItemsArray.parse([
+        {
+          response: {
+            headers: ["Content-Type"],
+          },
+        },
+        {
+          response: {
+            headers_except: ["Authorization"],
+          },
+        },
+      ]);
+    }).toThrow("Cannot have both response headers and response headers_except");
+  });
+
+  test("invalid when using both request url_query and url_query_except", () => {
+    expect(() => {
+      RedactionItemsArray.parse([
+        {
+          request: {
+            url_query: ["page"],
+          },
+        },
+        {
+          request: {
+            url_query_except: ["limit"],
+          },
+        },
+      ]);
+    }).toThrow(
+      "Cannot have both request url_query and request url_query_except",
+    );
+  });
+
+  test("invalid when using both response json_body and json_body_except", () => {
+    expect(() => {
+      RedactionItemsArray.parse([
+        {
+          response: {
+            json_body: ["data"],
+          },
+        },
+        {
+          response: {
+            json_body_except: ["metadata"],
+          },
+        },
+      ]);
+    }).toThrow(
+      "Cannot have both response json_body and response json_body_except",
+    );
+  });
+});