@oxy.so/core 1.18.1 → 3.0.0

package/src/crypto/__tests__/keyManager.recoveryLadder.test.ts

@@ -1,179 +0,0 @@
-/**
- * attemptIdentityRecovery — the ladder that restores a `lost` identity from an
- * independent, key_v1-surviving source (backup slot, then cross-app shared slot)
- * WITHOUT the recovery phrase. Every rung validates well-formed + derive-match +
- * `publicKey === marker.publicKey`, so a source holding a DIFFERENT account is
- * skipped (never a silent switch).
- */
-
-import { setPlatformOS } from '../../utils/platform';
-
-jest.mock(
-  'expo-secure-store',
-  () => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { createSecureStoreMock } = require('./identityMocks');
-    return createSecureStoreMock();
-  },
-  { virtual: true },
-);
-
-jest.mock(
-  'expo-crypto',
-  () => ({
-    __esModule: true,
-    getRandomBytes: (length: number) => {
-      const out = new Uint8Array(length);
-      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
-      return out;
-    },
-    digestStringAsync: async () => '0'.repeat(64),
-    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
-  }),
-  { virtual: true },
-);
-
-jest.mock('@oxy.so/protocol', () => {
-  const actual = jest.requireActual('@oxy.so/protocol');
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { createAsyncStorageMock } = require('./identityMocks');
-  const asyncStorage = createAsyncStorageMock();
-  return {
-    __esModule: true,
-    ...actual,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadExpoCrypto: async () => require('expo-crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadSecureStore: async () => require('expo-secure-store'),
-    loadAsyncStorage: async () => ({ default: asyncStorage }),
-    loadSharedIdentityBridge: async () => null,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadNodeCrypto: async () => require('crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
-  };
-});
-
-const PRIMARY_SVC = 'oxy_identity';
-const BACKUP_SVC = 'oxy_identity_backup';
-const V2_PRIV = 'oxy_identity_private_key_v2';
-const V2_PUB = 'oxy_identity_public_key_v2';
-const V2_BPRIV = 'oxy_identity_backup_private_key_v2';
-const V2_BPUB = 'oxy_identity_backup_public_key_v2';
-
-interface SecureStoreTestHandle {
-  __resetStore__: () => void;
-  __getRaw__: (key: string, service?: string) => string | null;
-  __setRaw__: (key: string, value: string, service?: string) => void;
-  __simulateKeystoreDeath__: (service: string) => void;
-}
-
-describe('KeyManager.attemptIdentityRecovery (recovery ladder)', () => {
-  let KeyManager: typeof import('../keyManager').KeyManager;
-  let ss: SecureStoreTestHandle;
-
-  const resetCaches = () => {
-    const km = KeyManager as unknown as {
-      cachedPublicKey: unknown;
-      cachedHasIdentity: unknown;
-      cachedPublicKeyResolved: unknown;
-      cachedSharedPublicKey: unknown;
-      cachedHasSharedIdentity: unknown;
-    };
-    km.cachedPublicKey = null;
-    km.cachedHasIdentity = null;
-    km.cachedPublicKeyResolved = false;
-    km.cachedSharedPublicKey = null;
-    km.cachedHasSharedIdentity = null;
-  };
-
-  beforeAll(() => {
-    setPlatformOS('ios');
-    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
-  });
-
-  beforeEach(async () => {
-    jest.resetModules();
-    setPlatformOS('ios');
-    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
-    ss.__resetStore__();
-    const mod = await import('../keyManager');
-    KeyManager = mod.KeyManager;
-    resetCaches();
-  });
-
-  it('recovers from the BACKUP slot when the primary keychain key dies', async () => {
-    const pub = await KeyManager.createIdentity();
-    // Kill ONLY the primary service — the backup slot (independent key) survives.
-    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
-    resetCaches();
-
-    expect((await KeyManager.getIdentityStatus()).state).toBe('lost');
-    resetCaches();
-
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: true, source: 'backup', publicKey: pub.toLowerCase() });
-    expect((await KeyManager.getIdentityStatus()).state).toBe('present');
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe((await KeyManager.getPrivateKey()));
-  });
-
-  it('recovers from the SHARED slot when both primary and backup keys die', async () => {
-    await KeyManager.createIdentity();
-    const priv = await KeyManager.getPrivateKey();
-    if (!priv) throw new Error('expected private key');
-    const pub = KeyManager.derivePublicKey(priv);
-    // Mirror the identity into the cross-app shared slot (survives key_v1 death).
-    await KeyManager.importSharedIdentity(priv);
-
-    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
-    ss.__simulateKeystoreDeath__(BACKUP_SVC);
-    resetCaches();
-
-    expect((await KeyManager.getIdentityStatus()).state).toBe('lost');
-    resetCaches();
-
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: true, source: 'shared', publicKey: pub.toLowerCase() });
-    expect((await KeyManager.getIdentityStatus()).state).toBe('present');
-  });
-
-  it('SKIPS a source that holds a DIFFERENT account (never silently switches)', async () => {
-    await KeyManager.createIdentity();
-    // Plant a DIFFERENT identity B in both the backup and shared slots.
-    const b = await KeyManager.generateKeyPair();
-    ss.__setRaw__(V2_BPRIV, b.privateKey, BACKUP_SVC);
-    ss.__setRaw__(V2_BPUB, b.publicKey, BACKUP_SVC);
-    await KeyManager.importSharedIdentity(b.privateKey);
-
-    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
-    resetCaches();
-
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: false, reason: 'mismatch' });
-    // The primary was NOT switched to B.
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).not.toBe(b.privateKey);
-  });
-
-  it('is a no-op when the identity is NOT lost (present)', async () => {
-    await KeyManager.createIdentity();
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: false, reason: 'not-lost' });
-  });
-
-  it('is a no-op on a genuinely absent (fresh) device', async () => {
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: false, reason: 'not-lost' });
-  });
-
-  it('reports no-sources when every recovery slot is empty or malformed', async () => {
-    await KeyManager.createIdentity();
-    // Corrupt the backup so it is not a valid candidate.
-    ss.__setRaw__(V2_BPRIV, 'zz-not-hex', BACKUP_SVC);
-    ss.__setRaw__(V2_BPUB, 'garbage', BACKUP_SVC);
-    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
-    resetCaches();
-
-    const result = await KeyManager.attemptIdentityRecovery();
-    expect(result).toEqual({ recovered: false, reason: 'no-sources' });
-  });
-});

