@openzeppelin/miden-multisig-client 0.13.3 → 0.14.3

package/src/raw-client.ts

@@ -0,0 +1,75 @@
+import {
+  MidenClient,
+  type TransactionProver,
+  type TransactionScript,
+  WasmWebClient,
+} from '@miden-sdk/miden-sdk';
+
+export const DEFAULT_MIDEN_RPC_URL = 'https://rpc.devnet.miden.io';
+
+export type RawClientSource = MidenClient | WasmWebClient;
+export interface ScriptLibrarySource {
+  namespace: string;
+  code: string;
+  linking?: 'dynamic' | 'static';
+}
+
+const rawClientCache = new WeakMap<MidenClient, Promise<WasmWebClient>>();
+
+export function resolveMidenRpcEndpoint(endpoint?: string): string {
+  return endpoint ?? DEFAULT_MIDEN_RPC_URL;
+}
+
+function isPublicMidenClient(client: RawClientSource): client is MidenClient {
+  return 'accounts' in client && 'sync' in client;
+}
+
+export function getRawMidenClient(
+  client: RawClientSource,
+  rpcUrl?: string,
+): Promise<WasmWebClient> {
+  if (!isPublicMidenClient(client)) {
+    return Promise.resolve(client);
+  }
+
+  const cached = rawClientCache.get(client);
+  if (cached) {
+    return cached;
+  }
+
+  const rawClient = WasmWebClient.createClient(
+    resolveMidenRpcEndpoint(rpcUrl),
+    undefined,
+    undefined,
+    client.storeIdentifier(),
+  );
+  rawClientCache.set(client, rawClient);
+  return rawClient;
+}
+
+export function getTransactionProver(client: RawClientSource): TransactionProver | null {
+  return isPublicMidenClient(client) ? client.defaultProver : null;
+}
+
+export async function compileTxScript(
+  client: RawClientSource,
+  code: string,
+  libraries: ScriptLibrarySource[] = [],
+  rpcUrl?: string,
+): Promise<TransactionScript> {
+  if (isPublicMidenClient(client)) {
+    return client.compile.txScript({ code, libraries });
+  }
+
+  const rawClient = await getRawMidenClient(client, rpcUrl);
+  const builder = 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);
+}

package/src/signers/ecdsa.test.ts

@@ -6,10 +6,12 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5]),
   };
 
+  const mockCommitment = {
+    toHex: () => '0x' + 'a'.repeat(64),
+  };
+
   const mockPublicKey = {
-    toCommitment: () => ({
-      toHex: () => '0x' + 'a'.repeat(64),
-    }),
+    toCommitment: () => mockCommitment,
     serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
   };
 
