@openzeppelin/miden-multisig-client 0.17.0-rc.2 → 0.17.0

package/src/utils/key.test.ts

@@ -1,91 +0,0 @@
-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', () => ({
-  ECDSA_AUTH_SCHEME_ID: 1,
-  FALCON_AUTH_SCHEME_ID: 2,
-  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 0x02-prefixed key as falcon', () => {
-      const bytes = new Uint8Array(200);
-      bytes[0] = 0x02;
-      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/signature.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  signatureHexToBytes,
-  buildSignatureAdviceEntry,
-  mergeSignatureAdviceMaps,
-  toWord,
-  tryComputeEcdsaCommitmentHex,
-} from './signature.js';
-
-// Mock the Miden SDK
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  AdviceMap: vi.fn().mockImplementation(() => ({
-    insert: vi.fn(),
-  })),
-  Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
-  FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
-  Poseidon2: {
-    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 },
-      ],
-    })),
-  },
-  PublicKey: {
-    deserialize: vi.fn().mockReturnValue({
-      toCommitment: () => ({ toHex: () => '0x' + 'c'.repeat(64) }),
-    }),
-  },
-}));
-
-describe('signature utilities', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('signatureHexToBytes', () => {
-    it('prepends auth scheme byte (2 = Falcon Poseidon2)', () => {
-      const result = signatureHexToBytes('deadbeef');
-      expect(result[0]).toBe(2);
-    });
-
-    it('prepends auth scheme byte (1 = ECDSA)', () => {
-      const result = signatureHexToBytes('deadbeef', 'ecdsa');
-      expect(result[0]).toBe(1);
-   });
-
-    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(2);
-      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([2]));
-    });
-
-    it('handles empty with 0x prefix', () => {
-      const result = signatureHexToBytes('0x');
-      expect(result).toEqual(new Uint8Array([2]));
-    });
-  });
-
-  describe('buildSignatureAdviceEntry', () => {
-    it('returns key and values', async () => {
-      const { Word, Signature } = await import('@miden-sdk/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, Poseidon2 } = await import('@miden-sdk/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(Poseidon2.hashElements).toHaveBeenCalled();
-    });
-
-    it('uses toPreparedSignature to get values', async () => {
-      const { Word, Signature } = await import('@miden-sdk/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('@miden-sdk/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('@miden-sdk/miden-sdk');
-      const advice = new AdviceMap();
-
-      const result = mergeSignatureAdviceMaps(advice, []);
-
-      expect(result).toBe(advice);
-    });
-
-    it('handles empty entries array', async () => {
-      const { AdviceMap } = await import('@miden-sdk/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('@miden-sdk/miden-sdk');
-
-      const word = toWord('abc123');
-
-      expect(Word.fromHex).toHaveBeenCalled();
-      expect(word).toBeDefined();
-    });
-
-    it('normalizes hex before creating Word', async () => {
-      const { Word } = await import('@miden-sdk/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('@miden-sdk/miden-sdk');
-
-      toWord('0xdef');
-
-      expect(Word.fromHex).toHaveBeenCalledWith('0x' + '0'.repeat(61) + 'def');
-    });
-
-    it('handles full 64-char hex', async () => {
-      const { Word } = await import('@miden-sdk/miden-sdk');
-      const fullHex = 'f'.repeat(64);
-
-      toWord(fullHex);
-
-      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/word.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { wordElementToBigInt, wordToHex } from './word.js';
-import { Word } from '@miden-sdk/miden-sdk';
-
-// Mock the Miden SDK Word class
-vi.mock('@miden-sdk/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);
-    });
-  });
-});