@luxexchange/lx 1.0.0

package/src/utils/addresses.ts

@@ -0,0 +1,213 @@
+import { getAddress } from '@ethersproject/address'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { chainIdToPlatform } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import { isEVMAddress } from '@luxfi/utilities/src/addresses/evm/evm'
+import { HexString } from '@luxfi/utilities/src/addresses/hex'
+import { isSVMAddress } from '@luxfi/utilities/src/addresses/svm/svm'
+import { tryCatch } from '@luxfi/utilities/src/errors'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+export enum AddressStringFormat {
+  Lowercase = 0,
+  Uppercase = 1,
+  Shortened = 2,
+}
+
+type GetValidAddressParams = {
+  address: Maybe<string>
+  withEVMChecksum?: boolean
+  log?: boolean
+} & (
+  | {
+      platform: Platform
+      chainId?: never
+    }
+  | {
+      platform?: never
+      chainId: UniverseChainId
+    }
+)
+
+const VALIDATION_CACHE_KEY_FN_MAP = {
+  [Platform.EVM]: (params: GetValidAddressParams) =>
+    `${Platform.EVM}-${params.address}-${Boolean(params.withEVMChecksum)}`,
+  [Platform.SVM]: (params: GetValidAddressParams) => `${Platform.SVM}-${params.address}`,
+} as const
+
+const ADDRESS_VALIDATION_CACHE = new Map<string, string | null>()
+
+function getCachedAddress(params: GetValidAddressParams): {
+  cachedAddress: string | null | undefined
+  cacheKey: string
+} {
+  const platform = params.platform ?? chainIdToPlatform(params.chainId)
+
+  const cacheKey = VALIDATION_CACHE_KEY_FN_MAP[platform](params)
+  return { cachedAddress: ADDRESS_VALIDATION_CACHE.get(cacheKey), cacheKey }
+}
+
+const VALIDATION_FN_MAP = {
+  [Platform.EVM]: getValidEVMAddress,
+  [Platform.SVM]: getValidSVMAddress,
+} as const
+
+/**
+ * Validates an EVM or SVM address and returns the normalized address. EVM addresses will be lowercased or checksummed depending on the `withEVMChecksum` field.
+ *
+ * FOR EVM ADDRESSES:
+ * When withEVMChecksum === true, this method performs a checksum on the address. Please, use only for validating user input.
+ * When withEVMChecksum === false, it checks: length === 42 and startsWith('0x') and returns a lowercased address.
+ *
+ * FOR SVM ADDRESSES:
+ * withEVMChecksum is ignored. SVM does not have checksum; addresses are validated to ensure they are 32 byte base58 strings.
+ *
+ * @param address The address to validate and normalize
+ * @param withEVMChecksum Whether to perform a checksum on the address if it is an EVM address
+ * @param platform The blockchain platform of the address, determines what validation is performed
+ * @param log If logging is enabled in case of errors
+ *
+ * @returns The normalized address or false if the address is invalid
+ */
+export function getValidAddress(params: GetValidAddressParams): Nullable<HexString | string> {
+  const { address, withEVMChecksum, log } = params
+  if (!address) {
+    return null
+  }
+
+  const platform = params.platform ?? chainIdToPlatform(params.chainId)
+
+  const { cachedAddress, cacheKey } = getCachedAddress(params)
+  if (cachedAddress !== undefined) {
+    return cachedAddress
+  }
+
+  const { data: result, error } = tryCatch(() => VALIDATION_FN_MAP[platform]({ address, withEVMChecksum }))
+  if (error && log) {
+    logger.warn('utils/addresses', 'getValidAddress', (error as Error).message, {
+      data: address,
+      stacktrace: new Error().stack,
+    })
+  }
+
+  ADDRESS_VALIDATION_CACHE.set(cacheKey, result)
+  return result
+}
+
+/**
+ * Validates an EVM address and returns the normalized address.
+ *
+ * @param address The address to validate and normalize
+ * @param withEVMChecksum Whether to perform a checksum on the address
+ * @returns The normalized address or null if the address is invalid
+ * @throws {Error} If the address is invalid
+ */
+function getValidEVMAddress({ address, withEVMChecksum }: { address: string; withEVMChecksum?: boolean }): HexString {
+  const addressWith0x = ensureLeading0x(address.trim())
+
+  if (withEVMChecksum) {
+    return getAddress(addressWith0x) as HexString
+  }
+
+  if (!isEVMAddress(addressWith0x)) {
+    throw new Error('Address has an invalid format')
+  }
+  return normalizeAddress(addressWith0x, AddressStringFormat.Lowercase) as HexString
+}
+
+/**
+ * Validates a Solana address and returns the normalized address.
+ *
+ * @param address The address to validate and normalize
+ * @returns The input address, if it is a valid SVM address (32 byte base58 string)
+ * @throws {Error} If the address is invalid
+ */
+function getValidSVMAddress({ address }: { address: string }): string {
+  if (!isSVMAddress(address)) {
+    throw new Error('Address has an invalid format')
+  }
+
+  return address
+}
+
+/**
+ * Normalizes an address given a format
+ *
+ * **Note**: To get the checksum address please, use {@link getValidAddress(address, true)}
+ *
+ * @param address
+ * @param format One of AddressStringFormat
+ * @returns the normalized address
+ */
+export function normalizeAddress(address: Address, format: AddressStringFormat): Address {
+  switch (format) {
+    case AddressStringFormat.Lowercase:
+      return address.toLowerCase()
+    case AddressStringFormat.Uppercase:
+      return address.toUpperCase()
+    case AddressStringFormat.Shortened:
+      return address.substr(0, 8)
+    default:
+      throw new Error(`Invalid AddressStringFormat: ${format}`)
+  }
+}
+
+/**
+ * Replaces any instance of 'x' letter in address string with an added zero-width-space invisible character
+ * this is done to solve an issue with the Inter font where an 'x' character between to numbers will be replaced as a muliplication sign
+ *
+ * @param address Address to sanitize
+ * @returns Sanitized address string
+ */
+export function sanitizeAddressText(address?: string): Maybe<string> {
+  const zws = '\u{200b}' // Zero-width space unicode
+  return address?.replace('x', `x${zws}`)
+}
+
+type AddressInput =
+  | {
+      address: Maybe<string>
+      chainId: UniverseChainId
+      platform?: never
+    }
+  | {
+      address: Maybe<string>
+      chainId?: never
+      platform: Platform
+    }
+
+type AreAddressesEqualParams = {
+  addressInput1: AddressInput
+  addressInput2: AddressInput
+}
+
+export function areAddressesEqual(params: AreAddressesEqualParams): boolean {
+  const { addressInput1, addressInput2 } = params
+  const platform1 = addressInput1.platform ?? chainIdToPlatform(addressInput1.chainId)
+  const platform2 = addressInput2.platform ?? chainIdToPlatform(addressInput2.chainId)
+
+  if (platform1 !== platform2) {
+    return false
+  }
+
+  // Solana addresses are Base58 encoded, so they are case-sensitive. Can compare strings directly.
+  if (addressInput1.address === addressInput2.address) {
+    return true
+  }
+
+  if (platform1 === Platform.EVM) {
+    return (
+      normalizeAddress(addressInput1.address ?? '', AddressStringFormat.Lowercase) ===
+      normalizeAddress(addressInput2.address ?? '', AddressStringFormat.Lowercase)
+    )
+  }
+
+  return false
+}
+
+/**
+ * Prepend '0x' if the input address does not start with '0x'/'0X'
+ */
+export function ensureLeading0x(input: Address): Address {
+  return input.startsWith('0x') || input.startsWith('0X') ? input : `0x${input}`
+}

