@luxexchange/lx 1.0.0

package/src/utils/currency.ts

@@ -0,0 +1,97 @@
+import { Currency, Token } from '@luxfi/amm-core'
+import { getChainInfo } from '@luxexchange/lx/src/features/chains/chainInfo'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { LocalizationContextState } from '@luxexchange/lx/src/features/language/LocalizationContext'
+import { getCurrencyAmount, ValueType } from '@luxexchange/lx/src/features/tokens/getCurrencyAmount'
+import { SerializedToken } from '@luxexchange/lx/src/features/tokens/warnings/slice/types'
+import { getValidAddress } from '@luxexchange/lx/src/utils/addresses'
+import { shortenAddress } from '@luxfi/utilities/src/addresses'
+
+const DEFAULT_MAX_SYMBOL_CHARACTERS = 6
+
+export function getSymbolDisplayText(symbol: Maybe<string>): Maybe<string> {
+  if (!symbol) {
+    return symbol
+  }
+
+  return symbol.length > DEFAULT_MAX_SYMBOL_CHARACTERS
+    ? symbol.substring(0, DEFAULT_MAX_SYMBOL_CHARACTERS - 1) + '…'
+    : symbol
+}
+
+export function wrappedNativeCurrency(chainId: UniverseChainId): Token {
+  const wrappedCurrencyInfo = getChainInfo(chainId).wrappedNativeCurrency
+  return new Token(
+    chainId,
+    wrappedCurrencyInfo.address,
+    wrappedCurrencyInfo.decimals,
+    wrappedCurrencyInfo.symbol,
+    wrappedCurrencyInfo.name,
+  )
+}
+
+export function serializeToken(token: Token): SerializedToken {
+  return {
+    chainId: token.chainId,
+    address: token.address,
+    decimals: token.decimals,
+    name: token.name,
+    symbol: token.symbol,
+  }
+}
+
+export function deserializeToken(serializedToken: SerializedToken): Token {
+  return new Token(
+    serializedToken.chainId,
+    serializedToken.address,
+    serializedToken.decimals,
+    serializedToken.symbol,
+    serializedToken.name,
+  )
+}
+
+export function getFormattedCurrencyAmount({
+  currency,
+  amount,
+  formatter,
+  isApproximateAmount = false,
+  valueType = ValueType.Raw,
+}: {
+  currency: Maybe<Currency>
+  amount: string
+  formatter: LocalizationContextState
+  isApproximateAmount?: boolean
+  valueType?: ValueType
+}): string {
+  const currencyAmount = getCurrencyAmount({
+    value: amount,
+    valueType,
+    currency,
+  })
+
+  if (!currencyAmount) {
+    return ''
+  }
+
+  const formattedAmount = formatter.formatCurrencyAmount({ value: currencyAmount })
+  return isApproximateAmount ? `~${formattedAmount} ` : `${formattedAmount} `
+}
+
+export function getCurrencyDisplayText(
+  currency: Maybe<Currency>,
+  tokenAddressString: Address | undefined,
+): string | undefined {
+  const symbolDisplayText = getSymbolDisplayText(currency?.symbol)
+
+  if (symbolDisplayText) {
+    return symbolDisplayText
+  }
+
+  return tokenAddressString &&
+    getValidAddress({
+      address: tokenAddressString,
+      chainId: currency?.chainId ?? UniverseChainId.Mainnet,
+    })
+    ? shortenAddress({ address: tokenAddressString })
+    : tokenAddressString
+}

package/src/utils/currencyId.test.ts

