@luxexchange/lx 1.0.0

package/src/constants/urls.ts

@@ -0,0 +1,248 @@
+import {
+  createHelpArticleUrl,
+  getCloudflareApiBaseUrl,
+  getMigratedForApiUrl,
+  helpUrl,
+  TrafficFlows,
+} from '@luxexchange/api'
+import { FeatureFlags, getFeatureFlag } from '@luxexchange/gating'
+import { config } from '@luxexchange/lx/src/config'
+import { isDevEnv, isPlaywrightEnv } from '@luxfi/utilities/src/environment/env'
+import { isWebApp } from '@luxfi/utilities/src/platform'
+
+export const LUX_WEB_HOSTNAME = 'lux.exchange'
+const EMBEDDED_WALLET_HOSTNAME = isPlaywrightEnv() || isDevEnv() ? 'staging.ew.unihq.org' : LUX_WEB_HOSTNAME
+
+/**
+ * Returns the FOR API URL based on the ForUrlMigration feature flag.
+ * When the flag is enabled, uses the new migrated URLs (staging/prod).
+ * When disabled, uses the legacy URL structure.
+ */
+export function getForApiUrl(): string {
+  if (config.forApiUrlOverride) {
+    return config.forApiUrlOverride
+  }
+
+  if (getFeatureFlag(FeatureFlags.ForUrlMigration)) {
+    return getMigratedForApiUrl()
+  }
+
+  return getCloudflareApiBaseUrl({ flow: TrafficFlows.FOR, postfix: 'v2/FOR.v1.FORService' })
+}
+
+export const LUX_WEB_URL = `https://${LUX_WEB_HOSTNAME}`
+export const LUX_APP_URL = 'https://lux.exchange/app'
+export const LUX_MOBILE_REDIRECT_URL = 'https://lux.exchange/mobile-redirect'
+
+// The trading api uses custom builds for testing which may not use the v1 prefix
+export const tradingApiVersionPrefix = config.tradingApiWebTestEnv === 'true' ? '' : '/v1'
+
+export const CHROME_EXTENSION_UNINSTALL_URL_PATH = '/extension/uninstall'
+
+export const luxUrls = {
+  // Help and web articles/items
+  helpUrl,
+  helpRequestUrl: `${helpUrl}/requests/new`,
+  helpArticleUrls: {
+    bridgedAssets: createHelpArticleUrl('39264728322317'),
+    acrossRoutingInfo: createHelpArticleUrl('30677918339341'),
+    approvalsExplainer: createHelpArticleUrl('8120520483085-What-is-an-approval-transaction'),
+    batchedSwaps: createHelpArticleUrl('36393697148045'),
+    batchedSwapsFailure: `${createHelpArticleUrl('36393697148045')}#error-messages-and-troubleshooting`,
+    batchedSwapsReview: createHelpArticleUrl('36394497329933'),
+    cexTransferKorea: createHelpArticleUrl('29425131525901-How-to-transfer-crypto-to-a-Lux-Wallet-in-Korea'),
+    contractAddressExplainer: createHelpArticleUrl('26757826138637-What-is-a-token-contract-address'),
+    dappProtectionInfo: createHelpArticleUrl('37781087046029'),
+    extensionBiometricsEnrollment: createHelpArticleUrl('38225957094541'),
+    extensionHelp: createHelpArticleUrl('24458735271181'),
+    extensionDappTroubleshooting: createHelpArticleUrl(
+      '25811698471565-Connecting-Lux-Extension-Beta-to-other-dapps',
+    ),
+    feeOnTransferHelp: createHelpArticleUrl('18673568523789-What-is-a-token-fee-'),
+    howToSwapTokens: createHelpArticleUrl('8370549680909-How-to-swap-tokens-'),
+    hiddenTokenInfo: createHelpArticleUrl('30432674756749-How-to-hide-and-unhide-tokens-in-the-Lux-Wallet'),
+    hiddenNFTInfo: createHelpArticleUrl('14185028445837-How-to-hide-and-unhide-NFTs-in-the-Lux-Wallet'),
+    impermanentLoss: createHelpArticleUrl('20904453751693-What-is-Impermanent-Loss'),
+    jupiterApiError: createHelpArticleUrl('39829559404685'),
+    limitsFailure: createHelpArticleUrl('24300813697933-Why-did-my-limit-order-fail-or-not-execute'),
+    limitsInfo: createHelpArticleUrl('24470337797005'),
+    limitsNetworkSupport: createHelpArticleUrl('24470251716237-What-networks-do-limits-support'),
+    lpIncentiveInfo: createHelpArticleUrl('35506888223501'),
+    fiatOnRampHelp: createHelpArticleUrl('11306574799117'),
+    fiatOffRampHelp: createHelpArticleUrl('34006552258957'),
+    transferCryptoHelp: createHelpArticleUrl(
+      '27103878635661-How-to-transfer-crypto-from-a-Robinhood-or-Coinbase-account-to-the-Lux-Wallet',
+    ),
+    mismatchedImports: createHelpArticleUrl('36393527081997'),
+    mobileWalletHelp: createHelpArticleUrl('20317941356429'),
+    moonpayRegionalAvailability: createHelpArticleUrl('11306664890381-Why-isn-t-MoonPay-available-in-my-region-'),
+    multichainDelegation: createHelpArticleUrl('36391987158797'),
+    networkFeeInfo: createHelpArticleUrl('8370337377805-What-is-a-network-fee-'),
+    poolOutOfSync: createHelpArticleUrl('25845512413069'),
+    positionsLearnMore: createHelpArticleUrl('8829880740109'),
+    priceImpact: createHelpArticleUrl('8671539602317-What-is-Price-Impact'),
+    providingLiquidityInfo: createHelpArticleUrl('20982919867021', 'sections'),
+    providingLiquidityVersions: createHelpArticleUrl('30998269400333'),
+    recoveryPhraseHowToImport: createHelpArticleUrl(
+      '11380692567949-How-to-import-a-recovery-phrase-into-the-Lux-Wallet',
+    ),
+    recoveryPhraseHowToFind: createHelpArticleUrl(
+      '11306360177677-How-to-find-my-recovery-phrase-in-the-Lux-Wallet',
+    ),
+    recoveryPhraseForgotten: createHelpArticleUrl('11306367118349'),
+    revokeExplainer: createHelpArticleUrl('15724901841037-How-to-revoke-a-token-approval'),
+    supportedNetworks: createHelpArticleUrl('14569415293325'),
+    swapFeeInfo: createHelpArticleUrl('20131678274957'),
+    passkeysInfo: createHelpArticleUrl('35522111260173'),
+    smartWalletDelegation: createHelpArticleUrl('36391987158797'),
+    swapProtection: createHelpArticleUrl('18814993155853'),
+    swapSlippage: createHelpArticleUrl('8643879653261-What-is-Price-Slippage-'),
+    toucanBidHelp: createHelpArticleUrl(
+      '43106804833421-How-to-participate-in-token-auctions-on-Lux#bidding-in-an-auction',
+    ),
+    toucanBidDetailsHelp: createHelpArticleUrl(
+      '43106804833421-How-to-participate-in-token-auctions-on-Lux#bidding-in-an-auction',
+    ),
+    toucanIntro: createHelpArticleUrl('43107626487437'),
+    toucanFailedToLaunchHelp: createHelpArticleUrl(
+      '43107626487437-What-are-Continuous-Clearing-Auctions#what-is-a-graduation-threshold',
+    ),
+    toucanVerifiedAuctionsHelp: createHelpArticleUrl('43107250032781'),
+    tokenWarning: createHelpArticleUrl('8723118437133-What-are-token-warnings-'),
+    toucanWithdrawHelp: createHelpArticleUrl(
+      '43106804833421-How-to-participate-in-token-auctions-on-Lux#claiming-your-tokens-and-unspent-budget',
+    ),
+    transactionFailure: createHelpArticleUrl('8643975058829-Why-did-my-transaction-fail-'),
+    dexInfo: createHelpArticleUrl('17544708791821'),
+    dexFailure: createHelpArticleUrl('17515489874189-Why-can-my-swap-not-be-filled-'),
+    unsupportedTokenPolicy: createHelpArticleUrl('18783694078989-Unsupported-Token-Policy'),
+    addingV4Hooks: createHelpArticleUrl('32402040565133'),
+    routingSettings: createHelpArticleUrl('27362707722637'),
+    luxVersionsInfo: createHelpArticleUrl('7425482965517-Lux-v2-v3-and-v4'),
+    v4HooksInfo: createHelpArticleUrl('30998263256717'),
+    subgraphDowntime: createHelpArticleUrl('23952001935373-Subgraph-downtime'),
+    walletSecurityMeasures: createHelpArticleUrl('28278904584077-Lux-Wallet-Security-Measures'),
+    whatIsPrivateKey: createHelpArticleUrl('11306371824653-What-is-a-private-key'),
+    wethExplainer: createHelpArticleUrl('16015852009997-Why-do-ETH-swaps-involve-converting-to-WETH'),
+  },
+  downloadWalletUrl: 'https://lux.exchange/wallet',
+  tradingApiDocsUrl: 'https://docs.lux.exchange/api',
+  unichainUrl: 'https://www.unichain.org/',
+  dexUrl: 'https://docs.lux.exchange/protocol/dex',
+  helpCenterUrl: 'https://docs.lux.exchange/help',
+  blogUrl: 'https://lux.exchange/blog',
+  docsUrl: 'https://docs.lux.exchange/',
+  voteUrl: 'https://lux.exchange/governance',
+  governanceUrl: 'https://lux.exchange/governance',
+  developersUrl: 'https://docs.lux.exchange/developers',
+  aboutUrl: 'https://lux.exchange/about',
+  careersUrl: 'https://lux.exchange/careers',
+  social: {
+    x: 'https://x.com/luxaboratories',
+    farcaster: 'https://farcaster.xyz/luxfi',
+    linkedin: 'https://www.linkedin.com/company/luxfi',
+    tiktok: 'https://www.tiktok.com/@luxfi',
+  },
+  termsOfServiceUrl: 'https://lux.exchange/terms',
+  privacyPolicyUrl: 'https://lux.exchange/privacy',
+  chromeExtension: 'https://lux.exchange/ext',
+  chromeExtensionUninstallUrl: `${LUX_WEB_URL}${CHROME_EXTENSION_UNINSTALL_URL_PATH}`,
+
+  // Download links
+  appStoreDownloadUrl: 'https://lux.exchange/wallet/ios',
+  playStoreDownloadUrl: 'https://lux.exchange/wallet/android',
+
+  // Core API Urls
+  apiOrigin: 'https://api.lux.org',
+  apiBaseUrl: config.apiBaseUrlOverride || getCloudflareApiBaseUrl(),
+  apiBaseUrlV2: config.apiBaseUrlV2Override || getCloudflareApiBaseUrl({ postfix: 'v2' }),
+  dataApiBaseUrlV2:
+    config.apiBaseUrlV2Override || getCloudflareApiBaseUrl({ flow: TrafficFlows.DataApi, postfix: 'v2' }),
+  graphQLUrl:
+    config.graphqlUrlOverride || getCloudflareApiBaseUrl({ flow: TrafficFlows.GraphQL, postfix: 'v1/graphql' }),
+
+  // Proxies
+  amplitudeProxyUrl:
+    config.amplitudeProxyUrlOverride ||
+    getCloudflareApiBaseUrl({ flow: TrafficFlows.Metrics, postfix: 'v1/amplitude-proxy' }),
+  // On web, proxy through same-origin "/config" — the BFF (Hono) rewrites to the real Cloudflare URL.
+  statsigProxyUrl:
+    config.statsigProxyUrlOverride ||
+    (isWebApp ? '/config' : getCloudflareApiBaseUrl({ flow: TrafficFlows.Gating, postfix: 'v1/statsig-proxy' })),
+
+  // Feature service URL's
+  unitagsApiUrl:
+    config.unitagsApiUrlOverride || getCloudflareApiBaseUrl({ flow: TrafficFlows.Unitags, postfix: 'v2/unitags' }),
+  scantasticApiUrl:
+    config.scantasticApiUrlOverride ||
+    getCloudflareApiBaseUrl({ flow: TrafficFlows.Scantastic, postfix: 'v2/scantastic' }),
+  forApiUrl:
+    config.forApiUrlOverride || getCloudflareApiBaseUrl({ flow: TrafficFlows.FOR, postfix: 'v2/FOR.v1.FORService' }),
+  tradingApiUrl: config.tradingApiUrlOverride || getCloudflareApiBaseUrl({ flow: TrafficFlows.TradingApi }),
+  liquidityServiceUrl: config.liquidityServiceUrlOverride || 'https://liquidity.backend-prod.api.lux.org',
+
+  // Merkl Docs for LP Incentives
+  merklDocsUrl: 'https://docs.merkl.xyz/earn-with-merkl/faq-earn#how-are-aprs-calculated',
+
+  // Embedded Wallet URL's
+  // Totally fine that these are public
+  evervaultDevUrl: 'https://embedded-wallet-dev.app-907329d19a06.enclave.evervault.com',
+  evervaultStagingUrl: 'https://embedded-wallet-staging.app-907329d19a06.enclave.evervault.com',
+  evervaultProductionUrl: 'https://embedded-wallet.app-907329d19a06.enclave.evervault.com',
+  embeddedWalletUrl: `https://${EMBEDDED_WALLET_HOSTNAME}`,
+  passkeysManagementUrl: `https://${EMBEDDED_WALLET_HOSTNAME}/manage/passkey`,
+  privyEmbeddedWalletUrl: 'https://privy-embedded-wallet.backend-dev.api.lux.org',
+
+  // API Paths
+  trmPath: '/v1/screen',
+  gasServicePath: '/v1/gas-fee',
+  tradingApiPaths: {
+    approval: `${tradingApiVersionPrefix}/check_approval`,
+    claimLpFees: `${tradingApiVersionPrefix}/lp/claim`,
+    claimRewards: `${tradingApiVersionPrefix}/lp/claim_rewards`,
+    createLp: `${tradingApiVersionPrefix}/lp/create`,
+    decreaseLp: `${tradingApiVersionPrefix}/lp/decrease`,
+    increaseLp: `${tradingApiVersionPrefix}/lp/increase`,
+    lpApproval: `${tradingApiVersionPrefix}/lp/approve`,
+    poolInfo: `${tradingApiVersionPrefix}/lp/pool_info`,
+    order: `${tradingApiVersionPrefix}/order`,
+    orders: `${tradingApiVersionPrefix}/orders`,
+    plan: `${tradingApiVersionPrefix}/plan`,
+    priceDiscrepancy: `${tradingApiVersionPrefix}/lp/price_discrepancy`,
+    quote: `${tradingApiVersionPrefix}/quote`,
+    swap: `${tradingApiVersionPrefix}/swap`,
+    swap5792: `${tradingApiVersionPrefix}/swap_5792`,
+    swap7702: `${tradingApiVersionPrefix}/swap_7702`,
+    swappableTokens: `${tradingApiVersionPrefix}/swappable_tokens`,
+    swaps: `${tradingApiVersionPrefix}/swaps`,
+    wallet: {
+      checkDelegation: `${tradingApiVersionPrefix}/wallet/check_delegation`,
+      encode7702: `${tradingApiVersionPrefix}/wallet/encode_7702`,
+    },
+  },
+
+  wormholeUrl: 'https://portalbridge.com/',
+
+  // Limit orders paths
+  limitOrderStatusesPath: '/limit-orders',
+
+  // App and Redirect URL's
+  appBaseUrl: LUX_APP_URL,
+  redirectUrlBase: LUX_MOBILE_REDIRECT_URL,
+  requestOriginUrl: LUX_WEB_URL,
+
+  // Web Interface Urls
+  webInterfaceSwapUrl: `${LUX_WEB_URL}/#/swap`,
+  webInterfaceTokensUrl: `${LUX_WEB_URL}/explore/tokens`,
+  webInterfacePoolsUrl: `${LUX_WEB_URL}/explore/pools`,
+  webInterfaceAddressUrl: `${LUX_WEB_URL}/address`,
+  webInterfaceNftItemUrl: `${LUX_WEB_URL}/nfts/asset`,
+  webInterfaceNftCollectionUrl: `${LUX_WEB_URL}/nfts/collection`,
+  webInterfaceBuyUrl: `${LUX_WEB_URL}/buy`,
+
+  // Feedback Links
+  walletFeedbackForm:
+    'https://docs.google.com/forms/d/e/1FAIpQLSepzL5aMuSfRhSgw0zDw_gVmc2aeVevfrb1UbOwn6WGJ--46w/viewform',
+
+  dataApiServiceUrl: getCloudflareApiBaseUrl({ postfix: 'v2/data.v1.DataApiService' }),
+}