package/src/crypto/__tests__/keyManager.recoveryMnemonic.test.ts

@@ -1,138 +0,0 @@
-/**
- * Recovery-mnemonic storage: a dedicated, device-only keychain slot that lets a
- * user re-reveal their 12-word phrase from Settings. Isolated from the identity
- * primary/backup slots (its own keychain service), null-on-absent, typed-throw
- * on a locked keychain, and wiped when the identity is deleted.
- */
-
-import { setPlatformOS } from '../../utils/platform';
-
-jest.mock(
-  'expo-secure-store',
-  () => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { createSecureStoreMock } = require('./identityMocks');
-    return createSecureStoreMock();
-  },
-  { virtual: true },
-);
-
-jest.mock(
-  'expo-crypto',
-  () => ({
-    __esModule: true,
-    getRandomBytes: (length: number) => {
-      const out = new Uint8Array(length);
-      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
-      return out;
-    },
-    digestStringAsync: async () => '0'.repeat(64),
-    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
-  }),
-  { virtual: true },
-);
-
-jest.mock('@oxy.so/protocol', () => {
-  const actual = jest.requireActual('@oxy.so/protocol');
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { createAsyncStorageMock } = require('./identityMocks');
-  const asyncStorage = createAsyncStorageMock();
-  return {
-    __esModule: true,
-    ...actual,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadExpoCrypto: async () => require('expo-crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadSecureStore: async () => require('expo-secure-store'),
-    loadAsyncStorage: async () => ({ default: asyncStorage }),
-    loadSharedIdentityBridge: async () => null,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadNodeCrypto: async () => require('crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
-  };
-});
-
-const MNEMONIC_SVC = 'oxy_identity_mnemonic';
-const MNEMONIC_KEY = 'oxy_identity_mnemonic_v1';
-const PRIMARY_SVC = 'oxy_identity';
-const PHRASE = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
-
-interface SecureStoreTestHandle {
-  __resetStore__: () => void;
-  __getRaw__: (key: string, service?: string) => string | null;
-  __simulateKeystoreDeath__: (service: string) => void;
-  __failPlan__: { failKey?: string; failOp?: 'set' | 'get'; failTimes?: number; failService?: string };
-}
-
-describe('KeyManager recovery mnemonic storage', () => {
-  let KeyManager: typeof import('../keyManager').KeyManager;
-  let IdentityUnavailableError: typeof import('../keyManager').IdentityUnavailableError;
-  let ss: SecureStoreTestHandle;
-
-  beforeAll(() => {
-    setPlatformOS('ios');
-    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
-  });
-
-  beforeEach(async () => {
-    jest.resetModules();
-    setPlatformOS('ios');
-    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
-    ss.__resetStore__();
-    const km = await import('../keyManager');
-    KeyManager = km.KeyManager;
-    IdentityUnavailableError = km.IdentityUnavailableError;
-  });
-
-  it('round-trips a stored mnemonic', async () => {
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    expect(await KeyManager.getRecoveryMnemonic()).toBe(PHRASE);
-  });
-
-  it('persists under its OWN keychain service, isolated from the identity slots', async () => {
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    // Present under the mnemonic service, invisible under the primary service.
-    expect(ss.__getRaw__(MNEMONIC_KEY, MNEMONIC_SVC)).toBe(PHRASE);
-    expect(ss.__getRaw__(MNEMONIC_KEY, PRIMARY_SVC)).toBeNull();
-  });
-
-  it('returns null when no mnemonic was ever stored (pre-feature identity)', async () => {
-    expect(await KeyManager.getRecoveryMnemonic()).toBeNull();
-  });
-
-  it('survives a keystore death of the identity primary service', async () => {
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    // The identity primary slot dies; the mnemonic lives in a distinct service.
-    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
-    expect(await KeyManager.getRecoveryMnemonic()).toBe(PHRASE);
-  });
-
-  it('throws IdentityUnavailableError (never null) when the read throws', async () => {
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    ss.__failPlan__.failOp = 'get';
-    ss.__failPlan__.failKey = MNEMONIC_KEY;
-    ss.__failPlan__.failService = MNEMONIC_SVC;
-    await expect(KeyManager.getRecoveryMnemonic()).rejects.toBeInstanceOf(IdentityUnavailableError);
-  });
-
-  it('throws IdentityUnavailableError when the write throws', async () => {
-    ss.__failPlan__.failOp = 'set';
-    ss.__failPlan__.failKey = MNEMONIC_KEY;
-    ss.__failPlan__.failService = MNEMONIC_SVC;
-    await expect(KeyManager.storeRecoveryMnemonic(PHRASE)).rejects.toBeInstanceOf(IdentityUnavailableError);
-  });
-
-  it('deleteRecoveryMnemonic removes the stored phrase', async () => {
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    await KeyManager.deleteRecoveryMnemonic();
-    expect(await KeyManager.getRecoveryMnemonic()).toBeNull();
-  });
-
-  it('deleteIdentity(force) wipes the stored mnemonic', async () => {
-    await KeyManager.createIdentity();
-    await KeyManager.storeRecoveryMnemonic(PHRASE);
-    await KeyManager.deleteIdentity(true, true, true);
-    expect(await KeyManager.getRecoveryMnemonic()).toBeNull();
-  });
-});

package/src/crypto/__tests__/keyManager.sharedSlotSync.test.ts

@@ -1,150 +0,0 @@
-/**
- * The two identity slots must never disagree, because the disagreement is
- * silent and it is money.
- *
- * Cross-app readers take the SHARED slot first — `deriveScopedSeed`, which is
- * where Peable's FairCoin wallet comes from — while signing and the server take
- * the PRIMARY. A key rotation used to write only the primary, so the shared slot
- * kept the replaced key: the recipient's wallet watched addresses derived from a
- * key the DID no longer published, and payers sent to addresses it never
- * watched. Nothing errored on either side.
- */
-
-import { setPlatformOS } from '../../utils/platform';
-
-jest.mock(
-  'expo-secure-store',
-  () => {
-    const store = new Map<string, string>();
-    return {
-      __esModule: true,
-      WHEN_UNLOCKED_THIS_DEVICE_ONLY: 'WHEN_UNLOCKED_THIS_DEVICE_ONLY',
-      WHEN_UNLOCKED: 'WHEN_UNLOCKED',
-      setItemAsync: jest.fn(async (k: string, v: string) => { store.set(k, v); }),
-      getItemAsync: jest.fn(async (k: string) => store.get(k) ?? null),
-      deleteItemAsync: jest.fn(async (k: string) => { store.delete(k); }),
-      __resetStore__: () => store.clear(),
-    };
-  },
-  { virtual: true },
-);
-
-jest.mock(
-  'expo-crypto',
-  () => ({
-    __esModule: true,
-    getRandomBytes: (length: number) => {
-      const out = new Uint8Array(length);
-      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
-      return out;
-    },
-    digestStringAsync: async () => '0'.repeat(64),
-    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
-  }),
-  { virtual: true },
-);
-
-jest.mock('@oxy.so/protocol', () => ({
-  __esModule: true,
-  ...jest.requireActual('@oxy.so/protocol'),
-  loadExpoCrypto: async () => require('expo-crypto'),
-  loadSecureStore: async () => require('expo-secure-store'),
-  loadNodeCrypto: async () => require('node:crypto'),
-  loadSharedIdentityBridge: async () => null,
-}));
-
-const KEY_A = 'aa'.repeat(32);
-const KEY_B = 'bb'.repeat(32);
-const toHex = (b: Uint8Array): string => Buffer.from(b).toString('hex');
-
-describe('identity slots stay in sync', () => {
-  let KeyManager: typeof import('../keyManager').KeyManager;
-
-  beforeEach(async () => {
-    jest.resetModules();
-    setPlatformOS('ios');
-    const secureStore = (await import('expo-secure-store' as string)) as unknown as {
-      __resetStore__: () => void;
-    };
-    secureStore.__resetStore__();
-    ({ KeyManager } = await import('../keyManager'));
-  });
-
-  /** The shape a rotation used to leave behind: each slot on a different key. */
-  async function makeSlotsDisagree(): Promise<{ publicA: string; publicB: string }> {
-    const publicA = await KeyManager.importSharedIdentity(KEY_A);
-    await KeyManager.importKeyPair(KEY_B, { overwrite: true });
-    const publicB = KeyManager.derivePublicKey(KEY_B);
-    return { publicA, publicB };
-  }
-
-  it('reports both slots, and which one money derives from', async () => {
-    const { publicA, publicB } = await makeSlotsDisagree();
-
-    const state = await KeyManager.getIdentityKeyState();
-
-    expect(state.sharedPublicKey).toBe(KeyManager.canonicalPublicKey(publicA));
-    expect(state.primaryPublicKey).toBe(KeyManager.canonicalPublicKey(publicB));
-    // The shared slot wins, which is exactly why a disagreement is dangerous.
-    expect(state.activePublicKey).toBe(state.sharedPublicKey);
-    expect(state.inSync).toBe(false);
-  });
-
-  it('is in sync when both slots hold the same key', async () => {
-    await KeyManager.importSharedIdentity(KEY_A);
-    await KeyManager.importKeyPair(KEY_A, { overwrite: true });
-
-    const state = await KeyManager.getIdentityKeyState();
-
-    expect(state.inSync).toBe(true);
-    expect(state.activePublicKey).toBe(state.primaryPublicKey);
-  });
-
-  // A device with one slot populated has nothing to contradict, so it must not
-  // read as a disagreement — otherwise every fresh install would report one.
-  it('is in sync when only one slot is populated', async () => {
-    await KeyManager.importKeyPair(KEY_A, { overwrite: true });
-
-    const state = await KeyManager.getIdentityKeyState();
-
-    expect(state.sharedPublicKey).toBeNull();
-    expect(state.activePublicKey).toBe(state.primaryPublicKey);
-    expect(state.inSync).toBe(true);
-  });
-
-  it('repairs a disagreeing shared slot from the primary instead of skipping', async () => {
-    const { publicB } = await makeSlotsDisagree();
-
-    const migrated = await KeyManager.syncSharedIdentity();
-
-    expect(migrated).toBe(true);
-    const state = await KeyManager.getIdentityKeyState();
-    expect(state.inSync).toBe(true);
-    expect(state.sharedPublicKey).toBe(KeyManager.canonicalPublicKey(publicB));
-  });
-
-  // The wallet is the reason any of this matters: the seed must follow the
-  // repaired key, not the one the stale slot was still handing out.
-  it('moves the derived wallet seed onto the repaired key', async () => {
-    await makeSlotsDisagree();
-    const strandedSeed = await KeyManager.deriveScopedSeed('peable/faircoin/v1');
-
-    await KeyManager.syncSharedIdentity();
-    const repairedSeed = await KeyManager.deriveScopedSeed('peable/faircoin/v1');
-
-    if (!strandedSeed || !repairedSeed) throw new Error('expected seeds');
-    expect(toHex(repairedSeed)).not.toBe(toHex(strandedSeed));
-
-    // And it is the seed a device holding only that one key would derive.
-    jest.resetModules();
-    const secureStore = (await import('expo-secure-store' as string)) as unknown as {
-      __resetStore__: () => void;
-    };
-    secureStore.__resetStore__();
-    const { KeyManager: Fresh } = await import('../keyManager');
-    await Fresh.importSharedIdentity(KEY_B);
-    const expected = await Fresh.deriveScopedSeed('peable/faircoin/v1');
-    if (!expected) throw new Error('expected a seed');
-    expect(toHex(repairedSeed)).toBe(toHex(expected));
-  });
-});

package/src/crypto/__tests__/keyManager.storageMigration.test.ts

@@ -1,227 +0,0 @@
-/**
- * Lazy migration of the identity from the legacy shared-`key_v1` slots onto the
- * isolated v2 slots (primary service `oxy_identity`, backup service
- * `oxy_identity_backup`).
- *
- * INVARIANT under test: at every instant ≥1 readable copy of a previously
- * existing identity remains — legacy is deleted ONLY after the v2 copy is
- * verified re-readable; a failed v2 write serves legacy for the session; any
- * read-throw defers everything (zero writes/deletes).
- */
-
-import { setPlatformOS } from '../../utils/platform';
-
-jest.mock(
-  'expo-secure-store',
-  () => {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { createSecureStoreMock } = require('./identityMocks');
-    return createSecureStoreMock();
-  },
-  { virtual: true },
-);
-
-jest.mock(
-  'expo-crypto',
-  () => ({
-    __esModule: true,
-    getRandomBytes: (length: number) => {
-      const out = new Uint8Array(length);
-      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
-      return out;
-    },
-    digestStringAsync: async () => '0'.repeat(64),
-    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
-  }),
-  { virtual: true },
-);
-
-jest.mock('@oxy.so/protocol', () => {
-  const actual = jest.requireActual('@oxy.so/protocol');
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const { createAsyncStorageMock } = require('./identityMocks');
-  const asyncStorage = createAsyncStorageMock();
-  return {
-    __esModule: true,
-    ...actual,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadExpoCrypto: async () => require('expo-crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadSecureStore: async () => require('expo-secure-store'),
-    loadAsyncStorage: async () => ({ default: asyncStorage }),
-    loadSharedIdentityBridge: async () => null,
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    loadNodeCrypto: async () => require('crypto'),
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
-  };
-});
-
-const PRIMARY_SVC = 'oxy_identity';
-const BACKUP_SVC = 'oxy_identity_backup';
-const V2_PRIV = 'oxy_identity_private_key_v2';
-const V2_PUB = 'oxy_identity_public_key_v2';
-const V2_BPRIV = 'oxy_identity_backup_private_key_v2';
-const V2_BPUB = 'oxy_identity_backup_public_key_v2';
-// Legacy slots (default keychain service).
-const L_PRIV = 'oxy_identity_private_key';
-const L_PUB = 'oxy_identity_public_key';
-const L_BPRIV = 'oxy_identity_backup_private_key';
-const L_BPUB = 'oxy_identity_backup_public_key';
-
-interface SecureStoreTestHandle {
-  __resetStore__: () => void;
-  __getRaw__: (key: string, service?: string) => string | null;
-  __setRaw__: (key: string, value: string, service?: string) => void;
-  __simulateKeystoreDeath__: (service: string) => void;
-  __failPlan__: { failKey?: string; failOp?: 'set' | 'get'; failTimes?: number; failService?: string };
-}
-
-interface MigrationCapable {
-  _ensureIdentitySlotsMigrated: () => Promise<{ mode: 'v2' | 'legacy' | 'deferred' }>;
-}
-
-describe('KeyManager identity slot migration (legacy → v2)', () => {
-  let KeyManager: typeof import('../keyManager').KeyManager;
-  let ss: SecureStoreTestHandle;
-
-  const resetCaches = () => {
-    const km = KeyManager as unknown as {
-      cachedPublicKey: unknown;
-      cachedHasIdentity: unknown;
-      cachedPublicKeyResolved: unknown;
-    };
-    km.cachedPublicKey = null;
-    km.cachedHasIdentity = null;
-    km.cachedPublicKeyResolved = false;
-  };
-
-  beforeAll(() => {
-    setPlatformOS('ios');
-    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
-  });
-
-  beforeEach(async () => {
-    jest.resetModules();
-    setPlatformOS('ios');
-    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
-    ss.__resetStore__();
-    const km = await import('../keyManager');
-    KeyManager = km.KeyManager;
-    resetCaches();
-  });
-
-  /** Seed a valid legacy identity (default keychain service) without migrating. */
-  const seedLegacyIdentity = async (): Promise<{ privateKey: string; publicKey: string }> => {
-    const kp = await KeyManager.generateKeyPair();
-    ss.__setRaw__(L_PRIV, kp.privateKey);
-    ss.__setRaw__(L_PUB, kp.publicKey);
-    ss.__setRaw__(L_BPRIV, kp.privateKey);
-    ss.__setRaw__(L_BPUB, kp.publicKey);
-    return kp;
-  };
-
-  it('migrates a healthy legacy identity into the v2 slots and deletes the legacy copy', async () => {
-    const kp = await seedLegacyIdentity();
-
-    // Trigger migration via any accessor.
-    expect(await KeyManager.getPublicKey()).toBe(kp.publicKey.toLowerCase());
-
-    // v2 now owns the identity...
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe(kp.privateKey.toLowerCase());
-    expect(ss.__getRaw__(V2_PUB, PRIMARY_SVC)).toBe(kp.publicKey.toLowerCase());
-    // ...and the legacy copy is gone (only after the v2 copy verified).
-    expect(ss.__getRaw__(L_PRIV)).toBeNull();
-    expect(ss.__getRaw__(L_PUB)).toBeNull();
-    expect(await KeyManager.hasIdentity()).toBe(true);
-  });
-
-  it('is idempotent — a second run leaves v2 intact and does not resurrect legacy', async () => {
-    const kp = await seedLegacyIdentity();
-    await KeyManager.getPublicKey();
-    resetCaches();
-    // Re-run (fresh caches, same process → migration memoized as v2).
-    expect(await KeyManager.getPublicKey()).toBe(kp.publicKey.toLowerCase());
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe(kp.privateKey.toLowerCase());
-    expect(ss.__getRaw__(L_PRIV)).toBeNull();
-  });
-
-  it('interrupted-after-copy (v2 healthy AND legacy still present) → cleans up legacy', async () => {
-    // Model a prior run that copied to v2 but crashed before deleting legacy.
-    const kp = await KeyManager.generateKeyPair();
-    ss.__setRaw__(V2_PRIV, kp.privateKey.toLowerCase(), PRIMARY_SVC);
-    ss.__setRaw__(V2_PUB, kp.publicKey.toLowerCase(), PRIMARY_SVC);
-    ss.__setRaw__(L_PRIV, kp.privateKey);
-    ss.__setRaw__(L_PUB, kp.publicKey);
-
-    expect(await KeyManager.getPublicKey()).toBe(kp.publicKey.toLowerCase());
-    // v2 kept, legacy cleaned up.
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe(kp.privateKey.toLowerCase());
-    expect(ss.__getRaw__(L_PRIV)).toBeNull();
-    expect(ss.__getRaw__(L_PUB)).toBeNull();
-  });
-
-  it('a failed v2 write serves the identity from legacy this session and never deletes legacy', async () => {
-    const kp = await seedLegacyIdentity();
-    // Make every v2 primary public write fail → migration cannot verify v2.
-    ss.__failPlan__.failOp = 'set';
-    ss.__failPlan__.failKey = V2_PUB;
-    ss.__failPlan__.failService = PRIMARY_SVC;
-
-    // Reads still succeed — served from the UNTOUCHED legacy slots.
-    expect(await KeyManager.getPublicKey()).toBe(kp.publicKey);
-    expect(await KeyManager.hasIdentity()).toBe(true);
-    // Legacy is intact; v2 primary was not left half-written.
-    expect(ss.__getRaw__(L_PRIV)).toBe(kp.privateKey);
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBeNull();
-  });
-
-  it('a legacy read throwing defers everything (unavailable, zero writes)', async () => {
-    await seedLegacyIdentity();
-    // v2 read succeeds (empty); the legacy private read throws → defer.
-    ss.__failPlan__.failOp = 'get';
-    ss.__failPlan__.failKey = L_PRIV;
-    ss.__failPlan__.failService = 'default';
-
-    const status = await KeyManager.getIdentityStatus();
-    expect(status.state).toBe('unavailable');
-    await expect(KeyManager.hasIdentity()).rejects.toMatchObject({ name: 'IdentityUnavailableError' });
-    // Nothing was written to v2.
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBeNull();
-  });
-
-  it('a keystore death BEFORE migration (loss predates markers) → absent, not a phantom identity', async () => {
-    await seedLegacyIdentity();
-    // key_v1 death: the legacy (default-service) entries are deleted on read.
-    ss.__simulateKeystoreDeath__('default');
-
-    const status = await KeyManager.getIdentityStatus();
-    // No marker existed (loss predates markers) → a genuine fresh device.
-    expect(status.state).toBe('absent');
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBeNull();
-  });
-
-  it('a fresh device (no legacy, no v2) resolves to the empty v2 layout', async () => {
-    const status = await KeyManager.getIdentityStatus();
-    expect(status.state).toBe('absent');
-    expect(await KeyManager.hasIdentity()).toBe(false);
-  });
-
-  it('concurrent callers share ONE migration run', async () => {
-    const kp = await seedLegacyIdentity();
-    const km = KeyManager as unknown as MigrationCapable;
-    const [a, b] = await Promise.all([km._ensureIdentitySlotsMigrated(), km._ensureIdentitySlotsMigrated()]);
-    // Same memoized result object → a single shared run.
-    expect(a).toBe(b);
-    expect(a.mode).toBe('v2');
-    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe(kp.privateKey.toLowerCase());
-  });
-
-  it('migrates a healthy legacy backup into the v2 backup slot', async () => {
-    const kp = await seedLegacyIdentity();
-    await KeyManager.getPublicKey();
-    expect(ss.__getRaw__(V2_BPRIV, BACKUP_SVC)).toBe(kp.privateKey.toLowerCase());
-    expect(ss.__getRaw__(V2_BPUB, BACKUP_SVC)).toBe(kp.publicKey.toLowerCase());
-    expect(ss.__getRaw__(L_BPRIV)).toBeNull();
-  });
-});