package/src/utils/approvals.test.ts

@@ -0,0 +1,40 @@
+import { MaxUint256 } from '@luxfi/amm-core'
+import { parseERC20ApproveCalldata } from '@luxexchange/lx/src/utils/approvals'
+
+describe(parseERC20ApproveCalldata, () => {
+  it('Returns proper address and amount for max spend', () => {
+    const calldata =
+      '0x095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+
+    MaxUint256.toString(16)
+
+    const { amount, spender } = parseERC20ApproveCalldata(calldata)
+
+    expect(amount.toString()).toEqual(MaxUint256.toString())
+    expect(spender).toEqual('0x000000000022d473030f116ddee9f6b43ac78ba3')
+  })
+
+  it('Returns proper address and amount for non-max spend', () => {
+    const calldata =
+      '0x095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba30000000000000000000000000000000000000000000000000000000000000001'
+
+    MaxUint256.toString(16)
+
+    const { amount, spender } = parseERC20ApproveCalldata(calldata)
+
+    expect(amount.toString()).toEqual('1')
+    expect(spender).toEqual('0x000000000022d473030f116ddee9f6b43ac78ba3')
+  })
+
+  it('Returns proper address and amount for 0 spend', () => {
+    const calldata =
+      '0x095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba30000000000000000000000000000000000000000000000000000000000000000'
+
+    MaxUint256.toString(16)
+
+    const { amount, spender } = parseERC20ApproveCalldata(calldata)
+
+    expect(amount.toString()).toEqual('0')
+    expect(spender).toEqual('0x000000000022d473030f116ddee9f6b43ac78ba3')
+  })
+})

