@vlayer/sdk 0.1.0-nightly-20241028-74b5b0d → 0.1.0-nightly-202410292-42360cf

package/dist/api/email/dnsResolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveDkimDns(domain: string, selector: string): Promise<string>;

package/dist/api/email/dnsResolver.js

@@ -0,0 +1,6 @@
+import DnsResolver from "dns-over-http-resolver";
+export async function resolveDkimDns(domain, selector) {
+    const resolver = new DnsResolver();
+    const address = await resolver.resolveTxt(`${selector}._domainkey.${domain}`);
+    return address.flat()[0];
+}

package/dist/api/email/dnsResolver.test.d.ts

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

package/dist/api/email/dnsResolver.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "vitest";
+import { resolveDkimDns } from "./dnsResolver";
+describe("resolveDkimDns Integration", () => {
+    test("resolves VLayer DNS", async () => {
+        const resolved = await resolveDkimDns("vlayer-xyz.20230601.gappssmtp.com", "20230601");
+        const expected = "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3gWcOhCm99qzN+h7/2+LeP3CLsJkQQ4EP/2mrceXle5pKq8uZmBl1U4d2Vxn4w+pWFANDLmcHolLboESLFqEL5N6ae7u9b236dW4zn9AFkXAGenTzQEeif9VUFtLAZ0Qh2eV7OQgz/vPj5IaNqJ7h9hpM9gO031fe4v+J0DLCE8Rgo7hXbNgJavctc0983DaCDQaznHZ44LZ6TtZv9TBs+QFvsy4+UCTfsuOtHzoEqOOuXsVXZKLP6B882XbEnBpXEF8QzV4J26HiAJFUbO3mAqZL2UeKC0hhzoIZqZXNG0BfuzOF0VLpDa18GYMUiu+LhEJPJO9D8zhzvQIHNrpGwIDAQAB";
+        expect(resolved).toBe(expected);
+    });
+    test("throws error if dns not found", async () => {
+        await expect(resolveDkimDns("not-a-domain.com", "abcd")).rejects.toThrow();
+    });
+});

package/dist/api/email/parseEmail.d.ts

@@ -0,0 +1,10 @@
+import { Email } from "postal-mime";
+export declare class DkimParsingError extends Error {
+    constructor(message: string);
+}
+export declare function parseEmail(mime: string): Promise<Email>;
+export declare function getDkimSigners(mail: Email): {
+    domain: string;
+    selector: string;
+}[];
+export declare function parseParams(str: string): Record<string, string>;

package/dist/api/email/parseEmail.js

@@ -0,0 +1,38 @@
+import PostalMime from "postal-mime";
+export class DkimParsingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DkimParsingError";
+    }
+}
+export async function parseEmail(mime) {
+    return await PostalMime.parse(mime.trim());
+}
+export function getDkimSigners(mail) {
+    const dkimHeader = mail.headers.filter((h) => h.key === "dkim-signature");
+    if (dkimHeader.length === 0)
+        throw new DkimParsingError("No DKIM header found");
+    return dkimHeader.map(parseHeader);
+}
+export function parseParams(str) {
+    return Object.fromEntries(str.split(";").map((s) => s
+        .trim()
+        .split("=")
+        .map((v) => v && v.trim())));
+}
+function parseHeader(header) {
+    const params = parseParams(header.value);
+    if (!params) {
+        throw new DkimParsingError(`Invalid DKIM header ${header.value}`);
+    }
+    if (!params.d) {
+        throw new DkimParsingError("DKIM header missing domain");
+    }
+    if (!params.s) {
+        throw new DkimParsingError("DKIM header missing selector");
+    }
+    return {
+        domain: params.d,
+        selector: params.s,
+    };
+}

package/dist/api/email/parseEmail.test.d.ts

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

