@luxexchange/sessions 1.0.2 → 1.0.3

package/src/session-service/createSessionService.test.ts

@@ -1,16 +1,16 @@
-import type { DeviceIdService } from '@luxfi/sessions/src/device-id/types'
-import type { SessionRepository } from '@luxfi/sessions/src/session-repository/types'
-import { createSessionService } from '@luxfi/sessions/src/session-service/createSessionService'
-import type { SessionService } from '@luxfi/sessions/src/session-service/types'
-import type { SessionStorage } from '@luxfi/sessions/src/session-storage/types'
-import type { LuxIdentifierService } from '@luxfi/sessions/src/lux-identifier/types'
+import type { DeviceIdService } from '@luxexchange/sessions/src/device-id/types'
+import type { SessionRepository } from '@luxexchange/sessions/src/session-repository/types'
+import { createSessionService } from '@luxexchange/sessions/src/session-service/createSessionService'
+import type { SessionService } from '@luxexchange/sessions/src/session-service/types'
+import type { SessionStorage } from '@luxexchange/sessions/src/session-storage/types'
+import type { LxIdentifierService } from '@luxexchange/sessions/src/uniswap-identifier/types'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 describe('createSessionService', () => {
   let storage: SessionStorage
   let repository: SessionRepository
   let deviceIdService: DeviceIdService
-  let luxIdentifierService: LuxIdentifierService
+  let lxIdentifierService: LxIdentifierService
   let service: SessionService
 
   beforeEach(() => {
@@ -37,14 +37,14 @@ describe('createSessionService', () => {
       },
     }
 
-    let luxIdentifierData: string | null = null
-    luxIdentifierService = {
-      getLuxIdentifier: async (): Promise<string | null> => luxIdentifierData,
-      setLuxIdentifier: async (identifier: string): Promise<void> => {
-        luxIdentifierData = identifier
+    let lxIdentifierData: string | null = null
+    lxIdentifierService = {
+      getLxIdentifier: async (): Promise<string | null> => lxIdentifierData,
+      setLxIdentifier: async (identifier: string): Promise<void> => {
+        lxIdentifierData = identifier
       },
-      removeLuxIdentifier: async (): Promise<void> => {
-        luxIdentifierData = null
+      removeLxIdentifier: async (): Promise<void> => {
+        lxIdentifierData = null
       },
     }
 
@@ -68,7 +68,7 @@ describe('createSessionService', () => {
       sessionStorage: storage,
       sessionRepository: repository,
       deviceIdService,
-      luxIdentifierService,
+      lxIdentifierService,
     })
   })
 
@@ -103,7 +103,7 @@ describe('createSessionService', () => {
         sessionStorage: storage,
         sessionRepository: repository,
         deviceIdService,
-        luxIdentifierService,
+        lxIdentifierService,
       })
 
       await service.initSession()
@@ -178,7 +178,7 @@ describe('createSessionService', () => {
         sessionStorage: storage,
         sessionRepository: repository,
         deviceIdService,
-        luxIdentifierService,
+        lxIdentifierService,
       })
 
       expect(await service2.getSessionState()).toEqual({ sessionId: 'test-session-123' })
@@ -201,7 +201,7 @@ describe('createSessionService', () => {
         sessionStorage: storage2,
         sessionRepository: repository,
         deviceIdService,
-        luxIdentifierService,
+        lxIdentifierService,
       })
 
       await service.initSession()
@@ -326,8 +326,8 @@ describe('createSessionService', () => {
     })
   })
 
-  describe('lux identifier handling', () => {
-    it('persists luxIdentifier when provided in extra', async () => {
+  describe('uniswap identifier handling', () => {
+    it('persists lxIdentifier when provided in extra', async () => {
       repository.initSession = async (): Promise<{
         sessionId?: string
         needChallenge: boolean
@@ -335,14 +335,14 @@ describe('createSessionService', () => {
       }> => ({
         sessionId: 'test-session-123',
         needChallenge: false,
-        extra: { luxIdentifier: '71cef16f-4d99-4082-987c-a6f810f9ca7f' },
+        extra: { lxIdentifier: '71cef16f-4d99-4082-987c-a6f810f9ca7f' },
       })
 
       await service.initSession()
-      expect(await luxIdentifierService.getLuxIdentifier()).toBe('71cef16f-4d99-4082-987c-a6f810f9ca7f')
+      expect(await lxIdentifierService.getLxIdentifier()).toBe('71cef16f-4d99-4082-987c-a6f810f9ca7f')
     })
 
-    it('does not persist luxIdentifier when not provided', async () => {
+    it('does not persist lxIdentifier when not provided', async () => {
       repository.initSession = async (): Promise<{
         sessionId?: string
         needChallenge: boolean
@@ -354,10 +354,10 @@ describe('createSessionService', () => {
       })
 
       await service.initSession()
-      expect(await luxIdentifierService.getLuxIdentifier()).toBeNull()
+      expect(await lxIdentifierService.getLxIdentifier()).toBeNull()
     })
 
-    it('updates luxIdentifier on subsequent initSession calls', async () => {
+    it('updates lxIdentifier on subsequent initSession calls', async () => {
       repository.initSession = async (): Promise<{
         sessionId?: string
         needChallenge: boolean
@@ -365,11 +365,11 @@ describe('createSessionService', () => {
       }> => ({
         sessionId: 'test-session-123',
         needChallenge: false,
-        extra: { luxIdentifier: 'first-identifier' },
+        extra: { lxIdentifier: 'first-identifier' },
       })
 
       await service.initSession()
-      expect(await luxIdentifierService.getLuxIdentifier()).toBe('first-identifier')
+      expect(await lxIdentifierService.getLxIdentifier()).toBe('first-identifier')
 
       repository.initSession = async (): Promise<{
         sessionId?: string
@@ -378,11 +378,11 @@ describe('createSessionService', () => {
       }> => ({
         sessionId: 'test-session-456',
         needChallenge: false,
-        extra: { luxIdentifier: 'second-identifier' },
+        extra: { lxIdentifier: 'second-identifier' },
       })
 
       await service.initSession()
-      expect(await luxIdentifierService.getLuxIdentifier()).toBe('second-identifier')
+      expect(await lxIdentifierService.getLxIdentifier()).toBe('second-identifier')
     })
   })
 })

package/src/session-service/createSessionService.ts

@@ -9,7 +9,7 @@ import type {
   VerifySessionResponse,
 } from '@luxexchange/sessions/src/session-service/types'
 import type { SessionStorage } from '@luxexchange/sessions/src/session-storage/types'
-import type { LuxIdentifierService } from '@luxexchange/sessions/src/lux-identifier/types'
+import type { LxIdentifierService } from '@luxexchange/sessions/src/uniswap-identifier/types'
 
 /**
  * Creates a Session Service instance.
@@ -18,7 +18,7 @@ import type { LuxIdentifierService } from '@luxexchange/sessions/src/lux-identif
 export function createSessionService(ctx: {
   sessionStorage: SessionStorage
   deviceIdService: DeviceIdService
-  luxIdentifierService: LuxIdentifierService
+  lxIdentifierService: LxIdentifierService
   sessionRepository: SessionRepository
 }): SessionService {
   async function initSession(): Promise<InitSessionResponse> {
@@ -29,8 +29,8 @@ export function createSessionService(ctx: {
     if (result.deviceId) {
       await ctx.deviceIdService.setDeviceId(result.deviceId)
     }
-    if (result.extra['luxIdentifier']) {
-      await ctx.luxIdentifierService.setLuxIdentifier(result.extra['luxIdentifier'])
+    if (result.extra['lxIdentifier']) {
+      await ctx.lxIdentifierService.setLxIdentifier(result.extra['lxIdentifier'])
     }
     return result
   }

package/src/session-service/types.ts

@@ -1,4 +1,4 @@
-import { ChallengeType } from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import { ChallengeType } from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
 import type { TypedChallengeData } from '@luxexchange/sessions/src/session-repository/types'
 import { SessionState } from '@luxexchange/sessions/src/session-storage/types'
 

package/src/session-storage/createSessionStorage.ts

@@ -1,4 +1,4 @@
-import { SessionStorage } from '@luxfi/sessions/src/session-storage/types'
+import { SessionStorage } from '@luxexchange/sessions/src/session-storage/types'
 
 /**
  * Creates a Session Storage instance, given a set of functions to interact with a storage driver.

package/src/session.integration.test.ts

@@ -39,6 +39,7 @@ const BACKEND_URL = 'https://entry-gateway.backend-staging.api.lux.org'
 // Web Platform Tests (Turnstile + Hashcash)
 // =============================================================================
 // Web uses Turnstile (browser CAPTCHA) first, then falls back to Hashcash
+// These tests hit a staging backend that occasionally returns transient 502s.
 describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
   let sessionService: SessionService
   let sessionStorage: InMemorySessionStorage
@@ -76,7 +77,7 @@ describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
     await sessionStorage.clear()
   })
 
-  it('initializes session with cookie, empty response sessionId', async () => {
+  it('initializes session with cookie, empty response sessionId', { timeout: 30000, retry: 5 }, async () => {
     const manualInitService = createSessionInitializationService({
       getSessionService: () => sessionService,
       challengeSolverService,
@@ -96,9 +97,9 @@ describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
     // Session is NOT stored locally yet because challenge is needed
     const sessionState = await sessionService.getSessionState()
     expect(sessionState).toBeNull()
-  }, 30000)
+  })
 
-  it('receives Turnstile challenge first', async () => {
+  it('receives Turnstile challenge first', { timeout: 30000, retry: 5 }, async () => {
     const manualInitService = createSessionInitializationService({
       getSessionService: () => sessionService,
       challengeSolverService,
@@ -113,9 +114,9 @@ describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
     // Web gets Turnstile first (browser-based CAPTCHA)
     expect(challenge.challengeType).toBe(ChallengeType.TURNSTILE)
     expect(challenge.challengeId).toBeTruthy()
-  }, 30000)
+  })
 
-  it('falls back to Hashcash after Turnstile fails', async () => {
+  it('falls back to Hashcash after Turnstile fails', { timeout: 30000, retry: 5 }, async () => {
     const manualInitService = createSessionInitializationService({
       getSessionService: () => sessionService,
       challengeSolverService,
@@ -151,56 +152,72 @@ describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
     const hashcashChallenge = await sessionService.requestChallenge()
     expect(hashcashChallenge.challengeType).toBe(ChallengeType.HASHCASH)
     expect(hashcashChallenge.challengeId).toBeTruthy()
-  }, 30000)
+  })
 
-  it('successfully upgrades session with Hashcash after Turnstile fails', { timeout: 60000, retry: 2 }, async () => {
-    const manualInitService = createSessionInitializationService({
-      getSessionService: () => sessionService,
-      challengeSolverService,
-      performanceTracker: createMockPerformanceTracker(),
-      getIsSessionUpgradeAutoEnabled: () => false,
-    })
+  it('successfully upgrades session with Hashcash after Turnstile fails', { timeout: 60000, retry: 5 }, async () => {
+    let lastError: unknown
 
-    await manualInitService.initialize()
+    // Some staging responses intermittently return HTTP 502 and leave session state invalid.
+    // Retry the full flow from a clean state so we don't carry over a broken session cookie.
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const manualInitService = createSessionInitializationService({
+          getSessionService: () => sessionService,
+          challengeSolverService,
+          performanceTracker: createMockPerformanceTracker(),
+          getIsSessionUpgradeAutoEnabled: () => false,
+        })
 
-    // Turnstile attempt (fails)
-    const turnstileChallenge = await sessionService.requestChallenge()
-    const turnstileSolver = challengeSolverService.getSolver(ChallengeType.TURNSTILE)
-    const turnstileSolution = await turnstileSolver?.solve({
-      challengeId: turnstileChallenge.challengeId,
-      challengeType: turnstileChallenge.challengeType,
-      extra: turnstileChallenge.extra,
-    })
+        await manualInitService.initialize()
 
-    const turnstileResult = await sessionService.verifySession({
-      solution: turnstileSolution || '',
-      challengeId: turnstileChallenge.challengeId,
-      challengeType: turnstileChallenge.challengeType,
-    })
-    expect(turnstileResult.retry).toBe(true)
+        // Turnstile attempt (fails)
+        const turnstileChallenge = await sessionService.requestChallenge()
+        const turnstileSolver = challengeSolverService.getSolver(ChallengeType.TURNSTILE)
+        const turnstileSolution = await turnstileSolver?.solve({
+          challengeId: turnstileChallenge.challengeId,
+          challengeType: turnstileChallenge.challengeType,
+          extra: turnstileChallenge.extra,
+        })
 
-    // Hashcash attempt
-    const hashcashChallenge = await sessionService.requestChallenge()
-    expect(hashcashChallenge.challengeType).toBe(ChallengeType.HASHCASH)
+        const turnstileResult = await sessionService.verifySession({
+          solution: turnstileSolution || '',
+          challengeId: turnstileChallenge.challengeId,
+          challengeType: turnstileChallenge.challengeType,
+        })
+        expect(turnstileResult.retry).toBe(true)
 
-    const hashcashSolver = challengeSolverService.getSolver(ChallengeType.HASHCASH)
-    const hashcashSolution = await hashcashSolver?.solve({
-      challengeId: hashcashChallenge.challengeId,
-      challengeType: hashcashChallenge.challengeType,
-      extra: hashcashChallenge.extra,
-    })
+        // Hashcash attempt
+        const hashcashChallenge = await sessionService.requestChallenge()
+        expect(hashcashChallenge.challengeType).toBe(ChallengeType.HASHCASH)
 
-    const hashcashResult = await sessionService.verifySession({
-      solution: hashcashSolution || '',
-      challengeId: hashcashChallenge.challengeId,
-      challengeType: hashcashChallenge.challengeType,
-    })
+        const hashcashSolver = challengeSolverService.getSolver(ChallengeType.HASHCASH)
+        const hashcashSolution = await hashcashSolver?.solve({
+          challengeId: hashcashChallenge.challengeId,
+          challengeType: hashcashChallenge.challengeType,
+          extra: hashcashChallenge.extra,
+        })
+
+        const hashcashResult = await sessionService.verifySession({
+          solution: hashcashSolution || '',
+          challengeId: hashcashChallenge.challengeId,
+          challengeType: hashcashChallenge.challengeType,
+        })
+
+        // Success!
+        expect(hashcashResult.retry).toBe(false)
+        return
+      } catch (error) {
+        lastError = error
+        await sessionService.removeSession()
+        cookieJar.clear()
+        await sessionStorage.clear()
+      }
+    }
 
-    // Success!
-    expect(hashcashResult.retry).toBe(false)
+    throw lastError instanceof Error ? lastError : new Error('Failed to complete Hashcash upgrade flow')
   })
 
-  it('completes auto-upgrade flow (Turnstile fail → Hashcash success)', { timeout: 60000, retry: 2 }, async () => {
+  it('completes auto-upgrade flow (Turnstile fail → Hashcash success)', { timeout: 60000, retry: 5 }, async () => {
     const autoInitService = createSessionInitializationService({
       getSessionService: () => sessionService,
       challengeSolverService,
@@ -219,38 +236,57 @@ describe('Real Backend Integration - Web (Turnstile + Hashcash)', () => {
 
   it(
     'calls initSession on reinit - backend handles session reuse via cookie',
-    { timeout: 60000, retry: 2 },
+    { timeout: 60000, retry: 5 },
     async () => {
-      const autoInitService = createSessionInitializationService({
-        getSessionService: () => sessionService,
-        challengeSolverService,
-        performanceTracker: createMockPerformanceTracker(),
-        getIsSessionUpgradeAutoEnabled: () => true,
-      })
-
-      await autoInitService.initialize()
-
-      // Cookie should be set from first init
-      expect(cookieJar.has('x-session-id')).toBe(true)
-      const originalSessionId = cookieJar.get('x-session-id')
-
-      // Simulate page refresh - call initialize again
-      // Backend receives cookie and decides to reuse session
-      const reinitService = createSessionInitializationService({
-        getSessionService: () => sessionService,
-        challengeSolverService,
-        performanceTracker: createMockPerformanceTracker(),
-        getIsSessionUpgradeAutoEnabled: () => true,
-      })
-
-      await reinitService.initialize()
-
-      // Backend should reuse session - cookie remains the same
-      expect(cookieJar.get('x-session-id')).toBe(originalSessionId)
+      let lastError: unknown
+
+      // Re-run the full reinit flow from a clean cookie/session state when staging is unstable.
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          await sessionService.removeSession()
+          cookieJar.clear()
+          await sessionStorage.clear()
+
+          const autoInitService = createSessionInitializationService({
+            getSessionService: () => sessionService,
+            challengeSolverService,
+            performanceTracker: createMockPerformanceTracker(),
+            getIsSessionUpgradeAutoEnabled: () => true,
+          })
+
+          await autoInitService.initialize()
+
+          // Cookie should be set from first init
+          expect(cookieJar.has('x-session-id')).toBe(true)
+          const originalSessionId = cookieJar.get('x-session-id')
+
+          // Simulate page refresh - call initialize again
+          // Backend receives cookie and decides to reuse session
+          const reinitService = createSessionInitializationService({
+            getSessionService: () => sessionService,
+            challengeSolverService,
+            performanceTracker: createMockPerformanceTracker(),
+            getIsSessionUpgradeAutoEnabled: () => true,
+          })
+
+          await reinitService.initialize()
+
+          // Backend should reuse session - cookie remains the same
+          expect(cookieJar.get('x-session-id')).toBe(originalSessionId)
+          return
+        } catch (error) {
+          lastError = error
+          await sessionService.removeSession()
+          cookieJar.clear()
+          await sessionStorage.clear()
+        }
+      }
+
+      throw lastError instanceof Error ? lastError : new Error('Failed to verify cookie-based session reuse flow')
     },
   )
 
-  it('fires analytics callbacks during auto-upgrade flow', { timeout: 60000, retry: 2 }, async () => {
+  it('fires analytics callbacks during auto-upgrade flow', { timeout: 60000, retry: 5 }, async () => {
     const analytics = {
       onInitStarted: vi.fn(),
       onInitCompleted: vi.fn(),
@@ -351,7 +387,7 @@ describe.each(NON_WEB_PLATFORMS)(
       await luxIdentifierService.removeLuxIdentifier()
     })
 
-    it('initializes session with session ID and device ID stored locally', async () => {
+    it('initializes session with session ID and device ID stored locally', { timeout: 30000, retry: 5 }, async () => {
       const manualInitService = createSessionInitializationService({
         getSessionService: () => sessionService,
         challengeSolverService,
@@ -372,9 +408,9 @@ describe.each(NON_WEB_PLATFORMS)(
       // Device ID should also be returned and stored
       const storedDeviceId = await deviceIdService.getDeviceId()
       expect(storedDeviceId).toBeTruthy()
-    }, 30000)
+    })
 
-    it('receives Hashcash challenge directly (no Turnstile)', async () => {
+    it('receives Hashcash challenge directly (no Turnstile)', { timeout: 30000, retry: 5 }, async () => {
       const manualInitService = createSessionInitializationService({
         getSessionService: () => sessionService,
         challengeSolverService,
@@ -389,9 +425,9 @@ describe.each(NON_WEB_PLATFORMS)(
       // Non-web gets Hashcash directly (Turnstile is browser-only)
       expect(challenge.challengeType).toBe(ChallengeType.HASHCASH)
       expect(challenge.challengeId).toBeTruthy()
-    }, 30000)
+    })
 
-    it('successfully upgrades session with Hashcash', { timeout: 60000, retry: 2 }, async () => {
+    it('successfully upgrades session with Hashcash', { timeout: 60000, retry: 5 }, async () => {
       const manualInitService = createSessionInitializationService({
         getSessionService: () => sessionService,
         challengeSolverService,
@@ -422,7 +458,7 @@ describe.each(NON_WEB_PLATFORMS)(
       expect(hashcashResult.retry).toBe(false)
     })
 
-    it('completes auto-upgrade flow', { timeout: 60000, retry: 2 }, async () => {
+    it('completes auto-upgrade flow', { timeout: 60000, retry: 5 }, async () => {
       const autoInitService = createSessionInitializationService({
         getSessionService: () => sessionService,
         challengeSolverService,
@@ -440,7 +476,7 @@ describe.each(NON_WEB_PLATFORMS)(
 
     it(
       'calls initSession on reinit - backend handles session reuse via X-Session-ID header',
-      { timeout: 60000, retry: 2 },
+      { timeout: 60000, retry: 5 },
       async () => {
         // First: Complete auto-upgrade flow
         const autoInitService = createSessionInitializationService({

package/src/sessionLifecycle.integration.test.ts

@@ -8,23 +8,23 @@ import {
   SignoutResponse,
   UpdateSessionResponse,
   VerifyResponse,
-} from '@luxdex/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import { createSessionRepository } from '@luxfi/sessions/src/session-repository/createSessionRepository'
-import { createSessionService } from '@luxfi/sessions/src/session-service/createSessionService'
-import type { SessionService } from '@luxfi/sessions/src/session-service/types'
+} from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import { createSessionRepository } from '@luxexchange/sessions/src/session-repository/createSessionRepository'
+import { createSessionService } from '@luxexchange/sessions/src/session-service/createSessionService'
+import type { SessionService } from '@luxexchange/sessions/src/session-service/types'
 import {
   createMockSessionClient,
   InMemoryDeviceIdService,
   InMemorySessionStorage,
-  InMemoryLuxIdentifierService,
+  InMemoryLxIdentifierService,
   type MockEndpoints,
-} from '@luxfi/sessions/src/test-utils'
+} from '@luxexchange/sessions/src/test-utils'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 describe('Session Lifecycle Integration Tests', () => {
   let sessionStorage: InMemorySessionStorage
   let deviceIdService: InMemoryDeviceIdService
-  let luxIdentifierService: InMemoryLuxIdentifierService
+  let lxIdentifierService: InMemoryLxIdentifierService
   let sessionService: SessionService
   let mockEndpoints: MockEndpoints
 
@@ -32,42 +32,42 @@ describe('Session Lifecycle Integration Tests', () => {
     // Initialize in-memory storage
     sessionStorage = new InMemorySessionStorage()
     deviceIdService = new InMemoryDeviceIdService()
-    luxIdentifierService = new InMemoryLuxIdentifierService()
+    lxIdentifierService = new InMemoryLxIdentifierService()
 
     // Set up mock endpoints with default responses
     mockEndpoints = {
-      '/lux.platformservice.v1.SessionService/InitSession': async (): Promise<InitSessionResponse> => {
+      '/uniswap.platformservice.v1.SessionService/InitSession': async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: 'test-session-123',
           needChallenge: false,
           extra: {},
         })
       },
-      '/lux.platformservice.v1.SessionService/Challenge': async (): Promise<ChallengeResponse> => {
+      '/uniswap.platformservice.v1.SessionService/Challenge': async (): Promise<ChallengeResponse> => {
         return new ChallengeResponse({
           challengeId: 'challenge-123',
           challengeType: ChallengeType.TURNSTILE,
           extra: { sitekey: 'test-key' },
         })
       },
-      '/lux.platformservice.v1.SessionService/Verify': async (): Promise<VerifyResponse> => {
+      '/uniswap.platformservice.v1.SessionService/Verify': async (): Promise<VerifyResponse> => {
         return new VerifyResponse({
           retry: false,
         })
       },
-      '/lux.platformservice.v1.SessionService/DeleteSession': async (): Promise<DeleteSessionResponse> => {
+      '/uniswap.platformservice.v1.SessionService/DeleteSession': async (): Promise<DeleteSessionResponse> => {
         return new DeleteSessionResponse({})
       },
-      '/lux.platformservice.v1.SessionService/IntrospectSession': async (): Promise<IntrospectSessionResponse> => {
+      '/uniswap.platformservice.v1.SessionService/IntrospectSession': async (): Promise<IntrospectSessionResponse> => {
         return new IntrospectSessionResponse({})
       },
-      '/lux.platformservice.v1.SessionService/UpdateSession': async (): Promise<UpdateSessionResponse> => {
+      '/uniswap.platformservice.v1.SessionService/UpdateSession': async (): Promise<UpdateSessionResponse> => {
         return new UpdateSessionResponse({})
       },
-      '/lux.platformservice.v1.SessionService/GetChallengeTypes': async (): Promise<GetChallengeTypesResponse> => {
+      '/uniswap.platformservice.v1.SessionService/GetChallengeTypes': async (): Promise<GetChallengeTypesResponse> => {
         return new GetChallengeTypesResponse({ challengeTypes: [] })
       },
-      '/lux.platformservice.v1.SessionService/Signout': async (): Promise<SignoutResponse> => {
+      '/uniswap.platformservice.v1.SessionService/Signout': async (): Promise<SignoutResponse> => {
         return new SignoutResponse({})
       },
     }
@@ -84,7 +84,7 @@ describe('Session Lifecycle Integration Tests', () => {
     sessionService = createSessionService({
       sessionStorage,
       deviceIdService,
-      luxIdentifierService,
+      lxIdentifierService,
       sessionRepository,
     })
   })
@@ -111,7 +111,7 @@ describe('Session Lifecycle Integration Tests', () => {
 
   it('handles session initialization without challenge requirement', async () => {
     // Override default to return needChallenge: false
-    mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'] =
+    mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'] =
       async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: 'simple-session-123',
@@ -151,7 +151,7 @@ describe('Session Lifecycle Integration Tests', () => {
   })
 
   it('stores session ID when provided (mobile/extension behavior)', async () => {
-    mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'] =
+    mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'] =
       async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: 'mobile-session-123',
@@ -170,7 +170,7 @@ describe('Session Lifecycle Integration Tests', () => {
   })
 
   it('handles web sessions without storing session ID when undefined', async () => {
-    mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'] =
+    mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'] =
       async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: undefined,
@@ -216,7 +216,7 @@ describe('Session Lifecycle Integration Tests', () => {
     expect(firstSession?.sessionId).toBe('test-session-123')
 
     // Update mock to return different session
-    mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'] =
+    mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'] =
       async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: 'new-session-789',
@@ -233,7 +233,7 @@ describe('Session Lifecycle Integration Tests', () => {
   })
 
   it('sets and retrieves device ID through init response', async () => {
-    mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'] =
+    mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'] =
       async (): Promise<InitSessionResponse> => {
         return new InitSessionResponse({
           sessionId: 'device-test-session',

package/src/test-utils/createLocalCookieTransport.ts

@@ -14,7 +14,7 @@ export function createLocalCookieTransport(options: { baseUrl: string; cookieJar
     interceptors: [
       (next) => async (request) => {
         // Add required headers that backend expects
-        request.header.set('x-request-source', 'lux-web')
+        request.header.set('x-request-source', 'lx-web')
 
         // Simulate browser cookie behavior: add stored cookies to request
         if (cookieJar.size > 0) {

package/src/test-utils/createLocalHeaderTransport.ts

@@ -3,7 +3,7 @@ import { createConnectTransport } from '@connectrpc/connect-web'
 
 interface CreateLocalHeaderTransportOptions {
   baseUrl: string
-  requestSource: 'lux-ios' | 'lux-android' | 'lux-extension'
+  requestSource: 'lx-ios' | 'lx-android' | 'lx-extension'
   getSessionId: () => Promise<string | null>
   getDeviceId: () => Promise<string | null>
 }

package/src/test-utils/mocks.ts

@@ -1,6 +1,6 @@
-import type { ChallengeSolver, ChallengeSolverService } from '@luxfi/sessions/src/challenge-solvers/types'
-import type { SessionService } from '@luxfi/sessions/src/session-service/types'
-import { ChallengeType } from '@luxfi/sessions/src/session-service/types'
+import type { ChallengeSolver, ChallengeSolverService } from '@luxexchange/sessions/src/challenge-solvers/types'
+import type { SessionService } from '@luxexchange/sessions/src/session-service/types'
+import { ChallengeType } from '@luxexchange/sessions/src/session-service/types'
 import { vi } from 'vitest'
 
 /**