package/src/utils/approvals.ts

@@ -0,0 +1,13 @@
+type ERC20ApprovalTransactionParts = {
+  /** The amount approved for spend */
+  amount: bigint
+  /** The address approved for spend */
+  spender: string
+}
+
+export function parseERC20ApproveCalldata(data: string): ERC20ApprovalTransactionParts {
+  const amount = BigInt(`0x${data.slice(-64)}`) // length of a uint256
+  const spender = `0x${data.slice(-104, -64)}` // length of an address
+
+  return { amount, spender }
+}

package/src/utils/balances.ts

@@ -0,0 +1,14 @@
+import { PortfolioBalance } from '@luxexchange/lx/src/features/dataApi/types'
+import { portfolioBalances } from '@luxexchange/lx/src/test/fixtures'
+
+export function portfolioBalancesById(inputBalances?: PortfolioBalance[]): Record<string, PortfolioBalance> {
+  const balances = inputBalances ?? portfolioBalances()
+
+  return balances.reduce(
+    (acc, balance) => {
+      acc[balance.currencyInfo.currencyId] = balance
+      return acc
+    },
+    {} as Record<string, PortfolioBalance>,
+  )
+}

package/src/utils/clipboard.native.ts

@@ -0,0 +1,71 @@
+import * as ExpoClipboard from 'expo-clipboard'
+import { IClipboard } from '@luxfi/utilities/src/clipboard/clipboard'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+const Clipboard: IClipboard = {
+  setClipboard: async (value: string) => {
+    try {
+      await ExpoClipboard.setStringAsync(value)
+    } catch (error) {
+      logger.error(error, { tags: { file: 'clipboard', function: 'setClipboard' } })
+    }
+  },
+  getClipboard: async () => {
+    try {
+      const value = await ExpoClipboard.getStringAsync()
+      return value
+    } catch (error) {
+      logger.error(error, { tags: { file: 'clipboard', function: 'getClipboard' } })
+      return undefined
+    }
+  },
+  setClipboardImage: async (imageUrl: string | undefined) => {
+    if (!imageUrl) {
+      return
+    }
+    try {
+      // fetch image blob from remote source
+      const res = await fetch(imageUrl)
+      const blob = await res.blob()
+
+      // convert to base64 required for clipboard
+      const base64Encoding = await blobToBase64(blob)
+
+      // extract base64 encoding from result string
+      const formattedEncoding = typeof base64Encoding === 'string' ? base64Encoding.split(',')[1] : null
+
+      // if valid result, copy to clipboard
+      if (formattedEncoding) {
+        await ExpoClipboard.setImageAsync(formattedEncoding)
+      }
+    } catch (error) {
+      logger.error(error, {
+        tags: { file: 'clipboard', function: 'setClipboardImage' },
+        extra: { imageUrl },
+      })
+    }
+  },
+} as IClipboard
+
+// Convert image data blob to base64 encoding
+function blobToBase64(blob: Blob): Promise<ArrayBuffer | string | null> {
+  const reader = new FileReader()
+  reader.readAsDataURL(blob)
+  return new Promise((resolve) => {
+    reader.onloadend = (): void => {
+      resolve(reader.result)
+    }
+  })
+}
+
+export function setClipboard(value: string): Promise<void> {
+  return Clipboard.setClipboard(value)
+}
+
+export function getClipboard(): Promise<string | void> {
+  return Clipboard.getClipboard()
+}
+
+export function setClipboardImage(imageUrl: string | undefined): Promise<void> {
+  return Clipboard.setClipboardImage(imageUrl)
+}