package/dist/api/email/parseEmail.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "vitest";
+import { getDkimSigners, parseEmail, parseParams } from "./parseEmail";
+const emailHeaders = `From: "John Doe" <john@d.oe>
+To: "Jane Doe" <jane@d.oe>
+Subject: Hello World
+Date: Thu, 1 Jan 1970 00:00:00 +0000
+`;
+const dkimHeader = "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com; h=from:to:subject; s=selector1; b=abcdef;";
+const body = "Hello, World!";
+const emailFixture = `${emailHeaders}${dkimHeader}\n\n${body}`;
+describe("parseEmail", () => {
+    test("should get dkim header from email", async () => { });
+    test("correctly parses untrimmed email", async () => {
+        const untrimmed = `\n   ${emailFixture}    \n`;
+        const email = await parseEmail(untrimmed);
+        expect(email.headers.find((h) => h.key === "dkim-signature")).toBeDefined();
+    });
+    test("works well with multiple dkim headers", async () => {
+        const dkimHeader2 = "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=second.signer; h=from:to:subject; s=selector2; b=abcdef;";
+        const email = await parseEmail(`${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`);
+        const dkim = email.headers.filter((h) => h.key === "dkim-signature");
+        expect(dkim).toHaveLength(2);
+        expect(parseParams(dkim[0].value).s).toBe("selector1");
+        expect(parseParams(dkim[1].value).s).toBe("selector2");
+    });
+});
+describe("getDkimSigners", () => {
+    test("should get dkim signers from email", async () => {
+        const email = await parseEmail(emailFixture);
+        const dkim = getDkimSigners(email);
+        expect(dkim).toHaveLength(1);
+        expect(dkim[0].domain).toBe("example.com");
+        expect(dkim[0].selector).toBe("selector1");
+    });
+    test("should get multiple dkim signers from email", async () => {
+        const dkimHeader2 = "DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=second.signer; h=from:to:subject; s=selector2; b=abcdef;";
+        const email = await parseEmail(`${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`);
+        const dkim = getDkimSigners(email);
+        expect(dkim).toHaveLength(2);
+        expect(dkim[0].domain).toBe("example.com");
+        expect(dkim[0].selector).toBe("selector1");
+        expect(dkim[1].domain).toBe("second.signer");
+        expect(dkim[1].selector).toBe("selector2");
+    });
+    test("should throw if no dkim header found", async () => {
+        const email = await parseEmail(emailHeaders);
+        expect(() => getDkimSigners(email)).toThrowError("No DKIM header found");
+    });
+    test("should throw if dkim header is invalid", async () => {
+        const email = await parseEmail(`${emailHeaders}DKIM-Signature: invalid\n\n${body}`);
+        expect(() => getDkimSigners(email)).toThrowError("DKIM header missing domain");
+    });
+    test("should throw if dkim header is missing domain", async () => {
+        const email = await parseEmail(`${emailHeaders}DKIM-Signature: v=1; s=selector\n\n${body}`);
+        expect(() => getDkimSigners(email)).toThrowError("DKIM header missing domain");
+    });
+    test("should throw if dkim header is missing selector", async () => {
+        const email = await parseEmail(`${emailHeaders}DKIM-Signature: v=1; d=example.com\n\n${body}`);
+        expect(() => getDkimSigners(email)).toThrowError("DKIM header missing selector");
+    });
+});
+describe("parseParams", () => {
+    test("should parse single parameter", () => {
+        const params = parseParams("a=b");
+        expect(params).toEqual({ a: "b" });
+    });
+    test("should parse multiple parameters", () => {
+        const params = parseParams("a=b; c=d; e=f");
+        expect(params).toEqual({ a: "b", c: "d", e: "f" });
+    });
+    test("should trim spaces around parameters", () => {
+        const params = parseParams(" a = b ; c = d ; e = f ");
+        expect(params).toEqual({ a: "b", c: "d", e: "f" });
+    });
+    test("should handle empty values", () => {
+        const params = parseParams("a=; b=c");
+        expect(params).toEqual({ a: "", b: "c" });
+    });
+    test("should handle missing values", () => {
+        const params = parseParams("a; b=c");
+        expect(params).toEqual({ a: undefined, b: "c" });
+    });
+    test("should handle empty string", () => {
+        const params = parseParams("");
+        expect(params).toEqual({});
+    });
+    test("should handle parameters with extra semicolons", () => {
+        const params = parseParams("a=b;; c=d;");
+        expect(params).toEqual({ a: "b", c: "d" });
+    });
+});

package/dist/api/email/preverify.d.ts

@@ -0,0 +1,4 @@
+export declare function preverifyEmail(mimeEmail: string): Promise<{
+    email: string;
+    dnsRecords: string[];
+}>;

package/dist/api/email/preverify.js

@@ -0,0 +1,18 @@
+import { parseEmail, getDkimSigners } from "./parseEmail";
+import { resolveDkimDns } from "./dnsResolver";
+export async function preverifyEmail(mimeEmail) {
+    const parsedEmail = await parseEmail(mimeEmail);
+    const signers = getDkimSigners(parsedEmail);
+    if (signers.length === 0) {
+        throw new Error("No DKIM header found");
+    }
+    if (signers.length > 1) {
+        throw new Error("Multiple DKIM headers found");
+    }
+    const [{ domain, selector }] = signers;
+    const dnsRecord = await resolveDkimDns(domain, selector);
+    return {
+        email: mimeEmail,
+        dnsRecords: [dnsRecord],
+    };
+}

