@openzeppelin/miden-multisig-client 0.12.6

package/src/utils/signature.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { signatureHexToBytes, buildSignatureAdviceEntry, mergeSignatureAdviceMaps, toWord } from './signature.js';
+
+// Mock the Miden SDK
+vi.mock('@demox-labs/miden-sdk', () => ({
+  AdviceMap: vi.fn().mockImplementation(() => ({
+    insert: vi.fn(),
+  })),
+  Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
+  FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
+  Rpo256: {
+    hashElements: vi.fn().mockReturnValue({
+      toHex: () => '0x' + 'h'.repeat(64),
+    }),
+  },
+  Signature: {
+    deserialize: vi.fn().mockReturnValue({
+      toPreparedSignature: vi.fn().mockReturnValue([1, 2, 3, 4]),
+    }),
+  },
+  Word: {
+    fromHex: vi.fn((hex: string) => ({
+      toHex: () => hex,
+      toFelts: () => [
+        { value: 1n },
+        { value: 2n },
+        { value: 3n },
+        { value: 4n },
+      ],
+    })),
+  },
+}));
+
+describe('signature utilities', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('signatureHexToBytes', () => {
+    it('prepends auth scheme byte (0 = RpoFalcon512)', () => {
+      const result = signatureHexToBytes('deadbeef');
+      expect(result[0]).toBe(0); // RpoFalcon512 scheme byte
+    });
+
+    it('converts hex to bytes after prefix', () => {
+      const result = signatureHexToBytes('deadbeef');
+      expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
+    });
+
+    it('handles 0x prefix', () => {
+      const result = signatureHexToBytes('0xaabbccdd');
+      expect(result[0]).toBe(0);
+      expect(result.slice(1)).toEqual(new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]));
+    });
+
+    it('returns correct length (input bytes + 1)', () => {
+      const sigHex = 'a'.repeat(128); // 64 bytes
+      const result = signatureHexToBytes(sigHex);
+      expect(result.length).toBe(65); // 64 bytes + 1 prefix byte
+    });
+
+    it('handles empty signature', () => {
+      const result = signatureHexToBytes('');
+      expect(result).toEqual(new Uint8Array([0])); // Just the prefix
+    });
+
+    it('handles empty with 0x prefix', () => {
+      const result = signatureHexToBytes('0x');
+      expect(result).toEqual(new Uint8Array([0]));
+    });
+  });
+
+  describe('buildSignatureAdviceEntry', () => {
+    it('returns key and values', async () => {
+      const { Word, Signature } = await import('@demox-labs/miden-sdk');
+      const pubkeyCommitment = Word.fromHex('0x' + 'a'.repeat(64));
+      const message = Word.fromHex('0x' + 'b'.repeat(64));
+      const signature = Signature.deserialize(new Uint8Array([0, 1, 2, 3]));
+
+      const { key, values } = buildSignatureAdviceEntry(pubkeyCommitment, message, signature);
+
+      expect(key).toBeDefined();
+      expect(values).toBeDefined();
+    });
+
+    it('hashes pubkey commitment and message to produce key', async () => {
+      const { Word, Signature, Rpo256 } = await import('@demox-labs/miden-sdk');
+      const pubkeyCommitment = Word.fromHex('0x' + 'a'.repeat(64));
+      const message = Word.fromHex('0x' + 'b'.repeat(64));
+      const signature = Signature.deserialize(new Uint8Array([0, 1, 2, 3]));
+
+      buildSignatureAdviceEntry(pubkeyCommitment, message, signature);
+
+      expect(Rpo256.hashElements).toHaveBeenCalled();
+    });
+
+    it('uses toPreparedSignature to get values', async () => {
+      const { Word, Signature } = await import('@demox-labs/miden-sdk');
+      const pubkeyCommitment = Word.fromHex('0x' + 'a'.repeat(64));
+      const message = Word.fromHex('0x' + 'b'.repeat(64));
+      const signature = Signature.deserialize(new Uint8Array([0, 1, 2, 3]));
+
+      const { values } = buildSignatureAdviceEntry(pubkeyCommitment, message, signature);
+
+      expect(signature.toPreparedSignature).toHaveBeenCalledWith(message);
+      expect(values).toEqual([1, 2, 3, 4]);
+    });
+  });
+
+  describe('mergeSignatureAdviceMaps', () => {
+    it('inserts all entries into advice map', async () => {
+      const { AdviceMap, Word, Signature } = await import('@demox-labs/miden-sdk');
+      const advice = new AdviceMap();
+
+      const entries = [
+        {
+          key: Word.fromHex('0x' + 'a'.repeat(64)),
+          values: [{ value: 1n }, { value: 2n }],
+        },
+        {
+          key: Word.fromHex('0x' + 'b'.repeat(64)),
+          values: [{ value: 3n }, { value: 4n }],
+        },
+      ];
+
+      const result = mergeSignatureAdviceMaps(advice, entries as any);
+
+      expect(advice.insert).toHaveBeenCalledTimes(2);
+      expect(result).toBe(advice);
+    });
+
+    it('returns the same advice map', async () => {
+      const { AdviceMap } = await import('@demox-labs/miden-sdk');
+      const advice = new AdviceMap();
+
+      const result = mergeSignatureAdviceMaps(advice, []);
+
+      expect(result).toBe(advice);
+    });
+
+    it('handles empty entries array', async () => {
+      const { AdviceMap } = await import('@demox-labs/miden-sdk');
+      const advice = new AdviceMap();
+
+      mergeSignatureAdviceMaps(advice, []);
+
+      expect(advice.insert).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('toWord', () => {
+    it('creates Word from hex string', async () => {
+      const { Word } = await import('@demox-labs/miden-sdk');
+
+      const word = toWord('abc123');
+
+      expect(Word.fromHex).toHaveBeenCalled();
+      expect(word).toBeDefined();
+    });
+
+    it('normalizes hex before creating Word', async () => {
+      const { Word } = await import('@demox-labs/miden-sdk');
+
+      toWord('abc');
+
+      // Should be called with normalized hex (0x + padded to 64 chars)
+      expect(Word.fromHex).toHaveBeenCalledWith('0x' + '0'.repeat(61) + 'abc');
+    });
+
+    it('handles 0x prefix', async () => {
+      const { Word } = await import('@demox-labs/miden-sdk');
+
+      toWord('0xdef');
+
+      expect(Word.fromHex).toHaveBeenCalledWith('0x' + '0'.repeat(61) + 'def');
+    });
+
+    it('handles full 64-char hex', async () => {
+      const { Word } = await import('@demox-labs/miden-sdk');
+      const fullHex = 'f'.repeat(64);
+
+      toWord(fullHex);
+
+      expect(Word.fromHex).toHaveBeenCalledWith('0x' + fullHex);
+    });
+  });
+});

package/src/utils/signature.ts

@@ -0,0 +1,36 @@
+import { AdviceMap, Felt, FeltArray, Rpo256, Signature, Word } from '@demox-labs/miden-sdk';
+import { hexToBytes, normalizeHexWord } from './encoding.js';
+
+export function signatureHexToBytes(hex: string): Uint8Array {
+  const sigBytes = hexToBytes(hex);
+  const withPrefix = new Uint8Array(sigBytes.length + 1);
+  withPrefix[0] = 0;
+  withPrefix.set(sigBytes, 1);
+  return withPrefix;
+}
+
+export function buildSignatureAdviceEntry(
+  pubkeyCommitment: Word,
+  message: Word,
+  signature: Signature,
+): { key: Word; values: Felt[] } {
+  const elements = new FeltArray([
+    ...pubkeyCommitment.toFelts(),
+    ...message.toFelts(),
+  ]);
+  const key = Rpo256.hashElements(elements);
+  const values = signature.toPreparedSignature(message);
+  return { key, values };
+}
+
+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));
+  }
+  return advice;
+}
+
+export function toWord(hex: string): Word {
+  return Word.fromHex(normalizeHexWord(hex));
+}
+