@@ -0,0 +1,130 @@
+import { getNativeAddress } from '@luxexchange/lx/src/constants/addresses'
+import { DAI, nativeOnChain } from '@luxexchange/lx/src/constants/tokens'
+import { DEFAULT_NATIVE_ADDRESS } from '@luxexchange/lx/src/features/chains/evm/rpc'
+import { DEFAULT_NATIVE_ADDRESS_SOLANA } from '@luxexchange/lx/src/features/chains/svm/defaults'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import {
+  areCurrencyIdsEqual,
+  buildCurrencyId,
+  buildNativeCurrencyId,
+  currencyAddress,
+  currencyId,
+  currencyIdToAddress,
+  currencyIdToChain,
+  currencyIdToGraphQLAddress,
+  getCurrencyAddressForAnalytics,
+  isCurrencyIdValid,
+  isNativeCurrencyAddress,
+  NATIVE_ANALYTICS_ADDRESS_VALUE,
+} from '@luxexchange/lx/src/utils/currencyId'
+import { INVALID_ADDRESS_TOO_SHORT, INVALID_CHAIN_ID, VALID_ADDRESS, VALID_CHAIN_ID } from '@luxfi/utilities/src/test/fixtures'
+
+const ETH = nativeOnChain(UniverseChainId.Mainnet)
+
+describe('currencyId', () => {
+  it.each`
+    _currencyId                                           | expected
+    ${`${VALID_CHAIN_ID}-${VALID_ADDRESS}`}               | ${true}
+    ${`${VALID_CHAIN_ID}-${INVALID_ADDRESS_TOO_SHORT}`}   | ${false}
+    ${`${INVALID_CHAIN_ID}-${VALID_ADDRESS}`}             | ${false}
+    ${`${INVALID_CHAIN_ID}-${INVALID_ADDRESS_TOO_SHORT}`} | ${false}
+    ${``}                                                 | ${false}
+    ${undefined}                                          | ${false}
+  `('currencyId=$currencyId should return expected=$expected', ({ _currencyId, expected }) => {
+    expect(isCurrencyIdValid(_currencyId)).toEqual(expected)
+  })
+  it.each([
+    [DAI, `1-${DAI.address}`],
+    [ETH, `${UniverseChainId.Mainnet}-${getNativeAddress(UniverseChainId.Mainnet)}`],
+  ])('builds correct ID for asset=$asset = $s', (asset, expectedId) => {
+    expect(currencyId(asset)).toEqual(expectedId)
+  })
+
+  it.each([[UniverseChainId.Mainnet, DAI.address, `${UniverseChainId.Mainnet}-${DAI.address}`]])(
+    'buildCurrencyId builds correct ID for chainId=%s + address=%s = %s',
+    // eslint-disable-next-line max-params
+    (chainId, address, expectedId) => {
+      expect(buildCurrencyId(chainId, address)).toEqual(expectedId)
+    },
+  )
+
+  it.each([
+    [currencyId(DAI), currencyId(DAI), true],
+    [currencyId(DAI), `${UniverseChainId.Mainnet}-${DAI.address.toLowerCase()}`, true],
+    [currencyId(DAI), currencyId(ETH), false],
+  ])(
+    'areCurrencyIdsEqual returns correct comparison for currencyId1=%s and currencyId2=%s = %s',
+    // eslint-disable-next-line max-params
+    (currencyId1, currencyId2, expected) => {
+      expect(areCurrencyIdsEqual(currencyId1, currencyId2)).toBe(expected)
+    },
+  )
+
+  it.each([
+    [ETH, getNativeAddress(UniverseChainId.Mainnet)],
+    [DAI, DAI.address],
+  ])('currencyAddress returns correct address for asset=%s = %s', (asset, expectedAddress) => {
+    expect(currencyAddress(asset)).toEqual(expectedAddress)
+  })
+
+  it.each([
+    [ETH, NATIVE_ANALYTICS_ADDRESS_VALUE],
+    [DAI, DAI.address],
+  ])('getCurrencyAddressForAnalytics returns correct address for asset=%s = %s', (asset, expectedAddress) => {
+    expect(getCurrencyAddressForAnalytics(asset)).toEqual(expectedAddress)
+  })
+
+  it.each([
+    [UniverseChainId.Mainnet, `1-0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`],
+    [UniverseChainId.Polygon, `137-0x0000000000000000000000000000000000001010`],
+    [UniverseChainId.Bnb, `56-0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`],
+  ])('buildNativeCurrencyId builds correct ID for chainId=%s = %s', (chainId, expectedId) => {
+    expect(buildNativeCurrencyId(chainId)).toEqual(expectedId)
+  })
+
+  it.each([
+    [UniverseChainId.Mainnet, getNativeAddress(UniverseChainId.Mainnet), true],
+    [UniverseChainId.Polygon, getNativeAddress(UniverseChainId.Polygon), true],
+    [UniverseChainId.Mainnet, null, true],
+    [UniverseChainId.Mainnet, getNativeAddress(UniverseChainId.Polygon), false],
+    [UniverseChainId.Mainnet, DAI.address, false],
+    [UniverseChainId.Mainnet, 'ETH', true],
+    [UniverseChainId.Mainnet, DEFAULT_NATIVE_ADDRESS, true],
+    [UniverseChainId.Solana, getNativeAddress(UniverseChainId.Solana), true],
+    [UniverseChainId.Solana, '11111', false],
+    [UniverseChainId.Solana, DEFAULT_NATIVE_ADDRESS_SOLANA, true],
+    // Invalid chainId should return false instead of crashing
+    [10143, DAI.address, false],
+    [99999, null, false],
+  ])(
+    'isNativeCurrencyAddress returns correct result for chainId=%s + address=%s = %s',
+    // eslint-disable-next-line max-params
+    (chainId, address, expected) => {
+      expect(isNativeCurrencyAddress(chainId, address)).toEqual(expected)
+    },
+  )
+
+  it.each([
+    [`1-${DAI.address}`, DAI.address],
+    [`1-${getNativeAddress(UniverseChainId.Mainnet)}`, getNativeAddress(UniverseChainId.Mainnet)],
+  ])('currencyIdToAddress returns correct address for _currencyId=%s = %s', (_currencyId, expectedAddress) => {
+    expect(currencyIdToAddress(_currencyId)).toEqual(expectedAddress)
+  })
+
+  it.each([
+    [`1-${DAI.address}`, DAI.address.toLowerCase()],
+    [`1-0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`, null],
+    ['137-0x0000000000000000000000000000000000001010', '0x0000000000000000000000000000000000001010'],
+    ['56-0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', null],
+  ])('currencyIdToGraphQLAddress returns correct address for currencyId=%s = %s', (_currencyId, expectedAddress) => {
+    expect(currencyIdToGraphQLAddress(_currencyId)).toEqual(expectedAddress)
+  })
+
+  it.each([
+    [`1-${DAI.address}`, UniverseChainId.Mainnet],
+    [`1-${getNativeAddress(UniverseChainId.Mainnet)}`, UniverseChainId.Mainnet],
+    ['', null],
+  ])('currencyIdToChain returns correct chain for currencyId=%s = %s', (_currencyId, expectedChain) => {
+    expect(currencyIdToChain(_currencyId)).toEqual(expectedChain)
+  })
+})

