@l.x/prices 1.0.3 → 1.0.5

package/src/utils/tokenIdentifier.test.ts

@@ -0,0 +1,145 @@
+import { Ether, Token } from '@luxamm/sdk-core'
+import type { TokenIdentifier } from '@l.x/prices'
+import {
+  createPriceKey,
+  createPriceKeyFromToken,
+  filterValidTokens,
+  isCurrency,
+  isTokenIdentifier,
+  normalizeToken,
+  parsePriceKey,
+  toSubscriptionParams,
+} from '@l.x/prices'
+import { describe, expect, it } from 'vitest'
+
+const WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
+const USDC_ADDRESS = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+
+describe('tokenIdentifier utilities', () => {
+  describe('isCurrency', () => {
+    it('returns true for Token instances', () => {
+      const token = new Token(1, WETH_ADDRESS, 18, 'WETH', 'Wrapped Ether')
+      expect(isCurrency(token)).toBe(true)
+    })
+
+    it('returns false for TokenIdentifier', () => {
+      const identifier: TokenIdentifier = { chainId: 1, address: WETH_ADDRESS }
+      expect(isCurrency(identifier)).toBe(false)
+    })
+  })
+
+  describe('isTokenIdentifier', () => {
+    it('returns true for TokenIdentifier objects', () => {
+      const identifier: TokenIdentifier = { chainId: 1, address: WETH_ADDRESS }
+      expect(isTokenIdentifier(identifier)).toBe(true)
+    })
+
+    it('returns false for Token instances', () => {
+      const token = new Token(1, WETH_ADDRESS, 18, 'WETH', 'Wrapped Ether')
+      expect(isTokenIdentifier(token)).toBe(false)
+    })
+  })
+
+  describe('normalizeToken', () => {
+    it('normalizes TokenIdentifier with lowercase address', () => {
+      const identifier: TokenIdentifier = { chainId: 1, address: WETH_ADDRESS }
+      const result = normalizeToken(identifier)
+      expect(result).toEqual({
+        chainId: 1,
+        address: WETH_ADDRESS.toLowerCase(),
+      })
+    })
+
+    it('normalizes native currency to zero address', () => {
+      const eth = Ether.onChain(1)
+      const result = normalizeToken(eth)
+      expect(result).toEqual({
+        chainId: 1,
+        address: '0x0000000000000000000000000000000000000000',
+      })
+    })
+
+    it('normalizes Token instance', () => {
+      const token = new Token(1, WETH_ADDRESS, 18, 'WETH', 'Wrapped Ether')
+      const result = normalizeToken(token)
+      expect(result).toEqual({
+        chainId: 1,
+        address: WETH_ADDRESS.toLowerCase(),
+      })
+    })
+  })
+
+  describe('createPriceKey', () => {
+    it('creates key with format chainId-address', () => {
+      const key = createPriceKey(1, WETH_ADDRESS)
+      expect(key).toBe(`1-${WETH_ADDRESS.toLowerCase()}`)
+    })
+
+    it('lowercases address', () => {
+      const key = createPriceKey(1, '0xABC')
+      expect(key).toBe('1-0xabc')
+    })
+  })
+
+  describe('createPriceKeyFromToken', () => {
+    it('creates key from TokenIdentifier', () => {
+      const identifier: TokenIdentifier = { chainId: 1, address: WETH_ADDRESS }
+      const key = createPriceKeyFromToken(identifier)
+      expect(key).toBe(`1-${WETH_ADDRESS.toLowerCase()}`)
+    })
+
+    it('creates key from Token', () => {
+      const token = new Token(1, WETH_ADDRESS, 18, 'WETH', 'Wrapped Ether')
+      const key = createPriceKeyFromToken(token)
+      expect(key).toBe(`1-${WETH_ADDRESS.toLowerCase()}`)
+    })
+  })
+
+  describe('parsePriceKey', () => {
+    it('parses key back to TokenIdentifier', () => {
+      const key = `1-${WETH_ADDRESS.toLowerCase()}`
+      const result = parsePriceKey(key)
+      expect(result).toEqual({
+        chainId: 1,
+        address: WETH_ADDRESS.toLowerCase(),
+      })
+    })
+
+    it('returns null for missing address', () => {
+      expect(parsePriceKey('1')).toBeNull()
+    })
+
+    it('returns null for invalid chainId', () => {
+      expect(parsePriceKey('abc-0x123')).toBeNull()
+    })
+
+    it('returns null for empty key', () => {
+      expect(parsePriceKey('')).toBeNull()
+    })
+  })
+
+  describe('toSubscriptionParams', () => {
+    it('converts to subscription params format', () => {
+      const identifier: TokenIdentifier = { chainId: 1, address: WETH_ADDRESS }
+      const params = toSubscriptionParams(identifier)
+      expect(params).toEqual({
+        chainId: 1,
+        tokenAddress: WETH_ADDRESS.toLowerCase(),
+      })
+    })
+  })
+
+  describe('filterValidTokens', () => {
+    it('filters out invalid addresses', () => {
+      const tokens: TokenIdentifier[] = [
+        { chainId: 1, address: WETH_ADDRESS },
+        { chainId: 1, address: 'invalid' },
+        { chainId: 1, address: USDC_ADDRESS },
+      ]
+      const result = filterValidTokens(tokens)
+      expect(result).toHaveLength(2)
+      expect(result[0]?.address).toBe(WETH_ADDRESS.toLowerCase())
+      expect(result[1]?.address).toBe(USDC_ADDRESS.toLowerCase())
+    })
+  })
+})

