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

package/src/multisig.ts

@@ -18,10 +18,7 @@ import type {
 } from './types.js';
 import { ProposalSaltMalformedError } from './multisig/authArgErrors.js';
 import type { ProcedureName } from './procedures.js';
-import type {
-  MidenClient,
-  WasmWebClient,
-} from '@miden-sdk/miden-sdk';
+import type { MidenClient, OutputNoteRecord } from '@miden-sdk/miden-sdk';
 import {
   Account,
   AccountId,
@@ -113,11 +110,7 @@ import {
   type NoteRecoverySteps,
   type RecoverNotesOptions,
 } from './recovery/recoverNotes.js';
-import {
-  getRawMidenClient,
-  getTransactionProver,
-  requireMidenRpcEndpoint,
-} from './raw-client.js';
+import { requireMidenRpcEndpoint } from './config.js';
 import {
   resolveProverConfig,
   type ResolvedProverConfig,
@@ -145,6 +138,20 @@ export interface AccountState {
   updatedAt: string;
 }
 
+/**
+ * Outcome of {@link Multisig.syncState}.
+ *
+ * `'guardian'`: GUARDIAN's canonical nonce was above the local nonce (or the
+ * local store had no account, or the same nonce carried a different
+ * commitment), so the state was fetched and reconciled; `state` is what
+ * GUARDIAN served. `'local'`: GUARDIAN's canonical nonce was below the local
+ * nonce, or equal to it at the same commitment, so the state fetch was
+ * skipped and the local account stands.
+ */
+export type SyncStateResult =
+  | { source: 'guardian'; state: AccountState }
+  | { source: 'local'; localNonce: bigint; guardianNonce: bigint };
+
 export interface AccountStateVerificationResult {
   accountId: string;
   localCommitment: string;
@@ -327,7 +334,6 @@ export class Multisig {
   private guardian: GuardianHttpClient;
   private readonly signer: Signer;
   private readonly midenClient: MidenClient;
-  private readonly rawClientPromise: Promise<WasmWebClient>;
   private readonly proverWorkflow: ProverWorkflow;
   private readonly rpcConfig: ResolvedRpcConfig;
   private readonly _accountId: string;
@@ -376,10 +382,9 @@ export class Multisig {
     this.midenClient = midenClient;
     this._accountId = accountId ?? (account ? accountIdToHex(account) : '');
     this.midenRpcEndpoint = requireMidenRpcEndpoint(midenRpcEndpoint);
-    this.rawClientPromise = getRawMidenClient(midenClient, this.midenRpcEndpoint);
     this.proverWorkflow = new ProverWorkflow(
       this.midenClient,
-      proverConfig ?? resolveProverConfig(undefined, getTransactionProver(midenClient)),
+      proverConfig ?? resolveProverConfig(undefined, midenClient.defaultProver),
     );
     this.rpcConfig = rpcConfig ?? resolveRpcConfig(undefined);
   }
@@ -388,10 +393,6 @@ export class Multisig {
     return this.midenRpcEndpoint;
   }
 
-  private async getRawClient(): Promise<WasmWebClient> {
-    return this.rawClientPromise;
-  }
-
   private proposalFactory(): ProposalFactory {
     return new ProposalFactory({
       accountId: this._accountId,
@@ -428,7 +429,7 @@ export class Multisig {
   }
 
   /**
-   * Resolve the account from the web client's store, falling back to the
+   * Resolve the account from the Miden client's store, falling back to the
    * `account` snapshot when the store has no record.
    *
    * Transaction execution reads the store, and other flows (e.g. consume-notes
@@ -436,12 +437,11 @@ export class Multisig {
    * source from the store to see the same state execution will.
    */
   async getStoreAccount(): Promise<Account> {
-    const webClient = await this.getRawClient();
-    const stored = await retryRpcRead(
-      () => webClient.getAccount(AccountId.fromHex(this._accountId)),
-      this.rpcConfig,
-    );
-    return stored ?? this.account;
+    return (await this.readStoreAccount()) ?? this.account;
+  }
+
+  private readStoreAccount(): Promise<Account | null> {
+    return retryRpcRead(() => this.midenClient.accounts.get(this._accountId), this.rpcConfig);
   }
 
   /**
@@ -610,24 +610,37 @@ export class Multisig {
   /**
    * 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) and the GUARDIAN state is safe to import, the local store
-   * is overwritten with the GUARDIAN state. When the GUARDIAN is merely *behind*
+   * Starts with the canonical-nonce pre-check (OpenZeppelin/guardian#191):
+   * GUARDIAN reports the nonce and commitment of its canonical state, and
+   * when that nonce is not above the local account's — at a matching
+   * commitment when equal — nothing newer exists to pull, so the state
+   * fetch is skipped and the local account stands (`source: 'local'`).
+   *
+   * Otherwise the state is fetched (`source: 'guardian'`). If the GUARDIAN
+   * commitment differs from the local commitment (or the account is missing
+   * locally) and the GUARDIAN state is safe to import, the local store is
+   * overwritten with the GUARDIAN state. When the GUARDIAN is merely *behind*
    * local — e.g. the pushed execution delta has not been canonicalized yet
    * (see OpenZeppelin/guardian#316) — the local state is already ahead and
    * on-chain-verifiable, so it is kept as authoritative. Either way, config is
    * refreshed from the resulting account so callers reading `Multisig.account`
    * (e.g. the UI) observe the current state instead of a stale snapshot.
    */
-  async syncState(): Promise<AccountState> {
+  async syncState(): Promise<SyncStateResult> {
+    const localAccount = await this.readStoreAccount();
+
+    if (localAccount) {
+      const head = await this.guardian.getCanonicalNonce(this._accountId);
+      const localNonce = localAccount.nonce().asInt();
+      const guardianNonce = BigInt(head.nonce);
+      if (this.guardianIsNotAhead(localAccount, localNonce, head.commitment, guardianNonce)) {
+        this.refreshConfigFromAccount(localAccount);
+        return { source: 'local', localNonce, guardianNonce };
+      }
+    }
+
     const state = await this.fetchState();
-    const accountId = AccountId.fromHex(this._accountId);
-    const webClient = await this.getRawClient();
-    const localAccount = await retryRpcRead(
-      () => webClient.getAccount(accountId),
-      this.rpcConfig,
-    );
-    let accountForConfigRefresh: Account | null = localAccount ?? null;
+    let accountForConfigRefresh: Account | null = localAccount;
 
     const guardianCommitment = normalizeHexWord(state.commitment);
     const localCommitment = localAccount
@@ -637,24 +650,44 @@ export class Multisig {
     if (!localAccount || localCommitment !== guardianCommitment) {
       const accountBytes = base64ToUint8Array(state.stateDataBase64);
       const incomingAccount = Account.deserialize(accountBytes);
-      if (await this.isSafeToOverwriteLocalState(incomingAccount, localAccount)) {
-        await webClient.newAccount(incomingAccount, true);
+      if (await this.isSafeToOverwriteLocalState(incomingAccount, localAccount ?? undefined)) {
+        await this.midenClient.accounts.insert({ account: incomingAccount, overwrite: true });
         accountForConfigRefresh = incomingAccount;
       }
     }
 
     this.refreshConfigFromAccount(accountForConfigRefresh);
 
-    return state;
+    return { source: 'guardian', state };
+  }
+
+  /**
+   * The pre-check decision: GUARDIAN has nothing newer when its canonical
+   * nonce is below the local nonce, or equal to it at the same commitment.
+   * An equal nonce with a different commitment is divergence, which the
+   * full fetch reports (see `isSafeToOverwriteLocalState`).
+   */
+  private guardianIsNotAhead(
+    localAccount: Account,
+    localNonce: bigint,
+    guardianCommitment: string,
+    guardianNonce: bigint,
+  ): boolean {
+    if (guardianNonce < localNonce) {
+      return true;
+    }
+    if (guardianNonce > localNonce) {
+      return false;
+    }
+    return (
+      normalizeHexWord(guardianCommitment) ===
+      normalizeHexWord(localAccount.to_commitment().toHex())
+    );
   }
 
   async verifyStateCommitment(): Promise<AccountStateVerificationResult> {
     const accountId = AccountId.fromHex(this._accountId);
-    const webClient = await this.getRawClient();
-    const localAccount = await retryRpcRead(
-      () => webClient.getAccount(accountId),
-      this.rpcConfig,
-    );
+    const localAccount = await this.readStoreAccount();
 
     if (!localAccount) {
       throw new Error(
@@ -725,14 +758,10 @@ export class Multisig {
    * fail.
    */
   private async syncNetworkOnly(): Promise<Account | null> {
-    const webClient = await this.getRawClient();
-    await retryRpcRead(() => webClient.syncState(), this.rpcConfig);
-    const account = await retryRpcRead(
-      () => webClient.getAccount(AccountId.fromHex(this._accountId)),
-      this.rpcConfig,
-    );
-    this.refreshConfigFromAccount(account ?? null);
-    return account ?? null;
+    await this.syncChain();
+    const account = await this.readStoreAccount();
+    this.refreshConfigFromAccount(account);
+    return account;
   }
 
   private refreshConfigFromAccount(account: Account | null): void {
@@ -1047,7 +1076,6 @@ export class Multisig {
     ...legacyArgs: never[]
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createAddSignerProposal', options, legacyArgs);
-    const webClient = await this.getRawClient();
     const targetThreshold = options.newThreshold ?? this.threshold;
     const targetSignerCommitments = [...this.signerCommitments, newCommitment];
     // What `update_signers_and_threshold` rejects on-chain, and what the auth
@@ -1061,13 +1089,13 @@ export class Multisig {
     this.warnOnOverrideDilution(targetSignerCommitments.length);
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      webClient,
+      this.midenClient,
       targetThreshold,
       targetSignerCommitments,
       this.proposalRequestOptions(options),
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1098,7 +1126,6 @@ export class Multisig {
     ...legacyArgs: never[]
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createRemoveSignerProposal', options, legacyArgs);
-    const webClient = await this.getRawClient();
     const normalizedRemove = signerToRemove.toLowerCase();
     const targetSignerCommitments = this.signerCommitments.filter(
       (c) => c.toLowerCase() !== normalizedRemove
@@ -1120,13 +1147,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      webClient,
+      this.midenClient,
       targetThreshold,
       targetSignerCommitments,
       this.proposalRequestOptions(options),
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1155,7 +1182,6 @@ export class Multisig {
     options: CreateProposalOptions = {},
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createChangeThresholdProposal', options);
-    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}`
@@ -1167,13 +1193,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateSignersTransactionRequest(
-      webClient,
+      this.midenClient,
       newThreshold,
       this.signerCommitments,
       this.proposalRequestOptions(options),
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1197,7 +1223,6 @@ export class Multisig {
     options: CreateProposalOptions = {},
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createUpdateProcedureThresholdProposal', options);
-    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}`
@@ -1216,13 +1241,13 @@ export class Multisig {
     }
 
     const { request, salt } = await buildUpdateProcedureThresholdTransactionRequest(
-      webClient,
+      this.midenClient,
       targetProcedure,
       targetThreshold,
       this.proposalRequestOptions(options),
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1279,7 +1304,6 @@ export class Multisig {
     newGuardianPubkey: string,
     approvalExpirationDelta: number | undefined,
   ): Promise<{ summaryBase64: string; metadata: ProposalMetadata }> {
-    const webClient = await this.getRawClient();
     // What `auth_tx_guarded_multisig` asserts after a guardian rotation, checked
     // before any signature is collected.
     validateMultisigConfig({
@@ -1290,7 +1314,7 @@ export class Multisig {
     await this.verifyGuardianEndpointCommitment(newGuardianEndpoint, newGuardianPubkey);
 
     const { request, salt } = await buildUpdateGuardianTransactionRequest(
-      webClient,
+      this.midenClient,
       newGuardianPubkey,
       {
         accountId: this._accountId,
@@ -1299,7 +1323,7 @@ export class Multisig {
       },
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1390,16 +1414,14 @@ export class Multisig {
     options: CreateProposalOptions = {},
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createConsumeNotesProposal', options);
-    const webClient = await this.getRawClient();
     if (noteIds.length === 0) {
       throw new Error('At least one note ID is required');
     }
 
     // Fetch notes locally (proposer has them per FR-012); embed for v2 verification.
-    const rawClient = await getRawMidenClient(webClient);
     const fetchedNotes: Note[] = [];
     for (const noteIdHex of noteIds) {
-      const inputNoteRecord = await rawClient.getInputNote(noteIdHex);
+      const inputNoteRecord = await this.midenClient.notes.get(noteIdHex);
       if (!inputNoteRecord) {
         throw new LegacyConsumeNotesNoteMissingError(noteIdHex);
       }
@@ -1412,12 +1434,12 @@ export class Multisig {
     const embeddedNotes = fetchedNotes.map((n) => noteToBase64(n));
 
     const { request, salt } = await buildConsumeNotesTransactionRequestFromNotes(
-      webClient,
+      this.midenClient,
       fetchedNotes,
       this.proposalRequestOptions(options),
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1464,7 +1486,6 @@ export class Multisig {
     ...legacyArgs: never[]
   ): Promise<Proposal> {
     const proposalNonce = resolveProposalNonce('createP2idProposal', options, legacyArgs);
-    const webClient = await this.getRawClient();
     if (amount <= 0n) {
       throw new Error('Amount must be greater than 0');
     }
@@ -1473,7 +1494,7 @@ export class Multisig {
     // CreateP2idProposalOptions can't be silently dropped before the builder.
     const { nonce: _nonce, ...noteOptions } = options;
     const { request, salt } = await buildP2idTransactionRequest(
-      webClient,
+      this.midenClient,
       this._accountId,
       recipientId,
       faucetId,
@@ -1481,7 +1502,7 @@ export class Multisig {
       noteOptions,
     );
 
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -1508,49 +1529,25 @@ export class Multisig {
   /**
    * Get notes that can be consumed by this multisig account.
    *
-   * Returns a list of notes that are committed on-chain and can be consumed
-   * immediately by the multisig account.
+   * Returns the notes the Miden client's last sync screened as consumable by
+   * this account right now; block-locked notes are left out.
    */
   async getConsumableNotes(): Promise<ConsumableNote[]> {
-    const accountId = AccountId.fromHex(this._accountId);
-    const webClient = await this.getRawClient();
+    const records = await this.midenClient.notes.listAvailable({ account: this._accountId });
 
-    // Get consumable notes for this account
-    const consumableRecords = await webClient.getConsumableNotes(accountId);
-
-    // Convert to our simplified ConsumableNote type
     const notes: ConsumableNote[] = [];
-    for (const record of consumableRecords) {
-      const inputNote = record.inputNoteRecord();
-      const consumability = record.noteConsumability();
-
-      // Only include notes that can be consumed now (consumableAfterBlock is undefined/null)
-      const canConsumeNow = consumability.some(
-        (c) => c.accountId().toString().toLowerCase() === this._accountId.toLowerCase() &&
-               c.consumptionStatus().consumableAfterBlock() === undefined
-      );
-
-      if (canConsumeNow) {
-        // Miden 0.15: InputNoteRecord.id() is `NoteId | undefined`; skip id-less records.
-        const id = inputNote.id();
-        if (id === undefined) {
-          continue;
-        }
-        const noteId = id.toString();
-        const details = inputNote.details();
-        const fungibleAssets = details.assets().fungibleAssets();
-
-        // Extract assets
-        const assets: NoteAsset[] = [];
-        for (const asset of fungibleAssets) {
-          assets.push({
-            faucetId: asset.faucetId().toString(),
-            amount: asset.amount(),
-          });
-        }
-
-        notes.push({ id: noteId, assets });
+    for (const inputNote of records) {
+      // Miden 0.15: InputNoteRecord.id() is `NoteId | undefined`; skip id-less records.
+      const id = inputNote.id();
+      if (id === undefined) {
+        continue;
       }
+      const assets: NoteAsset[] = inputNote
+        .details()
+        .assets()
+        .fungibleAssets()
+        .map((asset) => ({ faucetId: asset.faucetId().toString(), amount: asset.amount() }));
+      notes.push({ id: id.toString(), assets });
     }
 
     return notes;
@@ -1574,12 +1571,11 @@ export class Multisig {
    * @returns Serialized note file bytes
    */
   async exportNoteToBytes(noteId: string): Promise<Uint8Array> {
-    const webClient = await this.getRawClient();
     const trimmedNoteId = noteId.trim();
 
-    let record;
+    let record: OutputNoteRecord | undefined;
     try {
-      record = await webClient.getOutputNote(trimmedNoteId);
+      [record] = await this.midenClient.notes.listSent({ ids: [trimmedNoteId] });
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
       throw new Error(
@@ -1595,7 +1591,7 @@ export class Multisig {
     const format = record.inclusionProof()
       ? NoteExportFormat.Full
       : NoteExportFormat.Details;
-    const noteFile = await webClient.exportNoteFile(trimmedNoteId, format);
+    const noteFile = await this.midenClient.notes.export(trimmedNoteId, { format });
     return noteFile.serialize();
   }
 
@@ -1642,8 +1638,6 @@ export class Multisig {
    *   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);
@@ -1652,7 +1646,7 @@ export class Multisig {
       throw new Error(`failed to decode note file: ${detail}`);
     }
 
-    return webClient.importNoteFile(noteFile);
+    return this.midenClient.notes.import(noteFile);
   }
 
   /**
@@ -2160,10 +2154,7 @@ export class Multisig {
    * syncing first when this client is still below the block the request binds.
    */
   private async submitAtTip(request: TransactionRequest): Promise<void> {
-    const webClient = await this.getRawClient();
-    await prepareTipExecution(webClient, request, () =>
-      retryRpcRead(() => webClient.syncState(), this.rpcConfig),
-    );
+    await prepareTipExecution(this.midenClient, request, () => this.syncChain());
     await this.proverWorkflow.submit(AccountId.fromHex(this._accountId), request);
   }
 
@@ -2173,16 +2164,12 @@ export class Multisig {
    * store's sync height, which a node prunes about 50 blocks later.
    */
   private async syncChain(): Promise<void> {
-    const webClient = await this.getRawClient();
-    await retryRpcRead(() => webClient.syncState(), this.rpcConfig);
+    await retryRpcRead(() => this.midenClient.syncChain(), this.rpcConfig);
   }
 
   /** {@link syncToBoundBlock} with this client's RPC retry policy. */
   private async syncToBoundBlock(boundBlockNum: number): Promise<void> {
-    const webClient = await this.getRawClient();
-    await syncToBoundBlock(webClient, boundBlockNum, () =>
-      retryRpcRead(() => webClient.syncState(), this.rpcConfig),
-    );
+    await syncToBoundBlock(this.midenClient, boundBlockNum, () => this.syncChain());
   }
 
   /**
@@ -2213,9 +2200,8 @@ export class Multisig {
       );
     }
 
-    const webClient = await this.getRawClient();
     const request = deserializeTransactionRequest(transactionRequestBytes);
-    const { summary, anchor } = await executeForSummary(webClient, this._accountId, request);
+    const { summary, anchor } = await executeForSummary(this.midenClient, this._accountId, request);
     const chainAnchor = chainAnchorToBase64(anchor);
     anchor.free();
     const summaryBase64 = uint8ArrayToBase64(summary.serialize());
@@ -2298,8 +2284,7 @@ export class Multisig {
     } finally {
       anchor.free();
     }
-    const webClient = await this.getRawClient();
-    const derived = await executeForSummaryAtTip(webClient, this._accountId, bindingRequest);
+    const derived = await executeForSummaryAtTip(this.midenClient, this._accountId, bindingRequest);
     const derivedCommitmentHex = normalizeHexWord(derived.toCommitment().toHex());
     if (derivedCommitmentHex !== signedCommitmentHex) {
       throw new Error(
@@ -2874,7 +2859,6 @@ export class Multisig {
       // to the block the summary binds; a cosigner that has only just loaded
       // the account has not.
       await this.syncToBoundBlock(binding.boundBlockNum);
-      const webClient = await this.getRawClient();
 
       // A consume-notes summary commits to *authenticated* consumption (see
       // ensureNotesAuthenticated), which miden-client decides from this store
@@ -2888,7 +2872,7 @@ export class Multisig {
       }
 
       const request = await this.buildTransactionRequestFromMetadata(proposal.metadata, binding);
-      const reconstructed = await executeForSummaryAtTip(webClient, this._accountId, request);
+      const reconstructed = await executeForSummaryAtTip(this.midenClient, this._accountId, request);
       const reconstructedCommitment = normalizeHexWord(reconstructed.toCommitment().toHex());
 
       if (reconstructedCommitment !== txSummaryCommitment) {
@@ -2978,8 +2962,7 @@ export class Multisig {
     if (expirationBlockNum === undefined) {
       return;
     }
-    const webClient = await this.getRawClient();
-    const syncHeight = await webClient.getSyncHeight();
+    const syncHeight = await this.midenClient.getSyncHeight();
     if (syncHeight >= expirationBlockNum) {
       throw new Error(
         `Proposal ${proposalId} approval expired at block ${expirationBlockNum}; the chain is at ` +
@@ -3018,13 +3001,12 @@ export class Multisig {
     metadata: ProposalMetadata,
     requestOptions: MultisigRequestOptions,
   ): Promise<TransactionRequest> {
-    const webClient = await this.getRawClient();
     switch (metadata.proposalType) {
       case 'add_signer':
       case 'remove_signer':
       case 'change_threshold': {
         const { request } = await buildUpdateSignersTransactionRequest(
-          webClient,
+          this.midenClient,
           metadata.targetThreshold,
           metadata.targetSignerCommitments,
           requestOptions,
@@ -3033,7 +3015,7 @@ export class Multisig {
       }
       case 'switch_guardian': {
         const { request } = await buildUpdateGuardianTransactionRequest(
-          webClient,
+          this.midenClient,
           metadata.newGuardianPubkey,
           requestOptions,
         );
@@ -3041,7 +3023,7 @@ export class Multisig {
       }
       case 'update_procedure_threshold': {
         const { request } = await buildUpdateProcedureThresholdTransactionRequest(
-          webClient,
+          this.midenClient,
           metadata.targetProcedure,
           metadata.targetThreshold,
           requestOptions,
@@ -3054,7 +3036,7 @@ export class Multisig {
         if (version === CONSUME_NOTES_METADATA_VERSION_V2) {
           const decoded = decodeEmbeddedConsumeNotes(metadata);
           const { request } = await buildConsumeNotesTransactionRequestFromNotes(
-            webClient,
+            this.midenClient,
             decoded,
             requestOptions,
           );
@@ -3067,7 +3049,7 @@ export class Multisig {
             throw new UnsupportedMetadataVersionError(version);
           }
           const { request } = await buildConsumeNotesTransactionRequest(
-            webClient,
+            this.midenClient,
             metadata.noteIds,
             requestOptions,
           );
@@ -3077,7 +3059,7 @@ export class Multisig {
       }
       case 'p2id': {
         const { request } = await buildP2idTransactionRequest(
-          webClient,
+          this.midenClient,
           this._accountId,
           metadata.recipientId,
           metadata.faucetId,

package/src/procedures.ts

@@ -11,11 +11,11 @@
  * human-readable encoding and should not be copied into this table.
  */
 export const PROCEDURE_ROOTS = {
-  update_signers: '0xe39b380d435dd42206fd625fcddfd26a379a2312cfef0271e9b5f18cbdec67e5',
-  update_procedure_threshold: '0x5de3563f30c5dd130da49c8fdd86d867fed6dbbd928363021c53ef99d8034bac',
-  auth_tx: '0xf988ff88c7a9c2104d77862d580239ec40e060a9b4d2d96028135abeb8cc58bc',
+  update_signers: '0x0f664cdaae422fe43bb45d959c7e469b0c855ad1fc4e79fddd730ec3cb983c6e',
+  update_procedure_threshold: '0xa32cd13808fd8fb91adb3dceaed4d8faebc3bd80fa49c2903be4b8d7bf89ba77',
+  auth_tx: '0x71ba7380c6138d5e80e911094a9767ed0fa5c8ffefcf6a776754bfc75bc163b9',
   update_guardian: '0x93dedb135fd5bb7112c07aacf4a5680ddc76e45ecf043bfc42ea735b6d971911',
-  send_asset: '0x936e9920bffd7f458cc9ba2c4bbcc018fc4d3561511d79635955129268039dd7',
+  send_asset: '0xf261e7bdd1faee5db3b0abe4bb67b153fbca6ece3e456b83eff98697f21f6a97',
   receive_asset: '0xd7416b798a70aabbca510c3cd0f48ba35473b5d76dc302375157c6f563fffc15',
 } as const;
 
@@ -33,7 +33,7 @@ export type ProcedureName = keyof typeof PROCEDURE_ROOTS;
  * @example
  * ```typescript
  * const root = getProcedureRoot('send_asset');
- * // '0x936e9920bffd7f458cc9ba2c4bbcc018fc4d3561511d79635955129268039dd7'
+ * // '0xf261e7bdd1faee5db3b0abe4bb67b153fbca6ece3e456b83eff98697f21f6a97'
  * ```
  */
 export function getProcedureRoot(name: ProcedureName): string {