@l.x/sessions 1.0.4 → 1.0.5

package/LICENSE

@@ -0,0 +1,122 @@
+Lux Ecosystem License
+Version 1.2, December 2025
+
+Copyright (c) 2020-2025 Lux Industries Inc.
+All rights reserved.
+
+TECHNOLOGY PORTFOLIO - PATENT APPLICATIONS PLANNED
+Contact: licensing@lux.network
+
+================================================================================
+                          TERMS AND CONDITIONS
+================================================================================
+
+1. DEFINITIONS
+
+   "Lux Primary Network" means the official Lux blockchain with Network ID=1
+   and EVM Chain ID=96369.
+   
+   "Authorized Network" means the Lux Primary Network, official testnets/devnets,
+   and any L1/L2/L3 chain descending from the Lux Primary Network.
+   
+   "Descending Chain" means an L1/L2/L3 chain built on, anchored to, or deriving
+   security from the Lux Primary Network or its authorized testnets.
+   
+   "Research Use" means non-commercial academic research, education, personal
+   study, or evaluation purposes.
+   
+   "Commercial Use" means any use in connection with a product or service
+   offered for sale or fee, internal use by a for-profit entity, or any use
+   to generate revenue.
+
+2. GRANT OF LICENSE
+
+   Subject to these terms, Lux Industries Inc grants you a non-exclusive,
+   royalty-free license to:
+   
+   (a) Use for Research Use without restriction;
+   
+   (b) Operate on the Lux Primary Network (Network ID=1, EVM Chain ID=96369);
+   
+   (c) Operate on official Lux testnets and devnets;
+   
+   (d) Operate L1/L2/L3 chains descending from the Lux Primary Network;
+   
+   (e) Build applications within the Lux ecosystem;
+   
+   (f) Contribute improvements back to the original repositories.
+
+3. RESTRICTIONS
+
+   Without a commercial license from Lux Industries Inc, you may NOT:
+   
+   (a) Fork the Lux Network or any Lux software;
+   
+   (b) Create competing networks not descending from Lux Primary Network;
+   
+   (c) Use for Commercial Use outside the Lux ecosystem;
+   
+   (d) Sublicense or transfer rights outside the Lux ecosystem;
+   
+   (e) Use to create competing blockchain networks, exchanges, custody
+       services, or cryptographic systems outside the Lux ecosystem.
+
+4. NO FORKS POLICY
+
+   Lux Industries Inc maintains ZERO TOLERANCE for unauthorized forks.
+   Any fork or deployment on an unauthorized network constitutes:
+   
+   (a) Breach of this license;
+   (b) Grounds for immediate legal action.
+
+5. RIGHTS RESERVATION
+
+   All rights not explicitly granted are reserved by Lux Industries Inc.
+   
+   We plan to apply for patent protection for the technology in this
+   repository. Any implementation outside the Lux ecosystem may require
+   a separate commercial license.
+
+6. DISCLAIMER OF WARRANTY
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+7. LIMITATION OF LIABILITY
+
+   IN NO EVENT SHALL LUX INDUSTRIES INC BE LIABLE FOR ANY CLAIM, DAMAGES
+   OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE.
+
+8. TERMINATION
+
+   This license terminates immediately upon any breach, including but not
+   limited to deployment on unauthorized networks or creation of forks.
+
+9. GOVERNING LAW
+
+   This License shall be governed by the laws of the State of Delaware.
+
+10. COMMERCIAL LICENSING
+
+    For commercial use outside the Lux ecosystem:
+    
+    Lux Industries Inc.
+    Email: licensing@lux.network
+    Subject: Commercial License Request
+
+================================================================================
+                              TL;DR
+================================================================================
+
+- Research/academic use = OK
+- Lux Primary Network (Network ID=1, Chain ID=96369) = OK
+- L1/L2/L3 chains descending from Lux Primary Network = OK
+- Commercial products outside Lux ecosystem = Contact licensing@lux.network
+- Forks = Absolutely not
+
+================================================================================
+
+See LP-0012 for full licensing documentation:
+https://github.com/luxfi/lps/blob/main/LPs/lp-0012-ecosystem-licensing.md