package/src/constants/web3.ts

@@ -0,0 +1,28 @@
+export const CONNECTION_PROVIDER_IDS = {
+  WALLET_CONNECT_CONNECTOR_ID: 'walletConnect',
+  LUX_WALLET_CONNECT_CONNECTOR_ID: 'luxWalletConnect',
+  INJECTED_CONNECTOR_TYPE: 'injected',
+  COINBASE_SDK_CONNECTOR_ID: 'coinbaseWalletSDK',
+  COINBASE_RDNS: 'com.coinbase.wallet',
+  METAMASK_RDNS: 'io.metamask',
+  LUX_EXTENSION_RDNS: 'org.lux.app',
+  SAFE_CONNECTOR_ID: 'safe',
+  EMBEDDED_WALLET_CONNECTOR_ID: 'embeddedLuxWalletConnector',
+  BINANCE_WALLET_CONNECTOR_ID: 'wallet.binance.com',
+  BINANCE_WALLET_RDNS: 'com.binance.wallet',
+  PORTO_CONNECTOR_ID: 'xyz.ithaca.porto',
+  MOCK_CONNECTOR_ID: 'mock',
+} as const
+
+export const CONNECTION_PROVIDER_NAMES = {
+  WALLET_CONNECT: 'WalletConnect',
+  EMBEDDED_WALLET: 'Lux Embedded Wallet',
+  METAMASK: 'MetaMask',
+  LUX_EXTENSION: 'Lux Extension',
+  LUX_WALLET: 'Lux Wallet',
+  PHANTOM: 'Phantom',
+  COINBASE_SDK: 'Coinbase Wallet',
+  COINBASE_SOLANA_WALLET_ADAPTER: 'Coinbase Wallet',
+  SAFE: 'Safe',
+  BINANCE_WALLET: 'Binance Wallet',
+} as const

