@openzeppelin/miden-multisig-client 0.16.1 → 0.17.0-rc.1

package/src/inspector.test.ts

@@ -1,18 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { AccountInspector } from './inspector.js';
-
-// Storage slot names matching the MASM definitions
-const MULTISIG_SLOT_NAMES = {
-  THRESHOLD_CONFIG: 'openzeppelin::multisig::threshold_config',
-  SIGNER_PUBLIC_KEYS: 'openzeppelin::multisig::signer_public_keys',
-  EXECUTED_TRANSACTIONS: 'openzeppelin::multisig::executed_transactions',
-  PROCEDURE_THRESHOLDS: 'openzeppelin::multisig::procedure_thresholds',
-} as const;
-
-const GUARDIAN_SLOT_NAMES = {
-  SELECTOR: 'openzeppelin::guardian::selector',
-  PUBLIC_KEY: 'openzeppelin::guardian::public_key',
-} as const;
+import { AccountInspector, assertCompleteDetectedConfig } from './inspector.js';
+import type { DetectedMultisigConfig } from './inspector.js';
 
 // Mock the Miden SDK
 vi.mock('@miden-sdk/miden-sdk', () => {
@@ -21,15 +9,18 @@ vi.mock('@miden-sdk/miden-sdk', () => {
     toHex: () => '0x' + values.map(v => v.toString(16).padStart(16, '0')).join(''),
   });
 
+  // Faithful to the real SDK's read semantics (verified against the wasm
+  // glue and miden-protocol): getItem returns undefined for an absent slot;
+  // getMapItem returns undefined only when the slot is absent or not a map,
+  // and the EMPTY word for a missing key in an existing map
+  // (StorageMap::get is unwrap_or_default). Neither throws for "not found".
   const createMockStorage = (slots: Map<string, any>, maps: Map<string, Map<string, any>>) => ({
-    getItem: (slotName: string) => slots.get(slotName) ?? createMockWord([0n, 0n, 0n, 0n]),
+    getItem: (slotName: string) => slots.get(slotName),
     getMapItem: (slotName: string, key: any) => {
       const map = maps.get(slotName);
-      if (!map) throw new Error('Map not found');
+      if (!map) return undefined;
       const keyStr = key.toU64s?.()[0]?.toString() ?? '0';
-      const value = map.get(keyStr);
-      if (!value) throw new Error('Key not found');
-      return value;
+      return map.get(keyStr) ?? createMockWord([0n, 0n, 0n, 0n]);
     },
   });
 
@@ -46,7 +37,6 @@ vi.mock('@miden-sdk/miden-sdk', () => {
         // Return different mocked accounts based on test scenario
         // Default: 2-of-3 multisig with GUARDIAN enabled
         const slot0 = createMockWord([2n, 3n, 0n, 0n]); // threshold=2, numSigners=3
-        const slot4 = createMockWord([1n, 0n, 0n, 0n]); // GUARDIAN enabled
 
         const signerMap = new Map<string, any>();
         signerMap.set('0', createMockWord([BigInt('0x1111111111111111'), BigInt('0x2222222222222222'), BigInt('0x3333333333333333'), BigInt('0x4444444444444444')]));
@@ -57,15 +47,16 @@ vi.mock('@miden-sdk/miden-sdk', () => {
         guardianMap.set('0', createMockWord([BigInt('0xeeeeeeeeeeeeeeee'), BigInt('0xffffffffffffffff'), BigInt('0x0000000000000001'), BigInt('0x0000000000000002')]));
 
         const slots = new Map<string, any>();
-        slots.set('openzeppelin::multisig::threshold_config', slot0);
-        slots.set('openzeppelin::guardian::selector', slot4);
+        slots.set('miden::standards::auth::multisig::threshold_config', slot0);
 
         const maps = new Map<string, Map<string, any>>();
-        maps.set('openzeppelin::multisig::signer_public_keys', signerMap);
-        maps.set('openzeppelin::guardian::public_key', guardianMap);
+        maps.set('miden::standards::auth::multisig::approver_public_keys', signerMap);
+        maps.set('miden::standards::auth::guardian::pub_key', guardianMap);
 
         return {
           storage: () => createMockStorage(slots, maps),
+          // The contract-version guard checks for the pinned auth procedure.
+          code: () => ({ hasProcedure: () => true }),
           vault: () => createMockVault([
             { faucetId: '0xfaucet1', amount: 1000n },
             { faucetId: '0xfaucet2', amount: 500n },
@@ -73,10 +64,18 @@ vi.mock('@miden-sdk/miden-sdk', () => {
         };
       }),
     },
-    Word: vi.fn().mockImplementation((arr: BigUint64Array) => ({
-      toU64s: () => Array.from(arr),
-      toHex: () => '0x' + Array.from(arr).map(v => v.toString(16).padStart(16, '0')).join(''),
-    })),
+    Word: Object.assign(
+      vi.fn().mockImplementation((arr: BigUint64Array) => ({
+        toU64s: () => Array.from(arr),
+        toHex: () => '0x' + Array.from(arr).map(v => v.toString(16).padStart(16, '0')).join(''),
+      })),
+      {
+        fromHex: vi.fn((hex: string) => ({
+          toU64s: () => [0n, 0n, 0n, 0n],
+          toHex: () => hex,
+        })),
+      },
+    ),
   };
 });
 
@@ -94,11 +93,10 @@ describe('AccountInspector', () => {
       expect(config.numSigners).toBe(3);
     });
 
-    it('extracts GUARDIAN status', () => {
+    it('extracts the GUARDIAN commitment', () => {
       const base64 = btoa(String.fromCharCode(...new Uint8Array([1, 2, 3])));
       const config = AccountInspector.fromBase64(base64);
 
-      expect(config.guardianEnabled).toBe(true);
       expect(config.guardianCommitment).toMatch(/^0x[a-f0-9]+$/);
     });
 
@@ -138,6 +136,21 @@ describe('AccountInspector', () => {
 
       expect(config.numSigners).toBe(3);
     });
+
+    it('rejects accounts built from a different contract version', async () => {
+      const { Account } = await import('@miden-sdk/miden-sdk');
+      const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+      // Same account shape, but its code lacks the pinned auth procedure —
+      // root-keyed reads against it would silently miss its stored overrides.
+      const foreign = {
+        ...account,
+        code: () => ({ hasProcedure: () => false }),
+      };
+
+      expect(() => AccountInspector.fromAccount(foreign as never)).toThrow(
+        /unsupported contract version/,
+      );
+    });
   });
 });
 
@@ -146,19 +159,19 @@ describe('AccountInspector edge cases', () => {
     vi.clearAllMocks();
   });
 
-  it('handles account with GUARDIAN disabled', async () => {
+  it('returns a null GUARDIAN commitment when the guardian pub_key slot is absent', async () => {
     const { Account } = await import('@miden-sdk/miden-sdk');
 
-    // Override mock for this test
+    // Override mock for this test: no guardian pub_key entry present.
     vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
       storage: () => ({
         getItem: (slotName: string) => {
-          if (slotName === 'openzeppelin::multisig::threshold_config') return { toU64s: () => [1n, 1n, 0n, 0n] };
-          if (slotName === 'openzeppelin::guardian::selector') return { toU64s: () => [0n, 0n, 0n, 0n] }; // GUARDIAN disabled
+          if (slotName === 'miden::standards::auth::multisig::threshold_config') return { toU64s: () => [1n, 1n, 0n, 0n] };
           return { toU64s: () => [0n, 0n, 0n, 0n] };
         },
         getMapItem: (slotName: string, key: any) => {
-          if (slotName === 'openzeppelin::multisig::signer_public_keys' && key.toU64s?.()[0] === 0n) {
+          if (slotName === 'miden::standards::auth::multisig::approver_public_keys' && key.toU64s?.()[0] === 0n) {
             return {
               toHex: () => '0x' + 'a'.repeat(64),
               toU64s: () => [1n, 2n, 3n, 4n],
@@ -175,7 +188,6 @@ describe('AccountInspector edge cases', () => {
     const account = Account.deserialize(new Uint8Array([1, 2, 3]));
     const config = AccountInspector.fromAccount(account);
 
-    expect(config.guardianEnabled).toBe(false);
     expect(config.guardianCommitment).toBeNull();
   });
 
@@ -183,6 +195,7 @@ describe('AccountInspector edge cases', () => {
     const { Account } = await import('@miden-sdk/miden-sdk');
 
     vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
       storage: () => ({
         getItem: () => ({ toU64s: () => [1n, 1n, 0n, 0n] }),
         getMapItem: () => {
@@ -204,10 +217,10 @@ describe('AccountInspector edge cases', () => {
     const { Account } = await import('@miden-sdk/miden-sdk');
 
     vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
       storage: () => ({
         getItem: (slotName: string) => {
-          if (slotName === 'openzeppelin::multisig::threshold_config') return { toU64s: () => [2n, 5n, 0n, 0n] }; // threshold=2, numSigners=5
-          if (slotName === 'openzeppelin::guardian::selector') return { toU64s: () => [0n, 0n, 0n, 0n] };
+          if (slotName === 'miden::standards::auth::multisig::threshold_config') return { toU64s: () => [2n, 5n, 0n, 0n] }; // threshold=2, numSigners=5
           return { toU64s: () => [0n, 0n, 0n, 0n] };
         },
         getMapItem: () => {
@@ -231,6 +244,7 @@ describe('AccountInspector edge cases', () => {
     const { Account } = await import('@miden-sdk/miden-sdk');
 
     vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
       storage: () => ({
         getItem: () => ({ toU64s: () => [1n, 1n, 0n, 0n] }),
         getMapItem: () => {
@@ -248,3 +262,281 @@ describe('AccountInspector edge cases', () => {
     expect(config.vaultBalances).toEqual([]);
   });
 });
+
+describe('AccountInspector.getSignerPublicKeyCommitments', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns all signer commitments ordered by signer index', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    const commitments = AccountInspector.getSignerPublicKeyCommitments(account);
+
+    expect(commitments).toEqual([
+      '0x1111111111111111222222222222222233333333333333334444444444444444',
+      '0x5555555555555555666666666666666677777777777777778888888888888888',
+      '0xaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd',
+    ]);
+  });
+
+  it('rejects accounts built from a different contract version', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+    const foreign = {
+      ...account,
+      code: () => ({ hasProcedure: () => false }),
+    };
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(foreign as never)).toThrow(
+      /unsupported contract version/,
+    );
+  });
+
+  it('throws when a signer map entry is the empty word instead of truncating', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    // Real SDK semantics: entries 0 and 1 exist, entries 2..4 come back as
+    // the empty word (StorageMap::get is unwrap_or_default) — NOT undefined
+    // and NOT a throw.
+    const entries = new Map<string, any>([
+      ['0', { toU64s: () => [1n, 2n, 3n, 4n], toHex: () => '0x' + 'a'.repeat(64) }],
+      ['1', { toU64s: () => [5n, 6n, 7n, 8n], toHex: () => '0x' + 'b'.repeat(64) }],
+    ]);
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: (slotName: string) => {
+          if (slotName === 'miden::standards::auth::multisig::threshold_config') return { toU64s: () => [2n, 5n, 0n, 0n] };
+          return undefined;
+        },
+        getMapItem: (slotName: string, key: any) => {
+          if (slotName !== 'miden::standards::auth::multisig::approver_public_keys') return undefined;
+          const keyStr = key.toU64s?.()[0]?.toString() ?? '0';
+          return entries.get(keyStr) ?? { toU64s: () => [0n, 0n, 0n, 0n] };
+        },
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+      /missing signer public key at index 2/
+    );
+  });
+
+  it('throws when the signer map slot itself is absent', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: (slotName: string) => {
+          if (slotName === 'miden::standards::auth::multisig::threshold_config') return { toU64s: () => [2n, 3n, 0n, 0n] };
+          return undefined;
+        },
+        getMapItem: () => undefined,
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+      /missing signer public key at index 0/
+    );
+  });
+
+  it('throws when the threshold config slot is absent', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: () => undefined,
+        getMapItem: () => undefined,
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+      /not a guarded-multisig account/
+    );
+  });
+
+  it('throws when the threshold config reports zero signers', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: () => ({ toU64s: () => [0n, 0n, 0n, 0n] }),
+        getMapItem: () => undefined,
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+      /zero signers/
+    );
+  });
+
+  // 2n ** 53n is the smallest count whose Number() conversion is no longer a
+  // safe integer (i++ would stop advancing without the ceiling guard).
+  it.each([4294967295n, 2n ** 53n])(
+    'throws on an absurd signer count (%s) instead of looping',
+    async (count) => {
+      const { Account } = await import('@miden-sdk/miden-sdk');
+
+      vi.mocked(Account.deserialize).mockReturnValueOnce({
+        code: () => ({ hasProcedure: () => true }),
+        storage: () => ({
+          getItem: () => ({ toU64s: () => [2n, count, 0n, 0n] }),
+          getMapItem: () => ({ toU64s: () => [1n, 2n, 3n, 4n], toHex: () => '0x' + 'a'.repeat(64) }),
+        }),
+      } as any);
+
+      const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+      expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+        /sanity limit/
+      );
+    },
+  );
+
+  it('surfaces a descriptive error for an account from a different SDK copy', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    // wasm-bindgen's _assertClass rejects Word instances from another
+    // bundled SDK copy with this exact message.
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: (slotName: string) => {
+          if (slotName === 'miden::standards::auth::multisig::threshold_config') return { toU64s: () => [1n, 1n, 0n, 0n] };
+          return undefined;
+        },
+        getMapItem: () => {
+          throw new Error('expected instance of Word');
+        },
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getSignerPublicKeyCommitments(account)).toThrow(
+      /different copy of @miden-sdk\/miden-sdk/
+    );
+  });
+});
+
+describe('AccountInspector.getGuardianPublicKeyCommitment', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns the guardian commitment', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    const commitment = AccountInspector.getGuardianPublicKeyCommitment(account);
+
+    expect(commitment).toBe('0xeeeeeeeeeeeeeeeeffffffffffffffff00000000000000010000000000000002');
+  });
+
+  it('rejects accounts built from a different contract version', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+    const foreign = {
+      ...account,
+      code: () => ({ hasProcedure: () => false }),
+    };
+
+    expect(() => AccountInspector.getGuardianPublicKeyCommitment(foreign as never)).toThrow(
+      /unsupported contract version/,
+    );
+  });
+
+  it('throws when the guardian key entry is the empty word', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: () => ({ toU64s: () => [1n, 1n, 0n, 0n] }),
+        getMapItem: () => ({ toU64s: () => [0n, 0n, 0n, 0n] }),
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getGuardianPublicKeyCommitment(account)).toThrow(
+      /inconsistent account state/
+    );
+  });
+
+  it('propagates genuine storage read failures', async () => {
+    const { Account } = await import('@miden-sdk/miden-sdk');
+
+    vi.mocked(Account.deserialize).mockReturnValueOnce({
+      code: () => ({ hasProcedure: () => true }),
+      storage: () => ({
+        getItem: () => ({ toU64s: () => [1n, 1n, 0n, 0n] }),
+        getMapItem: () => {
+          throw new Error('storage backend exploded');
+        },
+      }),
+    } as any);
+
+    const account = Account.deserialize(new Uint8Array([1, 2, 3]));
+
+    expect(() => AccountInspector.getGuardianPublicKeyCommitment(account)).toThrow(
+      'storage backend exploded'
+    );
+  });
+});
+
+describe('assertCompleteDetectedConfig', () => {
+  const complete: DetectedMultisigConfig = {
+    threshold: 2,
+    numSigners: 2,
+    signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
+    guardianCommitment: '0x' + 'c'.repeat(64),
+    vaultBalances: [],
+    procedureThresholds: new Map(),
+  };
+
+  it('accepts a complete config', () => {
+    expect(() => assertCompleteDetectedConfig(complete)).not.toThrow();
+  });
+
+  it('rejects a signer set shorter than the reported count', () => {
+    expect(() =>
+      assertCompleteDetectedConfig({
+        ...complete,
+        numSigners: 3,
+      }),
+    ).toThrow(/incomplete signer set: storage reports 3 signers, read 2/);
+  });
+
+  it('rejects a zero signer count', () => {
+    expect(() =>
+      assertCompleteDetectedConfig({
+        ...complete,
+        numSigners: 0,
+        signerCommitments: [],
+      }),
+    ).toThrow(/incomplete signer set/);
+  });
+
+  it('rejects a missing guardian commitment', () => {
+    expect(() =>
+      assertCompleteDetectedConfig({
+        ...complete,
+        guardianCommitment: null,
+      }),
+    ).toThrow(/missing guardian commitment/);
+  });
+});