@oxyhq/core 13.2.0 → 15.0.0

package/src/mixins/__tests__/reputation.test.ts

@@ -10,19 +10,58 @@
  */
 
 import { OxyServices } from '../../OxyServices';
+import { OxyAuthenticationError } from '../../OxyServices.errors';
+import { isFullReputationBalance } from '@oxyhq/contracts';
 import type {
   ReputationBalance,
+  ReputationBalanceSummary,
+  ReputationBalanceView,
   ReputationTransaction,
   ReputationDispute,
   ReputationRule,
   ReputationLeaderboardEntry,
   ReputationInfluenceResult,
-} from '../OxyServices.reputation';
+} from '@oxyhq/contracts';
 
 const setAccessTokenForTest = (oxy: OxyServices): void => {
   oxy.httpService.setTokens('test-token');
 };
 
+/** An unsigned JWT carrying just the `userId` claim `getCurrentUserId` decodes. */
+const signedInToken = (userId: string): string => {
+  const encode = (value: object): string =>
+    Buffer.from(JSON.stringify(value))
+      .toString('base64')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=+$/, '');
+  return `${encode({ alg: 'none', typ: 'JWT' })}.${encode({ userId })}.`;
+};
+
+/**
+ * The fields the SUBJECT view adds. Mirrors the private list the API's
+ * `reputationReadAuthz` test asserts absent from the public view.
+ */
+const FULL_BALANCE_FIELD_NAMES = [
+  'positive',
+  'negative',
+  'breakdown',
+  'influence',
+  'reliability',
+  'recalculatedAt',
+  'updatedAt',
+] as const;
+
+/*
+ * The COMPILE-TIME half of this guarantee — that no private field is reachable
+ * on `ReputationBalanceView` without narrowing — is asserted in the SOURCE file,
+ * not here: `ts-jest` runs with `diagnostics: false` and `tsconfig.json`
+ * excludes `**\/__tests__`, so a type-level assertion written in this file could
+ * never fail. See `_PrivateFieldsAreUnreachableOnTheView` in
+ * `@oxyhq/contracts`' `src/reputation.ts`, which that package's
+ * `bun run typescript` and `build:types` both check.
+ */
+
 const balanceFixture: ReputationBalance = {
   userId: 'u1',
   total: 120,
@@ -53,6 +92,13 @@ const balanceFixture: ReputationBalance = {
   updatedAt: '2026-06-16T00:00:00.000Z',
 };
 
+/** What the API serves a caller who is neither the subject nor staff. */
+const summaryFixture: ReputationBalanceSummary = {
+  userId: 'u1',
+  total: 120,
+  trustTier: 'trusted',
+};
+
 const transactionFixture: ReputationTransaction = {
   id: 't1',
   userId: 'u1',
@@ -121,6 +167,74 @@ describe('OxyServices.reputation', () => {
       await oxy.getReputationBalance('a b/c');
       expect(makeRequestSpy.mock.calls[0][1]).toBe('/reputation/a%20b%2Fc/balance');
     });
+
+    it('passes the public view through unchanged for a third-party subject', async () => {
+      makeRequestSpy.mockResolvedValue(summaryFixture);
+
+      const result = await oxy.getReputationBalance('someone-else');
+
+      expect(result).toEqual(summaryFixture);
+      expect(isFullReputationBalance(result)).toBe(false);
+    });
+  });
+
+  describe('isFullReputationBalance', () => {
+    it('narrows the subject view', () => {
+      const view: ReputationBalanceView = balanceFixture;
+      expect(isFullReputationBalance(view)).toBe(true);
+      if (isFullReputationBalance(view)) {
+        // Reachable ONLY through the guard — the point of the narrowing.
+        expect(view.reliability.reportAccuracyScore).toBe(1);
+        expect(view.influence.reportWeight).toBe(1.0);
+        expect(view.breakdown.content).toBe(80);
+      }
+    });
+
+    it('rejects the public view', () => {
+      expect(isFullReputationBalance(summaryFixture)).toBe(false);
+    });
+
+    it('rejects a payload missing any single private field', () => {
+      for (const field of FULL_BALANCE_FIELD_NAMES) {
+        const partial = { ...balanceFixture };
+        delete (partial as Record<string, unknown>)[field];
+        expect(isFullReputationBalance(partial as ReputationBalanceView)).toBe(false);
+      }
+    });
+  });
+
+  describe('getMyReputationBalance', () => {
+    it('reads the signed-in user id from the token and returns the full shape', async () => {
+      oxy.httpService.setTokens(signedInToken('me-123'));
+      makeRequestSpy.mockResolvedValue(balanceFixture);
+
+      const result = await oxy.getMyReputationBalance();
+
+      // Typed as the full balance with no narrowing — the ergonomic path.
+      expect(result.reliability.abuseScore).toBe(0);
+      expect(makeRequestSpy).toHaveBeenCalledWith(
+        'GET',
+        '/reputation/me-123/balance',
+        undefined,
+        expect.objectContaining({ cache: true }),
+      );
+    });
+
+    it('throws without a signed-in user, and never issues the request', async () => {
+      oxy.httpService.clearTokens();
+
+      await expect(oxy.getMyReputationBalance()).rejects.toThrow(OxyAuthenticationError);
+      expect(makeRequestSpy).not.toHaveBeenCalled();
+    });
+
+    it('throws when the server answers 200 with the public view', async () => {
+      // What an absent or lapsed token gets: the endpoint's auth is optional, so
+      // the read succeeds and silently omits every private block.
+      oxy.httpService.setTokens(signedInToken('me-123'));
+      makeRequestSpy.mockResolvedValue(summaryFixture);
+
+      await expect(oxy.getMyReputationBalance()).rejects.toThrow(OxyAuthenticationError);
+    });
   });
 
   describe('getReputationLeaderboard', () => {

package/src/models/interfaces.ts

@@ -246,6 +246,7 @@ export interface BlockedUser {
     _id: string;
     username: string;
     avatar?: string;
+    name?: { displayName?: string };
   };
   userId: string;
   createdAt?: string;
@@ -260,6 +261,7 @@ export interface RestrictedUser {
     _id: string;
     username: string;
     avatar?: string;
+    name?: { displayName?: string };
   };
   userId: string;
   createdAt?: string;

package/src/session/accountProjection.ts

@@ -26,6 +26,7 @@ import type {
   AccountMember,
 } from '../mixins/OxyServices.accounts';
 import { getAccountDisplayName, getAccountFallbackHandle } from '../utils/accountUtils';
+import { getNormalizedUserHandle } from '../utils/userHandle';
 
 /**
  * The per-account user shape carried by a {@link SwitchableAccount}. The SDK's
@@ -170,7 +171,10 @@ export function projectSwitchableAccounts(input: ProjectSwitchableAccountsInput)
       kind: opts.kind,
       parentAccountId: opts.parentAccountId,
       callerMembership: opts.callerMembership,
-      displayName: getAccountDisplayName(accountUser, locale),
+      displayName:
+        accountUser.name?.displayName ??
+        getNormalizedUserHandle(accountUser) ??
+        getAccountDisplayName(null, locale),
       // Real email, or the `@handle` fallback (NEVER synthesized).
       email: accountUser.email ?? secondaryHandle,
       avatarUrl: resolveAvatarUrl(accountUser.avatar),

package/src/types/bip39.d.ts

@@ -1,32 +0,0 @@
-declare module 'bip39' {
-  export interface Wordlist {
-    [index: number]: string;
-    length: number;
-    getWord(index: number): string;
-    getWordIndex(word: string): number;
-  }
-
-  export const wordlists: {
-    english: string[];
-    chinese_simplified: string[];
-    chinese_traditional: string[];
-    french: string[];
-    italian: string[];
-    japanese: string[];
-    korean: string[];
-    spanish: string[];
-  };
-
-  // Use Uint8Array instead of Buffer for React Native compatibility
-  // In Node.js, Buffer extends Uint8Array so this is compatible
-  export function generateMnemonic(strength?: number, rng?: (size: number) => Uint8Array, wordlist?: string[]): string;
-  export function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
-  export function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
-  export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string;
-  export function entropyToMnemonic(entropy: string, wordlist?: string[]): string;
-  export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;
-  export function mnemonicToSeedHex(mnemonic: string, passphrase?: string): Promise<string>;
-  export function mnemonicToSeedHexSync(mnemonic: string, passphrase?: string): string;
-}
-
-