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

package/src/lookupAuth.test.ts

@@ -1,185 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// The Miden SDK is wasm-bound and is mocked across this test suite (matching
-// the pattern in transaction.test.ts, multisig.test.ts, etc.). We cannot run
-// real RPO256 here, but we CAN verify the lookup-digest function builds the
-// FeltArray sequence in the right order and chunking convention. Cross-language
-// parity against `crates/shared/tests/fixtures/lookup_auth_vectors.json` is
-// intentionally a separate runner — see `runRealSdkParity` below for the gated
-// hook.
-
-interface FakeFelt {
-  __felt: true;
-  value: bigint;
-}
-
-interface FakeWord {
-  __word: true;
-  felts: FakeFelt[];
-  toFelts: () => FakeFelt[];
-  toHex: () => string;
-}
-
-const hashCalls: { input: FakeFelt[] }[] = [];
-
-vi.mock('@miden-sdk/miden-sdk', () => {
-  const Felt = vi.fn().mockImplementation((value: bigint) => ({
-    __felt: true,
-    value,
-  }));
-
-  const FeltArray = vi.fn().mockImplementation((felts: FakeFelt[]) => felts);
-
-  const makeWord = (felts: FakeFelt[], hex = '0xMOCKED'): FakeWord => ({
-    __word: true,
-    felts,
-    toFelts: () => felts,
-    toHex: () => hex,
-  });
-
-  const Word = {
-    fromHex: vi.fn().mockImplementation((hex: string) => {
-      // Deterministic four-felt decomposition: split hex into 4 8-byte pieces.
-      // The values are not real Word semantics, but they let us assert the
-      // implementation passes them through in order.
-      const stripped = hex.startsWith('0x') ? hex.slice(2) : hex;
-      const padded = stripped.padStart(64, '0');
-      const felts: FakeFelt[] = [];
-      for (let i = 0; i < 4; i += 1) {
-        const piece = padded.slice(i * 16, (i + 1) * 16);
-        felts.push({ __felt: true, value: BigInt('0x' + piece) });
-      }
-      return makeWord(felts, hex);
-    }),
-  };
-
-  const Rpo256 = {
-    hashElements: vi.fn().mockImplementation((felts: FakeFelt[]) => {
-      hashCalls.push({ input: [...felts] });
-      // Synthesize a fake digest: 4 felts derived from the input length and
-      // first felt's value, so each call's output is distinguishable.
-      const seed = felts.length === 0 ? 0n : felts[0].value;
-      return makeWord(
-        [
-          { __felt: true, value: seed ^ BigInt(felts.length) },
-          { __felt: true, value: seed + 1n },
-          { __felt: true, value: seed + 2n },
-          { __felt: true, value: seed + 3n },
-        ],
-        '0xfakehash',
-      );
-    }),
-  };
-
-  return { Felt, FeltArray, Rpo256, Word };
-});
-
-const DOMAIN_TAG_BYTES = new TextEncoder().encode('guardian.lookup.v1');
-
-function bytesToExpectedFelts(bytes: Uint8Array): bigint[] {
-  const out: bigint[] = [];
-  for (let offset = 0; offset < bytes.length; offset += 8) {
-    let value = 0n;
-    for (let i = 0; i < 8; i += 1) {
-      const byte = offset + i < bytes.length ? bytes[offset + i] : 0;
-      value |= BigInt(byte) << BigInt(8 * i);
-    }
-    out.push(value);
-  }
-  return out;
-}
-
-let lookupAuthDigest: typeof import('./lookupAuth.js').lookupAuthDigest;
-let _resetLookupDomainTagCacheForTesting: typeof import('./lookupAuth.js')._resetLookupDomainTagCacheForTesting;
-
-beforeEach(async () => {
-  hashCalls.length = 0;
-  // Re-import to pick up a fresh cached domain tag per test, in addition to
-  // the explicit reset, so test ordering does not change behavior.
-  const mod = await import('./lookupAuth.js');
-  lookupAuthDigest = mod.lookupAuthDigest;
-  _resetLookupDomainTagCacheForTesting = mod._resetLookupDomainTagCacheForTesting;
-  _resetLookupDomainTagCacheForTesting();
-});
-
-describe('lookupAuthDigest', () => {
-  it('hashes the domain-tag bytes via the same 8-byte LE chunking as Rust', () => {
-    const keyCommitmentHex = '0x' + 'aa'.repeat(32);
-    lookupAuthDigest(1_700_000_000_000, keyCommitmentHex);
-
-    // First Rpo256.hashElements call must be the domain-tag computation
-    // (3 felts for "guardian.lookup.v1" — 18 bytes → ceil(18/8) = 3 chunks).
-    expect(hashCalls.length).toBeGreaterThanOrEqual(2);
-    const tagCall = hashCalls[0];
-    const expected = bytesToExpectedFelts(DOMAIN_TAG_BYTES);
-    expect(tagCall.input).toHaveLength(expected.length);
-    expect(tagCall.input.length).toBe(3);
-    for (let i = 0; i < expected.length; i += 1) {
-      expect(tagCall.input[i].value).toBe(expected[i]);
-    }
-  });
-
-  it('caches the domain-tag computation across calls', () => {
-    const keyCommitmentHex = '0x' + 'bb'.repeat(32);
-    lookupAuthDigest(1_700_000_000_000, keyCommitmentHex);
-    const callsAfterFirst = hashCalls.length;
-    lookupAuthDigest(1_700_000_000_001, keyCommitmentHex);
-    const callsAfterSecond = hashCalls.length;
-
-    // Second invocation should perform exactly one Rpo256.hashElements call
-    // (the message hash); the domain-tag hash is cached.
-    expect(callsAfterSecond - callsAfterFirst).toBe(1);
-  });
-
-  it('passes 9 felts in [tag, timestamp, key_commitment] order to the message hash', () => {
-    const keyCommitmentHex = '0x' + '01'.repeat(32);
-    const timestamp = 1_700_000_000_000n;
-    lookupAuthDigest(timestamp, keyCommitmentHex);
-
-    const messageCall = hashCalls[hashCalls.length - 1];
-    expect(messageCall.input).toHaveLength(9);
-
-    // Felt 4 is the timestamp, reinterpreted as u64 (no change for positive).
-    expect(messageCall.input[4].value).toBe(timestamp);
-
-    // Felts 5..8 are the key-commitment felts, derived deterministically by
-    // the mocked Word.fromHex from the hex representation.
-    const expectedKcWord = '01'.repeat(32);
-    for (let i = 0; i < 4; i += 1) {
-      const piece = expectedKcWord.slice(i * 16, (i + 1) * 16);
-      expect(messageCall.input[5 + i].value).toBe(BigInt('0x' + piece));
-    }
-  });
-
-  it('reinterprets a negative timestamp via two-complement u64 cast', () => {
-    const keyCommitmentHex = '0x' + 'cc'.repeat(32);
-    lookupAuthDigest(-1, keyCommitmentHex);
-
-    const messageCall = hashCalls[hashCalls.length - 1];
-    // -1 casts to u64 0xFFFFFFFFFFFFFFFF, then reduces mod the Goldilocks prime
-    // (matching Rust `felt_from_u64_reduced`): 0xFFFFFFFFFFFFFFFF - (2^64 - 2^32 + 1) = 0xFFFFFFFE.
-    expect(messageCall.input[4].value).toBe(0xFFFFFFFEn);
-  });
-
-  it('produces distinct digest inputs for distinct commitments', () => {
-    lookupAuthDigest(1_700_000_000_000, '0x' + '01'.repeat(32));
-    lookupAuthDigest(1_700_000_000_000, '0x' + '02'.repeat(32));
-
-    // Call 0 is the cached domain-tag hash. Calls 1 and 2 are the two message
-    // hashes; the second call hits the domain-tag cache so it does not produce
-    // an extra hash call.
-    const messageCallA = hashCalls[1];
-    const messageCallB = hashCalls[2];
-    expect(messageCallA.input[5].value).not.toBe(messageCallB.input[5].value);
-  });
-
-  it('produces distinct digest inputs for distinct timestamps', () => {
-    const keyCommitmentHex = '0x' + '01'.repeat(32);
-    lookupAuthDigest(1_700_000_000_000, keyCommitmentHex);
-    lookupAuthDigest(1_700_000_000_001, keyCommitmentHex);
-
-    const messageCallA = hashCalls[1];
-    const messageCallB = hashCalls[2];
-    expect(messageCallA.input[4].value).not.toBe(messageCallB.input[4].value);
-  });
-});