package/src/utils/clipboard.ts

@@ -0,0 +1,34 @@
+import { PlatformSplitStubError } from '@luxfi/utilities/src/errors'
+
+/** Dummy clipboard class. Overridden by mobile or extension related code. */
+
+export interface IClipboard {
+  setClipboard(value: string): Promise<void>
+  getClipboard(): Promise<string | void>
+  setClipboardImage(imageUrl: string | undefined): Promise<void>
+}
+
+/** This will be overridden by the compiler with platform-specific clipboard file. */
+const Clipboard: IClipboard = {
+  setClipboard: () => {
+    throw new PlatformSplitStubError('setClipboard')
+  },
+  getClipboard: () => {
+    throw new PlatformSplitStubError('getClipboard')
+  },
+  setClipboardImage: () => {
+    throw new PlatformSplitStubError('setClipboardImage')
+  },
+}
+
+export async function setClipboard(value: string): Promise<void> {
+  return Clipboard.setClipboard(value)
+}
+
+export async function getClipboard(): Promise<string | void> {
+  return Clipboard.getClipboard()
+}
+
+export async function setClipboardImage(imageUrl: string | undefined): Promise<void> {
+  return Clipboard.setClipboardImage(imageUrl)
+}

package/src/utils/cloud-backup/getCloudProviderName.native.ts

@@ -0,0 +1,12 @@
+import { Platform } from 'react-native'
+
+export function getCloudProviderName(): string {
+  switch (Platform.OS) {
+    case 'android':
+      return 'Google Drive'
+    case 'ios':
+      return 'iCloud'
+    default:
+      return ''
+  }
+}

package/src/utils/cloud-backup/getCloudProviderName.ts

@@ -0,0 +1,8 @@
+import { isAndroid } from '@luxfi/utilities/src/platform'
+
+export function getCloudProviderName(): string {
+  if (isAndroid) {
+    return 'Google Drive'
+  }
+  return 'iCloud'
+}

package/src/utils/colors.test.ts

@@ -0,0 +1,31 @@
+import { colorsLight } from '@luxfi/ui/src/theme'
+import { AdjustmentType, adjustColorVariant, findNearestThemeColor, getColorDiffScore } from '@luxexchange/lx/src/utils/colors'
+
+describe('adjustColorVariant', () => {
+  it('handles undefined', () => {
+    expect(adjustColorVariant(undefined, AdjustmentType.Lighten)).toEqual(undefined)
+  })
+
+  it('lightens color', () => {
+    expect(adjustColorVariant('bluePastel', AdjustmentType.Lighten)).toEqual('blueLight')
+  })
+
+  it('darkens color', () => {
+    expect(adjustColorVariant('blueVibrant', AdjustmentType.Darken)).toEqual('blueDark')
+  })
+})
+
+describe('findNearestThemeColor', () => {
+  it('Finds correct theme color for color in theme', () => {
+    expect(findNearestThemeColor(colorsLight.statusSuccess)).toEqual('greenBase')
+  })
+})
+
+describe('getColorDiffScore', () => {
+  it('returns 1 for same color', () => {
+    expect(getColorDiffScore('#000000', '#000000')).toEqual(1)
+  })
+  it('returns max for opposite color', () => {
+    expect(getColorDiffScore('#000000', '#ffffff')).toEqual(442.6729559300637)
+  })
+})