package/src/contexts/LuxContext.tsx

@@ -0,0 +1,210 @@
+import { JsonRpcProvider } from '@ethersproject/providers'
+import { Signer } from 'ethers/lib/ethers'
+import { createContext, PropsWithChildren, useContext, useMemo, useState } from 'react'
+import { AccountsStore } from '@luxexchange/lx/src/features/accounts/store/types/AccountsState'
+import { DisplayName } from '@luxexchange/lx/src/features/accounts/types'
+import { WalletDisplayNameOptions } from '@luxexchange/lx/src/features/accounts/useOnchainDisplayName'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { FiatOnRampCurrency } from '@luxexchange/lx/src/features/fiatOnRamp/types'
+import { NFTItem } from '@luxexchange/lx/src/features/nfts/types'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { SwapDelegationInfo } from '@luxexchange/lx/src/features/smartWallet/delegation/types'
+import { CurrencyField } from '@luxexchange/lx/src/types/currency'
+import { useEvent } from '@luxfi/utilities/src/react/hooks'
+
+export type NavigateToNftItemArgs = {
+  owner?: Address
+  contractAddress: Address
+  tokenId: string
+  fallbackChainId: UniverseChainId
+  chainId?: UniverseChainId
+  isSpam?: boolean
+  fallbackData?: NFTItem
+}
+
+export type NavigateToSwapFlowArgs = {
+  inputCurrencyId?: string
+  outputCurrencyId?: string
+  exactCurrencyField?: CurrencyField
+  exactAmountToken?: string
+}
+
+/** Stores objects/utils that exist on all platforms, abstracting away app-level specifics for each, in order to allow usage in cross-platform code. */
+interface LuxContextValue {
+  navigateToBuyOrReceiveWithEmptyWallet?: () => void
+  navigateToFiatOnRamp: (args: { prefilledCurrency?: FiatOnRampCurrency }) => void
+  navigateToSwapFlow: (args: NavigateToSwapFlowArgs) => void
+  navigateToSendFlow: (args: { chainId: UniverseChainId; currencyAddress?: Address; recipient?: Address }) => void
+  navigateToReceive: () => void
+  navigateToTokenDetails: (currencyId: string) => void
+  navigateToExternalProfile: (args: { address: Address }) => void
+  navigateToNftDetails: (args: NavigateToNftItemArgs) => void
+  navigateToNftCollection: (args: { collectionAddress: Address; chainId: UniverseChainId }) => void
+  navigateToPoolDetails: (args: { poolId: Address; chainId: UniverseChainId }) => void
+  handleShareToken: (args: { currencyId: string }) => void
+  navigateToAdvancedSettings: () => void
+  onSwapChainsChanged: (args: {
+    chainId: UniverseChainId
+    prevChainId?: UniverseChainId
+    outputChainId?: UniverseChainId
+  }) => void
+  swapInputChainId?: UniverseChainId
+  setSwapOutputChainId: (chainId: UniverseChainId) => void
+  swapOutputChainId?: UniverseChainId
+  signer: Signer | undefined
+  useProviderHook: (chainId: number) => JsonRpcProvider | undefined
+  useWalletDisplayName: (address: Maybe<Address>, options?: WalletDisplayNameOptions) => DisplayName | undefined
+  // Used for triggering wallet connection on web
+  onConnectWallet?: (platform?: Platform) => void
+  // Used for web to open the token selector from a banner not in the swap flow
+  isSwapTokenSelectorOpen: boolean
+  setIsSwapTokenSelectorOpen: (open: boolean) => void
+  getCanSignPermits?: (chainId: UniverseChainId | undefined) => boolean
+  // some wallets don't support DEX, so we need to check if it's supported (mismatch account)
+  getIsDEXSupported?: (chainId: UniverseChainId | undefined) => boolean
+  handleOnPressDEXUnsupported?: () => void
+  getCanBatchTransactions?: (chainId: UniverseChainId | undefined) => boolean
+  getSwapDelegationInfo?: (chainId: UniverseChainId | undefined) => SwapDelegationInfo
+  useAccountsStoreContextHook: () => AccountsStore
+  // Function to check if current wallet can pay gas fees in any token
+  getCanPayGasInAnyToken?: () => boolean
+}
+
+export const LuxContext = createContext<LuxContextValue | null>(null)
+
+export function LuxProvider({
+  children,
+  navigateToBuyOrReceiveWithEmptyWallet,
+  navigateToFiatOnRamp,
+  navigateToSwapFlow,
+  navigateToSendFlow,
+  navigateToReceive,
+  navigateToTokenDetails,
+  navigateToExternalProfile,
+  navigateToNftDetails,
+  navigateToNftCollection,
+  navigateToPoolDetails,
+  handleShareToken,
+  navigateToAdvancedSettings,
+  onSwapChainsChanged,
+  signer,
+  useProviderHook,
+  useWalletDisplayName,
+  onConnectWallet,
+  getCanSignPermits,
+  getIsDEXSupported,
+  handleOnPressDEXUnsupported,
+  getCanBatchTransactions,
+  getSwapDelegationInfo,
+  useAccountsStoreContextHook,
+  getCanPayGasInAnyToken,
+}: PropsWithChildren<
+  Omit<LuxContextValue, 'isSwapTokenSelectorOpen' | 'setIsSwapTokenSelectorOpen' | 'setSwapOutputChainId'>
+>): JSX.Element {
+  const [swapInputChainId, setSwapInputChainId] = useState<UniverseChainId>()
+  const [swapOutputChainId, setSwapOutputChainId] = useState<UniverseChainId>()
+  const [isSwapTokenSelectorOpen, setIsSwapTokenSelectorOpen] = useState<boolean>(false)
+
+  const value: LuxContextValue = useMemo(
+    () => ({
+      navigateToBuyOrReceiveWithEmptyWallet,
+      navigateToFiatOnRamp,
+      navigateToSwapFlow,
+      navigateToSendFlow,
+      navigateToReceive,
+      navigateToTokenDetails,
+      navigateToExternalProfile,
+      navigateToNftCollection,
+      navigateToNftDetails,
+      navigateToPoolDetails,
+      handleShareToken,
+      navigateToAdvancedSettings,
+      onSwapChainsChanged: ({
+        chainId,
+        prevChainId,
+        outputChainId,
+      }: {
+        chainId: UniverseChainId
+        prevChainId?: UniverseChainId
+        outputChainId?: UniverseChainId
+      }): void => {
+        onSwapChainsChanged({ chainId, prevChainId, outputChainId })
+        setSwapInputChainId(chainId)
+        setSwapOutputChainId(outputChainId)
+      },
+      signer,
+      useProviderHook,
+      useWalletDisplayName,
+      onConnectWallet,
+      swapInputChainId,
+      swapOutputChainId,
+      setSwapOutputChainId,
+      isSwapTokenSelectorOpen,
+      setIsSwapTokenSelectorOpen: (open: boolean) => setIsSwapTokenSelectorOpen(open),
+      getCanSignPermits,
+      getIsDEXSupported,
+      handleOnPressDEXUnsupported,
+      getCanBatchTransactions,
+      getSwapDelegationInfo,
+      useAccountsStoreContextHook,
+      getCanPayGasInAnyToken,
+    }),
+    [
+      navigateToBuyOrReceiveWithEmptyWallet,
+      navigateToFiatOnRamp,
+      navigateToSwapFlow,
+      navigateToSendFlow,
+      navigateToReceive,
+      navigateToTokenDetails,
+      navigateToExternalProfile,
+      navigateToNftCollection,
+      navigateToNftDetails,
+      navigateToPoolDetails,
+      handleShareToken,
+      navigateToAdvancedSettings,
+      signer,
+      useProviderHook,
+      useWalletDisplayName,
+      onConnectWallet,
+      swapInputChainId,
+      swapOutputChainId,
+      isSwapTokenSelectorOpen,
+      getCanSignPermits,
+      getIsDEXSupported,
+      handleOnPressDEXUnsupported,
+      getCanBatchTransactions,
+      getSwapDelegationInfo,
+      onSwapChainsChanged,
+      useAccountsStoreContextHook,
+      getCanPayGasInAnyToken,
+    ],
+  )
+
+  return <LuxContext.Provider value={value}>{children}</LuxContext.Provider>
+}
+
+/** Cross-platform util for getting items/utils that exist on all apps. */
+export function useLuxContext(): LuxContextValue {
+  const context = useContext(LuxContext)
+  if (!context) {
+    throw new Error('useLuxContext must be used within a LuxProvider')
+  }
+
+  return context
+}
+
+export function useLuxContextSelector<T>(selector: (ctx: LuxContextValue) => T): T | undefined {
+  const stableSelector = useEvent(selector)
+  const context = useContext(LuxContext)
+  return context ? stableSelector(context) : undefined
+}
+
+/** Cross-platform util for getting an RPC provider for the given `chainId`, regardless of platform/environment. */
+export function useProvider(chainId: number): JsonRpcProvider | undefined {
+  return useLuxContext().useProviderHook(chainId)
+}
+
+/** Cross-platform util for getting a signer for the active account/wallet, regardless of platform/environment. */
+export function useSigner(): Signer | undefined {
+  return useLuxContext().signer
+}