package/dist/api/email/preverify.test.d.ts

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

package/dist/api/email/preverify.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "vitest";
+import { preverifyEmail } from "./preverify";
+import { readFile } from "../../testHelpers/readFile";
+describe("Preverify email: integration", () => {
+    test("adds dns record to email mime", async () => {
+        const rawEmail = readFile("./src/api/email/testdata/test_email.txt");
+        const preverifiedEmail = await preverifyEmail(rawEmail);
+        expect(preverifiedEmail).toMatchObject({
+            email: rawEmail,
+            dnsRecords: [expect.stringContaining("v=DKIM1; k=rsa; p=")],
+        });
+    });
+    test("throws error if DKIM not found", async () => {
+        const emailWithNoDkimHeader = 'From: "Alice"\n\nBody';
+        await expect(preverifyEmail(emailWithNoDkimHeader)).rejects.toThrow("No DKIM header found");
+    });
+    test("throws error if DNS could not be resolved", async () => {
+        const emailWithNoDkimHeader = readFile("./src/api/email/testdata/test_email_unknown_domain.txt");
+        await expect(preverifyEmail(emailWithNoDkimHeader)).rejects.toThrow();
+    });
+    test("throws error if multiple DNS records found", async () => {
+        const emailWithNoDkimHeader = readFile("./src/api/email/testdata/test_email_multiple_dkims.txt");
+        await expect(preverifyEmail(emailWithNoDkimHeader)).rejects.toThrow("Multiple DKIM headers found");
+    });
+});

package/dist/api/helpers.d.ts

@@ -0,0 +1,38 @@
+import { type Abi, type Address, type Chain, type ContractFunctionArgs, type ContractFunctionName, type Hex, PublicClient, walletActions } from "viem";
+import type { ContractSpec, ContractArg } from "types/ethereum";
+export declare const chainIds: 31337[];
+export declare function createAnvilClient(chainId?: number): ReturnType<typeof walletActions> & PublicClient;
+export declare function deployContract(contractSpec: ContractSpec, args?: ContractArg[], chainId?: number): Promise<Address>;
+type DeploySpec<T extends Abi> = {
+    abi: T;
+    bytecode: {
+        object: Hex;
+    };
+};
+type Tail<T> = T extends readonly [unknown, ...infer U] ? U : [];
+export declare function deployProverVerifier<P extends Abi, V extends Abi>(proverSpec: DeploySpec<P>, verifierSpec: DeploySpec<V>, args?: {
+    prover?: ContractArg[];
+    verifier?: Tail<ContractArg>[];
+}, chainId?: number): Promise<`0x${string}`[]>;
+export declare function call<T extends Abi, F extends ContractFunctionName<T, "pure" | "view">>(abi: T, address: Address, functionName: F, args?: ContractFunctionArgs<T, "pure" | "view", F>, chainId?: number): Promise<import("viem").ContractFunctionReturnType<T, "pure" | "view", F, ContractFunctionArgs<T, "pure" | "view", F>>>;
+export declare function writeContract<T extends Abi, F extends ContractFunctionName<T, "payable" | "nonpayable">>(address: Address, abi: T, functionName: F, args: ContractFunctionArgs<T, "payable" | "nonpayable", F>, sender?: Address, chain?: Chain): Promise<import("viem").TransactionReceipt>;
+export declare const getTestAccount: () => {
+    address: Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign: (parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<Hex>;
+    experimental_signAuthorization: (parameters: import("viem/experimental").Authorization) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<import("viem").IsNarrowable<import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>>, Hex> extends true ? import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>> : Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+    publicKey: Hex;
+    source: "privateKey";
+    type: "local";
+};
+export declare const getTestAddresses: (chainId?: number) => Promise<Address[]>;
+export {};

package/dist/api/helpers.js

@@ -0,0 +1,72 @@
+import { createTestClient, http, publicActions, walletActions, } from "viem";
+import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
+import { foundry } from "viem/chains";
+const rpcUrls = new Map([[foundry.id, http()]]);
+export const chainIds = [foundry.id];
+export function createAnvilClient(chainId = foundry.id) {
+    const transport = rpcUrls.get(chainId);
+    if (transport == undefined) {
+        throw Error(`No url for chainId ${chainId}`);
+    }
+    return createTestClient({
+        chain: foundry,
+        mode: "anvil",
+        transport: transport,
+    })
+        .extend(publicActions)
+        .extend(walletActions);
+}
+export async function deployContract(contractSpec, args = [], chainId = foundry.id) {
+    const ethClient = createAnvilClient(chainId);
+    const [deployer] = await ethClient.getAddresses();
+    const txHash = await ethClient.deployContract({
+        abi: contractSpec.abi,
+        bytecode: contractSpec.bytecode.object,
+        account: deployer,
+        args,
+        chain: foundry,
+    });
+    const receipt = await ethClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status != "success") {
+        throw new Error(`Contract deployment failed with status: ${receipt.status}`);
+    }
+    return receipt.contractAddress;
+}
+export async function deployProverVerifier(proverSpec, verifierSpec, args = {}, chainId = foundry.id) {
+    console.log("Deploying prover");
+    const proverAddress = await deployContract(proverSpec, args.prover ?? [], chainId);
+    console.log(`Prover has been deployed on ${proverAddress} address`);
+    console.log("Deploying verifier");
+    const verifierAddress = await deployContract(verifierSpec, [proverAddress, ...(args.verifier ?? [])], chainId);
+    console.log(`Verifier has been deployed on ${verifierAddress} address`);
+    return [proverAddress, verifierAddress];
+}
+export async function call(abi, address, functionName, args, chainId = foundry.id) {
+    const ethClient = createAnvilClient(chainId);
+    return ethClient.readContract({
+        abi,
+        address,
+        functionName,
+        args,
+    });
+}
+export async function writeContract(address, abi, functionName, args, sender, chain = foundry) {
+    const ethClient = createAnvilClient(chain.id);
+    const selectedSender = sender || (await ethClient.getAddresses())[0];
+    const txHash = await ethClient.writeContract({
+        address,
+        abi: abi,
+        functionName,
+        args: args,
+        chain,
+        account: selectedSender,
+        chainOverride: undefined,
+    });
+    const txReceipt = await ethClient.waitForTransactionReceipt({ hash: txHash });
+    if (txReceipt.status != "success") {
+        throw new Error(`Transaction failed with status: ${txReceipt.status}`);
+    }
+    return txReceipt;
+}
+export const getTestAccount = () => privateKeyToAccount(generatePrivateKey());
+export const getTestAddresses = (chainId = foundry.id) => createAnvilClient(chainId).getAddresses();