package/src/utils/word.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi } from 'vitest';
+import { wordElementToBigInt, wordToHex } from './word.js';
+import { Word } from '@demox-labs/miden-sdk';
+
+// Mock the Miden SDK Word class
+vi.mock('@demox-labs/miden-sdk', () => ({
+  Word: {
+    fromHex: (hex: string): { toU64s: () => BigUint64Array; toHex: () => string } => {
+      // Parse hex string (remove 0x prefix if present)
+      const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+      if (cleanHex.length !== 64) {
+        throw new Error('Hex string must be 64 characters');
+      }
+
+      // Parse as big-endian: [e3_bytes][e2_bytes][e1_bytes][e0_bytes]
+      const e3 = BigInt('0x' + cleanHex.slice(0, 16));
+      const e2 = BigInt('0x' + cleanHex.slice(16, 32));
+      const e1 = BigInt('0x' + cleanHex.slice(32, 48));
+      const e0 = BigInt('0x' + cleanHex.slice(48, 64));
+
+      const elements = new BigUint64Array([e0, e1, e2, e3]);
+
+      return {
+        toU64s: () => elements,
+        toHex: () => {
+          const h3 = elements[3].toString(16).padStart(16, '0');
+          const h2 = elements[2].toString(16).padStart(16, '0');
+          const h1 = elements[1].toString(16).padStart(16, '0');
+          const h0 = elements[0].toString(16).padStart(16, '0');
+          return '0x' + h3 + h2 + h1 + h0;
+        },
+      };
+    },
+  },
+}));
+
+describe('word utilities', () => {
+  describe('wordElementToBigInt', () => {
+    it('should return element at valid index', () => {
+      const word = Word.fromHex(
+        '0x016ab79593165e5b849776919e0c0298fb9dac880d593d93edd7134bdcdb4b6f'
+      );
+      expect(wordElementToBigInt(word as Word, 0)).toBe(BigInt('0xedd7134bdcdb4b6f'));
+      expect(wordElementToBigInt(word as Word, 3)).toBe(BigInt('0x016ab79593165e5b'));
+    });
+
+    it('should return 0n for invalid index', () => {
+      const word = Word.fromHex(
+        '0x016ab79593165e5b849776919e0c0298fb9dac880d593d93edd7134bdcdb4b6f'
+      );
+      expect(wordElementToBigInt(word as Word, -1)).toBe(0n);
+      expect(wordElementToBigInt(word as Word, 4)).toBe(0n);
+    });
+  });
+
+  describe('wordToHex', () => {
+    it('should convert word back to hex string', () => {
+      const originalHex = '0xd6c130dba13c67ac4733915f24bea9d19f517f51a65c74ded7bcd27e066b400e';
+      const word = Word.fromHex(originalHex);
+      const hex = wordToHex(word as Word);
+      expect(hex).toBe(originalHex);
+    });
+  });
+});

package/src/utils/word.ts

@@ -0,0 +1,11 @@
+import { Word } from '@demox-labs/miden-sdk';
+
+export function wordToHex(word: Word): string {
+  return word.toHex();
+}
+
+export function wordElementToBigInt(word: Word, index: number): bigint {
+  const elements = word.toU64s();
+  return index >= 0 && index < elements.length ? elements[index] : 0n;
+}
+