package/src/multisig/consumeNotesErrors.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  ConsumeNotesMetadataOversizeError,
-  LegacyConsumeNotesNoteMissingError,
-  NoteBindingMismatchError,
-  UnsupportedMetadataVersionError,
-} from './consumeNotesErrors.js';
-
-describe('consume_notes error taxonomy (issue #229)', () => {
-  it('pins stable codes identical to the Rust SDK', () => {
-    expect(new NoteBindingMismatchError('x').code).toBe('consume_notes_note_binding_mismatch');
-    expect(new UnsupportedMetadataVersionError(99).code).toBe(
-      'consume_notes_unsupported_metadata_version',
-    );
-    expect(new ConsumeNotesMetadataOversizeError(1, 2).code).toBe(
-      'consume_notes_metadata_oversize',
-    );
-    expect(new LegacyConsumeNotesNoteMissingError('0xabc').code).toBe(
-      'consume_notes_legacy_note_missing',
-    );
-  });
-
-  it('preserves structured error fields for programmatic branching', () => {
-    const oversize = new ConsumeNotesMetadataOversizeError(262_144, 300_000);
-    expect(oversize.limit).toBe(262_144);
-    expect(oversize.actual).toBe(300_000);
-
-    const missing = new LegacyConsumeNotesNoteMissingError('0xnoteid');
-    expect(missing.noteId).toBe('0xnoteid');
-
-    const unsupported = new UnsupportedMetadataVersionError(99);
-    expect(unsupported.found).toBe(99);
-    const absent = new UnsupportedMetadataVersionError(undefined);
-    expect(absent.found).toBeUndefined();
-  });
-
-  it('extends Error so instanceof Error and instanceof <subclass> both work', () => {
-    const err = new NoteBindingMismatchError('boom');
-    expect(err).toBeInstanceOf(Error);
-    expect(err).toBeInstanceOf(NoteBindingMismatchError);
-    expect(err.name).toBe('NoteBindingMismatchError');
-  });
-});