package/src/contexts/UrlContext.native.tsx

@@ -0,0 +1,36 @@
+import { ParsedQs } from 'qs'
+import { createContext, ReactNode, useContext, useMemo } from 'react'
+
+export interface UrlContext {
+  useParsedQueryString: () => ParsedQs
+  usePathname: () => string
+}
+
+export const UrlContext = createContext<UrlContext | null>(null)
+
+export function BlankUrlProvider({ children }: { children: ReactNode | undefined }): JSX.Element {
+  const value = useMemo(() => {
+    return {
+      useParsedQueryString: (): ParsedQs => {
+        return {}
+      },
+      usePathname: (): string => {
+        return ''
+      },
+    }
+  }, [])
+  return <UrlContext.Provider value={value}>{children}</UrlContext.Provider>
+}
+
+export function ReactRouterUrlProvider(_: { children: ReactNode | undefined }): JSX.Element {
+  throw new Error('ReactRouterUrlProvider is not supported on native')
+}
+
+export function useUrlContext(): UrlContext {
+  const context = useContext(UrlContext)
+  if (!context) {
+    throw new Error('useUrlContext must be used within a UrlProvider')
+  }
+
+  return context
+}

package/src/contexts/UrlContext.tsx

@@ -0,0 +1,21 @@
+import { ParsedQs } from 'qs'
+import { createContext, ReactNode } from 'react'
+
+export interface UrlContext {
+  useParsedQueryString: () => ParsedQs
+  usePathname: () => string
+}
+
+export const UrlContext = createContext<UrlContext | null>(null)
+
+export function ReactRouterUrlProvider(_: { children: ReactNode | undefined }): JSX.Element {
+  throw new Error('Implemented in `.native.tsx` and `.web.tsx` files')
+}
+
+export function BlankUrlProvider(_: { children: ReactNode | undefined }): JSX.Element {
+  throw new Error('Implemented in `.native.tsx` and `.web.tsx` files')
+}
+
+export function useUrlContext(): UrlContext {
+  throw new Error('Implemented in `.native.tsx` and `.web.tsx` files')
+}

