@luxexchange/sessions 1.0.1 → 1.0.3

package/src/session-initialization/createSessionInitializationService.ts

@@ -1,10 +1,10 @@
-import type { ChallengeSolverService } from '@universe/sessions/src/challenge-solvers/types'
-import type { PerformanceTracker } from '@universe/sessions/src/performance/types'
+import type { ChallengeSolverService } from '@luxexchange/sessions/src/challenge-solvers/types'
+import type { PerformanceTracker } from '@luxexchange/sessions/src/performance/types'
 import {
   MaxChallengeRetriesError,
   NoSolverAvailableError,
-} from '@universe/sessions/src/session-initialization/sessionErrors'
-import type { SessionService } from '@universe/sessions/src/session-service/types'
+} from '@luxexchange/sessions/src/session-initialization/sessionErrors'
+import type { SessionService } from '@luxexchange/sessions/src/session-service/types'
 import type { Logger } from 'utilities/src/logger/logger'
 
 interface SessionInitResult {
@@ -61,22 +61,23 @@ function createSessionInitializationService(ctx: {
   /** Analytics callbacks for tracking session initialization lifecycle */
   analytics?: SessionInitAnalytics
 }): SessionInitializationService {
+  const log = ctx.getLogger?.()
+
   async function handleChallengeFlow(attemptCount = 0, flowStartTime?: number): Promise<void> {
     const startTime = flowStartTime ?? ctx.performanceTracker.now()
     const maxRetries = ctx.maxChallengeRetries ?? 3
 
     const challenge = await ctx.getSessionService().requestChallenge()
 
-    ctx.getLogger?.().debug('createSessionInitializationService', 'handleChallengeFlow', 'Requesting challenge', {
+    log?.debug('createSessionInitializationService', 'handleChallengeFlow', 'Requesting challenge', {
       challenge,
     })
 
     // Report challenge received (only on first attempt)
     if (attemptCount === 0) {
-      ctx.analytics?.onChallengeReceived?.({
-        challengeType: String(challenge.challengeType),
-        challengeId: challenge.challengeId,
-      })
+      const data = { challengeType: String(challenge.challengeType), challengeId: challenge.challengeId }
+      ctx.analytics?.onChallengeReceived?.(data)
+      log?.info('sessions', 'challengeReceived', 'Challenge received', data)
     }
 
     // get our solver for the challenge type
@@ -99,20 +100,16 @@ function createSessionInitializationService(ctx: {
         challengeData: challenge.challengeData,
       })
     } catch (solverError) {
-      ctx
-        .getLogger?.()
-        .warn(
-          'createSessionInitializationService',
-          'handleChallengeFlow',
-          'Solver failed, submitting placeholder solution to trigger fallback',
-          { error: solverError, challengeType: challenge.challengeType },
-        )
+      log?.warn(
+        'createSessionInitializationService',
+        'handleChallengeFlow',
+        'Solver failed, submitting placeholder solution to trigger fallback',
+        { error: solverError, challengeType: challenge.challengeType },
+      )
       solution = 'solver-failed'
     }
 
-    ctx
-      .getLogger?.()
-      .debug('createSessionInitializationService', 'handleChallengeFlow', 'Solved challenge', { solution })
+    log?.debug('createSessionInitializationService', 'handleChallengeFlow', 'Solved challenge', { solution })
 
     // Verify session with the solution
     const result = await ctx.getSessionService().verifySession({
@@ -121,23 +118,18 @@ function createSessionInitializationService(ctx: {
       challengeType: challenge.challengeType,
     })
 
+    const verifyData = {
+      success: !result.retry,
+      attemptNumber: attemptCount + 1,
+      totalDurationMs: ctx.performanceTracker.now() - startTime,
+    }
+    ctx.analytics?.onVerifyCompleted?.(verifyData)
+    log?.info('sessions', 'verifyCompleted', 'Verify completed', verifyData)
+
     if (!result.retry) {
-      // Verification was successful
-      ctx.analytics?.onVerifyCompleted?.({
-        success: true,
-        attemptNumber: attemptCount + 1,
-        totalDurationMs: ctx.performanceTracker.now() - startTime,
-      })
       return
     }
 
-    // Report retry (verification failed but will retry)
-    ctx.analytics?.onVerifyCompleted?.({
-      success: false,
-      attemptNumber: attemptCount + 1,
-      totalDurationMs: ctx.performanceTracker.now() - startTime,
-    })
-
     // Handle server retry request
     if (attemptCount >= maxRetries) {
       throw new MaxChallengeRetriesError(maxRetries, attemptCount + 1)
@@ -157,22 +149,21 @@ function createSessionInitializationService(ctx: {
       needChallenge = options.needChallenge
       sessionId = undefined
 
-      ctx.analytics?.onInitCompleted?.({
-        needChallenge,
-        durationMs: 0,
-      })
+      const data = { needChallenge, durationMs: 0 }
+      ctx.analytics?.onInitCompleted?.(data)
+      log?.info('sessions', 'initCompleted', 'Session init completed', data)
     } else {
       // Discover from backend
       ctx.analytics?.onInitStarted?.()
+      log?.info('sessions', 'initStarted', 'Session init started')
 
       const initResponse = await ctx.getSessionService().initSession()
       needChallenge = initResponse.needChallenge
       sessionId = initResponse.sessionId
 
-      ctx.analytics?.onInitCompleted?.({
-        needChallenge,
-        durationMs: ctx.performanceTracker.now() - initStartTime,
-      })
+      const data = { needChallenge, durationMs: ctx.performanceTracker.now() - initStartTime }
+      ctx.analytics?.onInitCompleted?.(data)
+      log?.info('sessions', 'initCompleted', 'Session init completed', data)
     }
 
     // Handle challenge if required and enabled

package/src/session-repository/createSessionClient.ts

@@ -1,5 +1,5 @@
 import { createPromiseClient, type PromiseClient, type Transport } from '@connectrpc/connect'
-import { SessionService } from '@luxdex/client-platform-service/dist/uniswap/platformservice/v1/sessionService_connect'
+import { SessionService } from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_connect'
 
 type SessionServiceClient = PromiseClient<typeof SessionService>
 

package/src/session-repository/createSessionRepository.test.ts

@@ -1,5 +1,5 @@
 import type { PromiseClient } from '@connectrpc/connect'
-import type { SessionService } from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_connect'
+import type { SessionService } from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_connect'
 import {
   ChallengeFailure,
   ChallengeFailure_Reason,
@@ -7,10 +7,10 @@ import {
   GetChallengeTypesResponse,
   InitSessionResponse,
   SignoutResponse,
-} from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import { createSessionRepository } from '@universe/sessions/src/session-repository/createSessionRepository'
-import { ChallengeRejectedError } from '@universe/sessions/src/session-repository/errors'
-import { ChallengeType } from '@universe/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 { ChallengeRejectedError } from '@luxexchange/sessions/src/session-repository/errors'
+import { ChallengeType } from '@luxexchange/sessions/src/session-service/types'
 import { describe, expect, it, type MockedFunction, vi } from 'vitest'
 
 type MockedClient = {

package/src/session-repository/createSessionRepository.ts

@@ -1,18 +1,18 @@
 import {
   ChallengeFailure_Reason,
   VerifyFailure_Reason,
-} from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import type { SessionServiceClient } from '@universe/sessions/src/session-repository/createSessionClient'
-import { ChallengeRejectedError } from '@universe/sessions/src/session-repository/errors'
-import type { SessionRepository, TypedChallengeData } from '@universe/sessions/src/session-repository/types'
-import { ChallengeFailureReason, VerifyFailureReason } from '@universe/sessions/src/session-repository/types'
+} from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import type { SessionServiceClient } from '@luxexchange/sessions/src/session-repository/createSessionClient'
+import { ChallengeRejectedError } from '@luxexchange/sessions/src/session-repository/errors'
+import type { SessionRepository, TypedChallengeData } from '@luxexchange/sessions/src/session-repository/types'
+import { ChallengeFailureReason, VerifyFailureReason } from '@luxexchange/sessions/src/session-repository/types'
 import type { Logger } from 'utilities/src/logger/logger'
 
 /**
  * Creates a session repository that handles communication with the session service.
  * This is the layer that makes actual API calls to the backend.
  *
- * TODO(proto): `VerifyResponse` in `@uniswap/client-platform-service` still has a proto3
+ * TODO(proto): `VerifyResponse` in `@luxamm/client-platform-service` still has a proto3
  * issue where an empty `VerifySuccess` message gets silently dropped, leaving
  * `outcome.case === undefined`. The `verifySession()` method works around this by using
  * the `retry` flag as a discriminator.
@@ -23,7 +23,7 @@ import type { Logger } from 'utilities/src/logger/logger'
 function createSessionRepository(ctx: { client: SessionServiceClient; getLogger?: () => Logger }): SessionRepository {
   const initSession: SessionRepository['initSession'] = async () => {
     try {
-      const response = await ctx.client['initSession']({})
+      const response = await ctx.client.initSession({})
 
       return {
         sessionId: response.sessionId,
@@ -39,7 +39,7 @@ function createSessionRepository(ctx: { client: SessionServiceClient; getLogger?
 
   const challenge: SessionRepository['challenge'] = async (request) => {
     try {
-      const response = await ctx.client['challenge']({
+      const response = await ctx.client.challenge({
         challengeType: request.challengeType,
         identifier: request.identifier,
       })
@@ -140,7 +140,7 @@ function createSessionRepository(ctx: { client: SessionServiceClient; getLogger?
 
   const verifySession: SessionRepository['verifySession'] = async (request) => {
     try {
-      const response = await ctx.client['verify']({
+      const response = await ctx.client.verify({
         solution: request.solution,
         challengeId: request.challengeId,
         type: request.challengeType,
@@ -209,7 +209,7 @@ function createSessionRepository(ctx: { client: SessionServiceClient; getLogger?
   const deleteSession: SessionRepository['deleteSession'] = async () => {
     try {
       // Proto renamed deleteSession to signout
-      await ctx.client['signout']({})
+      await ctx.client.signout({})
       return {}
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
@@ -219,10 +219,10 @@ function createSessionRepository(ctx: { client: SessionServiceClient; getLogger?
 
   const getChallengeTypes: SessionRepository['getChallengeTypes'] = async () => {
     try {
-      const response = await ctx.client['getChallengeTypes']({})
-      return response.challengeTypeConfig.map((cfg: { type: number; config: Record<string, string> }) => ({
-        type: cfg.type,
-        config: cfg.config,
+      const response = await ctx.client.getChallengeTypes({})
+      return response.challengeTypeConfig.map((config) => ({
+        type: config.type,
+        config: config.config,
       }))
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)

package/src/session-repository/errors.ts

@@ -1,4 +1,4 @@
-import { SessionError } from '@universe/sessions/src/session-initialization/sessionErrors'
+import { SessionError } from '@luxexchange/sessions/src/session-initialization/sessionErrors'
 
 /**
  * Error thrown when the Entry Gateway rejects a challenge request.

package/src/session-repository/types.ts

@@ -1,4 +1,4 @@
-import { ChallengeType } from '@luxdex/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import { ChallengeType } from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
 
 /**
  * Typed challenge data for Turnstile bot detection

package/src/session-service/createNoopSessionService.ts

@@ -1,5 +1,5 @@
-import { ChallengeType } from '@luxdex/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import type { SessionService } from '@luxfi/sessions/src/session-service/types'
+import { ChallengeType } from '@luxamm/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import type { SessionService } from '@luxexchange/sessions/src/session-service/types'
 
 function createNoopSessionService(): SessionService {
   const initSession: SessionService['initSession'] = async () => ({ needChallenge: false, extra: {} })

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

@@ -1,5 +1,5 @@
-import type { DeviceIdService } from '@universe/sessions/src/device-id/types'
-import type { SessionRepository } from '@universe/sessions/src/session-repository/types'
+import type { DeviceIdService } from '@luxexchange/sessions/src/device-id/types'
+import type { SessionRepository } from '@luxexchange/sessions/src/session-repository/types'
 import type {
   ChallengeRequest,
   ChallengeResponse,
@@ -7,9 +7,9 @@ import type {
   SessionService,
   VerifySessionRequest,
   VerifySessionResponse,
-} from '@universe/sessions/src/session-service/types'
-import type { SessionStorage } from '@universe/sessions/src/session-storage/types'
-import type { LuxIdentifierService } from '@universe/sessions/src/lux-identifier/types'
+} 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'
 
 /**
  * Creates a Session Service instance.
@@ -18,7 +18,7 @@ import type { LuxIdentifierService } from '@universe/sessions/src/lux-identifier
 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,6 +1,6 @@
-import { ChallengeType } from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
-import type { TypedChallengeData } from '@universe/sessions/src/session-repository/types'
-import { SessionState } from '@universe/sessions/src/session-storage/types'
+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'
 
 interface InitSessionResponse {
   sessionId?: string

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.