@luxexchange/sessions 1.0.1 → 1.0.3

package/src/session.integration.test.ts

@@ -1,24 +1,24 @@
-import { createChallengeSolverService } from '@universe/sessions/src/challenge-solvers/createChallengeSolverService'
-import { createHashcashSolver } from '@universe/sessions/src/challenge-solvers/createHashcashSolver'
-import { createNoneMockSolver } from '@universe/sessions/src/challenge-solvers/createNoneMockSolver'
-import { createTurnstileMockSolver } from '@universe/sessions/src/challenge-solvers/createTurnstileMockSolver'
-import type { PerformanceTracker } from '@universe/sessions/src/performance/types'
-import { createSessionInitializationService } from '@universe/sessions/src/session-initialization/createSessionInitializationService'
-import { createSessionClient } from '@universe/sessions/src/session-repository/createSessionClient'
-import { createSessionRepository } from '@universe/sessions/src/session-repository/createSessionRepository'
-import { createSessionService } from '@universe/sessions/src/session-service/createSessionService'
-import type { SessionService } from '@universe/sessions/src/session-service/types'
-import { ChallengeType } from '@universe/sessions/src/session-service/types'
+import { createChallengeSolverService } from '@luxexchange/sessions/src/challenge-solvers/createChallengeSolverService'
+import { createHashcashSolver } from '@luxexchange/sessions/src/challenge-solvers/createHashcashSolver'
+import { createNoneMockSolver } from '@luxexchange/sessions/src/challenge-solvers/createNoneMockSolver'
+import { createTurnstileMockSolver } from '@luxexchange/sessions/src/challenge-solvers/createTurnstileMockSolver'
+import type { PerformanceTracker } from '@luxexchange/sessions/src/performance/types'
+import { createSessionInitializationService } from '@luxexchange/sessions/src/session-initialization/createSessionInitializationService'
+import { createSessionClient } from '@luxexchange/sessions/src/session-repository/createSessionClient'
+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 { ChallengeType } from '@luxexchange/sessions/src/session-service/types'
 import {
   InMemoryDeviceIdService,
   InMemorySessionStorage,
   InMemoryLuxIdentifierService,
-} from '@universe/sessions/src/test-utils'
+} from '@luxexchange/sessions/src/test-utils'
 import {
   createCookieJar,
   createLocalCookieTransport,
-} from '@universe/sessions/src/test-utils/createLocalCookieTransport'
-import { createLocalHeaderTransport } from '@universe/sessions/src/test-utils/createLocalHeaderTransport'
+} from '@luxexchange/sessions/src/test-utils/createLocalCookieTransport'
+import { createLocalHeaderTransport } from '@luxexchange/sessions/src/test-utils/createLocalHeaderTransport'
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 // Mock performance tracker for testing
@@ -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'
 
 /**

package/src/test-utils.ts

@@ -17,30 +17,30 @@ import {
   type UpdateSessionResponse,
   type VerifyRequest,
   type VerifyResponse,
-} from '@luxdex/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import type { DeviceIdService } from '@luxfi/sessions/src/device-id/types'
-import type { SessionServiceClient } from '@luxfi/sessions/src/session-repository/createSessionClient'
-import type { SessionState, SessionStorage } from '@luxfi/sessions/src/session-storage/types'
-import type { LuxIdentifierService } from '@luxfi/sessions/src/lux-identifier/types'
+} from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import type { DeviceIdService } from '@luxexchange/sessions/src/device-id/types'
+import type { SessionServiceClient } from '@luxexchange/sessions/src/session-repository/createSessionClient'
+import type { SessionState, SessionStorage } from '@luxexchange/sessions/src/session-storage/types'
+import type { LxIdentifierService } from '@luxexchange/sessions/src/uniswap-identifier/types'
 // Types for our test transport
 export interface MockEndpointHandler {
   (request: any, headers: Record<string, string>): Promise<any>
 }
 
 export interface MockEndpoints {
-  '/lux.platformservice.v1.SessionService/InitSession': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/Challenge': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/Verify': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/IntrospectSession': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/UpdateSession': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/GetChallengeTypes': MockEndpointHandler
-  '/lux.platformservice.v1.SessionService/Signout': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/InitSession': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/Challenge': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/Verify': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/IntrospectSession': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/UpdateSession': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/GetChallengeTypes': MockEndpointHandler
+  '/uniswap.platformservice.v1.SessionService/Signout': MockEndpointHandler
 }
 
 // Test transport that intercepts requests and returns mock responses
 export function createTestTransport(mockEndpoints: MockEndpoints): ReturnType<typeof createConnectTransport> {
   return createConnectTransport({
-    baseUrl: 'https://test.api.lux.org',
+    baseUrl: 'https://test.api.lux.exchange',
     interceptors: [
       (_next) => async (request) => {
         const url = request.url
@@ -109,18 +109,18 @@ export class InMemoryDeviceIdService implements DeviceIdService {
   }
 }
 
-export class InMemoryLuxIdentifierService implements LuxIdentifierService {
+export class InMemoryLxIdentifierService implements LxIdentifierService {
   private identifier: string | null = null
 
-  async getLuxIdentifier(): Promise<string | null> {
+  async getLxIdentifier(): Promise<string | null> {
     return this.identifier
   }
 
-  async setLuxIdentifier(id: string): Promise<void> {
+  async setLxIdentifier(id: string): Promise<void> {
     this.identifier = id
   }
 
-  async removeLuxIdentifier(): Promise<void> {
+  async removeLxIdentifier(): Promise<void> {
     this.identifier = null
   }
 }
@@ -137,7 +137,7 @@ export function createMockSessionClient(
       request: PartialMessage<InitSessionRequest>,
       _options?: CallOptions,
     ): Promise<InitSessionResponse> => {
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/InitSession'](request, {})
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/InitSession'](request, {})
       return response as InitSessionResponse
     },
     challenge: async (
@@ -154,7 +154,7 @@ export function createMockSessionClient(
         headers['X-Device-ID'] = deviceId
       }
 
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/Challenge'](request, headers)
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/Challenge'](request, headers)
       return response as ChallengeResponse
     },
     verify: async (request: PartialMessage<VerifyRequest>, _options?: CallOptions): Promise<VerifyResponse> => {
@@ -168,32 +168,32 @@ export function createMockSessionClient(
         headers['X-Device-ID'] = deviceId
       }
 
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/Verify'](request, headers)
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/Verify'](request, headers)
       return response as VerifyResponse
     },
     introspectSession: async (
       request: PartialMessage<IntrospectSessionRequest>,
       _options?: CallOptions,
     ): Promise<IntrospectSessionResponse> => {
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/IntrospectSession'](request, {})
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/IntrospectSession'](request, {})
       return response as IntrospectSessionResponse
     },
     updateSession: async (
       request: PartialMessage<UpdateSessionRequest>,
       _options?: CallOptions,
     ): Promise<UpdateSessionResponse> => {
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/UpdateSession'](request, {})
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/UpdateSession'](request, {})
       return response as UpdateSessionResponse
     },
     getChallengeTypes: async (
       request: PartialMessage<GetChallengeTypesRequest>,
       _options?: CallOptions,
     ): Promise<GetChallengeTypesResponse> => {
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/GetChallengeTypes'](request, {})
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/GetChallengeTypes'](request, {})
       return response as GetChallengeTypesResponse
     },
     signout: async (request: PartialMessage<SignoutRequest>, _options?: CallOptions): Promise<SignoutResponse> => {
-      const response = await mockEndpoints['/lux.platformservice.v1.SessionService/Signout'](request, {})
+      const response = await mockEndpoints['/uniswap.platformservice.v1.SessionService/Signout'](request, {})
       return response as SignoutResponse
     },
   }

package/src/uniswap-identifier/createUniswapIdentifierService.ts

@@ -0,0 +1,19 @@
+import type { LxIdentifierService } from '@luxexchange/sessions/src/uniswap-identifier/types'
+
+function createLxIdentifierService(ctx: {
+  getLxIdentifier: () => Promise<string | null>
+  setLxIdentifier: (identifier: string) => Promise<void>
+  removeLxIdentifier: () => Promise<void>
+}): LxIdentifierService {
+  const getLxIdentifier = ctx.getLxIdentifier
+  const setLxIdentifier = ctx.setLxIdentifier
+  const removeLxIdentifier = ctx.removeLxIdentifier
+
+  return {
+    getLxIdentifier,
+    setLxIdentifier,
+    removeLxIdentifier,
+  }
+}
+
+export { createLxIdentifierService }