@oxy.so/core 1.18.1 → 3.0.0

package/src/crypto/__tests__/scopedSeed.test.ts

@@ -1,126 +0,0 @@
-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('crypto'),
-  loadSharedIdentityBridge: async () => null,
-}));
-
-const FIXED_PRIV = 'aa'.repeat(32);
-const EXPECTED_FAIR = '4b90d900a11b0a1737ed643db3446e5f28035d86f1a4fda92474ea8ab152adf5';
-const EXPECTED_OTHER = 'cdedf1f076b0f4766c769e55bc1e90c5bf44d8630f6e5fb147615ee7c330c905';
-const toHex = (b: Uint8Array): string => Buffer.from(b).toString('hex');
-
-describe('KeyManager.deriveScopedSeed', () => {
-  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__();
-    const km = await import('../keyManager');
-    KeyManager = km.KeyManager;
-    // Store a known shared identity key so derivation is deterministic.
-    await KeyManager.importSharedIdentity(FIXED_PRIV);
-  });
-
-  it('derives the pinned 32-byte seed for a fixed identity + info', async () => {
-    const seed = await KeyManager.deriveScopedSeed('oxypay/faircoin/v1');
-    if (!seed) throw new Error('expected a seed');
-    expect(seed).toHaveLength(32);
-    expect(toHex(seed)).toBe(EXPECTED_FAIR);
-  });
-
-  it('is deterministic (same identity + info → identical seed)', async () => {
-    const a = await KeyManager.deriveScopedSeed('oxypay/faircoin/v1');
-    const b = await KeyManager.deriveScopedSeed('oxypay/faircoin/v1');
-    if (!a || !b) throw new Error('expected seeds');
-    expect(toHex(a)).toBe(toHex(b));
-  });
-
-  it('domain-separates by info (different info → different seed)', async () => {
-    const fair = await KeyManager.deriveScopedSeed('oxypay/faircoin/v1');
-    const other = await KeyManager.deriveScopedSeed('oxypay/other/v1');
-    if (!fair || !other) throw new Error('expected seeds');
-    expect(toHex(other)).toBe(EXPECTED_OTHER);
-    expect(toHex(fair)).not.toBe(toHex(other));
-  });
-
-  it('never returns the raw private key (no leak)', async () => {
-    const seed = await KeyManager.deriveScopedSeed('oxypay/faircoin/v1');
-    if (!seed) throw new Error('expected a seed');
-    expect(toHex(seed)).not.toBe(FIXED_PRIV);
-  });
-
-  it('returns null on web (no identity key available)', async () => {
-    // `jest.resetModules()` gives KeyManager its own bound instance of
-    // `utils/platform` (its cached OS locks in as soon as `beforeEach`'s
-    // `importSharedIdentity` first checks it). The file-level `setPlatformOS`
-    // import above is bound to a different, earlier instance, so mutating it
-    // here would not be observed by the already-imported `KeyManager`. Reset
-    // again and re-import both from the same fresh module graph so the
-    // platform flip actually reaches the KeyManager instance under test.
-    //
-    // `jest.resetModules()` also re-runs the virtual `expo-secure-store`
-    // mock factory, handing this fresh KeyManager a brand-new empty
-    // in-memory store — the identity `beforeEach` imported lives only in the
-    // pre-reset store instance. Without re-storing an identity here, a
-    // `null` result would be ambiguous between the web gate and the
-    // no-identity fallback. Re-import the identity on THIS fresh instance
-    // (while still native — `importSharedIdentity` itself is native-gated
-    // and throws on web) BEFORE flipping to web, so the later `null` can
-    // only be explained by the web gate, not a missing identity.
-    jest.resetModules();
-    const platform = await import('../../utils/platform');
-    const km = await import('../keyManager');
-    await km.KeyManager.importSharedIdentity(FIXED_PRIV);
-    platform.setPlatformOS('web');
-    expect(await km.KeyManager.deriveScopedSeed('oxypay/faircoin/v1')).toBeNull();
-  });
-
-  it('returns null when no identity exists on the device', async () => {
-    const secureStore = (await import('expo-secure-store' as string)) as unknown as {
-      __resetStore__: () => void;
-    };
-    secureStore.__resetStore__();
-    expect(await KeyManager.deriveScopedSeed('oxypay/faircoin/v1')).toBeNull();
-  });
-});

package/src/crypto/__tests__/signChallengeShared.test.ts

