chore: remove graphql feature flag and old query methods (#6384)

* remove graphql feature flag and old query methods

* remove unused fn

* remove redundant names, simplify import

* explicit var naming

* column

* add comment

* update flag check

* undo

* visit /swap in uni search test

* empty array base

---------
Co-authored-by: Charles Bachmeier <charlie@genie.xyz>

src/components/FeatureFlagModal/FeatureFlagModal.tsx

 import { BaseVariant, FeatureFlag, featureFlagSettings, useUpdateFlag } from 'featureFlags'
 import { DetailsV2Variant, useDetailsV2Flag } from 'featureFlags/flags/nftDetails'
-import { NftGraphqlVariant, useNftGraphqlFlag } from 'featureFlags/flags/nftlGraphql'
 import { PayWithAnyTokenVariant, usePayWithAnyTokenFlag } from 'featureFlags/flags/payWithAnyToken'
 import { SwapWidgetVariant, useSwapWidgetFlag } from 'featureFlags/flags/swapWidget'
 import { TraceJsonRpcVariant, useTraceJsonRpcFlag } from 'featureFlags/flags/traceJsonRpc'
@@ -216,12 +215,6 @@ export default function FeatureFlagModal() {
         featureFlag={FeatureFlag.swapWidget}
         label="Swap Widget"
       />
-      <FeatureFlagOption
-        variant={NftGraphqlVariant}
-        value={useNftGraphqlFlag()}
-        featureFlag={FeatureFlag.nftGraphql}
-        label="Migrate NFT read endpoints to GQL"
-      />
       <FeatureFlagOption
         variant={DetailsV2Variant}
         value={useDetailsV2Flag()}

src/components/NavBar/SearchBar.tsx

@@ -4,7 +4,6 @@ import { sendAnalyticsEvent, Trace, TraceEvent, useTrace } from '@uniswap/analyt
 import { BrowserEvent, InterfaceElementName, InterfaceEventName, InterfaceSectionName } from '@uniswap/analytics-events'
 import { useWeb3React } from '@web3-react/core'
 import clsx from 'clsx'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { useCollectionSearch } from 'graphql/data/nft/CollectionSearch'
 import { useSearchTokens } from 'graphql/data/SearchTokens'
 import useDebounce from 'hooks/useDebounce'
@@ -16,9 +15,7 @@ import { Row } from 'nft/components/Flex'
 import { magicalGradientOnHover } from 'nft/css/common.css'
 import { useIsMobile, useIsTablet } from 'nft/hooks'
 import { useIsNavSearchInputVisible } from 'nft/hooks/useIsNavSearchInputVisible'
-import { fetchSearchCollections } from 'nft/queries'
 import { ChangeEvent, useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'
-import { useQuery } from 'react-query'
 import { useLocation } from 'react-router-dom'
 import styled from 'styled-components/macro'
 
@@ -52,44 +49,20 @@ export const SearchBar = () => {
   const { pathname } = useLocation()
   const isMobile = useIsMobile()
   const isTablet = useIsTablet()
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const isNavSearchInputVisible = useIsNavSearchInputVisible()
 
   useOnClickOutside(searchRef, () => {
     isOpen && toggleOpen()
   })
 
-  const { data: queryCollections, isLoading: queryCollectionsAreLoading } = useQuery(
-    ['searchCollections', debouncedSearchValue],
-    () => fetchSearchCollections(debouncedSearchValue),
-    {
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-      refetchOnReconnect: false,
-      enabled: !!debouncedSearchValue.length,
-    }
-  )
-
-  const { data: gqlCollections, loading: gqlCollectionsAreLoading } = useCollectionSearch(debouncedSearchValue)
-
-  const { gatedCollections, gatedCollectionsAreLoading } = useMemo(() => {
-    return isNftGraphqlEnabled
-      ? {
-          gatedCollections: gqlCollections,
-          gatedCollectionsAreLoading: gqlCollectionsAreLoading,
-        }
-      : {
-          gatedCollections: queryCollections,
-          gatedCollectionsAreLoading: queryCollectionsAreLoading,
-        }
-  }, [gqlCollections, gqlCollectionsAreLoading, isNftGraphqlEnabled, queryCollections, queryCollectionsAreLoading])
+  const { data: collections, loading: collectionsAreLoading } = useCollectionSearch(debouncedSearchValue)
 
   const { chainId } = useWeb3React()
   const { data: tokens, loading: tokensAreLoading } = useSearchTokens(debouncedSearchValue, chainId ?? 1)
 
   const isNFTPage = useIsNftPage()
 
-  const [reducedTokens, reducedCollections] = organizeSearchResults(isNFTPage, tokens ?? [], gatedCollections ?? [])
+  const [reducedTokens, reducedCollections] = organizeSearchResults(isNFTPage, tokens ?? [], collections ?? [])
 
   // close dropdown on escape
   useEffect(() => {
@@ -105,7 +78,7 @@ export const SearchBar = () => {
     return () => {
       document.removeEventListener('keydown', escapeKeyDownHandler)
     }
-  }, [isOpen, toggleOpen, gatedCollections])
+  }, [isOpen, toggleOpen, collections])
 
   // clear searchbar when changing pages
   useEffect(() => {
@@ -227,7 +200,7 @@ export const SearchBar = () => {
               collections={reducedCollections}
               queryText={debouncedSearchValue}
               hasInput={debouncedSearchValue.length > 0}
-              isLoading={tokensAreLoading || gatedCollectionsAreLoading}
+              isLoading={tokensAreLoading || collectionsAreLoading}
             />
           )}
         </Box>

src/components/NavBar/SearchBarDropdown.tsx

@@ -4,7 +4,6 @@ import { InterfaceSectionName, NavBarSearchTypes } from '@uniswap/analytics-even
 import { useWeb3React } from '@web3-react/core'
 import Badge from 'components/Badge'
 import { SupportedChainId } from 'constants/chains'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { HistoryDuration, SafetyLevel } from 'graphql/data/__generated__/types-and-hooks'
 import { useTrendingCollections } from 'graphql/data/nft/TrendingCollections'
 import { SearchToken } from 'graphql/data/SearchTokens'
@@ -13,11 +12,8 @@ import { useIsNftPage } from 'hooks/useIsNftPage'
 import { Box } from 'nft/components/Box'
 import { Column, Row } from 'nft/components/Flex'
 import { subheadSmall } from 'nft/css/common.css'
-import { fetchTrendingCollections } from 'nft/queries'
-import { GenieCollection, TimePeriod, TrendingCollection } from 'nft/types'
-import { formatEthPrice } from 'nft/utils/currency'
+import { GenieCollection, TrendingCollection } from 'nft/types'
 import { ReactNode, useEffect, useMemo, useState } from 'react'
-import { useQuery } from 'react-query'
 import { useLocation } from 'react-router-dom'
 import styled from 'styled-components/macro'
 import { ThemedText } from 'theme'
@@ -149,34 +145,30 @@ export const SearchBarDropdown = ({
   const { pathname } = useLocation()
   const { chainId } = useWeb3React()
   const isNFTPage = useIsNftPage()
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const isTokenPage = pathname.includes('/tokens')
   const [resultsState, setResultsState] = useState<ReactNode>()
 
-  const { data: trendingCollectionResults, isLoading: trendingCollectionsAreLoading } = useQuery(
-    ['trendingCollections', 'eth', 'twenty_four_hours'],
-    () => fetchTrendingCollections({ volumeType: 'eth', timePeriod: 'ONE_DAY' as TimePeriod, size: 3 })
+  const { data: trendingCollections, loading: trendingCollectionsAreLoading } = useTrendingCollections(
+    3,
+    HistoryDuration.Day
   )
 
-  const { data: gqlData, loading } = useTrendingCollections(3, HistoryDuration.Day)
-
-  const trendingCollections = useMemo(() => {
-    const gatedTrendingCollections = isNftGraphqlEnabled ? gqlData : trendingCollectionResults
-    return gatedTrendingCollections && (!isNftGraphqlEnabled || !loading)
-      ? gatedTrendingCollections
-          .map((collection) => ({
+  const formattedTrendingCollections = useMemo(() => {
+    return !trendingCollectionsAreLoading
+      ? trendingCollections
+          ?.map((collection) => ({
             ...collection,
             collectionAddress: collection.address,
-            floorPrice: isNftGraphqlEnabled ? collection.floor : formatEthPrice(collection.floor?.toString()),
+            floorPrice: collection.floor,
             stats: {
               total_supply: collection.totalSupply,
               one_day_change: collection.floorChange,
-              floor_price: isNftGraphqlEnabled ? collection.floor : formatEthPrice(collection.floor?.toString()),
+              floor_price: collection.floor,
             },
           }))
-          .slice(0, isNFTPage ? 3 : 2)
+          .slice(0, isNFTPage ? 3 : 2) ?? []
       : [...Array<GenieCollection>(isNFTPage ? 3 : 2)]
-  }, [gqlData, isNFTPage, isNftGraphqlEnabled, loading, trendingCollectionResults])
+  }, [trendingCollections, isNFTPage, trendingCollectionsAreLoading])
 
   const { data: trendingTokenData } = useTrendingTokens(useWeb3React().chainId)
 
@@ -189,7 +181,7 @@ export const SearchBarDropdown = ({
   const totalSuggestions = hasInput
     ? tokens.length + collections.length
     : Math.min(shortenedHistory.length, 2) +
-      (isNFTPage || !isTokenPage ? trendingCollections?.length ?? 0 : 0) +
+      (isNFTPage || !isTokenPage ? formattedTrendingCollections?.length ?? 0 : 0) +
       (isTokenPage || !isNFTPage ? trendingTokens?.length ?? 0 : 0)
 
   // Navigate search results via arrow keys
@@ -324,7 +316,7 @@ export const SearchBarDropdown = ({
                 startingIndex={shortenedHistory.length + (isNFTPage ? 0 : trendingTokens?.length ?? 0)}
                 setHoveredIndex={setHoveredIndex}
                 toggleOpen={toggleOpen}
-                suggestions={trendingCollections as unknown as GenieCollection[]}
+                suggestions={formattedTrendingCollections as unknown as GenieCollection[]}
                 eventProperties={{
                   suggestion_type: NavBarSearchTypes.COLLECTION_TRENDING,
                   ...eventProperties,
@@ -343,8 +335,7 @@ export const SearchBarDropdown = ({
     isLoading,
     tokens,
     collections,
-    trendingCollections,
-    trendingCollectionsAreLoading,
+    formattedTrendingCollections,
     trendingTokens,
     trendingTokenData,
     hoveredIndex,
@@ -358,6 +349,7 @@ export const SearchBarDropdown = ({
     totalSuggestions,
     trace,
     searchHistory,
+    trendingCollectionsAreLoading,
   ])
 
   const showBNBComingSoonBadge = chainId === SupportedChainId.BNB && !isLoading

src/featureFlags/flags/featureFlags.ts

@@ -8,6 +8,5 @@ export enum FeatureFlag {
   fiatOnRampButtonOnSwap = 'fiat_on_ramp_button_on_swap_page',
   swapWidget = 'swap_widget_replacement_enabled',
   statsigDummy = 'web_dummy_gate_amplitude_id',
-  nftGraphql = 'nft_graphql_migration',
   detailsV2 = 'details_v2',
 }

src/featureFlags/flags/nftlGraphql.ts

-import { BaseVariant, FeatureFlag, useBaseFlag } from '../index'
-
-export function useNftGraphqlFlag(): BaseVariant {
-  return useBaseFlag(FeatureFlag.nftGraphql)
-}
-
-export function useNftGraphqlEnabled(): boolean {
-  return useNftGraphqlFlag() === BaseVariant.Enabled
-}
-
-export { BaseVariant as NftGraphqlVariant }

src/graphql/data/nft/CollectionSearch.ts

 import { isAddress } from '@ethersproject/address'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import gql from 'graphql-tag'
 import { GenieCollection } from 'nft/types'
 import { blocklistedCollections } from 'nft/utils'
@@ -80,9 +79,8 @@ function useCollectionQuerySearch(query: string, skip?: boolean): useCollectionS
 }
 
 export function useCollectionSearch(queryOrAddress: string): useCollectionSearchReturnProps {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const isName = !isAddress(queryOrAddress.toLowerCase())
-  const queryResult = useCollectionQuerySearch(queryOrAddress, isNftGraphqlEnabled ? !isName : true)
-  const addressResult = useCollection(queryOrAddress, isNftGraphqlEnabled ? isName : true)
+  const queryResult = useCollectionQuerySearch(queryOrAddress, /* skip= */ !isName)
+  const addressResult = useCollection(queryOrAddress, /* skip= */ isName)
   return isName ? queryResult : { data: [addressResult.data], loading: addressResult.loading }
 }

src/graphql/data/nft/NftActivity.ts

 import { WatchQueryFetchPolicy } from '@apollo/client'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import gql from 'graphql-tag'
 import { ActivityEvent } from 'nft/types'
 import { useCallback, useMemo } from 'react'
@@ -71,13 +70,11 @@ gql`
 `
 
 export function useNftActivity(filter: NftActivityFilterInput, first?: number, fetchPolicy?: WatchQueryFetchPolicy) {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const { data, loading, fetchMore, error } = useNftActivityQuery({
     variables: {
       filter,
       first,
     },
-    skip: !isNftGraphqlEnabled,
     fetchPolicy,
   })
 

src/graphql/data/nft/TrendingCollections.ts

-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import gql from 'graphql-tag'
 import { TrendingCollection } from 'nft/types'
 import { useMemo } from 'react'
@@ -53,13 +52,11 @@ gql`
 `
 
 export function useTrendingCollections(size: number, timePeriod: HistoryDuration) {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const { data, loading, error } = useTrendingCollectionsQuery({
     variables: {
       size,
       timePeriod,
     },
-    skip: !isNftGraphqlEnabled,
   })
 
   const trendingCollections: TrendingCollection[] | undefined = useMemo(

src/nft/components/collection/Activity.tsx

 import { OpacityHoverState } from 'components/Common'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { NftActivityType } from 'graphql/data/__generated__/types-and-hooks'
 import { useNftActivity } from 'graphql/data/nft/NftActivity'
 import { Box } from 'nft/components/Box'
 import { Column, Row } from 'nft/components/Flex'
 import { themeVars, vars } from 'nft/css/sprinkles.css'
 import { useBag, useIsMobile } from 'nft/hooks'
-import { ActivityFetcher } from 'nft/queries/genie/ActivityFetcher'
-import { ActivityEvent, ActivityEventResponse, ActivityEventType } from 'nft/types'
+import { ActivityEvent, ActivityEventType } from 'nft/types'
 import { fetchPrice } from 'nft/utils/fetchPrice'
 import { useCallback, useEffect, useReducer, useState } from 'react'
 import InfiniteScroll from 'react-infinite-scroll-component'
-import { useInfiniteQuery } from 'react-query'
 import styled from 'styled-components/macro'
 import { useIsDarkMode } from 'theme/components/ThemeToggle'
 
@@ -66,51 +63,13 @@ export const reduceFilters = (state: typeof initialFilterState, action: { eventT
 const baseHref = (event: ActivityEvent) => `/#/nfts/asset/${event.collectionAddress}/${event.tokenId}?origin=activity`
 
 export const Activity = ({ contractAddress, rarityVerified, collectionName, chainId }: ActivityProps) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const [activeFilters, filtersDispatch] = useReducer(reduceFilters, initialFilterState)
 
   const {
-    data: eventsData,
-    fetchNextPage,
-    hasNextPage,
-    isFetchingNextPage,
-    isSuccess,
-    isLoading,
-  } = useInfiniteQuery<ActivityEventResponse>(
-    [
-      'collectionActivity',
-      {
-        contractAddress,
-        activeFilters,
-      },
-    ],
-    async ({ pageParam = '' }) => {
-      return await ActivityFetcher(
-        contractAddress,
-        {
-          eventTypes: Object.keys(activeFilters)
-            .filter((key) => activeFilters[key as ActivityEventType])
-            .map((key) => key as ActivityEventType),
-        },
-        pageParam
-      )
-    },
-    {
-      getNextPageParam: (lastPage) => {
-        return lastPage.events?.length === 25 ? lastPage.cursor : undefined
-      },
-      refetchInterval: 15000,
-      refetchIntervalInBackground: false,
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-    }
-  )
-
-  const {
-    nftActivity: gqlEventsData,
-    hasNext,
-    loadMore,
-    loading,
+    nftActivity,
+    hasNext: hasNextActivity,
+    loadMore: loadMoreActivities,
+    loading: activitiesAreLoading,
   } = useNftActivity(
     {
       activityTypes: Object.keys(activeFilters)
@@ -121,18 +80,7 @@ export const Activity = ({ contractAddress, rarityVerified, collectionName, chai
     25
   )
 
-  const { events, gatedHasNext, gatedLoadMore, gatedLoading, gatedIsLoadingMore } = {
-    events: isNftGraphqlEnabled
-      ? gqlEventsData
-      : isSuccess
-      ? eventsData?.pages.map((page) => page.events).flat()
-      : undefined,
-    gatedHasNext: isNftGraphqlEnabled ? hasNext : hasNextPage,
-    gatedLoadMore: isNftGraphqlEnabled ? loadMore : fetchNextPage,
-    gatedLoading: isNftGraphqlEnabled ? loading : isLoading,
-    gatedIsLoadingMore: isNftGraphqlEnabled ? hasNext && gqlEventsData?.length : isFetchingNextPage,
-  }
-
+  const isLoadingMore = hasNextActivity && nftActivity?.length
   const itemsInBag = useBag((state) => state.itemsInBag)
   const addAssetsToBag = useBag((state) => state.addAssetsToBag)
   const removeAssetsFromBag = useBag((state) => state.removeAssetsFromBag)
@@ -173,20 +121,20 @@ export const Activity = ({ contractAddress, rarityVerified, collectionName, chai
         <Filter eventType={ActivityEventType.Sale} />
         <Filter eventType={ActivityEventType.Transfer} />
       </Row>
-      {gatedLoading ? (
+      {activitiesAreLoading ? (
         <ActivityLoader />
       ) : (
-        events && (
+        nftActivity && (
           <Column marginTop="36">
             <HeaderRow />
             <InfiniteScroll
-              next={gatedLoadMore}
-              hasMore={!!gatedHasNext}
-              loader={gatedIsLoadingMore ? <ActivityPageLoader rowCount={2} /> : null}
-              dataLength={events?.length ?? 0}
+              next={loadMoreActivities}
+              hasMore={!!hasNextActivity}
+              loader={isLoadingMore ? <ActivityPageLoader rowCount={2} /> : null}
+              dataLength={nftActivity?.length ?? 0}
               style={{ overflow: 'unset' }}
             >
-              {events.map(
+              {nftActivity.map(
                 (event, i) =>
                   event.eventType && (
                     <Box

src/nft/components/collection/ActivityCells.tsx

@@ -2,7 +2,6 @@ import { sendAnalyticsEvent, useTrace } from '@uniswap/analytics'
 import { InterfacePageName, NFTEventName } from '@uniswap/analytics-events'
 import { ChainId } from '@uniswap/smart-order-router'
 import { MouseoverTooltip } from 'components/Tooltip'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { NftActivityType, OrderStatus } from 'graphql/data/__generated__/types-and-hooks'
 import { Box } from 'nft/components/Box'
 import { Column, Row } from 'nft/components/Flex'
@@ -26,8 +25,8 @@ import {
 } from 'nft/types'
 import { shortenAddress } from 'nft/utils/address'
 import { buildActivityAsset } from 'nft/utils/buildActivityAsset'
-import { formatEth, formatEthPrice } from 'nft/utils/currency'
-import { getTimeDifference, isValidDate } from 'nft/utils/date'
+import { formatEth } from 'nft/utils/currency'
+import { getTimeDifference } from 'nft/utils/date'
 import { putCommas } from 'nft/utils/putCommas'
 import { MouseEvent, useMemo, useState } from 'react'
 import styled from 'styled-components/macro'
@@ -95,10 +94,9 @@ export const BuyCell = ({
   isMobile,
   ethPriceInUSD,
 }: BuyCellProps) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const asset = useMemo(
-    () => buildActivityAsset(event, collectionName, ethPriceInUSD, isNftGraphqlEnabled),
-    [event, collectionName, ethPriceInUSD, isNftGraphqlEnabled]
+    () => buildActivityAsset(event, collectionName, ethPriceInUSD),
+    [event, collectionName, ethPriceInUSD]
   )
   const isSelected = useMemo(() => {
     return itemsInBag.some((item) => asset.tokenId === item.asset.tokenId && asset.address === item.asset.address)
@@ -187,16 +185,7 @@ const PriceTooltip = ({ price }: { price: string }) => (
 )
 
 export const PriceCell = ({ marketplace, price }: { marketplace?: Markets | string; price?: string | number }) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
-  const formattedPrice = useMemo(
-    () =>
-      price
-        ? isNftGraphqlEnabled
-          ? formatEth(parseFloat(price?.toString()))
-          : putCommas(formatEthPrice(price.toString()))?.toString()
-        : null,
-    [isNftGraphqlEnabled, price]
-  )
+  const formattedPrice = useMemo(() => (price ? formatEth(parseFloat(price?.toString())) : null), [price])
 
   return (
     <Row display={{ sm: 'none', md: 'flex' }} gap="8">
@@ -268,25 +257,16 @@ export const EventCell = ({
   price,
   isMobile,
 }: EventCellProps) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
-  const formattedPrice = useMemo(
-    () =>
-      price
-        ? isNftGraphqlEnabled
-          ? formatEth(parseFloat(price?.toString()))
-          : putCommas(formatEthPrice(price.toString()))?.toString()
-        : null,
-    [isNftGraphqlEnabled, price]
-  )
+  const formattedPrice = useMemo(() => (price ? formatEth(parseFloat(price?.toString())) : null), [price])
   return (
     <Column height="full" justifyContent="center" gap="4">
       <Row className={styles.eventDetail} color={eventColors(eventType)}>
         {renderEventIcon(eventType)}
         {ActivityEventTypeDisplay[eventType]}
       </Row>
-      {eventTimestamp && (isValidDate(eventTimestamp) || isNftGraphqlEnabled) && !isMobile && !eventOnly && (
+      {eventTimestamp && !isMobile && !eventOnly && (
         <Row className={styles.eventTime}>
-          {getTimeDifference(eventTimestamp.toString(), isNftGraphqlEnabled)}
+          {getTimeDifference(eventTimestamp.toString())}
           {eventTransactionHash && <ExternalLinkIcon transactionHash={eventTransactionHash} />}
         </Row>
       )}
@@ -378,7 +358,6 @@ const getItemImage = (tokenMetadata?: TokenMetadata): string | undefined => {
 export const ItemCell = ({ event, rarityVerified, collectionName, eventTimestamp, isMobile }: ItemCellProps) => {
   const [loaded, setLoaded] = useState(false)
   const [noContent, setNoContent] = useState(!getItemImage(event.tokenMetadata))
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
 
   return (
     <Row gap="16" overflow="hidden" whiteSpace="nowrap">
@@ -407,10 +386,7 @@ export const ItemCell = ({ event, rarityVerified, collectionName, eventTimestamp
             collectionName={collectionName}
           />
         )}
-        {isMobile &&
-          eventTimestamp &&
-          (isValidDate(eventTimestamp) || isNftGraphqlEnabled) &&
-          getTimeDifference(eventTimestamp.toString(), isNftGraphqlEnabled)}
+        {isMobile && eventTimestamp && getTimeDifference(eventTimestamp.toString())}
       </Column>
     </Row>
   )

src/nft/components/details/AssetActivity.tsx

 import { Trans } from '@lingui/macro'
 import { OpacityHoverState, ScrollBarStyles } from 'components/Common'
 import { LoadingBubble } from 'components/Tokens/loading'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { EventCell, MarketplaceIcon } from 'nft/components/collection/ActivityCells'
 import { ActivityEvent } from 'nft/types'
 import { shortenAddress } from 'nft/utils/address'
-import { formatEth, formatEthPrice } from 'nft/utils/currency'
+import { formatEth } from 'nft/utils/currency'
 import { getTimeDifference } from 'nft/utils/date'
-import { putCommas } from 'nft/utils/putCommas'
 import { ReactNode } from 'react'
 import styled from 'styled-components/macro'
 
@@ -149,17 +147,12 @@ export const LoadingAssetActivity = ({ rowCount }: { rowCount: number }) => {
 }
 
 const AssetActivity = ({ events }: { events: ActivityEvent[] | undefined }) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   return (
     <ActivityTable>
       {events &&
         events.map((event, index) => {
           const { eventTimestamp, eventType, fromAddress, marketplace, price, toAddress, transactionHash } = event
-          const formattedPrice = price
-            ? isNftGraphqlEnabled
-              ? formatEth(parseFloat(price ?? ''))
-              : putCommas(formatEthPrice(price)).toString()
-            : null
+          const formattedPrice = price ? formatEth(parseFloat(price ?? '')) : null
           if (!eventType) return null
           return (
             <TR key={index}>
@@ -195,7 +188,7 @@ const AssetActivity = ({ events }: { events: ActivityEvent[] | undefined }) => {
                   </Link>
                 )}
               </TD>
-              <TD>{eventTimestamp && getTimeDifference(eventTimestamp.toString(), isNftGraphqlEnabled)}</TD>
+              <TD>{eventTimestamp && getTimeDifference(eventTimestamp.toString())}</TD>
             </TR>
           )
         })}

src/nft/components/details/AssetDetails.tsx

 import { OpacityHoverState, ScrollBarStyles } from 'components/Common'
 import Resource from 'components/Tokens/TokenDetails/Resource'
 import { MouseoverTooltip } from 'components/Tooltip/index'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { NftActivityType } from 'graphql/data/__generated__/types-and-hooks'
 import { useNftActivity } from 'graphql/data/nft/NftActivity'
 import { Box } from 'nft/components/Box'
@@ -10,16 +9,14 @@ import { LoadingSparkle } from 'nft/components/common/Loading/LoadingSparkle'
 import { AssetPriceDetails } from 'nft/components/details/AssetPriceDetails'
 import { Center } from 'nft/components/Flex'
 import { themeVars, vars } from 'nft/css/sprinkles.css'
-import { ActivityFetcher } from 'nft/queries/genie/ActivityFetcher'
-import { ActivityEventResponse, ActivityEventType, CollectionInfoForAsset, GenieAsset } from 'nft/types'
+import { ActivityEventType, CollectionInfoForAsset, GenieAsset } from 'nft/types'
 import { shortenAddress } from 'nft/utils/address'
-import { formatEth, formatEthPrice } from 'nft/utils/currency'
+import { formatEth } from 'nft/utils/currency'
 import { isAudio } from 'nft/utils/isAudio'
 import { isVideo } from 'nft/utils/isVideo'
 import { putCommas } from 'nft/utils/putCommas'
 import { useCallback, useMemo, useReducer, useState } from 'react'
 import InfiniteScroll from 'react-infinite-scroll-component'
-import { useInfiniteQuery, useQuery } from 'react-query'
 import { Link as RouterLink } from 'react-router-dom'
 import styled from 'styled-components/macro'
 import { useIsDarkMode } from 'theme/components/ThemeToggle'
@@ -246,7 +243,6 @@ interface AssetDetailsProps {
 }
 
 export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const [dominantColor] = useState<[number, number, number]>([0, 0, 0])
 
   const { rarityProvider } = useMemo(
@@ -274,34 +270,6 @@ export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
 
   const { address: contractAddress, tokenId: token_id } = asset
 
-  const { data: priceData } = useQuery<ActivityEventResponse>(
-    [
-      'collectionActivity',
-      {
-        contractAddress,
-      },
-    ],
-    async ({ pageParam = '' }) => {
-      return await ActivityFetcher(
-        contractAddress,
-        {
-          token_id,
-          eventTypes: [ActivityEventType.Sale],
-        },
-        pageParam,
-        '1'
-      )
-    },
-    {
-      getNextPageParam: (lastPage) => {
-        return lastPage.events?.length === 25 ? lastPage.cursor : undefined
-      },
-      refetchInterval: 15000,
-      refetchIntervalInBackground: false,
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-    }
-  )
   const { nftActivity: gqlPriceData } = useNftActivity(
     {
       activityTypes: [NftActivityType.Sale],
@@ -312,14 +280,8 @@ export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
     'no-cache'
   )
 
-  let formattedPrice
-  if (isNftGraphqlEnabled) {
-    const weiPrice = gqlPriceData?.[0]?.price
-    formattedPrice = weiPrice ? formatEth(parseFloat(weiPrice)) : undefined
-  } else {
-    const ethPrice = priceData?.events[0]?.price
-    formattedPrice = ethPrice ? putCommas(formatEthPrice(priceData?.events[0]?.price)).toString() : undefined
-  }
+  const weiPrice = gqlPriceData?.[0]?.price
+  const formattedPrice = weiPrice ? formatEth(parseFloat(weiPrice)) : undefined
 
   const [activeFilters, filtersDispatch] = useReducer(reduceFilters, initialFilterState)
   const Filter = useCallback(
@@ -344,50 +306,11 @@ export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
   )
 
   const {
-    data: eventsData,
-    fetchNextPage,
-    hasNextPage,
-    isFetchingNextPage,
-    isSuccess,
-    isLoading: isActivityLoading,
-  } = useInfiniteQuery<ActivityEventResponse>(
-    [
-      'collectionActivity',
-      {
-        contractAddress,
-        activeFilters,
-        token_id,
-      },
-    ],
-    async ({ pageParam = '' }) => {
-      return await ActivityFetcher(
-        contractAddress,
-        {
-          token_id,
-          eventTypes: Object.keys(activeFilters)
-            .map((key) => key as ActivityEventType)
-            .filter((key) => activeFilters[key]),
-        },
-        pageParam
-      )
-    },
-    {
-      getNextPageParam: (lastPage) => {
-        return lastPage.events?.length === 25 ? lastPage.cursor : undefined
-      },
-      refetchInterval: 15000,
-      refetchIntervalInBackground: false,
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-    }
-  )
-
-  const {
-    nftActivity: gqlEventsData,
-    hasNext,
-    loadMore,
-    loading,
-    error,
+    nftActivity,
+    hasNext: hasNextActivity,
+    loadMore: loadMoreActivities,
+    loading: activitiesAreLoading,
+    error: errorLoadingActivities,
   } = useNftActivity(
     {
       activityTypes: Object.keys(activeFilters)
@@ -399,28 +322,6 @@ export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
     25
   )
 
-  const { events, gatedHasNext, gatedLoadMore, gatedLoading, gatedSuccess } = useMemo(() => {
-    return {
-      events: isNftGraphqlEnabled ? gqlEventsData : eventsData?.pages.map((page) => page.events).flat(),
-      gatedHasNext: isNftGraphqlEnabled ? hasNext : hasNextPage,
-      gatedLoadMore: isNftGraphqlEnabled ? loadMore : fetchNextPage,
-      gatedLoading: isNftGraphqlEnabled ? loading : isActivityLoading,
-      gatedSuccess: isNftGraphqlEnabled ? !error : isSuccess,
-    }
-  }, [
-    error,
-    eventsData?.pages,
-    fetchNextPage,
-    gqlEventsData,
-    hasNext,
-    hasNextPage,
-    isActivityLoading,
-    isNftGraphqlEnabled,
-    isSuccess,
-    loadMore,
-    loading,
-  ])
-
   const rarity = asset?.rarity?.providers?.[0]
   const [showHolder, setShowHolder] = useState(false)
 
@@ -482,27 +383,27 @@ export const AssetDetails = ({ asset, collection }: AssetDetailsProps) => {
             <Filter eventType={ActivityEventType.Transfer} />
             <Filter eventType={ActivityEventType.CancelListing} />
           </ActivitySelectContainer>
-          {gatedLoading ? (
+          {activitiesAreLoading ? (
             <LoadingAssetActivity rowCount={10} />
-          ) : events && events.length > 0 ? (
+          ) : nftActivity && nftActivity.length > 0 ? (
             <InfiniteScroll
-              next={gatedLoadMore}
-              hasMore={!!gatedHasNext}
+              next={loadMoreActivities}
+              hasMore={!!hasNextActivity}
               loader={
-                isFetchingNextPage && (
+                activitiesAreLoading && (
                   <Center>
                     <LoadingSparkle />
                   </Center>
                 )
               }
-              dataLength={events?.length ?? 0}
+              dataLength={nftActivity?.length ?? 0}
               scrollableTarget="activityContainer"
             >
-              <AssetActivity events={events} />
+              <AssetActivity events={nftActivity} />
             </InfiniteScroll>
           ) : (
             <>
-              {gatedSuccess && events && (
+              {!errorLoadingActivities && nftActivity && (
                 <EmptyActivitiesContainer>
                   <div>No activities yet</div>
                   <Link to={`/nfts/collection/${asset.address}`}>View collection items</Link>{' '}

src/nft/components/explore/Banner.tsx

-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { HistoryDuration } from 'graphql/data/__generated__/types-and-hooks'
 import { useTrendingCollections } from 'graphql/data/nft/TrendingCollections'
-import { fetchTrendingCollections } from 'nft/queries'
-import { TimePeriod } from 'nft/types'
 import { calculateCardIndex } from 'nft/utils'
 import { useCallback, useMemo, useState } from 'react'
-import { useQuery } from 'react-query'
 import { useNavigate } from 'react-router-dom'
 import styled from 'styled-components/macro'
 import { opacify } from 'theme/utils'
@@ -117,34 +113,17 @@ const TRENDING_COLLECTION_SIZE = 5
 
 const Banner = () => {
   const navigate = useNavigate()
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
-
-  const { data } = useQuery(
-    ['trendingCollections'],
-    () => {
-      return fetchTrendingCollections({
-        volumeType: 'eth',
-        timePeriod: TimePeriod.OneDay,
-        size: TRENDING_COLLECTION_SIZE + EXCLUDED_COLLECTIONS.length,
-      })
-    },
-    {
-      refetchOnReconnect: false,
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-    }
-  )
-  const { data: gqlData } = useTrendingCollections(
+
+  const { data: trendingCollections } = useTrendingCollections(
     TRENDING_COLLECTION_SIZE + EXCLUDED_COLLECTIONS.length,
     HistoryDuration.Day
   )
 
   const collections = useMemo(() => {
-    const gatedData = isNftGraphqlEnabled ? gqlData : data
-    return gatedData
+    return trendingCollections
       ?.filter((collection) => collection.address && !EXCLUDED_COLLECTIONS.includes(collection.address))
-      .slice(0, 5)
-  }, [data, gqlData, isNftGraphqlEnabled])
+      .slice(0, TRENDING_COLLECTION_SIZE)
+  }, [trendingCollections])
 
   const [activeCollectionIdx, setActiveCollectionIdx] = useState(0)
   const onToggleNextSlide = useCallback(

src/nft/components/explore/CarouselCard.tsx

 import { formatNumberOrString, NumberType } from '@uniswap/conedison/format'
 import { loadingAnimation } from 'components/Loader/styled'
 import { LoadingBubble } from 'components/Tokens/loading'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { useCollection } from 'graphql/data/nft/Collection'
 import { VerifiedIcon } from 'nft/components/icons'
 import { Markets, TrendingCollection } from 'nft/types'
-import { ethNumberStandardFormatter, formatWeiToDecimal } from 'nft/utils'
+import { ethNumberStandardFormatter } from 'nft/utils'
 import styled from 'styled-components/macro'
 import { ThemedText } from 'theme/components/text'
 
@@ -237,7 +236,6 @@ const MARKETS_ENUM_TO_NAME = {
 
 export const CarouselCard = ({ collection, onClick }: CarouselCardProps) => {
   const { data: gqlCollection, loading } = useCollection(collection.address ?? '')
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
 
   if (loading) return <LoadingCarouselCard />
 
@@ -256,10 +254,7 @@ export const CarouselCard = ({ collection, onClick }: CarouselCardProps) => {
             <TableElement>
               {collection.floor && (
                 <ThemedText.SubHeaderSmall color="userThemeColor">
-                  {isNftGraphqlEnabled
-                    ? ethNumberStandardFormatter(collection.floor)
-                    : formatWeiToDecimal(collection.floor.toString())}{' '}
-                  ETH Floor
+                  {ethNumberStandardFormatter(collection.floor)} ETH Floor
                 </ThemedText.SubHeaderSmall>
               )}
             </TableElement>

src/nft/components/explore/Cells/Cells.tsx

 import { formatEther } from '@ethersproject/units'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { SquareArrowDownIcon, SquareArrowUpIcon, VerifiedIcon } from 'nft/components/icons'
 import { useIsMobile } from 'nft/hooks'
 import { Denomination } from 'nft/types'
-import { volumeFormatter } from 'nft/utils'
+import { ethNumberStandardFormatter, volumeFormatter } from 'nft/utils'
 import { ReactNode } from 'react'
 import styled from 'styled-components/macro'
 import { ThemedText } from 'theme'
 
-import { ethNumberStandardFormatter, formatWeiToDecimal } from '../../../utils/currency'
 import * as styles from './Cells.css'
 
 const TruncatedText = styled.div`
@@ -114,13 +112,10 @@ export const EthCell = ({
   denomination: Denomination
   usdPrice?: number
 }) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
-  const denominatedValue = getDenominatedValue(denomination, !isNftGraphqlEnabled, value, usdPrice)
+  const denominatedValue = getDenominatedValue(denomination, false, value, usdPrice)
   const formattedValue = denominatedValue
     ? denomination === Denomination.ETH
-      ? isNftGraphqlEnabled
-        ? ethNumberStandardFormatter(denominatedValue.toString(), false, true, false) + ' ETH'
-        : formatWeiToDecimal(denominatedValue.toString(), true) + ' ETH'
+      ? ethNumberStandardFormatter(denominatedValue.toString(), false, true, false) + ' ETH'
       : ethNumberStandardFormatter(denominatedValue, true, false, true)
     : '-'
 

src/nft/components/explore/CollectionTable.tsx

-import { BigNumber } from '@ethersproject/bignumber'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { CollectionTableColumn, TimePeriod } from 'nft/types'
 import { useMemo } from 'react'
 import { CellProps, Column, Row } from 'react-table'
@@ -27,19 +25,11 @@ const compareFloats = (a?: number, b?: number): 1 | -1 => {
 }
 
 const CollectionTable = ({ data, timePeriod }: { data: CollectionTableColumn[]; timePeriod: TimePeriod }) => {
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
   const floorSort = useMemo(() => {
     return (rowA: Row<CollectionTableColumn>, rowB: Row<CollectionTableColumn>) => {
-      if (isNftGraphqlEnabled) {
-        return compareFloats(rowA.original.floor.value, rowB.original.floor.value)
-      } else {
-        const aFloor = BigNumber.from(rowA.original.floor.value ?? 0)
-        const bFloor = BigNumber.from(rowB.original.floor.value ?? 0)
-
-        return aFloor.gte(bFloor) ? 1 : -1
-      }
+      return compareFloats(rowA.original.floor.value, rowB.original.floor.value)
     }
-  }, [isNftGraphqlEnabled])
+  }, [])
 
   const floorChangeSort = useMemo(() => {
     return (rowA: Row<CollectionTableColumn>, rowB: Row<CollectionTableColumn>) => {

src/nft/components/explore/TrendingCollections.tsx

 import { OpacityHoverState } from 'components/Common'
-import { useNftGraphqlEnabled } from 'featureFlags/flags/nftlGraphql'
 import { HistoryDuration } from 'graphql/data/__generated__/types-and-hooks'
 import { useTrendingCollections } from 'graphql/data/nft/TrendingCollections'
 import ms from 'ms.macro'
@@ -10,7 +9,6 @@ import { useQuery } from 'react-query'
 import styled from 'styled-components/macro'
 import { ThemedText } from 'theme'
 
-import { fetchTrendingCollections } from '../../queries'
 import CollectionTable from './CollectionTable'
 
 const timeOptions: { label: string; value: TimePeriod }[] = [
@@ -90,22 +88,11 @@ function convertTimePeriodToHistoryDuration(timePeriod: TimePeriod): HistoryDura
 const TrendingCollections = () => {
   const [timePeriod, setTimePeriod] = useState<TimePeriod>(TimePeriod.OneDay)
   const [isEthToggled, setEthToggled] = useState(true)
-  const isNftGraphqlEnabled = useNftGraphqlEnabled()
-
-  const { isSuccess, data } = useQuery(
-    ['trendingCollections', timePeriod],
-    () => {
-      return fetchTrendingCollections({ volumeType: 'eth', timePeriod, size: 100 })
-    },
-    {
-      refetchOnReconnect: false,
-      refetchOnWindowFocus: false,
-      refetchOnMount: false,
-      refetchInterval: 5000,
-    }
-  )
 
-  const { data: gqlData, loading } = useTrendingCollections(100, convertTimePeriodToHistoryDuration(timePeriod))
+  const { data: trendingCollections, loading: trendingCollectionsAreLoading } = useTrendingCollections(
+    100,
+    convertTimePeriodToHistoryDuration(timePeriod)
+  )
 
   const { data: usdPrice } = useQuery(['fetchPrice', {}], () => fetchPrice(), {
     refetchOnReconnect: false,
@@ -114,11 +101,9 @@ const TrendingCollections = () => {
     refetchInterval: ms`1m`,
   })
 
-  const trendingCollections = useMemo(() => {
-    const gatedData = isNftGraphqlEnabled ? gqlData : data
-    const dataLoaded = isNftGraphqlEnabled ? !loading : isSuccess
-    if (dataLoaded && gatedData) {
-      return gatedData.map((d) => ({
+  const trendingCollectionColumns = useMemo(() => {
+    if (!trendingCollectionsAreLoading && trendingCollections) {
+      return trendingCollections.map((d) => ({
         ...d,
         collection: {
           name: d.name,
@@ -144,7 +129,7 @@ const TrendingCollections = () => {
         usdPrice,
       }))
     } else return [] as CollectionTableColumn[]
-  }, [isNftGraphqlEnabled, gqlData, data, loading, isSuccess, isEthToggled, usdPrice])
+  }, [trendingCollections, trendingCollectionsAreLoading, isEthToggled, usdPrice])
 
   return (
     <ExploreContainer>
@@ -178,7 +163,7 @@ const TrendingCollections = () => {
           </Selector>
         </Filter>
       </FiltersRow>
-      <CollectionTable data={trendingCollections} timePeriod={timePeriod} />
+      <CollectionTable data={trendingCollectionColumns} timePeriod={timePeriod} />
     </ExploreContainer>
   )
 }

src/nft/queries/genie/ActivityFetcher.ts

-import { ActivityEventResponse, ActivityFilter } from '../../types'
-
-export const ActivityFetcher = async (
-  contractAddress: string,
-  filters?: ActivityFilter,
-  cursor?: string,
-  limit?: string
-): Promise<ActivityEventResponse> => {
-  const filterParam =
-    filters && filters.eventTypes
-      ? `&event_types=${filters.eventTypes?.map((eventType) => `${eventType}`).join(',')}`
-      : ''
-
-  const tokenId = filters?.token_id ? `&token_id=${filters?.token_id}` : ''
-
-  const url = `${process.env.REACT_APP_TEMP_API_URL}/nft/collections/${contractAddress}/activity?limit=${
-    limit ? limit : '25'
-  }${filterParam}${cursor ? `&cursor=${cursor}` : ''}${tokenId}`
-
-  const r = await fetch(url, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  })
-  const data = await r.json()
-  return data.data
-}

src/nft/queries/genie/SearchCollectionsFetcher.ts

-import { isAddress } from '@ethersproject/address'
-import { blocklistedCollections } from 'nft/utils'
-
-import { GenieCollection } from '../../types'
-
-const MAX_SEARCH_RESULTS = 6
-
-const NFT_API_URL = process.env.REACT_APP_TEMP_API_URL
-export const fetchSearchCollections = async (addressOrName: string, recursive = false): Promise<GenieCollection[]> => {
-  if (!NFT_API_URL) return Promise.resolve([])
-  const url = `${NFT_API_URL}/nft/searchCollections`
-  const isName = !isAddress(addressOrName.toLowerCase())
-
-  if (!isName && !recursive) {
-    try {
-      return await fetchSearchCollections(addressOrName.toLowerCase(), true)
-    } catch {
-      return []
-    }
-  }
-
-  const filters = isName
-    ? {
-        $or: [{ name: { $regex: addressOrName, $options: 'i' } }],
-      }
-    : { address: addressOrName }
-
-  const payload = {
-    filters,
-    limit: 6,
-    fields: {
-      name: 1,
-      imageUrl: 1,
-      address: 1,
-      floorPrice: 1,
-    },
-    offset: 0,
-  }
-  const r = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(payload),
-  })
-  if (isName) {
-    const data = await r.json()
-    const formattedData = data?.data
-      ? data.data
-          .filter((collection: { address: string }) => !blocklistedCollections.includes(collection.address))
-          .map((collection: { stats: Record<string, unknown>; floorPrice: string }) => {
-            return {
-              ...collection,
-              stats: {
-                ...collection.stats,
-                floor_price: collection.floorPrice,
-              },
-            }
-          })
-      : []
-    return formattedData.slice(0, MAX_SEARCH_RESULTS)
-  }
-  const data = await r.json()
-
-  return data.data ? [{ ...data.data[0], stats: { ...data.data[0].stats, floor_price: data.data[0].floorPrice } }] : []
-}

src/nft/queries/genie/TrendingCollectionsFetcher.ts

-import { blocklistedCollections } from 'nft/utils'
-
-import { TimePeriod, TrendingCollection } from '../../types'
-
-const NFT_API_URL = process.env.REACT_APP_TEMP_API_URL
-export const fetchTrendingCollections = async (payload: {
-  volumeType: 'eth' | 'nft'
-  timePeriod: TimePeriod
-  size: number
-}): Promise<TrendingCollection[]> => {
-  if (!NFT_API_URL) return Promise.resolve([])
-  const url = `${NFT_API_URL}/nft/collections/trending`
-  const r = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(payload),
-  })
-
-  const data = await r.json()
-
-  return data.filter((collection: { address: string }) => !blocklistedCollections.includes(collection.address)) ?? []
-}

src/nft/queries/genie/index.ts

-export * from './ActivityFetcher'
 export * from './CollectionPreviewFetcher'
 export * from './RouteFetcher'
-export * from './SearchCollectionsFetcher'
-export * from './TrendingCollectionsFetcher'

src/nft/utils/buildActivityAsset.ts

-import { BigNumber } from '@ethersproject/bignumber'
-import { formatEther } from '@ethersproject/units'
 import { parseEther } from 'ethers/lib/utils'
 import { ActivityEvent, GenieAsset } from 'nft/types'
 
 import { formatEth } from './currency'
 
-export const buildActivityAsset = (
-  event: ActivityEvent,
-  collectionName: string,
-  ethPriceInUSD: number,
-  isNftGraphqlEnabled: boolean
-): GenieAsset => {
-  const assetUsdPrice = event.price
-    ? isNftGraphqlEnabled
-      ? formatEth(parseFloat(event.price) * ethPriceInUSD)
-      : formatEther(
-          BigNumber.from(event.price)
-            .mul(BigNumber.from(Math.trunc(ethPriceInUSD * 100)))
-            .div(100)
-        )
-    : '0'
+export const buildActivityAsset = (event: ActivityEvent, collectionName: string, ethPriceInUSD: number): GenieAsset => {
+  const assetUsdPrice = event.price ? formatEth(parseFloat(event.price) * ethPriceInUSD) : '0'
 
-  const weiPrice = isNftGraphqlEnabled ? (event.price ? parseEther(event.price) : '') : event.price
+  const weiPrice = event.price ? parseEther(event.price) : ''
 
   return {
     address: event.collectionAddress,

src/nft/utils/date.ts

-export const isValidDate = (date: number): boolean => {
-  const d = Date.parse(date.toString())
-  return isNaN(d) ? false : true
-}
-
-export const getTimeDifference = (eventTimestamp: string, isNftGraphqlEnabled: boolean) => {
-  const date = isNftGraphqlEnabled ? parseFloat(eventTimestamp) : new Date(eventTimestamp).getTime()
+export const getTimeDifference = (eventTimestamp: string) => {
+  const date = parseFloat(eventTimestamp)
   const diff = new Date().getTime() - date
 
   const days = Math.floor(diff / (1000 * 60 * 60 * 24))