@@ -27,7 +29,8 @@ vi.mock('@miden-sdk/miden-sdk', () => {
       })),
     },
     AccountId: {
-      fromHex: vi.fn(() => ({
+      fromHex: vi.fn((hex: string) => ({
+        toString: () => hex,
         prefix: () => ({ asInt: () => BigInt(1) }),
         suffix: () => ({ asInt: () => BigInt(2) }),
       })),
@@ -77,4 +80,32 @@ describe('EcdsaSigner', () => {
     expect(mockSecretKey.sign).toHaveBeenCalled();
     expect(Rpo256.hashElements).toHaveBeenCalledTimes(2);
   });
+
+  it('skips rebinding when the signer key is already attached to the same account', async () => {
+    const accountId = '0x' + 'd'.repeat(30);
+    const midenClient = {
+      keystore: {
+        getAccountId: vi.fn().mockResolvedValue({ toString: () => accountId }),
+        insert: vi.fn().mockResolvedValue(undefined),
+      },
+    };
+
+    await signer.bindAccountKey(midenClient as never, accountId);
+
+    expect(midenClient.keystore.insert).not.toHaveBeenCalled();
+  });
+
+  it('throws when the signer key is already attached to a different account', async () => {
+    const midenClient = {
+      keystore: {
+        getAccountId: vi.fn().mockResolvedValue({ toString: () => '0x' + 'e'.repeat(30) }),
+        insert: vi.fn().mockResolvedValue(undefined),
+      },
+    };
+
+    await expect(
+      signer.bindAccountKey(midenClient as never, '0x' + 'd'.repeat(30)),
+    ).rejects.toThrow('already bound to account');
+    expect(midenClient.keystore.insert).not.toHaveBeenCalled();
+  });
 });

package/src/signers/ecdsa.ts

@@ -1,5 +1,5 @@
 import type { RequestAuthPayload } from '@openzeppelin/guardian-client';
-import { AuthSecretKey } from '@miden-sdk/miden-sdk';
+import { AccountId, AuthSecretKey, type MidenClient, type Word } from '@miden-sdk/miden-sdk';
 import type { Signer, SignatureScheme } from '../types.js';
 import { bytesToHex, normalizeHexWord } from '../utils/encoding.js';
 import { AuthDigest } from '../utils/digest.js';
@@ -9,13 +9,15 @@ export class EcdsaSigner implements Signer {
   readonly publicKey: string;
   readonly scheme: SignatureScheme = 'ecdsa';
   private readonly secretKey: AuthSecretKey;
+  private readonly publicKeyCommitment: Word;
 
   constructor(secretKey: AuthSecretKey) {
     this.secretKey = secretKey;
     const pubKey = secretKey.publicKey();
     const serialized = pubKey.serialize();
     this.publicKey = bytesToHex(serialized.slice(1));
-    this.commitment = normalizeHexWord(pubKey.toCommitment().toHex());
+    this.publicKeyCommitment = pubKey.toCommitment();
+    this.commitment = normalizeHexWord(this.publicKeyCommitment.toHex());
   }
 
   async signAccountIdWithTimestamp(accountId: string, timestamp: number): Promise<string> {
@@ -37,6 +39,20 @@ export class EcdsaSigner implements Signer {
     return this.signWord(word);
   }
 
+  async bindAccountKey(midenClient: MidenClient, accountId: string): Promise<void> {
+    const targetAccountId = AccountId.fromHex(accountId);
+    const existingAccountId = await midenClient.keystore.getAccountId(this.publicKeyCommitment);
+    if (existingAccountId) {
+      if (existingAccountId.toString().toLowerCase() === accountId.toLowerCase()) {
+        return;
+      }
+      throw new Error(
+        `Signer commitment ${this.commitment} is already bound to account ${existingAccountId.toString()}`,
+      );
+    }
+    await midenClient.keystore.insert(targetAccountId, this.secretKey);
+  }
+
   private signWord(word: ReturnType<typeof AuthDigest.fromCommitmentHex>): string {
     const signature = this.secretKey.sign(word);
     const signatureBytes = signature.serialize();

package/src/signers/falcon.test.ts

@@ -6,10 +6,12 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
   };
 
+  const mockCommitment = {
+    toHex: () => '0x' + 'a'.repeat(64),
+  };
+
   const mockPublicKey = {
-    toCommitment: () => ({
-      toHex: () => '0x' + 'a'.repeat(64),
-    }),
+    toCommitment: () => mockCommitment,
     serialize: () => new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]),
   };
 
@@ -30,6 +32,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     },
     AccountId: {
       fromHex: vi.fn((hex: string) => ({
+        toString: () => hex,
         prefix: () => ({ asInt: () => BigInt(1) }),
         suffix: () => ({ asInt: () => BigInt(2) }),
       })),
@@ -147,4 +150,48 @@ describe('FalconSigner', () => {
       expect(signature).toBe('0x010203040506070809');
     });
   });
