@openzeppelin/miden-multisig-client 0.12.7 → 0.13.0

package/src/transaction/consumeNotes.ts

@@ -1,22 +1,27 @@
-import type { TransactionRequest, Word } from '@demox-labs/miden-sdk';
-import { NoteId, NoteIdAndArgs, NoteIdAndArgsArray, TransactionRequestBuilder, Word as WordType } from '@demox-labs/miden-sdk';
+import type { TransactionRequest, Word, WebClient } from '@miden-sdk/miden-sdk';
+import { NoteAndArgs, NoteAndArgsArray, TransactionRequestBuilder, Word as WordType } from '@miden-sdk/miden-sdk';
 import { randomWord } from '../utils/random.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
 
-export function buildConsumeNotesTransactionRequest(
+export async function buildConsumeNotesTransactionRequest(
+  webClient: WebClient,
   noteIds: string[],
   options: SignatureOptions = {},
-): { request: TransactionRequest; salt: Word } {
+): Promise<{ request: TransactionRequest; salt: Word }> {
   if (noteIds.length === 0) {
     throw new Error('At least one note ID is required');
   }
 
-  const noteIdAndArgsArray = new NoteIdAndArgsArray();
+  const noteAndArgsArray = new NoteAndArgsArray();
   for (const noteIdHex of noteIds) {
-    const noteId = NoteId.fromHex(noteIdHex);
-    const noteIdAndArgs = new NoteIdAndArgs(noteId, null);
-    noteIdAndArgsArray.push(noteIdAndArgs);
+    const inputNoteRecord = await webClient.getInputNote(noteIdHex);
+    if (!inputNoteRecord) {
+      throw new Error(`Note not found in local store: ${noteIdHex}`);
+    }
+    const note = inputNoteRecord.toNote();
+    const noteAndArgs = new NoteAndArgs(note, null);
+    noteAndArgsArray.push(noteAndArgs);
   }
 
   const authSaltHex = options.salt ? options.salt.toHex() : randomWord().toHex();
@@ -24,7 +29,7 @@ export function buildConsumeNotesTransactionRequest(
   const authSaltForBuilder = WordType.fromHex(normalizeHexWord(authSaltHex));
 
   let txBuilder = new TransactionRequestBuilder();
-  txBuilder = txBuilder.withAuthenticatedInputNotes(noteIdAndArgsArray);
+  txBuilder = txBuilder.withInputNotes(noteAndArgsArray);
   txBuilder = txBuilder.withAuthArg(authSaltForBuilder);
 
   if (options.signatureAdviceMap) {
@@ -38,4 +43,3 @@ export function buildConsumeNotesTransactionRequest(
     salt: authSaltForReturn,
   };
 }
-

package/src/transaction/options.ts

@@ -1,5 +1,5 @@
-import type { AdviceMap, Word } from '@demox-labs/miden-sdk';
-import type { SignatureScheme } from '../types.js';
+import type { AdviceMap, Word } from '@miden-sdk/miden-sdk';
+import type { SignatureScheme } from '@openzeppelin/psm-client';
 
 export interface SignatureOptions {
   salt?: Word;

package/src/transaction/p2id.ts

@@ -1,4 +1,4 @@
-import type { TransactionRequest, Word } from '@demox-labs/miden-sdk';
+import type { TransactionRequest, Word } from '@miden-sdk/miden-sdk';
 import {
   AccountId,
   Felt,
@@ -7,7 +7,6 @@ import {
   MidenArrays,
   Note,
   NoteAssets,
-  NoteExecutionHint,
   NoteInputs,
   NoteMetadata,
   NoteRecipient,
@@ -18,7 +17,7 @@ import {
   Rpo256,
   TransactionRequestBuilder,
   Word as WordType,
-} from '@demox-labs/miden-sdk';
+} from '@miden-sdk/miden-sdk';
 import { randomWord } from '../utils/random.js';
 import { normalizeHexWord } from '../utils/encoding.js';
 import type { SignatureOptions } from './options.js';
@@ -28,7 +27,6 @@ function buildP2idNote(
   recipient: AccountId,
   noteAssets: NoteAssets,
   noteType: NoteType,
-  aux: Felt,
   saltHex: string,
 ): Note {
   const salt = WordType.fromHex(normalizeHexWord(saltHex));
@@ -44,14 +42,12 @@ function buildP2idNote(
   ]));
 
   const noteRecipient = new NoteRecipient(serialNum, noteScript, noteInputs);
-  const noteTag = NoteTag.fromAccountId(recipient);
+  const noteTag = NoteTag.withAccountTarget(recipient);
 
   const noteMetadata = new NoteMetadata(
     sender,
     noteType,
     noteTag,
-    NoteExecutionHint.always(),
-    aux,
   );
 
   return new Note(noteAssets, noteMetadata, noteRecipient);
@@ -78,7 +74,6 @@ export function buildP2idTransactionRequest(
     recipient,
     noteAssets,
     NoteType.Public,
-    new Felt(0n),
     authSaltHex,
   );
 

package/src/transaction/summary.ts

@@ -1,5 +1,5 @@
-import type { TransactionRequest, TransactionSummary, WebClient } from '@demox-labs/miden-sdk';
-import { AccountId } from '@demox-labs/miden-sdk';
+import type { TransactionRequest, TransactionSummary, WebClient } from '@miden-sdk/miden-sdk';
+import { AccountId } from '@miden-sdk/miden-sdk';
 
 export async function executeForSummary(
   client: WebClient,

package/src/transaction/updatePsm.ts

@@ -7,19 +7,19 @@ import {
   WebClient,
   Word,
   Word as WordType,
-} from '@demox-labs/miden-sdk';
+} from '@miden-sdk/miden-sdk';
 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 buildUpdatePsmFalconScript(webClient: WebClient): TransactionScript {
-  const libBuilder = webClient.createScriptBuilder();
+  const libBuilder = webClient.createCodeBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm', PSM_MASM);
   libBuilder.linkDynamicLibrary(psmLib);
 
   const scriptSource = `
-use.openzeppelin::psm
+use openzeppelin::psm
 
 begin
     adv.push_mapval
@@ -32,12 +32,12 @@ end
 }
 
 function buildUpdatePsmEcdsaScript(webClient: WebClient): TransactionScript {
-  const libBuilder = webClient.createScriptBuilder();
+  const libBuilder = webClient.createCodeBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm_ecdsa', PSM_ECDSA_MASM);
   libBuilder.linkDynamicLibrary(psmLib);
 
   const scriptSource = `
-use.openzeppelin::psm_ecdsa
+use openzeppelin::psm_ecdsa
 
 begin
     adv.push_mapval
@@ -87,4 +87,3 @@ export async function buildUpdatePsmTransactionRequest(
     salt: authSaltForReturn,
   };
 }
-

package/src/transaction/updateSigners.ts

@@ -9,7 +9,7 @@ import {
   WebClient,
   Word,
   Word as WordType,
-} from '@demox-labs/miden-sdk';
+} from '@miden-sdk/miden-sdk';
 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';
@@ -36,7 +36,7 @@ function buildMultisigConfigAdvice(
 }
 
 function buildUpdateSignersFalconScript(webClient: WebClient): TransactionScript {
-  const libBuilder = webClient.createScriptBuilder();
+  const libBuilder = webClient.createCodeBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm', PSM_MASM);
   libBuilder.linkStaticLibrary(psmLib);
 
@@ -44,7 +44,7 @@ function buildUpdateSignersFalconScript(webClient: WebClient): TransactionScript
   libBuilder.linkDynamicLibrary(multisigLib);
 
   const scriptSource = `
-use.auth::multisig
+use auth::multisig
 
 begin
     call.multisig::update_signers_and_threshold
@@ -55,7 +55,7 @@ end
 }
 
 function buildUpdateSignersEcdsaScript(webClient: WebClient): TransactionScript {
-  const libBuilder = webClient.createScriptBuilder();
+  const libBuilder = webClient.createCodeBuilder();
   const psmLib = libBuilder.buildLibrary('openzeppelin::psm_ecdsa', PSM_ECDSA_MASM);
   libBuilder.linkStaticLibrary(psmLib);
 
@@ -63,7 +63,7 @@ function buildUpdateSignersEcdsaScript(webClient: WebClient): TransactionScript
   libBuilder.linkDynamicLibrary(multisigLib);
 
   const scriptSource = `
-use.auth::multisig
+use auth::multisig
 
 begin
     call.multisig::update_signers_and_threshold
@@ -115,4 +115,3 @@ export async function buildUpdateSignersTransactionRequest(
     configHash: configHashForReturn,
   };
 }
-

package/src/transaction.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeAll } from 'vitest';
 
 // Mock Miden SDK before importing transaction module
-vi.mock('@demox-labs/miden-sdk', () => ({
+vi.mock('@miden-sdk/miden-sdk', () => ({
   AccountId: { fromHex: vi.fn() },
   AdviceMap: vi.fn(),
   Felt: vi.fn().mockImplementation((v) => ({ value: v })),

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Account } from '@demox-labs/miden-sdk';
+import type { Account } from '@miden-sdk/miden-sdk';
 import type { SignatureScheme } from '@openzeppelin/psm-client';
 import type { ProcedureName } from './procedures.js';
 import type { TransactionProposal } from './types/proposal.js';

package/src/utils/digest.ts

@@ -0,0 +1,25 @@
+import { AccountId, Felt, FeltArray, Rpo256, Word } from '@miden-sdk/miden-sdk';
+
+export class AuthDigest {
+  static fromAccountIdWithTimestamp(accountId: string, timestamp: number): Word {
+    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)),
+    ]);
+
+    return Rpo256.hashElements(feltArray);
+  }
+
+  static fromCommitmentHex(commitmentHex: string): Word {
+    const paddedHex = commitmentHex.startsWith('0x') ? commitmentHex : `0x${commitmentHex}`;
+    const cleanHex = paddedHex.slice(2).padStart(64, '0');
+    return Word.fromHex(`0x${cleanHex}`);
+  }
+}

package/src/utils/ecdsa.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { EcdsaFormat } from './ecdsa.js';
+
+describe('EcdsaFormat', () => {
+  describe('normalizeRecoveryByte', () => {
+    it('should normalize v=27 to recovery_id=0', () => {
+      const rHex = 'aa'.repeat(32);
+      const sHex = 'bb'.repeat(32);
+      const sig = `0x${rHex}${sHex}1b`;
+      const result = EcdsaFormat.normalizeRecoveryByte(sig);
+      expect(result).toBe(`0x${rHex}${sHex}00`);
+    });
+
+    it('should normalize v=28 to recovery_id=1', () => {
+      const rHex = 'aa'.repeat(32);
+      const sHex = 'bb'.repeat(32);
+      const sig = `0x${rHex}${sHex}1c`;
+      const result = EcdsaFormat.normalizeRecoveryByte(sig);
+      expect(result).toBe(`0x${rHex}${sHex}01`);
+    });
+
+    it('should pass through v=0 unchanged', () => {
+      const rHex = 'aa'.repeat(32);
+      const sHex = 'bb'.repeat(32);
+      const sig = `0x${rHex}${sHex}00`;
+      const result = EcdsaFormat.normalizeRecoveryByte(sig);
+      expect(result).toBe(sig);
+    });
+
+    it('should pass through 64-byte signature unchanged', () => {
+      const sig = `0x${'ab'.repeat(64)}`;
+      const result = EcdsaFormat.normalizeRecoveryByte(sig);
+      expect(result).toBe(sig);
+    });
+
+    it('should throw on invalid length', () => {
+      expect(() => EcdsaFormat.normalizeRecoveryByte('0x' + 'ab'.repeat(10))).toThrow(
+        'Invalid ECDSA signature length',
+      );
+    });
+
+    it('should handle input without 0x prefix', () => {
+      const rHex = 'aa'.repeat(32);
+      const sHex = 'bb'.repeat(32);
+      const sig = `${rHex}${sHex}1b`;
+      const result = EcdsaFormat.normalizeRecoveryByte(sig);
+      expect(result).toBe(`0x${rHex}${sHex}00`);
+    });
+  });
+
+  describe('compressPublicKey', () => {
+    it('should compress a 65-byte uncompressed key with even y', () => {
+      const x = 'aa'.repeat(32);
+      const yEven = 'bb'.repeat(31) + 'b0';
+      const uncompressed = `0x04${x}${yEven}`;
+      const result = EcdsaFormat.compressPublicKey(uncompressed);
+      expect(result).toBe(`0x02${x}`);
+    });
+
+    it('should compress a 65-byte uncompressed key with odd y', () => {
+      const x = 'aa'.repeat(32);
+      const yOdd = 'bb'.repeat(31) + 'b1';
+      const uncompressed = `0x04${x}${yOdd}`;
+      const result = EcdsaFormat.compressPublicKey(uncompressed);
+      expect(result).toBe(`0x03${x}`);
+    });
+
+    it('should pass through a 33-byte compressed key unchanged', () => {
+      const compressed = `0x02${'aa'.repeat(32)}`;
+      const result = EcdsaFormat.compressPublicKey(compressed);
+      expect(result).toBe(compressed);
+    });
+
+    it('should throw on invalid length', () => {
+      expect(() => EcdsaFormat.compressPublicKey('0x' + 'ab'.repeat(10))).toThrow(
+        'Expected 65-byte uncompressed public key',
+      );
+    });
+
+    it('should throw on 65 bytes without 04 prefix', () => {
+      expect(() => EcdsaFormat.compressPublicKey('0x05' + 'ab'.repeat(64))).toThrow(
+        'Expected 65-byte uncompressed public key',
+      );
+    });
+  });
+
+  describe('keccakDigestHex', () => {
+    it('should return 0x-prefixed hex of keccak-256 hash', () => {
+      const result = EcdsaFormat.keccakDigestHex(new Uint8Array(0));
+      expect(result).toMatch(/^0x[a-f0-9]{64}$/);
+    });
+
+    it('should produce correct hash for empty input', () => {
+      const result = EcdsaFormat.keccakDigestHex(new Uint8Array(0));
+      expect(result).toBe('0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470');
+    });
+
+    it('should produce different hashes for different inputs', () => {
+      const a = EcdsaFormat.keccakDigestHex(new Uint8Array([1]));
+      const b = EcdsaFormat.keccakDigestHex(new Uint8Array([2]));
+      expect(a).not.toBe(b);
+    });
+  });
+});

package/src/utils/ecdsa.ts

@@ -0,0 +1,77 @@
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { ensureHexPrefix } from './encoding.js';
+
+const ECDSA_SIGNATURE_BYTE_LENGTH = 64;
+const ECDSA_SIGNATURE_WITH_RECOVERY_BYTE_LENGTH = 65;
+
+export class EcdsaFormat {
+  static normalizeSignatureHex(signatureHex: string): string {
+    const clean = ensureHexPrefix(signatureHex).slice(2);
+    const byteLength = clean.length / 2;
+
+    if (byteLength === ECDSA_SIGNATURE_WITH_RECOVERY_BYTE_LENGTH) {
+      return `0x${clean.slice(0, ECDSA_SIGNATURE_BYTE_LENGTH * 2)}`;
+    }
+
+    if (byteLength === ECDSA_SIGNATURE_BYTE_LENGTH) {
+      return `0x${clean}`;
+    }
+
+    throw new Error(
+      `Invalid ECDSA signature length: expected ${ECDSA_SIGNATURE_BYTE_LENGTH} or ${ECDSA_SIGNATURE_WITH_RECOVERY_BYTE_LENGTH} bytes, got ${byteLength}`,
+    );
+  }
+
+  static normalizeRecoveryByte(signatureHex: string): string {
+    const clean = ensureHexPrefix(signatureHex).slice(2);
+    const byteLength = clean.length / 2;
+
+    if (byteLength === ECDSA_SIGNATURE_WITH_RECOVERY_BYTE_LENGTH) {
+      const vByte = parseInt(clean.slice(-2), 16);
+      if (vByte === 27 || vByte === 28) {
+        const normalized = clean.slice(0, -2) + (vByte - 27).toString(16).padStart(2, '0');
+        return `0x${normalized}`;
+      }
+      return `0x${clean}`;
+    }
+
+    if (byteLength === ECDSA_SIGNATURE_BYTE_LENGTH) {
+      return `0x${clean}`;
+    }
+
+    throw new Error(
+      `Invalid ECDSA signature length: expected ${ECDSA_SIGNATURE_BYTE_LENGTH} or ${ECDSA_SIGNATURE_WITH_RECOVERY_BYTE_LENGTH} bytes, got ${byteLength}`,
+    );
+  }
+
+  static validatePublicKeyHex(publicKeyHex: string): boolean {
+    const clean = ensureHexPrefix(publicKeyHex).slice(2);
+    const byteLength = clean.length / 2;
+    return byteLength === 33 || byteLength === 65;
+  }
+
+  static compressPublicKey(uncompressedHex: string): string {
+    const clean = ensureHexPrefix(uncompressedHex).slice(2);
+    const byteLength = clean.length / 2;
+
+    if (byteLength === 33) return `0x${clean}`;
+
+    if (byteLength !== 65 || !clean.startsWith('04')) {
+      throw new Error(`Expected 65-byte uncompressed public key, got ${byteLength} bytes`);
+    }
+
+    const x = clean.slice(2, 66);
+    const yLastNibble = parseInt(clean.slice(-1), 16);
+    const tag = yLastNibble % 2 === 0 ? '02' : '03';
+    return `0x${tag}${x}`;
+  }
+
+  static keccakDigestHex(data: Uint8Array): string {
+    const hash = keccak_256(data);
+    let hex = '0x';
+    for (let i = 0; i < hash.length; i++) {
+      hex += hash[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+  }
+}

package/src/utils/index.ts

@@ -2,4 +2,5 @@ export * from './encoding.js';
 export * from './random.js';
 export * from './signature.js';
 export * from './word.js';
+export * from './key.js';
 

package/src/utils/key.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from 'vitest';
+import { PublicKeyFormat } from './key.js';
+
+vi.mock('@miden-sdk/miden-sdk', () => ({
+  Word: class {
+    private u64s: BigUint64Array;
+    constructor(u64s: BigUint64Array) {
+      this.u64s = u64s;
+    }
+    toHex() {
+      const h3 = this.u64s[3].toString(16).padStart(16, '0');
+      const h2 = this.u64s[2].toString(16).padStart(16, '0');
+      const h1 = this.u64s[1].toString(16).padStart(16, '0');
+      const h0 = this.u64s[0].toString(16).padStart(16, '0');
+      return '0x' + h3 + h2 + h1 + h0;
+    }
+  },
+}));
+
+vi.mock('./signature.js', () => ({
+  tryComputeCommitmentHex: vi.fn((_hex: string, _scheme: string) => '0x' + 'cc'.repeat(32)),
+}));
+
+describe('PublicKeyFormat', () => {
+  describe('parse', () => {
+    it('should treat 32-byte input as Word commitment with falcon scheme', () => {
+      const bytes = new Uint8Array(32);
+      bytes[0] = 0x42;
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('falcon');
+      expect(result.commitment).toBe(result.publicKeyHex);
+      expect(result.publicKeyHex).toMatch(/^0x[a-f0-9]{64}$/);
+    });
+
+    it('should detect 0x00-prefixed key as falcon', () => {
+      const bytes = new Uint8Array(200);
+      bytes[0] = 0x00;
+      bytes[1] = 0xab;
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('falcon');
+      expect(result.commitment).toBe('0x' + 'cc'.repeat(32));
+    });
+
+    it('should detect 0x01-prefixed 34-byte key as ecdsa', () => {
+      const bytes = new Uint8Array(34);
+      bytes[0] = 0x01;
+      bytes[1] = 0x02;
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('ecdsa');
+      expect(result.commitment).toBe('0x' + 'cc'.repeat(32));
+    });
+
+    it('should detect 33-byte input as ecdsa', () => {
+      const bytes = new Uint8Array(33);
+      bytes[0] = 0x02;
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('ecdsa');
+    });
+
+    it('should detect 65-byte input as ecdsa', () => {
+      const bytes = new Uint8Array(65);
+      bytes[0] = 0x04;
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('ecdsa');
+    });
+
+    it('should default to falcon for unknown lengths', () => {
+      const bytes = new Uint8Array(500);
+      const result = PublicKeyFormat.parse(bytes);
+      expect(result.scheme).toBe('falcon');
+    });
+  });
+
+  describe('wordBytesToHex', () => {
+    it('should convert 32 zero bytes to a valid hex string', () => {
+      const bytes = new Uint8Array(32);
+      const result = PublicKeyFormat.wordBytesToHex(bytes);
+      expect(result).toMatch(/^0x[a-f0-9]{64}$/);
+    });
+
+    it('should produce consistent output for same input', () => {
+      const bytes = new Uint8Array(32);
+      bytes[0] = 0xff;
+      const a = PublicKeyFormat.wordBytesToHex(bytes);
+      const b = PublicKeyFormat.wordBytesToHex(bytes);
+      expect(a).toBe(b);
+    });
+  });
+});

package/src/utils/key.ts

@@ -0,0 +1,49 @@
+import { Word } from '@miden-sdk/miden-sdk';
+import type { SignatureScheme } from '../types.js';
+import { bytesToHex } from './encoding.js';
+import { tryComputeCommitmentHex } from './signature.js';
+
+export class PublicKeyFormat {
+  static parse(publicKey: Uint8Array): {
+    scheme: SignatureScheme;
+    publicKeyHex: string;
+    commitment: string | null;
+  } {
+    if (publicKey.length === 32) {
+      const commitmentHex = PublicKeyFormat.wordBytesToHex(publicKey);
+      return { scheme: 'falcon', publicKeyHex: commitmentHex, commitment: commitmentHex };
+    }
+
+    const firstByte = publicKey[0];
+
+    if (firstByte === 0x00 && publicKey.length > 100) {
+      const hex = bytesToHex(publicKey.slice(1));
+      return { scheme: 'falcon', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'falcon') };
+    }
+
+    if (firstByte === 0x01 && publicKey.length === 34) {
+      const hex = bytesToHex(publicKey.slice(1));
+      return { scheme: 'ecdsa', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'ecdsa') };
+    }
+
+    if (publicKey.length === 33 || publicKey.length === 65) {
+      const hex = bytesToHex(publicKey);
+      return { scheme: 'ecdsa', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'ecdsa') };
+    }
+
+    const hex = bytesToHex(publicKey);
+    return { scheme: 'falcon', publicKeyHex: hex, commitment: tryComputeCommitmentHex(hex, 'falcon') };
+  }
+
+  static wordBytesToHex(bytes: Uint8Array): string {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const u64s = new BigUint64Array(4);
+    for (let i = 0; i < 4; i++) {
+      u64s[i] = view.getBigUint64(i * 8, true);
+    }
+    const word = new Word(u64s);
+    const hex = word.toHex();
+    const clean = hex.replace(/^0x/i, '').toLowerCase().padStart(64, '0');
+    return `0x${clean}`;
+  }
+}

package/src/utils/random.ts

@@ -1,4 +1,4 @@
-import { Word } from '@demox-labs/miden-sdk';
+import { Word } from '@miden-sdk/miden-sdk';
 
 export function randomWord(): Word {
   const bytes = new Uint8Array(32);