@luxexchange/gating 1.0.0

package/.depcheckrc

@@ -0,0 +1,13 @@
+ignores: [
+    # Standard ignores
+    "typescript",
+    "@typescript/native-preview",
+    "depcheck",
+
+    # Internal packages / workspaces
+    "@universe/gating",
+    "@universe/config",
+
+    # Peer dependencies
+    "react",
+  ]

package/.eslintrc.js

@@ -0,0 +1,21 @@
+module.exports = {
+  extends: ['@luxfi/eslint-config/lib'],
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+  },
+  overrides: [
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {
+        'no-relative-import-paths/no-relative-import-paths': [
+          'error',
+          {
+            allowSameFolder: false,
+            prefix: '@luxfi/gating',
+          },
+        ],
+        '@typescript-eslint/prefer-enum-initializers': 'off',
+      },
+    },
+  ],
+}

package/README.md

@@ -0,0 +1,3 @@
+# @universe/gating
+
+// TODO

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@luxexchange/gating",
+  "version": "1.0.0",
+  "dependencies": {
+    "@statsig/client-core": "3.12.2",
+    "@statsig/js-client": "3.12.2",
+    "@statsig/js-local-overrides": "3.12.2",
+    "@statsig/react-bindings": "3.12.2",
+    "@statsig/react-native-bindings": "3.12.2",
+    "@luxexchange/api": "^1.0.0",
+    "@luxfi/utilities": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.1",
+    "@typescript/native-preview": "7.0.0-dev.20260108.1",
+    "@luxfi/eslint-config": "^1.0.0",
+    "depcheck": "1.4.7",
+    "eslint": "8.57.1",
+    "typescript": "5.8.3"
+  },
+  "scripts": {
+    "typecheck": "nx typecheck gating",
+    "typecheck:tsgo": "nx typecheck:tsgo gating",
+    "lint": "nx lint gating",
+    "lint:fix": "nx lint:fix gating",
+    "lint:biome": "nx lint:biome gating",
+    "lint:biome:fix": "nx lint:biome:fix gating",
+    "lint:eslint": "nx lint:eslint gating",
+    "lint:eslint:fix": "nx lint:eslint:fix gating",
+    "check:deps:usage": "nx check:deps:usage gating"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "main": "src/index.ts",
+  "private": false,
+  "sideEffects": false
+}

package/project.json

@@ -0,0 +1,18 @@
+{
+  "name": "@luxfi/gating",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "pkgs/gating/src",
+  "projectType": "library",
+  "tags": ["scope:gating", "type:lib"],
+  "targets": {
+    "typecheck": {},
+    "typecheck:tsgo": {},
+    "lint:biome": {},
+    "lint:biome:fix": {},
+    "lint:eslint": {},
+    "lint:eslint:fix": {},
+    "lint": {},
+    "lint:fix": {},
+    "check:deps:usage": {}
+  }
+}

package/src/LocalOverrideAdapterWrapper.ts

@@ -0,0 +1,63 @@
+import { LocalOverrideAdapter } from '@statsig/js-local-overrides'
+import { getStatsigClient } from '@luxfi/gating/src/sdk/statsig'
+
+// Workaround for @statsig 3.x.x refreshing client after applying overrides to get the result without reloading
+// Should be removed after statsig add real time override apply functionality
+// Adds refresh only to used LocalOverrideAdapter methods. Other methods need to be added if refresh is required.
+export class LocalOverrideAdapterWrapper extends LocalOverrideAdapter {
+  constructor(sdkKey: string) {
+    super(sdkKey)
+  }
+
+  refreshStatsig(): void {
+    const statsigClient = getStatsigClient()
+    const statsigUser = statsigClient.getContext().user
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    statsigClient.updateUserAsync(statsigUser)
+  }
+
+  overrideGate(name: string, value: boolean): void {
+    super.overrideGate(name, value)
+    this.refreshStatsig()
+  }
+
+  removeGateOverride(name: string): void {
+    super.removeGateOverride(name)
+    this.refreshStatsig()
+  }
+
+  overrideDynamicConfig(name: string, value: Record<string, unknown>): void {
+    super.overrideDynamicConfig(name, value)
+    this.refreshStatsig()
+  }
+
+  removeDynamicConfigOverride(name: string): void {
+    super.removeDynamicConfigOverride(name)
+    this.refreshStatsig()
+  }
+
+  removeAllOverrides(): void {
+    super.removeAllOverrides()
+    this.refreshStatsig()
+  }
+
+  removeExperimentOverride(name: string): void {
+    super.removeExperimentOverride(name)
+    this.refreshStatsig()
+  }
+
+  overrideExperiment(name: string, value: Record<string, unknown>): void {
+    super.overrideExperiment(name, value)
+    this.refreshStatsig()
+  }
+
+  overrideLayer(name: string, value: Record<string, unknown>): void {
+    super.overrideLayer(name, value)
+    this.refreshStatsig()
+  }
+
+  removeLayerOverride(name: string): void {
+    super.removeLayerOverride(name)
+    this.refreshStatsig()
+  }
+}