+
+  describe('bindAccountKey', () => {
+    it('inserts the signer key when the commitment is not bound yet', async () => {
+      const midenClient = {
+        keystore: {
+          getAccountId: vi.fn().mockResolvedValue(null),
+          insert: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      await signer.bindAccountKey(midenClient as never, '0x' + 'd'.repeat(30));
+
+      expect(midenClient.keystore.getAccountId).toHaveBeenCalledTimes(1);
+      expect(midenClient.keystore.insert).toHaveBeenCalledTimes(1);
+    });
+
+    it('skips insert when the signer key is already bound to the same account', async () => {
+      const accountId = '0x' + 'd'.repeat(30);
+      const midenClient = {
+        keystore: {
+          getAccountId: vi.fn().mockResolvedValue({ toString: () => accountId }),
+          insert: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      await signer.bindAccountKey(midenClient as never, accountId);
+
+      expect(midenClient.keystore.insert).not.toHaveBeenCalled();
+    });
+
+    it('throws when the signer key is already bound to a different account', async () => {
+      const midenClient = {
+        keystore: {
+          getAccountId: vi.fn().mockResolvedValue({ toString: () => '0x' + 'e'.repeat(30) }),
+          insert: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      await expect(
+        signer.bindAccountKey(midenClient as never, '0x' + 'd'.repeat(30)),
+      ).rejects.toThrow('already bound to account');
+      expect(midenClient.keystore.insert).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/signers/falcon.ts

@@ -1,5 +1,5 @@
 import type { RequestAuthPayload } from '@openzeppelin/guardian-client';
-import { AuthSecretKey, type Word } from '@miden-sdk/miden-sdk';
+import { AccountId, AuthSecretKey, type MidenClient, type Word } from '@miden-sdk/miden-sdk';
 import type { Signer, SignatureScheme } from '../types.js';
 import { bytesToHex } from '../utils/encoding.js';
 import { AuthDigest } from '../utils/digest.js';
@@ -9,11 +9,13 @@ export class FalconSigner implements Signer {
   readonly publicKey: string;
   readonly scheme: SignatureScheme = 'falcon';
   private readonly secretKey: AuthSecretKey;
+  private readonly publicKeyCommitment: Word;
 
   constructor(secretKey: AuthSecretKey) {
     this.secretKey = secretKey;
     const pubKey = secretKey.publicKey();
-    this.commitment = pubKey.toCommitment().toHex();
+    this.publicKeyCommitment = pubKey.toCommitment();
+    this.commitment = this.publicKeyCommitment.toHex();
     const serialized = pubKey.serialize();
     const falconPubKey = serialized.slice(1);
     this.publicKey = bytesToHex(falconPubKey);
@@ -38,6 +40,20 @@ export class FalconSigner implements Signer {
     return this.signWord(word);
   }
 
+  async bindAccountKey(midenClient: MidenClient, accountId: string): Promise<void> {
+    const targetAccountId = AccountId.fromHex(accountId);
+    const existingAccountId = await midenClient.keystore.getAccountId(this.publicKeyCommitment);
+    if (existingAccountId) {
+      if (existingAccountId.toString().toLowerCase() === accountId.toLowerCase()) {
+        return;
+      }
+      throw new Error(
+        `Signer commitment ${this.commitment} is already bound to account ${existingAccountId.toString()}`,
+      );
+    }
+    await midenClient.keystore.insert(targetAccountId, this.secretKey);
+  }
+
   private signWord(word: Word): string {
     const signature = this.secretKey.sign(word);
     const signatureBytes = signature.serialize();

package/src/transaction/consumeNotes.ts

@@ -1,11 +1,22 @@
-import type { TransactionRequest, Word, WebClient } from '@miden-sdk/miden-sdk';
-import { NoteAndArgs, NoteAndArgsArray, TransactionRequestBuilder, Word as WordType } from '@miden-sdk/miden-sdk';
+import type {
+  MidenClient,
+  TransactionRequest,
+  WasmWebClient,
+  Word,
+} from '@miden-sdk/miden-sdk';
+import {
+  NoteAndArgs,
+  NoteAndArgsArray,
+  TransactionRequestBuilder,
+  Word as WordType,
+} from '@miden-sdk/miden-sdk';
+import { getRawMidenClient } from '../raw-client.js';
 import { randomWord } from '../utils/random.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
 
 export async function buildConsumeNotesTransactionRequest(
-  webClient: WebClient,
+  client: MidenClient | WasmWebClient,
   noteIds: string[],
   options: SignatureOptions = {},
 ): Promise<{ request: TransactionRequest; salt: Word }> {
@@ -13,10 +24,10 @@ export async function buildConsumeNotesTransactionRequest(
     throw new Error('At least one note ID is required');
   }
 
-  // Fetch full Note objects from the client store
+  const rawClient = await getRawMidenClient(client, options.midenRpcEndpoint);
   const noteAndArgsArray = new NoteAndArgsArray();
   for (const noteIdHex of noteIds) {
-    const inputNoteRecord = await webClient.getInputNote(noteIdHex);
+    const inputNoteRecord = await rawClient.getInputNote(noteIdHex);
     if (!inputNoteRecord) {
       throw new Error(`Note not found in local store: ${noteIdHex}`);
     }

package/src/transaction/options.ts

@@ -5,4 +5,5 @@ export interface SignatureOptions {
   salt?: Word;
   signatureAdviceMap?: AdviceMap;
   signatureScheme?: SignatureScheme;
+  midenRpcEndpoint?: string;
 }

package/src/transaction/p2id.test.ts

@@ -21,10 +21,20 @@ const {
     mockRandomWord: vi.fn().mockReturnValue({
       toHex: () => '0x' + 'aa'.repeat(32),
     }),
-    mockWordFromHex: vi.fn((hex: string) => ({
-      toHex: () => hex,
-      toFelts: () => saltFelts,
-    })),
+    mockWordFromHex: vi.fn((hex: string) => {
+      const normalized = hex.toLowerCase();
+      return {
+        toHex: () => hex,
+        toFelts: () => normalized === `0x${'00'.repeat(32)}`
+          ? [
+              { value: 0n },
+              { value: 0n },
+              { value: 0n },
+              { value: 0n },
+            ]
+          : saltFelts,
+      };
+    }),
     saltFelts,
   };
 });
@@ -50,7 +60,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     constructor(_assets: unknown[]) {}
   }
 
-  class NoteInputs {
+  class NoteStorage {
     constructor(_inputs: FeltArray) {}
   }
 
@@ -82,7 +92,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     constructor(_faucet: unknown, _amount: bigint) {}
   }
 
-  class OutputNoteArray {
+  class NoteArray {
     constructor(_notes: unknown[]) {}
   }
 
@@ -116,13 +126,13 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     FeltArray,
     FungibleAsset,
     MidenArrays: {
-      OutputNoteArray,
+      NoteArray,
     },
     Note,
     NoteAssets,
-    NoteInputs,
     NoteMetadata,
     NoteRecipient,
+    NoteStorage,
     NoteScript: {
       p2id: vi.fn(() => ({ kind: 'p2id-script' })),
     },
@@ -135,7 +145,7 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     OutputNote: {
       full: vi.fn((note: unknown) => ({ note })),
     },
-    Rpo256: {
+    Poseidon2: {
       hashElements: mockHashElements,
     },
     TransactionRequestBuilder,

package/src/transaction/p2id.ts

@@ -1,20 +1,18 @@
 import type { TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import {
   AccountId,
-  Felt,
   FeltArray,
   FungibleAsset,
   MidenArrays,
   Note,
   NoteAssets,
-  NoteInputs,
   NoteMetadata,
   NoteRecipient,
   NoteScript,
+  NoteStorage,
   NoteTag,
   NoteType,
-  OutputNote,
-  Rpo256,
+  Poseidon2,
   TransactionRequestBuilder,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
@@ -23,12 +21,10 @@ import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
 
 export function deriveP2idSerialNumber(salt: Word): Word {
-  return Rpo256.hashElements(new FeltArray([
+  const zeroWord = WordType.fromHex(`0x${'00'.repeat(32)}`);
+  return Poseidon2.hashElements(new FeltArray([
     ...salt.toFelts(),
-    new Felt(0n),
-    new Felt(0n),
-    new Felt(0n),
-    new Felt(0n),
+    ...zeroWord.toFelts(),
   ]));
 }
 
@@ -43,12 +39,12 @@ function buildP2idNote(
   const serialNum = deriveP2idSerialNumber(salt);
 
   const noteScript = NoteScript.p2id();
-  const noteInputs = new NoteInputs(new FeltArray([
+  const noteStorage = new NoteStorage(new FeltArray([
     recipient.suffix(),
     recipient.prefix(),
   ]));
 
-  const noteRecipient = new NoteRecipient(serialNum, noteScript, noteInputs);
+  const noteRecipient = new NoteRecipient(serialNum, noteScript, noteStorage);
   const noteTag = NoteTag.withAccountTarget(recipient);
 
   const noteMetadata = new NoteMetadata(
@@ -84,8 +80,7 @@ export function buildP2idTransactionRequest(
     authSaltHex,
   );
 
-  const outputNote = OutputNote.full(note);
-  const outputNotes = new MidenArrays.OutputNoteArray([outputNote]);
+  const outputNotes = new MidenArrays.NoteArray([note]);
 
   const authSaltForBuilder = WordType.fromHex(normalizeHexWord(authSaltHex));
 

package/src/transaction/summary.ts

@@ -1,12 +1,19 @@
-import type { TransactionRequest, TransactionSummary, WebClient } from '@miden-sdk/miden-sdk';
+import type {
+  MidenClient,
+  TransactionRequest,
+  TransactionSummary,
+  WasmWebClient,
+} from '@miden-sdk/miden-sdk';
 import { AccountId } from '@miden-sdk/miden-sdk';
+import { getRawMidenClient } from '../raw-client.js';
 
 export async function executeForSummary(
-  client: WebClient,
+  client: MidenClient | WasmWebClient,
   accountId: string,
   txRequest: TransactionRequest,
+  midenRpcEndpoint?: string,
 ): Promise<TransactionSummary> {
   const acc = AccountId.fromHex(accountId);
-  return (client as any).executeForSummary(acc, txRequest);
+  const rawClient = await getRawMidenClient(client, midenRpcEndpoint);
+  return rawClient.executeForSummary(acc, txRequest);
 }
-

package/src/transaction/updateGuardian.ts

@@ -1,50 +1,58 @@
 import {
   AdviceMap,
   FeltArray,
+  type MidenClient,
   TransactionRequest,
   TransactionRequestBuilder,
   TransactionScript,
-  WebClient,
+  type WasmWebClient,
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
 import { GUARDIAN_ECDSA_MASM, GUARDIAN_MASM } from '../account/masm/auth.js';
+import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { SignatureOptions } from './options.js';
 import type { SignatureScheme } from '../types.js';
 
-function buildUpdateGuardianScript(
-  webClient: WebClient,
+async function buildUpdateGuardianScript(
+  client: MidenClient | WasmWebClient,
   signatureScheme: SignatureScheme,
-): TransactionScript {
-  const libBuilder = webClient.createCodeBuilder();
-  const guardianLibraryPath = signatureScheme === 'ecdsa' ? 'openzeppelin::guardian_ecdsa' : 'openzeppelin::guardian';
+  midenRpcEndpoint?: string,
+): Promise<TransactionScript> {
+  const guardianLibraryPath = 'oz_guardian::guardian';
   const guardianMasm = signatureScheme === 'ecdsa' ? GUARDIAN_ECDSA_MASM : GUARDIAN_MASM;
-  const guardianProcedure = signatureScheme === 'ecdsa' ? 'guardian_ecdsa' : 'guardian';
-  const guardianLib = libBuilder.buildLibrary(guardianLibraryPath, guardianMasm);
-  libBuilder.linkDynamicLibrary(guardianLib);
 
   const scriptSource = `
-use openzeppelin::${guardianProcedure}
+use oz_guardian::guardian
 
 begin
     adv.push_mapval
     dropw
-    call.${guardianProcedure}::update_guardian_public_key
+    call.guardian::update_guardian_public_key
 end
   `;
 
-  return libBuilder.compileTxScript(scriptSource);
+  return compileTxScript(
+    client,
+    scriptSource,
+    [{ namespace: guardianLibraryPath, code: guardianMasm }],
+    midenRpcEndpoint,
+  );
 }
 
 export async function buildUpdateGuardianTransactionRequest(
-  webClient: WebClient,
+  client: MidenClient | WasmWebClient,
   newGuardianPubkey: string,
   options: SignatureOptions = {},
 ): Promise<{ request: TransactionRequest; salt: Word }> {
   const signatureScheme = options.signatureScheme ?? 'falcon';
-  const script = buildUpdateGuardianScript(webClient, signatureScheme);
+  const script = await buildUpdateGuardianScript(
+    client,
+    signatureScheme,
+    options.midenRpcEndpoint,
+  );
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
 

package/src/transaction/updateProcedureThreshold.ts

@@ -1,11 +1,12 @@
 import {
   Felt,
   FeltArray,
-  Rpo256,
+  type MidenClient,
+  Poseidon2,
   TransactionRequest,
   TransactionRequestBuilder,
   TransactionScript,
-  WebClient,
+  type WasmWebClient,
   Word,
   Word as WordType,
 } from '@miden-sdk/miden-sdk';
@@ -14,6 +15,7 @@ import {
   MULTISIG_MASM,
 } from '../account/masm/auth.js';
 import { getProcedureRoot, type ProcedureName } from '../procedures.js';
+import { compileTxScript } from '../raw-client.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { SignatureOptions } from './options.js';
@@ -31,25 +33,22 @@ function buildProcedureThresholdAdvice(
     new Felt(0n),
     new Felt(0n),
   ]);
-  const configHash = Rpo256.hashElements(payload);
+  const configHash = Poseidon2.hashElements(payload);
   return { configHash, payload };
 }
 
-function buildUpdateProcedureThresholdScript(
-  webClient: WebClient,
+async function buildUpdateProcedureThresholdScript(
+  client: MidenClient | WasmWebClient,
   procedure: ProcedureName,
   threshold: number,
   signatureScheme: SignatureScheme,
-): TransactionScript {
-  const libBuilder = webClient.createCodeBuilder();
+  midenRpcEndpoint?: string,
+): Promise<TransactionScript> {
   const multisigMasm = signatureScheme === 'ecdsa' ? MULTISIG_ECDSA_MASM : MULTISIG_MASM;
-
-  const multisigLib = libBuilder.buildLibrary('auth::multisig', multisigMasm);
-  libBuilder.linkDynamicLibrary(multisigLib);
   const procedureRoot = normalizeHexWord(getProcedureRoot(procedure));
 
   const scriptSource = `
-use auth::multisig
+use oz_multisig::multisig
 
 begin
     push.${procedureRoot}
@@ -60,11 +59,16 @@ begin
 end
   `;
 
-  return libBuilder.compileTxScript(scriptSource);
+  return compileTxScript(
+    client,
+    scriptSource,
+    [{ namespace: 'oz_multisig::multisig', code: multisigMasm }],
+    midenRpcEndpoint,
+  );
 }
 
 export async function buildUpdateProcedureThresholdTransactionRequest(
-  webClient: WebClient,
+  client: MidenClient | WasmWebClient,
   procedure: ProcedureName,
   threshold: number,
   options: SignatureOptions = {},
@@ -72,11 +76,12 @@ export async function buildUpdateProcedureThresholdTransactionRequest(
   const signatureScheme = options.signatureScheme ?? 'falcon';
   const { configHash } = buildProcedureThresholdAdvice(procedure, threshold);
 
-  const script = buildUpdateProcedureThresholdScript(
-    webClient,
+  const script = await buildUpdateProcedureThresholdScript(
+    client,
     procedure,
     threshold,
     signatureScheme,
+    options.midenRpcEndpoint,
   );
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
   const authSalt = WordType.fromHex(normalizeHexWord(authSaltHex));