@openzeppelin/miden-multisig-client 0.18.0-rc.1 → 0.18.0-rc.3

package/src/transaction/summary.ts

@@ -1,12 +1,8 @@
-import type {
-  MidenClient,
-  TransactionRequest,
-  TransactionSummary,
-  WasmWebClient,
-} from '@miden-sdk/miden-sdk';
-import { AccountId, ChainAnchor, Word } from '@miden-sdk/miden-sdk';
-import { getRawMidenClient } from '../raw-client.js';
+import type { MidenClient, TransactionRequest, TransactionSummary } from '@miden-sdk/miden-sdk';
+import { ChainAnchor, Word } from '@miden-sdk/miden-sdk';
+import { BoundBlockNotDeclaredError } from '../multisig/authArgErrors.js';
 import { base64ToUint8Array, normalizeHexWord, uint8ArrayToBase64 } from '../utils/encoding.js';
+import { requestBoundBlockNum } from './authArgs.js';
 
 /**
  * Layout of the six user params a multisig auth component binds into the
@@ -37,42 +33,61 @@ export class SummaryAnchorMismatchError extends Error {
 }
 
 /**
- * Captures a `ChainAnchor` for the request at the current sync height and
- * executes the transaction against it to obtain the summary awaiting
- * authorization. The anchor is returned alongside the summary so the proposer
- * can ship it with the signed data; cosigners and the executor then reproduce
- * the summary with {@link executeForSummaryAt} regardless of their own sync
- * height.
+ * The Miden client synced and its node still has not produced the block a
+ * proposal binds, so the proposal cannot execute at this client's tip yet.
+ * Worth retrying once the node catches up.
+ */
+export class ChainBehindBoundBlockError extends Error {
+  readonly retryable = true;
+  readonly syncHeight: number;
+  readonly boundBlockNum: number;
+
+  constructor(details: { syncHeight: number; boundBlockNum: number }) {
+    super(
+      `the Miden client synced to block ${details.syncHeight}, below block ` +
+        `${details.boundBlockNum} the proposal binds; its node has not reached that block yet`,
+    );
+    this.name = 'ChainBehindBoundBlockError';
+    this.syncHeight = details.syncHeight;
+    this.boundBlockNum = details.boundBlockNum;
+  }
+}
+
+/**
+ * Whether a failed re-execution came from chain state this client can catch up
+ * with rather than from the proposal itself: a node that has not reached the
+ * bound block yet, or account state the node pruned because this client had
+ * not synced recently. Either clears on a later attempt, which syncs first.
+ */
+export function isStaleChainError(error: unknown): boolean {
+  if (error instanceof ChainBehindBoundBlockError) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes('has been pruned');
+}
+
+/**
+ * Derives the summary awaiting authorization for a proposal the caller is
+ * creating now, and captures a `ChainAnchor` at the current sync height to ship
+ * with it.
  *
- * The request's auth args bind the block its summary commits to, and this
- * package pins that block to the anchor: a proposer builds at the sync height
- * the anchor is captured at, and a rebuild passes the anchor's block number.
- * The check below is what makes the first half hold.
+ * The summary is derived at the chain tip, like every other execution of a
+ * multisig proposal (see {@link executeForSummaryAtTip}). The anchor still
+ * travels in the proposal: it names the block the request's auth args bind,
+ * which is how a rebuild learns that block, and 0.18.0-rc.1 clients re-execute
+ * at it. A proposer builds at the sync height the anchor is captured at, and
+ * the check below is what makes that hold.
  */