package/src/multisig/helpers.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { computeCommitmentFromTxSummary, accountIdToHex } from './helpers.js';
-
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  Account: {},
-  TransactionSummary: {
-    deserialize: vi.fn((bytes: Uint8Array) => ({
-      toCommitment: () => ({
-        toHex: () => '0x' + 'c'.repeat(64),
-      }),
-    })),
-  },
-  Word: {},
-}));
-
-describe('multisig helpers', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('computeCommitmentFromTxSummary', () => {
-    it('computes commitment from base64 tx summary', async () => {
-      const base64 = btoa(String.fromCharCode(...new Uint8Array([1, 2, 3])));
-      const commitment = computeCommitmentFromTxSummary(base64);
-
-      expect(commitment).toBe('0x' + 'c'.repeat(64));
-    });
-
-    it('deserializes the tx summary bytes', async () => {
-      const { TransactionSummary } = await import('@miden-sdk/miden-sdk');
-      const base64 = btoa(String.fromCharCode(...new Uint8Array([4, 5, 6])));
-
-      computeCommitmentFromTxSummary(base64);
-
-      expect(TransactionSummary.deserialize).toHaveBeenCalledWith(
-        new Uint8Array([4, 5, 6])
-      );
-    });
-
-    it('returns hex string with 0x prefix', () => {
-      const base64 = btoa(String.fromCharCode(...new Uint8Array([1])));
-      const commitment = computeCommitmentFromTxSummary(base64);
-
-      expect(commitment.startsWith('0x')).toBe(true);
-    });
-  });
-
-  describe('accountIdToHex', () => {
-    it('returns account ID string if already hex formatted', () => {
-      const mockAccount = {
-        id: () => ({
-          toString: () => '0xabc123',
-          prefix: () => ({ asInt: () => BigInt(1) }),
-          suffix: () => ({ asInt: () => BigInt(2) }),
-        }),
-      };
-
-      const hex = accountIdToHex(mockAccount as any);
-      expect(hex).toBe('0xabc123');
-    });
-
-    it('handles 0X prefix', () => {
-      const mockAccount = {
-        id: () => ({
-          toString: () => '0Xabc123',
-          prefix: () => ({ asInt: () => BigInt(1) }),
-          suffix: () => ({ asInt: () => BigInt(2) }),
-        }),
-      };
-
-      const hex = accountIdToHex(mockAccount as any);
-      expect(hex).toBe('0Xabc123');
-    });
-
-    it('constructs hex from prefix and suffix if no 0x prefix', () => {
-      const mockAccount = {
-        id: () => ({
-          toString: () => 'not-a-hex',
-          prefix: () => ({ asInt: () => BigInt('0x0102030405060708') }),
-          suffix: () => ({ asInt: () => BigInt('0x0a0b0c0d0e0f1011') }),
-        }),
-      };
-
-      const hex = accountIdToHex(mockAccount as any);
-      expect(hex).toBe('0x01020304050607080a0b0c0d0e0f10');
-    });
-
-    it('pads prefix to 16 hex characters', () => {
-      const mockAccount = {
-        id: () => ({
-          toString: () => 'not-a-hex',
-          prefix: () => ({ asInt: () => BigInt(1) }),
-          suffix: () => ({ asInt: () => BigInt(0) }),
-        }),
-      };
-
-      const hex = accountIdToHex(mockAccount as any);
-      expect(hex).toBe('0x000000000000000100000000000000');
-    });
-
-    it('produces 30-character hex (excluding 0x prefix)', () => {
-      const mockAccount = {
-        id: () => ({
-          toString: () => 'not-a-hex',
-          prefix: () => ({ asInt: () => BigInt('0xffffffffffffffff') }),
-          suffix: () => ({ asInt: () => BigInt('0xffffffffffffffff') }),
-        }),
-      };
-
-      const hex = accountIdToHex(mockAccount as any);
-      expect(hex.length).toBe(32);
-    });
-  });
-});