ci(release): publish latest release

Author: hello-happy-puppy

RELEASE

@@ -1,6 +1,6 @@
 IPFS hash of the deployment:
-- CIDv0: `QmcSvSrURT9nXdKL4981wSjoVEtAmvpA9vmwXKY4rgfvqS`
-- CIDv1: `bafybeigrt3su45yk54xor7ogqlu3d7ck4rjpknuq6kfnfiyy65at5coevu`
+- CIDv0: `QmfUHqPyDETu7D7raa1XynT5U7EXeSFEoSrJLJAMFbW3WX`
+- CIDv1: `bafybeih6ro4lrfcs7ret2n7k5xmd2fld7b5xxvl732ckqim2ny2r6hby4a`
 
 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://bafybeigrt3su45yk54xor7ogqlu3d7ck4rjpknuq6kfnfiyy65at5coevu.ipfs.dweb.link/
-- [ipfs://QmcSvSrURT9nXdKL4981wSjoVEtAmvpA9vmwXKY4rgfvqS/](ipfs://QmcSvSrURT9nXdKL4981wSjoVEtAmvpA9vmwXKY4rgfvqS/)
+- https://bafybeih6ro4lrfcs7ret2n7k5xmd2fld7b5xxvl732ckqim2ny2r6hby4a.ipfs.dweb.link/
+- [ipfs://QmfUHqPyDETu7D7raa1XynT5U7EXeSFEoSrJLJAMFbW3WX/](ipfs://QmfUHqPyDETu7D7raa1XynT5U7EXeSFEoSrJLJAMFbW3WX/)

VERSION

@@ -1 +1 @@
-web/5.148.2
+web/5.148.3

apps/web/src/connection/wagmiConfig.ts

@@ -1,22 +1,19 @@
 import { getWagmiConnectorV2 } from '@binance/w3w-wagmi-connector-v2'
-import { getEntryGatewayUrl } from '@universe/api'
 import {
   createObservableTransport,
-  createRpcConfigResolver,
-  createUniRpcConfigResolver,
+  createUniRpcRoutedTransport,
   createUniRpcTransportFactory,
   getRpcObserver,
 } from '@universe/chains'
 import { isE2eTestEnv, isTestEnv } from '@universe/environment'
-import { FeatureFlags, getFeatureFlag } from '@universe/gating'
 import { UNISWAP_LOGO } from 'ui/src/assets'
 import { UNISWAP_WEB_URL } from 'uniswap/src/constants/urls'
 import { CONNECTION_PROVIDER_IDS } from 'uniswap/src/constants/web3'
 import type { getChainInfo } from 'uniswap/src/features/chains/chainInfo'
 import { ORDERED_EVM_CHAINS } from 'uniswap/src/features/chains/chainInfo'
 import { RPCType } from 'uniswap/src/features/chains/types'
 import { isTestnetChain } from 'uniswap/src/features/chains/utils'
-import { selectRpcUrl } from 'uniswap/src/features/providers/rpcUrlSelector'
+import { defaultResolveRpcConfig } from 'uniswap/src/features/providers/resolveRpcConfig'
 import { logger } from 'utilities/src/logger/logger'
 import { getNonEmptyArrayOrThrow } from 'utilities/src/primitives/array'
 import type { Chain } from 'viem'
@@ -111,16 +108,9 @@ function createWagmiConnectors(params: {
     : baseConnectors
 }
 
-const webResolveRpcConfig = createRpcConfigResolver({
-  resolveUniRpcConfig: createUniRpcConfigResolver({
-    getFeatureFlag: () => getFeatureFlag(FeatureFlags.UniRpcEnabled),
-    getEntryGatewayUrl,
-    requestSource: 'uniswap-web',
-    credentials: 'include',
-  }),
-  selectLegacyRpcUrl: selectRpcUrl,
-})
-
+// Cookie-session UniRPC transport factory (web's injected session strategy).
+// The gating decision lives in the shared `defaultResolveRpcConfig` resolver;
+// this only constructs the UniRPC transport once that resolver says to use it.
 const buildWebUniRpcTransport = createUniRpcTransportFactory({
   session: { type: 'cookies' },
 })
@@ -138,40 +128,42 @@ function createWagmiConfig(params: {
     chains: getNonEmptyArrayOrThrow(ORDERED_EVM_CHAINS),
     connectors,
     client({ chain }) {
-      const rpcConfig = webResolveRpcConfig({ chainId: chain.id, rpcType: RPCType.Public })
-      // Branch on the explicit `isUniRpc` flag — header presence used to be
-      // the implicit signal, which would have routed any legacy provider with
-      // static headers through the UniRPC transport by accident.
-      if (rpcConfig?.isUniRpc) {
-        return createClient({
-          chain,
-          batch: { multicall: true },
-          pollingInterval: 12_000,
-          transport: createObservableTransport({
-            baseTransportFactory: buildWebUniRpcTransport({
-              config: { rpcUrl: rpcConfig.rpcUrl, headers: rpcConfig.headers ?? {} },
-            }),
-            observer: getRpcObserver(),
-            meta: { chainId: chain.id, url: rpcConfig.rpcUrl },
-          }),
-        })
-      }
-
+      // wagmi builds this client once per chain and caches it for the session,
+      // so the UniRPC-vs-legacy choice must NOT be snapshotted here: on app
+      // start the gate behind `isUniRpc` is usually still unresolved (Statsig
+      // inits async; a cold load has no cached value), and a snapshot would pin
+      // the chain to the legacy Infura/QuickNode providers for the whole
+      // session even after the gate turns on. createUniRpcRoutedTransport
+      // re-reads the shared resolver per request, so the cached client
+      // self-heals onto UniRPC the moment the gate resolves — same guarantee
+      // ViemClientManager gets by re-resolving per `getViemClient` call.
       return createClient({
         chain,
         batch: { multicall: true },
         pollingInterval: 12_000,
-        transport: fallback(
-          orderedTransportUrls(chain).map((url) =>
+        transport: createUniRpcRoutedTransport({
+          resolveRpcConfig: () => defaultResolveRpcConfig({ chainId: chain.id, rpcType: RPCType.Public }),
+          buildUniRpcTransport: (rpcConfig) =>
             createObservableTransport({
-              baseTransportFactory: http(url, {
-                onFetchResponse: (response) => onFetchResponse(response, chain, url),
+              baseTransportFactory: buildWebUniRpcTransport({
+                config: { rpcUrl: rpcConfig.rpcUrl, headers: rpcConfig.headers ?? {} },
               }),
               observer: getRpcObserver(),
-              meta: { chainId: chain.id, url },
+              meta: { chainId: chain.id, url: rpcConfig.rpcUrl },
             }),
-          ),
-        ),
+          buildLegacyTransport: () =>
+            fallback(
+              orderedTransportUrls(chain).map((url) =>
+                createObservableTransport({
+                  baseTransportFactory: http(url, {
+                    onFetchResponse: (response) => onFetchResponse(response, chain, url),
+                  }),
+                  observer: getRpcObserver(),
+                  meta: { chainId: chain.id, url },
+                }),
+              ),
+            ),
+        }),
       })
     },
   })

apps/web/src/constants/providers.ts

@@ -21,10 +21,20 @@ const createProvider = createEthersProviderFactory({ resolveRpcConfig: defaultRe
  * `<StatsigProviderWrapper>` mounts and triggers `StatsigClient.instance(key)`
  * to create a no-options client; the React provider's `useClientAsyncInit`
  * then reuses that broken instance and silently drops `networkConfig.api`,
- * `overrideAdapter`, and `environment.tier`. The cache below preserves the
- * "captured at first call, not rebuilt mid-session" semantics.
+ * `overrideAdapter`, and `environment.tier`. If that first call still beats
+ * Statsig init the chain resolves to legacy — so the cache rebuilds once on the
+ * legacy→UniRPC transition (see `getRpcProvider`) rather than pinning the chain
+ * to legacy for the whole session. ViemClientManager solves the same staleness
+ * by re-resolving per call; ethers providers are stateful (polling/listeners),
+ * so we rebuild-on-transition instead.
  */
-function buildAppProvider(chainId: EVMUniverseChainId): ethersProviders.JsonRpcProvider {
+interface CachedProvider {
+  provider: ethersProviders.JsonRpcProvider
+  /** Whether `provider` is the UniRPC provider (vs the legacy multi-URL fallback). */
+  isUniRpc: boolean
+}
+
+function buildAppProvider(chainId: EVMUniverseChainId): CachedProvider {
   // Prefer UniRPC routing; fall through to the legacy multi-URL provider on
   // either branch — UniRPC inactive OR factory construction returned null
   // (createEthersProviderFactory swallows internal exceptions and returns
@@ -34,32 +44,45 @@ function buildAppProvider(chainId: EVMUniverseChainId): ethersProviders.JsonRpcP
   if (rpcConfig?.isUniRpc) {
     const provider = createProvider({ chainId, rpcType: RPCType.Public })
     if (provider) {
-      return provider
+      return { provider, isUniRpc: true }
     }
   }
 
   const info = getChainInfo(chainId)
-  return new AppJsonRpcProvider(
-    info.rpcUrls.interface.http.map(
-      (url) => new ConfiguredJsonRpcProvider({ url, networkish: { chainId, name: info.interfaceName } }),
+  return {
+    provider: new AppJsonRpcProvider(
+      info.rpcUrls.interface.http.map(
+        (url) => new ConfiguredJsonRpcProvider({ url, networkish: { chainId, name: info.interfaceName } }),
+      ),
     ),
-  )
+    isUniRpc: false,
+  }
 }
 
-const providerCache = new Map<EVMUniverseChainId, ethersProviders.JsonRpcProvider>()
+const providerCache = new Map<EVMUniverseChainId, CachedProvider>()
 
 /**
- * Returns the singleton interface RPC provider for `chainId`. Constructs on
- * first call, then caches. Use this everywhere instead of building providers
- * ad-hoc — it's the only entry point that respects the UniRPC gate.
+ * Returns the singleton interface RPC provider for `chainId`. Use this
+ * everywhere instead of building providers ad-hoc — it's the only entry point
+ * that respects the UniRPC gate.
+ *
+ * Constructs on first call, then caches. The one exception: if the cached
+ * provider is the legacy fallback (built before the UniRPC gate resolved) and
+ * the gate has since turned on, it rebuilds once onto UniRPC and sticks — so a
+ * first call that beat Statsig init doesn't pin the chain to legacy for the
+ * session.
  */
 export function getRpcProvider(chainId: EVMUniverseChainId): ethersProviders.JsonRpcProvider {
-  let provider = providerCache.get(chainId)
-  if (!provider) {
-    provider = buildAppProvider(chainId)
-    providerCache.set(chainId, provider)
+  const cached = providerCache.get(chainId)
+  if (cached) {
+    // Already on UniRPC, or still legacy and the gate is still off → reuse.
+    if (cached.isUniRpc || !defaultResolveRpcConfig({ chainId, rpcType: RPCType.Public })?.isUniRpc) {
+      return cached.provider
+    }
   }
-  return provider
+  const built = buildAppProvider(chainId)
+  providerCache.set(chainId, built)
+  return built.provider
 }
 
 export function getInterfaceProvider(

packages/chains/src/index.ts

@@ -53,6 +53,7 @@ export { zeroAddress } from './createZeroAddress'
 // Observability
 export { InstrumentedJsonRpcProvider } from './rpc/observability/InstrumentedJsonRpcProvider'
 export { createObservableTransport } from './rpc/observability/createObservableTransport'
+export { createUniRpcRoutedTransport } from './rpc/createUniRpcRoutedTransport'
 export { extractProviderName } from './rpc/observability/extractProviderName'
 export {
   noopObserver,

packages/chains/src/rpc/__tests__/observabilityInvariant.test.ts

@@ -270,3 +270,77 @@ describe('observability invariant — error message cardinality is bounded', ()
     expect(errorCtx.error.message).not.toContain('id":99')
   })
 })
+
+// ─────────────────────────────────────────────────────────────────────────
+// Status + JSON-RPC code must reach the observer as structured fields on every
+// path — that's what makes "401 bot-block vs 5xx outage vs JSON-RPC error"
+// answerable in Datadog instead of buried in a free-text message.
+// ─────────────────────────────────────────────────────────────────────────
+describe('observability invariant — structured error fields (httpStatus + rpcErrorCode)', () => {
+  test('viem: non-OK HTTP surfaces ctx.httpStatus (401 — not retried by viem)', async () => {
+    ;(globalThis.fetch as Mock).mockReset()
+    ;(globalThis.fetch as Mock).mockResolvedValue(
+      new Response(JSON.stringify({ message: 'unauthorized' }), {
+        status: 401,
+        headers: { 'content-type': 'application/json' },
+      }),
+    )
+
+    const factory = buildViemFactory({
+      rpcUrl: 'https://gateway/rpc/1',
+      isUniRpc: true,
+      headers: {},
+      credentials: 'include',
+    })
+    const client = factory({ chainId: CHAIN_ID, rpcType: RPCType.Public })!
+
+    await expect(client.getBlockNumber()).rejects.toThrow()
+
+    const ctxs = observer.onError.mock.calls.map((call) => call[0] as { httpStatus?: number })
+    expect(ctxs.some((c) => c.httpStatus === 401)).toBe(true)
+  })
+
+  test('ethers Web3Provider: non-OK HTTP surfaces ctx.httpStatus', async () => {
+    ;(globalThis.fetch as Mock).mockResolvedValueOnce(
+      new Response(JSON.stringify({ message: 'Forbidden' }), {
+        status: 403,
+        headers: { 'content-type': 'application/json' },
+      }),
+    )
+
+    const factory = buildEthersFactory({
+      rpcUrl: 'https://gateway/rpc/1',
+      isUniRpc: true,
+      headers: {},
+      getRequestHeaders: async () => ({}),
+    })
+    const provider = factory({ chainId: CHAIN_ID, rpcType: RPCType.Public })!
+
+    await expect(provider.send('eth_blockNumber', [])).rejects.toThrow()
+
+    const ctx = observer.onError.mock.calls[0]?.[0] as { httpStatus?: number }
+    expect(ctx.httpStatus).toBe(403)
+  })
+
+  test('ethers Web3Provider: JSON-RPC error surfaces ctx.rpcErrorCode', async () => {
+    ;(globalThis.fetch as Mock).mockResolvedValueOnce(
+      new Response(JSON.stringify({ jsonrpc: '2.0', id: 1, error: { code: -32000, message: 'execution reverted' } }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    )
+
+    const factory = buildEthersFactory({
+      rpcUrl: 'https://gateway/rpc/1',
+      isUniRpc: true,
+      headers: {},
+      getRequestHeaders: async () => ({}),
+    })
+    const provider = factory({ chainId: CHAIN_ID, rpcType: RPCType.Public })!
+
+    await expect(provider.send('eth_blockNumber', [])).rejects.toThrow('execution reverted')
+
+    const ctx = observer.onError.mock.calls[0]?.[0] as { rpcErrorCode?: number }
+    expect(ctx.rpcErrorCode).toBe(-32000)
+  })
+})

packages/chains/src/rpc/createEthersProvider.ts

@@ -2,6 +2,7 @@ import { providers as ethersProviders } from 'ethers/lib/ethers'
 import { logger } from 'utilities/src/logger/logger'
 import { SignerInfo } from './FlashbotsCommon'
 import { FlashbotsRpcProvider } from './FlashbotsRpcProvider'
+import { extractRpcErrorMeta } from './observability/extractRpcErrorMeta'
 import { InstrumentedJsonRpcProvider } from './observability/InstrumentedJsonRpcProvider'
 import { normalizeRpcError } from './observability/normalizeRpcError'
 import { generateRequestId, getRpcObserver, type RpcObserver } from './observability/rpcObserver'
@@ -70,7 +71,15 @@ function createJsonRpcFetchFunc(config: {
       })
 
       if (!response.ok) {
-        throw new Error(`RPC request failed: ${response.status} ${response.statusText}`)
+        // Carry the status as a structured field, not just in the message:
+        // on React Native `response.statusText` is empty, so the message alone
+        // ("RPC request failed: 403 ") isn't reliably parseable. extractRpcErrorMeta
+        // reads `.status` directly (with the message as a fallback).
+        const httpError = new Error(`RPC request failed: ${response.status} ${response.statusText}`.trim()) as Error & {
+          status?: number
+        }
+        httpError.status = response.status
+        throw httpError
       }
 
       const json = (await response.json()) as {
@@ -87,8 +96,15 @@ function createJsonRpcFetchFunc(config: {
       return json.result
     } catch (error) {
       // Normalize before handing to the observer so the rate limiter's
-      // bucket-by-message strategy stays effective. Throw the original.
-      config.observer.onError({ ...ctx, durationMs: performance.now() - start, error: normalizeRpcError(error) })
+      // bucket-by-message strategy stays effective; extract status/code from the
+      // raw error (the non-ok branch attaches `.status`, the JSON-RPC branch
+      // attaches `.code`). Throw the original.
+      config.observer.onError({
+        ...ctx,
+        durationMs: performance.now() - start,
+        error: normalizeRpcError(error),
+        ...extractRpcErrorMeta(error),
+      })
       throw error
     }
   }