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

package/src/account/masm/account-components/auth.ts

@@ -1,46 +0,0 @@
-// This file is generated by scripts/generate-masm.mjs from the MASM contract sources.
-// Do not edit it by hand.
-
-export const GUARDED_MULTISIG_ACCOUNT_COMPONENT_MASM = `# The MASM code of the Multi-Signature Authentication component integrated with a state guardian.
-#
-# See the \`AuthGuardedMultisig\` Rust type's documentation for more details.
-
-use miden::standards::auth::multisig
-use miden::standards::auth::guardian
-
-pub use {update_signers_and_threshold} from miden::standards::auth::multisig
-pub use {get_threshold_and_num_approvers} from miden::standards::auth::multisig
-pub use {set_procedure_threshold} from miden::standards::auth::multisig
-pub use {get_signer_at} from miden::standards::auth::multisig
-pub use {is_signer} from miden::standards::auth::multisig
-
-pub use {update_guardian_public_key} from miden::standards::auth::guardian
-
-#! Authenticate a transaction with multi-signature support and optional guardian verification.
-#!
-#! Inputs:
-#!   Operand stack: [SALT]
-#! Outputs:
-#!   Operand stack: []
-#!
-#! Invocation: call
-@auth_script
-pub proc auth_tx_guarded_multisig(salt: word)
-    # zero the leading user params (not exposed through this component's interface); the SALT
-    # occupies the trailing four
-    push.0.0.0
-    # => [0, 0, 0, SALT]
-
-    exec.multisig::auth_tx
-    # => [TX_SUMMARY_COMMITMENT]
-
-    dupw
-    # => [TX_SUMMARY_COMMITMENT, TX_SUMMARY_COMMITMENT]
-    
-    exec.guardian::verify_signature
-    # => [TX_SUMMARY_COMMITMENT]
-
-    exec.multisig::record_and_assert_new_tx
-    # => []
-end
-`;

package/src/account/masm/index.ts

@@ -1,4 +0,0 @@
-// This file is generated by scripts/generate-masm.mjs from the MASM contract sources.
-// Do not edit it by hand.
-
-export * from './account-components/auth.js';

package/src/account/masm.ts

@@ -1,4 +0,0 @@
-// This file is generated by scripts/generate-masm.mjs from the MASM contract sources.
-// Do not edit it by hand.
-
-export * from './masm/index.js';

package/src/account/storage.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-
-const { storageMaps, storageSlotMap } = vi.hoisted(() => {
-  const storageMaps: Array<{ entries: Array<{ key: unknown; value: unknown }> }> = [];
-  const storageSlotMap = vi.fn((name, map) => ({ kind: 'map', name, map }));
-
-  return { storageMaps, storageSlotMap };
-});
-
-vi.mock('@miden-sdk/miden-sdk', () => {
-  class MockWord {
-    data: BigUint64Array | string;
-
-    constructor(data: BigUint64Array | string) {
-      this.data = data;
-    }
-
-    static fromHex(hex: string) {
-      return new MockWord(hex);
-    }
-  }
-
-  class MockStorageMap {
-    entries: Array<{ key: unknown; value: unknown }> = [];
-
-    constructor() {
-      storageMaps.push(this);
-    }
-
-    insert(key: unknown, value: unknown) {
-      this.entries.push({ key, value });
-    }
-  }
-
-  return {
-    Word: MockWord,
-    StorageMap: MockStorageMap,
-    StorageSlot: {
-      fromValue: vi.fn((name, value) => ({ kind: 'value', name, value })),
-      map: storageSlotMap,
-    },
-  };
-});
-
-describe('buildMultisigStorageSlots', () => {
-  beforeEach(() => {
-    storageMaps.length = 0;
-    storageSlotMap.mockClear();
-  });
-
-  it('keeps single-signer public-key and scheme maps to the configured signer count', async () => {
-    const { buildMultisigStorageSlots } = await import('./storage.js');
-
-    buildMultisigStorageSlots({
-      threshold: 1,
-      signerCommitments: ['0x' + '1'.repeat(64)],
-      guardianCommitment: '0x' + '2'.repeat(64),
-      signatureScheme: 'falcon',
-    });
-
-    const signersMap = storageMaps[0];
-    const signerSchemesMap = storageMaps[1];
-
-    expect(signersMap.entries).toHaveLength(1);
-    expect(signerSchemesMap.entries).toHaveLength(1);
-    expect(signersMap.entries[0].key).toMatchObject({
-      data: new BigUint64Array([0n, 0n, 0n, 0n]),
-    });
-    expect(signerSchemesMap.entries[0].key).toMatchObject({
-      data: new BigUint64Array([0n, 0n, 0n, 0n]),
-    });
-  });
-
-  it('does not pad signer maps when there are already multiple signers', async () => {
-    const { buildMultisigStorageSlots } = await import('./storage.js');
-
-    buildMultisigStorageSlots({
-      threshold: 1,
-      signerCommitments: ['0x' + '1'.repeat(64), '0x' + '3'.repeat(64)],
-      guardianCommitment: '0x' + '2'.repeat(64),
-      signatureScheme: 'falcon',
-    });
-
-    const signersMap = storageMaps[0];
-    const signerSchemesMap = storageMaps[1];
-
-    expect(signersMap.entries).toHaveLength(2);
-    expect(signerSchemesMap.entries).toHaveLength(2);
-  });
-});