package/dist/api/lib/client.d.ts

@@ -0,0 +1,6 @@
+import { VlayerClient } from "types/vlayer";
+import { WebProofProvider } from "types/webProofProvider";
+export declare const createVlayerClient: ({ url, webProofProvider, }?: {
+    url?: string;
+    webProofProvider?: WebProofProvider;
+}) => VlayerClient;

package/dist/api/lib/client.js

@@ -0,0 +1,45 @@
+import { prove } from "../prover";
+import { createExtensionWebProofProvider } from "../webProof";
+import { decodeFunctionResult } from "viem";
+function dropEmptyProofFromArgs(args) {
+    if (Array.isArray(args)) {
+        return args.slice(1);
+    }
+    return [];
+}
+function generateRandomHash() {
+    let hash = "0x";
+    for (let i = 0; i < 40; ++i) {
+        hash += Math.floor(Math.random() * 16).toString(16);
+    }
+    return hash;
+}
+export const createVlayerClient = ({ url = "http://127.0.0.1:3000", webProofProvider = createExtensionWebProofProvider(), } = {
+    url: "http://127.0.0.1:3000",
+    webProofProvider: createExtensionWebProofProvider(),
+}) => {
+    console.log("createVlayerClient with", url, webProofProvider);
+    const resultHashMap = new Map();
+    return {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        prove: async ({ address, functionName, chainId, proverAbi, args }) => {
+            const result_promise = prove(address, proverAbi, functionName, args, chainId, url);
+            const hash = generateRandomHash();
+            resultHashMap.set(hash, [result_promise, proverAbi, functionName]);
+            return { hash };
+        },
+        waitForProvingResult: async ({ hash }) => {
+            const savedProvingData = resultHashMap.get(hash);
+            if (!savedProvingData) {
+                throw new Error("No result found for hash " + hash);
+            }
+            const { result: { proof, evm_call_result }, } = await savedProvingData[0];
+            const result = dropEmptyProofFromArgs(decodeFunctionResult({
+                abi: savedProvingData[1],
+                data: evm_call_result,
+                functionName: savedProvingData[2],
+            }));
+            return [proof, ...result];
+        },
+    };
+};

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

