@openzeppelin/miden-multisig-client 0.16.0 → 0.16.2

package/src/multisig.ts

@@ -19,7 +19,6 @@ import type {
 import type { ProcedureName } from './procedures.js';
 import type {
   MidenClient,
-  TransactionProver,
   WasmWebClient,
 } from '@miden-sdk/miden-sdk';
 import {
@@ -29,6 +28,8 @@ import {
   Endpoint,
   FeltArray,
   Note,
+  NoteExportFormat,
+  NoteFile,
   NoteType,
   RpcClient,
   Signature,
@@ -42,6 +43,7 @@ import {
   buildUpdateProcedureThresholdTransactionRequest,
   buildUpdateGuardianTransactionRequest,
   buildConsumeNotesTransactionRequest,
+  buildP2idNoteFromMetadata,
   buildP2idTransactionRequest,
   parseP2idNoteType,
   p2idNoteTypeToMetadata,
@@ -81,6 +83,16 @@ import {
   getTransactionProver,
   requireMidenRpcEndpoint,
 } from './raw-client.js';
+import {
+  resolveProverConfig,
+  type ResolvedProverConfig,
+} from './prover/config.js';
+import { ProverWorkflow } from './prover/workflow.js';
+import {
+  resolveRpcConfig,
+  type ResolvedRpcConfig,
+} from './rpc/config.js';
+import { retryRpcRead } from './rpc/retry.js';
 
 /**
  * Result of fetching account state from GUARDIAN.
@@ -143,7 +155,8 @@ export class Multisig {
   private readonly signer: Signer;
   private readonly midenClient: MidenClient;
   private readonly rawClientPromise: Promise<WasmWebClient>;
-  private readonly transactionProver: TransactionProver | null;
+  private readonly proverWorkflow: ProverWorkflow;
+  private readonly rpcConfig: ResolvedRpcConfig;
   private readonly _accountId: string;
   private readonly midenRpcEndpoint: string;
   private proposals: Map<string, Proposal> = new Map();
@@ -155,7 +168,9 @@ export class Multisig {
     signer: Signer,
     midenClient: MidenClient,
     accountId: string | undefined,
-    midenRpcEndpoint: string
+    midenRpcEndpoint: string,
+    proverConfig?: ResolvedProverConfig,
+    rpcConfig?: ResolvedRpcConfig,
   ) {
     this.account = account;
     this.threshold = config.threshold;
@@ -170,8 +185,12 @@ export class Multisig {
     this.midenClient = midenClient;
     this._accountId = accountId ?? (account ? accountIdToHex(account) : '');
     this.midenRpcEndpoint = requireMidenRpcEndpoint(midenRpcEndpoint);
-    this.transactionProver = getTransactionProver(midenClient);
     this.rawClientPromise = getRawMidenClient(midenClient, this.midenRpcEndpoint);
+    this.proverWorkflow = new ProverWorkflow(
+      this.midenClient,
+      proverConfig ?? resolveProverConfig(undefined, getTransactionProver(midenClient)),
+    );
+    this.rpcConfig = rpcConfig ?? resolveRpcConfig(undefined);
   }
 
   private getMidenRpcEndpoint(): string {
@@ -227,7 +246,11 @@ export class Multisig {
    */
   async getStoreAccount(): Promise<Account> {
     const webClient = await this.getRawClient();
-    return (await webClient.getAccount(AccountId.fromHex(this._accountId))) ?? this.account;
+    const stored = await retryRpcRead(
+      () => webClient.getAccount(AccountId.fromHex(this._accountId)),
+      this.rpcConfig,
+    );
+    return stored ?? this.account;
   }
 
   /**
@@ -315,7 +338,10 @@ export class Multisig {
     const state = await this.fetchState();
     const accountId = AccountId.fromHex(this._accountId);
     const webClient = await this.getRawClient();
-    const localAccount = await webClient.getAccount(accountId);
+    const localAccount = await retryRpcRead(
+      () => webClient.getAccount(accountId),
+      this.rpcConfig,
+    );
     let accountForConfigRefresh: Account | null = localAccount ?? null;
 
     const guardianCommitment = normalizeHexWord(state.commitment);
@@ -340,7 +366,10 @@ export class Multisig {
   async verifyStateCommitment(): Promise<AccountStateVerificationResult> {
     const accountId = AccountId.fromHex(this._accountId);
     const webClient = await this.getRawClient();
-    const localAccount = await webClient.getAccount(accountId);
+    const localAccount = await retryRpcRead(
+      () => webClient.getAccount(accountId),
+      this.rpcConfig,
+    );
 
     if (!localAccount) {
       throw new Error(
@@ -423,7 +452,10 @@ export class Multisig {
     const rpcClient = new RpcClient(new Endpoint(this.getMidenRpcEndpoint()));
 
     try {
-      const accountDetails = await rpcClient.getAccountDetails(accountId);
+      const accountDetails = await retryRpcRead(
+        () => rpcClient.getAccountDetails(accountId),
+        this.rpcConfig,
+      );
       // If the account is not found or its commitment is zero, means that the account is not deployed yet
       if (!accountDetails) {
         return null;
@@ -949,6 +981,151 @@ export class Multisig {
     return notes;
   }
 
+  /**
+   * Export a note created by this multisig account as serialized note-file
+   * bytes for out-of-band delivery (issue #356).
+   *
+   * A private note publishes only its commitment on chain, so the recipient
+   * can never learn its contents via sync; the sender must hand them the
+   * bytes produced here, which they load with {@link importNoteFromBytes}.
+   *
+   * The note must be an output note of this client (created by a transaction
+   * this client executed). When the note's on-chain inclusion proof is
+   * already known (after a post-commit sync) the full note with proof is
+   * exported; otherwise the note details are exported and the importer's
+   * client tracks the note until it commits on chain.
+   *
+   * @param noteId - ID of the note to export (hex string)
+   * @returns Serialized note file bytes
+   */
+  async exportNoteToBytes(noteId: string): Promise<Uint8Array> {
+    const webClient = await this.getRawClient();
+    const trimmedNoteId = noteId.trim();
+
+    let record;
+    try {
+      record = await webClient.getOutputNote(trimmedNoteId);
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Output note ${trimmedNoteId} not found in the local store; only notes created by this client can be exported: ${detail}`,
+      );
+    }
+    if (!record) {
+      throw new Error(
+        `Output note ${trimmedNoteId} not found in the local store; only notes created by this client can be exported`,
+      );
+    }
+
+    const format = record.inclusionProof()
+      ? NoteExportFormat.Full
+      : NoteExportFormat.Details;
+    const noteFile = await webClient.exportNoteFile(trimmedNoteId, format);
+    return noteFile.serialize();
+  }
+
+  /**
+   * Export a note created by this multisig account as a note file downloaded
+   * by the browser (issue #356). Browser-only convenience over
+   * {@link exportNoteToBytes}; use that method directly in non-DOM
+   * environments.
+   *
+   * @param noteId - ID of the note to export (hex string)
+   * @param filename - Download filename; defaults to `note_<id>.mno`
+   */
+  async exportNoteToFile(noteId: string, filename?: string): Promise<void> {
+    if (typeof document === 'undefined') {
+      throw new Error('exportNoteToFile requires a browser environment; use exportNoteToBytes instead');
+    }
+
+    const trimmedNoteId = noteId.trim();
+    const noteBytes = await this.exportNoteToBytes(trimmedNoteId);
+
+    const blob = new Blob([noteBytes as BlobPart], { type: 'application/octet-stream' });
+    const url = URL.createObjectURL(blob);
+    try {
+      const anchor = document.createElement('a');
+      anchor.href = url;
+      anchor.download = filename ?? `note_${trimmedNoteId}.mno`;
+      anchor.click();
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+
+  /**
+   * Import a note file received out-of-band (issue #356) so the note can be
+   * consumed by this multisig account.
+   *
+   * Sync the Miden client with the network afterwards so the note's on-chain
+   * commitment is tracked and the note shows up in {@link getConsumableNotes};
+   * it can then be consumed via {@link createConsumeNotesProposal}.
+   *
+   * @param noteBytes - Serialized note file bytes produced by
+   *   {@link exportNoteToBytes}
+   * @returns The note ID when the file carries one, or the note's details
+   *   commitment for a details-only file
+   */
+  async importNoteFromBytes(noteBytes: Uint8Array): Promise<string> {
+    const webClient = await this.getRawClient();
+
+    let noteFile: NoteFile;
+    try {
+      noteFile = NoteFile.deserialize(noteBytes);
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`failed to decode note file: ${detail}`);
+    }
+
+    return webClient.importNoteFile(noteFile);
+  }
+
+  /**
+   * Import a note file received out-of-band (issue #356) from a browser
+   * `File`/`Blob` (e.g. a file-input selection). See
+   * {@link importNoteFromBytes} for the returned identifier semantics.
+   */
+  async importNoteFromFile(file: Blob): Promise<string> {
+    const noteBytes = new Uint8Array(await file.arrayBuffer());
+    return this.importNoteFromBytes(noteBytes);
+  }
+
+  /**
+   * Compute the ID of the note a P2ID proposal will create when executed.
+   *
+   * The P2ID note is rebuilt deterministically from the proposal salt, so the
+   * ID is known ahead of execution. For a private P2ID this is the ID to pass
+   * to {@link exportNoteToBytes} after executing, so the note file can be delivered
+   * to the recipient out-of-band (issue #356).
+   *
+   * Call this before executing the proposal: the asset is derived from the
+   * current vault state, which execution itself changes.
+   */
+  async getP2idNoteId(proposal: Proposal): Promise<string> {
+    const metadata = proposal.metadata;
+    if (
+      metadata.proposalType !== 'p2id' ||
+      !metadata.recipientId ||
+      !metadata.faucetId ||
+      !metadata.amount ||
+      !metadata.saltHex
+    ) {
+      throw new Error('getP2idNoteId requires a P2ID proposal with recipient, faucet, amount, and salt metadata');
+    }
+
+    const account = await this.getStoreAccount();
+    const note = buildP2idNoteFromMetadata(
+      this._accountId,
+      metadata.recipientId,
+      metadata.faucetId,
+      BigInt(metadata.amount),
+      account,
+      parseP2idNoteType(metadata.noteType),
+      metadata.saltHex,
+    );
+    return note.id().toString();
+  }
+
   /**
    * Sign a proposal.
    *
@@ -1051,7 +1228,7 @@ export class Multisig {
     const { metadata, finalRequest, proposal } = await this.prepareProposalExecution(proposalId);
 
     const accountId = AccountId.fromHex(this._accountId);
-    await this.midenClient.transactions.submit(accountId, finalRequest);
+    await this.proverWorkflow.submit(accountId, finalRequest);
 
     if (metadata.proposalType === 'switch_guardian') {
       if (!metadata.newGuardianEndpoint || !metadata.newGuardianPubkey) {
@@ -1072,15 +1249,25 @@ export class Multisig {
           ...switchDelta,
           deltaPayload: switchDelta.deltaPayload.txSummary,
         });
-      } catch {
-        // best-effort; see above
+      } catch (error) {
+        // Best-effort — see above — but the failure must be visible: a
+        // silently lost push leaves the pre-switch GUARDIAN serving this
+        // account (split-brain, issue #305) with nothing to diagnose by.
+        console.warn(
+          'SwitchGuardian delta push to the pre-switch GUARDIAN failed; it ' +
+            'will keep serving this account until reconciliation',
+          error,
+        );
       }
 
       try {
         const webClient = await this.getRawClient();
-        await webClient.syncState();
+        await retryRpcRead(() => webClient.syncState(), this.rpcConfig);
 
-        const updatedAccount = await webClient.getAccount(accountId);
+        const updatedAccount = await retryRpcRead(
+          () => webClient.getAccount(accountId),
+          this.rpcConfig,
+        );
         if (!updatedAccount) {
           throw new Error(
             `Updated account ${this._accountId} is missing from local client`
@@ -1110,7 +1297,7 @@ export class Multisig {
    * after `prepareCustomExecution` rebuilds its request with the returned advice.
    */
   async submitTransaction(request: TransactionRequest): Promise<void> {
-    await this.midenClient.transactions.submit(AccountId.fromHex(this._accountId), request);
+    await this.proverWorkflow.submit(AccountId.fromHex(this._accountId), request);
   }
 
   /**

package/src/proposal/factory.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import type { DeltaStatus } from '@openzeppelin/guardian-client';
+import { ProposalFactory } from './factory.js';
+
+describe('ProposalFactory.toStatus', () => {
+  const factory = new ProposalFactory({
+    accountId: '0x' + 'a'.repeat(30),
+    signerCommitments: [],
+    resolveRequiredSignatures: () => 2,
+  });
+  // TS `private` is compile-time only; the mapping is worth pinning
+  // without dragging a full tx summary through `fromDelta`.
+  const toStatus = (status: DeltaStatus) =>
+    (factory as unknown as { toStatus: (s: DeltaStatus, t: string, sigs: unknown[]) => string })
+      .toStatus(status, 'p2id', []);
+
+  it('maps every terminal delta status to finalized (issue #345)', () => {
+    // A retained delta left the active candidate path: no longer
+    // signable, so finalized here — whether it landed is resolved by
+    // background reconciliation via the delta status, not the proposal
+    // list.
+    expect(toStatus({ status: 'canonical', timestamp: 't' })).toBe('finalized');
+    // Cast until the published guardian-client types include `retained`.
+    expect(
+      toStatus({
+        status: 'retained',
+        timestamp: 't',
+        reason: 'retry_exhausted',
+      } as unknown as DeltaStatus),
+    ).toBe('finalized');
+    expect(toStatus({ status: 'discarded', timestamp: 't' })).toBe('finalized');
+  });
+
+  it('maps active statuses to pending/ready', () => {
+    expect(toStatus({ status: 'candidate', timestamp: 't' })).toBe('ready');
+    expect(
+      toStatus({ status: 'pending', timestamp: 't', proposerId: 'p', cosignerSigs: [] }),
+    ).toBe('pending');
+  });
+});

package/src/proposal/factory.ts

@@ -156,7 +156,11 @@ export class ProposalFactory {
     proposalType: ProposalType,
     signatures: ProposalSignatureEntry[],
   ): ProposalStatus {
-    switch (status.status) {
+    // The explicit widening keeps this compiling against published
+    // @openzeppelin/guardian-client types that predate the `retained`
+    // status (issue #345); it becomes redundant — but stays correct —
+    // once the lockfile picks up a release that includes it.
+    switch (status.status as DeltaStatus['status'] | 'retained') {
       case 'pending': {
         const signaturesRequired = this.options.resolveRequiredSignatures(proposalType);
         return signatures.length >= signaturesRequired ? 'ready' : 'pending';
@@ -164,6 +168,12 @@ export class ProposalFactory {
       case 'candidate':
         return 'ready';
       case 'canonical':
+      // A retained delta left the active candidate path (issue #345):
+      // no longer signable or submittable, so it is finalized from the
+      // proposal list's point of view. Whether its transaction landed is
+      // resolved by background reconciliation, surfaced via the delta
+      // status, not here.
+      case 'retained':
       case 'discarded':
         return 'finalized';
     }

package/src/prover/config.test.ts

@@ -0,0 +1,90 @@
+import { readFileSync } from 'node:fs';
+import type { TransactionProver } from '@miden-sdk/miden-sdk';
+import { describe, expect, it } from 'vitest';
+import { resolveProverConfig } from './config.js';
+
+interface Fixtures {
+  attemptBudgets: Array<{ input: number | null; normalized: number }>;
+  endpoints: Array<{
+    input: string;
+    valid: boolean;
+    canonical?: string;
+  }>;
+}
+
+function fixtures(): Fixtures {
+  return JSON.parse(
+    readFileSync(
+      new URL(
+        '../../../../fixtures/miden-multisig-client/prover-policy-fixtures.json',
+        import.meta.url,
+      ),
+      'utf8',
+    ),
+  ) as Fixtures;
+}
+
+describe('resolveProverConfig', () => {
+  it('matches shared URL vectors', () => {
+    for (const fixture of fixtures().endpoints) {
+      const resolve = () => resolveProverConfig({ url: fixture.input }, null);
+      if (fixture.valid) {
+        expect(resolve().url, fixture.input).toBe(fixture.canonical);
+      } else {
+        expect(resolve, fixture.input).toThrow();
+      }
+    }
+  });
+
+  it('matches shared attempt-budget vectors for remote proving', () => {
+    for (const fixture of fixtures().attemptBudgets) {
+      const retry = fixture.input === null ? undefined : { maxAttempts: fixture.input };
+      const resolved = resolveProverConfig(
+        { url: 'https://prover.example', retry },
+        null,
+      );
+      expect(resolved.maxAttempts).toBe(fixture.normalized);
+    }
+  });
+
+  it.each([-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY, 4_294_967_296])(
+    'rejects invalid maxAttempts value %s',
+    (maxAttempts) => {
+      expect(() =>
+        resolveProverConfig(
+          { url: 'https://prover.example', retry: { maxAttempts } },
+          null,
+        ),
+      ).toThrow('prover.retry.maxAttempts');
+    },
+  );
+
+  it('keeps an endpoint-less injected prover at one attempt without serializing it', () => {
+    const serialize = () => {
+      throw new Error('callback provers cannot be serialized');
+    };
+    const callback = {
+      endpoint: () => undefined,
+      serialize,
+    } as unknown as TransactionProver;
+
+    expect(resolveProverConfig({ retry: { maxAttempts: 5 } }, callback)).toMatchObject({
+      kind: 'injected',
+      maxAttempts: 1,
+    });
+  });
+
+  it('lets a custom remote URL override an injected local prover', () => {
+    const local = {
+      serialize: () => 'local',
+      endpoint: () => undefined,
+    } as unknown as TransactionProver;
+    expect(
+      resolveProverConfig({ url: 'https://prover.example' }, local),
+    ).toMatchObject({
+      kind: 'remote',
+      url: 'https://prover.example/',
+      maxAttempts: 2,
+    });
+  });
+});

package/src/prover/config.ts

@@ -0,0 +1,78 @@
+import { TransactionProver } from '@miden-sdk/miden-sdk';
+
+export interface ProverRetryPolicy {
+  maxAttempts?: number;
+}
+
+export interface ProverConfig {
+  url?: string;
+  retry?: ProverRetryPolicy;
+}
+
+export interface ResolvedProverConfig {
+  readonly kind: 'injected' | 'remote';
+  readonly url?: string;
+  readonly maxAttempts: number;
+  createProver(): TransactionProver | undefined;
+}
+
+const DEFAULT_MAX_ATTEMPTS = 2;
+const MAX_U32 = 4_294_967_295;
+
+function normalizeMaxAttempts(value: number | undefined): number {
+  if (value === undefined) {
+    return DEFAULT_MAX_ATTEMPTS;
+  }
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0 || value > MAX_U32) {
+    throw new Error('prover.retry.maxAttempts must be an integer between 0 and 4294967295');
+  }
+  return Math.max(1, value);
+}
+
+function normalizeUrl(value: string): string {
+  const trimmed = value.trim();
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error('prover.url must be an absolute HTTP(S) URL with a host');
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol) || parsed.hostname === '') {
+    throw new Error('prover.url must be an absolute HTTP(S) URL with a host');
+  }
+  return parsed.href;
+}
+
+export function resolveProverConfig(
+  config: ProverConfig | undefined,
+  defaultProver: TransactionProver | null,
+): ResolvedProverConfig {
+  const maxAttempts = normalizeMaxAttempts(config?.retry?.maxAttempts);
+
+  if (config?.url !== undefined) {
+    const url = normalizeUrl(config.url);
+    return {
+      kind: 'remote',
+      url,
+      maxAttempts,
+      createProver: () => TransactionProver.newRemoteProver(url),
+    };
+  }
+
+  const endpoint = defaultProver?.endpoint();
+  if (defaultProver === null || endpoint === undefined) {
+    return {
+      kind: 'injected',
+      maxAttempts: 1,
+      createProver: () => undefined,
+    };
+  }
+
+  const descriptor = defaultProver.serialize();
+  return {
+    kind: 'remote',
+    url: endpoint,
+    maxAttempts,
+    createProver: () => TransactionProver.deserialize(descriptor),
+  };
+}

package/src/prover/errors.test.ts

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { isTransientProverError } from './errors.js';
+
+interface FixtureError {
+  code?: string;
+  status?: number;
+  message: string;
+  cause?: FixtureError;
+}
+
+interface Fixtures {
+  classifications: Array<{
+    name: string;
+    chain: FixtureError[];
+    transient: boolean;
+  }>;
+}
+
+function fixtures(): Fixtures {
+  return JSON.parse(
+    readFileSync(
+      new URL(
+        '../../../../fixtures/miden-multisig-client/prover-policy-fixtures.json',
+        import.meta.url,
+      ),
+      'utf8',
+    ),
+  ) as Fixtures;
+}
+
+describe('isTransientProverError', () => {
+  it('matches every shared classification vector', () => {
+    for (const fixture of fixtures().classifications) {
+      const error = fixture.chain.reduceRight<FixtureError | undefined>(
+        (cause, item) => ({ ...item, cause }),
+        undefined,
+      );
+      expect(isTransientProverError(error), fixture.name).toBe(fixture.transient);
+    }
+  });
+
+  it('stops safely on cyclic cause graphs', () => {
+    const error: FixtureError = { code: 'Unknown', message: 'not retryable' };
+    error.cause = error;
+    expect(isTransientProverError(error)).toBe(false);
+  });
+
+  it('recognizes numeric gRPC status codes', () => {
+    expect(isTransientProverError({ code: 14, message: 'unavailable' })).toBe(true);
+    expect(isTransientProverError({ code: 3, message: 'timeout text' })).toBe(false);
+  });
+
+  it('reads grpc code wording out of plain message text', () => {
+    expect(isTransientProverError(new Error('grpc code: NotFound'))).toBe(false);
+    expect(
+      isTransientProverError(new Error('grpc code: Internal; nested timeout')),
+    ).toBe(false);
+    expect(isTransientProverError(new Error('grpc code: Unavailable'))).toBe(true);
+  });
+});

package/src/prover/errors.ts

@@ -0,0 +1,10 @@
+import { isTransientError } from '../retry/classify.js';
+
+/**
+ * Prover-policy classification: the shared classifier with no transport-text
+ * extras — a bare "connection error" from a prover is treated as its
+ * considered answer.
+ */
+export function isTransientProverError(error: unknown): boolean {
+  return isTransientError(error);
+}

package/src/prover/retry.test.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import { retryDelay } from '../retry/runtime.js';
+
+interface Fixtures {
+  delays: Array<{ retryIndex: number; unitRandom: number; delayMs: number }>;
+}
+
+function fixtures(): Fixtures {
+  return JSON.parse(
+    readFileSync(
+      new URL(
+        '../../../../fixtures/miden-multisig-client/prover-policy-fixtures.json',
+        import.meta.url,
+      ),
+      'utf8',
+    ),
+  ) as Fixtures;
+}
+
+describe('retryDelay', () => {
+  it('matches every shared delay vector', () => {
+    for (const fixture of fixtures().delays) {
+      expect(retryDelay(fixture.retryIndex, fixture.unitRandom)).toBe(fixture.delayMs);
+    }
+  });
+
+  it('remains capped after numeric overflow', () => {
+    expect(retryDelay(Number.MAX_SAFE_INTEGER, 0.5)).toBe(8_000);
+  });
+
+  it.each([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])(
+    'uses neutral jitter for non-finite randomness',
+    (unitRandom) => {
+      expect(retryDelay(0, unitRandom)).toBe(500);
+    },
+  );
+});

package/src/prover/retry.ts

@@ -0,0 +1,21 @@
+import type { TransactionExecution, TransactionProof } from '@miden-sdk/miden-sdk';
+import type { ResolvedProverConfig } from './config.js';
+import { isTransientProverError } from './errors.js';
+import type { RetryRuntime } from '../retry/runtime.js';
+import { productionRetryRuntime, retryTransient } from '../retry/runtime.js';
+
+export async function proveWithRetry(
+  execution: TransactionExecution,
+  config: ResolvedProverConfig,
+  runtime: RetryRuntime = productionRetryRuntime,
+): Promise<TransactionProof> {
+  return retryTransient(
+    async () => {
+      const prover = config.createProver();
+      return prover === undefined ? await execution.prove() : await execution.prove({ prover });
+    },
+    config.maxAttempts,
+    isTransientProverError,
+    runtime,
+  );
+}