@luxexchange/lx 1.0.0

package/src/features/gas/utils/cancel.ts

@@ -0,0 +1,198 @@
+import { BigNumber } from '@ethersproject/bignumber'
+import { FeeType, GasFeeResult } from '@luxexchange/api'
+import { providers } from 'ethers/lib/ethers'
+import { TRANSACTION_CANCELLATION_GAS_FACTOR } from '@luxexchange/lx/src/constants/transactions'
+import { FeeDetails, getAdjustedGasFeeDetails } from '@luxexchange/lx/src/features/gas/adjustGasFee'
+import { CancellationGasFeeDetails } from '@luxexchange/lx/src/features/gas/hooks'
+import { isClassic, isDEX } from '@luxexchange/lx/src/features/transactions/swap/utils/routing'
+import { TransactionDetails, DEXOrderDetails } from '@luxexchange/lx/src/features/transactions/types/transactionDetails'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+export const CANCELLATION_TX_VALUE = '0x0'
+
+export enum CancellationType {
+  Classic = 'classic',
+  DEX = 'dex',
+}
+
+/**
+ * Determines the type of cancellation needed for a transaction
+ */
+export function getCancellationType(
+  transaction: TransactionDetails,
+  orders?: DEXOrderDetails[],
+): CancellationType {
+  return isDEX(transaction) || (orders !== undefined && orders.length > 0)
+    ? CancellationType.DEX
+    : CancellationType.Classic
+}
+
+/**
+ * Creates a classic cancellation transaction request
+ */
+export function createClassicCancelRequest(transaction: TransactionDetails): providers.TransactionRequest {
+  return {
+    chainId: transaction.chainId,
+    from: transaction.from,
+    to: transaction.from,
+    value: CANCELLATION_TX_VALUE,
+  }
+}
+
+/**
+ * Calculates the cancellation gas fee based on cancellation type
+ */
+export function calculateCancellationGasFee(params: {
+  type: CancellationType
+  transaction: TransactionDetails
+  gasFee?: GasFeeResult
+  cancelRequest?: providers.TransactionRequest
+  orders?: DEXOrderDetails[]
+}): CancellationGasFeeDetails | undefined {
+  const { type, transaction, gasFee, cancelRequest } = params
+
+  if (type === CancellationType.DEX) {
+    return calculateDEXCancellationGas(cancelRequest, gasFee)
+  }
+
+  return calculateClassicCancellationGas(transaction, gasFee)
+}
+
+/**
+ * Helper function to apply cancellation gas adjustment factor to a BigNumber value
+ */
+function applyGasAdjustmentFactor(value: BigNumber): string {
+  return value
+    .mul(Math.floor(TRANSACTION_CANCELLATION_GAS_FACTOR * 100))
+    .div(100)
+    .toString()
+}
+
+/**
+ * Pure function to calculate classic transaction cancellation gas fee
+ * @param transaction - The transaction to cancel
+ * @param gasFee - Current network gas fee
+ * @returns Cancellation gas fee details or undefined
+ */
+export function calculateClassicCancellationGas(
+  transaction: TransactionDetails,
+  gasFee: GasFeeResult | undefined,
+): CancellationGasFeeDetails | undefined {
+  if (!gasFee?.params || !gasFee.value || !gasFee.displayValue || gasFee.value === '0') {
+    return undefined
+  }
+
+  const classicCancelRequest = createClassicCancelRequest(transaction)
+
+  let adjustedFeeDetails: FeeDetails | undefined
+
+  // For classic transactions, we need the original request to determine fee adjustment
+  const request = isClassic(transaction) ? transaction.options.request : undefined
+
+  if (request) {
+    try {
+      adjustedFeeDetails = getAdjustedGasFeeDetails({
+        request,
+        currentGasFeeParams: gasFee.params,
+        adjustmentFactor: TRANSACTION_CANCELLATION_GAS_FACTOR,
+      })
+    } catch (error) {
+      logger.error(error, {
+        tags: { file: 'cancel.ts', function: 'getAdjustedGasFeeDetails' },
+        extra: { currentGasFeeParams: gasFee.params },
+      })
+      return undefined
+    }
+  } else {
+    // If no original request is available, manually apply the adjustment factor
+    if ('gasPrice' in gasFee.params) {
+      const adjustedGasPrice = applyGasAdjustmentFactor(BigNumber.from(gasFee.params.gasPrice))
+      adjustedFeeDetails = {
+        type: FeeType.LEGACY,
+        params: { gasPrice: adjustedGasPrice },
+      }
+    } else {
+      const adjustedMaxFeePerGas = applyGasAdjustmentFactor(BigNumber.from(gasFee.params.maxFeePerGas))
+      const adjustedMaxPriorityFeePerGas = applyGasAdjustmentFactor(BigNumber.from(gasFee.params.maxPriorityFeePerGas))
+      adjustedFeeDetails = {
+        type: FeeType.EIP1559,
+        params: { maxFeePerGas: adjustedMaxFeePerGas, maxPriorityFeePerGas: adjustedMaxPriorityFeePerGas },
+      }
+    }
+  }
+
+  const cancelRequest = {
+    ...classicCancelRequest,
+    ...adjustedFeeDetails.params,
+    gasLimit: gasFee.params.gasLimit,
+  }
+
+  const gasFeeDisplayValue = getCancellationGasFeeDisplayValue({
+    adjustedFeeDetails,
+    gasLimit: gasFee.params.gasLimit,
+    previousValue: gasFee.value,
+    previousDisplayValue: gasFee.displayValue,
+  })
+
+  return {
+    cancelRequest,
+    gasFeeDisplayValue,
+  }
+}
+
+/**
+ * Pure function to calculate DEX order cancellation gas fee
+ * @param cancelRequest - The cancellation transaction request
+ * @param gasFee - Current network gas fee
+ * @returns Cancellation gas fee details or undefined
+ */
+export function calculateDEXCancellationGas(
+  cancelRequest: providers.TransactionRequest | undefined,
+  gasFee: GasFeeResult | undefined,
+): CancellationGasFeeDetails | undefined {
+  if (!cancelRequest || !gasFee?.displayValue) {
+    return undefined
+  }
+
+  // For DEX cancellations, the gas fee is directly from the cancel request estimation
+  // No adjustment factor is needed since the transaction is different from the original
+  return {
+    cancelRequest,
+    gasFeeDisplayValue: gasFee.displayValue,
+  }
+}
+
+/**
+ * Helper function to calculate cancellation gas fee display value
+ */
+function getCancellationGasFeeDisplayValue({
+  adjustedFeeDetails,
+  gasLimit,
+  previousValue,
+  previousDisplayValue,
+}: {
+  adjustedFeeDetails: FeeDetails
+  gasLimit: string
+  previousValue: string
+  previousDisplayValue: string
+}): string {
+  // Calculate the new cancellation gas fee in wei
+  const newGasFeeWei = getCancellationGasFee(adjustedFeeDetails, gasLimit)
+
+  // Maintain the same ratio between display and actual value
+  // Both previousDisplayValue and previousValue are in wei (as BigNumber strings)
+  // The ratio captures the gas strategy's inflation factor difference (e.g., display might be 87% of actual)
+  return newGasFeeWei.mul(BigNumber.from(previousDisplayValue)).div(BigNumber.from(previousValue)).toString()
+}
+
+/**
+ * Helper function to calculate cancellation gas fee
+ */
+function getCancellationGasFee(adjustedFeeDetails: FeeDetails, gasLimit: string): BigNumber {
+  // doing object destructuring here loses ts checks based on FeeDetails.type >:(
+  if (adjustedFeeDetails.type === FeeType.LEGACY) {
+    return BigNumber.from(gasLimit).mul(adjustedFeeDetails.params.gasPrice)
+  }
+
+  return BigNumber.from(adjustedFeeDetails.params.maxFeePerGas).mul(gasLimit)
+}