package/src/utils/tokenIdentifier.ts

@@ -0,0 +1,111 @@
+import type { Currency, Token } from '@luxamm/sdk-core'
+import type { PriceKey, TokenIdentifier, TokenInput, TokenSubscriptionParams } from '@l.x/prices'
+import { isEVMAddress } from 'utilities/src/addresses/evm/evm'
+
+/** Address that represents native currencies on ETH, Arbitrum, etc. */
+const DEFAULT_NATIVE_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+/**
+ * Type guard to check if input is a Currency object (from @luxamm/sdk-core).
+ * Currency objects have isNative and isToken properties from the SDK.
+ */
+export function isCurrency(token: TokenInput): token is Currency {
+  return (
+    typeof token === 'object' &&
+    'chainId' in token &&
+    typeof (token as Currency).chainId === 'number' &&
+    // Currency from SDK always has isNative property (true for native, false for tokens)
+    'isNative' in token &&
+    typeof (token as Currency).isNative === 'boolean'
+  )
+}
+
+/**
+ * Type guard to check if input is a TokenIdentifier.
+ */
+export function isTokenIdentifier(token: TokenInput): token is TokenIdentifier {
+  return (
+    typeof token === 'object' &&
+    'chainId' in token &&
+    'address' in token &&
+    typeof (token as TokenIdentifier).chainId === 'number' &&
+    typeof (token as TokenIdentifier).address === 'string' &&
+    !('isNative' in token)
+  )
+}
+
+/**
+ * Normalizes any token input to a TokenIdentifier.
+ */
+export function normalizeToken(token: TokenInput): TokenIdentifier {
+  if (isTokenIdentifier(token)) {
+    return {
+      chainId: token.chainId,
+      address: token.address.toLowerCase(),
+    }
+  }
+
+  // It's a Currency
+  const currency = token as Currency
+  if (currency.isNative) {
+    return {
+      chainId: currency.chainId,
+      address: DEFAULT_NATIVE_ADDRESS,
+    }
+  }
+
+  // It's a Token
+  const tokenCurrency = currency as Token
+  return {
+    chainId: tokenCurrency.chainId,
+    address: tokenCurrency.address.toLowerCase(),
+  }
+}
+
+/**
+ * Creates a unique price key from chainId and address.
+ * Format matches CurrencyId convention: "chainId-address"
+ */
+export function createPriceKey(chainId: number, address: string): PriceKey {
+  return `${chainId}-${address.toLowerCase()}`
+}
+
+/**
+ * Creates a price key from a token input.
+ */
+export function createPriceKeyFromToken(token: TokenInput): PriceKey {
+  const { chainId, address } = normalizeToken(token)
+  return createPriceKey(chainId, address)
+}
+
+/**
+ * Parses a price key back to chainId and address.
+ * Returns null if the key is malformed (missing chainId or address).
+ */
+export function parsePriceKey(key: PriceKey): TokenIdentifier | null {
+  const [chainIdStr, address] = key.split('-')
+  const chainId = Number(chainIdStr)
+
+  if (Number.isNaN(chainId) || !address) {
+    return null
+  }
+
+  return { chainId, address }
+}
+
+/**
+ * Converts a TokenIdentifier to the format expected by the subscription API.
+ */
+export function toSubscriptionParams(token: TokenIdentifier): TokenSubscriptionParams {
+  return {
+    chainId: token.chainId,
+    tokenAddress: token.address.toLowerCase(),
+  }
+}
+
+/**
+ * Filters tokens to only those valid for subscription.
+ */
+export function filterValidTokens(tokens: TokenInput[]): TokenIdentifier[] {
+  return tokens.map(normalizeToken).filter((t) => isEVMAddress(t.address))
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "extends": "../../config/tsconfig/app.json",
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.json",
+    "src/global.d.ts"
+  ],
+  "exclude": [
+    "src/**/*.spec.ts",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.ts",
+    "src/**/*.test.tsx"
+  ],
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "types": ["node", "vitest/globals"],
+    "paths": {}
+  },
+  "references": [
+    {
+      "path": "../utilities"
+    },
+    {
+      "path": "../websocket"
+    },
+    {
+      "path": "../api"
+    },
+    {
+      "path": "../eslint-config"
+    }
+  ]
+}

package/tsconfig.lint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "preserveSymlinks": true
+  },
+  "include": ["**/*.ts", "**/*.tsx", "**/*.json"],
+  "exclude": ["node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    server: {
+      deps: {
+        inline: ['@tanstack/react-query', 'partysocket'],
+      },
+    },
+    coverage: {
+      exclude: [
+        '**/__generated__/**',
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/*.config.*',
+        '**/scripts/**',
+        '**/.eslintrc.*',
+      ],
+    },
+  },
+})

package/index.d.ts

@@ -1 +0,0 @@
-export * from '@luxexchange/prices';

package/index.js

@@ -1 +0,0 @@
-module.exports = require('@luxexchange/prices');