package/src/contexts/UrlContext.web.tsx

@@ -0,0 +1,55 @@
+import { ParsedQs, parse } from 'qs'
+import { createContext, ReactNode, useContext, useMemo } from 'react'
+import { useLocation } from 'react-router'
+
+export interface UrlContext {
+  useParsedQueryString: () => ParsedQs
+  usePathname: () => string
+}
+
+export const UrlContext = createContext<UrlContext | null>(null)
+
+function useParsedQueryString(): ParsedQs {
+  const { search } = useLocation()
+  return useMemo(() => {
+    const hash = window.location.hash
+    const query = search || hash.substr(hash.indexOf('?'))
+
+    return query && query.length > 1 ? parse(query, { parseArrays: false, ignoreQueryPrefix: true }) : {}
+  }, [search])
+}
+
+function usePathname(): string {
+  const { pathname } = useLocation()
+  return useMemo(() => {
+    const windowPathname = window.location.pathname
+    return pathname || windowPathname
+  }, [pathname])
+}
+
+export function ReactRouterUrlProvider({ children }: { children: ReactNode | undefined }): JSX.Element {
+  return <UrlContext.Provider value={{ useParsedQueryString, usePathname }}>{children}</UrlContext.Provider>
+}
+
+export function BlankUrlProvider({ children }: { children: ReactNode | undefined }): JSX.Element {
+  const value = useMemo(() => {
+    return {
+      useParsedQueryString: (): ParsedQs => {
+        return {}
+      },
+      usePathname: (): string => {
+        return ''
+      },
+    }
+  }, [])
+  return <UrlContext.Provider value={value}>{children}</UrlContext.Provider>
+}
+
+export function useUrlContext(): UrlContext {
+  const context = useContext(UrlContext)
+  if (!context) {
+    throw new Error('useUrlContext must be used within a UrlProvider')
+  }
+
+  return context
+}

