@l.x/gating 1.0.3 → 1.0.4

package/src/flags.ts

@@ -0,0 +1,222 @@
+import { logger } from 'utilities/src/logger/logger'
+import { isWebApp } from 'utilities/src/platform'
+
+// only disable for this enum
+/**
+ * Feature flag names.
+ * Add in alphabetical order for each section to decrease probability of merge conflicts.
+ */
+/* biome-ignore-start lint/style/useEnumInitializers: preserve the order */
+export enum FeatureFlags {
+  // Shared
+  AllowDEXOnlyRoutesInSwapSettings,
+  ArbitrumDutchV3,
+  BlockaidFotLogging,
+  CentralizedPrices,
+  ChainedActions,
+  DisableSwap7702,
+  DisableSessionsForPlan,
+  EmbeddedWallet,
+  EnablePermitMismatchUX,
+  ForceDisableWalletGetCapabilities,
+  ForcePermitTransactions,
+  ForSessionsEnabled,
+  ForUrlMigration,
+  GasServiceV2,
+  HashcashSolverEnabled,
+  Monad,
+  MultichainTokenUx,
+  NetworkFilterV2,
+  NoLxInterfaceFees,
+  PortionFields,
+  ProfitLoss,
+  SessionsPerformanceTrackingEnabled,
+  SessionsServiceEnabled,
+  SessionsUpgradeAutoEnabled,
+  SmartWallet,
+  SmartWalletDisableVideo,
+  Solana,
+  Soneium,
+  Tempo,
+  TurnstileSolverEnabled,
+  TwoSecondSwapQuotePollingInterval,
+  UnichainFlashblocks,
+  UniquoteEnabled,
+  UniroutePulumiEnabled,
+  LuxWrapped2025,
+  DEX,
+  DEXPriorityOrdersBase,
+  DEXPriorityOrdersOptimism,
+  DEXPriorityOrdersUnichain,
+  ViemProviderEnabled,
+  XLayer,
+
+  // Wallet
+  BottomTabs,
+  DisableFiatOnRampKorea,
+  Eip5792Methods,
+  EnableExportPrivateKeys,
+  EnableRestoreSeedPhrase,
+  EnableTransactionSpacingForDelegatedAccounts,
+  ExpoImage,
+
+  NotificationApiDataSource,
+  NotificationOnboardingCard,
+  NotificationService,
+
+  PrivateRpc,
+  Scantastic,
+  SelfReportSpamNFTs,
+  SmartWalletSettings,
+  UwULink,
+
+  // Web
+  AATestWeb,
+  AuctionDetailsV2,
+  BatchedSwaps,
+  DummyFlagTest,
+  LimitsFees,
+  LiquidityBatchedTransactions,
+  LpDynamicNativeSlippage,
+  LpIncentives,
+  NoLxInterfaceFeesNotification,
+  PortfolioDefiTab,
+  PortoWalletConnector,
+  SolanaPromo,
+  TDPTokenCarousel,
+  ToucanAuctionKYC,
+  ToucanLaunchAuction,
+  TraceJsonRpc,
+  UnificationCopy,
+  UnirouteEnabled,
+  UniversalSwap,
+}
+/* biome-ignore-end lint/style/useEnumInitializers: preserve the order */
+
+// These names must match the gate name on statsig.
+// Add in alphabetical order to decrease probability of merge conflicts.
+export const SHARED_FEATURE_FLAG_NAMES = new Map<FeatureFlags, string>([
+  [FeatureFlags.AllowDEXOnlyRoutesInSwapSettings, 'allow_luxx_only_routes_in_swap_settings'],
+  [FeatureFlags.ArbitrumDutchV3, 'luxx_dutchv3_orders_arbitrum'],
+  [FeatureFlags.BlockaidFotLogging, 'blockaid_fot_logging'],
+  [FeatureFlags.CentralizedPrices, 'centralized_prices'],
+  [FeatureFlags.ChainedActions, 'enable_chained_actions'],
+  [FeatureFlags.DisableSwap7702, 'disable-swap-7702'],
+  [FeatureFlags.DisableSessionsForPlan, 'disable_sessions_for_plan'],
+  [FeatureFlags.EmbeddedWallet, 'embedded_wallet'],
+  [FeatureFlags.EnablePermitMismatchUX, 'enable_permit2_mismatch_ux'],
+  [FeatureFlags.ForceDisableWalletGetCapabilities, 'force_disable_wallet_get_capabilities'],
+  [FeatureFlags.ForcePermitTransactions, 'force_permit_transactions'],
+  [FeatureFlags.ForSessionsEnabled, 'for_sessions_enabled'],
+  [FeatureFlags.ForUrlMigration, 'for_url_migration'],
+  [FeatureFlags.GasServiceV2, 'gas_service_v2'],
+  [FeatureFlags.HashcashSolverEnabled, 'sessions_hashcash_solver_enabled'],
+  [FeatureFlags.Monad, 'monad'],
+  [FeatureFlags.MultichainTokenUx, 'multichain_token_ux'],
+  [FeatureFlags.NetworkFilterV2, 'network_filter_v2'],
+  [FeatureFlags.NoLxInterfaceFees, 'no_lx_interface_fees'],
+  [FeatureFlags.NotificationApiDataSource, 'notification_api_data_source'],
+  [FeatureFlags.PortionFields, 'portion-fields'],
+  [FeatureFlags.ProfitLoss, 'profit_loss'],
+  [FeatureFlags.SelfReportSpamNFTs, 'self-report-spam-nfts'],
+  [FeatureFlags.SessionsPerformanceTrackingEnabled, 'sessions_performance_tracking_enabled'],
+  [FeatureFlags.SessionsServiceEnabled, 'sessions_service_enabled'],
+  [FeatureFlags.SessionsUpgradeAutoEnabled, 'sessions_upgrade_auto_enabled'],
+  [FeatureFlags.SmartWallet, 'smart-wallet'],
+  [FeatureFlags.SmartWalletDisableVideo, 'smart_wallet_disable_video'],
+  [FeatureFlags.Solana, 'solana'],
+  [FeatureFlags.Soneium, 'soneium'],
+  [FeatureFlags.Tempo, 'tempo'],
+  [FeatureFlags.TurnstileSolverEnabled, 'sessions_turnstile_solver_enabled'],
+  [FeatureFlags.TwoSecondSwapQuotePollingInterval, 'two_second_swap_quote_polling_interval'],
+  [FeatureFlags.UnichainFlashblocks, 'unichain_flashblocks'],
+  [FeatureFlags.UniquoteEnabled, 'uniquote_enabled'],
+  [FeatureFlags.UnirouteEnabled, 'uniroute_rollout'],
+  [FeatureFlags.UniroutePulumiEnabled, 'uniroute_pulumi_enabled'],
+  [FeatureFlags.LuxWrapped2025, 'lux_wrapped_2025'],
+  [FeatureFlags.DEX, 'luxx'],
+  [FeatureFlags.DEXPriorityOrdersBase, 'luxx_priority_orders_base'],
+  [FeatureFlags.DEXPriorityOrdersOptimism, 'luxx_priority_orders_optimism'],
+  [FeatureFlags.DEXPriorityOrdersUnichain, 'luxx_priority_orders_unichain'],
+  [FeatureFlags.ViemProviderEnabled, 'viem_provider_enabled'],
+  [FeatureFlags.XLayer, 'x_layer'],
+])
+
+// These names must match the gate name on statsig.
+// Add in alphabetical order to decrease probability of merge conflicts.
+export const WEB_FEATURE_FLAG_NAMES = new Map<FeatureFlags, string>([
+  ...SHARED_FEATURE_FLAG_NAMES,
+  [FeatureFlags.AATestWeb, 'aatest_web'],
+  [FeatureFlags.AuctionDetailsV2, 'auction_details_v2'],
+  [FeatureFlags.BatchedSwaps, 'batched_swaps'],
+  [FeatureFlags.DummyFlagTest, 'dummy_flag_test'],
+  [FeatureFlags.LimitsFees, 'limits_fees'],
+  [FeatureFlags.LiquidityBatchedTransactions, 'liquidity_batched_transactions'],
+  [FeatureFlags.LpDynamicNativeSlippage, 'lp_dynamic_native_slippage'],
+  [FeatureFlags.LpIncentives, 'lp_incentives'],
+  [FeatureFlags.NoLxInterfaceFeesNotification, 'no_lx_interface_fees_notification'],
+  [FeatureFlags.PortfolioDefiTab, 'portfolio_defi_tab'],
+  [FeatureFlags.PortoWalletConnector, 'porto_wallet_connector'],
+  [FeatureFlags.SolanaPromo, 'solana_promo'],
+  [FeatureFlags.TDPTokenCarousel, 'tdp_token_carousel'],
+  [FeatureFlags.ToucanAuctionKYC, 'toucan_auction_kyc'],
+  [FeatureFlags.ToucanLaunchAuction, 'toucan_launch_auction'],
+  [FeatureFlags.TraceJsonRpc, 'traceJsonRpc'],
+  [FeatureFlags.UnichainFlashblocks, 'unichain_flashblocks'],
+  [FeatureFlags.UnificationCopy, 'unification_copy'],
+  [FeatureFlags.UniversalSwap, 'universal_swap'],
+])
+
+// These names must match the gate name on statsig.
+// Add in alphabetical order to decrease probability of merge conflicts.
+export const WALLET_FEATURE_FLAG_NAMES = new Map<FeatureFlags, string>([
+  ...SHARED_FEATURE_FLAG_NAMES,
+  [FeatureFlags.BottomTabs, 'bottom_tabs'],
+  [FeatureFlags.DisableFiatOnRampKorea, 'disable-fiat-onramp-korea'],
+  [FeatureFlags.Eip5792Methods, 'eip_5792_methods'],
+  [FeatureFlags.EnableExportPrivateKeys, 'enable-export-private-keys'],
+  [FeatureFlags.EnableRestoreSeedPhrase, 'enable-restore-seed-phrase'],
+  [FeatureFlags.EnableTransactionSpacingForDelegatedAccounts, 'enable_transaction_spacing_for_delegated_accounts'],
+  [FeatureFlags.ExpoImage, 'expo_image'],
+
+  [FeatureFlags.NotificationOnboardingCard, 'notification_onboarding_card'],
+  [FeatureFlags.NotificationService, 'notification_system'],
+  [FeatureFlags.PrivateRpc, 'mev-blocker'],
+  [FeatureFlags.Scantastic, 'scantastic'],
+  [FeatureFlags.SmartWalletSettings, 'smart_wallet_settings'],
+  [FeatureFlags.UwULink, 'uwu-link'],
+])
+
+export enum FeatureFlagClient {
+  Web = 0,
+  Wallet = 1,
+}
+
+const FEATURE_FLAG_NAMES = {
+  [FeatureFlagClient.Web]: WEB_FEATURE_FLAG_NAMES,
+  [FeatureFlagClient.Wallet]: WALLET_FEATURE_FLAG_NAMES,
+}
+
+export function getFeatureFlagName(flag: FeatureFlags, client?: FeatureFlagClient): string {
+  const names =
+    client !== undefined
+      ? FEATURE_FLAG_NAMES[client]
+      : isWebApp
+        ? FEATURE_FLAG_NAMES[FeatureFlagClient.Web]
+        : FEATURE_FLAG_NAMES[FeatureFlagClient.Wallet]
+  const name = names.get(flag)
+  if (!name) {
+    const err = new Error(`Feature ${FeatureFlags[flag]} does not have a name mapped for this application`)
+
+    logger.error(err, {
+      tags: {
+        file: 'flags.ts',
+        function: 'getFeatureFlagName',
+      },
+    })
+
+    throw err
+  }
+
+  return name
+}