package/src/utils/currencyId.ts

@@ -0,0 +1,221 @@
+import { Currency } from '@uniswap/sdk-core'
+import { TradingApi } from '@luxexchange/api'
+import { getNativeAddress, getWrappedNativeAddress } from '@luxexchange/lx/src/constants/addresses'
+import { normalizeCurrencyIdForMapLookup, normalizeTokenAddressForCache } from '@luxexchange/lx/src/data/cache'
+import { TradeableAsset } from '@luxexchange/lx/src/entities/assets'
+import { getChainInfo } from '@luxexchange/lx/src/features/chains/chainInfo'
+import { DEFAULT_NATIVE_ADDRESS, DEFAULT_NATIVE_ADDRESS_LEGACY } from '@luxexchange/lx/src/features/chains/evm/defaults'
+import { DEFAULT_NATIVE_ADDRESS_SOLANA } from '@luxexchange/lx/src/features/chains/svm/defaults'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { isUniverseChainId, toSupportedChainId } from '@luxexchange/lx/src/features/chains/utils'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { isSVMChain } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import { CurrencyId } from '@luxexchange/lx/src/types/currency'
+import { areAddressesEqual, getValidAddress } from '@luxexchange/lx/src/utils/addresses'
+
+export function currencyId(tradeableAsset: TradeableAsset): CurrencyId
+export function currencyId(currency: Currency): CurrencyId
+export function currencyId(currency: Currency | undefined): CurrencyId | undefined
+export function currencyId(currency: Maybe<Currency>): CurrencyId | undefined
+export function currencyId(
+  currencyOrTradeableAsset: Maybe<Currency> | TradeableAsset | undefined,
+): CurrencyId | undefined {
+  if (!currencyOrTradeableAsset) {
+    return undefined
+  }
+
+  return buildCurrencyId(
+    currencyOrTradeableAsset.chainId,
+    'isNative' in currencyOrTradeableAsset
+      ? currencyAddress(currencyOrTradeableAsset)
+      : currencyOrTradeableAsset.address,
+  )
+}
+
+export function buildCurrencyId(chainId: UniverseChainId, address: string): string {
+  return `${chainId}-${address}`
+}
+
+/**
+ * Checks if a currencyId is valid by checking the chainId and address.
+ */
+export function isCurrencyIdValid(_currencyId: CurrencyId): boolean {
+  try {
+    const [chainId, address] = _currencyId.split('-')
+    const validChainId = toSupportedChainId(chainId)
+    if (!validChainId) {
+      return false
+    }
+    const validAddress = getValidAddress({ address, chainId: validChainId })
+
+    return !!validAddress
+  } catch (_error) {
+    return false
+  }
+}
+
+export function buildNativeCurrencyId(chainId: UniverseChainId): string {
+  return buildCurrencyId(chainId, getNativeAddress(chainId))
+}
+
+export function buildWrappedNativeCurrencyId(chainId: UniverseChainId): string {
+  return buildCurrencyId(chainId, getWrappedNativeAddress(chainId))
+}
+
+export function areCurrencyIdsEqual(id1: CurrencyId, id2: CurrencyId): boolean {
+  return normalizeCurrencyIdForMapLookup(id1) === normalizeCurrencyIdForMapLookup(id2)
+}
+
+export function areCurrenciesEqual(currency1?: Maybe<Currency>, currency2?: Maybe<Currency>): boolean {
+  if (!(currency1 && currency2)) {
+    return currency1 === currency2
+  }
+  return areCurrencyIdsEqual(currencyId(currency1), currencyId(currency2))
+}
+
+export function currencyAddress(currency: Currency): string {
+  if (currency.isNative) {
+    return getNativeAddress(currency.chainId)
+  }
+
+  return currency.address
+}
+
+export const NATIVE_ANALYTICS_ADDRESS_VALUE = 'NATIVE'
+
+export function getCurrencyAddressForAnalytics(currency: Currency): string {
+  if (currency.isNative) {
+    return NATIVE_ANALYTICS_ADDRESS_VALUE
+  }
+
+  return currency.address
+}
+
+export const isNativeCurrencyAddress = (chainId: UniverseChainId, address: Maybe<Address>): boolean => {
+  // Cast to include undefined since getChainInfo can return undefined at runtime for invalid chainIds
+  // even though TypeScript types say it always returns UniverseChainInfo
+  const chainInfo = getChainInfo(chainId) as ReturnType<typeof getChainInfo> | undefined
+
+  // Defensive check: if chainInfo is undefined (invalid chainId), treat as non-native
+  if (!chainInfo) {
+    return false
+  }
+
+  if (!address) {
+    return true
+  }
+
+  const { platform } = chainInfo
+  // sometimes the native token symbol is returned as the native token address
+  if (address === chainInfo.nativeCurrency.symbol) {
+    return true
+  }
+
+  const nativeAddress = getNativeAddress(chainId)
+
+  if (isSVMChain(chainId)) {
+    // For Solana, only consider DEFAULT_NATIVE_ADDRESS_SOLANA (11111...) as native
+    // WSOL (So111...) should be treated as a regular token, not native
+    return areAddressesEqual({
+      addressInput1: { address, platform },
+      addressInput2: { address: DEFAULT_NATIVE_ADDRESS_SOLANA, platform },
+    })
+  }
+
+  // allow both native address formats until all backend endpoints return the new one
+  if (nativeAddress === DEFAULT_NATIVE_ADDRESS_LEGACY) {
+    return (
+      areAddressesEqual({
+        addressInput1: { address, platform },
+        addressInput2: { address: nativeAddress, platform },
+      }) ||
+      areAddressesEqual({
+        addressInput1: { address, platform },
+        addressInput2: { address: DEFAULT_NATIVE_ADDRESS, platform },
+      })
+    )
+  }
+  return areAddressesEqual({
+    addressInput1: { address, platform },
+    addressInput2: { address: nativeAddress, platform },
+  })
+}
+
+// Currency ids are formatted as `chainId-tokenaddress`
+export function currencyIdToAddress(_currencyId: string): Address {
+  const currencyIdParts = _currencyId.split('-')
+  if (!currencyIdParts[1]) {
+    throw new Error(`Invalid currencyId format: ${_currencyId}`)
+  }
+  return currencyIdParts[1]
+}
+
+function isPolygonChain(chainId: number): chainId is UniverseChainId.Polygon {
+  return chainId === UniverseChainId.Polygon
+}
+
+function isCeloChain(chainId: number): chainId is UniverseChainId.Celo {
+  return chainId === UniverseChainId.Celo
+}
+
+// Similar to `currencyIdToAddress`, except native addresses are `null`.
+export function currencyIdToGraphQLAddress(_currencyId?: string): Address | null {
+  if (!_currencyId) {
+    return null
+  }
+
+  const address = currencyIdToAddress(_currencyId)
+  const chainId = currencyIdToChain(_currencyId)
+
+  if (!chainId) {
+    return null
+  }
+
+  // backend only expects `null` for the native asset, except Polygon & Celo
+  if (isNativeCurrencyAddress(chainId, address) && !isPolygonChain(chainId) && !isCeloChain(chainId)) {
+    return null
+  }
+
+  return normalizeTokenAddressForCache(address)
+}
+
+export function currencyIdToChain(_currencyId: string): UniverseChainId | null {
+  return toSupportedChainId(_currencyId.split('-')[0])
+}
+
+export function isDefaultNativeAddress({ address, platform }: { address: string; platform: Platform }): boolean {
+  return areAddressesEqual({
+    addressInput1: { address, platform },
+    addressInput2: { address: DEFAULT_NATIVE_ADDRESS_LEGACY, platform },
+  })
+}
+
+export type MaybeChainId = number | UniverseChainId | null | undefined | TradingApi.ChainId
+
+/**
+ * Takes in tokens and chains from an external source and validates that a currencyId can be built from them.
+ * Returns null if validation fails.
+ */
+export function validateAndBuildCurrencyId(params: {
+  chainId: MaybeChainId
+  tokenAddress: Address | string | undefined
+}): {
+  chainId: UniverseChainId
+  currencyId: CurrencyId
+  tokenAddress: Address
+} | null {
+  const { chainId, tokenAddress } = params
+  const chainIdValidated = isUniverseChainId(chainId) ? (chainId as UniverseChainId) : undefined
+
+  const _currencyId =
+    isUniverseChainId(chainIdValidated) && tokenAddress ? buildCurrencyId(chainIdValidated, tokenAddress) : undefined
+
+  if (!chainIdValidated || !_currencyId || !tokenAddress) {
+    return null
+  }
+  return {
+    chainId: chainIdValidated,
+    currencyId: _currencyId,
+    tokenAddress,
+  }
+}