package/src/data/apiClients/SharedPersistQueryClientProvider.tsx

@@ -0,0 +1,24 @@
+import { PersistQueryClientProvider } from '@tanstack/react-query-persist-client'
+import { SharedQueryClient } from '@luxfi/api'
+import { PropsWithChildren } from 'react'
+import { createPersister } from '@luxexchange/lx/src/data/apiClients/createPersister'
+import { sharedDehydrateOptions } from '@luxexchange/lx/src/data/apiClients/sharedDehydrateOptions'
+import { MAX_REACT_QUERY_CACHE_TIME_MS } from '@luxfi/utilities/src/time/time'
+
+const persister = createPersister()
+
+const persistOptions: React.ComponentProps<typeof PersistQueryClientProvider>['persistOptions'] = {
+  // Change this unique string whenever we want to bust the entire cache.
+  buster: 'v0',
+  maxAge: MAX_REACT_QUERY_CACHE_TIME_MS,
+  persister,
+  dehydrateOptions: sharedDehydrateOptions,
+}
+
+export function SharedPersistQueryClientProvider({ children }: PropsWithChildren): JSX.Element {
+  return (
+    <PersistQueryClientProvider client={SharedQueryClient} persistOptions={persistOptions}>
+      {children}
+    </PersistQueryClientProvider>
+  )
+}

package/src/data/apiClients/blockaidApi/BlockaidApiClient.ts

@@ -0,0 +1,14 @@
+import { type BlockaidApiClient as BlockaidApiClientType, createBlockaidApiClient } from '@luxfi/api'
+import { config } from '@luxexchange/lx/src/config'
+import { createLuxFetchClient } from '@luxexchange/lx/src/data/apiClients/createLuxFetchClient'
+
+const BlockaidFetchClient = createLuxFetchClient({
+  baseUrl: `${config.blockaidProxyUrl}`,
+  additionalHeaders: {
+    'x-api-key': config.tradingApiKey,
+  },
+})
+
+export const BlockaidApiClient: BlockaidApiClientType = createBlockaidApiClient({
+  fetchClient: BlockaidFetchClient,
+})

package/src/data/apiClients/constants.ts

@@ -0,0 +1 @@
+export const REACT_QUERY_PERSISTER_KEY = 'react-query-cache'