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

package/src/signers/para.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ParaSigner } from './para.js';
-import type { ParaSigningContext } from './para.js';
-import { keccak_256 } from '@noble/hashes/sha3.js';
-import { uint8ArrayToBase64 } from '../utils/encoding.js';
-import { wordToBytes } from '../utils/word.js';
-
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  Word: {
-    fromHex: vi.fn((hex: string) => ({
-      toHex: () => hex,
-      toFelts: () => [
-        { asInt: () => 1n },
-        { asInt: () => 2n },
-        { asInt: () => 3n },
-        { asInt: () => 4n },
-      ],
-    })),
-  },
-  AccountId: {
-    fromHex: vi.fn(() => ({
-      prefix: () => ({ asInt: () => BigInt(1) }),
-      suffix: () => ({ asInt: () => BigInt(2) }),
-    })),
-  },
-  Felt: vi.fn().mockImplementation((v: bigint) => ({ value: v })),
-  FeltArray: vi.fn().mockImplementation((arr: any[]) => arr),
-  Rpo256: {
-    hashElements: vi.fn().mockReturnValue({
-      toHex: () => '0x' + 'bb'.repeat(32),
-      toFelts: () => [
-        { asInt: () => 10n },
-        { asInt: () => 20n },
-        { asInt: () => 30n },
-        { asInt: () => 40n },
-      ],
-    }),
-  },
-}));
-
-describe('ParaSigner', () => {
-  let mockPara: ParaSigningContext;
-  const validCompressedKey = '0x02' + 'aa'.repeat(32);
-  const validUncompressedKey = '0x04' + 'aa'.repeat(32) + 'bb'.repeat(31) + 'b0';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockPara = {
-      signMessage: vi.fn().mockResolvedValue({
-        signature: '0x' + 'cc'.repeat(64),
-      }),
-    };
-  });
-
-  describe('constructor', () => {
-    it('should accept a valid compressed public key', () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      expect(signer.publicKey).toBe(validCompressedKey);
-      expect(signer.commitment).toBe('0xcommitment');
-      expect(signer.scheme).toBe('ecdsa');
-    });
-
-    it('should compress an uncompressed public key', () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validUncompressedKey);
-      expect(signer.publicKey).toBe('0x02' + 'aa'.repeat(32));
-    });
-
-    it('should throw on invalid public key', () => {
-      expect(
-        () => new ParaSigner(mockPara, 'wallet-1', '0xcommitment', '0xinvalid'),
-      ).toThrow('Invalid ECDSA public key for ParaSigner');
-    });
-  });
-
-  describe('signAccountIdWithTimestamp', () => {
-    it('should call para signMessage and return normalized signature', async () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      const result = await signer.signAccountIdWithTimestamp('0x' + 'aa'.repeat(15), 1700000000);
-      expect(mockPara.signMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          walletId: 'wallet-1',
-          messageBase64: expect.any(String),
-        }),
-      );
-      expect(result).toMatch(/^0x/);
-    });
-
-    it('hashes the auth digest word bytes before signing', async () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      await signer.signAccountIdWithTimestamp('0x' + 'aa'.repeat(15), 1700000000);
-
-      const expectedDigestBytes = keccak_256(
-        wordToBytes({
-          toFelts: () => [
-            { asInt: () => 10n },
-            { asInt: () => 20n },
-            { asInt: () => 30n },
-            { asInt: () => 40n },
-          ],
-        }),
-      );
-      const expectedBase64 = uint8ArrayToBase64(expectedDigestBytes);
-
-      expect(mockPara.signMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          walletId: 'wallet-1',
-          messageBase64: expectedBase64,
-        }),
-      );
-    });
-  });
-
-  describe('signRequest', () => {
-    it('hashes the request-bound auth digest word bytes before signing', async () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      await signer.signRequest(
-        '0x' + 'aa'.repeat(15),
-        1700000000,
-        { toBytes: () => new Uint8Array([1, 2, 3, 4]) } as never,
-      );
-
-      const expectedDigestBytes = keccak_256(
-        wordToBytes({
-          toFelts: () => [
-            { asInt: () => 10n },
-            { asInt: () => 20n },
-            { asInt: () => 30n },
-            { asInt: () => 40n },
-          ],
-        }),
-      );
-      const expectedBase64 = uint8ArrayToBase64(expectedDigestBytes);
-
-      expect(mockPara.signMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          walletId: 'wallet-1',
-          messageBase64: expectedBase64,
-        }),
-      );
-    });
-  });
-
-  describe('signCommitment', () => {
-    it('should call para signMessage', async () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      await signer.signCommitment('0x' + 'cc'.repeat(32));
-      expect(mockPara.signMessage).toHaveBeenCalled();
-    });
-  });
-
-  describe('signLookupMessage', () => {
-    it('hashes the LookupAuthMessage digest word bytes before signing', async () => {
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      await signer.signLookupMessage('0x' + 'cc'.repeat(32), 1700000000);
-
-      const expectedDigestBytes = keccak_256(
-        wordToBytes({
-          toFelts: () => [
-            { asInt: () => 10n },
-            { asInt: () => 20n },
-            { asInt: () => 30n },
-            { asInt: () => 40n },
-          ],
-        }),
-      );
-      const expectedBase64 = uint8ArrayToBase64(expectedDigestBytes);
-
-      expect(mockPara.signMessage).toHaveBeenCalledWith(
-        expect.objectContaining({
-          walletId: 'wallet-1',
-          messageBase64: expectedBase64,
-        }),
-      );
-    });
-  });
-
-  describe('signing denial', () => {
-    it('should throw when para returns no signature', async () => {
-      (mockPara.signMessage as ReturnType<typeof vi.fn>).mockResolvedValue({ signature: undefined });
-      const signer = new ParaSigner(mockPara, 'wallet-1', '0xcommitment', validCompressedKey);
-      await expect(signer.signCommitment('0x' + 'cc'.repeat(32))).rejects.toThrow(
-        'Para signing was denied by user',
-      );
-    });
-  });
-});