-export function executeForSummary(
-  client: MidenClient,
-  accountId: string,
-  txRequest: TransactionRequest,
-  midenRpcEndpoint: string,
-): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }>;
-export function executeForSummary(
-  client: WasmWebClient,
-  accountId: string,
-  txRequest: TransactionRequest,
-  midenRpcEndpoint?: string,
-): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }>;
 export async function executeForSummary(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   accountId: string,
   txRequest: TransactionRequest,
-  midenRpcEndpoint?: string,
 ): Promise<{ summary: TransactionSummary; anchor: ChainAnchor }> {
-  const acc = AccountId.fromHex(accountId);
-  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  const anchor = await rawClient.chainAnchorForRequest(txRequest);
+  const anchor = await client.transactions.captureAnchor(txRequest);
   let summary: TransactionSummary;
   try {
-    summary = await rawClient.executeForSummaryAt(acc, txRequest, anchor);
+    summary = await executeForSummaryAtTip(client, accountId, txRequest);
   } catch (error) {
     anchor.free();
     throw error;
@@ -92,35 +107,122 @@ export async function executeForSummary(
 }
 
 /**
- * Executes a transaction at the given `ChainAnchor`'s reference block to
- * obtain the summary awaiting authorization: the anchored counterpart of
- * {@link executeForSummary} for cosigners and executors holding a proposal's
- * anchor.
+ * Executes a multisig request at the chain tip to obtain the summary awaiting
+ * authorization. This is how cosigners and the executor reproduce a proposal's
+ * summary, whatever block they have synced to.
+ *
+ * Since protocol 0.17 a multisig summary binds the block its auth args name
+ * (the bound block), not the block the transaction executes against, so it
+ * reproduces at any later tip once the bound block is in the transaction's
+ * partial blockchain. The request declares it through `withBlockNumbers`, and
+ * foreign accounts, the fee faucet among them, load at the tip. Re-executing at
+ * the proposal's anchor instead loads them at the bound block, which a node
+ * prunes about 50 blocks later (issue #462).
+ *
+ * The client has to have synced to at least the bound block. When it has not,
+ * this syncs once before executing.
+ *
+ * @throws BoundBlockNotDeclaredError when the request binds a block in its
+ *   multisig auth args without declaring it.
  */
-export function executeForSummaryAt(
+export async function executeForSummaryAtTip(
   client: MidenClient,
   accountId: string,
   txRequest: TransactionRequest,
-  anchor: ChainAnchor,
-  midenRpcEndpoint: string,
-): Promise<TransactionSummary>;
-export function executeForSummaryAt(
-  client: WasmWebClient,
-  accountId: string,
-  txRequest: TransactionRequest,
-  anchor: ChainAnchor,
-  midenRpcEndpoint?: string,
-): Promise<TransactionSummary>;
+): Promise<TransactionSummary> {
+  await prepareTipExecution(client, txRequest);
+  return client.transactions.preview({
+    operation: 'custom',
+    account: accountId,
+    request: txRequest,
+  });
+}
+
+/**
+ * Gets `client` ready to execute `request` at the chain tip: checks the
+ * request declares the block its multisig auth args bind, and syncs to that
+ * block (see {@link syncToBoundBlock}).
+ *
+ * @throws BoundBlockNotDeclaredError when the request binds a block in its
+ *   multisig auth args without declaring it.
+ */
+export async function prepareTipExecution(
+  client: MidenClient,
+  request: TransactionRequest,
+  syncChain?: () => Promise<unknown>,
+): Promise<void> {
+  const boundBlockNum = requireDeclaredBoundBlock(request);
+  if (boundBlockNum !== undefined) {
+    await syncToBoundBlock(client, boundBlockNum, syncChain);
+  }
+}
+
+/**
+ * The block `request`'s multisig auth args bind, after checking the request
+ * declares it. `undefined` for a request without multisig auth args, which
+ * has no bound block to declare.
+ *
+ * @throws BoundBlockNotDeclaredError when the block is bound but not declared.
+ */
+export function requireDeclaredBoundBlock(request: TransactionRequest): number | undefined {
+  const boundBlockNum = requestBoundBlockNum(request);
+  if (boundBlockNum !== undefined && !request.blockNumbers().includes(boundBlockNum)) {
+    throw new BoundBlockNotDeclaredError(boundBlockNum);
+  }
+  return boundBlockNum;
+}
+
+/**
+ * Syncs `client` once when its sync height is below `blockNum`, the block a
+ * proposal binds. Execution at a tip below it fails with "requested block N is
+ * after transaction reference block M", and a store that has never synced (a
+ * cosigner that has only just loaded the account) holds no header to rebuild
+ * the request from. The sync is a chain sync; `syncChain` lets a caller wrap
+ * it in its own retry policy.
+ *
+ * This does not make a store that is already past the bound block current. An
+ * execution loads foreign accounts, the fee faucet among them, at the store's
+ * sync height, which a node prunes about 50 blocks later, so the multisig
+ * entry points that re-execute a proposal sync the chain first.
+ *
+ * @throws ChainBehindBoundBlockError when the node has not reached the block.
+ */
+export async function syncToBoundBlock(
+  client: MidenClient,
+  blockNum: number,
+  syncChain: () => Promise<unknown> = () => client.syncChain(),
+): Promise<void> {
+  if ((await client.getSyncHeight()) >= blockNum) {
+    return;
+  }
+  await syncChain();
+  const syncHeight = await client.getSyncHeight();
+  if (syncHeight < blockNum) {
+    throw new ChainBehindBoundBlockError({ syncHeight, boundBlockNum: blockNum });
+  }
+}
+
+/**
+ * Executes a transaction at the given `ChainAnchor`'s reference block to
+ * obtain the summary awaiting authorization.
+ *
+ * For a summary that binds the reference block, such as a single-signature
+ * one. A multisig proposal's summary binds its bound block instead and is
+ * reproduced with {@link executeForSummaryAtTip}: re-executing it at an anchor
+ * fails once the node prunes the anchor block's account state.
+ */
 export async function executeForSummaryAt(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   accountId: string,
   txRequest: TransactionRequest,
   anchor: ChainAnchor,
-  midenRpcEndpoint?: string,
 ): Promise<TransactionSummary> {
-  const acc = AccountId.fromHex(accountId);
-  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  return rawClient.executeForSummaryAt(acc, txRequest, anchor);
+  return client.transactions.preview({
+    operation: 'custom',
+    account: accountId,
+    request: txRequest,
+    anchor,
+  });
 }
 
 /**
@@ -134,7 +236,8 @@ export function chainAnchorToBase64(anchor: ChainAnchor): string {
  * Deserializes a `ChainAnchor` from its base64 wire form. `ChainAnchor`
  * deserialization validates the header/chain consistency internally, so a
  * decoded anchor only needs its block commitment checked against the signed
- * transaction summary before it is safe to execute against.
+ * transaction summary before the block it names is taken as the one the
+ * summary binds.
  */
 export function chainAnchorFromBase64(anchorBase64: string): ChainAnchor {
   return ChainAnchor.deserialize(base64ToUint8Array(anchorBase64));

package/src/transaction/updateGuardian.ts

@@ -2,21 +2,18 @@ import {
   type MidenClient,
   TransactionRequest,
   TransactionScript,
-  type WasmWebClient,
   Word,
 } from '@miden-sdk/miden-sdk';
-import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { authSchemeId } from '../utils/signature.js';
 import { buildMultisigRequest, multisigRequestBuilder } from './authArgs.js';
-import type { MidenClientMultisigRequestOptions, MultisigRequestOptions } from './options.js';
+import type { MultisigRequestOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 async function buildUpdateGuardianScript(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   newGuardianPubkey: string,
   signatureScheme: SignatureScheme,
-  midenRpcEndpoint?: string,
 ): Promise<TransactionScript> {
   // A word literal preserves the key's element order on the operand stack.
   const keyLiteral = normalizeHexWord(newGuardianPubkey);
@@ -36,31 +33,16 @@ pub proc main
 end
   `;
 
-  return compileTxScript(client, scriptSource, [], midenRpcEndpoint);
+  return client.compile.txScript({ code: scriptSource });
 }
 
-export function buildUpdateGuardianTransactionRequest(
-  client: MidenClient,
-  newGuardianPubkey: string,
-  options: MidenClientMultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
-export function buildUpdateGuardianTransactionRequest(
-  client: WasmWebClient,
-  newGuardianPubkey: string,
-  options: MultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
 export async function buildUpdateGuardianTransactionRequest(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   newGuardianPubkey: string,
   options: MultisigRequestOptions,
 ): Promise<{ request: TransactionRequest; salt: Word }> {
   const signatureScheme = options.signatureScheme ?? 'falcon';
-  const script = await buildUpdateGuardianScript(
-    client,
-    newGuardianPubkey,
-    signatureScheme,
-    options.midenRpcEndpoint,
-  );
+  const script = await buildUpdateGuardianScript(client, newGuardianPubkey, signatureScheme);
 
   const { builder, saltHex } = await multisigRequestBuilder(client, options);
   let txBuilder = builder.withCustomScript(script);

package/src/transaction/updateProcedureThreshold.ts

@@ -5,15 +5,13 @@ import {
   Poseidon2,
   TransactionRequest,
   TransactionScript,
-  type WasmWebClient,
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
 import { getProcedureRoot, type ProcedureName } from '../procedures.js';
-import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { buildMultisigRequest, multisigRequestBuilder } from './authArgs.js';
-import type { MidenClientMultisigRequestOptions, MultisigRequestOptions } from './options.js';
+import type { MultisigRequestOptions } from './options.js';
 
 function buildProcedureThresholdFelts(procedure: ProcedureName, threshold: number): Felt[] {
   const procedureRoot = WordType.fromHex(normalizeHexWord(getProcedureRoot(procedure)));
@@ -38,10 +36,9 @@ function buildProcedureThresholdConfigHash(procedure: ProcedureName, threshold:
 }
 
 async function buildUpdateProcedureThresholdScript(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   procedure: ProcedureName,
   threshold: number,
-  midenRpcEndpoint?: string,
 ): Promise<TransactionScript> {
   const procedureRoot = normalizeHexWord(getProcedureRoot(procedure));
 
@@ -58,35 +55,18 @@ pub proc main
 end
   `;
 
-  return compileTxScript(client, scriptSource, [], midenRpcEndpoint);
+  return client.compile.txScript({ code: scriptSource });
 }
 
-export function buildUpdateProcedureThresholdTransactionRequest(
-  client: MidenClient,
-  procedure: ProcedureName,
-  threshold: number,
-  options: MidenClientMultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
-export function buildUpdateProcedureThresholdTransactionRequest(
-  client: WasmWebClient,
-  procedure: ProcedureName,
-  threshold: number,
-  options: MultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
 export async function buildUpdateProcedureThresholdTransactionRequest(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   procedure: ProcedureName,
   threshold: number,
   options: MultisigRequestOptions,
 ): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }> {
   const configHash = buildProcedureThresholdConfigHash(procedure, threshold);
 
-  const script = await buildUpdateProcedureThresholdScript(
-    client,
-    procedure,
-    threshold,
-    options.midenRpcEndpoint,
-  );
+  const script = await buildUpdateProcedureThresholdScript(client, procedure, threshold);
   const { builder, saltHex } = await multisigRequestBuilder(client, options);
   let txBuilder = builder.withCustomScript(script);
 

package/src/transaction/updateSigners.ts

@@ -6,15 +6,13 @@ import {
   Poseidon2,
   TransactionRequest,
   TransactionScript,
-  type WasmWebClient,
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
-import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { authSchemeId } from '../utils/signature.js';
 import { buildMultisigRequest, multisigRequestBuilder } from './authArgs.js';
-import type { MidenClientMultisigRequestOptions, MultisigRequestOptions } from './options.js';
+import type { MultisigRequestOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
 function buildMultisigConfigFelts(
@@ -56,10 +54,7 @@ export function buildMultisigConfigAdvice(
   return { configHash, payload };
 }
 
-async function buildUpdateSignersScript(
-  client: MidenClient | WasmWebClient,
-  midenRpcEndpoint?: string,
-): Promise<TransactionScript> {
+async function buildUpdateSignersScript(client: MidenClient): Promise<TransactionScript> {
   const scriptSource = `
 use miden::standards::auth::multisig
 
@@ -69,23 +64,11 @@ pub proc main
 end
   `;
 
-  return compileTxScript(client, scriptSource, [], midenRpcEndpoint);
+  return client.compile.txScript({ code: scriptSource });
 }
 
-export function buildUpdateSignersTransactionRequest(
-  client: MidenClient,
-  threshold: number,
-  signerCommitments: string[],
-  options: MidenClientMultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
-export function buildUpdateSignersTransactionRequest(
-  client: WasmWebClient,
-  threshold: number,
-  signerCommitments: string[],
-  options: MultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }>;
 export async function buildUpdateSignersTransactionRequest(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   threshold: number,
   signerCommitments: string[],
   options: MultisigRequestOptions,
@@ -112,7 +95,7 @@ export async function buildUpdateSignersTransactionRequest(
   const advice = new AdviceMap();
   advice.insert(configHashForAdvice, payload);
 
-  const script = await buildUpdateSignersScript(client, options.midenRpcEndpoint);
+  const script = await buildUpdateSignersScript(client);
 
   const { builder, saltHex } = await multisigRequestBuilder(client, options);
   let txBuilder = builder

package/src/transaction.ts

@@ -10,11 +10,17 @@ export {
   buildConsumeNotesTransactionRequestFromNotes,
 } from './transaction/consumeNotes.js';
 export {
+  ChainBehindBoundBlockError,
   chainAnchorBlockNum,
   chainAnchorFromBase64,
   chainAnchorToBase64,
   executeForSummary,
   executeForSummaryAt,
+  executeForSummaryAtTip,
+  prepareTipExecution,
+  isStaleChainError,
+  requireDeclaredBoundBlock,
+  syncToBoundBlock,
   summaryApprovalExpirationBlockNum,
   summarySalt,
   SummaryAnchorMismatchError,

package/src/types/proposal.ts

@@ -38,11 +38,11 @@ interface BaseProposalMetadata {
   saltHex?: string;
   requiredSignatures?: number;
   /**
-   * Base64-serialized Miden `ChainAnchor` pinning the reference block the
-   * proposal's transaction summary was built at. Required to verify or
-   * execute the proposal: since protocol 0.16 the signed summary binds the
-   * reference block commitment, so it only reproduces when re-executed at
-   * that block.
+   * Base64-serialized Miden `ChainAnchor` at the block the proposal's
+   * transaction summary binds, the proposer's sync height when it built the
+   * request. Required, and checked against the summary's block commitment: a
+   * rebuild binds the block it names. The proposal executes at the chain tip,
+   * not at the anchor; 0.18.0-rc.1 clients still re-execute at it.
    */
   chainAnchor?: string;
 }
@@ -175,9 +175,10 @@ export interface Proposal {
 /**
  * Outcome of checking a proposal's metadata against its signed summary.
  * `failed.retryable` is true when the failure came from a transient node or
- * RPC error, so the same proposal may verify on a later sync; false when the
- * proposal itself cannot be reproduced (tampered metadata, an anchor block the
- * node has pruned) and it has to be re-proposed.
+ * RPC error, or from chain state this client had not caught up with, so the
+ * same proposal may verify on a later sync; false when the proposal itself
+ * cannot be reproduced (tampered metadata, for example) and it has to be
+ * re-proposed.
  */
 export type ProposalVerification =
   | { status: 'unchecked' }

package/dist/raw-client.d.ts

@@ -1,14 +0,0 @@
-import { MidenClient, type TransactionProver, type TransactionScript, WasmWebClient } from '@miden-sdk/miden-sdk';
-export type RawClientSource = MidenClient | WasmWebClient;
-export interface ScriptLibrarySource {
-    namespace: string;
-    code: string;
-    linking?: 'dynamic' | 'static';
-}
-export declare function requireConfigValue(field: string, value?: unknown): string;
-export declare function requireMidenRpcEndpoint(endpoint?: string): string;
-export declare function isPublicMidenClient(client: RawClientSource): client is MidenClient;
-export declare function getRawMidenClient(client: RawClientSource, rpcUrl?: string): Promise<WasmWebClient>;
-export declare function getTransactionProver(client: RawClientSource): TransactionProver | null;
-export declare function compileTxScript(client: RawClientSource, code: string, libraries?: ScriptLibrarySource[], rpcUrl?: string): Promise<TransactionScript>;
-//# sourceMappingURL=raw-client.d.ts.map

package/dist/raw-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"raw-client.d.ts","sourceRoot":"","sources":["../src/raw-client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,aAAa,CAAC;AAC1D,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;CAChC;AAID,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CASzE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,IAAI,WAAW,CAElF;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,CAAC,CAcxB;AAWD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAEtF;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,mBAAmB,EAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAgB5B"}

package/dist/raw-client.js

@@ -1,60 +0,0 @@
-import { WasmWebClient, } from '@miden-sdk/miden-sdk';
-const rawClientCache = new WeakMap();
-export function requireConfigValue(field, value) {
-    if (typeof value !== 'string') {
-        throw new Error(`missing required configuration: ${field}`);
-    }
-    const normalizedValue = value.trim();
-    if (normalizedValue === '') {
-        throw new Error(`missing required configuration: ${field}`);
-    }
-    return normalizedValue;
-}
-export function requireMidenRpcEndpoint(endpoint) {
-    return requireConfigValue('midenRpcEndpoint', endpoint);
-}
-export function isPublicMidenClient(client) {
-    return 'accounts' in client && 'sync' in client;
-}
-export async function getRawMidenClient(client, rpcUrl) {
-    if (!isPublicMidenClient(client)) {
-        return client;
-    }
-    const cached = rawClientCache.get(client);
-    if (cached) {
-        return cached;
-    }
-    const endpoint = requireMidenRpcEndpoint(rpcUrl);
-    const rawClient = createRawClient(client, endpoint);
-    rawClientCache.set(client, rawClient);
-    return rawClient;
-}
-/**
- * Opens the WASM client behind `client` on the same store. The protocol
- * configuration comes from the node with every sync and is read from that
- * shared store, so the shadow needs no fee faucet of its own.
- */
-async function createRawClient(client, endpoint) {
-    return WasmWebClient.createClient(endpoint, undefined, undefined, await client.storeIdentifier());
-}
-export function getTransactionProver(client) {
-    return isPublicMidenClient(client) ? client.defaultProver : null;
-}
-export async function compileTxScript(client, code, libraries = [], rpcUrl) {
-    if (isPublicMidenClient(client)) {
-        return client.compile.txScript({ code, libraries });
-    }
-    const rawClient = await getRawMidenClient(client, rpcUrl);
-    const builder = await rawClient.createCodeBuilder();
-    for (const library of libraries) {
-        const builtLibrary = builder.buildLibrary(library.namespace, library.code);
-        if (library.linking === 'static') {
-            builder.linkStaticLibrary(builtLibrary);
-        }
-        else {
-            builder.linkDynamicLibrary(builtLibrary);
-        }
-    }
-    return builder.compileTxScript(code);
-}
-//# sourceMappingURL=raw-client.js.map

package/dist/raw-client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"raw-client.js","sourceRoot":"","sources":["../src/raw-client.ts"],"names":[],"mappings":"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"}