@openzeppelin/miden-multisig-client 0.13.3 → 0.14.3

package/src/multisig.ts

@@ -16,7 +16,12 @@ import type {
   ProposalType,
 } from './types.js';
 import type { ProcedureName } from './procedures.js';
-import type { WebClient, TransactionRequest } from '@miden-sdk/miden-sdk';
+import type {
+  MidenClient,
+  TransactionProver,
+  TransactionRequest,
+  WasmWebClient,
+} from '@miden-sdk/miden-sdk';
 import {
   Account,
   AccountId,
@@ -53,6 +58,7 @@ import { AccountInspector } from './inspector.js';
 import { ProposalFactory } from './proposal/factory.js';
 import { ProposalMetadataCodec } from './proposal/metadata.js';
 import { ProposalSignatures } from './proposal/signatures.js';
+import { getRawMidenClient, getTransactionProver } from './raw-client.js';
 
 /**
  * Result of fetching account state from GUARDIAN.
@@ -87,7 +93,9 @@ export class Multisig {
 
   private guardian: GuardianHttpClient;
   private readonly signer: Signer;
-  private readonly webClient: WebClient;
+  private readonly midenClient: MidenClient;
+  private readonly rawClientPromise: Promise<WasmWebClient>;
+  private readonly transactionProver: TransactionProver | null;
   private readonly _accountId: string;
   private readonly midenRpcEndpoint?: string;
   private proposals: Map<string, Proposal> = new Map();
@@ -97,7 +105,7 @@ export class Multisig {
     config: MultisigConfig,
     guardian: GuardianHttpClient,
     signer: Signer,
-    webClient: WebClient,
+    midenClient: MidenClient,
     accountId?: string,
     midenRpcEndpoint?: string
   ) {
@@ -111,9 +119,11 @@ export class Multisig {
     );
     this.guardian = guardian;
     this.signer = signer;
-    this.webClient = webClient;
+    this.midenClient = midenClient;
     this._accountId = accountId ?? (account ? accountIdToHex(account) : '');
     this.midenRpcEndpoint = midenRpcEndpoint;
+    this.rawClientPromise = getRawMidenClient(midenClient, midenRpcEndpoint);
+    this.transactionProver = getTransactionProver(midenClient);
   }
 
   private getMidenRpcEndpoint(): string {
@@ -123,6 +133,10 @@ export class Multisig {
     return this.midenRpcEndpoint;
   }
 
+  private async getRawClient(): Promise<WasmWebClient> {
+    return this.rawClientPromise;
+  }
+
   private proposalFactory(): ProposalFactory {
     return new ProposalFactory({
       accountId: this._accountId,
@@ -228,7 +242,7 @@ export class Multisig {
   }
 
   /**
-   * Sync account state from GUARDIAN into the local WebClient store.
+   * Sync account state from GUARDIAN into the local Miden client store.
    *
    * If the GUARDIAN commitment differs from the local commitment (or the account
    * is missing locally), the local store is overwritten with the GUARDIAN state.
@@ -236,19 +250,20 @@ export class Multisig {
   async syncState(): Promise<AccountState> {
     const state = await this.fetchState();
     const accountId = AccountId.fromHex(this._accountId);
-    const localAccount = await this.webClient.getAccount(accountId);
+    const webClient = await this.getRawClient();
+    const localAccount = await webClient.getAccount(accountId);
     let accountForConfigRefresh: Account | null = localAccount ?? null;
 
     const guardianCommitment = normalizeHexWord(state.commitment);
     const localCommitment = localAccount
-      ? normalizeHexWord(localAccount.commitment().toHex())
+      ? normalizeHexWord(localAccount.to_commitment().toHex())
       : null;
 
     if (!localAccount || localCommitment !== guardianCommitment) {
       const accountBytes = base64ToUint8Array(state.stateDataBase64);
       const incomingAccount = Account.deserialize(accountBytes);
       await this.ensureSafeToOverwriteLocalState(incomingAccount, localAccount);
-      await this.webClient.newAccount(incomingAccount, true);
+      await webClient.newAccount(incomingAccount, true);
       accountForConfigRefresh = incomingAccount;
     }
 
@@ -259,7 +274,8 @@ export class Multisig {
 
   async verifyStateCommitment(): Promise<AccountStateVerificationResult> {
     const accountId = AccountId.fromHex(this._accountId);
-    const localAccount = await this.webClient.getAccount(accountId);
+    const webClient = await this.getRawClient();
+    const localAccount = await webClient.getAccount(accountId);
 
     if (!localAccount) {
       throw new Error(
@@ -267,7 +283,7 @@ export class Multisig {
       );
     }
 
-    const localCommitment = normalizeHexWord(localAccount.commitment().toHex());
+    const localCommitment = normalizeHexWord(localAccount.to_commitment().toHex());
     const onChainCommitment = await this.getOnChainCommitment(accountId);
 
     if (!onChainCommitment) {
@@ -308,7 +324,7 @@ export class Multisig {
       return;
     }
 
-    const incomingCommitment = normalizeHexWord(incomingAccount.commitment().toHex());
+    const incomingCommitment = normalizeHexWord(incomingAccount.to_commitment().toHex());
     if (incomingCommitment !== onChainCommitment) {
       throw new Error(
         `Refusing to overwrite local state: incoming commitment does not match on-chain commitment for account ${this._accountId}`
@@ -472,17 +488,18 @@ export class Multisig {
     nonce?: number,
     newThreshold?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     const targetThreshold = newThreshold ?? this.threshold;
     const targetSignerCommitments = [...this.signerCommitments, newCommitment];
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      this.webClient,
+      webClient,
       targetThreshold,
       targetSignerCommitments,
       { signatureScheme: this.signer.scheme },
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -510,6 +527,7 @@ export class Multisig {
     nonce?: number,
     newThreshold?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     const normalizedRemove = signerToRemove.toLowerCase();
     const targetSignerCommitments = this.signerCommitments.filter(
       (c) => c.toLowerCase() !== normalizedRemove
@@ -531,13 +549,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      this.webClient,
+      webClient,
       targetThreshold,
       targetSignerCommitments,
       { signatureScheme: this.signer.scheme },
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -563,6 +581,7 @@ export class Multisig {
     newThreshold: number,
     nonce?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     if (newThreshold < 1 || newThreshold > this.signerCommitments.length) {
       throw new Error(
         `Invalid threshold ${newThreshold}. Must be between 1 and ${this.signerCommitments.length}`
@@ -574,13 +593,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      this.webClient,
+      webClient,
       newThreshold,
       this.signerCommitments,
       { signatureScheme: this.signer.scheme },
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -601,6 +620,7 @@ export class Multisig {
     targetThreshold: number,
     nonce?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     if (targetThreshold < 0 || targetThreshold > this.signerCommitments.length) {
       throw new Error(
         `Invalid threshold ${targetThreshold}. Must be between 0 and ${this.signerCommitments.length}`
@@ -619,13 +639,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateProcedureThresholdTransactionRequest(
-      this.webClient,
+      webClient,
       targetProcedure,
       targetThreshold,
       { signatureScheme: this.signer.scheme },
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
     const action = targetThreshold === 0
@@ -656,15 +676,16 @@ export class Multisig {
     newGuardianPubkey: string,
     nonce?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     await this.verifyGuardianEndpointCommitment(newGuardianEndpoint, newGuardianPubkey);
 
     const { request, salt } = await buildUpdateGuardianTransactionRequest(
-      this.webClient,
+      webClient,
       newGuardianPubkey,
       { signatureScheme: this.signer.scheme },
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -702,13 +723,14 @@ export class Multisig {
     noteIds: string[],
     nonce?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     if (noteIds.length === 0) {
       throw new Error('At least one note ID is required');
     }
 
-    const { request, salt } = await buildConsumeNotesTransactionRequest(this.webClient, noteIds);
+    const { request, salt } = await buildConsumeNotesTransactionRequest(webClient, noteIds);
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -737,6 +759,7 @@ export class Multisig {
     amount: bigint,
     nonce?: number,
   ): Promise<Proposal> {
+    const webClient = await this.getRawClient();
     if (amount <= 0n) {
       throw new Error('Amount must be greater than 0');
     }
@@ -748,7 +771,7 @@ export class Multisig {
       amount,
     );
 
-    const summary = await executeForSummary(this.webClient, this._accountId, request);
+    const summary = await executeForSummary(webClient, this._accountId, request);
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
     const proposalNonce = nonce ?? Date.now();
 
@@ -773,9 +796,10 @@ export class Multisig {
    */
   async getConsumableNotes(): Promise<ConsumableNote[]> {
     const accountId = AccountId.fromHex(this._accountId);
+    const webClient = await this.getRawClient();
 
     // Get consumable notes for this account
-    const consumableRecords = await this.webClient.getConsumableNotes(accountId);
+    const consumableRecords = await webClient.getConsumableNotes(accountId);
 
     // Convert to our simplified ConsumableNote type
     const notes: ConsumableNote[] = [];
@@ -866,24 +890,73 @@ export class Multisig {
     return this.proposals.get(proposalId) ?? this.proposals.get(normalizedProposalId);
   }
 
+  async createTransactionProposalRequest(proposalId: string): Promise<TransactionRequest> {
+    const { finalRequest } = await this.prepareProposalExecution(proposalId);
+    return finalRequest;
+  }
+
   /**
    * Execute a proposal that has enough signatures.
    *
    * @param proposalId - The proposal commitment/ID
    */
   async executeProposal(proposalId: string): Promise<void> {
-    const proposal = this.proposals.get(proposalId);
+    const { metadata, finalRequest, proposal } = await this.prepareProposalExecution(proposalId);
+
+    const accountId = AccountId.fromHex(this._accountId);
+    await this.midenClient.transactions.submit(accountId, finalRequest);
+
+    if (metadata.proposalType === 'switch_guardian') {
+      if (!metadata.newGuardianEndpoint || !metadata.newGuardianPubkey) {
+        throw new Error('Switch GUARDIAN proposal metadata is incomplete after execution');
+      }
+
+      try {
+        const webClient = await this.getRawClient();
+        await webClient.syncState();
+
+        const updatedAccount = await webClient.getAccount(accountId);
+        if (!updatedAccount) {
+          throw new Error(
+            `Updated account ${this._accountId} is missing from local client`
+          );
+        }
+
+        const updatedStateBase64 = uint8ArrayToBase64(updatedAccount.serialize());
+        const nextGuardian = new GuardianHttpClient(metadata.newGuardianEndpoint);
+        this.setGuardianClient(nextGuardian);
+        this.guardianPublicKey = metadata.newGuardianPubkey;
+
+        await this.registerOnGuardian(updatedStateBase64);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `Transaction executed successfully but failed to register on new GUARDIAN: ${message}`
+        );
+      }
+    }
+
+    proposal.status = 'finalized';
+  }
+
+  private getLocalProposal(proposalId: string): Proposal | undefined {
+    const normalizedProposalId = normalizeHexWord(proposalId);
+    return this.proposals.get(proposalId) ?? this.proposals.get(normalizedProposalId);
+  }
+
+  private async prepareProposalExecution(
+    proposalId: string,
+  ): Promise<{ finalRequest: TransactionRequest; metadata: ProposalMetadata; proposal: Proposal }> {
+    const proposal = this.getLocalProposal(proposalId);
     if (!proposal) {
       throw new Error(`Proposal not found: ${proposalId}`);
     }
 
+    this.proposalFactory().assertAccountId(proposal.accountId);
     await this.verifyProposalMetadataBinding(proposal);
 
-    const proposalType = proposal.metadata?.proposalType;
-    const effectiveThreshold = proposalType
-      ? this.getEffectiveThreshold(proposalType)
-      : this.threshold;
-
+    const metadata = proposal.metadata;
+    const effectiveThreshold = this.getEffectiveThreshold(metadata.proposalType);
     const signatureContext = `Invalid proposal signatures for ${proposalId}`;
     const signaturesForExecution = new ProposalSignatures(
       proposal.signatures,
@@ -895,7 +968,8 @@ export class Multisig {
       throw new Error('Proposal is not ready for execution. Still pending signatures.');
     }
 
-    const isSwitchGuardian = proposalType === 'switch_guardian';
+    const isSwitchGuardian = metadata.proposalType === 'switch_guardian';
+    const normalizedProposalId = normalizeHexWord(proposal.id);
 
     let txSummaryBase64: string;
     let delta: DeltaObject | undefined;
@@ -903,7 +977,7 @@ export class Multisig {
     if (isSwitchGuardian) {
       txSummaryBase64 = proposal.txSummary;
     } else {
-      delta = await this.guardian.getDeltaProposal(this._accountId, proposalId);
+      delta = await this.guardian.getDeltaProposal(this._accountId, normalizedProposalId);
       txSummaryBase64 = delta.deltaPayload.txSummary.data;
     }
 
@@ -911,12 +985,13 @@ export class Multisig {
     const txSummary = TransactionSummary.deserialize(txSummaryBytes);
     const saltHex = txSummary.salt().toHex();
     const txCommitmentHex = txSummary.toCommitment().toHex();
+    const normalizedTxCommitmentHex = normalizeHexWord(txCommitmentHex);
     const normalizedSignerCommitments = new Set(
       this.signerCommitments.map((commitment) => normalizeHexWord(commitment)),
     );
-
     const adviceMap = new AdviceMap();
     const adviceMapKeys = new Set<string>();
+    const createTxCommitmentWord = (): Word => Word.fromHex(normalizedTxCommitmentHex);
 
     for (const cosignerSig of signaturesForExecution) {
       let signerCommitmentHex = normalizeHexWord(cosignerSig.signerId);
@@ -949,10 +1024,9 @@ export class Multisig {
         cosignerSig.signature.scheme,
       );
       const signature = Signature.deserialize(sigBytes);
-      const txCommitment = Word.fromHex(normalizeHexWord(txCommitmentHex));
       const { key, values } = buildSignatureAdviceEntry(
         signerCommitment,
-        txCommitment,
+        createTxCommitmentWord(),
         signature,
         ecdsaPublicKey,
         cosignerSig.signature.scheme === 'ecdsa'
@@ -993,10 +1067,9 @@ export class Multisig {
       }
       const ackSigBytes = signatureHexToBytes(ackSigHex, ackScheme);
       const ackSignature = Signature.deserialize(ackSigBytes);
-      const txCommitmentForAck = Word.fromHex(normalizeHexWord(txCommitmentHex));
       const { key: ackKey, values: ackValues } = buildSignatureAdviceEntry(
         guardianCommitment,
-        txCommitmentForAck,
+        createTxCommitmentWord(),
         ackSignature,
         ackScheme === 'ecdsa' ? ackPubkey : undefined,
         ackScheme === 'ecdsa' ? ackSigHex : undefined,
@@ -1009,13 +1082,10 @@ export class Multisig {
       adviceMap.insert(ackKey, new FeltArray(ackValues));
     }
 
-    const metadata = proposal.metadata;
-    if (!metadata) {
-      throw new Error('Proposal missing metadata');
-    }
     if (metadata.proposalType === 'switch_guardian') {
       await this.verifyGuardianEndpointCommitment(metadata.newGuardianEndpoint, metadata.newGuardianPubkey);
     }
+
     const executionSalt = Word.fromHex(normalizeHexWord(saltHex));
     const finalRequest = await this.buildTransactionRequestFromMetadata(
       metadata,
@@ -1023,42 +1093,7 @@ export class Multisig {
       adviceMap,
     );
 
-    const accountId = AccountId.fromHex(this._accountId);
-    const result = await this.webClient.executeTransaction(accountId, finalRequest);
-    const proven = await this.webClient.proveTransaction(result, null);
-    const submissionHeight = await this.webClient.submitProvenTransaction(proven, result);
-    await this.webClient.applyTransaction(result, submissionHeight);
-
-    if (metadata.proposalType === 'switch_guardian') {
-      if (!metadata.newGuardianEndpoint || !metadata.newGuardianPubkey) {
-        throw new Error('Switch GUARDIAN proposal metadata is incomplete after execution');
-      }
-
-      try {
-        await this.webClient.syncState();
-
-        const updatedAccount = await this.webClient.getAccount(accountId);
-        if (!updatedAccount) {
-          throw new Error(
-            `Updated account ${this._accountId} is missing from local client`
-          );
-        }
-
-        const updatedStateBase64 = uint8ArrayToBase64(updatedAccount.serialize());
-        const nextGuardian = new GuardianHttpClient(metadata.newGuardianEndpoint);
-        this.setGuardianClient(nextGuardian);
-        this.guardianPublicKey = metadata.newGuardianPubkey;
-
-        await this.registerOnGuardian(updatedStateBase64);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(
-          `Transaction executed successfully but failed to register on new GUARDIAN: ${message}`
-        );
-      }
-    }
-
-    proposal.status = 'finalized';
+    return { finalRequest, metadata, proposal };
   }
 
   /**
@@ -1236,7 +1271,8 @@ export class Multisig {
       : summary.salt();
 
     const request = await this.buildTransactionRequestFromMetadata(proposal.metadata, salt);
-    const reconstructed = await executeForSummary(this.webClient, this._accountId, request);
+    const webClient = await this.getRawClient();
+    const reconstructed = await executeForSummary(webClient, this._accountId, request);
     const reconstructedCommitment = normalizeHexWord(reconstructed.toCommitment().toHex());
 
     if (reconstructedCommitment !== txSummaryCommitment) {
@@ -1251,12 +1287,14 @@ export class Multisig {
     salt: Word,
     signatureAdviceMap?: AdviceMap,
   ): Promise<TransactionRequest> {
+    const webClient = await this.getRawClient();
+
     switch (metadata.proposalType) {
       case 'add_signer':
       case 'remove_signer':
       case 'change_threshold': {
         const { request } = await buildUpdateSignersTransactionRequest(
-          this.webClient,
+          webClient,
           metadata.targetThreshold,
           metadata.targetSignerCommitments,
           { salt, signatureAdviceMap, signatureScheme: this.signer.scheme }
@@ -1265,7 +1303,7 @@ export class Multisig {
       }
       case 'switch_guardian': {
         const { request } = await buildUpdateGuardianTransactionRequest(
-          this.webClient,
+          webClient,
           metadata.newGuardianPubkey,
           { salt, signatureAdviceMap, signatureScheme: this.signer.scheme }
         );
@@ -1273,7 +1311,7 @@ export class Multisig {
       }
       case 'update_procedure_threshold': {
         const { request } = await buildUpdateProcedureThresholdTransactionRequest(
-          this.webClient,
+          webClient,
           metadata.targetProcedure,
           metadata.targetThreshold,
           { salt, signatureAdviceMap, signatureScheme: this.signer.scheme }
@@ -1282,7 +1320,7 @@ export class Multisig {
       }
       case 'consume_notes': {
         const { request } = await buildConsumeNotesTransactionRequest(
-          this.webClient,
+          webClient,
           metadata.noteIds,
           { salt, signatureAdviceMap }
         );

package/src/procedures.ts

@@ -11,13 +11,13 @@
  * human-readable encoding and should not be copied into this table.
  */
 export const PROCEDURE_ROOTS = {
-  update_signers: '0xafdea9abee19b02620520b11a165267b266403fa408f7eebc91fc83c33b507ca',
-  update_procedure_threshold: '0xd6616423eebe012655a9db925363cc6751b94109a938e9bc5f488b52f75b7d1c',
-  auth_tx: '0x611abcd570631ad98842cb6f0ef891fe8f9ee508b3245c55a5531d5a8f7fdca9',
-  update_guardian: '0xcda1f9120a3ab2948d5cdc6b4b2982571c04e3f6af787a6d6b2f88eeedd872d7',
-  verify_guardian: '0xe4be6069ba56570afecab5ae2ff77165d5230b703ba2cff1cafe06b92aa19e56',
-  send_asset: '0x0e406b067ed2bcd7de745ca6517f519fd1a9be245f913347ac673ca1db30c1d6',
-  receive_asset: '0x6f4bdbdc4b13d7ed933d590d88ac9dfb98020c9e917697845b5e169395b76a01',
+  update_signers: '0x3d382ad461f9914c487c6fe908991d088eb54ecbd4aa8560ef79c66c3746bf19',
+  update_procedure_threshold: '0x1f43e9d56ceff5d547ffdcb89896fb38cae0be1b74d9235ed2b4aa525df85f8d',
+  auth_tx: '0x415530d7169f849d7219e810065f9119bba9af2c55070de0bf4f082a1c0aea5c',
+  update_guardian: '0xc8ea876f1837e5cd1d6031becdbd40ce262ecd55930d65400f6890a37149d80c',
+  verify_guardian: '0x9bc6e7b25c8dbaa29d6ad41e354a545dd0a4bac7f3a521bb5195ba101f0213cc',
+  send_asset: '0x6d30df4312a2c44ec842db1bee227cc045396ca91e2c47d756dcb607f2bf5f89',
+  receive_asset: '0x75f638c65584d058542bcf4674b066ae394183021bc9b44dc2fdd97d52f9bcfb',
 } as const;
 
 /**
@@ -34,7 +34,7 @@ export type ProcedureName = keyof typeof PROCEDURE_ROOTS;
  * @example
  * ```typescript
  * const root = getProcedureRoot('send_asset');
- * // '0x0e406b067ed2bcd7de745ca6517f519fd1a9be245f913347ac673ca1db30c1d6'
+ * // '0x6d30df4312a2c44ec842db1bee227cc045396ca91e2c47d756dcb607f2bf5f89'
  * ```
  */
 export function getProcedureRoot(name: ProcedureName): string {

package/src/raw-client.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockCreateClient } = vi.hoisted(() => ({
+  mockCreateClient: vi.fn(),
+}));
+
+vi.mock('@miden-sdk/miden-sdk', () => ({
+  WasmWebClient: {
+    createClient: mockCreateClient,
+  },
+}));
+
+import {
+  compileTxScript,
+  getRawMidenClient,
+  getTransactionProver,
+  resolveMidenRpcEndpoint,
+} from './raw-client.js';
+
+describe('raw-client', () => {
+  beforeEach(() => {
+    mockCreateClient.mockReset();
+  });
+
+  it('defaults RPC endpoint resolution to devnet', () => {
+    expect(resolveMidenRpcEndpoint()).toBe('https://rpc.devnet.miden.io');
+  });
+
+  it('returns the default prover from a public MidenClient', () => {
+    const prover = { kind: 'devnet-prover' };
+    const client = {
+      accounts: {},
+      sync: vi.fn(),
+      defaultProver: prover,
+      storeIdentifier: vi.fn(() => 'browser-db'),
+    };
+
+    expect(getTransactionProver(client as any)).toBe(prover);
+  });
+
+  it('returns null for raw web clients', () => {
+    const rawClient = {
+      executeTransaction: vi.fn(),
+      proveTransaction: vi.fn(),
+    };
+
+    expect(getTransactionProver(rawClient as any)).toBeNull();
+  });
+
+  it('creates and caches a raw client for a public MidenClient', async () => {
+    const rawClient = { kind: 'raw-client' };
+    const client = {
+      accounts: {},
+      sync: vi.fn(),
+      defaultProver: null,
+      storeIdentifier: vi.fn(() => 'browser-db'),
+    };
+
+    mockCreateClient.mockResolvedValue(rawClient);
+
+    await expect(
+      getRawMidenClient(client as any, 'https://rpc.devnet.miden.io'),
+    ).resolves.toBe(rawClient);
+    await expect(
+      getRawMidenClient(client as any, 'https://rpc.devnet.miden.io'),
+    ).resolves.toBe(rawClient);
+
+    expect(mockCreateClient).toHaveBeenCalledTimes(1);
+    expect(mockCreateClient).toHaveBeenCalledWith(
+      'https://rpc.devnet.miden.io',
+      undefined,
+      undefined,
+      'browser-db',
+    );
+  });
+
+  it('uses the public compile resource when available', async () => {
+    const script = { kind: 'compiled-script' };
+    const client = {
+      accounts: {},
+      sync: vi.fn(),
+      compile: {
+        txScript: vi.fn().mockResolvedValue(script),
+      },
+      storeIdentifier: vi.fn(() => 'browser-db'),
+    };
+
+    await expect(
+      compileTxScript(
+        client as any,
+        'begin end',
+        [{ namespace: 'auth::multisig', code: 'export.foo' }],
+      ),
+    ).resolves.toBe(script);
+
+    expect(client.compile.txScript).toHaveBeenCalledWith({
+      code: 'begin end',
+      libraries: [{ namespace: 'auth::multisig', code: 'export.foo' }],
+    });
+    expect(mockCreateClient).not.toHaveBeenCalled();
+  });
+
+  it('falls back to raw client compilation for low-level callers', async () => {
+    const compiledScript = { kind: 'compiled-script' };
+    const builtLibrary = { kind: 'built-library' };
+    const builder = {
+      buildLibrary: vi.fn().mockReturnValue(builtLibrary),
+      linkDynamicLibrary: vi.fn(),
+      linkStaticLibrary: vi.fn(),
+      compileTxScript: vi.fn().mockReturnValue(compiledScript),
+    };
+    const rawClient = {
+      createCodeBuilder: vi.fn().mockReturnValue(builder),
+    };
+
+    await expect(
+      compileTxScript(
+        rawClient as any,
+        'begin end',
+        [
+          { namespace: 'auth::multisig', code: 'export.foo' },
+          { namespace: 'auth::guardian', code: 'export.bar', linking: 'static' },
+        ],
+      ),
+    ).resolves.toBe(compiledScript);
+
+    expect(builder.buildLibrary).toHaveBeenNthCalledWith(1, 'auth::multisig', 'export.foo');
+    expect(builder.buildLibrary).toHaveBeenNthCalledWith(2, 'auth::guardian', 'export.bar');
+    expect(builder.linkDynamicLibrary).toHaveBeenCalledWith(builtLibrary);
+    expect(builder.linkStaticLibrary).toHaveBeenCalledWith(builtLibrary);
+    expect(builder.compileTxScript).toHaveBeenCalledWith('begin end');
+  });
+});