package/src/utils/colors.tsx

@@ -0,0 +1,127 @@
+import { useMemo } from 'react'
+import { useExtractedColors, useSporeColors } from '@luxfi/ui/src'
+import { GlobalColorNames, colors as GlobalColors, GlobalPalette, opacify } from '@luxfi/ui/src/theme'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { assert } from '@luxfi/utilities/src/errors'
+import { hexToRGB } from '@luxfi/utilities/src/theme/colors'
+
+export function getNetworkColorKey(chainId: UniverseChainId): `chain_${UniverseChainId}` {
+  return `chain_${chainId}`
+}
+
+/** Helper to retrieve foreground and background colors for a given chain */
+export function useNetworkColors(chainId: UniverseChainId): {
+  foreground: string
+  background: string
+} {
+  const colors = useSporeColors()
+  const color = colors[getNetworkColorKey(chainId)].val
+
+  const foreground = color
+  assert(foreground, 'Network color is not defined in Theme')
+
+  return {
+    foreground,
+    background: opacify(10, foreground),
+  }
+}
+
+/**
+ * @param uri image uri
+ * @returns Extracts background color from image uri and finds closest theme colors.
+ * Returns colors as raw hex code strings.
+ */
+export function useNearestThemeColorFromImageUri(uri: string | undefined): {
+  color: string | undefined
+  colorDark: string | undefined
+  colorLight: string | undefined
+} {
+  // extract color from image
+  const { colors: extractedImageColor } = useExtractedColors(uri, { colorStrategy: 'muted', fallback: 'accent1' })
+
+  // find nearest theme color and convert to darkest version from theme
+  return useMemo(() => {
+    if (!extractedImageColor?.base) {
+      return { color: undefined, colorDark: undefined, colorLight: undefined }
+    }
+    const color = findNearestThemeColor(extractedImageColor.base)
+    const colorDark = adjustColorVariant(color, AdjustmentType.Darken)
+    const colorLight = adjustColorVariant(color, AdjustmentType.Lighten)
+    return {
+      color: color ? GlobalColors[color] : undefined,
+      colorDark: colorDark ? GlobalColors[colorDark] : undefined,
+      colorLight: colorLight ? GlobalColors[colorLight] : undefined,
+    }
+  }, [extractedImageColor])
+}
+
+export enum AdjustmentType {
+  Darken = 'darken',
+  Lighten = 'lighten',
+}
+
+const colorPostfixes = ['Light', 'Pastel', 'Base', 'Vibrant', 'Dark']
+
+/**
+ * Replaces a GlobalPalette color variant with a dark or lighter version.
+ * Example: blue200 -> blue900
+ */
+export function adjustColorVariant(
+  colorName: GlobalColorNames | undefined,
+  adjustmentType: AdjustmentType,
+): keyof GlobalPalette | undefined {
+  if (!colorName) {
+    return undefined
+  }
+
+  const postfix = colorPostfixes.find((p) => colorName.endsWith(p))
+  if (!postfix) {
+    return undefined
+  }
+
+  const nextPostfix = colorPostfixes.indexOf(postfix) + (adjustmentType === AdjustmentType.Darken ? 1 : -1)
+  const nextColor = colorName.replace(postfix, '') + colorPostfixes[nextPostfix]
+
+  if (nextColor in GlobalColors) {
+    return nextColor as keyof GlobalPalette
+  }
+
+  return undefined
+}
+
+// Finds closest theme color to a given hex string by comparing rgb values. Returns GlobalPalette color name.
+export function findNearestThemeColor(hexString: string): keyof GlobalPalette | undefined {
+  return Object.keys(GlobalColors).reduce(
+    (closestMatch, currentColorName) => {
+      const currentHex = GlobalColors[currentColorName as keyof GlobalPalette]
+      const colorDiff = getColorDiffScore(hexString, currentHex)
+      if (colorDiff && (!closestMatch.colorDiff || colorDiff < closestMatch.colorDiff)) {
+        return { colorDiff, colorName: currentColorName as keyof GlobalPalette }
+      }
+      return closestMatch
+    },
+    {
+      colorDiff: Infinity,
+      colorName: undefined,
+    } as {
+      colorDiff: number | undefined
+      colorName: keyof GlobalPalette | undefined
+    },
+  ).colorName
+}
+
+/**
+ * Returns a number representing the difference between two colors. Lower means more similar.
+ */
+export function getColorDiffScore(colorA: string | null, colorB: string | null): number | undefined {
+  if (!colorA || !colorB) {
+    return undefined
+  }
+  const a = hexToRGB(colorA)
+  const b = hexToRGB(colorB)
+  if (!a || !b) {
+    return undefined
+  }
+  // Range 1 -> 442, add one to avoid comparison bugs when result is 0
+  return Math.sqrt(Math.pow(a.r - b.r, 2) + Math.pow(a.g - b.g, 2) + Math.pow(a.b - b.b, 2)) + 1
+}