package/src/transaction/index.ts

@@ -1,13 +0,0 @@
-export {
-  chainAnchorFromBase64,
-  chainAnchorToBase64,
-  executeForSummary,
-  executeForSummaryAt,
-  summarySalt,
-} from './summary.js';
-export { buildUpdateSignersTransactionRequest } from './updateSigners.js';
-export { buildUpdateProcedureThresholdTransactionRequest } from './updateProcedureThreshold.js';
-export { buildUpdateGuardianTransactionRequest } from './updateGuardian.js';
-export { buildConsumeNotesTransactionRequest } from './consumeNotes.js';
-export { buildP2idTransactionRequest } from './p2id.js';
-export type { SignatureOptions } from './options.js';

package/src/transaction/p2id.test.ts

@@ -1,371 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Word } from '@miden-sdk/miden-sdk';
-
-const {
-  mockFungibleAssetConstructor,
-  mockHashElements,
-  mockNormalizeHexWord,
-  mockRandomWord,
-  mockWordFromHex,
-  noteMetadataCalls,
-  noteRecipientCalls,
-  noteStorageCalls,
-  saltFelts,
-} = vi.hoisted(() => {
-  const saltFelts = [
-    { id: 'felt-0' },
-    { id: 'felt-1' },
-    { id: 'felt-2' },
-    { id: 'felt-3' },
-  ];
-
-  return {
-    mockFungibleAssetConstructor: vi.fn(),
-    noteMetadataCalls: [] as unknown[][],
-    noteRecipientCalls: [] as unknown[][],
-    noteStorageCalls: [] as unknown[][],
-    mockHashElements: vi.fn().mockReturnValue({ toString: () => 'serial' }),
-    mockNormalizeHexWord: vi.fn((hex: string) => hex),
-    mockRandomWord: vi.fn().mockReturnValue({
-      toHex: () => '0x' + 'aa'.repeat(32),
-    }),
-    mockWordFromHex: vi.fn((hex: string) => {
-      const normalized = hex.toLowerCase();
-      return {
-        toHex: () => hex,
-        toFelts: () => normalized === `0x${'00'.repeat(32)}`
-          ? [
-              { value: 0n },
-              { value: 0n },
-              { value: 0n },
-              { value: 0n },
-            ]
-          : saltFelts,
-      };
-    }),
-    saltFelts,
-  };
-});
-
-vi.mock('@miden-sdk/miden-sdk', () => {
-  class Felt {
-    readonly value: bigint;
-
-    constructor(value: bigint) {
-      this.value = value;
-    }
-  }
-
-  class FeltArray {
-    readonly values: unknown[];
-
-    constructor(values: unknown[]) {
-      this.values = values;
-    }
-  }
-
-  class NoteAssets {
-    constructor(_assets: unknown[]) {}
-  }
-
-  class NoteStorage {
-    constructor(inputs: FeltArray) {
-      noteStorageCalls.push([inputs]);
-    }
-  }
-
-  class NoteMetadata {
-    constructor(
-      sender: unknown,
-      noteType: unknown,
-      noteTag: unknown,
-    ) {
-      noteMetadataCalls.push([sender, noteType, noteTag]);
-    }
-  }
-
-  class NoteRecipient {
-    constructor(
-      serialNum: unknown,
-      noteScript: unknown,
-      noteInputs: unknown,
-    ) {
-      noteRecipientCalls.push([serialNum, noteScript, noteInputs]);
-    }
-  }
-
-  class Note {
-    constructor(
-      _assets: unknown,
-      _metadata: unknown,
-      _recipient: unknown,
-    ) {}
-  }
-
-  class FungibleAsset {
-    constructor(faucet: unknown, amount: bigint) {
-      mockFungibleAssetConstructor(faucet, amount);
-    }
-  }
-
-  class NoteArray {
-    constructor(_notes: unknown[]) {}
-  }
-
-  class TransactionRequestBuilder {
-    withOwnOutputNotes(_notes: unknown): this {
-      return this;
-    }
-
-    withAuthArg(_authArg: unknown): this {
-      return this;
-    }
-
-    extendAdviceMap(_adviceMap: unknown): this {
-      return this;
-    }
-
-    build(): { kind: 'request' } {
-      return { kind: 'request' };
-    }
-  }
-
-  return {
-    AccountId: {
-      fromHex: vi.fn((hex: string) => ({
-        hex,
-        prefix: () => 1,
-        suffix: () => 2,
-        toString: () => hex,
-      })),
-    },
-    Felt,
-    FeltArray,
-    FungibleAsset,
-    MidenArrays: {
-      NoteArray,
-    },
-    Note,
-    NoteAssets,
-    NoteMetadata,
-    NoteRecipient,
-    NoteStorage,
-    NoteScript: {
-      p2id: vi.fn(() => ({ kind: 'p2id-script' })),
-      p2ide: vi.fn(() => ({ kind: 'p2ide-script' })),
-    },
-    NoteTag: {
-      withAccountTarget: vi.fn(() => ({ kind: 'tag' })),
-    },
-    NoteType: {
-      Private: 0,
-      Public: 1,
-    },
-    OutputNote: {
-      full: vi.fn((note: unknown) => ({ note })),
-    },
-    Poseidon2: {
-      hashElements: mockHashElements,
-    },
-    TransactionRequestBuilder,
-    Word: {
-      fromHex: mockWordFromHex,
-    },
-  };
-});
-
-vi.mock('../utils/encoding.js', () => ({
-  normalizeHexWord: mockNormalizeHexWord,
-}));
-
-vi.mock('../utils/random.js', () => ({
-  randomWord: mockRandomWord,
-}));
-
-import { buildP2idTransactionRequest, parseP2idNoteType, p2idNoteTypeToMetadata } from './p2id.js';
-import { NoteType } from '@miden-sdk/miden-sdk';
-
-const FAUCET_ID = '0x7bfb0f38b0fafa103f86a805594171';
-
-describe('buildP2idTransactionRequest', () => {
-  beforeEach(() => {
-    mockFungibleAssetConstructor.mockClear();
-    mockHashElements.mockClear();
-    mockNormalizeHexWord.mockClear();
-    mockRandomWord.mockClear();
-    mockWordFromHex.mockClear();
-    noteMetadataCalls.length = 0;
-    noteRecipientCalls.length = 0;
-    noteStorageCalls.length = 0;
-  });
-
-  it('derives serial number from salt felts plus four zero felts', () => {
-    const salt = { toHex: () => '0x' + '11'.repeat(32) } as unknown as Word;
-
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-      { salt },
-    );
-
-    expect(mockRandomWord).not.toHaveBeenCalled();
-    expect(mockHashElements).toHaveBeenCalledTimes(1);
-
-    const [feltArrayArg] = mockHashElements.mock.calls[0] as [{ values: unknown[] }];
-    const values = feltArrayArg.values;
-
-    expect(values).toHaveLength(8);
-    expect(values.slice(0, 4)).toEqual(saltFelts);
-
-    for (const felt of values.slice(4)) {
-      expect((felt as { value: bigint }).value).toBe(0n);
-    }
-  });
-
-  it('creates a public note by default (issue #322)', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-    );
-
-    expect(noteMetadataCalls).toHaveLength(1);
-    expect(noteMetadataCalls[0][1]).toBe(NoteType.Public);
-  });
-
-  it('builds the asset from the faucet id, whose callback flag it carries since Miden 0.16', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-    );
-
-    expect(mockFungibleAssetConstructor).toHaveBeenCalledTimes(1);
-    const [faucet, amount] = mockFungibleAssetConstructor.mock.calls[0] as [{ hex: string }, bigint];
-    expect(faucet.hex).toBe(FAUCET_ID);
-    expect(amount).toBe(10n);
-  });
-
-  it('threads the requested noteType into the note metadata (issue #322)', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      '0x7bfb0f38b0fafa103f86a805594171',
-      10n,
-      { noteType: NoteType.Private },
-    );
-
-    expect(noteMetadataCalls).toHaveLength(1);
-    expect(noteMetadataCalls[0][1]).toBe(NoteType.Private);
-  });
-
-  it('builds a plain P2ID note without heights: p2id script, 2 storage items', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-    );
-
-    expect(noteRecipientCalls).toHaveLength(1);
-    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2id-script' });
-    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
-    expect(storageInputs.values).toEqual([2, 1]);
-  });
-
-  it('builds a P2IDE note when reclaimHeight is set (issue #366)', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-      { reclaimHeight: 12345 },
-    );
-
-    expect(noteRecipientCalls).toHaveLength(1);
-    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2ide-script' });
-
-    // P2IDE storage layout: [suffix, prefix, reclaim, timelock], 0 = unset.
-    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
-    expect(storageInputs.values).toHaveLength(4);
-    expect(storageInputs.values.slice(0, 2)).toEqual([2, 1]);
-    expect((storageInputs.values[2] as { value: bigint }).value).toBe(12345n);
-    expect((storageInputs.values[3] as { value: bigint }).value).toBe(0n);
-  });
-
-  it('builds a P2IDE note when only timelockHeight is set (issue #366)', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-      { timelockHeight: 777 },
-    );
-
-    expect(noteRecipientCalls[0][1]).toEqual({ kind: 'p2ide-script' });
-    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
-    expect((storageInputs.values[2] as { value: bigint }).value).toBe(0n);
-    expect((storageInputs.values[3] as { value: bigint }).value).toBe(777n);
-  });
-
-  it('carries both heights into the P2IDE storage (issue #366)', () => {
-    buildP2idTransactionRequest(
-      '0x7bfb0f38b0fafa103f86a805594170',
-      '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-      FAUCET_ID,
-      10n,
-      { reclaimHeight: 500, timelockHeight: 400 },
-    );
-
-    const [storageInputs] = noteStorageCalls[0] as [{ values: unknown[] }];
-    expect((storageInputs.values[2] as { value: bigint }).value).toBe(500n);
-    expect((storageInputs.values[3] as { value: bigint }).value).toBe(400n);
-  });
-
-  it.each([
-    ['zero', 0],
-    ['negative', -5],
-    ['fractional', 1.5],
-    ['above u32::MAX', 0x1_0000_0000],
-  ])('rejects a %s height instead of building a divergent note (issue #366)', (_label, height) => {
-    expect(() =>
-      buildP2idTransactionRequest(
-        '0x7bfb0f38b0fafa103f86a805594170',
-        '0x8a65fc5a39e4cd106d648e3eb4ab5f',
-        FAUCET_ID,
-        10n,
-          { reclaimHeight: height },
-      ),
-    ).toThrow(/unsupported reclaimHeight/);
-  });
-});
-
-describe('parseP2idNoteType', () => {
-  it('maps absent to Public (pre-#322 proposals)', () => {
-    expect(parseP2idNoteType(undefined)).toBe(NoteType.Public);
-  });
-
-  it('maps wire values to note types', () => {
-    expect(parseP2idNoteType('public')).toBe(NoteType.Public);
-    expect(parseP2idNoteType('private')).toBe(NoteType.Private);
-  });
-
-  it('rejects unknown values instead of silently rebuilding a public note', () => {
-    expect(() => parseP2idNoteType('encrypted')).toThrow(/unsupported metadata.noteType/);
-  });
-});
-
-describe('p2idNoteTypeToMetadata', () => {
-  it('omits the default so public payloads keep the legacy wire shape', () => {
-    expect(p2idNoteTypeToMetadata(undefined)).toBeUndefined();
-    expect(p2idNoteTypeToMetadata(NoteType.Public)).toBeUndefined();
-  });
-
-  it('serializes private', () => {
-    expect(p2idNoteTypeToMetadata(NoteType.Private)).toBe('private');
-  });
-});

