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

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",
+    );
+  });
+});

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

@@ -0,0 +1,201 @@
+import { z } from "zod";
+import type { WebProofStepNotarize, WebProverSessionConfig } from "./message";
+export const RedactRequestHeadersSchema = z.object({
+  request: z.object({
+    headers: z.array(z.string()),
+  }),
+});
+
+export const RedactRequestHeadersExceptSchema = z.object({
+  request: z.object({
+    headers_except: z.array(z.string()),
+  }),
+});
+
+export const RedactRequestUrlQueryParamSchema = z.object({
+  request: z.object({
+    url_query: z.array(z.string()),
+  }),
+});
+
+export const RedactRequestUrlQueryParamExceptSchema = z.object({
+  request: z.object({
+    url_query_except: z.array(z.string()),
+  }),
+});
+
+export const RedactResponseHeadersSchema = z.object({
+  response: z.object({
+    headers: z.array(z.string()),
+  }),
+});
+
+export const RedactResponseHeadersExceptSchema = z.object({
+  response: z.object({
+    headers_except: z.array(z.string()),
+  }),
+});
+
+export const RedactResponseJsonBodySchema = z.object({
+  response: z.object({
+    json_body: z.array(z.string()),
+  }),
+});
+
+export const RedactResponseJsonBodyExceptSchema = z.object({
+  response: z.object({
+    json_body_except: z.array(z.string()),
+  }),
+});
+
+export const RedactionItemSchema = z.union([
+  RedactRequestHeadersSchema,
+  RedactRequestHeadersExceptSchema,
+  RedactRequestUrlQueryParamSchema,
+  RedactRequestUrlQueryParamExceptSchema,
+  RedactResponseHeadersSchema,
+  RedactResponseHeadersExceptSchema,
+  RedactResponseJsonBodySchema,
+  RedactResponseJsonBodyExceptSchema,
+]);
+
+export type RedactRequestHeadersExcept = z.infer<
+  typeof RedactRequestHeadersExceptSchema
+>;
+export type RedactRequestHeaders = z.infer<typeof RedactRequestHeadersSchema>;
+
+export type RedactRequestUrlQueryParam = z.infer<
+  typeof RedactRequestUrlQueryParamSchema
+>;
+export type RedactRequestUrlQueryParamExcept = z.infer<
+  typeof RedactRequestUrlQueryParamExceptSchema
+>;
+export type RedactResponseHeaders = z.infer<typeof RedactResponseHeadersSchema>;
+
+export type RedactResponseJsonBody = z.infer<
+  typeof RedactResponseJsonBodySchema
+>;
+export type RedactResponseJsonBodyExcept = z.infer<
+  typeof RedactResponseJsonBodyExceptSchema
+>;
+export type RedactResponseHeadersExcept = z.infer<
+  typeof RedactResponseHeadersExceptSchema
+>;
+
+export type RedactionItem = z.infer<typeof RedactionItemSchema>;
+// Define the individual types
+
+const checkConflictingItems =
+  (items: RedactionItem[]) =>
+  (
+    getFirstItem: (item: RedactionItem) => boolean,
+    getSecondItem: (item: RedactionItem) => boolean,
+  ) => {
+    const hasFirst = items.some(getFirstItem);
+    const hasSecond = items.some(getSecondItem);
+    return !(hasFirst && hasSecond);
+  };
+
+const ensureNoResponseHeadersConflict = (items: RedactionItem[]) => {
+  const hasResponseHeaders = (item: RedactionItem) =>
+    "response" in item &&
+    "headers" in item.response &&
+    item.response.headers.length > 0;
+
+  const hasResponseHeadersExcept = (item: RedactionItem) =>
+    "response" in item &&
+    "headers_except" in item.response &&
+    item.response.headers_except.length > 0;
+
+  return checkConflictingItems(items)(
+    hasResponseHeaders,
+    hasResponseHeadersExcept,
+  );
+};
+
+const ensureNoResponseJsonBodyConflict = (items: RedactionItem[]) => {
+  const hasResponseJsonBody = (item: RedactionItem) =>
+    "response" in item &&
+    "json_body" in item.response &&
+    item.response.json_body.length > 0;
+
+  const hasResponseJsonBodyExcept = (item: RedactionItem) =>
+    "response" in item &&
+    "json_body_except" in item.response &&
+    item.response.json_body_except.length > 0;
+
+  return checkConflictingItems(items)(
+    hasResponseJsonBody,
+    hasResponseJsonBodyExcept,
+  );
+};
+
+const ensureNoRequestHeadersConflict = (items: RedactionItem[]) => {
+  const hasRequestHeaders = (item: RedactionItem) =>
+    "request" in item &&
+    "headers" in item.request &&
+    item.request.headers.length > 0;
+
+  const hasRequestHeadersExcept = (item: RedactionItem) =>
+    "request" in item &&
+    "headers_except" in item.request &&
+    item.request.headers_except.length > 0;
+
+  return checkConflictingItems(items)(
+    hasRequestHeaders,
+    hasRequestHeadersExcept,
+  );
+};
+
+const ensureNoRequestUrlQueryParamConflict = (items: RedactionItem[]) => {
+  const hasRequestUrlQuery = (item: RedactionItem) =>
+    "request" in item &&
+    "url_query" in item.request &&
+    item.request.url_query.length > 0;
+
+  const hasRequestUrlQueryExcept = (item: RedactionItem) =>
+    "request" in item &&
+    "url_query_except" in item.request &&
+    item.request.url_query_except.length > 0;
+
+  return checkConflictingItems(items)(
+    hasRequestUrlQuery,
+    hasRequestUrlQueryExcept,
+  );
+};
+
+export const RedactionItemsArray = z
+  .array(RedactionItemSchema)
+  .refine(ensureNoResponseHeadersConflict, {
+    message: "Cannot have both response headers and response headers_except",
+  })
+  .refine(ensureNoResponseJsonBodyConflict, {
+    message:
+      "Cannot have both response json_body and response json_body_except",
+  })
+  .refine(ensureNoRequestHeadersConflict, {
+    message: "Cannot have both request headers and request headers_except",
+  })
+  .refine(ensureNoRequestUrlQueryParamConflict, {
+    message: "Cannot have both request url_query and request url_query_except",
+  })
+  .refine(ensureNoRequestUrlQueryParamConflict, {
+    message: "Cannot have both request url_query and request url_query_except",
+  });
+
+export type RedactionItemsArray = z.infer<typeof RedactionItemsArray>;
+
+export type RedactionConfig = RedactionItem[];
+
+export function getRedactionConfig(
+  provingSessionConfig: WebProverSessionConfig,
+): RedactionConfig {
+  const notarizeStep = provingSessionConfig.steps.find(
+    (step): step is WebProofStepNotarize => step.step === "notarize",
+  );
+  const redactionConfig =
+    notarizeStep !== undefined
+      ? (notarizeStep as WebProofStepNotarize).redact
+      : [];
+  return redactionConfig;
+}

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

@@ -0,0 +1,11 @@
+type Brand<B> = { __brand: B };
+export type Branded<T, B> = T & Brand<B>;
+
+export function isDefined<T>(
+  value: T | undefined,
+  message: string = "Value is undefined",
+): asserts value is T {
+  if (value === undefined) {
+    throw new Error(message);
+  }
+}