package/src/features/gas/utils.test.ts

@@ -0,0 +1,74 @@
+import { CurrencyAmount } from '@luxfi/amm-core'
+import { DAI } from '@luxexchange/lx/src/constants/tokens'
+import { applyNativeTokenPercentageBuffer, hasSufficientFundsIncludingGas } from '@luxexchange/lx/src/features/gas/utils'
+import { MAINNET_CURRENCY } from '@luxexchange/lx/src/test/fixtures'
+
+const ZERO_ETH = CurrencyAmount.fromRawAmount(MAINNET_CURRENCY, 0)
+const ONE_ETH = CurrencyAmount.fromRawAmount(MAINNET_CURRENCY, 1e18)
+const TEN_ETH = ONE_ETH.multiply(10)
+
+describe(applyNativeTokenPercentageBuffer, () => {
+  it('returns undefined if no currency amount is provided', () => {
+    expect(applyNativeTokenPercentageBuffer(undefined, 10)).toBeUndefined()
+  })
+
+  it('takes a percentage and returns the remaining amount', () => {
+    expect(applyNativeTokenPercentageBuffer(ONE_ETH, 10)?.quotient.toString()).toEqual('900000000000000000')
+  })
+
+  it('handles decimal based percentage buffers', () => {
+    expect(applyNativeTokenPercentageBuffer(ONE_ETH, 1.5)?.quotient.toString()).toEqual('985000000000000000')
+  })
+
+  it('returns the original amount if no percentage is provided', () => {
+    expect(applyNativeTokenPercentageBuffer(ONE_ETH, 0)?.quotient.toString()).toEqual('1000000000000000000')
+  })
+
+  it('returns the original amount if the currency is not native', () => {
+    expect(
+      applyNativeTokenPercentageBuffer(CurrencyAmount.fromRawAmount(DAI, '100000000'), 10)?.quotient.toString(),
+    ).toEqual('100000000')
+  })
+})
+
+describe(hasSufficientFundsIncludingGas, () => {
+  it('correctly returns when there is enough for gas with no tx value', () => {
+    const mockParams = {
+      transactionAmount: undefined,
+      gasFee: '1000',
+      nativeCurrencyBalance: ONE_ETH,
+    }
+
+    expect(hasSufficientFundsIncludingGas(mockParams)).toBe(true)
+  })
+
+  it('correctly returns when there is enough for gas even with tx value', () => {
+    const mockParams = {
+      transactionAmount: ONE_ETH,
+      gasFee: '1000',
+      nativeCurrencyBalance: TEN_ETH,
+    }
+
+    expect(hasSufficientFundsIncludingGas(mockParams)).toBe(true)
+  })
+
+  it('correctly returns when there is not enough gas with no tx value', () => {
+    const mockParams = {
+      transactionAmount: undefined,
+      gasFee: '1000',
+      nativeCurrencyBalance: ZERO_ETH,
+    }
+
+    expect(hasSufficientFundsIncludingGas(mockParams)).toBe(false)
+  })
+
+  it('correctly returns when there is not enough gas with a tx value', () => {
+    const mockParams = {
+      transactionAmount: ONE_ETH,
+      gasFee: '1000',
+      nativeCurrencyBalance: ZERO_ETH,
+    }
+
+    expect(hasSufficientFundsIncludingGas(mockParams)).toBe(false)
+  })
+})