package/package.json

@@ -1,19 +1,6 @@
 {
   "name": "@l.x/sessions",
-  "version": "1.0.4",
-  "scripts": {
-    "typecheck": "nx typecheck sessions",
-    "typecheck:tsgo": "nx typecheck:tsgo sessions",
-    "lint": "nx lint sessions",
-    "lint:fix": "nx lint:fix sessions",
-    "lint:biome": "nx lint:biome sessions",
-    "lint:biome:fix": "nx lint:biome:fix sessions",
-    "lint:eslint": "nx lint:eslint sessions",
-    "lint:eslint:fix": "nx lint:eslint:fix sessions",
-    "check:deps:usage": "nx check:deps:usage sessions",
-    "test": "nx test sessions",
-    "test:integration:backend": "nx test:integration:backend sessions"
-  },
+  "version": "1.0.5",
   "nx": {
     "includedScripts": []
   },
@@ -23,10 +10,10 @@
     "@noble/hashes": "2.0.1",
     "@scure/base": "2.0.0",
     "@tanstack/react-query": "5.90.20",
-    "@luxamm/client-platform-service": "0.0.118",
+    "@luxamm/client-platform-service": "0.0.119",
     "bidc": "0.0.3",
-    "@luxfi/utilities": "workspace:^",
-    "zod": "4.3.6"
+    "zod": "4.3.6",
+    "@luxfi/utilities": "^1.0.6"
   },
   "devDependencies": {
     "@edge-runtime/vm": "5.0.0",
@@ -34,16 +21,29 @@
     "@types/node": "22.13.1",
     "@types/react": "19.0.10",
     "@typescript/native-preview": "7.0.0-dev.20260311.1",
-    "@luxfi/eslint-config": "workspace:^",
     "@vitest/coverage-v8": "3.2.1",
     "depcheck": "1.4.7",
     "eslint": "8.57.1",
     "happy-dom": "20.0.10",
     "ts-morph": "23.0.0",
     "typescript": "5.8.3",
-    "vitest": "3.2.1"
+    "vitest": "3.2.1",
+    "@luxfi/eslint-config": "^1.0.6"
   },
   "main": "src/index.ts",
   "private": false,
-  "sideEffects": false
+  "sideEffects": false,
+  "scripts": {
+    "typecheck": "nx typecheck sessions",
+    "typecheck:tsgo": "nx typecheck:tsgo sessions",
+    "lint": "nx lint sessions",
+    "lint:fix": "nx lint:fix sessions",
+    "lint:biome": "nx lint:biome sessions",
+    "lint:biome:fix": "nx lint:biome:fix sessions",
+    "lint:eslint": "nx lint:eslint sessions",
+    "lint:eslint:fix": "nx lint:eslint:fix sessions",
+    "check:deps:usage": "nx check:deps:usage sessions",
+    "test": "nx test sessions",
+    "test:integration:backend": "nx test:integration:backend sessions"
+  }
 }

package/src/challengeFlow.integration.test.ts