package/src/utils/datadog.native.ts

@@ -0,0 +1,5 @@
+import { NotImplementedError } from '@luxfi/utilities/src/errors'
+
+export function initializeDatadog(_appName: string): void {
+  throw new NotImplementedError('initializeDatadog')
+}

package/src/utils/datadog.ts

@@ -0,0 +1,5 @@
+import { PlatformSplitStubError } from '@luxfi/utilities/src/errors'
+
+export function initializeDatadog(_appName: string): Promise<void> {
+  throw new PlatformSplitStubError('initializeDatadog')
+}

package/src/utils/datadog.web.ts

@@ -0,0 +1,159 @@
+import { datadogLogs } from '@datadog/browser-logs'
+import { datadogRum, RumEvent, RumEventDomainContext, RumFetchResourceEventDomainContext } from '@datadog/browser-rum'
+import {
+  DatadogIgnoredErrorsConfigKey,
+  DatadogIgnoredErrorsValType,
+  DatadogSessionSampleRateKey,
+  DatadogSessionSampleRateValType,
+  DynamicConfigs,
+  Experiments,
+  getDynamicConfigValue,
+  getStatsigClient,
+  WALLET_FEATURE_FLAG_NAMES,
+  WEB_FEATURE_FLAG_NAMES,
+} from '@luxfi/gating'
+import { config } from '@luxexchange/lx/src/config'
+import { getUniqueId } from '@luxfi/utilities/src/device/uniqueId'
+import { datadogEnabledBuild, localDevDatadogEnabled } from '@luxfi/utilities/src/environment/constants'
+import { isBetaEnv } from '@luxfi/utilities/src/environment/env'
+import { getDatadogEnvironment } from '@luxfi/utilities/src/logger/datadog/env'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+import { isExtensionApp, isWebApp } from '@luxfi/utilities/src/platform'
+
+// In case Statsig is not available
+const EXTENSION_DEFAULT_DATADOG_SESSION_SAMPLE_RATE = 10 // percent
+const INTERFACE_DEFAULT_DATADOG_SESSION_SAMPLE_RATE = 10 // percent
+
+function beforeSend(event: RumEvent, context: RumEventDomainContext): boolean {
+  // otherwise DataDog will ignore error events
+  event.view.url = event.view.url.replace(/^chrome-extension:\/\/[a-z]{32}\//i, '')
+  if (event.error && event.type === 'error') {
+    if (event.error.source === 'console') {
+      return false
+    }
+    const ignoredErrors = getDynamicConfigValue<
+      DynamicConfigs.DatadogIgnoredErrors,
+      DatadogIgnoredErrorsConfigKey,
+      DatadogIgnoredErrorsValType
+    >({
+      config: DynamicConfigs.DatadogIgnoredErrors,
+      key: DatadogIgnoredErrorsConfigKey.Errors,
+      defaultValue: [],
+    })
+
+    const ignoredError = ignoredErrors.find(({ messageContains }: { messageContains: string }) =>
+      event.error.message.includes(messageContains),
+    )
+    if (ignoredError && Math.random() > ignoredError.sampleRate) {
+      return false
+    }
+
+    Object.defineProperty(event.error, 'stack', {
+      value: event.error.stack?.replace(/chrome-extension:\/\/[a-z]{32}/gi, ''),
+      writable: false,
+      configurable: true,
+    })
+  }
+  if (event.type === 'resource' && event.resource.url.includes('graphql')) {
+    const requestBody = (context as RumFetchResourceEventDomainContext).requestInit?.body
+    if (requestBody) {
+      const body = JSON.parse(requestBody as string)
+      event.context = {
+        ...event.context,
+        operationName: body.operationName,
+      }
+    }
+  }
+
+  return true
+}
+
+export async function initializeDatadog(appName: string): Promise<void> {
+  if (!datadogEnabledBuild) {
+    return
+  }
+
+  const sessionSampleRate = getDynamicConfigValue<
+    DynamicConfigs.DatadogSessionSampleRate,
+    DatadogSessionSampleRateKey,
+    DatadogSessionSampleRateValType
+  >({
+    config: DynamicConfigs.DatadogSessionSampleRate,
+    key: DatadogSessionSampleRateKey.Rate,
+    defaultValue: isExtensionApp
+      ? EXTENSION_DEFAULT_DATADOG_SESSION_SAMPLE_RATE
+      : INTERFACE_DEFAULT_DATADOG_SESSION_SAMPLE_RATE,
+  })
+
+  const sharedDatadogConfig = {
+    clientToken: config.datadogClientToken,
+    service: isWebApp ? `web-${getDatadogEnvironment()}` : `extension-${getDatadogEnvironment()}`,
+    env: getDatadogEnvironment(),
+    version: isExtensionApp ? process.env.VERSION : process.env.REACT_APP_VERSION_TAG,
+    trackingConsent: undefined,
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  const shouldUseFullSampleRate = localDevDatadogEnabled || (isWebApp && isBetaEnv())
+
+  datadogRum.init({
+    ...sharedDatadogConfig,
+    applicationId: config.datadogProjectId,
+    sessionSampleRate: shouldUseFullSampleRate ? 100 : sessionSampleRate,
+    sessionReplaySampleRate: 0,
+    trackResources: true,
+    trackLongTasks: true,
+    trackUserInteractions: true,
+    enablePrivacyForActionName: true,
+    beforeSend,
+  })
+
+  // According to the Datadog RUM documentation:
+  // https://docs.datadoghq.com/real_user_monitoring/browser/setup/client?tab=rum#access-internal-context
+  // datadogRum.init() seems to be synchronous and internal context is immediately available.
+  // Local testing confirms this behavior, explaining why no "onInitialization" callback is needed.
+  const internalContext = datadogRum.getInternalContext()
+  const sessionIsSampled = internalContext?.session_id !== undefined
+
+  // we do not want to log anything if session is not sampled
+  if (sessionIsSampled) {
+    datadogLogs.init({
+      ...sharedDatadogConfig,
+      site: 'datadoghq.com',
+      forwardErrorsToLogs: false,
+    })
+    logger.setDatadogEnabled(true)
+  }
+
+  try {
+    const userId = await getUniqueId()
+    datadogRum.setUser({
+      id: userId,
+    })
+  } catch (e) {
+    logger.error(e, {
+      tags: { file: 'datadog.ts', function: 'initializeDatadog' },
+    })
+  }
+
+  datadogRum.setGlobalContextProperty('app', appName)
+  datadogRum.setGlobalContextProperty('buildType', process.env.REACT_APP_WEB_BUILD_TYPE)
+
+  for (const [_, flagKey] of [...WEB_FEATURE_FLAG_NAMES.entries(), ...WALLET_FEATURE_FLAG_NAMES.entries()]) {
+    datadogRum.addFeatureFlagEvaluation(
+      // Datadog has a limited set of accepted symbols in feature flags
+      // https://docs.datadoghq.com/real_user_monitoring/guide/setup-feature-flag-data-collection/?tab=reactnative#feature-flag-naming
+      flagKey.replaceAll('-', '_'),
+      getStatsigClient().checkGate(flagKey),
+    )
+  }
+
+  for (const experiment of Object.values(Experiments)) {
+    datadogRum.addFeatureFlagEvaluation(
+      // Datadog has a limited set of accepted symbols in feature flags
+      // https://docs.datadoghq.com/real_user_monitoring/guide/setup-feature-flag-data-collection/?tab=reactnative#feature-flag-naming
+      `experiment_${experiment.replaceAll('-', '_')}`,
+      getStatsigClient().getExperiment(experiment).groupName,
+    )
+  }
+}

package/src/utils/isWSOL.test.ts

@@ -0,0 +1,38 @@
+import { Currency } from '@luxfi/amm-core'
+import { nativeOnChain, WRAPPED_NATIVE_CURRENCY } from '@luxexchange/lx/src/constants/tokens'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { SolanaToken } from '@luxexchange/lx/src/features/tokens/SolanaToken'
+import { isWSOL } from '@luxexchange/lx/src/utils/isWSOL'
+
+const SOL = nativeOnChain(UniverseChainId.Solana)
+const WSOL = WRAPPED_NATIVE_CURRENCY[UniverseChainId.Solana]!
+
+describe('isWSOL', () => {
+  it('should return true for WSOL token', () => {
+    expect(isWSOL(WSOL)).toBe(true)
+  })
+
+  it('should return false for native SOL', () => {
+    expect(isWSOL(SOL)).toBe(false)
+  })
+
+  it('should return false for other SPL tokens', () => {
+    const otherToken = new SolanaToken(
+      UniverseChainId.Solana,
+      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
+      6,
+      'USDC',
+      'USD Coin',
+    )
+    expect(isWSOL(otherToken)).toBe(false)
+  })
+
+  it('should return false for EVM tokens', () => {
+    const mockETH = {
+      isNative: true,
+      chainId: UniverseChainId.Mainnet,
+      address: '0x0000000000000000000000000000000000000000',
+    } as unknown as Currency
+    expect(isWSOL(mockETH)).toBe(false)
+  })
+})

package/src/utils/isWSOL.ts

@@ -0,0 +1,17 @@
+import { Currency } from '@luxfi/amm-core'
+import { WRAPPED_SOL_ADDRESS_SOLANA } from '@luxexchange/lx/src/features/chains/svm/defaults'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { areAddressesEqual } from '@luxexchange/lx/src/utils/addresses'
+
+/**
+ * Checks if a currency is WSOL (Wrapped SOL)
+ */
+export function isWSOL(currency: Currency): boolean {
+  return (
+    !currency.isNative &&
+    areAddressesEqual({
+      addressInput1: { address: currency.address, chainId: currency.chainId },
+      addressInput2: { address: WRAPPED_SOL_ADDRESS_SOLANA, chainId: UniverseChainId.Solana },
+    })
+  )
+}

package/src/utils/link.native.ts

@@ -0,0 +1,9 @@
+import { Linking } from 'react-native'
+
+export async function openURL(url: string): Promise<void> {
+  await Linking.openURL(url)
+}
+
+export async function canOpenURL(url: string): Promise<boolean> {
+  return await Linking.canOpenURL(url)
+}