ci(release): publish latest release

Author: hello-happy-puppy

RELEASE

@@ -1,6 +1,6 @@
 IPFS hash of the deployment:
-- CIDv0: `QmNxYFPwWseSvpgkBN5c3vDewpbsEdSuXgJF7epxQZezCU`
-- CIDv1: `bafybeiajggnkyo4mxc4va5sl4bj6vmex7jm7pd557roqdyc3rqiq2bebau`
+- CIDv0: `QmPjuGM1wsScvkB1LSBa22Fm61tgEQ8qRVoimnXCxkuNfG`
+- CIDv1: `bafybeiau2cap5oub3nn6jg6u4qdl7ftf3az7bof3b5mu26xiy2l326q4r4`
 
 The latest release is always mirrored at [app.uniswap.org](https://app.uniswap.org).
 
@@ -10,5 +10,5 @@ You can also access the Uniswap Interface from an IPFS gateway.
 Your Uniswap settings are never remembered across different URLs.
 
 IPFS gateways:
-- https://bafybeiajggnkyo4mxc4va5sl4bj6vmex7jm7pd557roqdyc3rqiq2bebau.ipfs.dweb.link/
-- [ipfs://QmNxYFPwWseSvpgkBN5c3vDewpbsEdSuXgJF7epxQZezCU/](ipfs://QmNxYFPwWseSvpgkBN5c3vDewpbsEdSuXgJF7epxQZezCU/)
+- https://bafybeiau2cap5oub3nn6jg6u4qdl7ftf3az7bof3b5mu26xiy2l326q4r4.ipfs.dweb.link/
+- [ipfs://QmPjuGM1wsScvkB1LSBa22Fm61tgEQ8qRVoimnXCxkuNfG/](ipfs://QmPjuGM1wsScvkB1LSBa22Fm61tgEQ8qRVoimnXCxkuNfG/)

VERSION

@@ -1 +1 @@
-web/5.151.1
+web/5.151.2

apps/web/src/components/FeatureFlagModal/flagGroups.tsx

@@ -53,6 +53,7 @@ export function buildFlagGroups(extras: {
         { flag: FeatureFlags.GasFeeOverrides, label: 'Enable Custom Gas Fee Overrides' },
         { flag: FeatureFlags.UniquoteEnabled, label: 'Enable Uniquote' },
         { flag: FeatureFlags.UnirouteEnabled, label: 'Enable Uniroute' },
+        { flag: FeatureFlags.RequestSwapSteps, label: 'Request SwapSteps in classic quotes' },
         { flag: FeatureFlags.UseUniversalRouterVersion211, label: 'Use Universal Router v2.1.1' },
         { flag: FeatureFlags.ViemProviderEnabled, label: 'Enable Viem Provider' },
         { flag: FeatureFlags.LimitsFees, label: 'Enable Limits fees' },

packages/api/src/clients/trading/api.json

@@ -6474,6 +6474,15 @@
         ],
         "description": "The protocol of the pool."
       },
+      "ProtocolItemsAmm": {
+        "type": "string",
+        "enum": [
+          "V2",
+          "V3",
+          "V4"
+        ],
+        "description": "The protocol of the pool."
+      },
       "encodedOrder": {
         "type": "string",
         "description": "An encoded copy of the order details which will be submitted to the filler network along with the signed permit."

packages/gating/src/flags.ts

@@ -43,6 +43,7 @@ export enum FeatureFlags {
   RwaUxSearch,
   RwaUxSearchTop24hSection,
   RandomizeQuotePolling,
+  RequestSwapSteps,
   Robinhood,
   SessionsPerformanceTrackingEnabled,
   SessionsServiceEnabled,
@@ -148,6 +149,7 @@ export const SHARED_FEATURE_FLAG_NAMES = new Map<FeatureFlags, string>([
   [FeatureFlags.RWAUXExplore, 'rwa_ux_explore'],
   [FeatureFlags.RWAUXExploreCarousel, 'rwa_ux_explore_carousel'],
   [FeatureFlags.RandomizeQuotePolling, 'randomize_quote_polling'],
+  [FeatureFlags.RequestSwapSteps, 'request_swap_steps'],
   [FeatureFlags.Robinhood, 'robinhood'],
   [FeatureFlags.RwaGeoblocked, 'rwa_geo_blocked'],
   [FeatureFlags.RwaUxSearch, 'rwa_ux_search'],

packages/uniswap/src/data/apiClients/tradingApi/TradingApiClient.test.ts

@@ -573,6 +573,19 @@ describe('getFeatureFlaggedHeaders', () => {
           break
       }
     })
+
+    it(`Endpoint: ${path} should/should not include RequestSwapSteps header when feature flag is enabled`, async () => {
+      mockGetFeatureFlag.mockImplementation((flag) => flag === FeatureFlags.RequestSwapSteps)
+      const headers = await getFeatureFlaggedHeaders(path)
+      switch (path) {
+        case TRADING_API_PATHS.quote:
+          expect(headers).toHaveProperty(TradingApiHeaders.RequestSwapSteps, 'true')
+          break
+        default:
+          expect(headers).not.toHaveProperty(TradingApiHeaders.RequestSwapSteps)
+          break
+      }
+    })
   })
 })
 

packages/uniswap/src/data/apiClients/tradingApi/TradingApiClient.ts

@@ -55,6 +55,7 @@ function addHeaderIfEnabled(params: { headers: Record<string, string>; key: stri
 
 export enum TradingApiHeaders {
   UniversalRouterVersion = 'x-universal-router-version',
+  RequestSwapSteps = 'x-universal-router-swapsteps',
   UniquoteEnabled = 'x-uniquote-enabled',
   ViemProviderEnabled = 'x-viem-provider-enabled',
   Erc20EthEnabled = 'x-erc20eth-enabled',
@@ -91,6 +92,7 @@ export const getFeatureFlaggedHeaders = async (
 
   const chainedActionsEnabled = getFeatureFlag(FeatureFlags.ChainedActions)
   const unirouteEnabled = getFeatureFlag(FeatureFlags.UnirouteEnabled)
+  const shouldRequestSwapSteps = getFeatureFlag(FeatureFlags.RequestSwapSteps)
   const ethAsErc20UniswapXEnabled = getExperimentValueFromLayer<
     typeof Layers.SwapPage,
     Experiments.EthAsErc20UniswapX,
@@ -108,6 +110,7 @@ export const getFeatureFlaggedHeaders = async (
       headers[TradingApiHeaders.UniroutePulumiEnabled] = 'true'
       addHeaderIfEnabled({ headers, key: TradingApiHeaders.Erc20EthEnabled, enabled: ethAsErc20UniswapXEnabled })
       addHeaderIfEnabled({ headers, key: TradingApiHeaders.ChainedActionsEnabled, enabled: chainedActionsEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.RequestSwapSteps, enabled: shouldRequestSwapSteps })
       addHeaderIfEnabled({
         headers,
         key: TradingApiHeaders.DisableUniswapInterfaceFees,

packages/uniswap/src/features/transactions/swap/components/RoutingInfo/RoutingHopInfo.tsx

@@ -21,7 +21,8 @@ import {
   BestRouteUniswapXTooltip,
 } from 'uniswap/src/features/transactions/swap/form/SwapFormScreen/SwapFormTooltips/BestRouteTooltip'
 import { Trade } from 'uniswap/src/features/transactions/swap/types/trade'
-import { isUniswapX } from 'uniswap/src/features/transactions/swap/utils/routing'
+import { isClassic, isUniswapX } from 'uniswap/src/features/transactions/swap/utils/routing'
+import { summarizeSwapSteps } from 'uniswap/src/utils/routingDiagram/routingProviders/uniswapRoutingProvider'
 import { useRoutingEntries, useRoutingProvider } from 'uniswap/src/utils/routingDiagram/routingRegistry'
 import { NumberType } from 'utilities/src/format/types'
 
@@ -44,6 +45,18 @@ export function RoutingHopInfo({
   const routingProvider = useRoutingProvider({ routing: trade.routing })
   const isUniswapXTrade = isUniswapX(trade)
 
+  const swapStepsSummary = useMemo(() => {
+    const steps = isClassic(trade) ? trade.quote.quote.swapSteps : undefined
+    if (!steps?.length) {
+      return undefined
+    }
+    const { pools, versions } = summarizeSwapSteps(steps)
+    if (pools <= 0 || versions.length === 0) {
+      return undefined
+    }
+    return { pools, versions }
+  }, [trade])
+
   const caption = useMemo(() => {
     const textVariant = isWebPlatform ? 'body4' : 'body2'
     const textAlign = isWebPlatform ? 'left' : 'center'
@@ -65,6 +78,17 @@ export function RoutingHopInfo({
       )
     }
 
+    if (swapStepsSummary) {
+      return (
+        <Text variant={textVariant} textAlign={textAlign} color="$neutral2">
+          {t('swap.routing.poolsAndVersions', {
+            count: swapStepsSummary.pools,
+            versions: swapStepsSummary.versions.join(', '),
+          })}
+        </Text>
+      )
+    }
+
     if (routes) {
       const descriptionText =
         routingProvider?.getDescription?.(t) ??
@@ -86,7 +110,7 @@ export function RoutingHopInfo({
       )
     }
     return null
-  }, [t, trade, routes, gasFeeFormatted, routingProvider, isUniswapXTrade])
+  }, [t, trade, routes, gasFeeFormatted, routingProvider, isUniswapXTrade, swapStepsSummary])
 
   const modalTitle =
     !isUniswapXTrade && routingProvider?.name
@@ -96,15 +120,15 @@ export function RoutingHopInfo({
   const ModalIcon = routingProvider?.icon ?? OrderRouting
   const modalIconColor = routingProvider?.iconColor ?? '$neutral1'
 
-  const mobileLearnMore =
-    isMobileApp && !isUniswapXTrade ? (
-      <LearnMoreLink textVariant="buttonLabel3" url={UniswapHelpUrls.articles.routingSettings} />
+  const learnMoreLink =
+    !isUniswapXTrade && (isMobileApp || swapStepsSummary || !routes || routes.length === 0) ? (
+      <LearnMoreLink textVariant="buttonLabel4" textColor="$neutral1" url={UniswapHelpUrls.articles.routingSettings} />
     ) : undefined
 
   return (
     <Flex row alignItems="center" justifyContent="space-between">
       <WarningInfo
-        infoButton={mobileLearnMore}
+        infoButton={learnMoreLink}
         modalProps={{
           modalName: ModalName.SwapReview,
           captionComponent: caption,
@@ -118,6 +142,8 @@ export function RoutingHopInfo({
         tooltipProps={{
           text: isUniswapXTrade ? (
             <BestRouteUniswapXTooltip />
+          ) : swapStepsSummary ? (
+            caption
           ) : routes && routes.length > 0 ? (
             <BestRouteTooltip />
           ) : (

packages/uniswap/src/features/transactions/swap/utils/trade.test.ts

@@ -1,3 +1,4 @@
+import { Protocol } from '@uniswap/router-sdk'
 import { TradeType } from '@uniswap/sdk-core'
 import { type ClassicQuoteResponse, TradingApi } from '@universe/api'
 import { UNI, WBTC } from 'uniswap/src/constants/tokens'
@@ -8,7 +9,7 @@ import {
   type BridgeTrade,
   type ClassicTrade,
 } from 'uniswap/src/features/transactions/swap/types/trade'
-import { requireAcceptNewTrade } from 'uniswap/src/features/transactions/swap/utils/trade'
+import { getProtocolVersionFromTrade, requireAcceptNewTrade } from 'uniswap/src/features/transactions/swap/utils/trade'
 
 const INPUT_TOKEN = UNI[UniverseChainId.Mainnet]
 
@@ -142,3 +143,113 @@ describe(requireAcceptNewTrade, () => {
     })
   })
 })
+
+const ADDRESS_ZERO = '0x0000000000000000000000000000000000000000'
+
+function v2SwapStep(): TradingApi.SwapStep {
+  return {
+    type: 'V2_SWAP_EXACT_IN' as TradingApi.V2SwapExactInStep['type'],
+    recipient: ADDRESS_ZERO,
+    amountIn: '0',
+    amountOutMin: '0',
+    path: [ADDRESS_ZERO, ADDRESS_ZERO],
+  } as TradingApi.SwapStep
+}
+
+function v3SwapStep(): TradingApi.SwapStep {
+  return {
+    type: 'V3_SWAP_EXACT_IN' as TradingApi.V3SwapExactInStep['type'],
+    recipient: ADDRESS_ZERO,
+    amountIn: '0',
+    amountOutMin: '0',
+    path: '0x',
+  } as TradingApi.SwapStep
+}
+
+function v4SwapStep(): TradingApi.SwapStep {
+  return {
+    type: 'V4_SWAP' as TradingApi.V4SwapStep['type'],
+    v4Actions: [
+      {
+        action: 'SWAP_EXACT_IN_SINGLE' as TradingApi.V4SwapExactInSingle['action'],
+        poolKey: {} as TradingApi.SwapPoolKey,
+        zeroForOne: true,
+        amountIn: '0',
+        amountOutMinimum: '0',
+        hookData: '0x',
+      } as TradingApi.V4Action,
+    ],
+  } as TradingApi.SwapStep
+}
+
+const wrapEthStep = {
+  type: 'WRAP_ETH' as TradingApi.WrapEthStep['type'],
+  recipient: ADDRESS_ZERO,
+  amount: '0',
+} as TradingApi.SwapStep
+
+// Builds a classic trade carrying the given `swapSteps`, with a single V3 quote-route hop so the
+// route-based fallback resolves to V3 whenever `swapSteps` are absent or contribute no version.
+const createClassicTradeWithSwapSteps = (swapSteps?: TradingApi.SwapStep[]): ClassicTrade => {
+  const trade = createClassicTradeFromQuote({
+    quote: {
+      requestId: '123',
+      routing: TradingApi.Routing.CLASSIC,
+      permitData: null,
+      quote: {
+        input: { amount: '100', maximumAmount: '100', token: INPUT_TOKEN.address },
+        output: { amount: '100', minimumAmount: '100', token: WBTC.address, recipient: '0xrecipient' },
+        swapper: '0xswapper',
+        route: [[{ type: 'v3-pool' }]],
+        swapSteps,
+      },
+    } as ClassicQuoteResponse,
+    currencyIn: INPUT_TOKEN,
+    currencyOut: WBTC,
+    tradeType: TradeType.EXACT_INPUT,
+    deadline: Date.now() + 60 * 30 * 1000,
+  })
+
+  if (!trade) {
+    throw new Error('Expected test classic trade to be created')
+  }
+
+  return trade
+}
+
+describe(getProtocolVersionFromTrade, () => {
+  it('returns undefined for non-classic trades', () => {
+    expect(getProtocolVersionFromTrade(createBridgeTestTrade('1000', '990'))).toBeUndefined()
+  })
+
+  describe('with swapSteps (new routing field)', () => {
+    it('returns V2 when swapSteps contain only V2 swaps', () => {
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps([v2SwapStep()]))).toBe(Protocol.V2)
+    })
+
+    it('returns V3 when swapSteps contain only V3 swaps', () => {
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps([v3SwapStep()]))).toBe(Protocol.V3)
+    })
+
+    it('returns V4 when swapSteps contain only V4 swaps', () => {
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps([v4SwapStep()]))).toBe(Protocol.V4)
+    })
+
+    it('returns MIXED when swapSteps span multiple protocol versions', () => {
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps([v2SwapStep(), v3SwapStep()]))).toBe(
+        Protocol.MIXED,
+      )
+    })
+
+    it('falls back to route inference when swapSteps contribute no versions (wrap/unwrap only)', () => {
+      // wrap/unwrap steps yield no protocol versions, so the V3 SDK route resolves the protocol.
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps([wrapEthStep]))).toBe(Protocol.V3)
+    })
+  })
+
+  describe('without swapSteps (route fallback)', () => {
+    it('infers the protocol from the SDK routes', () => {
+      expect(getProtocolVersionFromTrade(createClassicTradeWithSwapSteps(undefined))).toBe(Protocol.V3)
+    })
+  })
+})

packages/uniswap/src/features/transactions/swap/utils/trade.ts

@@ -209,15 +209,76 @@ export function getRateToDisplay({
   return showInverseRate ? rate : inverseRate
 }
 
+/**
+ * Derives the protocol version-set from a quote's `swapSteps` and maps it to a single `Protocol`.
+ * A single version maps to its matching protocol; multiple versions are reported as MIXED. Returns
+ * undefined when no swap versions are present (e.g. pure wrap/unwrap steps), letting the caller fall
+ * back to route-based inference.
+ *
+ * Reads `swapSteps` directly rather than reusing `summarizeSwapSteps` (which also computes pool
+ * counts and lives alongside the UI/routing-diagram layer) to keep this data util free of that
+ * dependency — importing it introduces a circular dependency through `swap/utils/routing`.
+ */
+function getProtocolFromSwapSteps(steps: readonly TradingApi.SwapStep[]): Protocol | undefined {
+  const versions = new Set<Protocol.V2 | Protocol.V3 | Protocol.V4>()
+
+  for (const step of steps) {
+    switch (step.type) {
+      case 'V2_SWAP_EXACT_IN':
+      case 'V2_SWAP_EXACT_OUT':
+        versions.add(Protocol.V2)
+        break
+      case 'V3_SWAP_EXACT_IN':
+      case 'V3_SWAP_EXACT_OUT':
+        versions.add(Protocol.V3)
+        break
+      case 'V4_SWAP':
+        for (const action of step.v4Actions) {
+          switch (action.action) {
+            case 'SWAP_EXACT_IN':
+            case 'SWAP_EXACT_OUT':
+            case 'SWAP_EXACT_IN_SINGLE':
+            case 'SWAP_EXACT_OUT_SINGLE':
+              versions.add(Protocol.V4)
+              break
+            // SETTLE / TAKE action variants contribute no protocol version.
+          }
+        }
+        break
+      // WRAP_ETH / UNWRAP_WETH steps contribute no protocol version.
+    }
+  }
+
+  if (versions.size === 0) {
+    return undefined
+  }
+  if (versions.size > 1) {
+    return Protocol.MIXED
+  }
+  const [version] = versions
+  return version
+}
+
 export function getProtocolVersionFromTrade(trade: Trade): Protocol | undefined {
   if (!isClassic(trade)) {
     return undefined
   }
 
+  // Prefer the new `swapSteps` routing field when present: it is the canonical Universal Router
+  // step sequence and correctly distinguishes V4 (which the route-based fallback below cannot).
+  // Only populated when the GuideStar quoter wins the hybrid quote race.
+  const { swapSteps } = trade.quote.quote
+  if (swapSteps?.length) {
+    const protocol = getProtocolFromSwapSteps(swapSteps)
+    if (protocol) {
+      return protocol
+    }
+  }
+
+  // Fallback for quotes without `swapSteps`: infer from the classic quote route hop types.
+  // Note: route hops cannot express V4, so V4 is only detectable via `swapSteps` above.
   const route = trade.quote.quote.route ?? []
   const protocols = new Set(route.flatMap((hops) => hops.map((hop) => hop.type)))
-
-  // TODO(SWAP-2724): Update to properly extract from newer routing response types
   if (protocols.size === 0) {
     return undefined
   }