@@ -1,63 +0,0 @@
-/**
- * `signChallengeWithSharedKey` tests.
- *
- * Verifies the shared-key challenge signer mirrors `signChallenge` exactly —
- * same `auth:${publicKey}:${challenge}:${timestamp}` message format so the
- * server verification path is unchanged — but sources the SHARED key from
- * `KeyManager` (not the primary device key). We mock the shared key access with
- * a real secp256k1 keypair so signing/verification is genuine.
- */
-
-import { generateSecp256k1KeyPair } from '@oxy.so/protocol/secp256k1';
-import { verifySignature } from '@oxy.so/protocol';
-import { KeyManager } from '../keyManager';
-import { SignatureService } from '../signatureService';
-
-describe('SignatureService.signChallengeWithSharedKey', () => {
-  const sharedKeyPair = generateSecp256k1KeyPair();
-  const sharedPublicKey = sharedKeyPair.publicKey;
-  const sharedPrivateKey = sharedKeyPair.privateKey;
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('signs with the shared key and uses the unchanged message format', async () => {
-    jest.spyOn(KeyManager, 'getSharedPublicKey').mockResolvedValue(sharedPublicKey);
-    jest.spyOn(KeyManager, 'getSharedPrivateKey').mockResolvedValue(sharedPrivateKey);
-    // Guard: it must NOT fall back to the primary device key.
-    const primarySpy = jest.spyOn(KeyManager, 'getPublicKey');
-
-    const result = await SignatureService.signChallengeWithSharedKey('chal-123');
-
-    expect(result.publicKey).toBe(sharedPublicKey);
-    expect(typeof result.challenge).toBe('string'); // the signature
-    expect(typeof result.timestamp).toBe('number');
-    expect(primarySpy).not.toHaveBeenCalled();
-
-    // The signature verifies against the SAME message format `signChallenge`
-    // uses, proving the format is unchanged and the shared key signed it.
-    const message = `auth:${sharedPublicKey}:chal-123:${result.timestamp}`;
-    await expect(
-      verifySignature(message, result.challenge, sharedPublicKey),
-    ).resolves.toBe(true);
-  });
-
-  it('throws when no shared identity exists', async () => {
-    jest.spyOn(KeyManager, 'getSharedPublicKey').mockResolvedValue(null);
-    jest.spyOn(KeyManager, 'getSharedPrivateKey').mockResolvedValue(null);
-
-    await expect(
-      SignatureService.signChallengeWithSharedKey('chal-123'),
-    ).rejects.toThrow(/No shared identity/);
-  });
-
-  it('throws when the shared private key is missing even if the public key is present', async () => {
-    jest.spyOn(KeyManager, 'getSharedPublicKey').mockResolvedValue(sharedPublicKey);
-    jest.spyOn(KeyManager, 'getSharedPrivateKey').mockResolvedValue(null);
-
-    await expect(
-      SignatureService.signChallengeWithSharedKey('chal-123'),
-    ).rejects.toThrow(/No shared identity/);
-  });
-});

package/src/crypto/__tests__/signedRecord.test.ts

