@midnightntwrk/wallet-sdk-prover-client 1.2.3

package/README.md

@@ -0,0 +1,77 @@
+# @midnightntwrk/wallet-sdk-prover-client
+
+Client for interacting with the Midnight ZK proof generation service.
+
+## Installation
+
+```bash
+npm install @midnightntwrk/wallet-sdk-prover-client
+```
+
+## Overview
+
+This package provides a client for submitting transactions to a Proof Server that generates zero-knowledge proofs. It is
+used to finalize shielded transactions by converting unproven transactions into proven ones.
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { HttpProverClient } from '@midnightntwrk/wallet-sdk-prover-client';
+
+// Initialize the client with the Proof Server URL
+const proverClient = new HttpProverClient({
+  serverUrl: 'http://localhost:6300',
+});
+
+// Prove an unproven transaction
+const provenTransaction = await proverClient.proveTransaction(unprovenTransaction);
+```
+
+### With Custom Cost Model
+
+```typescript
+const provenTransaction = await proverClient.proveTransaction(unprovenTransaction, customCostModel);
+```
+
+## API
+
+### HttpProverClient
+
+```typescript
+class HttpProverClient {
+  constructor(config: { serverUrl: string });
+
+  proveTransaction<S extends Signaturish, B extends Bindingish>(
+    transaction: Transaction<S, PreProof, B>,
+    costModel?: CostModel,
+  ): Promise<Transaction<S, Proof, B>>;
+}
+```
+
+## Exports
+
+### Default Export
+
+- `HttpProverClient` - HTTP client for the Proof Server
+
+### Effect Submodule (`/effect`)
+
+Effect.ts-based implementation:
+
+```typescript
+import { ProverClient, HttpProverClient } from '@midnightntwrk/wallet-sdk-prover-client/effect';
+```
+
+## Error Handling
+
+The client may throw the following errors:
+
+- `ClientError` - Issues with the provided transaction or connection problems
+- `ServerError` - Internal server errors or connection failures
+- `InvalidProtocolSchemeError` - Invalid URL scheme in configuration
+
+## License
+
+Apache-2.0

package/dist/effect/HttpProverClient.d.ts

@@ -0,0 +1,12 @@
+import { Effect, Layer } from 'effect';
+import { ProverClient } from './ProverClient.js';
+import { type InvalidProtocolSchemeError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+/**
+ * Creates a layer for a {@link ProverClient} that sends requests to a Proof Server over HTTP.
+ *
+ * @param config The server configuration to use when configuring the HTTP elements of the layer.
+ * @returns A `Layer` for {@link ProverClient} that sends requests to a configured Proof Server over HTTP. The layer can
+ *   fail with an `InvalidProtocolSchemeError` if `config` is invalid for a HTTP context.
+ */
+export declare const layer: (config: ProverClient.ServerConfig) => Layer.Layer<ProverClient, InvalidProtocolSchemeError>;
+export declare const create: (config: ProverClient.ServerConfig) => Effect.Effect<ProverClient.Service, InvalidProtocolSchemeError>;

package/dist/effect/HttpProverClient.js

@@ -0,0 +1,83 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Chunk, Duration, Effect, Either, Layer, pipe, Schedule, Stream } from 'effect';
+import { FetchHttpClient, HttpBody, HttpClient, HttpClientRequest } from '@effect/platform';
+import { ProverClient } from './ProverClient.js';
+import { ClientError, HttpURL, ServerError, } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import { BlobOps, EitherOps } from '@midnightntwrk/wallet-sdk-utilities';
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+const PROVE_TX_PATH = '/prove';
+const CHECK_TX_PATH = '/check';
+/**
+ * Creates a layer for a {@link ProverClient} that sends requests to a Proof Server over HTTP.
+ *
+ * @param config The server configuration to use when configuring the HTTP elements of the layer.
+ * @returns A `Layer` for {@link ProverClient} that sends requests to a configured Proof Server over HTTP. The layer can
+ *   fail with an `InvalidProtocolSchemeError` if `config` is invalid for a HTTP context.
+ */
+export const layer = (config) => Layer.effect(ProverClient, HttpURL.make(new URL(config.url)).pipe(Either.map((baseUrl) => new HttpProverClientImpl(baseUrl)), Either.match({
+    onLeft: (l) => Effect.fail(l),
+    onRight: (r) => Effect.succeed(r),
+})));
+export const create = (config) => {
+    return pipe(HttpURL.make(new URL(config.url)), Either.map((baseUrl) => new HttpProverClientImpl(baseUrl)), EitherOps.toEffect, Effect.map((client) => ProverClient.of(client)));
+};
+class HttpProverClientImpl {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    baseUrl;
+    request(path, payload, failurePrefix) {
+        const concatBytes = (chunks) => Effect.promise(() => BlobOps.getBytes(new Blob(chunks.map((chunk) => new Uint8Array(chunk)))));
+        const receiveBody = (response) => pipe(response.stream, Stream.runCollect, Effect.flatMap((chunks) => concatBytes(Chunk.toArray(chunks))));
+        // Build endpoint URL from the already validated base URL
+        const url = HttpURL.HttpURL(new URL(path, this.baseUrl));
+        const proveTxRequest = pipe(Effect.succeed(payload), Effect.map((body) => HttpClientRequest.post(url).pipe(
+        // A raw body must be used instead of `bodyUint8Array` so that no explicit `content-length`
+        // header is attached: `fetch` derives the length from the body itself, and an explicit
+        // header is rejected as malformed by undici >= 8.2.0 when it is installed as the global
+        // dispatcher (e.g. transitively via testcontainers or @effect/platform-node).
+        HttpClientRequest.setBody(HttpBody.raw(body, { contentType: 'application/octet-stream' })))), Effect.flatMap(HttpClient.execute), Effect.flatMap((response) => Effect.gen(function* () {
+            if (response.status !== 200) {
+                const text = yield* response.text;
+                return yield* new ClientError({ message: `${failurePrefix}: ${text}` });
+            }
+            return yield* receiveBody(response);
+        })), Effect.retry({
+            times: 3,
+            while: (error) => 
+            // Retry if we get a Bad Gateway, Service Unavailable, or Gateway Timeout error.
+            error._tag === 'ResponseError' && error.response.status >= 502 && error.response.status <= 504,
+            schedule: Schedule.exponential(Duration.seconds(2), 2),
+        }));
+        return proveTxRequest.pipe(Effect.catchTags({
+            RequestError: (err) => new ClientError({ message: `Failed to connect to Proof Server: ${err.message}` }),
+            ResponseError: (err) => Effect.orElseSucceed(err.response.text, () => 'Unknown server error').pipe(Effect.flatMap((message) => new ServerError({ message }))),
+        }), Effect.provide(FetchHttpClient.layer));
+    }
+    serverProverProvider = () => ({
+        check: async (serializedPreimage, _keyLocation) => pipe(Effect.succeed(ledger.createCheckPayload(serializedPreimage)), Effect.flatMap((tx) => this.request(CHECK_TX_PATH, tx, 'Failed to check')), Effect.map((response) => ledger.parseCheckResult(response)), Effect.runPromise),
+        prove: async (serializedPreimage, _keyLocation, overwriteBindingInput) => pipe(Effect.succeed(ledger.createProvingPayload(serializedPreimage, overwriteBindingInput)), Effect.flatMap((tx) => this.request(PROVE_TX_PATH, tx, 'Failed to prove')), Effect.runPromise),
+    });
+    proveTransaction(transaction, costModel) {
+        return pipe(Effect.succeed(this.serverProverProvider()), Effect.flatMap((provider) => Effect.tryPromise({
+            try: () => transaction.prove(provider, costModel),
+            catch: (error) => error instanceof ClientError || error instanceof ServerError
+                ? error
+                : new ClientError({ message: 'Failed to prove transaction', cause: error }),
+        })));
+    }
+    asProvingProvider() {
+        return this.serverProverProvider();
+    }
+}

package/dist/effect/ProverClient.d.ts

@@ -0,0 +1,32 @@
+import { type Effect, Context } from 'effect';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type ClientError, type ServerError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import type { KeyMaterialProvider } from '@midnight-ntwrk/zkir-v2';
+declare const ProverClient_base: Context.TagClass<ProverClient, "@midnight-ntwrk/prover-client#ProverClient", ProverClient.Service>;
+/** A client that provides proof services for unproven transactions. */
+export declare class ProverClient extends ProverClient_base {
+}
+export declare namespace ProverClient {
+    /** Provides server-related configuration for {@link ProverClient} implementations. */
+    interface ServerConfig {
+        /** The base URL to the Proof Server. */
+        readonly url: URL | string;
+    }
+    /** Provides wasm-related configuration for {@link KeyMaterialProvider} implementations. */
+    interface WasmConfig {
+        /** The Key Material Provider. */
+        readonly keyMaterialProvider: KeyMaterialProvider;
+    }
+    interface Service {
+        /**
+         * Proves an unproven transaction by submitting it to an associated Proof Server.
+         *
+         * @param transaction A serialized unproven transaction.
+         * @returns An `Effect` that yields with a serialized transaction representing the proven version of `transaction`;
+         *   or fails with a client or server side error.
+         */
+        proveTransaction<S extends ledger.Signaturish, B extends ledger.Bindingish>(tx: ledger.Transaction<S, ledger.PreProof, B>, costModel?: ledger.CostModel): Effect.Effect<ledger.Transaction<S, ledger.Proof, B>, ClientError | ServerError>;
+        asProvingProvider(): ledger.ProvingProvider;
+    }
+}
+export {};

package/dist/effect/ProverClient.js

@@ -0,0 +1,16 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Context } from 'effect';
+/** A client that provides proof services for unproven transactions. */
+export class ProverClient extends Context.Tag('@midnight-ntwrk/prover-client#ProverClient')() {
+}

package/dist/effect/WasmProver.d.ts

@@ -0,0 +1,47 @@
+import { Effect, Layer, Schema } from 'effect';
+import { type InvalidProtocolSchemeError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import { type KeyMaterialProvider } from '@midnight-ntwrk/zkir-v2';
+import { ProverClient } from './ProverClient.js';
+/**
+ * Creates a layer for a {@link ProverClient} that sends requests to a Wasm Prover.
+ *
+ * @param config The Key Material Provider to use when configuring the prover's elements of the layer.
+ * @returns A `Layer` for {@link ProverClient} that sends requests to a configured Wasm Prover.
+ */
+export declare const layer: (config: ProverClient.WasmConfig) => Layer.Layer<ProverClient, InvalidProtocolSchemeError>;
+export declare const create: (config: ProverClient.WasmConfig) => Effect.Effect<ProverClient.Service, InvalidProtocolSchemeError>;
+export declare const CheckOperationSchema: Schema.Struct<{
+    op: Schema.Literal<["check"]>;
+    args: Schema.Tuple<[typeof Schema.Uint8Array]>;
+}>;
+export declare const ProveOperationSchema: Schema.Struct<{
+    op: Schema.Literal<["prove"]>;
+    args: Schema.Tuple2<typeof Schema.Uint8Array, Schema.Union<[typeof Schema.BigIntFromSelf, typeof Schema.Undefined]>>;
+}>;
+export declare const LookupKeyRequestSchema: Schema.Struct<{
+    op: Schema.Literal<["lookupKey"]>;
+    keyLocation: typeof Schema.String;
+}>;
+export declare const GetParamsRequestSchema: Schema.Struct<{
+    op: Schema.Literal<["getParams"]>;
+    k: typeof Schema.Number;
+}>;
+export declare const ResponseFromWorkerSchema: Schema.Struct<{
+    op: Schema.Literal<["result"]>;
+    value: Schema.Union<[typeof Schema.Uint8Array, Schema.Array$<Schema.Union<[typeof Schema.BigIntFromSelf, typeof Schema.Undefined]>>]>;
+}>;
+export declare const LookupKeyOperationResultSchema: Schema.Struct<{
+    op: Schema.Literal<["lookupKey"]>;
+    keyLocation: typeof Schema.String;
+    result: Schema.optional<Schema.Struct<{
+        proverKey: typeof Schema.Uint8Array;
+        verifierKey: typeof Schema.Uint8Array;
+        ir: typeof Schema.Uint8Array;
+    }>>;
+}>;
+export declare const GetParamsOperationResultSchema: Schema.Struct<{
+    op: Schema.Literal<["getParams"]>;
+    k: typeof Schema.Number;
+    result: typeof Schema.Uint8Array;
+}>;
+export declare const makeDefaultKeyMaterialProvider: () => KeyMaterialProvider;

package/dist/effect/WasmProver.js

@@ -0,0 +1,200 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import Worker from 'web-worker';
+import { Effect, Layer, Schema, pipe } from 'effect';
+import { ClientError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import { ProverClient } from './ProverClient.js';
+/**
+ * Creates a layer for a {@link ProverClient} that sends requests to a Wasm Prover.
+ *
+ * @param config The Key Material Provider to use when configuring the prover's elements of the layer.
+ * @returns A `Layer` for {@link ProverClient} that sends requests to a configured Wasm Prover.
+ */
+export const layer = (config) => Layer.effect(ProverClient, Effect.succeed(new WasmProverImpl(config.keyMaterialProvider)));
+export const create = (config) => {
+    return Effect.succeed(new WasmProverImpl(config.keyMaterialProvider));
+};
+const MAX_TIME_TO_PROCESS = 10 * 60 * 1000;
+export const CheckOperationSchema = Schema.Struct({
+    op: Schema.Literal('check'),
+    args: Schema.Tuple(Schema.Uint8Array),
+});
+export const ProveOperationSchema = Schema.Struct({
+    op: Schema.Literal('prove'),
+    args: Schema.Tuple(Schema.Uint8Array, Schema.Union(Schema.BigIntFromSelf, Schema.Undefined)),
+});
+export const LookupKeyRequestSchema = Schema.Struct({
+    op: Schema.Literal('lookupKey'),
+    keyLocation: Schema.String,
+});
+export const GetParamsRequestSchema = Schema.Struct({
+    op: Schema.Literal('getParams'),
+    k: Schema.Number,
+});
+export const ResponseFromWorkerSchema = Schema.Struct({
+    op: Schema.Literal('result'),
+    value: Schema.Union(Schema.Uint8Array, Schema.Array(Schema.Union(Schema.BigIntFromSelf, Schema.Undefined))),
+});
+const ProvingKeyMaterialSchema = Schema.Struct({
+    proverKey: Schema.Uint8Array,
+    verifierKey: Schema.Uint8Array,
+    ir: Schema.Uint8Array,
+});
+export const LookupKeyOperationResultSchema = Schema.Struct({
+    op: Schema.Literal('lookupKey'),
+    keyLocation: Schema.String,
+    result: Schema.optional(ProvingKeyMaterialSchema),
+});
+export const GetParamsOperationResultSchema = Schema.Struct({
+    op: Schema.Literal('getParams'),
+    k: Schema.Number,
+    result: Schema.Uint8Array,
+});
+const MessageDataSchema = Schema.Union(LookupKeyRequestSchema, GetParamsRequestSchema, ResponseFromWorkerSchema);
+const callProverWorker = ({ kmProvider, op, args }) => {
+    return new Promise((resolve, reject) => {
+        const currentFile = import.meta.url;
+        const worker = new Worker(new URL(`../../dist/proof-worker.js`, currentFile), { type: 'module' });
+        // initialize worker
+        worker.postMessage(op === 'check'
+            ? Schema.encodeSync(CheckOperationSchema)({ op, args: [args[0]] })
+            : Schema.encodeSync(ProveOperationSchema)({ op, args: [args[0], args[1]] }));
+        // a message from the worker
+        worker.addEventListener('message', ({ data }) => {
+            const decoded = Schema.decodeUnknownSync(MessageDataSchema)(data);
+            const { op } = decoded;
+            if (op === 'lookupKey') {
+                const { keyLocation } = decoded;
+                kmProvider
+                    .lookupKey(keyLocation)
+                    .then((result) => {
+                    worker.postMessage(Schema.encodeSync(LookupKeyOperationResultSchema)({ op, keyLocation, result }));
+                })
+                    .catch((e) => {
+                    worker.terminate();
+                    reject(e);
+                });
+            }
+            else if (op === 'getParams') {
+                const { k } = decoded;
+                kmProvider
+                    .getParams(k)
+                    .then((result) => {
+                    worker.postMessage(Schema.encodeSync(GetParamsOperationResultSchema)({ op, k, result }));
+                })
+                    .catch((e) => {
+                    worker.terminate();
+                    reject(e);
+                });
+            }
+            else if (op === 'result') {
+                const { value } = decoded;
+                worker.terminate();
+                resolve(value);
+            }
+        });
+        worker.addEventListener('error', (e) => {
+            worker.terminate();
+            reject(Error(e.message));
+        });
+        setTimeout(() => {
+            worker.terminate();
+            reject(new Error(`${op} action timed out`));
+        }, MAX_TIME_TO_PROCESS);
+    });
+};
+class WasmProverImpl {
+    constructor(keyMaterialProvider) {
+        this.keyMaterialProvider = keyMaterialProvider;
+    }
+    keyMaterialProvider;
+    wasmProverProvider = (keyMaterialProvider) => ({
+        check: async (serializedPreimage, _keyLocation) => callProverWorker({
+            kmProvider: keyMaterialProvider ?? this.keyMaterialProvider,
+            op: 'check',
+            args: [serializedPreimage],
+        }),
+        prove: async (serializedPreimage, _keyLocation, overwriteBindingInput) => callProverWorker({
+            kmProvider: keyMaterialProvider ?? this.keyMaterialProvider,
+            op: 'prove',
+            args: [serializedPreimage, overwriteBindingInput],
+        }),
+    });
+    proveTransaction(transaction, costModel, keyMaterialProvider) {
+        return pipe(Effect.succeed(this.wasmProverProvider(keyMaterialProvider)), Effect.flatMap((provider) => Effect.tryPromise({
+            try: () => transaction.prove(provider, costModel),
+            catch: (error) => error instanceof ClientError
+                ? error
+                : new ClientError({ message: 'Failed to prove transaction', cause: error }),
+        })));
+    }
+    asProvingProvider() {
+        return this.wasmProverProvider();
+    }
+}
+export const makeDefaultKeyMaterialProvider = () => {
+    const cache = new Map();
+    const s3 = 'https://midnight-s3-fileshare-dev-eu-west-1.s3.eu-west-1.amazonaws.com';
+    const ver = 9;
+    const fetchWithRetry = async (url, retries = 5) => {
+        for (let i = 0; i < retries; i++) {
+            try {
+                return await fetch(url);
+            }
+            catch (e) {
+                // eslint-disable-next-line no-console
+                console.error('Failed to fetch at attempt', i + 1, url, e);
+                // cooldown a bit before retrying
+                await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, i + 1)));
+            }
+        }
+        throw new Error(`Failed to fetch ${url} after ${retries} attempts`);
+    };
+    const keyMaterialProvider = {
+        lookupKey: async (keyLocation) => {
+            const pth = {
+                'midnight/zswap/spend': `zswap/${ver}/spend`,
+                'midnight/zswap/output': `zswap/${ver}/output`,
+                'midnight/zswap/sign': `zswap/${ver}/sign`,
+                'midnight/dust/spend': `dust/${ver}/spend`,
+            }[keyLocation];
+            if (pth === undefined) {
+                return undefined;
+            }
+            if (cache.has(pth)) {
+                return cache.get(pth);
+            }
+            const pk = await fetchWithRetry(`${s3}/${pth}.prover`);
+            const vk = await fetchWithRetry(`${s3}/${pth}.verifier`);
+            const ir = await fetchWithRetry(`${s3}/${pth}.bzkir`);
+            const result = {
+                proverKey: new Uint8Array(await pk.arrayBuffer()),
+                verifierKey: new Uint8Array(await vk.arrayBuffer()),
+                ir: new Uint8Array(await ir.arrayBuffer()),
+            };
+            cache.set(pth, result);
+            return result;
+        },
+        getParams: async (k) => {
+            const cacheKey = `params-${k}`;
+            if (cache.has(cacheKey)) {
+                return cache.get(cacheKey);
+            }
+            const data = await fetchWithRetry(`${s3}/bls_midnight_2p${k}`);
+            const result = new Uint8Array(await data.arrayBuffer());
+            cache.set(cacheKey, result);
+            return result;
+        },
+    };
+    return keyMaterialProvider;
+};

package/dist/effect/index.d.ts

@@ -0,0 +1,3 @@
+export * as ProverClient from './ProverClient.js';
+export * as HttpProverClient from './HttpProverClient.js';
+export * as WasmProver from './WasmProver.js';

package/dist/effect/index.js

@@ -0,0 +1,15 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+export * as ProverClient from './ProverClient.js';
+export * as HttpProverClient from './HttpProverClient.js';
+export * as WasmProver from './WasmProver.js';

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { ProverClient } from './effect/index.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+/** Sends serialized unproven transactions to a Proof Server over HTTP. */
+export declare class HttpProverClient {
+    #private;
+    /**
+     * Initializes a new {@link HttpProverClient}.
+     *
+     * @param config The server configuration to use when configuring the HTTP elements of the Proof Server.
+     * @throws {@link ProverClient.InvalidProtocolSchemeError} The `config` is invalid for a HTTP context. E.g., expecting
+     *   'http:' or 'https:' URLs but something other was provided.
+     */
+    constructor(config: ProverClient.ProverClient.ServerConfig);
+    /**
+     * Proves an unproven transaction by submitting it over HTTP to an associated Proof Server.
+     *
+     * @param transaction An unproven ledger transaction.
+     * @returns A `Promise` that resolves with a proven transaction or fails with a client or server side error.
+     * @throws {@link ClientError} There was an issue with the provided `transaction`, or a connection with the configured
+     *   Proof Server could not be initiated.
+     * @throws {@link ServerError} Unable to establish a connection with the configured Proof Server, or there was an
+     *   internal error that prevented the proof request from being executed.
+     */
+    proveTransaction<S extends ledger.Signaturish, B extends ledger.Bindingish>(transaction: ledger.Transaction<S, ledger.PreProof, B>, costModel?: ledger.CostModel): Promise<ledger.Transaction<S, ledger.Proof, B>>;
+}

package/dist/index.js

@@ -0,0 +1,43 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect } from 'effect';
+import { ProverClient, HttpProverClient as _HttpProverClient } from './effect/index.js';
+/** Sends serialized unproven transactions to a Proof Server over HTTP. */
+export class HttpProverClient {
+    #innerClient;
+    /**
+     * Initializes a new {@link HttpProverClient}.
+     *
+     * @param config The server configuration to use when configuring the HTTP elements of the Proof Server.
+     * @throws {@link ProverClient.InvalidProtocolSchemeError} The `config` is invalid for a HTTP context. E.g., expecting
+     *   'http:' or 'https:' URLs but something other was provided.
+     */
+    constructor(config) {
+        this.#innerClient = Effect.gen(function* () {
+            return yield* ProverClient.ProverClient;
+        }).pipe(Effect.provide(_HttpProverClient.layer(config)), Effect.runSync);
+    }
+    /**
+     * Proves an unproven transaction by submitting it over HTTP to an associated Proof Server.
+     *
+     * @param transaction An unproven ledger transaction.
+     * @returns A `Promise` that resolves with a proven transaction or fails with a client or server side error.
+     * @throws {@link ClientError} There was an issue with the provided `transaction`, or a connection with the configured
+     *   Proof Server could not be initiated.
+     * @throws {@link ServerError} Unable to establish a connection with the configured Proof Server, or there was an
+     *   internal error that prevented the proof request from being executed.
+     */
+    proveTransaction(transaction, costModel) {
+        return this.#innerClient.proveTransaction(transaction, costModel).pipe(Effect.runPromise);
+    }
+}

package/dist/proof-worker.d.ts

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

package/dist/proof-worker.js

@@ -0,0 +1,77 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Schema } from 'effect';
+import { check, prove } from '@midnight-ntwrk/zkir-v2';
+import { GetParamsOperationResultSchema, CheckOperationSchema, ProveOperationSchema, LookupKeyOperationResultSchema, ResponseFromWorkerSchema, LookupKeyRequestSchema, GetParamsRequestSchema, } from './effect/WasmProver.js';
+const MAX_TIME_TO_PROCESS = 10 * 60 * 1000;
+const keyMaterialProvider = {
+    lookupKey(keyLocation) {
+        return new Promise((resolve, reject) => {
+            postMessage(Schema.encodeSync(LookupKeyRequestSchema)({ op: 'lookupKey', keyLocation }));
+            const subscription = ({ data }) => {
+                const decoded = Schema.decodeUnknownSync(MessageDataSchema)(data);
+                if (decoded.op === 'lookupKey' && decoded.keyLocation === keyLocation) {
+                    removeEventListener('message', subscription);
+                    resolve(decoded.result);
+                }
+            };
+            addEventListener('message', subscription);
+            setTimeout(() => reject(new Error(`Promise timed out for lookupKey: ${keyLocation}`)), MAX_TIME_TO_PROCESS);
+        });
+    },
+    getParams(k) {
+        return new Promise((resolve, reject) => {
+            postMessage(Schema.encodeSync(GetParamsRequestSchema)({ op: 'getParams', k }));
+            const subscription = ({ data }) => {
+                const decoded = Schema.decodeUnknownSync(MessageDataSchema)(data);
+                if (decoded.op === 'getParams' && decoded.k === k) {
+                    removeEventListener('message', subscription);
+                    resolve(decoded.result);
+                }
+            };
+            addEventListener('message', subscription);
+            setTimeout(() => reject(new Error(`Promise timed out for getParams: ${k}`)), MAX_TIME_TO_PROCESS);
+        });
+    },
+};
+const MessageDataSchema = Schema.Union(CheckOperationSchema, ProveOperationSchema, LookupKeyOperationResultSchema, GetParamsOperationResultSchema);
+addEventListener('message', ({ data }) => {
+    const decoded = Schema.decodeUnknownSync(MessageDataSchema)(data);
+    const { op } = decoded;
+    if (op === 'check') {
+        const [a] = decoded.args;
+        check(a, keyMaterialProvider)
+            .then((result) => {
+            postMessage(Schema.encodeSync(ResponseFromWorkerSchema)({
+                op: 'result',
+                value: result,
+            }));
+        })
+            .catch((e) => {
+            throw e;
+        });
+    }
+    else if (op === 'prove') {
+        const [a, b] = decoded.args;
+        prove(a, keyMaterialProvider, b)
+            .then((result) => {
+            postMessage(Schema.encodeSync(ResponseFromWorkerSchema)({
+                op: 'result',
+                value: result,
+            }));
+        })
+            .catch((e) => {
+            throw e;
+        });
+    }
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@midnightntwrk/wallet-sdk-prover-client",
+  "version": "1.2.3",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "Midnight Foundation",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midnightntwrk/midnight-wallet.git",
+    "directory": "packages/prover-client"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./effect": {
+      "types": "./dist/effect/index.d.ts",
+      "import": "./dist/effect/index.js"
+    }
+  },
+  "dependencies": {
+    "@effect/platform": "^0.96.0",
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
+    "@midnight-ntwrk/zkir-v2": "^2.1.0",
+    "@midnightntwrk/wallet-sdk-utilities": "^1.2.0",
+    "effect": "^3.19.19",
+    "web-worker": "^1.5.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -b ./tsconfig.json --noEmit --force",
+    "test": "vitest run",
+    "lint": "eslint --max-warnings 0",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "dist": "tsc -b ./tsconfig.build.json",
+    "dist:publish": "tsc -b ./tsconfig.publish.json",
+    "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",
+    "publint": "publint --strict"
+  }
+}