@openzeppelin/miden-multisig-client 0.12.6 → 0.12.8

package/src/procedures.ts

@@ -1,72 +1,37 @@
-/**
- * known procedure roots for multisig accounts.
- *
- * IMPORTANT: These values are extracted from the TypeScript SDK's compiled MASM output,
- * NOT from the Rust crate. The SDK may compile MASM differently, resulting in different
- * procedure roots. Use the debug output from builder.ts to update these values.
- */
+import type { SignatureScheme } from '@openzeppelin/psm-client';
 
-/**
- * Static mapping of procedure names to their deterministic roots.
- *
- * Component ordering: Multisig (auth) -> PSM -> BasicWallet
- */
-export const PROCEDURE_ROOTS = {
-  // Multisig component procedures
-  /** Update signer list and threshold configuration */
+export const PROCEDURE_ROOTS_FALCON = {
   update_signers: '0x53d0ad381a193de0cf6af3730141e498274103dfc3b8c8e7367bd49d4a66c72b',
-  /** Authenticate transaction with multisig (Falcon512) */
   auth_tx: '0x474c613b38001cc36d68557e9d881495d6a461a9027033445c7672c586509026',
-
-  // PSM component procedures
-  /** Update PSM public key */
   update_psm: '0xb103236807e5bf09c27efc2c5287ca8b03ab9efc1d852b62ebd31f5f1927ec26',
-  /** Verify PSM signature */
   verify_psm: '0x30727fc23c6105a678fea8b4c1920f35fa85c03f16a0cf98372c8f56701f8a87',
-
-  // BasicWallet procedures
-  /** Send assets from account (move_asset_to_note) */
   send_asset: '0x0e406b067ed2bcd7de745ca6517f519fd1a9be245f913347ac673ca1db30c1d6',
-  /** Receive assets into account */
   receive_asset: '0x6f4bdbdc4b13d7ed933d590d88ac9dfb98020c9e917697845b5e169395b76a01',
 } as const;
 
-/**
- * Valid procedure names that can be used for threshold overrides.
- */
-export type ProcedureName = keyof typeof PROCEDURE_ROOTS;
+export const PROCEDURE_ROOTS_ECDSA = {
+  update_signers: '0x930f9ea86d33c7b3b2d23c4e9ac2492add461359344ed25b1acd38f3713dd79c',
+  auth_tx: '0x2bc7664a9dd47b36e7c8b8c3df03412798e4410173f36acfe03d191a38add053',
+  update_psm: '0x26ec27195f1fd3eb622b851dfc9eab038bca87522cfc7ec209bfe507682303b1',
+  verify_psm: '0xbeb9e08a83eca030968f2f137b5673136f21bc16c82fd408c2ce2495ccbdcd15',
+  send_asset: '0xd6c130dba13c67ac4733915f24bea9d19f517f51a65c74ded7bcd27e066b400e',
+  receive_asset: '0x016ab79593165e5b849776919e0c0298fb9dac880d593d93edd7134bdcdb4b6f',
+} as const;
+
+export const PROCEDURE_ROOTS = PROCEDURE_ROOTS_FALCON;
+
+export type ProcedureName = keyof typeof PROCEDURE_ROOTS_FALCON;
 
-/**
- * Get the procedure root for a given procedure name.
- *
- * @param name - The procedure name
- * @returns The procedure root as a hex string
- *
- * @example
- * ```typescript
- * const root = getProcedureRoot('receive_asset');
- * // '0x6f4bdbdc4b13d7ed933d590d88ac9dfb98020c9e917697845b5e169395b76a01'
- * ```
- */
-export function getProcedureRoot(name: ProcedureName): string {
-  return PROCEDURE_ROOTS[name];
+export function getProcedureRoot(name: ProcedureName, scheme: SignatureScheme = 'falcon'): string {
+  const roots = scheme === 'ecdsa' ? PROCEDURE_ROOTS_ECDSA : PROCEDURE_ROOTS_FALCON;
+  return roots[name];
 }
 
-/**
- * Check if a string is a valid procedure name.
- *
- * @param name - The string to check
- * @returns true if the string is a valid procedure name
- */
 export function isProcedureName(name: string): name is ProcedureName {
-  return name in PROCEDURE_ROOTS;
+  return name in PROCEDURE_ROOTS_FALCON;
 }
 
-/**
- * Get all available procedure names.
- *
- * @returns Array of all valid procedure names
- */
-export function getProcedureNames(): ProcedureName[] {
-  return Object.keys(PROCEDURE_ROOTS) as ProcedureName[];
+export function getProcedureNames(scheme: SignatureScheme = 'falcon'): ProcedureName[] {
+  const roots = scheme === 'ecdsa' ? PROCEDURE_ROOTS_ECDSA : PROCEDURE_ROOTS_FALCON;
+  return Object.keys(roots) as ProcedureName[];
 }

package/src/signer.ts

@@ -1,27 +1,11 @@
-/**
- * Falcon Signer implementation for PSM client authentication.
- *
- * This implements the Signer interface using the Miden SDK's SecretKey
- * for Falcon signatures.
- */
-
 import { SecretKey, Word, AccountId, Felt, FeltArray, Rpo256 } from '@demox-labs/miden-sdk';
-import type { Signer } from './types.js';
+import type { Signer, SignatureScheme } from './types.js';
 import { bytesToHex } from './utils/encoding.js';
 
-/**
- * A Falcon signer that implements the Signer interface.
- *
- * @example
- * ```typescript
- * const secretKey = SecretKey.rpoFalconWithRNG(seed);
- * const signer = new FalconSigner(secretKey);
- * console.log(signer.commitment);
- * ```
- */
 export class FalconSigner implements Signer {
   readonly commitment: string;
   readonly publicKey: string;
+  readonly scheme: SignatureScheme = 'falcon';
   private readonly secretKey: SecretKey;
 
   constructor(secretKey: SecretKey) {
@@ -33,14 +17,7 @@ export class FalconSigner implements Signer {
     this.publicKey = bytesToHex(falconPubKey);
   }
 
-  /**
-   * Signs an account ID with a timestamp.
-   * @param accountId - The account ID to sign
-   * @param timestamp - Unix timestamp in milliseconds (use Date.now())
-   * @returns Hex-encoded Falcon signature
-   */
   signAccountIdWithTimestamp(accountId: string, timestamp: number): string {
-    // Parse the account ID from hex
     const paddedHex = accountId.startsWith('0x') ? accountId : `0x${accountId}`;
     const parsedAccountId = AccountId.fromHex(paddedHex);
     const prefix = parsedAccountId.prefix();
@@ -60,9 +37,6 @@ export class FalconSigner implements Signer {
     return bytesToHex(falconSignature);
   }
 
-  /**
-   * Signs a commitment/word for proposal signing.
-   */
   signCommitment(commitmentHex: string): string {
     const paddedHex = commitmentHex.startsWith('0x') ? commitmentHex : `0x${commitmentHex}`;
     const cleanHex = paddedHex.slice(2).padStart(64, '0');
@@ -73,3 +47,49 @@ export class FalconSigner implements Signer {
     return bytesToHex(falconSignature);
   }
 }
+
+export class EcdsaSigner implements Signer {
+  readonly commitment: string;
+  readonly publicKey: string;
+  readonly scheme: SignatureScheme = 'ecdsa';
+  private readonly secretKey: SecretKey;
+
+  constructor(secretKey: SecretKey) {
+    this.secretKey = secretKey;
+    const pubKey = secretKey.publicKey();
+    this.commitment = pubKey.toCommitment().toHex();
+    const serialized = pubKey.serialize();
+    const ecdsaPubKey = serialized.slice(1);
+    this.publicKey = bytesToHex(ecdsaPubKey);
+  }
+
+  signAccountIdWithTimestamp(accountId: string, timestamp: number): string {
+    const paddedHex = accountId.startsWith('0x') ? accountId : `0x${accountId}`;
+    const parsedAccountId = AccountId.fromHex(paddedHex);
+    const prefix = parsedAccountId.prefix();
+    const suffix = parsedAccountId.suffix();
+
+    const feltArray = new FeltArray([
+      prefix,
+      suffix,
+      new Felt(BigInt(timestamp)),
+      new Felt(BigInt(0)),
+    ]);
+
+    const digest = Rpo256.hashElements(feltArray);
+    const signature = this.secretKey.sign(digest);
+    const signatureBytes = signature.serialize();
+    const ecdsaSignature = signatureBytes.slice(1);
+    return bytesToHex(ecdsaSignature);
+  }
+
+  signCommitment(commitmentHex: string): string {
+    const paddedHex = commitmentHex.startsWith('0x') ? commitmentHex : `0x${commitmentHex}`;
+    const cleanHex = paddedHex.slice(2).padStart(64, '0');
+    const word = Word.fromHex(`0x${cleanHex}`);
+    const signature = this.secretKey.sign(word);
+    const signatureBytes = signature.serialize();
+    const ecdsaSignature = signatureBytes.slice(1);
+    return bytesToHex(ecdsaSignature);
+  }
+}

package/src/transaction/options.ts

@@ -1,7 +1,9 @@
 import type { AdviceMap, Word } from '@demox-labs/miden-sdk';
+import type { SignatureScheme } from '../types.js';
 
 export interface SignatureOptions {
   salt?: Word;
   signatureAdviceMap?: AdviceMap;
+  signatureScheme?: SignatureScheme;
 }
 

package/src/transaction/updatePsm.ts

@@ -8,12 +8,12 @@ import {
   Word,
   Word as WordType,
 } from '@demox-labs/miden-sdk';
-import { PSM_MASM } from '../account/masm.js';
+import { PSM_ECDSA_MASM, PSM_MASM } from '../account/masm.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { SignatureOptions } from './options.js';
 
-function buildUpdatePsmScript(webClient: WebClient): TransactionScript {
+function buildUpdatePsmFalconScript(webClient: WebClient): TransactionScript {
   const libBuilder = webClient.createScriptBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm', PSM_MASM);
   libBuilder.linkDynamicLibrary(psmLib);
@@ -31,12 +31,33 @@ end
   return libBuilder.compileTxScript(scriptSource);
 }
 
+function buildUpdatePsmEcdsaScript(webClient: WebClient): TransactionScript {
+  const libBuilder = webClient.createScriptBuilder();
+  const psmLib = libBuilder.buildLibrary('openzeppelin::psm_ecdsa', PSM_ECDSA_MASM);
+  libBuilder.linkDynamicLibrary(psmLib);
+
+  const scriptSource = `
+use.openzeppelin::psm_ecdsa
+
+begin
+    adv.push_mapval
+    dropw
+    call.psm_ecdsa::update_psm_public_key
+end
+  `;
+
+  return libBuilder.compileTxScript(scriptSource);
+}
+
 export async function buildUpdatePsmTransactionRequest(
   webClient: WebClient,
   newPsmPubkey: string,
   options: SignatureOptions = {},
 ): Promise<{ request: TransactionRequest; salt: Word }> {
-  const script = buildUpdatePsmScript(webClient);
+  const signatureScheme = options.signatureScheme ?? 'falcon';
+  const script = signatureScheme === 'ecdsa'
+    ? buildUpdatePsmEcdsaScript(webClient)
+    : buildUpdatePsmFalconScript(webClient);
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
 

package/src/transaction/updateSigners.ts

@@ -10,7 +10,7 @@ import {
   Word,
   Word as WordType,
 } from '@demox-labs/miden-sdk';
-import { MULTISIG_MASM, PSM_MASM } from '../account/masm.js';
+import { MULTISIG_ECDSA_MASM, MULTISIG_MASM, PSM_ECDSA_MASM, PSM_MASM } from '../account/masm.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import { randomWord } from '../utils/random.js';
 import type { SignatureOptions } from './options.js';
@@ -35,7 +35,7 @@ function buildMultisigConfigAdvice(
   return { configHash, payload };
 }
 
-function buildUpdateSignersScript(webClient: WebClient): TransactionScript {
+function buildUpdateSignersFalconScript(webClient: WebClient): TransactionScript {
   const libBuilder = webClient.createScriptBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm', PSM_MASM);
   libBuilder.linkStaticLibrary(psmLib);
@@ -54,12 +54,32 @@ end
   return libBuilder.compileTxScript(scriptSource);
 }
 
+function buildUpdateSignersEcdsaScript(webClient: WebClient): TransactionScript {
+  const libBuilder = webClient.createScriptBuilder();
+  const psmLib = libBuilder.buildLibrary('openzeppelin::psm_ecdsa', PSM_ECDSA_MASM);
+  libBuilder.linkStaticLibrary(psmLib);
+
+  const multisigLib = libBuilder.buildLibrary('auth::multisig', MULTISIG_ECDSA_MASM);
+  libBuilder.linkDynamicLibrary(multisigLib);
+
+  const scriptSource = `
+use.auth::multisig
+
+begin
+    call.multisig::update_signers_and_threshold
+end
+  `;
+
+  return libBuilder.compileTxScript(scriptSource);
+}
+
 export async function buildUpdateSignersTransactionRequest(
   webClient: WebClient,
   threshold: number,
   signerCommitments: string[],
   options: SignatureOptions = {},
 ): Promise<{ request: TransactionRequest; salt: Word; configHash: Word }> {
+  const signatureScheme = options.signatureScheme ?? 'falcon';
   const { configHash: configHashForAdvice, payload } = buildMultisigConfigAdvice(threshold, signerCommitments);
 
   const { configHash: configHashForScript } = buildMultisigConfigAdvice(threshold, signerCommitments);
@@ -69,7 +89,9 @@ export async function buildUpdateSignersTransactionRequest(
   const advice = new AdviceMap();
   advice.insert(configHashForAdvice, payload);
 
-  const script = buildUpdateSignersScript(webClient);
+  const script = signatureScheme === 'ecdsa'
+    ? buildUpdateSignersEcdsaScript(webClient)
+    : buildUpdateSignersFalconScript(webClient);
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
 

package/src/transaction.test.ts

@@ -116,6 +116,12 @@ describe('transaction utilities', () => {
       expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
     });
 
+    it('should prepend auth scheme byte (1 = ECDSA)', () => {
+      const result = signatureHexToBytes('deadbeef', 'ecdsa');
+      expect(result[0]).toBe(1); // ECDSA scheme byte
+      expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
+    });
+
     it('should handle 0x prefix', () => {
       const result = signatureHexToBytes('0xaabbccdd');
       expect(result[0]).toBe(0);

package/src/transaction.ts

@@ -1,5 +1,3 @@
-// Backward-compatible entry point for transaction helpers.
-// The implementations now live in ./transaction/.
 export {
   buildConsumeNotesTransactionRequest,
 } from './transaction/consumeNotes.js';

package/src/types/proposal.ts

@@ -1,14 +1,14 @@
-import type { ProposalType as PsmProposalType } from '@openzeppelin/psm-client';
+import type { ProposalType as PsmProposalType, SignatureScheme } from '@openzeppelin/psm-client';
 export type ProposalType = Exclude<PsmProposalType, 'custom'>;
 
-export type ProposalStatus =
+export type TransactionProposalStatus =
   | { type: 'pending'; signaturesCollected: number; signaturesRequired: number; signers: string[] }
   | { type: 'ready' }
   | { type: 'finalized' };
 
-export interface ProposalSignatureEntry {
+export interface TransactionProposalSignature {
   signerId: string;
-  signature: { scheme: 'falcon'; signature: string };
+  signature: { scheme: 'falcon' | 'ecdsa'; signature: string; publicKey?: string };
   timestamp: string;
 }
 
@@ -55,17 +55,18 @@ export type ProposalMetadata =
   | P2IdProposalMetadata
   | UnknownProposalMetadata;
 
-export interface Proposal {
+export interface TransactionProposal {
   id: string;
+  commitment: string;
   accountId: string;
   nonce: number;
-  status: ProposalStatus;
+  status: TransactionProposalStatus;
   txSummary: string;
-  signatures: ProposalSignatureEntry[];
+  signatures: TransactionProposalSignature[];
   metadata: ProposalMetadata;
 }
 
-export interface ExportedProposal {
+export interface ExportedTransactionProposal {
   accountId: string;
   nonce: number;
   commitment: string;
@@ -78,3 +79,9 @@ export interface ExportedProposal {
   metadata?: ProposalMetadata;
 }
 
+export interface SignTransactionProposalParams {
+  commitment: string;
+  signature: string;
+  publicKey?: string;
+  scheme?: SignatureScheme;
+}

package/src/types.ts

@@ -1,9 +1,16 @@
 import type { Account } from '@demox-labs/miden-sdk';
+import type { SignatureScheme } from '@openzeppelin/psm-client';
 import type { ProcedureName } from './procedures.js';
+import type { TransactionProposal } from './types/proposal.js';
+import type { AccountState } from './multisig.js';
+import type { DetectedMultisigConfig } from './inspector.js';
 
 export type {
   Signer,
   FalconSignature,
+  EcdsaSignature,
+  ProposalSignature,
+  SignatureScheme,
   CosignerSignature,
   AuthConfig,
   DeltaStatus,
@@ -19,14 +26,27 @@ export type {
 } from '@openzeppelin/psm-client';
 
 export type {
-  ExportedProposal,
-  Proposal,
+  TransactionProposal,
+  TransactionProposalStatus,
+  TransactionProposalSignature,
+  ExportedTransactionProposal,
+  SignTransactionProposalParams,
   ProposalMetadata,
-  ProposalSignatureEntry,
-  ProposalStatus,
   ProposalType,
 } from './types/proposal.js';
 
+export interface SyncResult {
+  proposals: TransactionProposal[];
+  state: AccountState;
+  notes: ConsumableNote[];
+  config: DetectedMultisigConfig;
+}
+
+export interface TransactionProposalResult {
+  proposal: TransactionProposal;
+  proposals: TransactionProposal[];
+}
+
 export interface MultisigAccountState {
   id: string;
   nonce: number;
@@ -34,20 +54,8 @@ export interface MultisigAccountState {
   cosignerCommitments: string[];
 }
 
-/**
- * Per-procedure threshold override.
- *
- * @example
- * ```typescript
- * const thresholds: ProcedureThreshold[] = [
- *   { procedure: 'receive_asset', threshold: 1 },
- *   { procedure: 'update_signers', threshold: 3 },
- * ];
- * ```
- */
 export interface ProcedureThreshold {
   procedure: ProcedureName;
-  /** Threshold for this procedure (1 to numSigners) */
   threshold: number;
 }
 
@@ -55,9 +63,11 @@ export interface MultisigConfig {
   threshold: number;
   signerCommitments: string[];
   psmCommitment: string;
+  psmPublicKey?: string;
   psmEnabled?: boolean;
   storageMode?: 'private' | 'public';
   procedureThresholds?: ProcedureThreshold[];
+  signatureScheme?: SignatureScheme;
 }
 
 export interface CreateAccountResult {

package/src/utils/signature.test.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { signatureHexToBytes, buildSignatureAdviceEntry, mergeSignatureAdviceMaps, toWord } from './signature.js';
+import {
+  signatureHexToBytes,
+  buildSignatureAdviceEntry,
+  mergeSignatureAdviceMaps,
+  toWord,
+  tryComputeEcdsaCommitmentHex,
+} from './signature.js';
 
 // Mock the Miden SDK
 vi.mock('@demox-labs/miden-sdk', () => ({
@@ -29,6 +35,11 @@ vi.mock('@demox-labs/miden-sdk', () => ({
       ],
     })),
   },
+  PublicKey: {
+    deserialize: vi.fn().mockReturnValue({
+      toCommitment: () => ({ toHex: () => '0x' + 'c'.repeat(64) }),
+    }),
+  },
 }));
 
 describe('signature utilities', () => {
@@ -42,6 +53,11 @@ describe('signature utilities', () => {
       expect(result[0]).toBe(0); // RpoFalcon512 scheme byte
     });
 
+    it('prepends auth scheme byte (1 = ECDSA)', () => {
+      const result = signatureHexToBytes('deadbeef', 'ecdsa');
+      expect(result[0]).toBe(1); // ECDSA scheme byte
+    });
+
     it('converts hex to bytes after prefix', () => {
       const result = signatureHexToBytes('deadbeef');
       expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
@@ -184,4 +200,11 @@ describe('signature utilities', () => {
       expect(Word.fromHex).toHaveBeenCalledWith('0x' + fullHex);
     });
   });
+
+  describe('tryComputeEcdsaCommitmentHex', () => {
+    it('returns normalized commitment when SDK supports ECDSA public keys', () => {
+      const commitment = tryComputeEcdsaCommitmentHex('0x' + 'aa'.repeat(33));
+      expect(commitment).toBe('0x' + 'c'.repeat(64));
+    });
+  });
 });

package/src/utils/signature.ts

@@ -1,28 +1,111 @@
 import { AdviceMap, Felt, FeltArray, Rpo256, Signature, Word } from '@demox-labs/miden-sdk';
+import * as midenSdk from '@demox-labs/miden-sdk';
 import { hexToBytes, normalizeHexWord } from './encoding.js';
+import type { SignatureScheme } from '../types.js';
 
-export function signatureHexToBytes(hex: string): Uint8Array {
+export function signatureHexToBytes(hex: string, scheme: SignatureScheme = 'falcon'): Uint8Array {
   const sigBytes = hexToBytes(hex);
   const withPrefix = new Uint8Array(sigBytes.length + 1);
-  withPrefix[0] = 0;
+  withPrefix[0] = scheme === 'ecdsa' ? 1 : 0;
   withPrefix.set(sigBytes, 1);
   return withPrefix;
 }
 
+function bytesToPackedU32Felts(bytes: Uint8Array): Felt[] {
+  const felts: Felt[] = [];
+  for (let i = 0; i < bytes.length; i += 4) {
+    let packed = 0;
+    for (let j = 0; j < 4 && i + j < bytes.length; j++) {
+      packed |= bytes[i + j] << (j * 8);
+    }
+    felts.push(new Felt(BigInt(packed >>> 0)));
+  }
+  return felts;
+}
+
+function encodeEcdsaSignatureFelts(pubkeyBytes: Uint8Array, sigBytes: Uint8Array): Felt[] {
+  const pkFelts = bytesToPackedU32Felts(pubkeyBytes);
+  const sigFelts = bytesToPackedU32Felts(sigBytes);
+  const encoded = [...pkFelts, ...sigFelts];
+  encoded.reverse();
+  return encoded;
+}
+
 export function buildSignatureAdviceEntry(
   pubkeyCommitment: Word,
   message: Word,
   signature: Signature,
+  ecdsaPubkeyHex?: string,
+  ecdsaSigHex?: string,
 ): { key: Word; values: Felt[] } {
   const elements = new FeltArray([
     ...pubkeyCommitment.toFelts(),
     ...message.toFelts(),
   ]);
   const key = Rpo256.hashElements(elements);
-  const values = signature.toPreparedSignature(message);
+
+  let values: Felt[];
+  if (ecdsaPubkeyHex && ecdsaSigHex) {
+    const pkBytes = hexToBytes(ecdsaPubkeyHex);
+    const sigBytes = hexToBytes(ecdsaSigHex);
+    values = encodeEcdsaSignatureFelts(pkBytes, sigBytes);
+  } else {
+    values = signature.toPreparedSignature(message);
+  }
+
   return { key, values };
 }
 
+export function tryComputeEcdsaCommitmentHex(pubkeyHex: string): string | null {
+  const bytes = hexToBytes(pubkeyHex);
+  const withPrefix = new Uint8Array(bytes.length + 1);
+  withPrefix[0] = 1;
+  withPrefix.set(bytes, 1);
+
+  try {
+    const { PublicKey } = midenSdk as any;
+    const instance = PublicKey.deserialize(withPrefix);
+    return normalizeHexWord(instance.toCommitment().toHex());
+  } catch {
+    return null;
+  }
+}
+
+export function verifyEcdsaCommitment(
+  pubkeyHex: string,
+  expectedCommitmentHex: string,
+): { match: boolean; computedHex: string; packedFelts: string[]; error?: string } {
+  try {
+    const bytes = hexToBytes(pubkeyHex);
+    const packedU32Values: number[] = [];
+    for (let i = 0; i < bytes.length; i += 4) {
+      let packed = 0;
+      for (let j = 0; j < 4 && i + j < bytes.length; j++) {
+        packed |= bytes[i + j] << (j * 8);
+      }
+      packedU32Values.push(packed >>> 0);
+    }
+
+    const packedFelts = bytesToPackedU32Felts(bytes);
+    const feltArray = new FeltArray(packedFelts);
+    const computed = Rpo256.hashElements(feltArray);
+    const computedHex = normalizeHexWord(computed.toHex());
+    const expectedNorm = normalizeHexWord(expectedCommitmentHex);
+    return {
+      match: computedHex === expectedNorm,
+      computedHex,
+      packedFelts: packedU32Values.map(v => v.toString()),
+    };
+  } catch (e) {
+    return {
+      match: false,
+      computedHex: `ERROR: ${e}`,
+      packedFelts: [],
+      error: String(e),
+    };
+  }
+}
+
 export function mergeSignatureAdviceMaps(advice: AdviceMap, entries: Array<{ key: Word; values: Felt[] }>): AdviceMap {
   for (const entry of entries) {
     advice.insert(entry.key, new FeltArray(entry.values));
@@ -33,4 +116,3 @@ export function mergeSignatureAdviceMaps(advice: AdviceMap, entries: Array<{ key
 export function toWord(hex: string): Word {
   return Word.fromHex(normalizeHexWord(hex));
 }
-