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

package/src/recovery/proposalNoteImport.ts

@@ -15,17 +15,16 @@ import {
   InputNote,
   type InputNoteRecord,
   InputNoteState,
+  type MidenClient,
   Note,
   type NoteAssets,
   NoteDetails,
   NoteFile,
-  NoteFilter,
-  NoteFilterTypes,
   type NoteInclusionProof,
   RpcClient,
 } from '@miden-sdk/miden-sdk';
 
-import { getRawMidenClient, requireMidenRpcEndpoint, type RawClientSource } from '../raw-client.js';
+import { requireMidenRpcEndpoint } from '../config.js';
 import { resolveRpcConfig, type RpcConfig } from '../rpc/config.js';
 import { isTransientRpcError } from '../rpc/errors.js';
 import { retryRpcRead } from '../rpc/retry.js';
@@ -176,10 +175,10 @@ function recordKeys(record: InputNoteRecord): string[] {
  * Shared by the recovery primitives (proposal import and backfill).
  */
 export async function collectExistingRecords(
-  webClient: Awaited<ReturnType<typeof getRawMidenClient>>,
+  midenClient: MidenClient,
 ): Promise<Map<string, InputNoteRecord>> {
   const existing = new Map<string, InputNoteRecord>();
-  const records = await webClient.getInputNotes(new NoteFilter(NoteFilterTypes.All));
+  const records = await midenClient.notes.list();
   for (const record of records) {
     for (const key of recordKeys(record)) {
       existing.set(key, record);
@@ -196,7 +195,7 @@ export async function collectExistingRecords(
  * re-check).
  */
 export async function importNoteWithProof(
-  webClient: Awaited<ReturnType<typeof getRawMidenClient>>,
+  midenClient: MidenClient,
   source: NoteImportSource,
   idHex: string,
   note: Note,
@@ -204,7 +203,7 @@ export async function importNoteWithProof(
 ): Promise<{ outcome: NoteImportOutcome; wasImported: boolean }> {
   try {
     const inputNote = InputNote.authenticated(note, proof);
-    await webClient.importNoteFile(NoteFile.fromInputNote(inputNote));
+    await midenClient.notes.import(NoteFile.fromInputNote(inputNote));
     return {
       outcome: { identifier: idHex, source, status: 'imported' },
       wasImported: true,
@@ -239,7 +238,7 @@ export async function importNoteWithProof(
  * it flags the outcome's classification as unconfirmed instead.
  */
 export async function reclassifyConsumedImports(
-  webClient: Awaited<ReturnType<typeof getRawMidenClient>>,
+  midenClient: MidenClient,
   imported: Array<{ index: number; idHex: string; detailsKey: string }>,
   outcomes: NoteImportOutcome[],
 ): Promise<void> {
@@ -247,7 +246,7 @@ export async function reclassifyConsumedImports(
     return;
   }
   try {
-    const records = await webClient.getInputNotes(new NoteFilter(NoteFilterTypes.All));
+    const records = await midenClient.notes.list();
     const byId = new Map<string, InputNoteRecord>();
     const byDetailsKey = new Map<string, InputNoteRecord>();
     for (const record of records) {
@@ -328,14 +327,13 @@ export async function reclassifyConsumedImports(
  * ```
  */
 export async function importNotesFromProposals(
-  midenClient: RawClientSource,
+  midenClient: MidenClient,
   proposals: ReadonlyArray<Pick<Proposal, 'id' | 'metadata'>>,
   options: ImportNotesFromProposalsOptions,
 ): Promise<NoteImportOutcome[]> {
   const midenRpcEndpoint = requireMidenRpcEndpoint(options.midenRpcEndpoint);
   const rpcConfig = resolveRpcConfig(options.rpc);
   throwIfCancelled(options.cancelled);
-  const webClient = await getRawMidenClient(midenClient, midenRpcEndpoint);
 
   const outcomes: NoteImportOutcome[] = [];
 
@@ -413,7 +411,7 @@ export async function importNotesFromProposals(
 
   let existing: Map<string, InputNoteRecord>;
   try {
-    existing = await collectExistingRecords(webClient);
+    existing = await collectExistingRecords(midenClient);
   } catch (error) {
     const reason = `failed to read local store: ${errorDetail(error)}`;
     for (const candidate of decoded) {
@@ -496,7 +494,7 @@ export async function importNotesFromProposals(
     const proof = proofs.get(candidate.idHex);
     if (proof) {
       const { outcome, wasImported } = await importNoteWithProof(
-        webClient,
+        midenClient,
         'proposal',
         candidate.idHex,
         candidate.note,
@@ -519,7 +517,7 @@ export async function importNotesFromProposals(
         // create a permanent user-source tag that the transport backfill
         // also re-drains, and that would outlive even a failed import.)
         const details = new NoteDetails(candidate.note.assets(), candidate.note.recipient());
-        await webClient.importNoteFile(
+        await midenClient.notes.import(
           NoteFile.fromExpectedNote(details, candidate.note.metadata().tag(), 0),
         );
         outcomes.push({
@@ -542,7 +540,7 @@ export async function importNotesFromProposals(
   }
 
   throwIfCancelled(options.cancelled);
-  await reclassifyConsumedImports(webClient, imported, outcomes);
+  await reclassifyConsumedImports(midenClient, imported, outcomes);
 
   return outcomes;
 }

package/src/recovery/publicNoteBackfill.ts

@@ -15,6 +15,7 @@ import {
   type CommittedNote,
   Endpoint,
   type InputNoteRecord,
+  type MidenClient,
   type Note,
   type NoteInclusionProof,
   NoteScript,
@@ -32,7 +33,7 @@ import {
   type NoteImportOutcome,
   reclassifyConsumedImports,
 } from './proposalNoteImport.js';
-import { getRawMidenClient, requireMidenRpcEndpoint, type RawClientSource } from '../raw-client.js';
+import { requireMidenRpcEndpoint } from '../config.js';
 import { resolveRpcConfig, type RpcConfig } from '../rpc/config.js';
 import { isTransientRpcError } from '../rpc/errors.js';
 import { retryRpcRead } from '../rpc/retry.js';
@@ -235,12 +236,11 @@ export interface BackfillPublicNotesOptions {
  * ```
  */
 export async function backfillPublicNotesByTag(
-  midenClient: RawClientSource,
+  midenClient: MidenClient,
   options: BackfillPublicNotesOptions,
 ): Promise<PublicBackfillReport> {
   const midenRpcEndpoint = requireMidenRpcEndpoint(options.midenRpcEndpoint);
   const rpcConfig = resolveRpcConfig(options.rpc);
-  const webClient = await getRawMidenClient(midenClient, midenRpcEndpoint);
   const rpcClient = new RpcClient(new Endpoint(midenRpcEndpoint));
   // Parse eagerly so a malformed account ID throws before any network work.
   AccountId.fromHex(options.accountId);
@@ -426,7 +426,7 @@ export async function backfillPublicNotesByTag(
 
   let existing: Map<string, InputNoteRecord>;
   try {
-    existing = await collectExistingRecords(webClient);
+    existing = await collectExistingRecords(midenClient);
   } catch (error) {
     const reason = `failed to read local store: ${errorDetail(error)}`;
     for (const candidate of pending) {
@@ -480,7 +480,7 @@ export async function backfillPublicNotesByTag(
       }
     }
     const { outcome, wasImported } = await importNoteWithProof(
-      webClient,
+      midenClient,
       'backfill',
       candidate.idHex,
       candidate.note,
@@ -496,7 +496,7 @@ export async function backfillPublicNotesByTag(
     outcomes.push(outcome);
   }
 
-  await reclassifyConsumedImports(webClient, imported, outcomes);
+  await reclassifyConsumedImports(midenClient, imported, outcomes);
 
   return buildReport();
 }

package/src/transaction/authArgs.ts

@@ -1,7 +1,12 @@
-import type { Felt, TransactionRequest, TransactionRequestBuilder, Word } from '@miden-sdk/miden-sdk';
-import { AccountId, Word as WordType } from '@miden-sdk/miden-sdk';
+import type {
+  Felt,
+  MidenClient,
+  TransactionRequest,
+  TransactionRequestBuilder,
+  Word,
+} from '@miden-sdk/miden-sdk';
+import { Word as WordType } from '@miden-sdk/miden-sdk';
 import { MultisigAuthArgsMissingError } from '../multisig/authArgErrors.js';
-import { getRawMidenClient, isPublicMidenClient, type RawClientSource } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { MultisigRequestOptions } from './options.js';
@@ -38,28 +43,17 @@ export interface MultisigRequestDraft {
  * the hex rather than taken from the caller, and nothing frees it afterwards.
  */
 export async function multisigRequestBuilder(
-  client: RawClientSource,
+  client: MidenClient,
   options: MultisigRequestOptions,
 ): Promise<MultisigRequestDraft> {
-  const { accountId, boundBlockNum, approvalExpirationDelta, midenRpcEndpoint } = options;
+  const { accountId, boundBlockNum, approvalExpirationDelta } = options;
   assertApprovalExpirationDelta(approvalExpirationDelta);
   const saltHex = normalizeHexWord(options.salt ? options.salt.toHex() : randomWord().toHex());
-  const salt = WordType.fromHex(saltHex);
-  if (isPublicMidenClient(client)) {
-    const builder = await client.feeAwareTransactionRequestBuilder(accountId, {
-      feeConversionSalt: salt,
-      boundBlockNum,
-      approvalExpirationDelta,
-    });
-    return { builder, saltHex };
-  }
-  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  const builder = await rawClient.feeAwareTransactionRequestBuilder(
-    AccountId.fromHex(accountId),
-    approvalExpirationDelta ?? null,
-    salt,
-    boundBlockNum ?? null,
-  );
+  const builder = await client.feeAwareTransactionRequestBuilder(accountId, {
+    feeConversionSalt: WordType.fromHex(saltHex),
+    boundBlockNum,
+    approvalExpirationDelta,
+  });
   return { builder, saltHex };
 }
 

package/src/transaction/consumeNotes.ts

@@ -1,32 +1,15 @@
-import type {
-  MidenClient,
-  Note,
-  TransactionRequest,
-  WasmWebClient,
-  Word,
-} from '@miden-sdk/miden-sdk';
+import type { MidenClient, Note, TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import { NoteAndArgs, NoteAndArgsArray } from '@miden-sdk/miden-sdk';
 import { LegacyConsumeNotesNoteMissingError } from '../multisig/consumeNotesErrors.js';
-import { getRawMidenClient } from '../raw-client.js';
 import { buildMultisigRequest, multisigRequestBuilder } from './authArgs.js';
-import type { MidenClientMultisigRequestOptions, MultisigRequestOptions } from './options.js';
+import type { MultisigRequestOptions } from './options.js';
 
 /**
  * Build a consume-notes request from loaded `Note` objects (no local-store
  * read). v2 verification path for issue #229.
  */
-export function buildConsumeNotesTransactionRequestFromNotes(
-  client: MidenClient,
-  notes: Note[],
-  options: MidenClientMultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
-export function buildConsumeNotesTransactionRequestFromNotes(
-  client: WasmWebClient,
-  notes: Note[],
-  options: MultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
 export async function buildConsumeNotesTransactionRequestFromNotes(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   notes: Note[],
   options: MultisigRequestOptions,
 ): Promise<{ request: TransactionRequest; salt: Word }> {
@@ -53,18 +36,8 @@ export async function buildConsumeNotesTransactionRequestFromNotes(
  * Legacy/creation adapter: fetches notes from the local store and delegates
  * to the from-notes variant. v2 verification MUST NOT call this.
  */
-export function buildConsumeNotesTransactionRequest(
-  client: MidenClient,
-  noteIds: string[],
-  options: MidenClientMultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
-export function buildConsumeNotesTransactionRequest(
-  client: WasmWebClient,
-  noteIds: string[],
-  options: MultisigRequestOptions,
-): Promise<{ request: TransactionRequest; salt: Word }>;
 export async function buildConsumeNotesTransactionRequest(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   noteIds: string[],
   options: MultisigRequestOptions,
 ): Promise<{ request: TransactionRequest; salt: Word }> {
@@ -72,15 +45,14 @@ export async function buildConsumeNotesTransactionRequest(
     throw new Error('At least one note ID is required');
   }
 
-  const rawClient = await getRawMidenClient(client, options.midenRpcEndpoint);
   const notes: Note[] = [];
   for (const noteIdHex of noteIds) {
-    const inputNoteRecord = await rawClient.getInputNote(noteIdHex);
+    const inputNoteRecord = await client.notes.get(noteIdHex);
     if (!inputNoteRecord) {
       throw new LegacyConsumeNotesNoteMissingError(noteIdHex);
     }
     notes.push(inputNoteRecord.toNote());
   }
 
-  return buildConsumeNotesTransactionRequestFromNotes(rawClient, notes, options);
+  return buildConsumeNotesTransactionRequestFromNotes(client, notes, options);
 }

package/src/transaction/noteAuthentication.ts

@@ -13,11 +13,16 @@
  * {@link ensureNotesAuthenticated} first, so the executed transaction is the
  * one the cosigners signed regardless of what each store held before.
  */
-import { Endpoint, type Note, type NoteInclusionProof, RpcClient } from '@miden-sdk/miden-sdk';
+import {
+  Endpoint,
+  type MidenClient,
+  type Note,
+  type NoteInclusionProof,
+  RpcClient,
+} from '@miden-sdk/miden-sdk';
 
+import { requireMidenRpcEndpoint } from '../config.js';
 import { ConsumeNoteNotAuthenticatedError } from '../multisig/consumeNotesErrors.js';
-import type { RawClientSource } from '../raw-client.js';
-import { getRawMidenClient } from '../raw-client.js';
 import { importNoteWithProof } from '../recovery/proposalNoteImport.js';
 import { resolveRpcConfig, type RpcConfig } from '../rpc/config.js';
 import { retryRpcRead } from '../rpc/retry.js';
@@ -44,19 +49,19 @@ export interface EnsureNotesAuthenticatedOptions {
  *   record still lacks authentication after a sync.
  */
 export async function ensureNotesAuthenticated(
-  midenClient: RawClientSource,
+  midenClient: MidenClient,
   notes: readonly Note[],
   options: EnsureNotesAuthenticatedOptions,
 ): Promise<void> {
-  const webClient = await getRawMidenClient(midenClient, options.midenRpcEndpoint);
-  const pending = await unauthenticatedNotes(webClient, notes);
+  const midenRpcEndpoint = requireMidenRpcEndpoint(options.midenRpcEndpoint);
+  const pending = await unauthenticatedNotes(midenClient, notes);
   if (pending.length === 0) {
     return;
   }
 
   const proofs = new Map<string, NoteInclusionProof>();
   try {
-    const rpcClient = new RpcClient(new Endpoint(options.midenRpcEndpoint));
+    const rpcClient = new RpcClient(new Endpoint(midenRpcEndpoint));
     const fetched = await retryRpcRead(
       () => rpcClient.getNotesById(pending.map((note) => note.id())),
       resolveRpcConfig(options.rpc),
@@ -81,7 +86,7 @@ export async function ensureNotesAuthenticated(
       );
     }
     const { outcome, wasImported } = await importNoteWithProof(
-      webClient,
+      midenClient,
       'proposal',
       idHex,
       note,
@@ -99,10 +104,10 @@ export async function ensureNotesAuthenticated(
   // height; a newer one lands unverified until a sync fetches its block
   // header. A cosigner that just loaded the account is typically behind the
   // note's block, so sync once and re-check before failing.
-  if ((await unauthenticatedNotes(webClient, notes)).length > 0) {
-    await webClient.syncState();
+  if ((await unauthenticatedNotes(midenClient, notes)).length > 0) {
+    await midenClient.syncChain();
   }
-  const still = await unauthenticatedNotes(webClient, notes);
+  const still = await unauthenticatedNotes(midenClient, notes);
   if (still.length > 0) {
     throw new ConsumeNoteNotAuthenticatedError(
       noteIdHex(still[0]),
@@ -114,12 +119,12 @@ export async function ensureNotesAuthenticated(
 
 /** The subset of `notes` whose local record is missing or carries no proof. */
 async function unauthenticatedNotes(
-  webClient: Awaited<ReturnType<typeof getRawMidenClient>>,
+  midenClient: MidenClient,
   notes: readonly Note[],
 ): Promise<Note[]> {
   const pending: Note[] = [];
   for (const note of notes) {
-    const record = await webClient.getInputNote(noteIdHex(note));
+    const record = await midenClient.notes.get(noteIdHex(note));
     if (!record || !record.isAuthenticated()) {
       pending.push(note);
     }

package/src/transaction/options.ts

@@ -5,7 +5,6 @@ export interface SignatureOptions {
   salt?: Word;
   signatureAdviceMap?: AdviceMap;
   signatureScheme?: SignatureScheme;
-  midenRpcEndpoint?: string;
   /**
    * The block the transaction summary binds. Omitted, the store's sync height,
    * which is right for the party creating a proposal. A cosigner or executor
@@ -23,10 +22,6 @@ export interface SignatureOptions {
   approvalExpirationDelta?: number;
 }
 
-export interface MidenClientSignatureOptions extends SignatureOptions {
-  midenRpcEndpoint: string;
-}
-
 /**
  * Options for a request a multisig account executes. The account decides the
  * auth args the request has to carry, so every multisig builder needs it.
@@ -34,7 +29,3 @@ export interface MidenClientSignatureOptions extends SignatureOptions {
 export interface MultisigRequestOptions extends SignatureOptions {
   accountId: string;
 }
-
-export interface MidenClientMultisigRequestOptions extends MultisigRequestOptions {
-  midenRpcEndpoint: string;
-}

package/src/transaction/p2id.ts

@@ -1,4 +1,4 @@
-import type { TransactionRequest, Word } from '@miden-sdk/miden-sdk';
+import type { MidenClient, TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import {
   AccountId,
   Felt,
@@ -16,7 +16,6 @@ import {
   Poseidon2,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
-import type { RawClientSource } from '../raw-client.js';
 import { buildMultisigRequest, multisigRequestBuilder } from './authArgs.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
@@ -163,7 +162,7 @@ export function buildP2idNoteFromMetadata(
 }
 
 export async function buildP2idTransactionRequest(
-  client: RawClientSource,
+  client: MidenClient,
   senderId: string,
   recipientId: string,
   faucetId: string,

package/src/transaction/summary.ts

@@ -1,12 +1,6 @@
-import type {
-  MidenClient,
-  TransactionRequest,
-  TransactionSummary,
-  WasmWebClient,
-} from '@miden-sdk/miden-sdk';
-import { AccountId, ChainAnchor, Word } from '@miden-sdk/miden-sdk';
+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 { getRawMidenClient } from '../raw-client.js';
 import { base64ToUint8Array, normalizeHexWord, uint8ArrayToBase64 } from '../utils/encoding.js';
 import { requestBoundBlockNum } from './authArgs.js';
 
@@ -85,29 +79,15 @@ export function isStaleChainError(error: unknown): boolean {
  * 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 rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  const anchor = await rawClient.chainAnchorForRequest(txRequest);
+  const anchor = await client.transactions.captureAnchor(txRequest);
   let summary: TransactionSummary;
   try {
-    summary = await executeForSummaryAtTip(rawClient, accountId, txRequest);
+    summary = await executeForSummaryAtTip(client, accountId, txRequest);
   } catch (error) {
     anchor.free();
     throw error;
@@ -145,27 +125,17 @@ export async function executeForSummary(
  * @throws BoundBlockNotDeclaredError when the request binds a block in its
  *   multisig auth args without declaring it.
  */
-export function executeForSummaryAtTip(
-  client: MidenClient,
-  accountId: string,
-  txRequest: TransactionRequest,
-  midenRpcEndpoint: string,
-): Promise<TransactionSummary>;
-export function executeForSummaryAtTip(
-  client: WasmWebClient,
-  accountId: string,
-  txRequest: TransactionRequest,
-  midenRpcEndpoint?: string,
-): Promise<TransactionSummary>;
 export async function executeForSummaryAtTip(
-  client: MidenClient | WasmWebClient,
+  client: MidenClient,
   accountId: string,
   txRequest: TransactionRequest,
-  midenRpcEndpoint?: string,
 ): Promise<TransactionSummary> {
-  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
-  await prepareTipExecution(rawClient, txRequest);
-  return rawClient.executeForSummary(AccountId.fromHex(accountId), txRequest);
+  await prepareTipExecution(client, txRequest);
+  return client.transactions.preview({
+    operation: 'custom',
+    account: accountId,
+    request: txRequest,
+  });
 }
 
 /**
@@ -177,13 +147,13 @@ export async function executeForSummaryAtTip(
  *   multisig auth args without declaring it.
  */
 export async function prepareTipExecution(
-  client: WasmWebClient,
+  client: MidenClient,
   request: TransactionRequest,
-  syncState?: () => Promise<unknown>,
+  syncChain?: () => Promise<unknown>,
 ): Promise<void> {
   const boundBlockNum = requireDeclaredBoundBlock(request);
   if (boundBlockNum !== undefined) {
-    await syncToBoundBlock(client, boundBlockNum, syncState);
+    await syncToBoundBlock(client, boundBlockNum, syncChain);
   }
 }
 
@@ -207,8 +177,8 @@ export function requireDeclaredBoundBlock(request: TransactionRequest): number |
  * 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. `syncState` lets a caller wrap the sync in its own retry
- * policy.
+ * 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
@@ -218,14 +188,14 @@ export function requireDeclaredBoundBlock(request: TransactionRequest): number |
  * @throws ChainBehindBoundBlockError when the node has not reached the block.
  */
 export async function syncToBoundBlock(
-  client: WasmWebClient,
+  client: MidenClient,
   blockNum: number,
-  syncState: () => Promise<unknown> = () => client.syncState(),
+  syncChain: () => Promise<unknown> = () => client.syncChain(),
 ): Promise<void> {
   if ((await client.getSyncHeight()) >= blockNum) {
     return;
   }
-  await syncState();
+  await syncChain();
   const syncHeight = await client.getSyncHeight();
   if (syncHeight < blockNum) {
     throw new ChainBehindBoundBlockError({ syncHeight, boundBlockNum: blockNum });
@@ -241,30 +211,18 @@ export async function syncToBoundBlock(
  * reproduced with {@link executeForSummaryAtTip}: re-executing it at an anchor
  * fails once the node prunes the anchor block's account state.
  */
-export function executeForSummaryAt(
-  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>;
 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,
+  });
 }
 
 /**

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);