package/src/utils/createTransactionId.ts

@@ -0,0 +1,5 @@
+import { v4 as uuid } from 'uuid'
+
+export function createTransactionId(): string {
+  return uuid()
+}

package/src/utils/currency.test.ts

@@ -0,0 +1,40 @@
+import { DAI, USDC } from '@luxexchange/lx/src/constants/tokens'
+import { Locale } from '@luxexchange/lx/src/features/language/constants'
+import { mockLocalizedFormatter } from '@luxexchange/lx/src/test/mocks'
+import { getCurrencyDisplayText, getFormattedCurrencyAmount } from '@luxexchange/lx/src/utils/currency'
+import { noOpFunction } from '@luxfi/utilities/src/test/utils'
+
+const mockFormatter = mockLocalizedFormatter(Locale.EnglishUnitedStates)
+
+describe(getFormattedCurrencyAmount, () => {
+  it('formats valid amount', () => {
+    expect(
+      getFormattedCurrencyAmount({ currency: DAI, amount: '1000000000000000000', formatter: mockFormatter }),
+    ).toEqual('1.00 ')
+  })
+
+  it('handles invalid Currency', () => {
+    expect(getFormattedCurrencyAmount({ currency: undefined, amount: '1', formatter: mockFormatter })).toEqual('')
+    expect(getFormattedCurrencyAmount({ currency: null, amount: '1', formatter: mockFormatter })).toEqual('')
+  })
+
+  it('handles error', () => {
+    // invalid raw amount will throw error
+    vi.spyOn(console, 'error').mockImplementation(noOpFunction)
+    expect(getFormattedCurrencyAmount({ currency: USDC, amount: '0.1', formatter: mockFormatter })).toEqual('')
+  })
+})
+
+describe(getCurrencyDisplayText, () => {
+  it('Returns symbol for token', () => {
+    expect(getCurrencyDisplayText(DAI, DAI.address)).toEqual('DAI')
+  })
+
+  it('handles undefined currency with address', () => {
+    expect(getCurrencyDisplayText(undefined, DAI.address)).toEqual('0x6B17...1d0F')
+  })
+
+  it('handles undefined address with currency', () => {
+    expect(getCurrencyDisplayText(DAI, undefined)).toEqual('DAI')
+  })
+})