package/src/configs.ts

@@ -0,0 +1,289 @@
+import { GasStrategy } from '@luxfi/api'
+
+// TODO: move to own package
+export enum Locale {
+  Afrikaans = 'af-ZA',
+  ArabicSaudi = 'ar-SA',
+  Catalan = 'ca-ES',
+  ChineseSimplified = 'zh-Hans',
+  ChineseTraditional = 'zh-Hant',
+  CzechCzechia = 'cs-CZ',
+  DanishDenmark = 'da-DK',
+  DutchNetherlands = 'nl-NL',
+  EnglishUnitedStates = 'en-US',
+  FinnishFinland = 'fi-FI',
+  FrenchFrance = 'fr-FR',
+  GreekGreece = 'el-GR',
+  HebrewIsrael = 'he-IL',
+  HindiIndia = 'hi-IN',
+  HungarianHungarian = 'hu-HU',
+  IndonesianIndonesia = 'id-ID',
+  ItalianItaly = 'it-IT',
+  JapaneseJapan = 'ja-JP',
+  KoreanKorea = 'ko-KR',
+  MalayMalaysia = 'ms-MY',
+  NorwegianNorway = 'no-NO',
+  PolishPoland = 'pl-PL',
+  PortugueseBrazil = 'pt-BR',
+  PortuguesePortugal = 'pt-PT',
+  RomanianRomania = 'ro-RO',
+  RussianRussia = 'ru-RU',
+  Serbian = 'sr-SP',
+  SpanishLatam = 'es-419',
+  SpanishBelize = 'es-BZ',
+  SpanishCuba = 'es-CU',
+  SpanishDominicanRepublic = 'es-DO',
+  SpanishGuatemala = 'es-GT',
+  SpanishHonduras = 'es-HN',
+  SpanishMexico = 'es-MX',
+  SpanishNicaragua = 'es-NI',
+  SpanishPanama = 'es-PA',
+  SpanishPeru = 'es-PE',
+  SpanishPuertoRico = 'es-PR',
+  SpanishElSalvador = 'es-SV',
+  SpanishUnitedStates = 'es-US',
+  SpanishArgentina = 'es-AR',
+  SpanishBolivia = 'es-BO',
+  SpanishChile = 'es-CL',
+  SpanishColombia = 'es-CO',
+  SpanishCostaRica = 'es-CR',
+  SpanishEcuador = 'es-EC',
+  SpanishSpain = 'es-ES',
+  SpanishParaguay = 'es-PY',
+  SpanishUruguay = 'es-UY',
+  SpanishVenezuela = 'es-VE',
+  SwahiliTanzania = 'sw-TZ',
+  SwedishSweden = 'sv-SE',
+  TurkishTurkey = 'tr-TR',
+  UkrainianUkraine = 'uk-UA',
+  UrduPakistan = 'ur-PK',
+  VietnameseVietnam = 'vi-VN',
+}
+
+/**
+ * Dynamic Configs
+ * These should match the dynamic config's `Config Name` on Statsig
+ */
+export enum DynamicConfigs {
+  // Shared
+  Swap = 'swap_config',
+  NetworkRequests = 'network_requests',
+  Chains = 'chains',
+  SyncTransactionSubmissionChainIds = 'sync_transaction_submission_chain_ids',
+  BlockedAsyncSubmissionChainIds = 'blocked_async_submission_chain_ids',
+
+  // Wallet
+  HomeScreenExploreTokens = 'home_screen_explore_tokens',
+  ForceUpgrade = 'force_upgrade',
+  OnDeviceRecovery = 'on_device_recovery',
+  UwuLink = 'uwulink_config',
+  GasStrategies = 'gas_strategy',
+  DatadogSessionSampleRate = 'datadog_session_sample_rate',
+  DatadogIgnoredErrors = 'datadog_ignored_errors',
+  EmbeddedWalletConfig = 'embedded_wallet_config',
+  ExtensionBiometricUnlock = 'extension_biometric_unlock_config',
+
+  // Web
+  AstroChain = 'astro_chain',
+  BlockedNftCollections = 'blocked_nft_collections',
+  ExternallyConnectableExtension = 'externally_connectable_extension',
+  LPConfig = 'lp_config',
+  AllowedV4WethHookAddresses = 'allowed_v4_weth_hook_addresses',
+  OutageBannerChainId = 'outage_banner_chain_id',
+  VerifiedAuctions = 'verified_auctions',
+}
+
+// Config values go here for easy access
+
+// Shared
+export enum SwapConfigKey {
+  AverageL1BlockTimeMs = 'averageL1BlockTimeMs',
+  AverageL2BlockTimeMs = 'averageL2BlockTimeMs',
+  TradingApiSwapRequestMs = 'tradingApiSwapRequestMs',
+
+  MinAutoSlippageToleranceL2 = 'minAutoSlippageToleranceL2',
+
+  EthSwapMinGasAmount = 'ethSwapMinGasAmount',
+  EthSendMinGasAmount = 'ethSendMinGasAmount',
+  PolygonSwapMinGasAmount = 'polygonSwapMinGasAmount',
+  PolygonSendMinGasAmount = 'polygonSendMinGasAmount',
+  AvalancheSwapMinGasAmount = 'avalancheSwapMinGasAmount',
+  AvalancheSendMinGasAmount = 'avalancheSendMinGasAmount',
+  CeloSwapMinGasAmount = 'celoSwapMinGasAmount',
+  CeloSendMinGasAmount = 'celoSendMinGasAmount',
+  MonSwapMinGasAmount = 'monSwapMinGasAmount',
+  MonSendMinGasAmount = 'monSendMinGasAmount',
+  SolanaSwapMinGasAmount = 'solanaSwapMinGasAmount',
+  SolanaSendMinGasAmount = 'solanaSendMinGasAmount',
+  GenericL2SwapMinGasAmount = 'genericL2SwapMinGasAmount',
+  GenericL2SendMinGasAmount = 'genericL2SendMinGasAmount',
+
+  LowBalanceWarningGasPercentage = 'lowBalanceWarningGasPercentage',
+}
+
+export enum NetworkRequestsConfigKey {
+  BalanceMaxRefetchAttempts = 'balanceMaxRefetchAttempts',
+}
+
+export enum ChainsConfigKey {
+  OrderedChainIds = 'orderedChainIds',
+  NewChainIds = 'newChainIds',
+}
+
+// Wallet
+export enum ForceUpgradeConfigKey {
+  Status = 'status',
+  Translations = 'translations',
+}
+
+export type ForceUpgradeStatus = 'recommended' | 'required' | 'not-required'
+
+type SupportedLocale = `${Extract<Locale[keyof Locale], string>}`
+
+type ContentMessage = {
+  title: string
+  description: string
+}
+
+export type ForceUpgradeTranslations = Record<SupportedLocale, ContentMessage>
+
+export enum EmbeddedWalletConfigKey {
+  BaseUrl = 'baseUrl',
+}
+
+export enum ExtensionBiometricUnlockConfigKey {
+  EnableOnboardingEnrollment = 'enableOnboardingEnrollment',
+  EnableSettingsEnrollment = 'enableSettingsEnrollment',
+  EnableUnlocking = 'enableUnlocking',
+}
+
+export enum SyncTransactionSubmissionChainIdsConfigKey {
+  ChainIds = 'chainIds',
+}
+
+export enum BlockedAsyncSubmissionChainIdsConfigKey {
+  ChainIds = 'chainIds',
+}
+
+export enum HomeScreenExploreTokensConfigKey {
+  EthChainId = 'ethChainId',
+  Tokens = 'tokens',
+}
+
+export enum OnDeviceRecoveryConfigKey {
+  AppLoadingTimeoutMs = 'appLoadingTimeoutMs',
+  MaxMnemonicsToLoad = 'maxMnemonicsToLoad',
+}
+
+export enum UwuLinkConfigKey {
+  Allowlist = 'allowlist',
+}
+
+export enum DatadogIgnoredErrorsConfigKey {
+  Errors = 'errors',
+}
+
+export enum DatadogSessionSampleRateKey {
+  Rate = 'rate',
+}
+
+export enum BlockedNftCollectionsConfigKey {
+  BlocklistedCollections = 'blocklistedCollections',
+}
+
+export enum ExternallyConnectableExtensionConfigKey {
+  ExtensionId = 'extensionId',
+}
+
+export type DatadogIgnoredErrorsValType = Array<{ messageContains: string; sampleRate: number }>
+
+export type DatadogSessionSampleRateValType = number
+
+export type GasStrategyType = 'general' | 'swap'
+
+export type GasStrategyConditions = {
+  name: string
+  chainId: number
+  types: GasStrategyType
+  isActive: boolean
+}
+
+export type GasStrategyWithConditions = {
+  strategy: GasStrategy
+  conditions: GasStrategyConditions
+}
+
+export type GasStrategies = {
+  strategies: GasStrategyWithConditions[]
+}
+
+// Web
+export enum QuickRouteChainsConfigKey {
+  Chains = 'quick_route_chains',
+}
+
+export enum AstroChainConfigKey {
+  Url = 'url',
+}
+
+export enum LPConfigKey {
+  DefaultSlippage = 'defaultSlippage',
+  V4SlippageOverride = 'v4SlippageOverride',
+}
+
+export enum AllowedV4WethHookAddressesConfigKey {
+  HookAddresses = 'hookAddresses',
+}
+
+export enum VerifiedAuctionsConfigKey {
+  VerifiedAuctionIds = 'verifiedAuctionIds',
+}
+
+export enum OutageBannerChainIdConfigKey {
+  ChainId = 'chainId',
+}
+
+export type DynamicConfigKeys = {
+  // Shared
+  [DynamicConfigs.Swap]: SwapConfigKey
+  [DynamicConfigs.NetworkRequests]: NetworkRequestsConfigKey
+  [DynamicConfigs.Chains]: ChainsConfigKey
+
+  // Wallet
+  [DynamicConfigs.HomeScreenExploreTokens]: HomeScreenExploreTokensConfigKey
+  [DynamicConfigs.ForceUpgrade]: ForceUpgradeConfigKey
+  [DynamicConfigs.OnDeviceRecovery]: OnDeviceRecoveryConfigKey
+  [DynamicConfigs.UwuLink]: UwuLinkConfigKey
+  [DynamicConfigs.DatadogIgnoredErrors]: DatadogIgnoredErrorsConfigKey
+  [DynamicConfigs.DatadogSessionSampleRate]: DatadogSessionSampleRateKey
+  [DynamicConfigs.EmbeddedWalletConfig]: EmbeddedWalletConfigKey
+  [DynamicConfigs.ExtensionBiometricUnlock]: ExtensionBiometricUnlockConfigKey
+  [DynamicConfigs.SyncTransactionSubmissionChainIds]: SyncTransactionSubmissionChainIdsConfigKey
+
+  // Web
+  [DynamicConfigs.AstroChain]: AstroChainConfigKey
+  [DynamicConfigs.BlockedNftCollections]: BlockedNftCollectionsConfigKey
+  [DynamicConfigs.ExternallyConnectableExtension]: ExternallyConnectableExtensionConfigKey
+  [DynamicConfigs.LPConfig]: LPConfigKey
+  [DynamicConfigs.AllowedV4WethHookAddresses]: AllowedV4WethHookAddressesConfigKey
+  [DynamicConfigs.VerifiedAuctions]: VerifiedAuctionsConfigKey
+  [DynamicConfigs.BlockedAsyncSubmissionChainIds]: BlockedAsyncSubmissionChainIdsConfigKey
+  [DynamicConfigs.OutageBannerChainId]: OutageBannerChainIdConfigKey
+}
+
+// This type must match the format in statsig dynamic config for uwulink
+// https://console.statsig.com/5HjUux4OvSGzgqWIfKFt8i/dynamic_configs/uwulink_config
+export type UwULinkAllowlistItem = {
+  chainId: number
+  address: string
+  name: string
+  logo?: {
+    dark?: string
+    light?: string
+  }
+}
+
+export type UwULinkAllowlist = {
+  contracts: UwULinkAllowlistItem[]
+  tokenRecipients: UwULinkAllowlistItem[]
+}

