@midnight-ntwrk/wallet-sdk-prover-client 2.0.0-beta.2 → 2.0.0-beta.3

package/README.md

@@ -57,6 +57,34 @@ class HttpProverClient {
 }
 ```
 
+### Proving providers, per ledger version
+
+A proof preimage is produced by the ledger version that built the transaction, and the request carrying it has to be
+framed and read back by that same version. `HttpProverClient` therefore offers one provider per ledger version:
+
+```typescript
+const client = await Effect.runPromise(HttpProverClient.create({ url: proofServerUrl }));
+
+client.asV9ProvingProvider(); // frames with @midnightntwrk/ledger-v9; asProvingProvider() is the same provider
+client.asV8ProvingProvider(); // frames with @midnight-ntwrk/ledger-v8
+```
+
+`WasmProver` offers both names too, and returns the same provider for each: the in-process prover drives a zkir runtime
+over bytes and never looks at a ledger version.
+
+Its key material is read from a published bucket, one line per circuit generation rather than per ledger:
+
+```typescript
+WasmProver.makeDefaultKeyMaterialProvider(); // the line both ledger versions accept
+WasmProver.makeDefaultKeyMaterialProvider({ circuits: 8 }); // an explicit override
+```
+
+The default is what both ledger versions accept today; `circuits` exists so an operator whose bucket says otherwise can
+say so, not because a fork implies a change of line.
+
+> This package depends on both ledger runtimes, `@midnight-ntwrk/ledger-v8` and `@midnightntwrk/ledger-v9`. Both are
+> WASM modules, so a direct consumer bundling this package ships both.
+
 ## Exports
 
 ### Default Export

package/dist/effect/HttpProverClient.js

@@ -15,9 +15,20 @@ import { FetchHttpClient, HttpBody, HttpClient, HttpClientRequest } from '@effec
 import { ProverClient } from './ProverClient.js';
 import { ClientError, HttpURL, ServerError, } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
 import { BlobOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
-import * as ledger from '@midnightntwrk/ledger-v9';
+import * as ledgerV8 from '@midnight-ntwrk/ledger-v8';
+import * as ledgerV9 from '@midnightntwrk/ledger-v9';
 const PROVE_TX_PATH = '/prove';
 const CHECK_TX_PATH = '/check';
+const v9Framing = {
+    createProvingPayload: (preimage, binding) => ledgerV9.createProvingPayload(preimage, binding),
+    createCheckPayload: (preimage) => ledgerV9.createCheckPayload(preimage),
+    parseCheckResult: (result) => ledgerV9.parseCheckResult(result),
+};
+const v8Framing = {
+    createProvingPayload: (preimage, binding) => ledgerV8.createProvingPayload(preimage, binding),
+    createCheckPayload: (preimage) => ledgerV8.createCheckPayload(preimage),
+    parseCheckResult: (result) => ledgerV8.parseCheckResult(result),
+};
 /**
  * Creates a layer for a {@link ProverClient} that sends requests to a Proof Server over HTTP.
  *
@@ -65,15 +76,15 @@ class HttpProverClientImpl {
             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),
+    serverProverProvider = (framing) => ({
+        check: async (serializedPreimage, _keyLocation) => pipe(Effect.succeed(framing.createCheckPayload(serializedPreimage)), Effect.flatMap((tx) => this.request(CHECK_TX_PATH, tx, 'Failed to check')), Effect.map((response) => framing.parseCheckResult(response)), Effect.runPromise),
+        prove: async (serializedPreimage, _keyLocation, overwriteBindingInput) => pipe(Effect.succeed(framing.createProvingPayload(serializedPreimage, overwriteBindingInput)), Effect.flatMap((tx) => this.request(PROVE_TX_PATH, tx, 'Failed to prove')), Effect.runPromise),
         // The proof server holds its own key material and resolves circuits from the
         // preimage's key location, so there is never local key material to provide.
         lookupKey: (_keyLocation) => Promise.resolve(undefined),
     });
     proveTransaction(transaction, costModel) {
-        return pipe(Effect.succeed(this.serverProverProvider()), Effect.flatMap((provider) => Effect.tryPromise({
+        return pipe(Effect.succeed(this.serverProverProvider(v9Framing)), Effect.flatMap((provider) => Effect.tryPromise({
             try: () => transaction.prove(provider, costModel),
             catch: (error) => error instanceof ClientError || error instanceof ServerError
                 ? error
@@ -81,6 +92,12 @@ class HttpProverClientImpl {
         })));
     }
     asProvingProvider() {
-        return this.serverProverProvider();
+        return this.serverProverProvider(v9Framing);
+    }
+    asV9ProvingProvider() {
+        return this.asProvingProvider();
+    }
+    asV8ProvingProvider() {
+        return this.serverProverProvider(v8Framing);
     }
 }

package/dist/effect/ProverClient.d.ts

@@ -1,5 +1,6 @@
 import { type Effect, Context } from 'effect';
-import type * as ledger from '@midnightntwrk/ledger-v9';
+import type * as ledgerV8 from '@midnight-ntwrk/ledger-v8';
+import type * as ledgerV9 from '@midnightntwrk/ledger-v9';
 import { type ClientError, type ServerError } from '@midnight-ntwrk/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>;
@@ -25,8 +26,21 @@ export declare namespace ProverClient {
          * @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;
+        proveTransaction<S extends ledgerV9.Signaturish, B extends ledgerV9.Bindingish>(tx: ledgerV9.Transaction<S, ledgerV9.PreProof, B>, costModel?: ledgerV9.CostModel): Effect.Effect<ledgerV9.Transaction<S, ledgerV9.Proof, B>, ClientError | ServerError>;
+        /** A proving provider that frames its requests with ledger-v9. */
+        asProvingProvider(): ledgerV9.ProvingProvider;
+        /** The same provider as {@link asProvingProvider}, named for the ledger version it frames with. */
+        asV9ProvingProvider(): ledgerV9.ProvingProvider;
+        /**
+         * A proving provider that frames its requests with ledger-v8.
+         *
+         * @remarks
+         *   A preimage is produced by the ledger version that built the transaction, and has to be framed and read back by
+         *   that same version — so a client serving a ledger-v8 transaction is asked for this provider rather than the
+         *   other. An in-process prover has nothing to distinguish: it works on bytes, and offers the same provider for
+         *   both.
+         */
+        asV8ProvingProvider(): ledgerV8.ProvingProvider;
     }
 }
 export {};

package/dist/effect/WasmProver.d.ts

@@ -44,4 +44,17 @@ export declare const GetParamsOperationResultSchema: Schema.Struct<{
     k: typeof Schema.Number;
     result: typeof Schema.Uint8Array;
 }>;
-export declare const makeDefaultKeyMaterialProvider: () => KeyMaterialProvider;
+/** Which line of the key-material bucket to read: the circuits the keys were generated for. */
+export type KeyMaterialConfig = {
+    /**
+     * The circuit line to read.
+     *
+     * @remarks
+     *   Not a ledger version, despite reading like one. Line 9 is what both ledger versions the SDK carries accept today —
+     *   ledger-v8's own line predates the zkir runtime they share and its verifier keys are rejected outright — which is
+     *   why it is the default on both sides. The setting exists so an operator whose bucket says otherwise can say so,
+     *   not because a fork implies a change of line.
+     */
+    circuits?: 8 | 9;
+};
+export declare const makeDefaultKeyMaterialProvider: (config?: KeyMaterialConfig) => KeyMaterialProvider;

package/dist/effect/WasmProver.js

@@ -142,11 +142,25 @@ class WasmProverImpl {
     asProvingProvider() {
         return this.wasmProverProvider();
     }
+    /**
+     * The same provider {@link asProvingProvider} returns.
+     *
+     * @remarks
+     *   The in-process prover drives a zkir runtime over bytes and never looks at a ledger version, so there is nothing for
+     *   a ledger-v8 variant to do differently. It is offered under both names because the caller choosing a backend for
+     *   an epoch should not have to know which backends care about the epoch and which do not.
+     */
+    asV9ProvingProvider() {
+        return this.wasmProverProvider();
+    }
+    asV8ProvingProvider() {
+        return this.wasmProverProvider();
+    }
 }
-export const makeDefaultKeyMaterialProvider = () => {
+export const makeDefaultKeyMaterialProvider = (config) => {
     const cache = new Map();
     const s3 = 'https://midnight-s3-fileshare-dev-eu-west-1.s3.eu-west-1.amazonaws.com';
-    const ver = 9;
+    const ver = config?.circuits ?? 9;
     const fetchWithRetry = async (url, retries = 5) => {
         for (let i = 0; i < retries; i++) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-prover-client",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.3",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -31,9 +31,10 @@
   },
   "dependencies": {
     "@effect/platform": "^0.96.0",
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
     "@midnight-ntwrk/zkir-v2": "^2.1.0",
-    "@midnightntwrk/ledger-v9": "1.0.0-rc.3",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.2.0",
+    "@midnightntwrk/ledger-v9": "1.0.0-rc.4",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.2.2-beta.0",
     "effect": "^3.19.19",
     "web-worker": "^1.5.0"
   },