@openzeppelin/miden-multisig-client 0.13.4 → 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[] = [];
@@ -880,10 +904,7 @@ export class Multisig {
     const { metadata, finalRequest, proposal } = await this.prepareProposalExecution(proposalId);
 
     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);
+    await this.midenClient.transactions.submit(accountId, finalRequest);
 
     if (metadata.proposalType === 'switch_guardian') {
       if (!metadata.newGuardianEndpoint || !metadata.newGuardianPubkey) {
@@ -891,9 +912,10 @@ export class Multisig {
       }
 
       try {
-        await this.webClient.syncState();
+        const webClient = await this.getRawClient();
+        await webClient.syncState();
 
-        const updatedAccount = await this.webClient.getAccount(accountId);
+        const updatedAccount = await webClient.getAccount(accountId);
         if (!updatedAccount) {
           throw new Error(
             `Updated account ${this._accountId} is missing from local client`
@@ -1249,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) {
@@ -1264,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 }
@@ -1278,7 +1303,7 @@ export class Multisig {
       }
       case 'switch_guardian': {
         const { request } = await buildUpdateGuardianTransactionRequest(
-          this.webClient,
+          webClient,
           metadata.newGuardianPubkey,
           { salt, signatureAdviceMap, signatureScheme: this.signer.scheme }
         );
@@ -1286,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 }
@@ -1295,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');
+  });
+});

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();
+  });
 });