@@ -0,0 +1,14 @@
+import { Abi, Address, Hex } from "viem";
+import { Branded } from "../../../web-proof-commons";
+export type Bytecode = {
+    object: Hex;
+};
+export type ContractSpec = {
+    abi: Abi;
+    bytecode: Bytecode;
+};
+export type ContractArg = number | string | boolean | bigint | number[] | string[] | boolean[] | bigint[] | Address[];
+export type EthereumAddress = Branded<Hex, "EthereumAddress">;
+export type EthereumTxHash = Branded<Hex, "EthereumTxHash">;
+export declare function assertEthereumAddress(hash: string): asserts hash is EthereumAddress;
+export declare function assertEthereumTxHash(hash: string): asserts hash is EthereumTxHash;

package/dist/api/lib/types/ethereum.js

@@ -0,0 +1,12 @@
+export function assertEthereumAddress(hash) {
+    const regex = /^(0x)?[0-9a-fA-F]{40}$/;
+    if (!regex.test(hash)) {
+        throw new Error(`Invalid ethereum account ${hash}`);
+    }
+}
+export function assertEthereumTxHash(hash) {
+    const regex = /^(0x)?[0-9a-fA-F]{64}$/;
+    if (!regex.test(hash)) {
+        throw new Error(`Invalid ethereum tx hash ${hash}`);
+    }
+}

package/dist/api/lib/types/index.js

@@ -0,0 +1,3 @@
+export * from "./ethereum";
+export * from "./vlayer";
+export * from "./webProofProvider";

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

@@ -0,0 +1,8 @@
+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[];
+export {};

package/dist/api/lib/types/viem.js

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

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

@@ -0,0 +1,47 @@
+import { Abi, AbiStateMutability, Address, ContractFunctionArgs, ContractFunctionName, Hex } from "viem";
+type Calldata = string;
+export type CallParams = {
+    to: Address;
+    data: Calldata;
+};
+export type CallContext = {
+    chain_id: number;
+};
+export type Proof = {
+    length: bigint;
+    seal: {
+        verifierSelector: Hex;
+        seal: readonly [Hex, Hex, Hex, Hex, Hex, Hex, Hex, Hex];
+        mode: number;
+    };
+    callAssumptions: {
+        proverContractAddress: Address;
+        functionSelector: Hex;
+        settleBlockHash: Hex;
+        settleBlockNumber: bigint;
+    };
+};
+export interface VCallResult {
+    evm_call_result: Hex;
+    proof: Proof;
+}
+export interface VCallResponse {
+    jsonrpc: string;
+    result: VCallResult;
+    id: number;
+}
+export type VlayerClient = {
+    prove: <T extends Abi, F extends ContractFunctionName<T>>(args: {
+        address: Hex;
+        proverAbi: T;
+        functionName: F;
+        chainId: number;
+        args: ContractFunctionArgs<T, AbiStateMutability, F>;
+    }) => Promise<{
+        hash: string;
+    }>;
+    waitForProvingResult: ({ hash, }: {
+        hash: string;
+    }) => Promise<[Proof, ...unknown[]]>;
+};
+export {};

package/dist/api/lib/types/vlayer.js

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

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

@@ -0,0 +1,29 @@
+import { Hex, Abi, ContractFunctionName } from "viem";
+import type { ContractFunctionArgsWithout } from "./viem";
+import { Branded, WebProof, WebProofStep } from "../../../web-proof-commons";
+export type WebProofSetupInput = {
+    logoUrl: string;
+    steps: WebProofStep[];
+};
+export type WebProofSetup = Branded<WebProofSetupInput & {
+    isWebProof: true;
+}, "webProof">;
+export type ProverCallCommitment<T extends Abi, F extends ContractFunctionName<T>> = {
+    address: Hex;
+    proverAbi: T;
+    functionName: F;
+    commitmentArgs: ContractFunctionArgsWithout<T, F, {
+        name: "webProof";
+    }>;
+    chainId: number;
+};
+export type GetWebProofArgs<T extends Abi, F extends ContractFunctionName<T>> = {
+    proverCallCommitment: ProverCallCommitment<T, F>;
+} & WebProofSetupInput;
+export type WebProofProvider = {
+    getWebProof: <T extends Abi, F extends ContractFunctionName<T>>(args: GetWebProofArgs<T, F>) => Promise<WebProof>;
+};
+export type WebProofProviderSetup = {
+    notaryUrl?: string;
+    wsProxyUrl?: string;
+};