package/src/constants.ts

@@ -0,0 +1,4 @@
+export enum StatsigCustomAppValue {
+  Mobile = 'mobile',
+  Extension = 'extension',
+}

package/src/experiments.ts

@@ -0,0 +1,90 @@
+/**
+ * Experiment parameter names. Ordered alphabetically.
+ *
+ * These must match parameter names on Statsig within an experiment
+ */
+export enum Experiments {
+  EthAsErc20DEX = 'eth_as_erc20_luxx_experiment',
+  ExploreBackendSorting = 'explore_backend_sorting',
+  NativeTokenPercentageBuffer = 'lp_native_buffer',
+  PriceUxUpdate = 'price_ux_update',
+  PrivateRpc = 'private_rpc',
+  SwapConfirmation = 'swap-confirmation',
+  UnichainFlashblocksModal = 'unichain_flashblocks_modal',
+}
+
+export enum Layers {
+  ExplorePage = 'explore-page',
+  SwapPage = 'swap-page',
+}
+
+// experiment groups
+
+export enum NativeTokenPercentageBufferExperimentGroup {
+  Control = 'Control',
+  Buffer1 = 'Buffer1',
+}
+
+// experiment properties
+
+export enum ArbitrumXV2SamplingProperties {
+  RoutingType = 'routingType',
+}
+
+export enum PrivateRpcProperties {
+  FlashbotsEnabled = 'flashbots_enabled',
+  RefundPercent = 'refund_percent',
+}
+
+export enum NativeTokenPercentageBufferProperties {
+  BufferSize = 'bufferSize',
+}
+
+export enum SwapConfirmationProperties {
+  WaitTimes = 'wait_times',
+}
+
+export enum ExploreBackendSortingProperties {
+  BackendSortingEnabled = 'backendSortingEnabled',
+}
+
+// Swap Layer experiment properties
+
+export enum SwapLayerProperties {
+  UpdatedPriceUX = 'updatedPriceUX',
+  FlashblocksModalEnabled = 'flashblocksModalEnabled',
+  EthAsErc20DEXEnabled = 'ethAsErc20DEXEnabled',
+  MinEthErc20USDValueThresholdByChain = 'minEthErc20USDValueThresholdByChain',
+}
+
+export enum PriceUxUpdateProperties {
+  UpdatedPriceUX = SwapLayerProperties.UpdatedPriceUX,
+}
+
+export enum UnichainFlashblocksProperties {
+  FlashblocksModalEnabled = SwapLayerProperties.FlashblocksModalEnabled,
+}
+
+export enum EthAsErc20DEXProperties {
+  EthAsErc20DEXEnabled = SwapLayerProperties.EthAsErc20DEXEnabled,
+  MinEthErc20USDValueThresholdByChain = SwapLayerProperties.MinEthErc20USDValueThresholdByChain,
+}
+
+// Ordered alphabetically.
+export type ExperimentProperties = {
+  [Experiments.EthAsErc20DEX]: EthAsErc20DEXProperties
+  [Experiments.ExploreBackendSorting]: ExploreBackendSortingProperties
+  [Experiments.NativeTokenPercentageBuffer]: NativeTokenPercentageBufferProperties
+  [Experiments.PriceUxUpdate]: PriceUxUpdateProperties
+  [Experiments.PrivateRpc]: PrivateRpcProperties
+  [Experiments.SwapConfirmation]: SwapConfirmationProperties
+  [Experiments.UnichainFlashblocksModal]: UnichainFlashblocksProperties
+}
+
+// will be a spread of all experiment properties in that layer
+export const LayerProperties: Record<Layers, string[]> = {
+  [Layers.ExplorePage]: Object.values({
+    ...ExploreBackendSortingProperties,
+  }),
+  [Layers.SwapPage]: Object.values(SwapLayerProperties),
+}