@@ -1,230 +0,0 @@
-/**
- * Signed-record envelope tests — the DEVICE-key-bound path in `@oxy.so/core`.
- *
- * `SignatureService.signRecord` / `signRecordV2` read the device key from
- * `KeyManager` and delegate the cryptography to `@oxy.so/protocol`'s
- * `signEnvelope`. These tests prove the orchestration: an envelope built from a
- * stored key round-trips through the protocol's `verifyEnvelopeSignature`, and
- * tampering breaks it. The pure canonical-bytes / `computeRecordId` guards live
- * in `@oxy.so/protocol`'s own suite.
- *
- * We mock `KeyManager.getPrivateKey` with a real secp256k1 private key,
- * so the signing/verification is genuine cryptography (not a stub).
- */
-
-import { generateSecp256k1KeyPair } from '@oxy.so/protocol/secp256k1';
-import type { SignedRecordEnvelope } from '@oxy.so/contracts';
-import {
-  canonicalize,
-  signedRecordSigningInput,
-  verifySignature,
-  verifyEnvelopeSignature,
-} from '@oxy.so/protocol';
-import { KeyManager } from '../keyManager';
-import { SignatureService } from '../signatureService';
-
-describe('SignatureService.signRecord / verifyEnvelopeSignature', () => {
-  const keyPair = generateSecp256k1KeyPair();
-  const publicKey = keyPair.publicKey;
-  const privateKey = keyPair.privateKey.padStart(64, '0');
-
-  beforeEach(() => {
-    jest.spyOn(KeyManager, 'getPrivateKey').mockResolvedValue(privateKey);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('builds a well-formed self-issued envelope', async () => {
-    const subject = 'did:web:oxy.so:u:abc123';
-    const record = { displayName: 'Nate', bio: 'builder' };
-
-    const envelope = await SignatureService.signRecord('profile', subject, record);
-
-    expect(envelope.version).toBe(1);
-    expect(envelope.type).toBe('profile');
-    expect(envelope.subject).toBe(subject);
-    expect(envelope.issuer).toBe(subject); // self-issued
-    expect(envelope.record).toEqual(record);
-    expect(envelope.publicKey).toBe(publicKey); // derived from the stored private key
-    expect(envelope.alg).toBe('ES256K-DER-SHA256');
-    expect(typeof envelope.signature).toBe('string');
-    expect(envelope.signature.length).toBeGreaterThan(0);
-    expect(typeof envelope.issuedAt).toBe('number');
-  });
-
-  it('round-trips: a freshly signed record verifies', async () => {
-    const envelope = await SignatureService.signRecord('identity', 'did:web:oxy.so:u:u1', {
-      handle: '@nate',
-      nested: { a: 1, b: [2, 3] },
-    });
-    await expect(verifyEnvelopeSignature(envelope)).resolves.toBe(true);
-  });
-
-  it('signs the canonical JSON of every field except publicKey + signature', async () => {
-    const subject = 'did:web:oxy.so:u:u2';
-    const record = { z: 1, a: 2 };
-    const envelope = await SignatureService.signRecord('profile', subject, record);
-
-    const expectedInput = canonicalize({
-      version: envelope.version,
-      type: envelope.type,
-      subject: envelope.subject,
-      issuer: envelope.issuer,
-      record: envelope.record,
-      issuedAt: envelope.issuedAt,
-    });
-
-    // The helper reproduces exactly that input from the envelope.
-    expect(signedRecordSigningInput(envelope)).toBe(expectedInput);
-    // And it omits publicKey/signature.
-    expect(expectedInput).not.toContain(envelope.publicKey);
-    expect(expectedInput).not.toContain(envelope.signature);
-
-    // The signature verifies against that exact input + the embedded key.
-    await expect(
-      verifySignature(expectedInput, envelope.signature, envelope.publicKey),
-    ).resolves.toBe(true);
-  });
-
-  describe('tamper detection', () => {
-    let envelope: SignedRecordEnvelope;
-
-    beforeEach(async () => {
-      envelope = await SignatureService.signRecord('profile', 'did:web:oxy.so:u:u3', {
-        displayName: 'Original',
-        score: 10,
-      });
-    });
-
-    it('rejects a mutated record', async () => {
-      const tampered: SignedRecordEnvelope = {
-        ...envelope,
-        record: { ...envelope.record, displayName: 'Tampered' },
-      };
-      await expect(verifyEnvelopeSignature(tampered)).resolves.toBe(false);
-    });
-
-    it('rejects a changed subject', async () => {
-      const tampered: SignedRecordEnvelope = { ...envelope, subject: 'did:web:oxy.so:u:evil' };
-      await expect(verifyEnvelopeSignature(tampered)).resolves.toBe(false);
-    });
-
-    it('rejects a changed issuedAt', async () => {
-      const tampered: SignedRecordEnvelope = { ...envelope, issuedAt: envelope.issuedAt + 1 };
-      await expect(verifyEnvelopeSignature(tampered)).resolves.toBe(false);
-    });
-
-    it('rejects verification against an unrelated public key', async () => {
-      const otherKey = generateSecp256k1KeyPair().publicKey;
-      const tampered: SignedRecordEnvelope = { ...envelope, publicKey: otherKey };
-      await expect(verifyEnvelopeSignature(tampered)).resolves.toBe(false);
-    });
-  });
-
-  it('throws when no identity is stored', async () => {
-    jest.spyOn(KeyManager, 'getPrivateKey').mockResolvedValue(null);
-    await expect(
-      SignatureService.signRecord('identity', 'did:web:oxy.so:u:u4', {}),
-    ).rejects.toThrow(/No identity found/);
-  });
-});
-
-describe('SignatureService.signRecordV2 / verifyEnvelopeSignature (v2 hash chain)', () => {
-  const keyPair = generateSecp256k1KeyPair();
-  const publicKey = keyPair.publicKey;
-  const privateKey = keyPair.privateKey.padStart(64, '0');
-
-  beforeEach(() => {
-    jest.spyOn(KeyManager, 'getPrivateKey').mockResolvedValue(privateKey);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  const chain = {
-    seq: 0,
-    prev: null as string | null,
-    collection: 'app.oxy.reputation',
-    rkey: 'rt_1',
-  };
-
-  it('builds a well-formed v2 envelope carrying the chain fields', async () => {
-    const subject = 'did:web:oxy.so:u:abc123';
-    const envelope = await SignatureService.signRecordV2(
-      'reputation_attestation',
-      subject,
-      { points: 25 },
-      chain,
-    );
-
-    expect(envelope.version).toBe(2);
-    expect(envelope.type).toBe('reputation_attestation');
-    expect(envelope.subject).toBe(subject);
-    expect(envelope.issuer).toBe(subject); // self-issued
-    expect(envelope.seq).toBe(0);
-    expect(envelope.prev).toBeNull();
-    expect(envelope.collection).toBe('app.oxy.reputation');
-    expect(envelope.rkey).toBe('rt_1');
-    expect(envelope.publicKey).toBe(publicKey);
-    expect(envelope.alg).toBe('ES256K-DER-SHA256');
-    expect(typeof envelope.signature).toBe('string');
-  });
-
-  it('round-trips: a freshly signed v2 record verifies', async () => {
-    const envelope = await SignatureService.signRecordV2(
-      'validation_verdict',
-      'did:web:oxy.so:u:v1',
-      { verdict: 'approve' },
-      { seq: 3, prev: 'a'.repeat(64), collection: 'app.oxy.validation', rkey: 'req_9' },
-    );
-    await expect(verifyEnvelopeSignature(envelope)).resolves.toBe(true);
-  });
-
-  it('covers the chain fields in the signed bytes (tampering breaks verify)', async () => {
-    const envelope = await SignatureService.signRecordV2(
-      'reputation_attestation',
-      'did:web:oxy.so:u:t1',
-      { points: 8 },
-      chain,
-    );
-
-    await expect(verifyEnvelopeSignature({ ...envelope, seq: 1 })).resolves.toBe(false);
-    await expect(
-      verifyEnvelopeSignature({ ...envelope, prev: 'b'.repeat(64) }),
-    ).resolves.toBe(false);
-    await expect(
-      verifyEnvelopeSignature({ ...envelope, collection: 'app.evil' }),
-    ).resolves.toBe(false);
-    await expect(verifyEnvelopeSignature({ ...envelope, rkey: 'other' })).resolves.toBe(false);
-  });
-
-  it('a v2 envelope signs over DIFFERENT bytes than the same base fields as v1', async () => {
-    const subject = 'did:web:oxy.so:u:diff';
-    const record = { x: 1 };
-    const v2 = await SignatureService.signRecordV2('profile', subject, record, chain);
-
-    const v1Input = signedRecordSigningInput({
-      version: 1,
-      type: 'profile',
-      subject,
-      issuer: subject,
-      record,
-      issuedAt: v2.issuedAt,
-    });
-    const v2Input = signedRecordSigningInput(v2);
-    expect(v2Input).not.toBe(v1Input);
-    expect(v2Input).toContain('"seq":0');
-    expect(v2Input).toContain('"prev":null');
-    expect(v2Input).toContain('"collection":"app.oxy.reputation"');
-  });
-
-  it('throws when no identity is stored', async () => {
-    jest.spyOn(KeyManager, 'getPrivateKey').mockResolvedValue(null);
-    await expect(
-      SignatureService.signRecordV2('identity', 'did:web:oxy.so:u:u4', {}, chain),
-    ).rejects.toThrow(/No identity found/);
-  });
-});

package/src/i18n/__tests__/accountCategoryLabels.test.ts

@@ -1,62 +0,0 @@
-import { ACCOUNT_CATEGORY_IDS, SELECTABLE_ACCOUNT_CATEGORY_IDS } from '@oxy.so/contracts';
-import { accountCategoryLabel, EN_ACCOUNT_CATEGORY_LABELS } from '../accountCategoryLabels';
-
-/**
- * Every locale the SDK ships a dictionary for, plus a region variant and an
- * untranslated language, because the three take different paths through
- * `translate`: exact dictionary, base-subtag dictionary, and English fallback.
- */
-const SHIPPED_LOCALES = [
-  'en-US',
-  'es-ES',
-  'ca-ES',
-  'fr-FR',
-  'de-DE',
-  'it-IT',
-  'pt-PT',
-  'ja-JP',
-  'ko-KR',
-  'zh-CN',
-  'ar-SA',
-] as const;
-const REGION_VARIANT = 'es-MX';
-const UNSHIPPED_LOCALE = 'nl-NL';
-
-describe('accountCategoryLabel', () => {
-  // Vacuity floor: a traversal bug that yielded an empty id list would make
-  // every assertion below pass over nothing.
-  it('covers the whole vocabulary', () => {
-    expect(ACCOUNT_CATEGORY_IDS.length).toBeGreaterThanOrEqual(46);
-    expect(Object.keys(EN_ACCOUNT_CATEGORY_LABELS)).toHaveLength(ACCOUNT_CATEGORY_IDS.length);
-  });
-
-  it.each([...SHIPPED_LOCALES, REGION_VARIANT, UNSHIPPED_LOCALE])(
-    'names every category in %s — never a key, never a slug, never empty',
-    (locale) => {
-      for (const id of ACCOUNT_CATEGORY_IDS) {
-        const label = accountCategoryLabel(locale, id);
-        expect(label).not.toBe('');
-        // `translate` echoes the key when it resolves nothing, so the key IS the
-        // failure signal. This is what the screen's old `t(key) || id` believed
-        // it was catching and could not, since a non-empty string is truthy.
-        expect(label).not.toBe(`accounts.accountCategory.${id}`);
-        // The raw slug reaching a reader is the bug this whole indirection
-        // exists to prevent. `ai` is excluded: its English label legitimately
-        // equals its id.
-      }
-    },
-  );
-
-  it('falls back to English for a language with no category translations', () => {
-    // German ships a dictionary but no category labels, so it exercises
-    // `translate`'s PER-KEY English fallback rather than its locale fallback.
-    expect(accountCategoryLabel('de-DE', 'cooperative')).toBe(
-      EN_ACCOUNT_CATEGORY_LABELS.cooperative,
-    );
-  });
-
-  it('resolves a region variant through its base language', () => {
-    expect(accountCategoryLabel('es-MX', 'news')).toBe(accountCategoryLabel('es-ES', 'news'));
-    expect(accountCategoryLabel('es-MX', 'news')).not.toBe(EN_ACCOUNT_CATEGORY_LABELS.news);
-  });
-});

package/src/i18n/__tests__/accountRoleLabels.test.ts

@@ -1,54 +0,0 @@
-import type { AccountRole } from '../../mixins/OxyServices.accounts';
-import { EN_ACCOUNT_ROLE_LABELS, accountRoleLabel } from '../accountRoleLabels';
-
-const ACCOUNT_ROLES: AccountRole[] = [
-  'owner',
-  'admin',
-  'editor',
-  'developer',
-  'billing',
-  'viewer',
-];
-
-const SHIPPED_LOCALES = [
-  'en-US',
-  'es-ES',
-  'ca-ES',
-  'fr-FR',
-  'de-DE',
-  'it-IT',
-  'pt-PT',
-  'ja-JP',
-  'ko-KR',
-  'zh-CN',
-  'ar-SA',
-] as const;
-const REGION_VARIANT = 'es-MX';
-const UNSHIPPED_LOCALE = 'nl-NL';
-
-describe('accountRoleLabel', () => {
-  it('covers the whole vocabulary', () => {
-    expect(ACCOUNT_ROLES.length).toBe(6);
-    expect(Object.keys(EN_ACCOUNT_ROLE_LABELS)).toHaveLength(ACCOUNT_ROLES.length);
-  });
-
-  it.each([...SHIPPED_LOCALES, REGION_VARIANT, UNSHIPPED_LOCALE])(
-    'names every role in %s — never a key, never a slug, never empty',
-    (locale) => {
-      for (const role of ACCOUNT_ROLES) {
-        const label = accountRoleLabel(locale, role);
-        expect(label).not.toBe('');
-        expect(label).not.toBe(`accounts.roles.${role}.label`);
-      }
-    },
-  );
-
-  it('falls back to English for a language with no role translations', () => {
-    expect(accountRoleLabel('de-DE', 'developer')).toBe(EN_ACCOUNT_ROLE_LABELS.developer);
-  });
-
-  it('resolves a region variant through its base language', () => {
-    expect(accountRoleLabel('es-MX', 'admin')).toBe(accountRoleLabel('es-ES', 'admin'));
-    expect(accountRoleLabel('es-MX', 'admin')).not.toBe(EN_ACCOUNT_ROLE_LABELS.admin);
-  });
-});

package/src/i18n/__tests__/reputationCategoryLabels.test.ts

@@ -1,56 +0,0 @@
-import { REPUTATION_CATEGORIES } from '@oxy.so/contracts';
-import {
-  EN_REPUTATION_CATEGORY_LABELS,
-  reputationCategoryLabel,
-} from '../reputationCategoryLabels';
-
-const SHIPPED_LOCALES = [
-  'en-US',
-  'es-ES',
-  'ca-ES',
-  'fr-FR',
-  'de-DE',
-  'it-IT',
-  'pt-PT',
-  'ja-JP',
-  'ko-KR',
-  'zh-CN',
-  'ar-SA',
-] as const;
-const REGION_VARIANT = 'es-MX';
-const UNSHIPPED_LOCALE = 'nl-NL';
-
-describe('reputationCategoryLabel', () => {
-  it('covers the whole vocabulary', () => {
-    expect(REPUTATION_CATEGORIES.length).toBeGreaterThanOrEqual(7);
-    expect(Object.keys(EN_REPUTATION_CATEGORY_LABELS)).toHaveLength(
-      REPUTATION_CATEGORIES.length,
-    );
-  });
-
-  it.each([...SHIPPED_LOCALES, REGION_VARIANT, UNSHIPPED_LOCALE])(
-    'names every category in %s — never a key, never a slug, never empty',
-    (locale) => {
-      for (const id of REPUTATION_CATEGORIES) {
-        const label = reputationCategoryLabel(locale, id);
-        expect(label).not.toBe('');
-        expect(label).not.toBe(`trust.rules.categories.${id}`);
-      }
-    },
-  );
-
-  it('falls back to English for a language with no category translations', () => {
-    expect(reputationCategoryLabel('de-DE', 'physical')).toBe(
-      EN_REPUTATION_CATEGORY_LABELS.physical,
-    );
-  });
-
-  it('resolves a region variant through its base language', () => {
-    expect(reputationCategoryLabel('es-MX', 'content')).toBe(
-      reputationCategoryLabel('es-ES', 'content'),
-    );
-    expect(reputationCategoryLabel('es-MX', 'content')).not.toBe(
-      EN_REPUTATION_CATEGORY_LABELS.content,
-    );
-  });
-});

package/src/i18n/__tests__/trustTierLabels.test.ts

@@ -1,47 +0,0 @@
-import { TRUST_TIERS } from '@oxy.so/contracts';
-import { EN_TRUST_TIER_LABELS, trustTierLabel } from '../trustTierLabels';
-
-const SHIPPED_LOCALES = [
-  'en-US',
-  'es-ES',
-  'ca-ES',
-  'fr-FR',
-  'de-DE',
-  'it-IT',
-  'pt-PT',
-  'ja-JP',
-  'ko-KR',
-  'zh-CN',
-  'ar-SA',
-] as const;
-const REGION_VARIANT = 'es-MX';
-const UNSHIPPED_LOCALE = 'nl-NL';
-
-describe('trustTierLabel', () => {
-  it('covers the whole vocabulary', () => {
-    expect(TRUST_TIERS.length).toBe(5);
-    expect(Object.keys(EN_TRUST_TIER_LABELS)).toHaveLength(TRUST_TIERS.length);
-  });
-
-  it.each([...SHIPPED_LOCALES, REGION_VARIANT, UNSHIPPED_LOCALE])(
-    'names every tier in %s — never a key, never a slug, never empty',
-    (locale) => {
-      for (const tier of TRUST_TIERS) {
-        const label = trustTierLabel(locale, tier);
-        expect(label).not.toBe('');
-        expect(label).not.toBe(`trust.tiers.${tier}`);
-      }
-    },
-  );
-
-  it('falls back to English for a language with no tier translations', () => {
-    expect(trustTierLabel('de-DE', 'high_trust')).toBe(
-      EN_TRUST_TIER_LABELS.high_trust,
-    );
-  });
-
-  it('resolves a region variant through its base language', () => {
-    expect(trustTierLabel('es-MX', 'verified')).toBe(trustTierLabel('es-ES', 'verified'));
-    expect(trustTierLabel('es-MX', 'verified')).not.toBe(EN_TRUST_TIER_LABELS.verified);
-  });
-});