package/src/transaction/rpoRandomCoin.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { Word } from '@miden-sdk/miden-sdk';
-
-const { mockHashElements, seedFelts } = vi.hoisted(() => {
-  const seedFelts = [
-    { id: 'seed-0' },
-    { id: 'seed-1' },
-    { id: 'seed-2' },
-    { id: 'seed-3' },
-  ];
-
-  return {
-    mockHashElements: vi.fn().mockReturnValue({ id: 'drawn-word' }),
-    seedFelts,
-  };
-});
-
-vi.mock('@miden-sdk/miden-sdk', () => {
-  class Felt {
-    readonly value: bigint;
-
-    constructor(value: bigint) {
-      this.value = value;
-    }
-  }
-
-  class FeltArray {
-    readonly values: unknown[];
-
-    constructor(values: unknown[]) {
-      this.values = values;
-    }
-  }
-
-  return {
-    Felt,
-    FeltArray,
-    Rpo256: {
-      hashElements: mockHashElements,
-    },
-  };
-});
-
-import { RpoRandomCoin } from './rpoRandomCoin.js';
-
-describe('RpoRandomCoin', () => {
-  it('drawWord hashes seed felts plus four zero felts', () => {
-    const seed = { toFelts: () => seedFelts } as unknown as Word;
-    const coin = new RpoRandomCoin(seed);
-    const drawn = coin.drawWord();
-
-    expect(drawn).toEqual({ id: 'drawn-word' });
-    expect(mockHashElements).toHaveBeenCalledTimes(1);
-
-    const [feltArrayArg] = mockHashElements.mock.calls[0] as [{ values: unknown[] }];
-    const values = feltArrayArg.values;
-
-    expect(values).toHaveLength(8);
-    expect(values.slice(0, 4)).toEqual(seedFelts);
-    for (const felt of values.slice(4)) {
-      expect((felt as { value: bigint }).value).toBe(0n);
-    }
-  });
-});

package/src/transaction/summary.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  AccountId: { fromHex: vi.fn() },
-  Word: {
-    newFromFelts: vi.fn((felts: unknown[]) => ({ felts })),
-  },
-}));
-
-vi.mock('../raw-client.js', () => ({
-  getRawMidenClient: vi.fn(),
-}));
-
-const { summarySalt } = await import('./summary.js');
-
-describe('summarySalt', () => {
-  it('reads the salt from the trailing four user params', () => {
-    const summary = {
-      userParams: () => [0, 0, 0, 11, 22, 33, 44],
-    } as never;
-
-    expect(summarySalt(summary)).toEqual({ felts: [11, 22, 33, 44] });
-  });
-
-  it('ignores the leading three user params the auth component zeroes', () => {
-    const summary = {
-      userParams: () => [7, 8, 9, 11, 22, 33, 44],
-    } as never;
-
-    expect(summarySalt(summary)).toEqual({ felts: [11, 22, 33, 44] });
-  });
-});