@@ -23,7 +23,7 @@ import {
   createTestTransport,
   InMemoryDeviceIdService,
   InMemorySessionStorage,
-  InMemoryLxIdentifierService,
+  InMemoryLXIdentifierService,
   type MockEndpoints,
 } from '@l.x/sessions/src/test-utils'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -52,7 +52,7 @@ const mockTurnstileSolve = vi.fn()
 describe('Challenge Flow Integration Tests', () => {
   let sessionStorage: InMemorySessionStorage
   let deviceIdService: InMemoryDeviceIdService
-  let lxIdentifierService: InMemoryLxIdentifierService
+  let lxIdentifierService: InMemoryLXIdentifierService
   let sessionService: SessionService
   let sessionInitializationService: SessionInitializationService
   let mockEndpoints: MockEndpoints
@@ -61,7 +61,7 @@ describe('Challenge Flow Integration Tests', () => {
     // Initialize in-memory storage
     sessionStorage = new InMemorySessionStorage()
     deviceIdService = new InMemoryDeviceIdService()
-    lxIdentifierService = new InMemoryLxIdentifierService()
+    lxIdentifierService = new InMemoryLXIdentifierService()
 
     // Set up mock endpoints with default responses
     mockEndpoints = {

package/src/index.ts

@@ -12,9 +12,9 @@
 export { createDeviceIdService } from '@l.x/sessions/src/device-id/createDeviceIdService'
 export type { DeviceIdService } from '@l.x/sessions/src/device-id/types'
 // Lx Identifier
-export { createLxIdentifierService } from '@l.x/sessions/src/lx-identifier/createLxIdentifierService'
+export { createLXIdentifierService } from '@l.x/sessions/src/lx-identifier/createLXIdentifierService'
 export { lxIdentifierQuery } from '@l.x/sessions/src/lx-identifier/lxIdentifierQuery'
-export type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+export type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 // Session Repository
 export { createSessionRepository } from '@l.x/sessions/src/session-repository/createSessionRepository'
 export { ChallengeRejectedError } from '@l.x/sessions/src/session-repository/errors'
@@ -129,7 +129,7 @@ export { createNoopPerformanceTracker } from '@l.x/sessions/src/performance/crea
 export {
   InMemorySessionStorage,
   InMemoryDeviceIdService,
-  InMemoryLxIdentifierService,
+  InMemoryLXIdentifierService,
 } from '@l.x/sessions/src/test-utils'
 export {
   createCookieJar,

package/src/lx-identifier/createLXIdentifierService.ts

@@ -0,0 +1 @@
+export { createLXIdentifierService } from './createUniswapIdentifierService'

package/src/lx-identifier/createUniswapIdentifierService.ts

@@ -0,0 +1,19 @@
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-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 }

package/src/lx-identifier/lxIdentifierQuery.ts

@@ -0,0 +1 @@
+export { lxIdentifierQuery } from './uniswapIdentifierQuery'

package/src/lx-identifier/types.ts

@@ -0,0 +1,11 @@
+/**
+ * Lx Identifier provider interface
+ * Platform-specific implementations handle lx identifier persistence
+ */
+interface LXIdentifierService {
+  getLXIdentifier(): Promise<string | null>
+  setLXIdentifier(identifier: string): Promise<void>
+  removeLXIdentifier(): Promise<void>
+}
+
+export type { LXIdentifierService }

package/src/lx-identifier/uniswapIdentifierQuery.ts

@@ -0,0 +1,20 @@
+import { queryOptions } from '@tanstack/react-query'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import { ReactQueryCacheKey } from 'utilities/src/reactQuery/cache'
+import type { QueryOptionsResult } from 'utilities/src/reactQuery/queryOptions'
+
+type LXIdentifierQueryOptions = QueryOptionsResult<
+  string | null,
+  Error,
+  string | null,
+  [ReactQueryCacheKey.LXIdentifier]
+>
+
+export function lxIdentifierQuery(getService: () => LXIdentifierService): LXIdentifierQueryOptions {
+  return queryOptions({
+    queryKey: [ReactQueryCacheKey.LXIdentifier],
+    queryFn: async () => getService().getLXIdentifier(),
+    staleTime: Infinity,
+    gcTime: Infinity,
+  })
+}

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

@@ -3,14 +3,14 @@ import type { SessionRepository } from '@l.x/sessions/src/session-repository/typ
 import { createSessionService } from '@l.x/sessions/src/session-service/createSessionService'
 import type { SessionService } from '@l.x/sessions/src/session-service/types'
 import type { SessionStorage } from '@l.x/sessions/src/session-storage/types'
-import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 describe('createSessionService', () => {
   let storage: SessionStorage
   let repository: SessionRepository
   let deviceIdService: DeviceIdService
-  let lxIdentifierService: LxIdentifierService
+  let lxIdentifierService: LXIdentifierService
   let service: SessionService
 
   beforeEach(() => {
@@ -39,11 +39,11 @@ describe('createSessionService', () => {
 
     let lxIdentifierData: string | null = null
     lxIdentifierService = {
-      getLxIdentifier: async (): Promise<string | null> => lxIdentifierData,
-      setLxIdentifier: async (identifier: string): Promise<void> => {
+      getLXIdentifier: async (): Promise<string | null> => lxIdentifierData,
+      setLXIdentifier: async (identifier: string): Promise<void> => {
         lxIdentifierData = identifier
       },
-      removeLxIdentifier: async (): Promise<void> => {
+      removeLXIdentifier: async (): Promise<void> => {
         lxIdentifierData = null
       },
     }
@@ -339,7 +339,7 @@ describe('createSessionService', () => {
       })
 
       await service.initSession()
-      expect(await lxIdentifierService.getLxIdentifier()).toBe('71cef16f-4d99-4082-987c-a6f810f9ca7f')
+      expect(await lxIdentifierService.getLXIdentifier()).toBe('71cef16f-4d99-4082-987c-a6f810f9ca7f')
     })
 
     it('does not persist lxIdentifier when not provided', async () => {
@@ -354,7 +354,7 @@ describe('createSessionService', () => {
       })
 
       await service.initSession()
-      expect(await lxIdentifierService.getLxIdentifier()).toBeNull()
+      expect(await lxIdentifierService.getLXIdentifier()).toBeNull()
     })
 
     it('updates lxIdentifier on subsequent initSession calls', async () => {
@@ -369,7 +369,7 @@ describe('createSessionService', () => {
       })
 
       await service.initSession()
-      expect(await lxIdentifierService.getLxIdentifier()).toBe('first-identifier')
+      expect(await lxIdentifierService.getLXIdentifier()).toBe('first-identifier')
 
       repository.initSession = async (): Promise<{
         sessionId?: string
@@ -382,7 +382,7 @@ describe('createSessionService', () => {
       })
 
       await service.initSession()
-      expect(await lxIdentifierService.getLxIdentifier()).toBe('second-identifier')
+      expect(await lxIdentifierService.getLXIdentifier()).toBe('second-identifier')
     })
   })
 })

package/src/session-service/createSessionService.ts

@@ -9,7 +9,7 @@ import type {
   VerifySessionResponse,
 } from '@l.x/sessions/src/session-service/types'
 import type { SessionStorage } from '@l.x/sessions/src/session-storage/types'
-import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 
 /**
  * Creates a Session Service instance.
@@ -18,7 +18,7 @@ import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 export function createSessionService(ctx: {
   sessionStorage: SessionStorage
   deviceIdService: DeviceIdService
-  lxIdentifierService: LxIdentifierService
+  lxIdentifierService: LXIdentifierService
   sessionRepository: SessionRepository
 }): SessionService {
   async function initSession(): Promise<InitSessionResponse> {
@@ -30,7 +30,7 @@ export function createSessionService(ctx: {
       await ctx.deviceIdService.setDeviceId(result.deviceId)
     }
     if (result.extra['lxIdentifier']) {
-      await ctx.lxIdentifierService.setLxIdentifier(result.extra['lxIdentifier'])
+      await ctx.lxIdentifierService.setLXIdentifier(result.extra['lxIdentifier'])
     }
     return result
   }

package/src/sessionLifecycle.integration.test.ts

@@ -16,7 +16,7 @@ import {
   createMockSessionClient,
   InMemoryDeviceIdService,
   InMemorySessionStorage,
-  InMemoryLxIdentifierService,
+  InMemoryLXIdentifierService,
   type MockEndpoints,
 } from '@l.x/sessions/src/test-utils'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
@@ -24,7 +24,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 describe('Session Lifecycle Integration Tests', () => {
   let sessionStorage: InMemorySessionStorage
   let deviceIdService: InMemoryDeviceIdService
-  let lxIdentifierService: InMemoryLxIdentifierService
+  let lxIdentifierService: InMemoryLXIdentifierService
   let sessionService: SessionService
   let mockEndpoints: MockEndpoints
 
@@ -32,7 +32,7 @@ describe('Session Lifecycle Integration Tests', () => {
     // Initialize in-memory storage
     sessionStorage = new InMemorySessionStorage()
     deviceIdService = new InMemoryDeviceIdService()
-    lxIdentifierService = new InMemoryLxIdentifierService()
+    lxIdentifierService = new InMemoryLXIdentifierService()
 
     // Set up mock endpoints with default responses
     mockEndpoints = {

package/src/test-utils.ts

@@ -21,7 +21,7 @@ import {
 import type { DeviceIdService } from '@l.x/sessions/src/device-id/types'
 import type { SessionServiceClient } from '@l.x/sessions/src/session-repository/createSessionClient'
 import type { SessionState, SessionStorage } from '@l.x/sessions/src/session-storage/types'
-import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 // Types for our test transport
 export interface MockEndpointHandler {
   (request: any, headers: Record<string, string>): Promise<any>
@@ -109,18 +109,18 @@ export class InMemoryDeviceIdService implements DeviceIdService {
   }
 }
 
-export class InMemoryLxIdentifierService implements LxIdentifierService {
+export class InMemoryLXIdentifierService implements LXIdentifierService {
   private identifier: string | null = null
 
-  async getLxIdentifier(): Promise<string | null> {
+  async getLXIdentifier(): Promise<string | null> {
     return this.identifier
   }
 
-  async setLxIdentifier(id: string): Promise<void> {
+  async setLXIdentifier(id: string): Promise<void> {
     this.identifier = id
   }
 
-  async removeLxIdentifier(): Promise<void> {
+  async removeLXIdentifier(): Promise<void> {
     this.identifier = null
   }
 }

package/src/uniswap-identifier/createUniswapIdentifierService.ts

@@ -1,19 +1,19 @@
-import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-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
+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,
+    getLXIdentifier,
+    setLXIdentifier,
+    removeLXIdentifier,
   }
 }
 
-export { createLxIdentifierService }
+export { createLXIdentifierService }

package/src/uniswap-identifier/types.ts

@@ -2,10 +2,10 @@
  * Lx Identifier provider interface
  * Platform-specific implementations handle lx identifier persistence
  */
-interface LxIdentifierService {
-  getLxIdentifier(): Promise<string | null>
-  setLxIdentifier(identifier: string): Promise<void>
-  removeLxIdentifier(): Promise<void>
+interface LXIdentifierService {
+  getLXIdentifier(): Promise<string | null>
+  setLXIdentifier(identifier: string): Promise<void>
+  removeLXIdentifier(): Promise<void>
 }
 
-export type { LxIdentifierService }
+export type { LXIdentifierService }

package/src/uniswap-identifier/uniswapIdentifierQuery.ts

@@ -1,19 +1,19 @@
 import { queryOptions } from '@tanstack/react-query'
-import type { LxIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
+import type { LXIdentifierService } from '@l.x/sessions/src/lx-identifier/types'
 import { ReactQueryCacheKey } from 'utilities/src/reactQuery/cache'
 import type { QueryOptionsResult } from 'utilities/src/reactQuery/queryOptions'
 
-type LxIdentifierQueryOptions = QueryOptionsResult<
+type LXIdentifierQueryOptions = QueryOptionsResult<
   string | null,
   Error,
   string | null,
-  [ReactQueryCacheKey.LxIdentifier]
+  [ReactQueryCacheKey.LXIdentifier]
 >
 
-export function lxIdentifierQuery(getService: () => LxIdentifierService): LxIdentifierQueryOptions {
+export function lxIdentifierQuery(getService: () => LXIdentifierService): LXIdentifierQueryOptions {
   return queryOptions({
-    queryKey: [ReactQueryCacheKey.LxIdentifier],
-    queryFn: async () => getService().getLxIdentifier(),
+    queryKey: [ReactQueryCacheKey.LXIdentifier],
+    queryFn: async () => getService().getLXIdentifier(),
     staleTime: Infinity,
     gcTime: Infinity,
   })