package/dist/api/lib/types/webProofProvider.js

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

package/dist/api/prover.d.ts

@@ -0,0 +1,2 @@
+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, url?: string): Promise<import("types/vlayer").VCallResponse>;

package/dist/api/prover.js

@@ -0,0 +1,15 @@
+import { encodeFunctionData, } from "viem";
+import { v_call } from "./v_call";
+import { foundry } from "viem/chains";
+export async function prove(prover, abi, functionName, args, chainId = foundry.id, url = "http://127.0.0.1:3000") {
+    const calldata = encodeFunctionData({
+        abi: abi,
+        functionName: functionName,
+        args: args,
+    });
+    const call = { to: prover, data: calldata };
+    const context = {
+        chain_id: chainId,
+    };
+    return v_call(call, context, url);
+}

package/dist/api/v_call.d.ts

@@ -0,0 +1,2 @@
+import { CallContext, CallParams, VCallResponse } from "types/vlayer";
+export declare function v_call(call: CallParams, context: CallContext, url?: string): Promise<VCallResponse>;

package/dist/api/v_call.js

@@ -0,0 +1,30 @@
+function v_callBody(call, context) {
+    return {
+        method: "v_call",
+        params: [call, context],
+        id: 1,
+        jsonrpc: "2.0",
+    };
+}
+export async function v_call(call, context, url = "http://127.0.0.1:3000") {
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(v_callBody(call, context)),
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const response_json = await response.json();
+    //TODO we should launch some schema validation here
+    assertObject(response_json);
+    if ("error" in response_json) {
+        throw new Error(`Error response: ${response_json.error.message || "unknown error"}`);
+    }
+    return response_json;
+}
+function assertObject(x) {
+    if (typeof x !== "object") {
+        throw new Error("Expected object");
+    }
+}

package/dist/api/webProof/createWebProof.d.ts

@@ -0,0 +1,2 @@
+import { WebProofSetup, WebProofSetupInput } from "types/webProofProvider";
+export declare const createWebProof: ({ logoUrl, steps }: WebProofSetupInput) => WebProofSetup;

package/dist/api/webProof/createWebProof.js

@@ -0,0 +1,7 @@
+export const createWebProof = ({ logoUrl, steps }) => {
+    return {
+        logoUrl,
+        steps,
+        isWebProof: true,
+    };
+};

package/dist/api/webProof/index.js

@@ -0,0 +1,3 @@
+export * from "./createWebProof";
+export * from "./steps";
+export * from "./providers";

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

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

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

@@ -0,0 +1,32 @@
+// this id is fixed in the extension by the key in manifest.json
+const EXTENSION_ID = "jbchhcgphfokabmfacnkafoeeeppjmpl";
+export const createExtensionWebProofProvider = ({ notaryUrl = "https://notary.pse.dev/v0.1.0-alpha.5/", wsProxyUrl = "wss://notary.pse.dev/proxy", } = {
+    notaryUrl: "https://notary.pse.dev/v0.1.0-alpha.5/",
+    wsProxyUrl: "wss://notary.pse.dev/proxy",
+}) => {
+    return {
+        getWebProof: async function (webProofSetup) {
+            return new Promise((resolve, reject) => {
+                chrome.runtime.sendMessage(EXTENSION_ID, {
+                    action: 0 /* ExtensionAction.RequestWebProof */,
+                    payload: {
+                        notaryUrl,
+                        wsProxyUrl,
+                        logoUrl: webProofSetup.logoUrl,
+                        steps: webProofSetup.steps,
+                    },
+                });
+                const port = chrome.runtime.connect(EXTENSION_ID);
+                // TODO: validate message in runtime
+                port.onMessage.addListener((message) => {
+                    if (message.type === "ProofDone" /* ExtensionMessageType.ProofDone */) {
+                        resolve(message.proof);
+                    }
+                    if (message.type === "ProofError" /* ExtensionMessageType.ProofError */) {
+                        reject(new Error(message.error));
+                    }
+                });
+            });
+        },
+    };
+};

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

@@ -0,0 +1 @@
+export * from "./extension";

package/dist/api/webProof/steps/expectUrl.d.ts

@@ -0,0 +1,2 @@
+import { WebProofStepExpectUrl } from "../../../web-proof-commons";
+export declare const expectUrl: (url: string, label: string) => WebProofStepExpectUrl;