package/src/client.test.ts

@@ -1,473 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MultisigClient } from './client.js';
-import type { Signer } from './types.js';
-
-// Mock the Miden SDK
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  AccountId: {
-    fromHex: vi.fn((hex: string) => ({ toString: () => hex })),
-  },
-  Account: {
-    deserialize: vi.fn(() => ({
-      id: () => ({
-        toString: () => '0x' + 'd'.repeat(30),
-        prefix: () => ({ asInt: () => BigInt(1) }),
-        suffix: () => ({ asInt: () => BigInt(2) }),
-      }),
-      serialize: () => new Uint8Array([1, 2, 3]),
-      storage: vi.fn(),
-      vault: vi.fn(),
-    })),
-  },
-  Word: vi.fn(),
-}));
-
-// Mock the AccountInspector, keeping the real assertCompleteDetectedConfig
-// so load()'s fail-closed validation is exercised.
-vi.mock('./inspector.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('./inspector.js')>();
-  return {
-    ...actual,
-    AccountInspector: {
-      fromAccount: vi.fn(() => ({
-        threshold: 2,
-        numSigners: 2,
-        signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-        guardianCommitment: '0x' + 'c'.repeat(64),
-        vaultBalances: [],
-        procedureThresholds: new Map(),
-      })),
-    },
-  };
-});
-
-// Mock the account creation module
-vi.mock('./account/index.js', () => ({
-  createMultisigAccount: vi.fn().mockResolvedValue({
-    account: {
-      id: () => ({
-        toString: () => '0x' + 'a'.repeat(30),
-        prefix: () => ({ asInt: () => BigInt(1) }),
-        suffix: () => ({ asInt: () => BigInt(2) }),
-      }),
-      serialize: () => new Uint8Array([1, 2, 3]),
-    },
-    seed: new Uint8Array([4, 5, 6]),
-  }),
-}));
-
-// Mock fetch for GUARDIAN client
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-const GUARDIAN_URL = 'http://localhost:3000';
-const MIDEN_RPC = 'http://localhost:57291';
-const CLIENT_CONFIG = { guardianEndpoint: GUARDIAN_URL, midenRpcEndpoint: MIDEN_RPC };
-
-describe('MultisigClient', () => {
-  let webClient: any;
-  let mockSigner: Signer;
-
-  beforeEach(() => {
-    mockFetch.mockReset();
-
-    webClient = {
-      accounts: {
-        get: vi.fn().mockResolvedValue(null),
-        insert: vi.fn().mockResolvedValue(undefined),
-      },
-      keystore: {
-        insert: vi.fn().mockResolvedValue(undefined),
-      },
-    };
-
-    mockSigner = {
-      commitment: '0x' + '1'.repeat(64),
-      publicKey: '0x' + '2'.repeat(64),
-      scheme: 'falcon',
-      signAccountIdWithTimestamp: vi.fn().mockResolvedValue('0x' + 'a'.repeat(128)),
-      signRequest: vi.fn().mockReturnValue('0x' + 'a'.repeat(128)),
-      signCommitment: vi.fn().mockReturnValue('0x' + 'b'.repeat(128)),
-    };
-  });
-
-  describe('constructor', () => {
-    it('should create client when both endpoints are supplied', () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      expect(client).toBeInstanceOf(MultisigClient);
-    });
-
-    it('should create client with custom GUARDIAN endpoint', () => {
-      const client = new MultisigClient(webClient, {
-        guardianEndpoint: 'http://custom:8080',
-        midenRpcEndpoint: MIDEN_RPC,
-      });
-      expect(client).toBeInstanceOf(MultisigClient);
-    });
-
-    it('throws when the config object is omitted', () => {
-      expect(() => new (MultisigClient as any)(webClient)).toThrow(
-        'missing required configuration: midenRpcEndpoint',
-      );
-    });
-
-    it.each([undefined, null, 42, '', '   '])(
-      'throws before any network or store access when midenRpcEndpoint is %j',
-      (endpoint) => {
-        expect(
-          () =>
-            new MultisigClient(webClient, {
-              guardianEndpoint: GUARDIAN_URL,
-              midenRpcEndpoint: endpoint as any,
-            }),
-        ).toThrow('missing required configuration: midenRpcEndpoint');
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(webClient.accounts.get).not.toHaveBeenCalled();
-        expect(webClient.accounts.insert).not.toHaveBeenCalled();
-      },
-    );
-
-    it.each([undefined, null, 42, '', '   '])(
-      'throws before any network or store access when guardianEndpoint is %j',
-      (endpoint) => {
-        expect(
-          () =>
-            new MultisigClient(webClient, {
-              guardianEndpoint: endpoint as any,
-              midenRpcEndpoint: MIDEN_RPC,
-            }),
-        ).toThrow('missing required configuration: guardianEndpoint');
-        expect(mockFetch).not.toHaveBeenCalled();
-        expect(webClient.accounts.get).not.toHaveBeenCalled();
-        expect(webClient.accounts.insert).not.toHaveBeenCalled();
-      },
-    );
-
-    it('rejects a blank endpoint passed to setGuardianEndpoint', () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      expect(() => client.setGuardianEndpoint('   ')).toThrow(
-        'missing required configuration: guardianEndpoint',
-      );
-    });
-  });
-
-  describe('guardianClient getter', () => {
-    it('should expose GUARDIAN client for getting pubkey', () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      expect(client.guardianClient).toBeDefined();
-    });
-  });
-
-  describe('create', () => {
-    it('should create multisig and return Multisig instance', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      const config = {
-        threshold: 2,
-        signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-        guardianCommitment: '0x' + 'c'.repeat(64),
-      };
-
-      const multisig = await client.create(config, mockSigner);
-
-      expect(multisig).toBeDefined();
-      expect(multisig.threshold).toBe(2);
-      expect(multisig.signerCommitments).toEqual(config.signerCommitments);
-      expect(multisig.guardianCommitment).toBe(config.guardianCommitment);
-    });
-
-    it('should set signer on GUARDIAN client', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      const config = {
-        threshold: 1,
-        signerCommitments: ['0x' + 'a'.repeat(64)],
-        guardianCommitment: '0x' + 'c'.repeat(64),
-      };
-
-      const multisig = await client.create(config, mockSigner);
-      expect(multisig.signerCommitment).toBe(mockSigner.commitment);
-    });
-
-    it('binds the signer auth key to the created account when supported', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      const bindAccountKey = vi.fn().mockResolvedValue(undefined);
-      const bindingSigner = {
-        ...mockSigner,
-        bindAccountKey,
-      };
-
-      await client.create({
-        threshold: 1,
-        signerCommitments: ['0x' + 'a'.repeat(64)],
-        guardianCommitment: '0x' + 'c'.repeat(64),
-      }, bindingSigner);
-
-      expect(bindAccountKey).toHaveBeenCalledWith(webClient, '0x' + 'a'.repeat(30));
-    });
-  });
-
-  describe('load', () => {
-    it('should load existing multisig account and detect config', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      // Mock getState response
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: '0x' + 'd'.repeat(30),
-          commitment: '0x' + 'e'.repeat(64),
-          state_json: { data: 'base64state' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
-        }),
-      });
-
-      const accountId = '0x' + 'd'.repeat(30);
-      const multisig = await client.load(accountId, mockSigner);
-
-      expect(multisig).toBeDefined();
-      expect(multisig.accountId).toBe(accountId);
-      // Config is detected from account storage via AccountInspector
-      expect(multisig.threshold).toBe(2);
-      expect(multisig.signerCommitments).toEqual(['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)]);
-      expect(multisig.guardianCommitment).toBe('0x' + 'c'.repeat(64));
-      expect(multisig.account).not.toBeNull();
-      expect(webClient.accounts.get).toHaveBeenCalledTimes(1);
-      expect(webClient.accounts.insert).toHaveBeenCalledTimes(1);
-    });
-
-    it('fails closed when the detected signer set is incomplete (issue #306 review)', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      const { AccountInspector } = await import('./inspector.js');
-      // Storage reports 3 signers but only 2 entries were readable — adopting
-      // this config would let membership proposals drop the missing key.
-      vi.mocked(AccountInspector.fromAccount).mockReturnValueOnce({
-        threshold: 2,
-        numSigners: 3,
-        signerCommitments: ['0x' + 'a'.repeat(64), '0x' + 'b'.repeat(64)],
-        guardianCommitment: '0x' + 'c'.repeat(64),
-        vaultBalances: [],
-        procedureThresholds: new Map(),
-      });
-
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: '0x' + 'd'.repeat(30),
-          commitment: '0x' + 'e'.repeat(64),
-          state_json: { data: 'base64state' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
-        }),
-      });
-
-      await expect(client.load('0x' + 'd'.repeat(30), mockSigner)).rejects.toThrow(
-        /incomplete signer set: storage reports 3 signers, read 2/,
-      );
-    });
-
-    it('fails closed when the guardian commitment is missing', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      const { AccountInspector } = await import('./inspector.js');
-      vi.mocked(AccountInspector.fromAccount).mockReturnValueOnce({
-        threshold: 1,
-        numSigners: 1,
-        signerCommitments: ['0x' + 'a'.repeat(64)],
-        guardianCommitment: null,
-        vaultBalances: [],
-        procedureThresholds: new Map(),
-      });
-
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: '0x' + 'd'.repeat(30),
-          commitment: '0x' + 'e'.repeat(64),
-          state_json: { data: 'base64state' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
-        }),
-      });
-
-      await expect(client.load('0x' + 'd'.repeat(30), mockSigner)).rejects.toThrow(
-        /missing guardian commitment/,
-      );
-    });
-
-    it('should throw if account not found on GUARDIAN', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-        headers: new Headers(),
-        text: async () =>
-          JSON.stringify({
-            code: 'account_not_found',
-            message: 'Account not found',
-            meta: { retryable: false },
-          }),
-      });
-
-      await expect(
-        client.load('0xnonexistent', mockSigner)
-      ).rejects.toThrow('Account not found');
-    });
-
-    it('should allow registerOnGuardian after load without explicit initial state', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: '0x' + 'd'.repeat(30),
-          commitment: '0x' + 'e'.repeat(64),
-          state_json: { data: 'base64state' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
-        }),
-      });
-
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          success: true,
-          message: 'Account configured',
-          ack_pubkey: '0x' + 'f'.repeat(64),
-        }),
-      });
-
-      const accountId = '0x' + 'd'.repeat(30);
-      const multisig = await client.load(accountId, mockSigner);
-
-      await expect(multisig.registerOnGuardian()).resolves.toBeUndefined();
-      expect(webClient.accounts.get).toHaveBeenCalledTimes(1);
-      expect(webClient.accounts.insert).toHaveBeenCalledTimes(1);
-    });
-
-    it('binds the signer auth key after loading an account when supported', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      const bindAccountKey = vi.fn().mockResolvedValue(undefined);
-      const bindingSigner = {
-        ...mockSigner,
-        bindAccountKey,
-      };
-
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: '0x' + 'd'.repeat(30),
-          commitment: '0x' + 'e'.repeat(64),
-          state_json: { data: 'base64state' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
-        }),
-      });
-
-      await client.load('0x' + 'd'.repeat(30), bindingSigner);
-
-      expect(bindAccountKey).toHaveBeenCalledWith(webClient, '0x' + 'd'.repeat(30));
-    });
-  });
-
-  // --- recoverByKey -------------------
-
-  describe('recoverByKey', () => {
-    function makeLookupCapableSigner() {
-      return {
-        commitment: '0x' + 'a'.repeat(64),
-        publicKey: '0x' + 'p'.repeat(897),
-        scheme: 'falcon' as const,
-        signAccountIdWithTimestamp: vi.fn().mockResolvedValue('0x' + 'a'.repeat(128)),
-        signRequest: vi.fn().mockReturnValue('0x' + 'a'.repeat(128)),
-        signCommitment: vi.fn().mockReturnValue('0x' + 'b'.repeat(128)),
-        signLookupMessage: vi.fn().mockResolvedValue('0x' + 'c'.repeat(762)),
-      };
-    }
-
-    function mockServerLookupResponse(accountIds: string[]) {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          accounts: accountIds.map((id) => ({ account_id: id })),
-        }),
-      });
-    }
-
-    function mockServerStateResponse(accountId: string) {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          account_id: accountId,
-          commitment: '0x' + 'f'.repeat(64),
-          state_json: { data: 'base64data' },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-01T00:00:00Z',
-        }),
-      });
-    }
-
-    it('returns one (accountId, state) pair when lookup matches a single account', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      const signer = makeLookupCapableSigner();
-      const accountId = '0x7bfb0f38b0fafa103f86a805594170';
-
-      mockServerLookupResponse([accountId]);
-      mockServerStateResponse(accountId);
-
-      const recovered = await client.recoverByKey(signer);
-
-      expect(recovered).toHaveLength(1);
-      expect(recovered[0].accountId).toBe(accountId);
-      expect(recovered[0].state.commitment).toBe('0x' + 'f'.repeat(64));
-      expect(signer.signLookupMessage).toHaveBeenCalledTimes(1);
-      expect(signer.signLookupMessage).toHaveBeenCalledWith(
-        signer.commitment,
-        expect.any(Number)
-      );
-      // Lookup + getState = exactly two HTTP requests.
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-
-    it('returns multiple (accountId, state) pairs when one commitment authorizes several accounts', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      const signer = makeLookupCapableSigner();
-      const accountA = '0xaaa1';
-      const accountB = '0xbbb2';
-
-      mockServerLookupResponse([accountA, accountB]);
-      mockServerStateResponse(accountA);
-      mockServerStateResponse(accountB);
-
-      const recovered = await client.recoverByKey(signer);
-
-      expect(recovered.map((r) => r.accountId)).toEqual([accountA, accountB]);
-      // 1 lookup + 2 state fetches.
-      expect(mockFetch).toHaveBeenCalledTimes(3);
-    });
-
-    it('returns empty array when no account authorizes the commitment', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      const signer = makeLookupCapableSigner();
-
-      mockServerLookupResponse([]);
-
-      const recovered = await client.recoverByKey(signer);
-
-      expect(recovered).toEqual([]);
-      // Only the lookup HTTP call — no per-account state fetches.
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-
-    it('throws a clear error when the signer does not implement signLookupMessage', async () => {
-      const client = new MultisigClient(webClient, CLIENT_CONFIG);
-      // mockSigner from the outer beforeEach lacks signLookupMessage.
-      await expect(client.recoverByKey(mockSigner)).rejects.toThrow(/signLookupMessage/);
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/connectivity.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { GuardianHttpError } from '@openzeppelin/guardian-client';
-import { isLikelyNetworkError, toUserFacingError } from './connectivity.js';
-
-describe('isLikelyNetworkError', () => {
-  it('flags codeless transport failures', () => {
-    for (const m of [
-      'Failed to fetch',
-      'NetworkError when attempting to fetch resource',
-      'Load failed',
-      'The operation was aborted',
-      'request timed out',
-      'connection refused',
-      'getaddrinfo ENOTFOUND guardian.example',
-    ]) {
-      expect(isLikelyNetworkError(new TypeError(m))).toBe(true);
-    }
-  });
-
-  it('does not flag semantic errors', () => {
-    expect(isLikelyNetworkError(new Error('account is paused'))).toBe(false);
-    expect(isLikelyNetworkError(new Error('insufficient signatures'))).toBe(false);
-  });
-});
-
-describe('toUserFacingError', () => {
-  it('uses the server code + user-safe message when Guardian was reached', () => {
-    const body = JSON.stringify({
-      code: 'account_paused',
-      message: "This account is paused and can't approve transactions right now.",
-      meta: { retryable: false },
-    });
-    const result = toUserFacingError(new GuardianHttpError(409, 'Conflict', body));
-    expect(result.code).toBe('account_paused');
-    expect(result.userMessage).toContain('paused');
-    expect(result.category).toBeUndefined();
-  });
-
-  it('classifies a codeless transport failure as connectivity', () => {
-    const result = toUserFacingError(new TypeError('Failed to fetch'));
-    expect(result.code).toBeUndefined();
-    expect(result.category).toBe('unreachable');
-    expect(result.userMessage).toContain("Can't reach Guardian");
-    // The raw transport text is never the primary message.
-    expect(result.userMessage).not.toContain('Failed to fetch');
-  });
-
-  it('classifies timeouts and aborts as the timeout category', () => {
-    for (const m of ['request timed out', 'The operation was aborted']) {
-      const result = toUserFacingError(new Error(m));
-      expect(result.category).toBe('timeout');
-      expect(result.userMessage).toContain("Can't reach Guardian");
-    }
-  });
-
-  it('treats a reachable proxy 5xx with no Guardian body as connectivity', () => {
-    const result = toUserFacingError(new GuardianHttpError(502, 'Bad Gateway', '<html>nope</html>'));
-    expect(result.category).toBe('unreachable');
-    expect(result.userMessage).toContain("Can't reach Guardian");
-  });
-
-  it('falls back to a generic message for unknown non-Guardian errors', () => {
-    const result = toUserFacingError(new Error('totally unexpected'));
-    expect(result.userMessage).toBe('Something went wrong. Please try again.');
-    expect(result.userMessage).not.toContain('totally unexpected');
-  });
-});