@vlayer/sdk 0.1.0-nightly-20241127-882e178 → 0.1.0-nightly-20241128-59dd64d

package/dist/api/lib/types/webProofProvider.d.ts

@@ -1,6 +1,6 @@
 import { Hex, Abi, ContractFunctionName } from "viem";
 import type { ContractFunctionArgsWithout } from "./viem.js";
-import { Branded, ExtensionMessageType, ExtensionMessage, WebProof, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
+import { Branded, ExtensionMessageType, ExtensionMessage, type PresentationJSON, WebProofStep, ZkProvingStatus } from "../../../web-proof-commons/index.js";
 export type WebProofRequestInput = {
     logoUrl: string;
     steps: WebProofStep[];
@@ -22,7 +22,7 @@ export type GetWebProofArgs<T extends Abi, F extends ContractFunctionName<T>> =
     proverCallCommitment: ProverCallCommitment<T, F>;
 } & WebProofRequestInput;
 export type WebProofProvider = {
-    getWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => Promise<WebProof>;
+    getWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => Promise<PresentationJSON>;
     requestWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => void;
     notifyZkProvingStatus: (status: ZkProvingStatus) => void;
     addEventListeners: <T extends ExtensionMessageType>(messageType: T, listener: (args: Extract<ExtensionMessage, {

package/dist/api/prover.d.ts

@@ -1,2 +1,5 @@
 import { type Abi, AbiStateMutability, type Address, ContractFunctionArgs, ContractFunctionName } from "viem";
-export declare function prove<T extends Abi, F extends ContractFunctionName<T>>(prover: Address, abi: T, functionName: F, args: ContractFunctionArgs<T, AbiStateMutability, F>, chainId?: number, gasLimit?: number, url?: string): Promise<import("./lib/types/vlayer.js").VCallResponse>;
+export interface ProveOptions {
+    preverifyVersions?: boolean;
+}
+export declare function prove<T extends Abi, F extends ContractFunctionName<T>>(prover: Address, abi: T, functionName: F, args: ContractFunctionArgs<T, AbiStateMutability, F>, chainId?: number, gasLimit?: number, url?: string, options?: ProveOptions): Promise<import("./lib/types/vlayer.js").VCallResponse>;

package/dist/api/prover.js

@@ -1,7 +1,17 @@
 import { encodeFunctionData, } from "viem";
 import { v_call } from "./v_call.js";
 import { foundry } from "viem/chains";
-export async function prove(prover, abi, functionName, args, chainId = foundry.id, gasLimit = 1_000_000, url = "http://127.0.0.1:3000") {
+import { v_versions } from "./v_versions.js";
+import { checkVersionCompatibility } from "./utils/versions.js";
+import { version as sdkVersion } from "../../package.json";
+async function preverifyVersions(url, shouldPreverify) {
+    if (shouldPreverify) {
+        const proverVersions = await v_versions(url);
+        checkVersionCompatibility(proverVersions.result.api_version, sdkVersion);
+    }
+}
+export async function prove(prover, abi, functionName, args, chainId = foundry.id, gasLimit = 1_000_000, url = "http://127.0.0.1:3000", options = { preverifyVersions: false }) {
+    await preverifyVersions(url, !!options.preverifyVersions);
     const calldata = encodeFunctionData({
         abi: abi,
         functionName: functionName,

package/dist/api/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare function checkVersionCompatibility(proverSemver: string, sdkSemver: string): void;

package/dist/api/utils/versions.js

@@ -0,0 +1,19 @@
+import { parse } from "semver";
+import { VersionError } from "../lib/errors.js";
+function safeParseSemver(semverString) {
+    const parsed = parse(semverString);
+    if (parsed === null) {
+        throw new VersionError(`Invalid semver string: ${semverString}`);
+    }
+    return parsed;
+}
+export function checkVersionCompatibility(proverSemver, sdkSemver) {
+    const { major: proverMajor, minor: proverMinor } = safeParseSemver(proverSemver);
+    const { major: sdkMajor, minor: sdkMinor } = safeParseSemver(sdkSemver);
+    if (proverMajor !== sdkMajor) {
+        throw new VersionError(`SDK version ${sdkSemver} is incompatible with prover version ${proverSemver}`);
+    }
+    if (proverMajor === 0 && proverMinor !== sdkMinor) {
+        throw new VersionError(`SDK version ${sdkSemver} is incompatible with prover version ${proverSemver}`);
+    }
+}

package/dist/api/utils/versions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/utils/versions.test.js

@@ -0,0 +1,39 @@
+import { describe, test, expect } from "vitest";
+import { checkVersionCompatibility } from "./versions.js";
+describe("versions compatibility", () => {
+    test("throws if major version mismatches", () => {
+        expect(() => {
+            checkVersionCompatibility("1.2.3", "2.1.3");
+        }).toThrowError("SDK version 2.1.3 is incompatible with prover version 1.2.3");
+    });
+    test("throws if major version mismatches with metadata after dash", () => {
+        expect(() => {
+            checkVersionCompatibility("1.2.3-dev-123456-deadbeef", "2.1.3");
+        }).toThrowError("SDK version 2.1.3 is incompatible with prover version 1.2.3-dev-123456-deadbeef");
+    });
+    test("throws if major version is 0 and minor version mismatches", () => {
+        expect(() => {
+            checkVersionCompatibility("0.2.3", "0.1.3");
+        }).toThrowError("SDK version 0.1.3 is incompatible with prover version 0.2.3");
+    });
+    test("does not throw if major and minor versions match", () => {
+        expect(() => {
+            checkVersionCompatibility("1.2.3", "1.2.13");
+        }).not.toThrow();
+    });
+    test("does not throw if major version is >0 and minor mismatches", () => {
+        expect(() => {
+            checkVersionCompatibility("1.2.3", "1.5.8");
+        }).not.toThrow();
+    });
+    test("does not throw if major version is 0 and minor matches", () => {
+        expect(() => {
+            checkVersionCompatibility("0.2.3", "0.2.7");
+        }).not.toThrow();
+    });
+    test("works for semvers with metadata after dash", () => {
+        expect(() => {
+            checkVersionCompatibility("0.2.3-dev-123456-deadbeef", "0.2.7");
+        }).not.toThrow();
+    });
+});

package/dist/api/v_versions.d.ts

@@ -0,0 +1,12 @@
+interface VVersionsResponseResult {
+    call_guest_id: string;
+    chain_guest_id: string;
+    api_version: string;
+}
+export interface VVersionsResponse {
+    jsonrpc: string;
+    result: VVersionsResponseResult;
+    id: number;
+}
+export declare function v_versions(url?: string): Promise<VVersionsResponse>;
+export {};

package/dist/api/v_versions.js

@@ -0,0 +1,36 @@
+const v_versionsBody = {
+    method: "v_versions",
+    params: [],
+    id: 1,
+    jsonrpc: "2.0",
+};
+export async function v_versions(url = "http://127.0.0.1:3000") {
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(v_versionsBody),
+        headers: { "Content-Type": "application/json" },
+    });
+    console.log("response", response);
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const response_json = await response.json();
+    assertResponseObject(response_json);
+    return response_json;
+}
+function isFieldAString(x, field) {
+    return (field in x && typeof x[field] === "string");
+}
+function assertResponseObject(x) {
+    if (!x || typeof x !== "object") {
+        throw new Error("Expected object");
+    }
+    if (!("result" in x) || !x.result || typeof x.result !== "object") {
+        throw new Error(`Unexpected \`v_versions\` response: ${JSON.stringify(x, null, 2)}`);
+    }
+    if (!isFieldAString(x.result, "call_guest_id") ||
+        !isFieldAString(x.result, "chain_guest_id") ||
+        !isFieldAString(x.result, "api_version")) {
+        throw new Error(`Unexpected \`v_versions\` response: ${JSON.stringify(x, null, 2)}`);
+    }
+}

package/dist/api/webProof/providers/extension.d.ts

@@ -1,2 +1,3 @@
-import { type WebProofProvider, type WebProofProviderSetup } from "../../lib/types/webProofProvider.js";
+import { type WebProofProvider, type WebProofProviderSetup, type WebProofRequestInput } from "../../lib/types/webProofProvider.js";
+export declare const validateWebProofRequest: (webProofRequest: WebProofRequestInput) => void;
 export declare const createExtensionWebProofProvider: ({ notaryUrl, wsProxyUrl, }?: WebProofProviderSetup) => WebProofProvider;

package/dist/api/webProof/providers/extension.js

@@ -1,4 +1,4 @@
-import { ExtensionMessageType, } from "../../../web-proof-commons/index.js";
+import { EXTENSION_STEP, ExtensionMessageType, assertUrl, assertUrlPattern, } from "../../../web-proof-commons/index.js";
 const EXTENSION_ID = "jbchhcgphfokabmfacnkafoeeeppjmpl";
 class ExtensionWebProofProvider {
     notaryUrl;
@@ -54,6 +54,7 @@ class ExtensionWebProofProvider {
         this.listeners[messageType].push(listener);
     }
     requestWebProof(webProofRequest) {
+        validateWebProofRequest(webProofRequest);
         this.connectToExtension().postMessage({
             action: "RequestWebProof" /* ExtensionAction.RequestWebProof */,
             payload: {
@@ -86,6 +87,19 @@ class ExtensionWebProofProvider {
         });
     }
 }
-export const createExtensionWebProofProvider = ({ notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.5/", wsProxyUrl = "wss://notary.pse.dev/proxy", } = {}) => {
+const validateSteps = (steps) => {
+    steps.forEach(({ step, url }) => {
+        if (step === EXTENSION_STEP.startPage) {
+            assertUrl(url);
+        }
+        else {
+            assertUrlPattern(url);
+        }
+    });
+};
+export const validateWebProofRequest = (webProofRequest) => {
+    validateSteps(webProofRequest.steps);
+};
+export const createExtensionWebProofProvider = ({ notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.7", wsProxyUrl = "wss://notary.pse.dev/proxy", } = {}) => {
     return new ExtensionWebProofProvider(notaryUrl, wsProxyUrl);
 };

package/dist/api/webProof/providers/extension.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/webProof/providers/extension.test.js

@@ -0,0 +1,65 @@
+import { createExtensionWebProofProvider } from "./extension.js";
+import { describe, it, expect } from "vitest";
+import { expectUrl, startPage, notarize } from "../steps/index.js";
+import { StepValidationError } from "../../../web-proof-commons/index.js";
+const defaults = {
+    logoUrl: "https://example.com/logo.png",
+    proverCallCommitment: {
+        address: "0x",
+        proverAbi: [],
+        chainId: 1,
+        functionName: "test",
+        commitmentArgs: null,
+    },
+};
+const invalidUrl = "http:/example.com";
+const invalidUrlPattern = "http://+.test";
+const validUrl = "https://example.com";
+const validUrlPattern = "https://example.com/test";
+const label = "test";
+describe("ExtensionWebProofProvider", () => {
+    it("should properly validate startPage step", () => {
+        const provider = createExtensionWebProofProvider();
+        expect(() => provider.requestWebProof({
+            ...defaults,
+            steps: [startPage(invalidUrl, label)],
+        })).toThrow(StepValidationError);
+    });
+    it("should properly validate expectUrl step", () => {
+        const provider = createExtensionWebProofProvider();
+        expect(() => provider.requestWebProof({
+            ...defaults,
+            steps: [expectUrl(invalidUrlPattern, label)],
+        })).toThrow(StepValidationError);
+    });
+    it("should properly validate notarize step", () => {
+        const provider = createExtensionWebProofProvider();
+        expect(() => provider.requestWebProof({
+            ...defaults,
+            steps: [notarize(invalidUrlPattern, "GET", label)],
+        })).toThrow(StepValidationError);
+    });
+    it("successfully validates all steps", () => {
+        const provider = createExtensionWebProofProvider();
+        expect(() => provider.requestWebProof({
+            ...defaults,
+            steps: [
+                startPage(validUrl, label),
+                expectUrl(validUrlPattern, label),
+                notarize(validUrlPattern, "GET", label),
+            ],
+        })).not.toThrow(StepValidationError);
+    });
+    it("should properly work backward compatible way with only urls used", () => {
+        const provider = createExtensionWebProofProvider();
+        expect(() => provider.requestWebProof({
+            ...defaults,
+            steps: [
+                startPage(validUrl, label),
+                expectUrl(validUrl, label),
+                expectUrl(validUrl, label),
+                notarize(validUrl, "GET", label),
+            ],
+        })).not.toThrow(StepValidationError);
+    });
+});

package/dist/index.d.ts

@@ -2,6 +2,5 @@ export * as testHelpers from "./api/helpers.js";
 export { preverifyEmail } from "./api/email/preverify.js";
 export { createVlayerClient } from "./api/lib/client.js";
 export * from "./api/lib/types/index.js";
-export * from "./web-proof-commons/types/webProof.js";
 export * from "./web-proof-commons/utils.js";
 export * from "./web-proof-commons/types/message.js";

package/dist/index.js

@@ -2,6 +2,5 @@ export * as testHelpers from "./api/helpers.js";
 export { preverifyEmail } from "./api/email/preverify.js";
 export { createVlayerClient } from "./api/lib/client.js";
 export * from "./api/lib/types/index.js";
-export * from "./web-proof-commons/types/webProof.js";
 export * from "./web-proof-commons/utils.js";
 export * from "./web-proof-commons/types/message.js";

package/dist/web-proof-commons/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./types/message.js";
-export * from "./types/webProof.js";
 export * from "./utils.js";

package/dist/web-proof-commons/index.js

@@ -1,3 +1,2 @@
 export * from "./types/message.js";
-export * from "./types/webProof.js";
 export * from "./utils.js";

package/dist/web-proof-commons/types/message.d.ts

@@ -1,5 +1,5 @@
 import type { Branded } from "../utils.js";
-import type { WebProof } from "./webProof.js";
+import type { PresentationJSON as TLSNPresentationJSON } from "tlsn-js/src/types";
 export declare const EXTENSION_STEP: {
     readonly expectUrl: "expectUrl";
     readonly startPage: "startPage";
@@ -32,10 +32,11 @@ export declare enum ExtensionMessageType {
     TabOpened = "TabOpened",
     ProofProcessing = "ProofProcessing"
 }
+export type PresentationJSON = TLSNPresentationJSON;
 export type ExtensionMessage = {
     type: ExtensionMessageType.ProofDone;
     payload: {
-        proof: WebProof;
+        proof: PresentationJSON;
     };
 } | {
     type: ExtensionMessageType.ProofError;
@@ -62,19 +63,34 @@ export type WebProverSessionConfig = {
     steps: WebProofStep[];
 };
 export type WebProofStep = WebProofStepNotarize | WebProofStepExpectUrl | WebProofStepStartPage;
+export type UrlPattern = Branded<string, "UrlPattern">;
+export type Url = Branded<UrlPattern, "Url">;
 export type WebProofStepNotarize = Branded<{
-    url: string;
+    url: UrlPattern;
     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;
+    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 declare enum StepValidationErrors {
+    InvalidUrl = "InvalidUrl",
+    InvalidUrlPattern = "InvalidUrlPattern"
+}
+export declare enum StepValidationErrorMessage {
+    InvalidUrl = "Wrong url",
+    InvalidUrlPattern = "Wrong url pattern"
+}
+export declare class StepValidationError extends Error {
+    constructor(message: string, name: StepValidationErrors);
+}
+export declare function assertUrl(url: string): asserts url is Url;
+export declare function assertUrlPattern(urlPattern: string): asserts urlPattern is UrlPattern;

package/dist/web-proof-commons/types/message.js

@@ -1,3 +1,5 @@
+import { URLPattern } from "urlpattern-polyfill";
+import urlRegex from "url-regex";
 export const EXTENSION_STEP = {
     expectUrl: "expectUrl",
     startPage: "startPage",
@@ -18,3 +20,33 @@ export var ExtensionMessageType;
     ExtensionMessageType["TabOpened"] = "TabOpened";
     ExtensionMessageType["ProofProcessing"] = "ProofProcessing";
 })(ExtensionMessageType || (ExtensionMessageType = {}));
+export var StepValidationErrors;
+(function (StepValidationErrors) {
+    StepValidationErrors["InvalidUrl"] = "InvalidUrl";
+    StepValidationErrors["InvalidUrlPattern"] = "InvalidUrlPattern";
+})(StepValidationErrors || (StepValidationErrors = {}));
+export var StepValidationErrorMessage;
+(function (StepValidationErrorMessage) {
+    StepValidationErrorMessage["InvalidUrl"] = "Wrong url";
+    StepValidationErrorMessage["InvalidUrlPattern"] = "Wrong url pattern";
+})(StepValidationErrorMessage || (StepValidationErrorMessage = {}));
+export class StepValidationError extends Error {
+    constructor(message, name) {
+        super(message);
+        this.name = name;
+    }
+}
+export function assertUrl(url) {
+    const isUrl = urlRegex({ strict: true }).test(url);
+    if (!isUrl) {
+        throw new StepValidationError(`${StepValidationErrorMessage.InvalidUrl}: ${url}`, StepValidationErrors.InvalidUrl);
+    }
+}
+export function assertUrlPattern(urlPattern) {
+    try {
+        new URLPattern(urlPattern);
+    }
+    catch {
+        throw new StepValidationError(`${StepValidationErrorMessage.InvalidUrlPattern}: ${urlPattern} `, StepValidationErrors.InvalidUrlPattern);
+    }
+}

package/package.json

@@ -15,7 +15,7 @@
       "types": "./dist/config/index.d.ts"
     }
   },
-  "version": "0.1.0-nightly-20241127-882e178",
+  "version": "0.1.0-nightly-20241128-59dd64d",
   "scripts": {
     "build": "bun tsc && bun tsc-alias",
     "test:unit": "vitest --run",
@@ -25,6 +25,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.27.7",
     "@types/bun": "latest",
+    "@types/semver": "^7.5.8",
     "abitype": "^1.0.6",
     "vitest": "^2.1.1",
     "vitest-fetch-mock": "^0.4.1"
@@ -37,7 +38,9 @@
     "dns-over-http-resolver": "^3.0.3",
     "dotenv-flow": "^4.1.0",
     "postal-mime": "^2.3.2",
+    "semver": "^7.6.3",
     "tsc-alias": "^1.8.10",
+    "url-regex": "^5.0.0",
     "viem": "2.21.0",
     "vite-tsconfig-paths": "^5.0.1"
   },

package/dist/web-proof-commons/types/webProof.d.ts

@@ -1,86 +0,0 @@
-export interface WebProof {
-    session: Session;
-    substrings: Substrings;
-    notaryUrl: string;
-}
-export interface Session {
-    header: Header;
-    signature: Signature;
-    session_info: SessionInfo;
-}
-export interface SessionInfo {
-    server_name: ServerName;
-    handshake_decommitment: HandshakeDecommitment;
-}
-export interface HandshakeDecommitment {
-    nonce: number[];
-    data: Data;
-}
-export interface Data {
-    server_cert_details: ServerCERTDetails;
-    server_kx_details: ServerKxDetails;
-    client_random: number[];
-    server_random: number[];
-}
-export interface ServerCERTDetails {
-    cert_chain: Array<number[]>;
-    ocsp_response: number[];
-    scts: null;
-}
-export interface ServerKxDetails {
-    kx_params: number[];
-    kx_sig: KxSig;
-}
-export interface KxSig {
-    scheme: string;
-    sig: number[];
-}
-export interface Header {
-    encoder_seed: number[];
-    merkle_root: number[];
-    sent_len: number;
-    recv_len: number;
-    handshake_summary: HandshakeSummary;
-}
-export interface HandshakeSummary {
-    time: number;
-    server_public_key: ServerPublicKey;
-    handshake_commitment: number[];
-}
-export interface ServerPublicKey {
-    group: string;
-    key: number[];
-}
-export interface ServerName {
-    Dns: string;
-}
-export interface Signature {
-    P256: string;
-}
-export interface Substrings {
-    openings: {
-        [key: string]: Opening[];
-    };
-    inclusion_proof: InclusionProof;
-}
-export interface InclusionProof {
-    proof: unknown[];
-    total_leaves: number;
-}
-export interface Opening {
-    kind?: string;
-    ranges?: Range[];
-    direction?: string;
-    Blake3?: Blake3;
-}
-export interface Blake3 {
-    data: number[];
-    nonce: number[];
-}
-export interface Range {
-    start: number;
-    end: number;
-}
-export declare const assertWebProof: (candidate: {
-    notaryUrl?: string;
-}) => asserts candidate is WebProof;

package/dist/web-proof-commons/types/webProof.js

@@ -1,10 +0,0 @@
-// 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 const assertWebProof = function (candidate) {
-    //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");
-    }
-};