package/src/features/gas/utils.ts

@@ -0,0 +1,289 @@
+import type { TransactionRequest } from '@ethersproject/providers'
+import { type Currency, type CurrencyAmount } from '@uniswap/sdk-core'
+import {
+  type GasEstimate,
+  type GasFeeResult,
+  type GasFeeResultWithoutState,
+  type GasStrategy,
+  type TransactionEip1559FeeParams,
+  type TransactionLegacyFeeParams,
+} from '@luxexchange/api'
+import {
+  DynamicConfigs,
+  type GasStrategies,
+  type GasStrategyType,
+  type GasStrategyWithConditions,
+  getStatsigClient,
+} from '@luxexchange/gating'
+import JSBI from 'jsbi'
+import { createEthersProvider } from '@luxexchange/lx/src/features/providers/createEthersProvider'
+import { getCurrencyAmount, ValueType } from '@luxexchange/lx/src/features/tokens/getCurrencyAmount'
+import { type Prettify } from 'viem'
+
+// Normal speed strategy - Lower multipliers for economical transactions
+export const NORMAL_GAS_STRATEGY: GasStrategy = {
+  limitInflationFactor: 1.1,
+  displayLimitInflationFactor: 1,
+  priceInflationFactor: 1.1,
+  percentileThresholdFor1559Fee: 50,
+  thresholdToInflateLastBlockBaseFee: 0.9,
+  baseFeeMultiplier: 1,
+  baseFeeHistoryWindow: 20,
+  minPriorityFeeRatioOfBaseFee: 0.1,
+  minPriorityFeeGwei: 1,
+  maxPriorityFeeGwei: 5,
+}
+
+// Fast speed strategy - Moderate multipliers for balanced speed/cost
+export const FAST_GAS_STRATEGY: GasStrategy = {
+  limitInflationFactor: 1.12,
+  displayLimitInflationFactor: 1,
+  priceInflationFactor: 1.25,
+  percentileThresholdFor1559Fee: 60,
+  thresholdToInflateLastBlockBaseFee: 0.8,
+  baseFeeMultiplier: 1,
+  baseFeeHistoryWindow: 20,
+  minPriorityFeeRatioOfBaseFee: 0.15,
+  minPriorityFeeGwei: 1.5,
+  maxPriorityFeeGwei: 7,
+}
+
+// Urgent speed strategy - Higher multipliers for fast confirmation
+export const URGENT_GAS_STRATEGY: GasStrategy = {
+  limitInflationFactor: 1.15,
+  displayLimitInflationFactor: 1,
+  priceInflationFactor: 1.5,
+  percentileThresholdFor1559Fee: 75,
+  thresholdToInflateLastBlockBaseFee: 0.75,
+  baseFeeMultiplier: 1,
+  baseFeeHistoryWindow: 20,
+  minPriorityFeeRatioOfBaseFee: 0.2,
+  minPriorityFeeGwei: 2,
+  maxPriorityFeeGwei: 9,
+}
+
+// The default "Urgent" strategy that was previously hardcoded in the gas service
+export const DEFAULT_GAS_STRATEGY: GasStrategy = URGENT_GAS_STRATEGY
+
+export enum GasSpeed {
+  Normal = 'normal',
+  Fast = 'fast',
+  Urgent = 'urgent',
+}
+
+export const GAS_SPEED_STRATEGIES: Record<GasSpeed, GasStrategy> = {
+  [GasSpeed.Normal]: NORMAL_GAS_STRATEGY,
+  [GasSpeed.Fast]: FAST_GAS_STRATEGY,
+  [GasSpeed.Urgent]: URGENT_GAS_STRATEGY,
+} as const
+
+export function applyNativeTokenPercentageBuffer(
+  currencyAmount: Maybe<CurrencyAmount<Currency>>,
+  nativeTokenPercentageBuffer: number,
+): Maybe<CurrencyAmount<Currency>> {
+  if (!currencyAmount) {
+    return undefined
+  }
+
+  if (!currencyAmount.currency.isNative) {
+    return currencyAmount
+  }
+
+  // Calculate the remaining percentage (e.g., for 10% reduction, multiply by 0.9)
+  const remainingPercentage = JSBI.subtract(
+    JSBI.BigInt(10000),
+    JSBI.BigInt(Math.floor(nativeTokenPercentageBuffer * 100)),
+  )
+
+  // currencyAmount is 1 ETH (1000000000000000000 wei)
+  const totalAmount = currencyAmount.quotient
+  // remainingAmount is remainingPercentage * totalAmount
+  // or for 10% reduction, it's 900000000000000000 wei
+  const remainingAmount = JSBI.divide(JSBI.multiply(totalAmount, remainingPercentage), JSBI.BigInt(10000))
+
+  return getCurrencyAmount({
+    value: remainingAmount.toString(),
+    valueType: ValueType.Raw,
+    currency: currencyAmount.currency,
+  })
+}
+
+function getNativeCurrencyTotalSpend({
+  value,
+  gasFee,
+  nativeCurrency,
+}: {
+  value?: CurrencyAmount<Currency>
+  gasFee?: string
+  nativeCurrency?: Currency
+}): Maybe<CurrencyAmount<Currency>> {
+  if (!gasFee || !nativeCurrency) {
+    return value
+  }
+
+  const gasFeeAmount = getCurrencyAmount({
+    value: gasFee,
+    valueType: ValueType.Raw,
+    currency: nativeCurrency,
+  })
+
+  return value && gasFeeAmount ? gasFeeAmount.add(value) : gasFeeAmount
+}
+
+export function hasSufficientFundsIncludingGas(params: {
+  transactionAmount?: CurrencyAmount<Currency>
+  gasFee?: string
+  nativeCurrencyBalance?: CurrencyAmount<Currency>
+}): boolean {
+  const { transactionAmount, gasFee, nativeCurrencyBalance } = params
+  const totalSpend = getNativeCurrencyTotalSpend({
+    value: transactionAmount,
+    gasFee,
+    nativeCurrency: nativeCurrencyBalance?.currency,
+  })
+  return !totalSpend || !nativeCurrencyBalance?.lessThan(totalSpend)
+}
+
+// Function to find the name of a gas strategy based on the GasEstimate
+export function findLocalGasStrategy(
+  gasEstimate: GasEstimate,
+  type: GasStrategyType,
+): GasStrategyWithConditions | undefined {
+  const gasStrategies = getStatsigClient().getDynamicConfig(DynamicConfigs.GasStrategies).value as GasStrategies
+  return gasStrategies.strategies.find(
+    (s) => s.conditions.types === type && areEqualGasStrategies(s.strategy, gasEstimate.strategy),
+  )
+}
+
+// Helper function to check if the config value is a valid GasStrategies object
+function isValidGasStrategies(value: unknown): value is GasStrategies {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'strategies' in value &&
+    Array.isArray((value as GasStrategies).strategies)
+  )
+}
+
+function getIsStatsigReady(): boolean {
+  return getStatsigClient().loadingStatus === 'Ready'
+}
+
+export function getActiveGasStrategy({
+  chainId,
+  type,
+  isStatsigReady,
+}: {
+  chainId: number | undefined
+  type: GasStrategyType
+  isStatsigReady?: boolean
+}): GasStrategy {
+  if (isStatsigReady === false || !getIsStatsigReady()) {
+    return DEFAULT_GAS_STRATEGY
+  }
+  const config = getStatsigClient().getDynamicConfig(DynamicConfigs.GasStrategies)
+  const gasStrategies = isValidGasStrategies(config.value) ? config.value : undefined
+  const activeStrategy = gasStrategies?.strategies.find(
+    (s) => s.conditions.chainId === chainId && s.conditions.types === type && s.conditions.isActive,
+  )
+  return activeStrategy ? activeStrategy.strategy : DEFAULT_GAS_STRATEGY
+}
+
+export function areEqualGasStrategies(a?: GasStrategy, b?: GasStrategy): boolean {
+  if (!a || !b) {
+    return false
+  }
+
+  const optionalFieldMatch = <T>(fieldA: T | undefined | null, fieldB: T | undefined | null): boolean => {
+    return fieldA == null || fieldB == null || fieldA === fieldB
+  }
+
+  // Required fields must be exactly equal
+  const requiredFieldsEqual =
+    a.limitInflationFactor === b.limitInflationFactor &&
+    a.priceInflationFactor === b.priceInflationFactor &&
+    a.percentileThresholdFor1559Fee === b.percentileThresholdFor1559Fee
+
+  // Optional fields can be undefined on either side or equal if both defined
+  const optionalFieldsMatch =
+    optionalFieldMatch(a.thresholdToInflateLastBlockBaseFee, b.thresholdToInflateLastBlockBaseFee) &&
+    optionalFieldMatch(a.baseFeeMultiplier, b.baseFeeMultiplier) &&
+    optionalFieldMatch(a.baseFeeHistoryWindow, b.baseFeeHistoryWindow) &&
+    optionalFieldMatch(a.minPriorityFeeRatioOfBaseFee, b.minPriorityFeeRatioOfBaseFee) &&
+    optionalFieldMatch(a.minPriorityFeeGwei, b.minPriorityFeeGwei) &&
+    optionalFieldMatch(a.maxPriorityFeeGwei, b.maxPriorityFeeGwei)
+
+  // displayLimitInflationFactor is not returned by the server, so it's ignored here
+  return requiredFieldsEqual && optionalFieldsMatch
+}
+
+export function getGasPrice(estimate?: GasEstimate): string | undefined {
+  return estimate && 'gasPrice' in estimate ? estimate.gasPrice : (estimate?.maxFeePerGas ?? undefined)
+}
+
+export type ValidatedGasFeeResult = Prettify<GasFeeResult & { value: string; error: null }>
+export function validateGasFeeResult(gasFee: GasFeeResult): ValidatedGasFeeResult | undefined {
+  if (gasFee.value === undefined || gasFee.error) {
+    return undefined
+  }
+  return { ...gasFee, value: gasFee.value, error: null }
+}
+
+export async function estimateGasWithClientSideProvider({
+  tx,
+  fallbackGasLimit,
+}: {
+  tx: TransactionRequest
+  fallbackGasLimit?: number
+}): Promise<GasFeeResultWithoutState> {
+  try {
+    if (!tx.chainId) {
+      throw new Error('No chainId for clientside gas estimation')
+    }
+    const provider = createEthersProvider({ chainId: tx.chainId })
+    if (!provider) {
+      throw new Error('No provider for clientside gas estimation')
+    }
+    const gasUseEstimate = (await provider.estimateGas(tx)).toNumber() * 10e9
+
+    return {
+      value: gasUseEstimate.toString(),
+      displayValue: gasUseEstimate.toString(),
+    }
+  } catch {
+    // provider.estimateGas will error if the account doesn't have sufficient ETH balance, but we should show an estimated cost anyway
+    return {
+      value: fallbackGasLimit?.toString(),
+      // These estimates don't inflate the gas limit, so we can use the same value for display
+      displayValue: fallbackGasLimit?.toString(),
+    }
+  }
+}
+
+export function extractGasFeeParams(estimate: GasEstimate): TransactionLegacyFeeParams | TransactionEip1559FeeParams {
+  if ('maxFeePerGas' in estimate) {
+    return {
+      maxFeePerGas: estimate.maxFeePerGas,
+      maxPriorityFeePerGas: estimate.maxPriorityFeePerGas,
+      gasLimit: estimate.gasLimit,
+    }
+  } else {
+    return {
+      gasPrice: estimate.gasPrice,
+      gasLimit: estimate.gasLimit,
+    }
+  }
+}
+
+/**
+ * Determines if gas estimation has failed for a transaction request.
+ * Returns true when:
+ * - The request is a transaction type that requires gas estimation
+ * - Gas fee result has finished loading
+ * - Either an error occurred OR no value was returned
+ */
+export function hasGasEstimationFailed(isTransactionRequest: boolean, gasFeeResult: GasFeeResult | undefined): boolean {
+  return (
+    isTransactionRequest && !!gasFeeResult && !gasFeeResult.isLoading && (!!gasFeeResult.error || !gasFeeResult.value)
+  )
+}