package/src/getIsHashcashSolverEnabled.ts

@@ -0,0 +1,12 @@
+import { FeatureFlags } from '@l.x/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@l.x/gating/src/hooks'
+
+function getIsHashcashSolverEnabled(): boolean {
+  return getFeatureFlag(FeatureFlags.HashcashSolverEnabled)
+}
+
+function useIsHashcashSolverEnabled(): boolean {
+  return useFeatureFlag(FeatureFlags.HashcashSolverEnabled)
+}
+
+export { getIsHashcashSolverEnabled, useIsHashcashSolverEnabled }

package/src/getIsPerformanceTrackingEnabled.ts

@@ -0,0 +1,19 @@
+import { FeatureFlags } from '@l.x/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@l.x/gating/src/hooks'
+
+/**
+ * Returns whether sessions performance tracking is enabled.
+ *
+ * Defaults to false (disabled) - must be explicitly enabled via Statsig flag.
+ * When enabled, session analytics will include duration measurements.
+ * When disabled, duration values will be -1 (sentinel value).
+ */
+function getIsSessionsPerformanceTrackingEnabled(): boolean {
+  return getFeatureFlag(FeatureFlags.SessionsPerformanceTrackingEnabled)
+}
+
+function useIsSessionsPerformanceTrackingEnabled(): boolean {
+  return useFeatureFlag(FeatureFlags.SessionsPerformanceTrackingEnabled)
+}
+
+export { getIsSessionsPerformanceTrackingEnabled, useIsSessionsPerformanceTrackingEnabled }