package/src/flags.ts

@@ -0,0 +1,234 @@
+import { logger } from '@luxfi/utilities/src/logger/logger'
+import { isWebApp } from '@luxfi/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,
+  BridgedAssetsBannerV2,
+  CentralizedPrices,
+  ChainedActions,
+  DisableSwap7702,
+  DisableSessionsForPlan,
+  EmbeddedWallet,
+  EnablePermitMismatchUX,
+  ForceDisableWalletGetCapabilities,
+  ForcePermitTransactions,
+  ForSessionsEnabled,
+  ForUrlMigration,
+  HashcashSolverEnabled,
+  Monad,
+  MultichainTokenUx,
+  NoLuxInterfaceFees,
+  PortionFields,
+  ProfitLoss,
+  SessionsPerformanceTrackingEnabled,
+  SessionsServiceEnabled,
+  SessionsUpgradeAutoEnabled,
+  SmartWallet,
+  SmartWalletDisableVideo,
+  Solana,
+  Soneium,
+  TurnstileSolverEnabled,
+  TwoSecondSwapQuotePollingInterval,
+  UnichainFlashblocks,
+  UniquoteEnabled,
+  UniroutePulumiEnabled,
+  LuxWrapped2025,
+  DEX,
+  DEXPriorityOrdersBase,
+  DEXPriorityOrdersOptimism,
+  DEXPriorityOrdersUnichain,
+  ViemProviderEnabled,
+  XLayer,
+
+  // Wallet
+  BlurredLockScreen,
+  BottomTabs,
+  BridgedAssetsBanner,
+  DisableFiatOnRampKorea,
+  Eip5792Methods,
+  EnableExportPrivateKeys,
+  EnableRestoreSeedPhrase,
+  EnableTransactionSpacingForDelegatedAccounts,
+
+  NotificationApiDataSource,
+  NotificationOnboardingCard,
+  NotificationService,
+
+  PrivateRpc,
+  Scantastic,
+  SelfReportSpamNFTs,
+  SmartWalletSettings,
+  UwULink,
+
+  // Web
+  AATestWeb,
+  BatchedSwaps,
+  ConversionApiMigration,
+  ConversionTracking,
+  DummyFlagTest,
+  GoogleConversionTracking,
+  GqlTokenLists,
+  LimitsFees,
+  LiquidityBatchedTransactions,
+  LpIncentives,
+  MigrateLiquidityApi,
+  NoLuxInterfaceFeesNotification,
+  PortfolioDefiTab,
+  PortfolioTokensAllocationChart,
+  PortoWalletConnector,
+  PriceRangeInputV2,
+  SolanaPromo,
+  TDPTokenCarousel,
+  Toucan,
+  ToucanAuctionKYC,
+  ToucanLaunchAuction,
+  TraceJsonRpc,
+  TwitterConversionTracking,
+  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.BridgedAssetsBannerV2, 'bridged_assets_banner_v2'],
+  [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.HashcashSolverEnabled, 'sessions_hashcash_solver_enabled'],
+  [FeatureFlags.Monad, 'monad'],
+  [FeatureFlags.MultichainTokenUx, 'multichain_token_ux'],
+  [FeatureFlags.NoLuxInterfaceFees, 'no_lux_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.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.BatchedSwaps, 'batched_swaps'],
+  [FeatureFlags.ConversionApiMigration, 'conversion_api_migration'],
+  [FeatureFlags.ConversionTracking, 'conversion-tracking'],
+  [FeatureFlags.DummyFlagTest, 'dummy_flag_test'],
+  [FeatureFlags.GoogleConversionTracking, 'google_conversion_tracking'],
+  [FeatureFlags.GqlTokenLists, 'gql_token_lists'],
+  [FeatureFlags.LimitsFees, 'limits_fees'],
+  [FeatureFlags.LiquidityBatchedTransactions, 'liquidity_batched_transactions'],
+  [FeatureFlags.LpIncentives, 'lp_incentives'],
+  [FeatureFlags.MigrateLiquidityApi, 'migrate_liquidity_api'],
+  [FeatureFlags.NoLuxInterfaceFeesNotification, 'no_lux_interface_fees_notification'],
+  [FeatureFlags.PortfolioDefiTab, 'portfolio_defi_tab'],
+  [FeatureFlags.PortfolioTokensAllocationChart, 'portfolio_tokens_allocation_chart'],
+  [FeatureFlags.PortoWalletConnector, 'porto_wallet_connector'],
+  [FeatureFlags.PriceRangeInputV2, 'price_range_input_v2'],
+  [FeatureFlags.SolanaPromo, 'solana_promo'],
+  [FeatureFlags.TDPTokenCarousel, 'tdp_token_carousel'],
+  [FeatureFlags.Toucan, 'toucan'],
+  [FeatureFlags.ToucanAuctionKYC, 'toucan_auction_kyc'],
+  [FeatureFlags.ToucanLaunchAuction, 'toucan_launch_auction'],
+  [FeatureFlags.TraceJsonRpc, 'traceJsonRpc'],
+  [FeatureFlags.TwitterConversionTracking, 'twitter_conversion_tracking'],
+  [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.BlurredLockScreen, 'blurred_lock_screen'],
+  [FeatureFlags.BottomTabs, 'bottom_tabs'],
+  [FeatureFlags.BridgedAssetsBanner, 'bridged_assets_banner'],
+  [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.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 '@luxexchange/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@luxexchange/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 '@luxexchange/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@luxexchange/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 '@luxfi/config'
+import { FeatureFlags } from '@luxfi/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@luxfi/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 '@luxfi/config'
+import { FeatureFlags } from '@luxfi/gating/src/flags'
+import { getFeatureFlag } from '@luxfi/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 '@luxexchange/gating/src/flags'
+import { getFeatureFlag, useFeatureFlag } from '@luxexchange/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 '@luxfi/utilities/src/environment/env'
+import { isWebApp } from '@luxfi/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 '@luxfi/gating/src/configs'
+import { ExperimentProperties, Experiments } from '@luxfi/gating/src/experiments'
+import { FeatureFlags, getFeatureFlagName } from '@luxfi/gating/src/flags'
+import {
+  getStatsigClient,
+  TypedReturn,
+  useDynamicConfig,
+  useExperiment,
+  useFeatureGate,
+  useGateValue,
+  useLayer,
+  useStatsigClient,
+} from '@luxfi/gating/src/sdk/statsig'
+import { useEffect, useMemo, useState } from 'react'
+import { logger } from '@luxfi/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,97 @@
+export type {
+  DatadogIgnoredErrorsValType,
+  DatadogSessionSampleRateValType,
+  DynamicConfigKeys,
+  ForceUpgradeStatus,
+  ForceUpgradeTranslations,
+  GasStrategies,
+  GasStrategyType,
+  GasStrategyWithConditions,
+  UwULinkAllowlist,
+  UwULinkAllowlistItem,
+} from '@luxexchange/gating/src/configs'
+export {
+  AllowedV4WethHookAddressesConfigKey,
+  BlockedAsyncSubmissionChainIdsConfigKey,
+  ChainsConfigKey,
+  DatadogIgnoredErrorsConfigKey,
+  DatadogSessionSampleRateKey,
+  DynamicConfigs,
+  EmbeddedWalletConfigKey,
+  ExtensionBiometricUnlockConfigKey,
+  ExternallyConnectableExtensionConfigKey,
+  ForceUpgradeConfigKey,
+  HomeScreenExploreTokensConfigKey,
+  LPConfigKey,
+  NetworkRequestsConfigKey,
+  OnDeviceRecoveryConfigKey,
+  OutageBannerChainIdConfigKey,
+  SwapConfigKey,
+  SyncTransactionSubmissionChainIdsConfigKey,
+  UwuLinkConfigKey,
+  VerifiedAuctionsConfigKey,
+} from '@luxexchange/gating/src/configs'
+export { StatsigCustomAppValue } from '@luxexchange/gating/src/constants'
+export type { ExperimentProperties } from '@luxexchange/gating/src/experiments'
+export {
+  EthAsErc20DEXProperties,
+  Experiments,
+  ExploreBackendSortingProperties,
+  LayerProperties,
+  Layers,
+  NativeTokenPercentageBufferProperties,
+  PriceUxUpdateProperties,
+  PrivateRpcProperties,
+  UnichainFlashblocksProperties,
+} from '@luxexchange/gating/src/experiments'
+export {
+  FeatureFlagClient,
+  FeatureFlags,
+  getFeatureFlagName,
+  WALLET_FEATURE_FLAG_NAMES,
+  WEB_FEATURE_FLAG_NAMES,
+} from '@luxexchange/gating/src/flags'
+export { getIsHashcashSolverEnabled, useIsHashcashSolverEnabled } from '@luxexchange/gating/src/getIsHashcashSolverEnabled'
+export {
+  getIsSessionsPerformanceTrackingEnabled,
+  useIsSessionsPerformanceTrackingEnabled,
+} from '@luxexchange/gating/src/getIsPerformanceTrackingEnabled'
+export { getIsSessionServiceEnabled, useIsSessionServiceEnabled } from '@luxexchange/gating/src/getIsSessionServiceEnabled'
+export { getIsSessionUpgradeAutoEnabled } from '@luxexchange/gating/src/getIsSessionUpgradeAutoEnabled'
+export {
+  getIsTurnstileSolverEnabled,
+  useIsTurnstileSolverEnabled,
+} from '@luxexchange/gating/src/getIsTurnstileSolverEnabled'
+export { getStatsigEnvName } from '@luxexchange/gating/src/getStatsigEnvName'
+export {
+  getDynamicConfigValue,
+  getExperimentValue,
+  getExperimentValueFromLayer,
+  getFeatureFlag,
+  useDynamicConfigValue,
+  useExperimentValue,
+  useExperimentValueFromLayer,
+  useExperimentValueWithExposureLoggingDisabled,
+  useFeatureFlag,
+  useFeatureFlagWithExposureLoggingDisabled,
+  useFeatureFlagWithLoading,
+  useStatsigClientStatus,
+} from '@luxexchange/gating/src/hooks'
+export { LocalOverrideAdapterWrapper } from '@luxexchange/gating/src/LocalOverrideAdapterWrapper'
+export type {
+  StatsigOptions,
+  StatsigUser,
+  StorageProvider,
+} from '@luxexchange/gating/src/sdk/statsig'
+export {
+  getOverrideAdapter,
+  getStatsigClient,
+  StatsigClient,
+  StatsigContext,
+  StatsigProvider,
+  Storage,
+  useClientAsyncInit,
+  useExperiment,
+  useLayer,
+} from '@luxexchange/gating/src/sdk/statsig'
+export { getOverrides } from '@luxexchange/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 '@luxfi/config'
+import { LocalOverrideAdapterWrapper } from '@luxfi/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)

package/src/sdk/statsig.ts

@@ -0,0 +1,44 @@
+import { StatsigClient } from '@statsig/react-bindings'
+import { getConfig } from '@luxfi/config'
+import { LocalOverrideAdapterWrapper } from '@luxfi/gating/src/LocalOverrideAdapterWrapper'
+import { isTestEnv } from '@luxfi/utilities/src/environment/env'
+
+export {
+  StatsigClient,
+  StatsigContext,
+  type StatsigOptions,
+  StatsigProvider,
+  type StatsigUser,
+  Storage,
+  type StorageProvider,
+  type TypedReturn,
+  useClientAsyncInit,
+  useDynamicConfig,
+  useExperiment,
+  useFeatureGate,
+  useGateValue,
+  useLayer,
+  useStatsigClient,
+  useStatsigUser,
+} from '@statsig/react-bindings'
+
+let localOverrideAdapter: LocalOverrideAdapterWrapper | undefined
+
+function getStatsigApiKeyOrThrow(): string {
+  // A dummy key is used in test env b/c the wallet/mobile tests use this file instead of the statsig.native file
+  const statsigApiKey = isTestEnv() ? 'dummy-test-key' : getConfig().statsigApiKey
+
+  // Return empty string instead of throwing for self-hosted deployments without Statsig
+  return statsigApiKey || ''
+}
+
+export function getOverrideAdapter(): LocalOverrideAdapterWrapper {
+  if (!localOverrideAdapter) {
+    localOverrideAdapter = new LocalOverrideAdapterWrapper(getStatsigApiKeyOrThrow())
+  }
+  return localOverrideAdapter
+}
+
+export function getStatsigClient(): StatsigClient {
+  return StatsigClient.instance(getStatsigApiKeyOrThrow())
+}

package/src/utils.ts

@@ -0,0 +1,24 @@
+import { PrecomputedEvaluationsInterface } from '@statsig/js-client'
+import { getOverrideAdapter } from '@luxfi/gating/src/sdk/statsig'
+
+export function isStatsigReady(client: PrecomputedEvaluationsInterface): boolean {
+  return client.loadingStatus === 'Ready'
+}
+
+type GateOverride = [string, boolean]
+type ConfigOverride = [string, Record<string, unknown>]
+
+export function getOverrides(client: PrecomputedEvaluationsInterface): {
+  configOverrides: ConfigOverride[]
+  gateOverrides: GateOverride[]
+} {
+  const statsigOverrides = isStatsigReady(client)
+    ? getOverrideAdapter().getAllOverrides()
+    : { gate: {}, dynamicConfig: {}, layer: {} }
+
+  const filterNumbers = (value: [string, unknown]): boolean => isNaN(parseInt(value[0], 10))
+  const gateOverrides = Object.entries(statsigOverrides.gate).filter(filterNumbers)
+  const configOverrides = Object.entries(statsigOverrides.dynamicConfig).filter(filterNumbers)
+
+  return { configOverrides, gateOverrides }
+}

package/tsconfig.json

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

package/tsconfig.lint.json

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