package/src/features/gating/StatsigProviderWrapper.tsx

@@ -0,0 +1,71 @@
+import {
+  type StatsigOptions,
+  StatsigProvider,
+  type StatsigUser,
+  type StorageProvider,
+  useClientAsyncInit,
+} from '@luxfi/gating'
+import { type ReactNode, useEffect, useMemo } from 'react'
+import { config } from '@luxexchange/lx/src/config'
+import { statsigBaseConfig } from '@luxexchange/lx/src/features/gating/statsigBaseConfig'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+type StatsigProviderWrapperProps = {
+  user: StatsigUser
+  children: ReactNode
+  onInit?: () => void
+  options?: Partial<StatsigUser>
+  storageProvider?: StorageProvider
+}
+
+export function StatsigProviderWrapper({
+  children,
+  options,
+  user,
+  storageProvider,
+  onInit,
+}: StatsigProviderWrapperProps): ReactNode {
+  // Skip Statsig when no API key is configured (e.g. self-hosted deployments)
+  if (!config.statsigApiKey) {
+    onInit?.()
+    return <>{children}</>
+  }
+
+  const statsigOptions = useMemo<StatsigOptions>(
+    () => ({
+      ...statsigBaseConfig,
+      storageProvider,
+      ...options,
+    }),
+    [storageProvider, options],
+  )
+
+  const { client, isLoading: isStatsigLoading } = useClientAsyncInit(config.statsigApiKey, user, statsigOptions)
+
+  useEffect(() => {
+    if (isStatsigLoading) {
+      return
+    }
+
+    onInit?.()
+  }, [isStatsigLoading, onInit])
+
+  useEffect(() => {
+    const errorHandler = (event: unknown): void => {
+      logger.error('StatsigProviderWrapper', {
+        tags: { file: 'StatsigProviderWrapper', function: 'error' },
+        extra: {
+          event,
+        },
+      })
+    }
+    client.on('error', errorHandler)
+    client.on('initialization_failure', errorHandler)
+    return () => {
+      client.off('error', errorHandler)
+      client.off('initialization_failure', errorHandler)
+    }
+  }, [client])
+
+  return <StatsigProvider client={client}>{children}</StatsigProvider>
+}