package/src/getIsSessionServiceEnabled.ts

@@ -0,0 +1,14 @@
+import { getConfig } from '@l.x/config'
+import { FeatureFlags } from '@l.x/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@l.x/gating/src/hooks'
+
+function getIsSessionServiceEnabled(): boolean {
+  return getConfig().enableSessionService || getFeatureFlag(FeatureFlags.SessionsServiceEnabled)
+}
+
+function useIsSessionServiceEnabled(): boolean {
+  const featureFlagEnabled = useFeatureFlag(FeatureFlags.SessionsServiceEnabled)
+  return getConfig().enableSessionService || featureFlagEnabled
+}
+
+export { getIsSessionServiceEnabled, useIsSessionServiceEnabled }

package/src/getIsSessionUpgradeAutoEnabled.ts

@@ -0,0 +1,9 @@
+import { getConfig } from '@l.x/config'
+import { FeatureFlags } from '@l.x/gating/src/flags'
+import { getFeatureFlag } from '@l.x/gating/src/hooks'
+
+function getIsSessionUpgradeAutoEnabled(): boolean {
+  return getConfig().enableSessionUpgradeAuto || getFeatureFlag(FeatureFlags.SessionsUpgradeAutoEnabled)
+}
+
+export { getIsSessionUpgradeAutoEnabled }

