@oxy.so/core 1.18.1 → 3.0.0

package/src/session/__tests__/sessionIntegration.test.ts

@@ -1,209 +0,0 @@
-import type { DeviceSessionState } from '@oxy.so/contracts';
-import type { User } from '../../models/interfaces';
-import { SessionClient, type TokenTransport } from '../SessionClient';
-import { createSessionClientHost } from '../sessionClientHost';
-import { createSessionClient } from '../createSessionClient';
-import {
-  accountIdsOf,
-  activeSessionIdOf,
-  activeUserOf,
-  deviceStateToClientSessions,
-} from '../projectSessionState';
-
-function fakeOxy() {
-  const listeners = new Set<(t: string | null) => void>();
-  return {
-    makeRequest: jest.fn().mockResolvedValue({ ok: true }),
-    getBaseURL: jest.fn().mockReturnValue('https://api.oxy.so'),
-    getAccessToken: jest.fn().mockReturnValue('tok'),
-    setTokens: jest.fn(),
-    onTokensChanged: jest.fn((l: (t: string | null) => void) => {
-      listeners.add(l);
-      return () => listeners.delete(l);
-    }),
-    _emit: (t: string | null) => listeners.forEach((l) => l(t)),
-  };
-}
-
-describe('createSessionClientHost', () => {
-  test('delegates REST + token methods to oxyServices', async () => {
-    const oxy = fakeOxy();
-    const host = createSessionClientHost(oxy as never);
-    await host.makeRequest('GET', '/session/device/state', undefined, { cache: false });
-    expect(oxy.makeRequest).toHaveBeenCalledWith('GET', '/session/device/state', undefined, { cache: false });
-    expect(host.getBaseURL()).toBe('https://api.oxy.so');
-    expect(host.getAccessToken()).toBe('tok');
-    host.setTokens('new');
-    expect(oxy.setTokens).toHaveBeenCalledWith('new');
-  });
-
-  test('getCurrentAccountId reflects setCurrentAccountId', () => {
-    const host = createSessionClientHost(fakeOxy() as never);
-    expect(host.getCurrentAccountId()).toBeNull();
-    host.setCurrentAccountId('u1');
-    expect(host.getCurrentAccountId()).toBe('u1');
-  });
-
-  test('setDeviceCredential reflects on getDeviceCredential', () => {
-    const host = createSessionClientHost(fakeOxy() as never);
-    expect(host.getDeviceCredential()).toBeNull();
-    host.setDeviceCredential({ deviceId: 'd1', deviceSecret: 's1' });
-    expect(host.getDeviceCredential()).toEqual({ deviceId: 'd1', deviceSecret: 's1' });
-  });
-
-  test('onTokensChanged forwards to oxyServices and unsubscribes', () => {
-    const oxy = fakeOxy();
-    const host = createSessionClientHost(oxy as never);
-    const cb = jest.fn();
-    const unsub = host.onTokensChanged(cb);
-    oxy._emit(null);
-    expect(cb).toHaveBeenCalledWith(null);
-    unsub();
-    oxy._emit('x');
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-});
-
-function makeUser(id: string): User {
-  return {
-    id,
-    publicKey: `pk-${id}`,
-    username: `user-${id}`,
-    name: {},
-  };
-}
-
-// DeviceSessionState.updatedAt is an epoch-ms number on the wire (see
-// packages/contracts/src/deviceSession.ts: `updatedAt: z.number()`), not an
-// ISO string.
-const UPDATED_AT_MS = Date.UTC(2026, 6, 1, 0, 0, 0, 0);
-const UPDATED_AT_ISO = new Date(UPDATED_AT_MS).toISOString();
-
-const state: DeviceSessionState = {
-  deviceId: 'device-1',
-  accounts: [
-    { accountId: 'a1', sessionId: 'sess-a1', authuser: 0 },
-    { accountId: 'a2', sessionId: 'sess-a2', authuser: 1 },
-  ],
-  activeAccountId: 'a2',
-  revision: 1,
-  updatedAt: UPDATED_AT_MS,
-};
-
-const usersById = new Map<string, User>([
-  ['a1', makeUser('a1')],
-  ['a2', makeUser('a2')],
-]);
-
-describe('projectSessionState', () => {
-  describe('activeSessionIdOf', () => {
-    test('returns the active account sessionId', () => {
-      expect(activeSessionIdOf(state)).toBe('sess-a2');
-    });
-
-    test('returns null for null state', () => {
-      expect(activeSessionIdOf(null)).toBeNull();
-    });
-
-    test('returns null when activeAccountId is null', () => {
-      expect(activeSessionIdOf({ ...state, activeAccountId: null })).toBeNull();
-    });
-  });
-
-  describe('deviceStateToClientSessions', () => {
-    test('maps every account in order with isCurrent + authuser', () => {
-      const sessions = deviceStateToClientSessions(state, usersById);
-      expect(sessions).toHaveLength(2);
-      expect(sessions[0]).toEqual({
-        sessionId: 'sess-a1',
-        deviceId: 'device-1',
-        expiresAt: UPDATED_AT_ISO,
-        lastActive: UPDATED_AT_ISO,
-        userId: 'a1',
-        isCurrent: false,
-        authuser: 0,
-      });
-      expect(sessions[1]).toEqual({
-        sessionId: 'sess-a2',
-        deviceId: 'device-1',
-        expiresAt: UPDATED_AT_ISO,
-        lastActive: UPDATED_AT_ISO,
-        userId: 'a2',
-        isCurrent: true,
-        authuser: 1,
-      });
-    });
-
-    test('still projects a session for an account absent from usersById', () => {
-      const sessions = deviceStateToClientSessions(state, new Map());
-      expect(sessions).toHaveLength(2);
-      expect(sessions.map((session) => session.userId)).toEqual(['a1', 'a2']);
-    });
-  });
-
-  describe('activeUserOf', () => {
-    test('returns the active account user', () => {
-      expect(activeUserOf(state, usersById)).toEqual(makeUser('a2'));
-    });
-
-    test('returns null for null state', () => {
-      expect(activeUserOf(null, usersById)).toBeNull();
-    });
-
-    test('returns null when activeAccountId is null', () => {
-      expect(activeUserOf({ ...state, activeAccountId: null }, usersById)).toBeNull();
-    });
-
-    test('returns null when the active account id is absent from usersById', () => {
-      expect(activeUserOf(state, new Map())).toBeNull();
-    });
-  });
-
-  describe('accountIdsOf', () => {
-    test('returns every account id in order', () => {
-      expect(accountIdsOf(state)).toEqual(['a1', 'a2']);
-    });
-
-    test('returns [] for null state', () => {
-      expect(accountIdsOf(null)).toEqual([]);
-    });
-  });
-});
-
-describe('createSessionClient', () => {
-  function fakeTransport(): TokenTransport {
-    return { ensureActiveToken: jest.fn().mockResolvedValue(undefined) };
-  }
-
-  test('wires a SessionClient instance backed by the host + injected transport', () => {
-    const oxy = fakeOxy();
-
-    const { client, host } = createSessionClient(oxy as never, fakeTransport());
-
-    expect(client).toBeInstanceOf(SessionClient);
-    expect(typeof client.bootstrap).toBe('function');
-    expect(client.getState()).toBeNull();
-    expect(typeof host.setCurrentAccountId).toBe('function');
-  });
-
-  test('the returned host reflects setCurrentAccountId', () => {
-    const oxy = fakeOxy();
-
-    const { host } = createSessionClient(oxy as never, fakeTransport());
-
-    expect(host.getCurrentAccountId()).toBeNull();
-    host.setCurrentAccountId('u1');
-    expect(host.getCurrentAccountId()).toBe('u1');
-  });
-
-  test('uses the injected transport (not a hard-coded one) when the client bootstraps', async () => {
-    const oxy = fakeOxy();
-    oxy.makeRequest.mockResolvedValue({ state, activeToken: null });
-    const transport = fakeTransport();
-
-    const { client } = createSessionClient(oxy as never, transport);
-    await client.bootstrap();
-
-    expect(transport.ensureActiveToken).toHaveBeenCalledWith(expect.objectContaining({ revision: state.revision }));
-  });
-});

package/src/session/__tests__/sharedDeviceCredential.test.ts

@@ -1,300 +0,0 @@
-/**
- * The shared native DeviceSession credential — the decision rules that separate
- * "this device already has a session" from "this device could not be read".
- *
- * Every case here is written against the one failure this module exists to make
- * unreachable: a secure store that is LOCKED or BROKEN looking like a secure
- * store that is EMPTY. The empty answer authorises a write into the slot; the
- * failed answer must authorise nothing. Several assertions below are the only
- * thing standing between that misreading and a live shared session being
- * overwritten, so they are written to fail loudly rather than shrink quietly.
- */
-import { createMemoryAuthStateStore, type AuthStateStore, type PersistedAuthState } from '../authStateStore';
-import {
-  createSharedMirroringAuthStateStore,
-  decideSharedDeviceJoin,
-  decideSharedDevicePublish,
-  normalizeSharedDeviceSessionRead,
-  publishProvenDeviceCredential,
-  readLocalDeviceCredential,
-  type SharedDeviceCredential,
-  type SharedDeviceCredentialRead,
-  type SharedDeviceCredentialStore,
-} from '../sharedDeviceCredential';
-
-const CRED: SharedDeviceCredential = { deviceId: 'dev-shared', deviceSecret: 'ds-shared' };
-const OTHER: SharedDeviceCredential = { deviceId: 'dev-other', deviceSecret: 'ds-other' };
-
-const PRESENT: SharedDeviceCredentialRead = { state: 'present', credential: CRED };
-const ABSENT: SharedDeviceCredentialRead = { state: 'absent' };
-const UNAVAILABLE: SharedDeviceCredentialRead = { state: 'unavailable', cause: new Error('keychain locked') };
-const UNSUPPORTED: SharedDeviceCredentialRead = { state: 'unsupported' };
-
-/** Every read state, so a new one cannot be added without deciding what it means. */
-const ALL_READS: SharedDeviceCredentialRead[] = [PRESENT, ABSENT, UNAVAILABLE, UNSUPPORTED];
-
-function localWith(credential: SharedDeviceCredential | null): PersistedAuthState {
-  return {
-    sessionId: 'sess-local',
-    userId: 'user-local',
-    ...(credential ? { deviceId: credential.deviceId, deviceSecret: credential.deviceSecret } : {}),
-  };
-}
-
-/** An in-memory {@link SharedDeviceCredentialStore} with scripted read behaviour. */
-function makeSharedStore(initial: SharedDeviceCredentialRead) {
-  let current = initial;
-  const publish = jest.fn(async (credential: SharedDeviceCredential) => {
-    current = { state: 'present', credential };
-    return true;
-  });
-  const clear = jest.fn(async () => {
-    current = { state: 'absent' };
-  });
-  const store: SharedDeviceCredentialStore = {
-    read: async () => current,
-    publish,
-    clear,
-  };
-  return { store, publish, clear, peek: () => current };
-}
-
-describe('readLocalDeviceCredential', () => {
-  test('requires BOTH halves of the mint credential', () => {
-    expect(readLocalDeviceCredential(null)).toBeNull();
-    expect(readLocalDeviceCredential({ sessionId: 's', userId: 'u' })).toBeNull();
-    expect(readLocalDeviceCredential({ sessionId: 's', userId: 'u', deviceId: 'd' })).toBeNull();
-    expect(readLocalDeviceCredential({ sessionId: 's', userId: 'u', deviceSecret: 'x' })).toBeNull();
-    expect(readLocalDeviceCredential(localWith(CRED))).toEqual(CRED);
-  });
-});
-
-describe('normalizeSharedDeviceSessionRead', () => {
-  test('narrows a well-formed present payload', () => {
-    expect(
-      normalizeSharedDeviceSessionRead({ status: 'present', deviceId: 'dev-x', deviceSecret: 'ds-x' }),
-    ).toEqual({ state: 'present', credential: { deviceId: 'dev-x', deviceSecret: 'ds-x' } });
-  });
-
-  test('narrows an explicit absent payload', () => {
-    expect(normalizeSharedDeviceSessionRead({ status: 'absent' })).toEqual({ state: 'absent' });
-  });
-
-  test.each([
-    ['null', null],
-    ['undefined', undefined],
-    ['a string', 'absent'],
-    ['a number', 0],
-    ['an empty object', {}],
-    ['an unknown status', { status: 'maybe' }],
-    ['present with no deviceId', { status: 'present', deviceSecret: 'ds-x' }],
-    ['present with no deviceSecret', { status: 'present', deviceId: 'dev-x' }],
-    ['present with an empty deviceSecret', { status: 'present', deviceId: 'dev-x', deviceSecret: '' }],
-    ['present with a non-string deviceId', { status: 'present', deviceId: 7, deviceSecret: 'ds-x' }],
-    ['an explicit unavailable', { status: 'unavailable', reason: 'keystore' }],
-  ])('reports %s as unavailable, never absent', (_label, raw) => {
-    const read = normalizeSharedDeviceSessionRead(raw);
-    // `unavailable` and `absent` are the pair that must never be confused: the
-    // second one authorises a write into the slot.
-    expect(read.state).toBe('unavailable');
-  });
-});
-
-describe('decideSharedDeviceJoin', () => {
-  test('adopts when the slot holds a credential and this app has none', () => {
-    expect(decideSharedDeviceJoin(localWith(null), PRESENT)).toEqual({ action: 'adopt', credential: CRED });
-    expect(decideSharedDeviceJoin(null, PRESENT)).toEqual({ action: 'adopt', credential: CRED });
-  });
-
-  test('NEVER adopts when the slot could not be read', () => {
-    // The keystore-unavailable case. Adopting nothing is right; the danger is a
-    // caller downstream reading this as "fresh device".
-    expect(decideSharedDeviceJoin(localWith(null), UNAVAILABLE)).toEqual({
-      action: 'skip',
-      reason: 'shared-unreadable',
-    });
-  });
-
-  test('reports an unsupported slot distinctly from an unreadable one', () => {
-    // Same behaviour, different diagnosis: no shared transport in this build is
-    // normal, an unreadable one is not.
-    expect(decideSharedDeviceJoin(localWith(null), UNSUPPORTED)).toEqual({
-      action: 'skip',
-      reason: 'shared-unsupported',
-    });
-  });
-
-  test('skips an empty slot', () => {
-    expect(decideSharedDeviceJoin(localWith(null), ABSENT)).toEqual({ action: 'skip', reason: 'shared-empty' });
-  });
-
-  test('never moves an app that already holds its own credential — in ANY slot state', () => {
-    // "No user is signed out merely because one app updates first" holds by
-    // construction: whatever the slot says, an app with a working credential of
-    // its own is left exactly where it is. Including when the slot holds a
-    // DIFFERENT device session.
-    for (const read of ALL_READS) {
-      expect(decideSharedDeviceJoin(localWith(OTHER), read)).toEqual({
-        action: 'skip',
-        reason: 'local-credential-present',
-      });
-    }
-    expect(ALL_READS).toHaveLength(4);
-  });
-});
-
-describe('decideSharedDevicePublish', () => {
-  test('seeds an empty slot with a proven credential', () => {
-    expect(decideSharedDevicePublish(CRED, ABSENT)).toEqual({ action: 'publish' });
-  });
-
-  test('NEVER writes over a slot it could not read', () => {
-    // The destructive direction. An unreadable slot may hold another principal's
-    // live session; writing on the strength of a failed read is how it is lost.
-    expect(decideSharedDevicePublish(CRED, UNAVAILABLE)).toEqual({
-      action: 'skip',
-      reason: 'shared-unreadable',
-    });
-  });
-
-  test('does not write when there is no slot at all', () => {
-    expect(decideSharedDevicePublish(CRED, UNSUPPORTED)).toEqual({
-      action: 'skip',
-      reason: 'shared-unsupported',
-    });
-  });
-
-  test('refreshes the secret for the SAME device session', () => {
-    const rotated = { deviceId: CRED.deviceId, deviceSecret: 'ds-rotated' };
-    expect(decideSharedDevicePublish(rotated, PRESENT)).toEqual({ action: 'publish' });
-  });
-
-  test('is a no-op when the slot already holds exactly this credential', () => {
-    expect(decideSharedDevicePublish(CRED, PRESENT)).toEqual({ action: 'skip', reason: 'already-current' });
-  });
-
-  test('leaves a slot owned by a DIFFERENT device session alone', () => {
-    // Overwriting would silently migrate every other app on this device onto our
-    // session at their next cold boot. That is a user-visible change of identity,
-    // not something a background persist decides.
-    expect(decideSharedDevicePublish(OTHER, PRESENT)).toEqual({
-      action: 'skip',
-      reason: 'owned-by-another-device',
-    });
-  });
-});
-
-describe('publishProvenDeviceCredential', () => {
-  test('writes into an empty slot', async () => {
-    const shared = makeSharedStore(ABSENT);
-    await expect(publishProvenDeviceCredential({ shared: shared.store, credential: CRED })).resolves.toEqual({
-      status: 'published',
-    });
-    expect(shared.publish).toHaveBeenCalledWith(CRED);
-    expect(shared.peek()).toEqual(PRESENT);
-  });
-
-  test('does not call publish at all when the slot is unreadable', async () => {
-    const shared = makeSharedStore(UNAVAILABLE);
-    await expect(publishProvenDeviceCredential({ shared: shared.store, credential: CRED })).resolves.toEqual({
-      status: 'skipped',
-      reason: 'shared-unreadable',
-    });
-    expect(shared.publish).not.toHaveBeenCalled();
-  });
-
-  test('reports an unverified write as a failure rather than a success', async () => {
-    const shared: SharedDeviceCredentialStore = {
-      read: async () => ABSENT,
-      // The contract is read-back-verified; a store that could not confirm the
-      // bytes landed must say so, or a fresh install joins with a phantom.
-      publish: async () => false,
-      clear: async () => undefined,
-    };
-    await expect(publishProvenDeviceCredential({ shared, credential: CRED })).resolves.toEqual({
-      status: 'publish-failed',
-    });
-  });
-});
-
-describe('createSharedMirroringAuthStateStore', () => {
-  function harness(initial: SharedDeviceCredentialRead = ABSENT) {
-    const local = createMemoryAuthStateStore();
-    const shared = makeSharedStore(initial);
-    return { local, shared, store: createSharedMirroringAuthStateStore({ local, shared: shared.store }) };
-  }
-
-  test('mirrors a saved credential into the shared slot', async () => {
-    const h = harness();
-    await expect(h.store.save(localWith(CRED))).resolves.toBe(true);
-    expect(h.shared.publish).toHaveBeenCalledWith(CRED);
-    expect(await h.local.load()).toEqual(localWith(CRED));
-  });
-
-  test('does not re-write the slot when the credential has not changed', async () => {
-    const h = harness();
-    await h.store.save(localWith(CRED));
-    await h.store.save({ ...localWith(CRED), accessToken: 'warm', expiresAt: 'later' });
-    await h.store.save({ ...localWith(CRED), accessToken: 'warmer', expiresAt: 'later-still' });
-    expect(h.shared.publish).toHaveBeenCalledTimes(1);
-  });
-
-  test('mirrors again once the credential really changes', async () => {
-    const h = harness();
-    await h.store.save(localWith(CRED));
-    await h.store.save(localWith({ deviceId: CRED.deviceId, deviceSecret: 'ds-rotated' }));
-    expect(h.shared.publish).toHaveBeenCalledTimes(2);
-  });
-
-  test('saves nothing to the slot when the state carries no credential', async () => {
-    const h = harness();
-    await h.store.save({ sessionId: 's', userId: 'u' });
-    expect(h.shared.publish).not.toHaveBeenCalled();
-  });
-
-  test('reports the LOCAL durability verdict, not the mirror outcome', async () => {
-    // The caller's contract is about the durable local write — a lane persisting
-    // a rotated secret treats `false` as fatal. A best-effort mirror must never
-    // be able to flip that answer in either direction.
-    const failingLocal: AuthStateStore = {
-      load: async () => null,
-      save: async () => false,
-      clear: async () => undefined,
-    };
-    const shared = makeSharedStore(ABSENT);
-    const store = createSharedMirroringAuthStateStore({ local: failingLocal, shared: shared.store });
-    await expect(store.save(localWith(CRED))).resolves.toBe(false);
-    expect(shared.publish).toHaveBeenCalledWith(CRED);
-  });
-
-  test('a throwing shared store cannot fail a successful local write', async () => {
-    const shared: SharedDeviceCredentialStore = {
-      read: async () => {
-        throw new Error('binder died');
-      },
-      publish: async () => true,
-      clear: async () => undefined,
-    };
-    const store = createSharedMirroringAuthStateStore({ local: createMemoryAuthStateStore(), shared });
-    await expect(store.save(localWith(CRED))).resolves.toBe(true);
-  });
-
-  test('signing out of THIS app does not clear the device-wide slot', async () => {
-    // Other apps may still be signed in on that credential, and once the server
-    // session is gone the credential mints `no_active_session` for everyone
-    // anyway. This app's sign-out is not authority over the join point.
-    const h = harness();
-    await h.store.save(localWith(CRED));
-    await h.store.clear();
-    expect(h.shared.clear).not.toHaveBeenCalled();
-    expect(h.shared.peek()).toEqual(PRESENT);
-    expect(await h.local.load()).toBeNull();
-  });
-
-  test('load is a pass-through and never adopts', async () => {
-    // Adoption is an explicit cold-boot step. A storage primitive must not be
-    // able to change who the app is signed in as.
-    const h = harness(PRESENT);
-    expect(await h.store.load()).toBeNull();
-  });
-});

package/src/utils/__tests__/accountUtils.test.ts

@@ -1,151 +0,0 @@
-import {
-    createQuickAccount,
-    getAccountDisplayName,
-    getAccountFallbackHandle,
-    formatPublicKeyHandle,
-} from '../accountUtils';
-
-describe('getAccountDisplayName', () => {
-    it('prefers the API name.displayName when present', () => {
-        expect(
-            getAccountDisplayName({
-                name: { first: 'Nate', displayName: 'Nate Isern' },
-                username: 'nateus',
-            }),
-        ).toBe('Nate Isern');
-    });
-
-    it('returns first name for first-name-only accounts (NOT the username)', () => {
-        const result = getAccountDisplayName({
-            name: { first: 'Nate' },
-            username: 'nateus',
-        });
-        expect(result).toBe('Nate');
-        expect(result).not.toBe('nateus');
-    });
-
-    it('composes first + last when both are present', () => {
-        expect(
-            getAccountDisplayName({
-                name: { first: 'Nate', last: 'Isern' },
-                username: 'nateus',
-            }),
-        ).toBe('Nate Isern');
-    });
-
-    it('returns last name only when first is missing', () => {
-        expect(
-            getAccountDisplayName({
-                name: { last: 'Isern' },
-                username: 'nateus',
-            }),
-        ).toBe('Isern');
-    });
-
-    it('prefers name.full when present', () => {
-        expect(
-            getAccountDisplayName({
-                name: { first: 'Nate', last: 'Isern', full: 'Nathaniel Isern' },
-                username: 'nateus',
-            }),
-        ).toBe('Nathaniel Isern');
-    });
-
-    it('uses pre-normalized account-row displayName when there is no structured name', () => {
-        expect(
-            getAccountDisplayName({
-                displayName: 'Cool Display',
-                username: 'nateus',
-            }),
-        ).toBe('Cool Display');
-    });
-
-    it('supports name stored as a plain string', () => {
-        expect(getAccountDisplayName({ name: 'Legacy Name', username: 'nateus' })).toBe(
-            'Legacy Name',
-        );
-    });
-
-    it('falls back to username when there is no name', () => {
-        expect(getAccountDisplayName({ username: 'nateus' })).toBe('nateus');
-    });
-
-    it('falls back to the public-key handle when there is no name or username', () => {
-        const result = getAccountDisplayName({
-            publicKey: '0x1234567890abcdef',
-        });
-        // common.accountFallback = "Account {{handle}}"; handle truncated to 0x12345678…
-        expect(result).toBe('Account 0x12345678…');
-        expect(result).not.toContain('Unknown');
-    });
-
-    it('returns the translated unnamed fallback when nothing is available', () => {
-        expect(getAccountDisplayName({})).toBe('Unnamed');
-        expect(getAccountDisplayName(null)).toBe('Unnamed');
-        expect(getAccountDisplayName(undefined)).toBe('Unnamed');
-    });
-
-    it('ignores whitespace-only name fields', () => {
-        expect(
-            getAccountDisplayName({
-                name: { first: '   ', last: '   ' },
-                username: 'nateus',
-            }),
-        ).toBe('nateus');
-    });
-
-    it('honours the locale for the fallback strings', () => {
-        expect(getAccountDisplayName({}, 'es-ES')).toBe('Sin nombre');
-        expect(getAccountDisplayName({ publicKey: '0x1234567890abcdef' }, 'es-ES')).toBe(
-            'Cuenta 0x12345678…',
-        );
-    });
-});
-
-describe('getAccountFallbackHandle', () => {
-    it('returns the bare username when present', () => {
-        expect(getAccountFallbackHandle({ username: 'nateus' })).toBe('nateus');
-    });
-
-    it('falls back to a truncated public-key handle', () => {
-        expect(getAccountFallbackHandle({ publicKey: '0x1234567890abcdef' })).toBe('0x12345678…');
-    });
-
-    it('returns undefined when neither username nor publicKey is present', () => {
-        expect(getAccountFallbackHandle({})).toBeUndefined();
-        expect(getAccountFallbackHandle(null)).toBeUndefined();
-    });
-});
-
-describe('createQuickAccount', () => {
-    it('prefers API name.displayName over composed first/last', () => {
-        const account = createQuickAccount('sess-1', {
-            name: { first: 'Nate', last: 'Isern', displayName: 'Nate Isern' },
-            username: 'nateus',
-            id: 'user-1',
-        });
-        expect(account.displayName).toBe('Nate Isern');
-    });
-
-    it('falls back to the normalized handle when displayName is absent', () => {
-        const account = createQuickAccount('sess-1', {
-            name: { first: 'Nate', last: 'Isern' },
-            username: 'nateus',
-            id: 'user-1',
-        });
-        expect(account.displayName).toBe('nateus');
-        expect(account.displayName).not.toBe('Nate Isern');
-    });
-});
-
-describe('formatPublicKeyHandle', () => {
-    it('truncates a long key and strips the 0x prefix before re-adding it', () => {
-        expect(formatPublicKeyHandle('0x1234567890abcdef')).toBe('0x12345678…');
-        expect(formatPublicKeyHandle('1234567890abcdef')).toBe('0x12345678…');
-    });
-
-    it('returns the raw (prefixed) key when too short to truncate', () => {
-        expect(formatPublicKeyHandle('0xabcd')).toBe('0xabcd');
-        expect(formatPublicKeyHandle('abcd')).toBe('0xabcd');
-    });
-});