package/src/features/gating/statsigBaseConfig.ts

@@ -0,0 +1,10 @@
+import { getOverrideAdapter, getStatsigEnvName, StatsigOptions } from '@luxfi/gating'
+import { luxUrls } from '@luxexchange/lx/src/constants/urls'
+
+export const statsigBaseConfig: StatsigOptions = {
+  networkConfig: { api: luxUrls.statsigProxyUrl },
+  environment: {
+    tier: getStatsigEnvName(),
+  },
+  overrideAdapter: getOverrideAdapter(),
+}

package/src/features/gating/typeGuards.ts

@@ -0,0 +1,23 @@
+import { GraphQLApi } from '@luxfi/api'
+import { UwULinkAllowlist } from '@luxfi/gating'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+
+export const isUwULinkAllowlistType = (x: unknown): x is UwULinkAllowlist => {
+  const hasFields =
+    x !== null && typeof x === 'object' && Object.hasOwn(x, 'contracts') && Object.hasOwn(x, 'tokenRecipients')
+
+  if (!hasFields) {
+    return false
+  }
+
+  const castedObj = x as { contracts: unknown; tokenRecipients: unknown }
+
+  return Array.isArray(castedObj.contracts) && Array.isArray(castedObj.tokenRecipients)
+}
+
+export const isUniverseChainIdArrayType = (x: unknown): x is UniverseChainId[] =>
+  Array.isArray(x) && x.every((c: unknown) => typeof c === 'number')
+
+export const isContractInputArrayType = (x: unknown): x is GraphQLApi.ContractInput[] =>
+  Array.isArray(x) &&
+  x.every((val) => typeof val.chain === 'string' && (!val.address || typeof val.address === 'string'))