package/src/getIsTurnstileSolverEnabled.ts

@@ -0,0 +1,12 @@
+import { FeatureFlags } from '@l.x/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@l.x/gating/src/hooks'
+
+function getIsTurnstileSolverEnabled(): boolean {
+  return getFeatureFlag(FeatureFlags.TurnstileSolverEnabled)
+}
+
+function useIsTurnstileSolverEnabled(): boolean {
+  return useFeatureFlag(FeatureFlags.TurnstileSolverEnabled)
+}
+
+export { getIsTurnstileSolverEnabled, useIsTurnstileSolverEnabled }

package/src/getStatsigEnvName.ts

@@ -0,0 +1,19 @@
+import { isBetaEnv, isProdEnv } from 'utilities/src/environment/env'
+import { isWebApp } from 'utilities/src/platform'
+
+export enum StatsigEnvName {
+  Beta = 'beta', // mobile and extension environment-specific
+  Development = 'development',
+  Production = 'production',
+  Staging = 'staging', // interface (web) environment-specific
+}
+
+export function getStatsigEnvName(): StatsigEnvName {
+  if (isBetaEnv()) {
+    return isWebApp ? StatsigEnvName.Staging : StatsigEnvName.Beta
+  }
+  if (isProdEnv()) {
+    return StatsigEnvName.Production
+  }
+  return StatsigEnvName.Development
+}

package/src/hooks.ts

