@vlayer/sdk 0.1.0-nightly-20250127-5ee6ca8 → 0.1.0-nightly-20250128-0a32cfc

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

@@ -0,0 +1,197 @@
+import {
+  type WebProofProvider,
+  type WebProofProviderSetup,
+  type WebProofRequestInput,
+} from "../../lib/types/webProofProvider";
+
+import {
+  EXTENSION_STEP,
+  ExtensionAction,
+  type ExtensionMessage,
+  ExtensionMessageType,
+  type WebProofStep,
+  type PresentationJSON,
+  ZkProvingStatus,
+  assertUrl,
+  assertUrlPattern,
+  type RedactionConfig,
+  RedactionItemsArray,
+  type MessageToExtension,
+} from "../../../web-proof-commons";
+
+import debug from "debug";
+
+const log = debug("vlayer:WebProof:provider");
+
+const EXTENSION_ID = "jbchhcgphfokabmfacnkafoeeeppjmpl";
+
+declare let chrome: {
+  runtime: {
+    sendMessage: (
+      extensionId: string | undefined,
+      message: MessageToExtension,
+    ) => void;
+    connect: (extensionId: string) => {
+      onMessage: {
+        addListener: (message: unknown) => void;
+      };
+      postMessage: (message: MessageToExtension) => void;
+      onDisconnect: {
+        addListener: (callback: () => void) => void;
+      };
+    };
+  };
+};
+
+class ExtensionWebProofProvider implements WebProofProvider {
+  private port: ReturnType<typeof chrome.runtime.connect> | null = null;
+
+  private listeners: Partial<
+    Record<
+      ExtensionMessageType,
+      ((
+        args: Extract<ExtensionMessage, { type: ExtensionMessageType }>,
+      ) => void)[]
+    >
+  > = {};
+
+  constructor(
+    private notaryUrl: string,
+    private wsProxyUrl: string,
+  ) {}
+
+  public notifyZkProvingStatus(status: ZkProvingStatus) {
+    if (typeof chrome !== "undefined") {
+      // Chrome does not provide reliable api to check if given extension is installed
+      // what we could do is to use management api but
+      // 1) this will need to provided extra permission
+      // 2) still is not reliable because this api becomes defined when first extension that uses it is installed
+      // so still will need to try catch
+      try {
+        chrome.runtime.sendMessage(EXTENSION_ID, {
+          action: ExtensionAction.NotifyZkProvingStatus,
+          payload: { status },
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (e) {
+        log("Cant send message", "look that extension is not installed ");
+      }
+    }
+  }
+
+  private connectToExtension() {
+    if (!this.port) {
+      this.port = chrome.runtime.connect(EXTENSION_ID);
+      this.port.onDisconnect.addListener(() => {
+        this.port = null;
+        this.connectToExtension();
+      });
+      this.port.onMessage.addListener((message: ExtensionMessage) => {
+        if (message.type === ExtensionMessageType.ProofDone) {
+          this.listeners[ExtensionMessageType.ProofDone]?.forEach((cb) => {
+            cb(message);
+          });
+        }
+        if (message.type === ExtensionMessageType.ProofError) {
+          this.listeners[ExtensionMessageType.ProofError]?.forEach((cb) => {
+            cb(message);
+          });
+        }
+      });
+    }
+    return this.port;
+  }
+
+  public addEventListeners<T extends ExtensionMessageType>(
+    messageType: T,
+    listener: (args: Extract<ExtensionMessage, { type: T }>) => void,
+  ) {
+    this.connectToExtension();
+    if (!this.listeners[messageType]) {
+      this.listeners[messageType] = [];
+    }
+    this.listeners[messageType].push(
+      listener as (args: ExtensionMessage) => void,
+    );
+  }
+
+  public requestWebProof(webProofRequest: WebProofRequestInput) {
+    validateWebProofRequest(webProofRequest);
+    this.connectToExtension().postMessage({
+      action: ExtensionAction.RequestWebProof,
+      payload: {
+        notaryUrl: this.notaryUrl,
+        wsProxyUrl: this.wsProxyUrl,
+        logoUrl: webProofRequest.logoUrl,
+        steps: webProofRequest.steps,
+      },
+    });
+  }
+
+  public async getWebProof(webProofRequest: WebProofRequestInput): Promise<{
+    presentationJSON: PresentationJSON;
+    decodedTranscript: {
+      sent: string;
+      recv: string;
+    };
+  }> {
+    return new Promise<{
+      presentationJSON: PresentationJSON;
+      decodedTranscript: {
+        sent: string;
+        recv: string;
+      };
+    }>((resolve, reject) => {
+      chrome.runtime.sendMessage(EXTENSION_ID, {
+        action: ExtensionAction.RequestWebProof,
+        payload: {
+          notaryUrl: this.notaryUrl,
+          wsProxyUrl: this.wsProxyUrl,
+          logoUrl: webProofRequest.logoUrl,
+          steps: webProofRequest.steps,
+        },
+      });
+
+      this.connectToExtension().onMessage.addListener(
+        (message: ExtensionMessage) => {
+          if (message.type === ExtensionMessageType.ProofDone) {
+            resolve(message.payload);
+          }
+          if (message.type === ExtensionMessageType.ProofError) {
+            reject(new Error(message.payload.error));
+          }
+        },
+      );
+    });
+  }
+}
+
+const validateSteps = (steps: WebProofStep[]) => {
+  steps.forEach((step) => {
+    if (step.step === EXTENSION_STEP.startPage) {
+      assertUrl(step.url);
+    } else {
+      assertUrlPattern(step.url);
+    }
+    if (step.step === EXTENSION_STEP.notarize) {
+      validateRedaction(step.redact ?? []);
+    }
+  });
+};
+
+const validateRedaction = (redaction: RedactionConfig) => {
+  RedactionItemsArray.parse(redaction);
+};
+
+export const validateWebProofRequest = (
+  webProofRequest: WebProofRequestInput,
+) => {
+  validateSteps(webProofRequest.steps);
+};
+
+export const createExtensionWebProofProvider = ({
+  notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.7",
+  wsProxyUrl = "wss://notary.pse.dev/proxy",
+}: WebProofProviderSetup = {}): WebProofProvider => {
+  return new ExtensionWebProofProvider(notaryUrl, wsProxyUrl);
+};

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,
+  type WebProofStepExpectUrl,
+} from "../../../web-proof-commons";
+
+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";
+import { startPage } from "./startPage";
+import { notarize } from "./notarize";
+
+const steps = {
+  expectUrl,
+  startPage,
+  notarize,
+};
+
+export { expectUrl, startPage, notarize, steps };

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

@@ -0,0 +1,20 @@
+import {
+  EXTENSION_STEP,
+  type WebProofStepNotarize,
+  type RedactionConfig,
+} from "../../../web-proof-commons";
+
+export const notarize = (
+  url: string,
+  method: string = "GET",
+  label: string,
+  redact?: RedactionConfig,
+) => {
+  return {
+    url,
+    method,
+    label,
+    redact: redact ?? [],
+    step: EXTENSION_STEP.notarize,
+  } as WebProofStepNotarize;
+};

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

@@ -0,0 +1,12 @@
+import {
+  EXTENSION_STEP,
+  type WebProofStepStartPage,
+} from "../../../web-proof-commons";
+
+export const startPage = (url: string, label: string) => {
+  return {
+    url,
+    label,
+    step: EXTENSION_STEP.startPage,
+  } as WebProofStepStartPage;
+};

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