@@ -0,0 +1,244 @@
+import { StatsigClientEventCallback, StatsigLoadingStatus } from '@statsig/client-core'
+import { DynamicConfigKeys } from '@l.x/gating/src/configs'
+import { ExperimentProperties, Experiments } from '@l.x/gating/src/experiments'
+import { FeatureFlags, getFeatureFlagName } from '@l.x/gating/src/flags'
+import {
+  getStatsigClient,
+  TypedReturn,
+  useDynamicConfig,
+  useExperiment,
+  useFeatureGate,
+  useGateValue,
+  useLayer,
+  useStatsigClient,
+} from '@l.x/gating/src/sdk/statsig'
+import { useEffect, useMemo, useState } from 'react'
+import { logger } from 'utilities/src/logger/logger'
+
+export function useFeatureFlag(flag: FeatureFlags): boolean {
+  const name = getFeatureFlagName(flag)
+  const value = useGateValue(name)
+  return value
+}
+
+export function useFeatureFlagWithLoading(flag: FeatureFlags): { value: boolean; isLoading: boolean } {
+  const { isStatsigLoading } = useStatsigClientStatus()
+  const name = getFeatureFlagName(flag)
+  const { value } = useFeatureGate(name)
+  return { value, isLoading: isStatsigLoading }
+}
+
+export function getFeatureFlag(flag: FeatureFlags): boolean {
+  try {
+    const name = getFeatureFlagName(flag)
+    return getStatsigClient().checkGate(name)
+  } catch (e) {
+    logger.debug('gating/hooks.ts', 'getFeatureFlag', JSON.stringify({ e }))
+    return false
+  }
+}
+
+export function useFeatureFlagWithExposureLoggingDisabled(flag: FeatureFlags): boolean {
+  const name = getFeatureFlagName(flag)
+  const value = useGateValue(name, { disableExposureLog: true })
+  return value
+}
+
+export function getFeatureFlagWithExposureLoggingDisabled(flag: FeatureFlags): boolean {
+  const name = getFeatureFlagName(flag)
+  return getStatsigClient().checkGate(name, { disableExposureLog: true })
+}
+
+export function useExperimentGroupNameWithLoading(experiment: Experiments): {
+  value: string | null
+  isLoading: boolean
+} {
+  const { isStatsigLoading } = useStatsigClientStatus()
+  const statsigExperiment = useExperiment(experiment)
+  return { value: statsigExperiment.groupName, isLoading: isStatsigLoading }
+}
+
+export function useExperimentGroupName(experiment: Experiments): string | null {
+  const { groupName } = useExperiment(experiment)
+  return groupName
+}
+
+export function useExperimentValue<
+  Exp extends keyof ExperimentProperties,
+  Param extends ExperimentProperties[Exp],
+  ValType,
+>({
+  experiment,
+  param,
+  defaultValue,
+  customTypeGuard,
+}: {
+  experiment: Exp
+  param: Param
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const statsigExperiment = useExperiment(experiment)
+  const value = statsigExperiment.get(param, defaultValue)
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function getExperimentValue<
+  Exp extends keyof ExperimentProperties,
+  Param extends ExperimentProperties[Exp],
+  ValType,
+>({
+  experiment,
+  param,
+  defaultValue,
+  customTypeGuard,
+}: {
+  experiment: Exp
+  param: Param
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const statsigExperiment = getStatsigClient().getExperiment(experiment)
+  const value = statsigExperiment.get(param, defaultValue)
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function useExperimentValueWithExposureLoggingDisabled<
+  Exp extends keyof ExperimentProperties,
+  Param extends ExperimentProperties[Exp],
+  ValType,
+>({
+  experiment,
+  param,
+  defaultValue,
+  customTypeGuard,
+}: {
+  experiment: Exp
+  param: Param
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const statsigExperiment = useExperiment(experiment, { disableExposureLog: true })
+  const value = statsigExperiment.get(param, defaultValue)
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function useDynamicConfigValue<
+  Conf extends keyof DynamicConfigKeys,
+  Key extends DynamicConfigKeys[Conf],
+  ValType,
+>({
+  config,
+  key,
+  defaultValue,
+  customTypeGuard,
+}: {
+  config: Conf
+  key: Key
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const dynamicConfig = useDynamicConfig(config)
+  const value = dynamicConfig.get(key, defaultValue)
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function getDynamicConfigValue<
+  Conf extends keyof DynamicConfigKeys,
+  Key extends DynamicConfigKeys[Conf],
+  ValType,
+>({
+  config,
+  key,
+  defaultValue,
+  customTypeGuard,
+}: {
+  config: Conf
+  key: Key
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const dynamicConfig = getStatsigClient().getDynamicConfig(config)
+  const value = dynamicConfig.get(key, defaultValue)
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function getExperimentValueFromLayer<Layer extends string, Exp extends keyof ExperimentProperties, ValType>({
+  layerName,
+  param,
+  defaultValue,
+  customTypeGuard,
+}: {
+  layerName: Layer
+  param: ExperimentProperties[Exp]
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const layer = getStatsigClient().getLayer(layerName)
+  const value = layer.get(param, defaultValue)
+  // we directly get param from layer; these are spread from experiments
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function useExperimentValueFromLayer<Layer extends string, Exp extends keyof ExperimentProperties, ValType>({
+  layerName,
+  param,
+  defaultValue,
+  customTypeGuard,
+}: {
+  layerName: Layer
+  param: ExperimentProperties[Exp]
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const layer = useLayer(layerName)
+  const value = layer.get(param, defaultValue)
+  // we directly get param from layer; these are spread from experiments
+  return checkTypeGuard({ value, defaultValue, customTypeGuard })
+}
+
+export function checkTypeGuard<ValType>({
+  value,
+  defaultValue,
+  customTypeGuard,
+}: {
+  value: TypedReturn<ValType>
+  defaultValue: ValType
+  customTypeGuard?: (x: unknown) => x is ValType
+}): ValType {
+  const isOfDefaultValueType = (val: unknown): val is ValType => typeof val === typeof defaultValue
+
+  if (customTypeGuard?.(value) || isOfDefaultValueType(value)) {
+    return value
+  } else {
+    return defaultValue
+  }
+}
+
+export function useStatsigClientStatus(): {
+  isStatsigLoading: boolean
+  isStatsigReady: boolean
+  isStatsigUninitialized: boolean
+} {
+  const { client } = useStatsigClient()
+  const [statsigStatus, setStatsigStatus] = useState<StatsigLoadingStatus>(client.loadingStatus)
+
+  useEffect(() => {
+    const handler: StatsigClientEventCallback<'values_updated'> = (event) => {
+      setStatsigStatus(event.status)
+    }
+    client.on('values_updated', handler)
+    return () => {
+      client.off('values_updated', handler)
+    }
+  }, [client])
+
+  return useMemo(
+    () => ({
+      isStatsigLoading: statsigStatus === 'Loading',
+      isStatsigReady: statsigStatus === 'Ready',
+      isStatsigUninitialized: statsigStatus === 'Uninitialized',
+    }),
+    [statsigStatus],
+  )
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+export type {
+  DatadogIgnoredErrorsValType,
+  DatadogSessionSampleRateValType,
+  DynamicConfigKeys,
+  ForceUpgradeStatus,
+  ForceUpgradeTranslations,
+  GasStrategies,
+  GasStrategyType,
+  GasStrategyWithConditions,
+  UwULinkAllowlist,
+  UwULinkAllowlistItem,
+} from '@l.x/gating/src/configs'
+export {
+  AllowedV4WethHookAddressesConfigKey,
+  BlockedAsyncSubmissionChainIdsConfigKey,
+  ChainsConfigKey,
+  CreateAuctionConfigKey,
+  DatadogIgnoredErrorsConfigKey,
+  DatadogSessionSampleRateKey,
+  DynamicConfigs,
+  EmbeddedWalletBetaPassphrasesKey,
+  EmbeddedWalletConfigKey,
+  ExtensionBiometricUnlockConfigKey,
+  ExternallyConnectableExtensionConfigKey,
+  ForceUpgradeConfigKey,
+  HomeScreenExploreTokensConfigKey,
+  LPConfigKey,
+  NetworkRequestsConfigKey,
+  OnDeviceRecoveryConfigKey,
+  OutageBannerChainIdConfigKey,
+  SwapConfigKey,
+  SyncTransactionSubmissionChainIdsConfigKey,
+  UwuLinkConfigKey,
+  VerifiedAuctionsConfigKey,
+} from '@l.x/gating/src/configs'
+export { StatsigCustomAppValue } from '@l.x/gating/src/constants'
+export type { ExperimentProperties } from '@l.x/gating/src/experiments'
+export {
+  EthAsErc20DEXProperties,
+  Experiments,
+  ExploreBackendSortingProperties,
+  LayerProperties,
+  Layers,
+  NativeTokenPercentageBufferProperties,
+  PrivateRpcProperties,
+  UnichainFlashblocksProperties,
+} from '@l.x/gating/src/experiments'
+export {
+  FeatureFlagClient,
+  FeatureFlags,
+  getFeatureFlagName,
+  WALLET_FEATURE_FLAG_NAMES,
+  WEB_FEATURE_FLAG_NAMES,
+} from '@l.x/gating/src/flags'
+export { getIsHashcashSolverEnabled, useIsHashcashSolverEnabled } from '@l.x/gating/src/getIsHashcashSolverEnabled'
+export {
+  getIsSessionsPerformanceTrackingEnabled,
+  useIsSessionsPerformanceTrackingEnabled,
+} from '@l.x/gating/src/getIsPerformanceTrackingEnabled'
+export { getIsSessionServiceEnabled, useIsSessionServiceEnabled } from '@l.x/gating/src/getIsSessionServiceEnabled'
+export { getIsSessionUpgradeAutoEnabled } from '@l.x/gating/src/getIsSessionUpgradeAutoEnabled'
+export {
+  getIsTurnstileSolverEnabled,
+  useIsTurnstileSolverEnabled,
+} from '@l.x/gating/src/getIsTurnstileSolverEnabled'
+export { getStatsigEnvName } from '@l.x/gating/src/getStatsigEnvName'
+export {
+  getDynamicConfigValue,
+  getExperimentValue,
+  getExperimentValueFromLayer,
+  getFeatureFlag,
+  useDynamicConfigValue,
+  useExperimentValue,
+  useExperimentValueFromLayer,
+  useExperimentValueWithExposureLoggingDisabled,
+  useFeatureFlag,
+  useFeatureFlagWithExposureLoggingDisabled,
+  useFeatureFlagWithLoading,
+  useStatsigClientStatus,
+} from '@l.x/gating/src/hooks'
+export { LocalOverrideAdapterWrapper } from '@l.x/gating/src/LocalOverrideAdapterWrapper'
+export type {
+  StatsigOptions,
+  StatsigUser,
+  StorageProvider,
+} from '@l.x/gating/src/sdk/statsig'
+export {
+  getOverrideAdapter,
+  getStatsigClient,
+  StatsigClient,
+  StatsigContext,
+  StatsigProvider,
+  Storage,
+  useClientAsyncInit,
+  useExperiment,
+  useGateValue,
+  useLayer,
+} from '@l.x/gating/src/sdk/statsig'
+export { getOverrides } from '@l.x/gating/src/utils'

package/src/sdk/statsig.native.ts

@@ -0,0 +1,33 @@
+import { type StatsigClient } from '@statsig/react-bindings'
+import { StatsigClientRN } from '@statsig/react-native-bindings'
+import { getConfig } from '@l.x/config'
+import { LocalOverrideAdapterWrapper } from '@l.x/gating/src/LocalOverrideAdapterWrapper'
+
+const config = getConfig()
+
+export type { StatsigOptions, StatsigUser, StorageProvider, TypedReturn } from '@statsig/react-native-bindings'
+export {
+  StatsigClient,
+  StatsigContext,
+  StatsigProviderRN as StatsigProvider,
+  Storage,
+  useClientAsyncInitRN as useClientAsyncInit,
+  useDynamicConfig,
+  useExperiment,
+  useFeatureGate,
+  useGateValue,
+  useLayer,
+  useStatsigClient,
+  useStatsigUser,
+} from '@statsig/react-native-bindings'
+
+let localOverrideAdapter: LocalOverrideAdapterWrapper | undefined
+
+export const getOverrideAdapter = (): LocalOverrideAdapterWrapper => {
+  if (!localOverrideAdapter) {
+    localOverrideAdapter = new LocalOverrideAdapterWrapper(config.statsigApiKey)
+  }
+  return localOverrideAdapter
+}
+
+export const getStatsigClient = (): StatsigClient => StatsigClientRN.instance(config.statsigApiKey)