diff --git a/.env.development b/.env.development
index 7ee5b06ee99..218aad21ac8 100644
--- a/.env.development
+++ b/.env.development
@@ -99,3 +99,4 @@ VITE_FEATURE_KATANA=true
 VITE_FEATURE_YIELD_XYZ=true
 VITE_FEATURE_YIELDS_PAGE=true
 VITE_FEATURE_EARN_TAB=true
+VITE_FEATURE_YIELD_MULTI_ACCOUNT=true
diff --git a/src/assets/translations/en/main.json b/src/assets/translations/en/main.json
index a926e3a4742..7fb7c526a96 100644
--- a/src/assets/translations/en/main.json
+++ b/src/assets/translations/en/main.json
@@ -180,6 +180,7 @@
     "featureDisabled": "This feature is temporarily disabled.",
     "yes": "Yes",
     "activeAccount": "Active Account",
+    "selectAccount": "Select Account",
     "update": "Update",
     "apy": "APY",
     "installed": "Installed",
@@ -2769,6 +2770,7 @@
     "recommendedForYou": "Recommended for you",
     "earn": "Earn",
     "myBalance": "My Balance",
+    "balanceByAccount": "Balance by Account",
     "providers": "Providers",
     "successEnter": "You successfully entered %{amount} %{symbol}",
     "successExit": "You successfully exited %{amount} %{symbol}",
diff --git a/src/components/EarnDashboard/components/PositionDetails/PositionDetails.tsx b/src/components/EarnDashboard/components/PositionDetails/PositionDetails.tsx
index b2e812a1f91..3c4400a0582 100644
--- a/src/components/EarnDashboard/components/PositionDetails/PositionDetails.tsx
+++ b/src/components/EarnDashboard/components/PositionDetails/PositionDetails.tsx
@@ -2,16 +2,19 @@ import { Flex, useMediaQuery } from '@chakra-ui/react'
 
 import { StakingPositionsByProvider } from './StakingPositionsByProvider'
 
+import type { YieldOpportunityDisplay } from '@/components/StakingVaults/hooks/useYieldAsOpportunities'
 import type { AggregatedOpportunitiesByAssetIdReturn } from '@/state/slices/opportunitiesSlice/types'
 import { breakpoints } from '@/theme/theme'
 
 type PositionDetailsProps = AggregatedOpportunitiesByAssetIdReturn & {
   forceCompactView?: boolean
+  yieldOpportunities?: YieldOpportunityDisplay[]
 }
 
 export const PositionDetails: React.FC<PositionDetailsProps> = ({
   opportunities,
   forceCompactView,
+  yieldOpportunities,
 }) => {
   const [isLargerThanMd] = useMediaQuery(`(min-width: ${breakpoints['md']})`, { ssr: false })
   const isCompactView = !isLargerThanMd || forceCompactView
@@ -20,9 +23,17 @@ export const PositionDetails: React.FC<PositionDetailsProps> = ({
   const flexPy = isCompactView ? 2 : 8
   const flexGap = isCompactView ? 2 : 6
 
+  const hasPositions = opportunities.staking.length > 0 || (yieldOpportunities?.length ?? 0) > 0
+
+  if (!hasPositions) return null
+
   return (
     <Flex px={flexPx} py={flexPy} flexDir='column' gap={flexGap}>
-      <StakingPositionsByProvider ids={opportunities.staking} forceCompactView={forceCompactView} />
+      <StakingPositionsByProvider
+        ids={opportunities.staking}
+        forceCompactView={forceCompactView}
+        yieldOpportunities={yieldOpportunities}
+      />
     </Flex>
   )
 }
diff --git a/src/components/EarnDashboard/components/PositionDetails/StakingPositionsByProvider.tsx b/src/components/EarnDashboard/components/PositionDetails/StakingPositionsByProvider.tsx
index 5e412568f22..2845224ce49 100644
--- a/src/components/EarnDashboard/components/PositionDetails/StakingPositionsByProvider.tsx
+++ b/src/components/EarnDashboard/components/PositionDetails/StakingPositionsByProvider.tsx
@@ -12,6 +12,7 @@ import type { Column, Row } from 'react-table'
 import { Amount } from '@/components/Amount/Amount'
 import { LazyLoadAvatar } from '@/components/LazyLoadAvatar'
 import { ReactTable } from '@/components/ReactTable/ReactTable'
+import type { YieldOpportunityDisplay } from '@/components/StakingVaults/hooks/useYieldAsOpportunities'
 import { RawText } from '@/components/Text'
 import { WalletActions } from '@/context/WalletProvider/actions'
 import { DefiAction } from '@/features/defi/contexts/DefiManagerProvider/DefiCommon'
@@ -38,14 +39,20 @@ import {
 import { useAppSelector } from '@/state/store'
 import { breakpoints } from '@/theme/theme'
 
+type UnifiedPosition = StakingEarnOpportunityType & {
+  isYield?: boolean
+  yieldId?: string
+}
+
 type StakingPositionsByProviderProps = {
   ids: OpportunityId[]
   forceCompactView?: boolean
+  yieldOpportunities?: YieldOpportunityDisplay[]
 }
 
 const arrowForwardIcon = <ArrowForwardIcon />
 
-export type RowProps = Row<StakingEarnOpportunityType>
+export type RowProps = Row<UnifiedPosition>
 
 type CalculateRewardFiatAmountArgs = {
   assets: Partial<Record<AssetId, Asset>>
@@ -91,6 +98,7 @@ const calculateRewardFiatAmount: CalculateRewardFiatAmount = ({
 export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProps> = ({
   ids,
   forceCompactView,
+  yieldOpportunities,
 }) => {
   const location = useLocation()
   const { navigate } = useBrowserRouter()
@@ -110,7 +118,25 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
     selectAggregatedEarnUserStakingOpportunitiesIncludeEmpty,
   )
   const isRfoxFoxEcosystemPageEnabled = useFeatureFlag('RfoxFoxEcosystemPage')
-  const filteredDown = useMemo(
+
+  const yieldPositionsAsUnified = useMemo<UnifiedPosition[]>(() => {
+    if (!yieldOpportunities?.length) return []
+    return yieldOpportunities.map(y => ({
+      id: y.yieldId,
+      assetId: y.yieldId,
+      underlyingAssetId: y.yieldId,
+      provider: y.providerName,
+      apy: y.apy,
+      fiatAmount: y.fiatAmount,
+      icon: y.providerIcon,
+      isYield: true,
+      yieldId: y.yieldId,
+      isReadOnly: true,
+      opportunityName: undefined,
+    })) as unknown as UnifiedPosition[]
+  }, [yieldOpportunities])
+
+  const legacyFiltered = useMemo(
     () =>
       stakingOpportunities.filter(
         e => ids.includes(e.assetId as OpportunityId) || ids.includes(e.id as OpportunityId),
@@ -118,16 +144,43 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
     [ids, stakingOpportunities],
   )
 
+  const filteredDown = useMemo<UnifiedPosition[]>(() => {
+    const result = [...yieldPositionsAsUnified, ...legacyFiltered]
+    console.debug(
+      '[StakingPositionsByProvider] filteredDown:',
+      JSON.stringify(
+        result.map(r => ({
+          id: r.id,
+          provider: r.provider,
+          isYield: (r as UnifiedPosition).isYield,
+          fiatAmount: r.fiatAmount,
+        })),
+        null,
+        2,
+      ),
+    )
+    return result
+  }, [yieldPositionsAsUnified, legacyFiltered])
+
   const handleClick = useCallback(
     (row: RowProps, action: DefiAction) => {
       const { original: opportunity } = row
 
+      if (opportunity.isYield && opportunity.yieldId) {
+        if (walletDrawer.isOpen) {
+          walletDrawer.close()
+        }
+        navigate(`/yields/${opportunity.yieldId}`)
+        return
+      }
+
       if (opportunity.isReadOnly) {
         const url = getMetadataForProvider(opportunity.provider)?.url
         url && window.open(url, '_blank')
         return
       }
 
+      const legacyOpp = opportunity as StakingEarnOpportunityType
       const {
         type,
         provider,
@@ -136,7 +189,7 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
         rewardAddress,
         assetId,
         highestBalanceAccountAddress,
-      } = opportunity
+      } = legacyOpp
       const { assetReference, assetNamespace } = fromAssetId(assetId)
 
       if (provider === DefiProvider.rFOX) {
@@ -170,7 +223,7 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
       trackOpportunityEvent(
         MixPanelEvent.ClickOpportunity,
         {
-          opportunity,
+          opportunity: legacyOpp,
           element: 'Table Row',
         },
         assets,
@@ -211,28 +264,25 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
       dispatch,
     ],
   )
-  const columns: Column<StakingEarnOpportunityType>[] = useMemo(
+  const columns: Column<UnifiedPosition>[] = useMemo(
     () => [
       {
         Header: translate('defi.stakingPosition'),
         accessor: 'assetId',
         Cell: ({ row }: { row: RowProps }) => {
-          // Version or Provider
-          // Opportunity Name
+          const opp = row.original as StakingEarnOpportunityType & UnifiedPosition
           const subText = []
-          if (row.original.version) subText.push(row.original.provider)
-          if (row.original.opportunityName) subText.push(row.original.opportunityName)
-          const isRunePool = row.original.assetId === thorchainAssetId
-          const providerName = isRunePool
-            ? 'RUNEPool'
-            : row.original.version ?? row.original.provider
+          if (opp.version) subText.push(opp.provider)
+          if (opp.opportunityName) subText.push(opp.opportunityName)
+          const isRunePool = opp.assetId === thorchainAssetId
+          const providerName = isRunePool ? 'RUNEPool' : opp.version ?? opp.provider
           return (
             <Flex gap={4} alignItems='center'>
               <LazyLoadAvatar
                 size='sm'
                 bg='transparent'
-                src={row.original.icon ?? getMetadataForProvider(row.original.provider)?.icon ?? ''}
-                key={`provider-icon-${row.original.id}`}
+                src={opp.icon ?? getMetadataForProvider(opp.provider)?.icon ?? ''}
+                key={`provider-icon-${opp.id}`}
               />
               <Flex flexDir='column'>
                 <RawText>{providerName}</RawText>
@@ -249,20 +299,19 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
         Header: translate('defi.totalValue'),
         accessor: 'fiatAmount',
         Cell: ({ row }: { row: RowProps }) => {
-          const opportunity = row.original
-
-          const fiatRewardsAmount = calculateRewardFiatAmount({
-            rewardAssetIds: row.original.rewardAssetIds,
-            rewardsCryptoBaseUnit: row.original.rewardsCryptoBaseUnit,
-            assets,
-            marketDataUserCurrency,
-          })
+          const opp = row.original as StakingEarnOpportunityType & UnifiedPosition
 
-          const hasValue =
-            bnOrZero(opportunity.fiatAmount).gt(0) || bnOrZero(fiatRewardsAmount).gt(0)
+          const fiatRewardsAmount = opp.isYield
+            ? 0
+            : calculateRewardFiatAmount({
+                rewardAssetIds: opp.rewardAssetIds,
+                rewardsCryptoBaseUnit: opp.rewardsCryptoBaseUnit,
+                assets,
+                marketDataUserCurrency,
+              })
 
-          // Note, this already includes rewards. Let's not double-count them
-          const totalFiatAmount = bnOrZero(row.original.fiatAmount).toFixed(2)
+          const hasValue = bnOrZero(opp.fiatAmount).gt(0) || bnOrZero(fiatRewardsAmount).gt(0)
+          const totalFiatAmount = bnOrZero(opp.fiatAmount).toFixed(2)
 
           return hasValue ? (
             <Flex flexDir='column' alignItems={widthMdFlexStart}>
@@ -277,33 +326,38 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
         Header: translate('defi.apy'),
         accessor: 'apy',
         Cell: ({ row }: { row: RowProps }) => {
-          const isRfoxStaking = RFOX_STAKING_ASSET_IDS.includes(row.original.underlyingAssetId)
+          const opp = row.original as StakingEarnOpportunityType & UnifiedPosition
+          const isRfoxStaking =
+            !opp.isYield && RFOX_STAKING_ASSET_IDS.includes(opp.underlyingAssetId)
 
-          if (isRfoxStaking) return <RfoxApy stakingAssetId={row.original.underlyingAssetId} />
+          if (isRfoxStaking) return <RfoxApy stakingAssetId={opp.underlyingAssetId} />
 
           return (
             <Tag colorScheme='green'>
-              <Amount.Percent value={row.original.apy} />
+              <Amount.Percent value={opp.apy} />
             </Tag>
           )
         },
       },
       {
         Header: translate('defi.claimableRewards'),
-        accessor: 'rewardsCryptoBaseUnit',
+        accessor: 'id',
         display: isCompactCols ? 'none' : undefined,
         Cell: ({ row }: { row: RowProps }) => {
+          const opp = row.original as StakingEarnOpportunityType & UnifiedPosition
+          const handleClaimClick = useCallback(() => handleClick(row, DefiAction.Claim), [row])
+
+          if (opp.isYield) return <RawText variant='sub-text'>-</RawText>
+
           const fiatAmount = calculateRewardFiatAmount({
-            rewardAssetIds: row.original.rewardAssetIds,
-            rewardsCryptoBaseUnit: row.original.rewardsCryptoBaseUnit,
+            rewardAssetIds: opp.rewardAssetIds,
+            rewardsCryptoBaseUnit: opp.rewardsCryptoBaseUnit,
             assets,
             marketDataUserCurrency,
           })
           const hasRewardsBalance = bnOrZero(fiatAmount).gt(0)
 
-          const handleClaimClick = useCallback(() => handleClick(row, DefiAction.Claim), [row])
-
-          return hasRewardsBalance && row.original.isClaimableRewards ? (
+          return hasRewardsBalance && opp.isClaimableRewards ? (
             <Button
               isDisabled={!hasRewardsBalance}
               variant='ghost-filled'
@@ -322,30 +376,17 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
             <RawText variant='sub-text'>-</RawText>
           )
         },
-        sortType: (a: RowProps, b: RowProps): number => {
-          const aFiatPrice = calculateRewardFiatAmount({
-            rewardAssetIds: a.original.rewardAssetIds,
-            rewardsCryptoBaseUnit: a.original.rewardsCryptoBaseUnit,
-            assets,
-            marketDataUserCurrency,
-          })
-          const bFiatPrice = calculateRewardFiatAmount({
-            rewardAssetIds: b.original.rewardAssetIds,
-            rewardsCryptoBaseUnit: b.original.rewardsCryptoBaseUnit,
-            assets,
-            marketDataUserCurrency,
-          })
-          return aFiatPrice - bFiatPrice
-        },
       },
       {
         Header: () => null,
         id: 'expander',
         display: isCompactCols ? 'none' : undefined,
         Cell: ({ row }: { row: RowProps }) => {
-          const url = getMetadataForProvider(row.original.provider)?.url
+          const opp = row.original as StakingEarnOpportunityType & UnifiedPosition
+          const url = getMetadataForProvider(opp.provider)?.url
           const translation = (() => {
-            if (!row.original.isReadOnly) return 'common.manage'
+            if (opp.isYield) return 'common.view'
+            if (!opp.isReadOnly) return 'common.manage'
             return url ? 'common.view' : undefined
           })()
           const handleOverviewClick = useCallback(
@@ -361,9 +402,7 @@ export const StakingPositionsByProvider: React.FC<StakingPositionsByProviderProp
                   size='sm'
                   colorScheme='blue'
                   width={widthMdAuto}
-                  rightIcon={
-                    row.original.isReadOnly && url ? <ExternalLinkIcon boxSize={3} /> : undefined
-                  }
+                  rightIcon={opp.isReadOnly && url ? <ExternalLinkIcon boxSize={3} /> : undefined}
                   onClick={handleOverviewClick}
                 >
                   {translate(translation)}
diff --git a/src/components/StakingVaults/DeFiEarn.tsx b/src/components/StakingVaults/DeFiEarn.tsx
index 90915d1b05b..2b2b2b4806f 100644
--- a/src/components/StakingVaults/DeFiEarn.tsx
+++ b/src/components/StakingVaults/DeFiEarn.tsx
@@ -1,24 +1,31 @@
 import type { FlexProps, ResponsiveValue } from '@chakra-ui/react'
 import { Box, Flex } from '@chakra-ui/react'
 import type { ChainId } from '@shapeshiftoss/caip'
+import { fromAssetId } from '@shapeshiftoss/caip'
 import type { Property } from 'csstype'
 import type { JSX } from 'react'
-import { useState } from 'react'
+import { useMemo, useState } from 'react'
 
 import { GlobalFilter } from './GlobalFilter'
 import { useFetchOpportunities } from './hooks/useFetchOpportunities'
-import type { PositionTableProps } from './PositionTable'
+import { useYieldAsOpportunities } from './hooks/useYieldAsOpportunities'
+import type { PositionTableProps, UnifiedOpportunity } from './PositionTable'
 import { PositionTable } from './PositionTable'
 
 import { ChainDropdown } from '@/components/ChainDropdown/ChainDropdown'
 import { knownChainIds } from '@/constants/chains'
+import { useFeatureFlag } from '@/hooks/useFeatureFlag/useFeatureFlag'
 import { useQuery } from '@/hooks/useQuery/useQuery'
 import { useWallet } from '@/hooks/useWallet/useWallet'
-import { selectWalletConnectedChainIdsSorted } from '@/state/slices/selectors'
+import { bnOrZero } from '@/lib/bignumber/bignumber'
+import {
+  selectAggregatedEarnOpportunitiesByAssetId,
+  selectWalletConnectedChainIdsSorted,
+} from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 
 type DefiEarnProps = {
-  positionTableProps?: Omit<PositionTableProps, 'searchQuery'>
+  positionTableProps?: Omit<PositionTableProps, 'searchQuery' | 'data' | 'isLoading'>
   header?: JSX.Element
   forceCompactView?: boolean
 } & FlexProps
@@ -34,15 +41,100 @@ export const DeFiEarn: React.FC<DefiEarnProps> = ({
   forceCompactView,
   ...rest
 }) => {
-  const { isConnected } = useWallet().state
+  const {
+    state: { isConnected },
+  } = useWallet()
   const { q } = useQuery<{ q?: string }>()
   const [searchQuery, setSearchQuery] = useState(q ?? '')
   const [selectedChainId, setSelectedChainId] = useState<ChainId | undefined>()
-  const chainIds = useAppSelector(state =>
+
+  const isYieldXyzEnabled = useFeatureFlag('YieldXyz')
+
+  const chainIdsFromWallet = useAppSelector(state =>
     isConnected ? selectWalletConnectedChainIdsSorted(state) : knownChainIds,
   )
 
-  useFetchOpportunities()
+  const { isLoading: isOpportunitiesLoading } = useFetchOpportunities()
+  const legacyPositions = useAppSelector(state =>
+    selectAggregatedEarnOpportunitiesByAssetId(state, { chainId: undefined }),
+  )
+
+  const { data: yieldOpportunities, isLoading: isYieldLoading } =
+    useYieldAsOpportunities(isYieldXyzEnabled)
+
+  const mergedData: UnifiedOpportunity[] = useMemo(() => {
+    const map = new Map<string, UnifiedOpportunity>()
+
+    if (isYieldXyzEnabled && yieldOpportunities) {
+      console.debug('[DeFiEarn] Yield opportunities:', JSON.stringify(yieldOpportunities, null, 2))
+      yieldOpportunities.forEach(item => {
+        map.set(item.assetId, item)
+      })
+    }
+
+    console.debug(
+      '[DeFiEarn] Legacy positions:',
+      JSON.stringify(
+        legacyPositions.map(p => ({ assetId: p.assetId, fiatAmount: p.fiatAmount })),
+        null,
+        2,
+      ),
+    )
+
+    legacyPositions.forEach(item => {
+      const existing = map.get(item.assetId)
+      if (existing) {
+        console.debug('[DeFiEarn] Merging asset:', item.assetId, {
+          yieldFiat: existing.fiatAmount,
+          legacyFiat: item.fiatAmount,
+        })
+        const mergedFiatAmount = bnOrZero(existing.fiatAmount)
+          .plus(bnOrZero(item.fiatAmount))
+          .toFixed(2)
+        const mergedApy = bnOrZero(existing.apy).gt(bnOrZero(item.apy)) ? existing.apy : item.apy
+        map.set(item.assetId, {
+          ...existing,
+          fiatAmount: mergedFiatAmount,
+          apy: mergedApy,
+          opportunities: {
+            staking: [...existing.opportunities.staking, ...item.opportunities.staking],
+            lp: [...existing.opportunities.lp, ...item.opportunities.lp],
+          },
+        })
+      } else {
+        map.set(item.assetId, item as UnifiedOpportunity)
+      }
+    })
+
+    const result = Array.from(map.values()).sort((a, b) =>
+      bnOrZero(b.fiatAmount).minus(bnOrZero(a.fiatAmount)).toNumber(),
+    )
+    console.debug(
+      '[DeFiEarn] Final merged data:',
+      JSON.stringify(
+        result.map(r => ({
+          assetId: r.assetId,
+          fiatAmount: r.fiatAmount,
+          isYield: r.isYield,
+          yieldCount: r.yieldOpportunities?.length,
+          stakingCount: r.opportunities.staking.length,
+        })),
+        null,
+        2,
+      ),
+    )
+    return result
+  }, [isYieldXyzEnabled, legacyPositions, yieldOpportunities])
+
+  const chainIds = useMemo(() => {
+    if (!isYieldXyzEnabled || !yieldOpportunities?.length) return chainIdsFromWallet
+    const yieldChainIds = yieldOpportunities
+      .map(item => fromAssetId(item.assetId).chainId)
+      .filter(Boolean)
+    return Array.from(new Set([...chainIdsFromWallet, ...yieldChainIds]))
+  }, [chainIdsFromWallet, isYieldXyzEnabled, yieldOpportunities])
+
+  const isLoading = isOpportunitiesLoading || (isYieldXyzEnabled && isYieldLoading)
 
   return (
     <Flex width='full' flexDir='column' gap={6}>
@@ -74,6 +166,9 @@ export const DeFiEarn: React.FC<DefiEarnProps> = ({
           chainId={selectedChainId}
           searchQuery={searchQuery}
           forceCompactView={forceCompactView}
+          data={mergedData}
+          isLoading={isLoading}
+          {...positionTableProps}
         />
       </Box>
     </Flex>
diff --git a/src/components/StakingVaults/PositionTable.tsx b/src/components/StakingVaults/PositionTable.tsx
index 9a961e64b48..1ef070b3a9d 100644
--- a/src/components/StakingVaults/PositionTable.tsx
+++ b/src/components/StakingVaults/PositionTable.tsx
@@ -7,6 +7,7 @@ import { useCallback, useEffect, useMemo, useState, useTransition } from 'react'
 import { useTranslate } from 'react-polyglot'
 import type { Column, Row } from 'react-table'
 
+import type { YieldAggregatedOpportunity } from './hooks/useYieldAsOpportunities'
 import { SearchEmpty } from './SearchEmpty'
 
 import { Amount } from '@/components/Amount/Amount'
@@ -16,30 +17,27 @@ import { ReactTable } from '@/components/ReactTable/ReactTable'
 import { ResultsEmpty } from '@/components/ResultsEmpty'
 import { AssetCell } from '@/components/StakingVaults/Cells'
 import { RawText } from '@/components/Text'
-import { useIsSnapInstalled } from '@/hooks/useIsSnapInstalled/useIsSnapInstalled'
-import { useWallet } from '@/hooks/useWallet/useWallet'
-import { walletSupportsChain } from '@/hooks/useWalletSupportsChain/useWalletSupportsChain'
 import { bnOrZero } from '@/lib/bignumber/bignumber'
 import { isEvmAddress } from '@/lib/utils/isEvmAddress'
 import type { AggregatedOpportunitiesByAssetIdReturn } from '@/state/slices/opportunitiesSlice/types'
-import {
-  selectAccountIdsByChainId,
-  selectAggregatedEarnOpportunitiesByAssetId,
-  selectAssetsSortedByMarketCap,
-  selectIsAnyOpportunitiesApiQueryPending,
-} from '@/state/slices/selectors'
+import { selectAssetsSortedByMarketCap } from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 import { breakpoints } from '@/theme/theme'
 
-export type RowProps = Row<AggregatedOpportunitiesByAssetIdReturn>
+export type UnifiedOpportunity = AggregatedOpportunitiesByAssetIdReturn &
+  Partial<YieldAggregatedOpportunity>
+export type RowProps = Row<UnifiedOpportunity>
 
 const cellFlexJustifyContent = { base: 'flex-end', md: 'flex-start' }
 const cellTagSize = { base: 'sm', md: 'md' }
 const initialState = { pageSize: 30 }
+
 export type PositionTableProps = {
   chainId?: ChainId
   searchQuery: string
   forceCompactView?: boolean
+  data?: UnifiedOpportunity[]
+  isLoading?: boolean
 }
 
 const emptyIcon = <DefiIcon boxSize='20px' color='blue.500' />
@@ -47,59 +45,61 @@ const emptyIcon = <DefiIcon boxSize='20px' color='blue.500' />
 export const PositionTable: React.FC<PositionTableProps> = ({
   chainId,
   searchQuery,
+  data,
+  isLoading = false,
   forceCompactView = false,
 }) => {
   'use no memo'
   const translate = useTranslate()
   const assets = useAppSelector(selectAssetsSortedByMarketCap)
-  const isAnyOpportunitiesApiQueriesPending = useAppSelector(
-    selectIsAnyOpportunitiesApiQueryPending,
-  )
   const [isLargerThanMd] = useMediaQuery(`(min-width: ${breakpoints['md']})`, { ssr: false })
 
   const isCompactCols = !isLargerThanMd || forceCompactView
 
-  const [processedRows, setProcessedRows] = useState<AggregatedOpportunitiesByAssetIdReturn[]>([])
+  const basePositions = useMemo(() => data ?? [], [data])
+
+  const filteredByChain = useMemo(() => {
+    if (!chainId) return basePositions
+    return basePositions.filter(position => fromAssetId(position.assetId).chainId === chainId)
+  }, [basePositions, chainId])
+
+  const [processedRows, setProcessedRows] = useState<UnifiedOpportunity[]>([])
   const [, startTransition] = useTransition()
 
-  const selectAggregatedEarnOpportunitiesByAssetIdParams = useMemo(
-    () => ({
-      chainId,
-    }),
-    [chainId],
-  )
+  const filterRowsBySearchTerm = useCallback(
+    (rows: UnifiedOpportunity[], filterValue: string) => {
+      if (!filterValue) return rows
+      const search = filterValue.trim().toLowerCase()
+      if (!search) return rows
 
-  const {
-    state: { isConnected, wallet },
-  } = useWallet()
+      if (isEvmAddress(search)) {
+        return rows.filter(row => fromAssetId(row.assetId).assetReference.toLowerCase() === search)
+      }
 
-  const positions = useAppSelector(state =>
-    selectAggregatedEarnOpportunitiesByAssetId(
-      state,
-      selectAggregatedEarnOpportunitiesByAssetIdParams,
-    ),
+      return matchSorter(rows, search, {
+        keys: [
+          row => assets.find(a => a.assetId === row.assetId)?.name ?? '',
+          row => assets.find(a => a.assetId === row.assetId)?.symbol ?? '',
+          row => (row.searchable ?? []).join(' '),
+        ],
+        threshold: matchSorter.rankings.CONTAINS,
+      })
+    },
+    [assets],
   )
 
-  const { isSnapInstalled } = useIsSnapInstalled()
-  const accountIdsByChainId = useAppSelector(selectAccountIdsByChainId)
+  const isSearching = useMemo(() => searchQuery.length > 0, [searchQuery])
 
-  const filteredPositions = useMemo(
-    () =>
-      !isConnected
-        ? positions
-        : positions.filter(position => {
-            const chainAccountIds = accountIdsByChainId[fromAssetId(position.assetId).chainId] ?? []
-            return walletSupportsChain({
-              checkConnectedAccountIds: chainAccountIds,
-              chainId: fromAssetId(position.assetId).chainId,
-              wallet,
-              isSnapInstalled,
-            })
-          }),
-    [accountIdsByChainId, isConnected, isSnapInstalled, positions, wallet],
-  )
+  useEffect(() => {
+    startTransition(() => {
+      const targetRows = isSearching
+        ? filterRowsBySearchTerm(filteredByChain, searchQuery)
+        : filteredByChain
+      setProcessedRows(targetRows)
+    })
+  }, [filteredByChain, filterRowsBySearchTerm, isSearching, searchQuery])
 
-  const columns: Column<AggregatedOpportunitiesByAssetIdReturn>[] = useMemo(
+  const columns: Column<UnifiedOpportunity>[] = useMemo(
     () => [
       {
         Header: '#',
@@ -119,16 +119,12 @@ export const PositionTable: React.FC<PositionTableProps> = ({
       },
       {
         Header: translate('defi.totalValue'),
-        id: 'fiatAmount',
         accessor: 'fiatAmount',
         Cell: ({ row }: { row: RowProps }) => {
-          // A fiat amount can be positive or negative (debt) but not zero
           const hasValue =
             bnOrZero(row.original.fiatAmount).gt(0) ||
             bnOrZero(row.original.fiatRewardsAmount).gt(0)
-
           const totalFiatAmount = bnOrZero(row.original.fiatAmount).toFixed(2)
-
           return hasValue ? (
             <Amount.Fiat value={totalFiatAmount} />
           ) : (
@@ -140,18 +136,13 @@ export const PositionTable: React.FC<PositionTableProps> = ({
         Header: translate('defi.apy'),
         accessor: 'apy',
         textAlign: 'right',
-        Cell: ({ row }: { row: RowProps }) =>
-          row.original.apy !== undefined ? (
-            <Flex justifyContent={cellFlexJustifyContent}>
-              <Tag colorScheme='green' size={cellTagSize}>
-                <Amount.Percent value={row.original.apy} />
-              </Tag>
-            </Flex>
-          ) : (
-            <Flex justifyContent={cellFlexJustifyContent}>
-              <RawText variant='sub-text'>-</RawText>
-            </Flex>
-          ),
+        Cell: ({ row }: { row: RowProps }) => (
+          <Flex justifyContent={cellFlexJustifyContent}>
+            <Tag colorScheme='green' size={cellTagSize}>
+              <Amount.Percent value={row.original.apy} />
+            </Tag>
+          </Flex>
+        ),
       },
       {
         Header: () => null,
@@ -171,52 +162,24 @@ export const PositionTable: React.FC<PositionTableProps> = ({
         ),
       },
     ],
-    [translate, isCompactCols, assets],
-  )
-
-  const filterRowsBySearchTerm = useCallback(
-    (rows: AggregatedOpportunitiesByAssetIdReturn[], filterValue: any) => {
-      if (!filterValue) return rows
-      if (typeof filterValue !== 'string') {
-        return []
-      }
-      const search = filterValue.trim().toLowerCase()
-      if (isEvmAddress(filterValue)) {
-        return rows.filter(
-          row => fromAssetId(row.assetId).assetReference.toLowerCase() === filterValue,
-        )
-      }
-      const assetIds = rows.map(row => row.assetId)
-      const rowAssets = assets.filter(asset => assetIds.includes(asset.assetId))
-      const matchedAssets = matchSorter(rowAssets, search, {
-        keys: ['name', 'symbol'],
-        threshold: matchSorter.rankings.CONTAINS,
-      }).map(asset => asset.assetId)
-      const results = rows.filter(row => matchedAssets.includes(row.assetId))
-      return results
-    },
-    [assets],
+    [assets, isCompactCols, translate],
   )
 
-  const isSearching = useMemo(() => searchQuery.length > 0, [searchQuery])
-
-  useEffect(() => {
-    if (!filteredPositions.length) return setProcessedRows([])
-
-    startTransition(() => {
-      const newRows = isSearching
-        ? filterRowsBySearchTerm(filteredPositions, searchQuery)
-        : filteredPositions
-      setProcessedRows(newRows)
-    })
-  }, [filteredPositions, isSearching, searchQuery, filterRowsBySearchTerm])
-
-  const handleRowClick = useCallback((row: RowProps) => row.toggleRowExpanded(), [])
+  const handleRowClick = useCallback((row: RowProps) => {
+    row.toggleRowExpanded()
+  }, [])
 
   const renderSubComponent = useCallback(
-    ({ original }: RowProps) => (
-      <PositionDetails key={original.assetId} {...original} forceCompactView={forceCompactView} />
-    ),
+    ({ original }: RowProps) => {
+      return (
+        <PositionDetails
+          key={original.assetId}
+          {...original}
+          forceCompactView={forceCompactView}
+          yieldOpportunities={original.yieldOpportunities}
+        />
+      )
+    },
     [forceCompactView],
   )
 
@@ -229,8 +192,8 @@ export const PositionTable: React.FC<PositionTableProps> = ({
   }, [searchQuery])
 
   const isInitialProcessing = useMemo(
-    () => !processedRows.length && !isAnyOpportunitiesApiQueriesPending && positions.length,
-    [processedRows, isAnyOpportunitiesApiQueriesPending, positions],
+    () => !processedRows.length && !isLoading && filteredByChain.length > 0,
+    [filteredByChain.length, isLoading, processedRows.length],
   )
 
   if (isInitialProcessing) {
@@ -246,7 +209,7 @@ export const PositionTable: React.FC<PositionTableProps> = ({
       onRowClick={handleRowClick}
       data={processedRows}
       columns={columns}
-      isLoading={isAnyOpportunitiesApiQueriesPending}
+      isLoading={isLoading}
       renderSubComponent={renderSubComponent}
       renderEmptyComponent={renderEmptyComponent}
       initialState={initialState}
diff --git a/src/components/StakingVaults/hooks/useYieldAsOpportunities.ts b/src/components/StakingVaults/hooks/useYieldAsOpportunities.ts
new file mode 100644
index 00000000000..9a42518192f
--- /dev/null
+++ b/src/components/StakingVaults/hooks/useYieldAsOpportunities.ts
@@ -0,0 +1,153 @@
+import type { AssetId } from '@shapeshiftoss/caip'
+import { fromAssetId } from '@shapeshiftoss/caip'
+import { useMemo } from 'react'
+
+import { bnOrZero } from '@/lib/bignumber/bignumber'
+import { DEFAULT_NATIVE_VALIDATOR_BY_CHAIN_ID } from '@/lib/yieldxyz/constants'
+import type { AugmentedYieldDto } from '@/lib/yieldxyz/types'
+import { useAllYieldBalances } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
+import { useYields } from '@/react-queries/queries/yieldxyz/useYields'
+import type { AggregatedOpportunitiesByAssetIdReturn } from '@/state/slices/opportunitiesSlice/types'
+
+export type YieldOpportunityDisplay = {
+  yieldId: string
+  providerName: string
+  providerIcon?: string
+  apy: string
+  fiatAmount: string
+  cryptoAmount: string
+}
+
+export type YieldAggregatedOpportunity = AggregatedOpportunitiesByAssetIdReturn & {
+  yieldOpportunities: YieldOpportunityDisplay[]
+  searchable: string[]
+  isYield: true
+}
+
+export const useYieldAsOpportunities = (
+  enabled: boolean,
+): {
+  data: YieldAggregatedOpportunity[] | undefined
+  isLoading: boolean
+} => {
+  const { data: yieldsData, isLoading: isYieldsLoading } = useYields({ enabled })
+  const { data: yieldBalancesData, isLoading: isYieldBalancesLoading } = useAllYieldBalances({
+    enabled,
+  })
+
+  const data = useMemo<YieldAggregatedOpportunity[] | undefined>(() => {
+    if (!yieldsData?.all) return undefined
+
+    const aggregatedByAssetId: Record<AssetId, YieldAggregatedOpportunity> = {}
+
+    yieldsData.all.forEach((yieldItem: AugmentedYieldDto) => {
+      const inputAssetId = yieldItem.inputTokens?.[0]?.assetId
+      if (!inputAssetId) return
+
+      if (!aggregatedByAssetId[inputAssetId]) {
+        aggregatedByAssetId[inputAssetId] = {
+          assetId: inputAssetId,
+          underlyingAssetIds: [inputAssetId],
+          apy: undefined,
+          fiatAmount: '0',
+          cryptoBalancePrecision: '0',
+          fiatRewardsAmount: '0',
+          opportunities: {
+            staking: [],
+            lp: [],
+          },
+          yieldOpportunities: [],
+          searchable: [],
+          isYield: true,
+        }
+      }
+
+      const balancesForYield = yieldBalancesData?.aggregated[yieldItem.id]
+      const { chainId } = fromAssetId(inputAssetId)
+
+      let totalUsd: string
+      let totalCrypto: string
+
+      if (balancesForYield?.hasValidators) {
+        const defaultValidatorAddress = DEFAULT_NATIVE_VALIDATOR_BY_CHAIN_ID[chainId]
+        const validatorAddresses = Object.keys(balancesForYield.byValidator)
+        const selectedValidatorAddress = defaultValidatorAddress ?? validatorAddresses[0]
+        const validatorBalance = selectedValidatorAddress
+          ? balancesForYield.byValidator[selectedValidatorAddress]
+          : undefined
+        totalUsd = validatorBalance?.totalUsd ?? '0'
+        totalCrypto = validatorBalance?.totalCrypto ?? '0'
+      } else {
+        totalUsd = balancesForYield?.totalUsd ?? '0'
+        totalCrypto = balancesForYield?.totalCrypto ?? '0'
+      }
+
+      const existingFiatAmount = bnOrZero(aggregatedByAssetId[inputAssetId].fiatAmount)
+      const existingCryptoBalancePrecision = bnOrZero(
+        aggregatedByAssetId[inputAssetId].cryptoBalancePrecision,
+      )
+
+      aggregatedByAssetId[inputAssetId].fiatAmount = existingFiatAmount.plus(totalUsd).toFixed(2)
+      aggregatedByAssetId[inputAssetId].cryptoBalancePrecision = existingCryptoBalancePrecision
+        .plus(totalCrypto)
+        .toString()
+
+      const currentApy = aggregatedByAssetId[inputAssetId].apy
+      aggregatedByAssetId[inputAssetId].apy = currentApy
+        ? bnOrZero(currentApy).gt(yieldItem.rewardRate.total)
+          ? currentApy
+          : yieldItem.rewardRate.total.toString()
+        : yieldItem.rewardRate.total.toString()
+
+      if (bnOrZero(totalUsd).gt(0.01) || bnOrZero(totalCrypto).gt(0)) {
+        aggregatedByAssetId[inputAssetId].yieldOpportunities.push({
+          yieldId: yieldItem.id,
+          providerName: yieldItem.metadata.name || yieldItem.providerId,
+          providerIcon: yieldItem.metadata.logoURI,
+          apy: yieldItem.rewardRate.total.toString(),
+          fiatAmount: bnOrZero(totalUsd).toFixed(2),
+          cryptoAmount: bnOrZero(totalCrypto).toString(),
+        })
+      }
+
+      const searchable = aggregatedByAssetId[inputAssetId].searchable
+      const tokenSymbol = yieldItem.inputTokens?.[0]?.symbol ?? yieldItem.token.symbol
+      const tokenName = yieldItem.inputTokens?.[0]?.name ?? yieldItem.token.name
+      const providerName = yieldItem.metadata.name || yieldItem.providerId
+      searchable.push(tokenSymbol, tokenName, providerName, yieldItem.id)
+    })
+
+    const result = Object.values(aggregatedByAssetId)
+
+    result.forEach(agg => {
+      agg.yieldOpportunities.sort((a, b) => {
+        const aFiat = bnOrZero(a.fiatAmount)
+        const bFiat = bnOrZero(b.fiatAmount)
+        if (!aFiat.eq(bFiat)) return bFiat.minus(aFiat).toNumber()
+        return bnOrZero(b.apy).minus(bnOrZero(a.apy)).toNumber()
+      })
+    })
+
+    console.debug(
+      '[useYieldAsOpportunities] Result:',
+      JSON.stringify(
+        result.map(r => ({
+          assetId: r.assetId,
+          fiatAmount: r.fiatAmount,
+          yieldOpportunities: r.yieldOpportunities.map(y => ({
+            providerName: y.providerName,
+            fiatAmount: y.fiatAmount,
+          })),
+        })),
+        null,
+        2,
+      ),
+    )
+
+    return result
+  }, [yieldBalancesData?.aggregated, yieldsData?.all])
+
+  const isLoading = isYieldsLoading || isYieldBalancesLoading
+
+  return { data, isLoading }
+}
diff --git a/src/lib/yieldxyz/utils.test.ts b/src/lib/yieldxyz/utils.test.ts
new file mode 100644
index 00000000000..49cd1f1f204
--- /dev/null
+++ b/src/lib/yieldxyz/utils.test.ts
@@ -0,0 +1,245 @@
+import { describe, expect, it } from 'vitest'
+
+import { SHAPESHIFT_COSMOS_VALIDATOR_ADDRESS } from './constants'
+import type { AugmentedYieldDto, ValidatorDto } from './types'
+import {
+  ensureValidatorApr,
+  getTransactionButtonText,
+  resolveYieldInputAssetIcon,
+  searchValidators,
+  searchYields,
+  sortValidators,
+} from './utils'
+
+describe('getTransactionButtonText', () => {
+  it('should handle type variations with dashes and underscores', () => {
+    expect(getTransactionButtonText('CLAIM_REWARDS', undefined)).toBe('Claim')
+    expect(getTransactionButtonText('claim-rewards', undefined)).toBe('Claim')
+  })
+
+  it('should fallback to parsing title when type is unknown', () => {
+    expect(getTransactionButtonText(undefined, 'Approve token')).toBe('Approve')
+    expect(getTransactionButtonText(undefined, 'Deposit ETH transaction')).toBe('Enter')
+    expect(getTransactionButtonText(undefined, 'Claim rewards')).toBe('Claim')
+  })
+
+  it('should return Confirm as final fallback', () => {
+    expect(getTransactionButtonText(undefined, undefined)).toBe('Confirm')
+    expect(getTransactionButtonText(undefined, 'Unknown action')).toBe('Confirm')
+  })
+
+  it('should capitalize unknown types', () => {
+    expect(getTransactionButtonText('CUSTOM_ACTION', undefined)).toBe('Custom_action')
+  })
+})
+
+describe('resolveYieldInputAssetIcon', () => {
+  it('should prefer inputToken assetId', () => {
+    const yieldItem = {
+      inputTokens: [{ assetId: 'eip155:1/slip44:60', logoURI: 'https://input.png' }],
+      token: { assetId: 'eip155:1/erc20:0xtoken', logoURI: 'https://token.png' },
+      metadata: { logoURI: 'https://metadata.png' },
+    }
+    expect(resolveYieldInputAssetIcon(yieldItem)).toEqual({
+      assetId: 'eip155:1/slip44:60',
+      src: undefined,
+    })
+  })
+
+  it('should fallback to token assetId when inputToken has none', () => {
+    const yieldItem = {
+      inputTokens: [{ logoURI: 'https://input.png' }],
+      token: { assetId: 'eip155:1/erc20:0xtoken', logoURI: 'https://token.png' },
+      metadata: { logoURI: 'https://metadata.png' },
+    }
+    expect(resolveYieldInputAssetIcon(yieldItem)).toEqual({
+      assetId: 'eip155:1/erc20:0xtoken',
+      src: undefined,
+    })
+  })
+
+  it('should fallback to inputToken logoURI when no assetIds', () => {
+    const yieldItem = {
+      inputTokens: [{ logoURI: 'https://input.png' }],
+      token: { logoURI: 'https://token.png' },
+      metadata: { logoURI: 'https://metadata.png' },
+    }
+    expect(resolveYieldInputAssetIcon(yieldItem)).toEqual({
+      assetId: undefined,
+      src: 'https://input.png',
+    })
+  })
+
+  it('should fallback to metadata logoURI as last resort', () => {
+    const yieldItem = {
+      inputTokens: [],
+      token: {},
+      metadata: { logoURI: 'https://metadata.png' },
+    }
+    expect(resolveYieldInputAssetIcon(yieldItem)).toEqual({
+      assetId: undefined,
+      src: 'https://metadata.png',
+    })
+  })
+
+  it('should handle empty inputTokens array', () => {
+    const yieldItem = {
+      inputTokens: [],
+      token: { assetId: 'eip155:1/slip44:60' },
+      metadata: {},
+    }
+    expect(resolveYieldInputAssetIcon(yieldItem)).toEqual({
+      assetId: 'eip155:1/slip44:60',
+      src: undefined,
+    })
+  })
+})
+
+describe('searchYields', () => {
+  const mockYields = [
+    {
+      metadata: { name: 'ETH Staking' },
+      token: { symbol: 'ETH', name: 'Ethereum' },
+      providerId: 'lido',
+    },
+    {
+      metadata: { name: 'USDC Lending' },
+      token: { symbol: 'USDC', name: 'USD Coin' },
+      providerId: 'aave',
+    },
+    {
+      metadata: { name: 'BTC Vault' },
+      token: { symbol: 'WBTC', name: 'Wrapped Bitcoin' },
+      providerId: 'yearn',
+    },
+  ] as AugmentedYieldDto[]
+
+  it('should return all yields when query is empty', () => {
+    expect(searchYields(mockYields, '')).toHaveLength(3)
+  })
+
+  it('should search by metadata name', () => {
+    expect(searchYields(mockYields, 'staking')).toHaveLength(1)
+    expect(searchYields(mockYields, 'staking')[0].metadata.name).toBe('ETH Staking')
+  })
+
+  it('should search by token symbol', () => {
+    expect(searchYields(mockYields, 'eth')).toHaveLength(1)
+    expect(searchYields(mockYields, 'usdc')).toHaveLength(1)
+  })
+
+  it('should search by token name', () => {
+    expect(searchYields(mockYields, 'ethereum')).toHaveLength(1)
+    expect(searchYields(mockYields, 'bitcoin')).toHaveLength(1)
+  })
+
+  it('should search by providerId', () => {
+    expect(searchYields(mockYields, 'lido')).toHaveLength(1)
+    expect(searchYields(mockYields, 'aave')).toHaveLength(1)
+  })
+
+  it('should be case insensitive', () => {
+    expect(searchYields(mockYields, 'ETH')).toHaveLength(1)
+    expect(searchYields(mockYields, 'LIDO')).toHaveLength(1)
+  })
+
+  it('should return empty array when no matches', () => {
+    expect(searchYields(mockYields, 'xyz')).toHaveLength(0)
+  })
+})
+
+describe('searchValidators', () => {
+  const mockValidators = [
+    { name: 'ShapeShift DAO', address: 'cosmos123' },
+    { name: 'Figment', address: 'cosmos456' },
+    { name: 'Chorus One', address: 'cosmos789' },
+  ] as ValidatorDto[]
+
+  it('should return all validators when query is empty', () => {
+    expect(searchValidators(mockValidators, '')).toHaveLength(3)
+  })
+
+  it('should search by name', () => {
+    expect(searchValidators(mockValidators, 'shape')).toHaveLength(1)
+    expect(searchValidators(mockValidators, 'figment')).toHaveLength(1)
+  })
+
+  it('should search by address', () => {
+    expect(searchValidators(mockValidators, '123')).toHaveLength(1)
+    expect(searchValidators(mockValidators, 'cosmos')).toHaveLength(3)
+  })
+
+  it('should be case insensitive', () => {
+    expect(searchValidators(mockValidators, 'SHAPESHIFT')).toHaveLength(1)
+  })
+})
+
+describe('sortValidators', () => {
+  const mockValidators = [
+    { name: 'Regular', address: 'cosmos111', preferred: false },
+    { name: 'ShapeShift', address: SHAPESHIFT_COSMOS_VALIDATOR_ADDRESS, preferred: false },
+    { name: 'Preferred', address: 'cosmos333', preferred: true },
+  ] as ValidatorDto[]
+
+  it('should put ShapeShift validator first by default', () => {
+    const sorted = sortValidators(mockValidators)
+    expect(sorted[0].name).toBe('ShapeShift')
+  })
+
+  it('should put preferred validators before non-preferred', () => {
+    const sorted = sortValidators(mockValidators, { shapeShiftFirst: false, preferredFirst: true })
+    expect(sorted[0].name).toBe('Preferred')
+  })
+
+  it('should respect both options', () => {
+    const sorted = sortValidators(mockValidators, { shapeShiftFirst: true, preferredFirst: true })
+    expect(sorted[0].name).toBe('ShapeShift')
+    expect(sorted[1].name).toBe('Preferred')
+  })
+
+  it('should not mutate original array', () => {
+    const original = [...mockValidators]
+    sortValidators(mockValidators)
+    expect(mockValidators).toEqual(original)
+  })
+})
+
+describe('ensureValidatorApr', () => {
+  const baseValidator = {
+    name: 'Test',
+    address: 'cosmos123',
+    preferred: false,
+    logoURI: '',
+    commission: 0.05,
+    status: 'active',
+    stakedBalance: '1000',
+    votingPower: 0.01,
+    website: '',
+    tvl: '1000000',
+    tvlRaw: '1000000000000',
+  } as unknown as ValidatorDto
+
+  it('should return validator unchanged if it has rewardRate.total', () => {
+    const validator: ValidatorDto = {
+      ...baseValidator,
+      rewardRate: { total: 0.15, rateType: 'APR' as const, components: [] },
+    }
+    expect(ensureValidatorApr(validator)).toBe(validator)
+  })
+
+  it('should add fallback APR if rewardRate.total is missing', () => {
+    const validator = { ...baseValidator, rewardRate: undefined } as unknown as ValidatorDto
+    const result = ensureValidatorApr(validator)
+    expect(result.rewardRate?.total).toBeDefined()
+    expect(result.rewardRate?.rateType).toBe('APR')
+  })
+
+  it('should preserve existing components when adding fallback', () => {
+    const validator = {
+      ...baseValidator,
+      rewardRate: { components: [{ type: 'test', rate: 0.1 }] },
+    } as unknown as ValidatorDto
+    const result = ensureValidatorApr(validator)
+    expect(result.rewardRate?.components).toHaveLength(1)
+  })
+})
diff --git a/src/lib/yieldxyz/utils.ts b/src/lib/yieldxyz/utils.ts
index e0feda81908..2b020763e99 100644
--- a/src/lib/yieldxyz/utils.ts
+++ b/src/lib/yieldxyz/utils.ts
@@ -8,8 +8,6 @@ import {
 } from './constants'
 import type { AugmentedYieldDto, ValidatorDto, YieldIconSource } from './types'
 
-import { bnOrZero } from '@/lib/bignumber/bignumber'
-
 export const yieldNetworkToChainId = (network: string): ChainId | undefined => {
   if (!isSupportedYieldNetwork(network)) return undefined
   return YIELD_NETWORK_TO_CHAIN_ID[network]
@@ -146,9 +144,6 @@ export const sortValidators = (
   })
 }
 
-export const toUserCurrency = (usdAmount: string | number, rate: string | number): string =>
-  bnOrZero(usdAmount).times(rate).toFixed()
-
 export const ensureValidatorApr = (validator: ValidatorDto): ValidatorDto =>
   validator.rewardRate?.total
     ? validator
diff --git a/src/pages/Yields/YieldAccountContext.tsx b/src/pages/Yields/YieldAccountContext.tsx
index 7948d235ff5..9f962d6da8d 100644
--- a/src/pages/Yields/YieldAccountContext.tsx
+++ b/src/pages/Yields/YieldAccountContext.tsx
@@ -1,34 +1,58 @@
+import type { AccountId } from '@shapeshiftoss/caip'
 import React, { createContext, memo, useCallback, useContext, useMemo, useState } from 'react'
 
+import { selectAccountNumberByAccountId } from '@/state/slices/portfolioSlice/selectors'
+import { selectEnabledWalletAccountIds } from '@/state/slices/selectors'
+import { useAppSelector } from '@/state/store'
+
 type YieldAccountContextType = {
+  accountId: AccountId | undefined
   accountNumber: number
-  setAccountNumber: (accountNumber: number) => void
+  setAccountId: (accountId: AccountId | undefined) => void
 }
 
 const YieldAccountContext = createContext<YieldAccountContextType | undefined>(undefined)
 
-export const YieldAccountProvider: React.FC<{ children: React.ReactNode }> = memo(
-  ({ children }) => {
-    const [accountNumber, setAccountNumberState] = useState(0)
+export const YieldAccountProvider: React.FC<{
+  children: React.ReactNode
+  initialAccountId?: AccountId
+}> = memo(({ children, initialAccountId }) => {
+  const enabledWalletAccountIds = useAppSelector(selectEnabledWalletAccountIds)
+  const [userSelectedAccountId, setUserSelectedAccountId] = useState<AccountId | undefined>(
+    initialAccountId,
+  )
+
+  const accountId = useMemo(
+    () => userSelectedAccountId ?? enabledWalletAccountIds[0],
+    [userSelectedAccountId, enabledWalletAccountIds],
+  )
+
+  const accountNumber = useAppSelector(state => {
+    if (!accountId) return 0
+    const foundAccountNumber = selectAccountNumberByAccountId(state, { accountId })
+    return foundAccountNumber ?? 0
+  })
 
-    const setAccountNumber = useCallback((accountNumber: number) => {
-      setAccountNumberState(accountNumber)
-    }, [])
+  const setAccountId = useCallback((nextAccountId: AccountId | undefined) => {
+    setUserSelectedAccountId(nextAccountId)
+  }, [])
 
-    const value = useMemo(
-      () => ({ accountNumber, setAccountNumber }),
-      [accountNumber, setAccountNumber],
-    )
+  const value = useMemo(
+    () => ({ accountId, accountNumber, setAccountId }),
+    [accountId, accountNumber, setAccountId],
+  )
 
-    return <YieldAccountContext.Provider value={value}>{children}</YieldAccountContext.Provider>
-  },
-)
+  return <YieldAccountContext.Provider value={value}>{children}</YieldAccountContext.Provider>
+})
 
 export const useYieldAccount = () => {
   const context = useContext(YieldAccountContext)
-  // Fallback to account 0 when used outside YieldAccountProvider (e.g., YieldAssetSection on asset pages)
   if (context === undefined) {
-    return { accountNumber: 0, setAccountNumber: () => {} }
+    return {
+      accountId: undefined,
+      accountNumber: 0,
+      setAccountId: () => {},
+    }
   }
   return context
 }
diff --git a/src/pages/Yields/YieldAssetDetails.tsx b/src/pages/Yields/YieldAssetDetails.tsx
index 6cf98a882c3..fe2c39fbf79 100644
--- a/src/pages/Yields/YieldAssetDetails.tsx
+++ b/src/pages/Yields/YieldAssetDetails.tsx
@@ -18,9 +18,12 @@ import { memo, useCallback, useMemo } from 'react'
 import { useTranslate } from 'react-polyglot'
 import { useNavigate, useParams, useSearchParams } from 'react-router-dom'
 
+import { AccountSelector } from '@/components/AccountSelector/AccountSelector'
 import { Amount } from '@/components/Amount/Amount'
 import { AssetIcon } from '@/components/AssetIcon'
 import { ChainIcon } from '@/components/ChainMenu'
+import { Display } from '@/components/Display'
+import { useFeatureFlag } from '@/hooks/useFeatureFlag/useFeatureFlag'
 import { bnOrZero } from '@/lib/bignumber/bignumber'
 import {
   COSMOS_ATOM_NATIVE_STAKING_YIELD_ID,
@@ -38,11 +41,15 @@ import { YieldFilters } from '@/pages/Yields/components/YieldFilters'
 import { YieldItem, YieldItemSkeleton } from '@/pages/Yields/components/YieldItem'
 import { YieldTable } from '@/pages/Yields/components/YieldTable'
 import { ViewToggle } from '@/pages/Yields/components/YieldViewHelpers'
+import { useYieldAccountSync } from '@/pages/Yields/hooks/useYieldAccountSync'
 import { useYieldFilters } from '@/pages/Yields/hooks/useYieldFilters'
 import { useAllYieldBalances } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
 import { useYieldProviders } from '@/react-queries/queries/yieldxyz/useYieldProviders'
 import { useYields } from '@/react-queries/queries/yieldxyz/useYields'
-import { selectUserCurrencyToUsdRate } from '@/state/slices/selectors'
+import {
+  selectPortfolioAccountIdsByAssetIdFilter,
+  selectUserCurrencyToUsdRate,
+} from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 
 export const YieldAssetDetails = memo(() => {
@@ -85,7 +92,32 @@ export const YieldAssetDetails = memo(() => {
   const { data: yields, isLoading } = useYields()
   const { data: yieldProviders } = useYieldProviders()
   const userCurrencyToUsdRate = useAppSelector(selectUserCurrencyToUsdRate)
-  const { data: allBalancesData } = useAllYieldBalances()
+
+  const assetInfo = useMemo(() => {
+    const group = yields?.assetGroups?.find(g => g.symbol === decodedSymbol)
+    if (!group) return null
+    return { assetName: group.name, assetIcon: group.icon, assetId: group.assetId }
+  }, [yields?.assetGroups, decodedSymbol])
+
+  const isYieldMultiAccountEnabled = useFeatureFlag('YieldMultiAccount')
+  const accountIdsForAsset = useAppSelector(state =>
+    assetInfo?.assetId
+      ? selectPortfolioAccountIdsByAssetIdFilter(state, { assetId: assetInfo.assetId })
+      : [],
+  )
+
+  const { selectedAccountId, handleAccountChange } = useYieldAccountSync({
+    availableAccountIds: accountIdsForAsset,
+  })
+
+  const showAccountSelector = isYieldMultiAccountEnabled && accountIdsForAsset.length > 1
+
+  const balanceAccountIds = useMemo(() => {
+    if (!isYieldMultiAccountEnabled) return accountIdsForAsset
+    return selectedAccountId ? [selectedAccountId] : accountIdsForAsset
+  }, [isYieldMultiAccountEnabled, selectedAccountId, accountIdsForAsset])
+
+  const { data: allBalancesData } = useAllYieldBalances({ accountIds: balanceAccountIds })
   const allBalances = allBalancesData?.byYieldId
 
   const getProviderLogo = useCallback(
@@ -177,12 +209,6 @@ export const YieldAssetDetails = memo(() => {
     [assetYields, selectedNetwork, selectedProvider, selectedType],
   )
 
-  const assetInfo = useMemo(() => {
-    const group = yields?.assetGroups?.find(g => g.symbol === decodedSymbol)
-    if (!group) return null
-    return { assetName: group.name, assetIcon: group.icon, assetId: group.assetId }
-  }, [yields?.assetGroups, decodedSymbol])
-
   const columns = useMemo<ColumnDef<AugmentedYieldDto>[]>(
     () => [
       {
@@ -374,20 +400,51 @@ export const YieldAssetDetails = memo(() => {
   const assetHeaderElement = useMemo(() => {
     if (!assetInfo) return null
     return (
-      <Flex alignItems='center' gap={4} mb={8}>
-        <AssetIcon
-          {...(assetInfo.assetId ? { assetId: assetInfo.assetId } : { src: assetInfo.assetIcon })}
-          size='lg'
-          showNetworkIcon={false}
-        />
-        <Box>
-          <Heading size='lg'>
-            {translate('yieldXYZ.assetYields', { asset: assetInfo.assetName })}
-          </Heading>
-        </Box>
-      </Flex>
+      <Box mb={8}>
+        <Flex
+          alignItems={{ base: 'flex-start', md: 'center' }}
+          justifyContent='space-between'
+          gap={4}
+          direction={{ base: 'column', md: 'row' }}
+        >
+          <Flex alignItems='center' gap={4}>
+            <AssetIcon
+              {...(assetInfo.assetId
+                ? { assetId: assetInfo.assetId }
+                : { src: assetInfo.assetIcon })}
+              size='lg'
+              showNetworkIcon={false}
+            />
+            <Box>
+              <Heading size='lg'>
+                {translate('yieldXYZ.assetYields', { asset: assetInfo.assetName })}
+              </Heading>
+            </Box>
+          </Flex>
+          {showAccountSelector && assetInfo?.assetId && (
+            <Display.Desktop>
+              <AccountSelector
+                assetId={assetInfo.assetId}
+                accountId={selectedAccountId}
+                onChange={handleAccountChange}
+              />
+            </Display.Desktop>
+          )}
+        </Flex>
+        {showAccountSelector && assetInfo?.assetId && (
+          <Display.Mobile>
+            <Box mt={4}>
+              <AccountSelector
+                assetId={assetInfo.assetId}
+                accountId={selectedAccountId}
+                onChange={handleAccountChange}
+              />
+            </Box>
+          </Display.Mobile>
+        )}
+      </Box>
     )
-  }, [assetInfo, translate])
+  }, [assetInfo, translate, selectedAccountId, handleAccountChange, showAccountSelector])
 
   const loadingGridElement = useMemo(
     () => (
diff --git a/src/pages/Yields/YieldDetail.tsx b/src/pages/Yields/YieldDetail.tsx
index 6495750ec93..06bb993ae67 100644
--- a/src/pages/Yields/YieldDetail.tsx
+++ b/src/pages/Yields/YieldDetail.tsx
@@ -3,6 +3,9 @@ import { memo, useEffect, useMemo } from 'react'
 import { useTranslate } from 'react-polyglot'
 import { useNavigate, useParams, useSearchParams } from 'react-router-dom'
 
+import { AccountSelector } from '@/components/AccountSelector/AccountSelector'
+import { Display } from '@/components/Display'
+import { useFeatureFlag } from '@/hooks/useFeatureFlag/useFeatureFlag'
 import { bnOrZero } from '@/lib/bignumber/bignumber'
 import {
   COSMOS_ATOM_NATIVE_STAKING_YIELD_ID,
@@ -20,11 +23,15 @@ import { YieldHero } from '@/pages/Yields/components/YieldHero'
 import { YieldManager } from '@/pages/Yields/components/YieldManager'
 import { YieldPositionCard } from '@/pages/Yields/components/YieldPositionCard'
 import { YieldStats } from '@/pages/Yields/components/YieldStats'
+import { useYieldAccountSync } from '@/pages/Yields/hooks/useYieldAccountSync'
 import { useAllYieldBalances } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
 import { useYield } from '@/react-queries/queries/yieldxyz/useYield'
 import { useYieldProviders } from '@/react-queries/queries/yieldxyz/useYieldProviders'
 import { useYieldValidators } from '@/react-queries/queries/yieldxyz/useYieldValidators'
-import { selectUserCurrencyToUsdRate } from '@/state/slices/selectors'
+import {
+  selectPortfolioAccountIdsByAssetIdFilter,
+  selectUserCurrencyToUsdRate,
+} from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 
 export const YieldDetail = memo(() => {
@@ -32,10 +39,40 @@ export const YieldDetail = memo(() => {
   const [searchParams] = useSearchParams()
   const navigate = useNavigate()
   const translate = useTranslate()
+
   const userCurrencyToUsdRate = useAppSelector(selectUserCurrencyToUsdRate)
 
   const { data: yieldItem, isLoading, error } = useYield(yieldId ?? '')
-  const { data: allBalancesData, isFetching: isBalancesFetching } = useAllYieldBalances()
+
+  const selectorAssetId = useMemo(() => {
+    if (yieldItem?.token.assetId) return yieldItem.token.assetId
+    if (yieldItem?.inputTokens?.[0]?.assetId) return yieldItem.inputTokens[0].assetId
+    return undefined
+  }, [yieldItem?.inputTokens, yieldItem?.token.assetId])
+
+  const availableAccounts = useAppSelector(state =>
+    selectorAssetId
+      ? selectPortfolioAccountIdsByAssetIdFilter(state, { assetId: selectorAssetId })
+      : [],
+  )
+
+  const isYieldMultiAccountEnabled = useFeatureFlag('YieldMultiAccount')
+
+  const { selectedAccountId, handleAccountChange } = useYieldAccountSync({
+    availableAccountIds: availableAccounts,
+  })
+
+  const showAccountSelector = isYieldMultiAccountEnabled && availableAccounts.length > 1
+
+  const balanceAccountIds = useMemo(() => {
+    if (!isYieldMultiAccountEnabled)
+      return availableAccounts.length > 0 ? availableAccounts : undefined
+    return selectedAccountId ? [selectedAccountId] : undefined
+  }, [isYieldMultiAccountEnabled, selectedAccountId, availableAccounts])
+
+  const { data: allBalancesData, isFetching: isBalancesFetching } = useAllYieldBalances({
+    accountIds: balanceAccountIds,
+  })
   const balances = yieldItem?.id ? allBalancesData?.normalized[yieldItem.id] : undefined
   const isBalancesLoading = !allBalancesData && isBalancesFetching
 
@@ -172,6 +209,28 @@ export const YieldDetail = memo(() => {
         maxW={{ base: 'full', md: 'container.md', lg: 'container.lg' }}
         px={{ base: 4, md: 8, lg: 12 }}
       >
+        {showAccountSelector && selectorAssetId && (
+          <>
+            <Display.Desktop>
+              <Flex justifyContent='flex-end' pt={4}>
+                <AccountSelector
+                  assetId={selectorAssetId}
+                  accountId={selectedAccountId}
+                  onChange={handleAccountChange}
+                />
+              </Flex>
+            </Display.Desktop>
+            <Display.Mobile>
+              <Box pt={2} pb={2}>
+                <AccountSelector
+                  assetId={selectorAssetId}
+                  accountId={selectedAccountId}
+                  onChange={handleAccountChange}
+                />
+              </Box>
+            </Display.Mobile>
+          </>
+        )}
         <YieldHero
           yieldItem={yieldItem}
           userBalanceUsd={userBalances.userCurrency}
diff --git a/src/pages/Yields/components/YieldActionModal.tsx b/src/pages/Yields/components/YieldActionModal.tsx
index 719933082fe..a1fd1c765f9 100644
--- a/src/pages/Yields/components/YieldActionModal.tsx
+++ b/src/pages/Yields/components/YieldActionModal.tsx
@@ -58,6 +58,7 @@ export const YieldActionModal = memo(function YieldActionModal({
   validatorName,
   validatorLogoURI,
   passthrough,
+  accountId,
   ...props
 }: YieldActionModalProps) {
   const translate = useTranslate()
@@ -85,7 +86,7 @@ export const YieldActionModal = memo(function YieldActionModal({
     validatorAddress,
     passthrough,
     manageActionType: props.manageActionType,
-    accountId: props.accountId,
+    accountId,
   })
 
   const shouldFetchValidators = useMemo(
@@ -358,6 +359,7 @@ export const YieldActionModal = memo(function YieldActionModal({
         providerInfo={successProviderInfo}
         transactionSteps={transactionSteps}
         yieldId={yieldItem.id}
+        accountId={accountId}
         onDone={handleClose}
         successMessageKey={successMessageKey}
       />
@@ -368,6 +370,7 @@ export const YieldActionModal = memo(function YieldActionModal({
       successProviderInfo,
       transactionSteps,
       yieldItem.id,
+      accountId,
       handleClose,
       successMessageKey,
     ],
diff --git a/src/pages/Yields/components/YieldActivePositions.tsx b/src/pages/Yields/components/YieldActivePositions.tsx
index eeb29dac83f..cd1813b0f0c 100644
--- a/src/pages/Yields/components/YieldActivePositions.tsx
+++ b/src/pages/Yields/components/YieldActivePositions.tsx
@@ -2,6 +2,7 @@ import {
   Avatar,
   Box,
   HStack,
+  Stack,
   Table,
   TableContainer,
   Tbody,
@@ -11,28 +12,60 @@ import {
   Thead,
   Tr,
 } from '@chakra-ui/react'
-import type { AssetId } from '@shapeshiftoss/caip'
+import type { AccountId, AssetId } from '@shapeshiftoss/caip'
 import { memo, useCallback, useMemo } from 'react'
 import { useTranslate } from 'react-polyglot'
 import { useNavigate } from 'react-router-dom'
 
 import { Amount } from '@/components/Amount/Amount'
+import { Display } from '@/components/Display'
+import { RawText } from '@/components/Text'
 import { bnOrZero } from '@/lib/bignumber/bignumber'
 import type { AugmentedYieldDto } from '@/lib/yieldxyz/types'
-import { toUserCurrency } from '@/lib/yieldxyz/utils'
-import type { YieldBalanceAggregate } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
+import type { AugmentedYieldBalanceWithAccountId } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
 import { useYieldProviders } from '@/react-queries/queries/yieldxyz/useYieldProviders'
+import { accountIdToLabel } from '@/state/slices/portfolioSlice/utils'
 import { selectAssetById, selectUserCurrencyToUsdRate } from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 
+type AccountBalanceInfo = {
+  totalUsd: string
+  totalCrypto: string
+  validatorAddress?: string
+  validatorName?: string
+  validatorLogo?: string
+}
+
+type AccountYieldPosition = {
+  accountId: AccountId
+  accountLabel: string
+  yieldItem: AugmentedYieldDto
+  providerId: string
+  providerLogo: string | undefined
+  apy: number
+  totalUsd: string
+  totalCrypto: string
+  validatorAddress?: string
+  validatorName?: string
+  validatorLogo?: string
+}
+
 type YieldActivePositionsProps = {
-  aggregated: Record<string, YieldBalanceAggregate>
+  balancesByYieldId: Record<string, AugmentedYieldBalanceWithAccountId[]> | undefined
   yields: AugmentedYieldDto[]
   assetId: AssetId
 }
 
+type HandlePositionClickArgs = {
+  yieldId: string
+  accountId: AccountId
+  validatorAddress?: string
+}
+
+const hoverSx = { bg: 'background.surface.raised.base', cursor: 'pointer' }
+
 export const YieldActivePositions = memo(
-  ({ aggregated, yields, assetId }: YieldActivePositionsProps) => {
+  ({ balancesByYieldId, yields, assetId }: YieldActivePositionsProps) => {
     const translate = useTranslate()
     const navigate = useNavigate()
     const asset = useAppSelector(state => selectAssetById(state, assetId))
@@ -45,132 +78,113 @@ export const YieldActivePositions = memo(
       [providers],
     )
 
-    const activeYields = useMemo(
-      () => yields.filter(y => aggregated[y.id] && bnOrZero(aggregated[y.id].totalUsd).gt(0)),
-      [yields, aggregated],
+    const getProviderName = useCallback(
+      (providerId: string) => providers?.[providerId]?.name ?? providerId,
+      [providers],
     )
 
-    const handleRowClick = useCallback(
-      (yieldId: string, validatorAddress?: string) => {
-        const url = validatorAddress
-          ? `/yields/${yieldId}?validator=${validatorAddress}`
-          : `/yields/${yieldId}`
-        navigate(url)
-      },
-      [navigate],
-    )
+    const accountPositions = useMemo((): AccountYieldPosition[] => {
+      if (!balancesByYieldId || !asset) return []
 
-    const hasValidators = useMemo(
-      () => activeYields.some(y => aggregated[y.id]?.hasValidators),
-      [activeYields, aggregated],
-    )
+      const positions: AccountYieldPosition[] = []
+      const yieldsMap = new Map(yields.map(y => [y.id, y]))
 
-    const providerColumnHeader = useMemo(
-      () =>
-        hasValidators
-          ? translate('yieldXYZ.validator') ?? 'Validator'
-          : translate('yieldXYZ.provider') ?? 'Provider',
-      [hasValidators, translate],
-    )
+      for (const [yieldId, balances] of Object.entries(balancesByYieldId)) {
+        const yieldItem = yieldsMap.get(yieldId)
+        if (!yieldItem) continue
+
+        const accountBalances = new Map<AccountId, AccountBalanceInfo>()
 
-    const apyColumnHeader = useMemo(() => translate('yieldXYZ.apy') ?? 'APY', [translate])
+        for (const balance of balances) {
+          const { accountId, amountUsd, amount, validator } = balance
+          if (!accountId || bnOrZero(amount).lte(0)) continue
 
-    const tvlColumnHeader = useMemo(() => translate('yieldXYZ.tvl') ?? 'TVL', [translate])
+          const existing = accountBalances.get(accountId)
+          if (existing) {
+            accountBalances.set(accountId, {
+              totalUsd: bnOrZero(existing.totalUsd).plus(amountUsd).toFixed(),
+              totalCrypto: bnOrZero(existing.totalCrypto).plus(amount).toFixed(),
+              validatorAddress: existing.validatorAddress ?? validator?.address,
+              validatorName: existing.validatorName ?? validator?.name,
+              validatorLogo: existing.validatorLogo ?? validator?.logoURI,
+            })
+          } else {
+            accountBalances.set(accountId, {
+              totalUsd: amountUsd,
+              totalCrypto: amount,
+              validatorAddress: validator?.address,
+              validatorName: validator?.name,
+              validatorLogo: validator?.logoURI,
+            })
+          }
+        }
+
+        for (const [accountId, balanceInfo] of accountBalances) {
+          positions.push({
+            accountId,
+            accountLabel: accountIdToLabel(accountId),
+            yieldItem,
+            providerId: yieldItem.providerId,
+            providerLogo: getProviderLogo(yieldItem.providerId),
+            apy: bnOrZero(yieldItem.rewardRate.total).times(100).toNumber(),
+            totalUsd: balanceInfo.totalUsd,
+            totalCrypto: balanceInfo.totalCrypto,
+            validatorAddress: balanceInfo.validatorAddress,
+            validatorName: balanceInfo.validatorName,
+            validatorLogo: balanceInfo.validatorLogo,
+          })
+        }
+      }
 
-    const balanceColumnHeader = useMemo(
-      () => translate('yieldXYZ.balance') ?? 'Balance',
-      [translate],
+      return positions.sort((a, b) => bnOrZero(b.totalUsd).minus(a.totalUsd).toNumber())
+    }, [balancesByYieldId, yields, asset, getProviderLogo])
+
+    const handlePositionClick = useCallback(
+      ({ yieldId, accountId, validatorAddress }: HandlePositionClickArgs) => {
+        const params = new URLSearchParams()
+        params.set('accountId', accountId)
+        if (validatorAddress) params.set('validator', validatorAddress)
+        navigate(`/yields/${yieldId}?${params.toString()}`)
+      },
+      [navigate],
     )
 
     const tableRows = useMemo(() => {
       if (!asset) return null
 
-      return activeYields.flatMap(yieldItem => {
-        const yieldAggregate = aggregated[yieldItem.id]
-        if (!yieldAggregate) return []
-
-        const apy = bnOrZero(yieldItem.rewardRate.total).times(100).toNumber()
-        const { byValidator, hasValidators, totalUsd, totalCrypto } = yieldAggregate
-
-        if (hasValidators) {
-          return Object.values(byValidator).map(
-            ({ validator, totalUsd: validatorUsd, totalCrypto: validatorCrypto }) => {
-              const totalUserCurrency = toUserCurrency(validatorUsd, userCurrencyToUsdRate)
-
-              return (
-                <Tr
-                  key={`${yieldItem.id}-${validator.address}`}
-                  _hover={{ bg: 'background.surface.raised.base', cursor: 'pointer' }}
-                  onClick={() => handleRowClick(yieldItem.id, validator.address)}
-                >
-                  <Td>
-                    <HStack spacing={2}>
-                      {validator.logoURI ? (
-                        <Avatar src={validator.logoURI} size='xs' name={validator.name} />
-                      ) : (
-                        <Avatar
-                          size='xs'
-                          src={getProviderLogo(yieldItem.providerId)}
-                          name={yieldItem.providerId}
-                        />
-                      )}
-                      <Text fontSize='sm' textTransform='capitalize'>
-                        {validator.name || yieldItem.providerId}
-                      </Text>
-                    </HStack>
-                  </Td>
-                  <Td isNumeric>
-                    <Text
-                      fontWeight='bold'
-                      fontSize='md'
-                      bgGradient='linear(to-r, green.300, blue.400)'
-                      bgClip='text'
-                    >
-                      {apy.toFixed(2)}%
-                    </Text>
-                  </Td>
-                  <Td isNumeric>
-                    <Text fontSize='sm' color='text.subtle'>
-                      -
-                    </Text>
-                  </Td>
-                  <Td isNumeric>
-                    <Box textAlign='right'>
-                      <Amount.Fiat value={totalUserCurrency} fontWeight='bold' color='green.400' />
-                      <Amount.Crypto
-                        value={validatorCrypto}
-                        symbol={asset.symbol}
-                        color='text.subtle'
-                        fontSize='xs'
-                      />
-                    </Box>
-                  </Td>
-                </Tr>
-              )
-            },
-          )
-        }
-
-        const totalUserCurrency = toUserCurrency(totalUsd, userCurrencyToUsdRate)
-        const tvlUsd = yieldItem.statistics?.tvlUsd
-        const tvlUserCurrency = toUserCurrency(tvlUsd, userCurrencyToUsdRate)
+      return accountPositions.map(position => {
+        const totalUserCurrency = bnOrZero(position.totalUsd).times(userCurrencyToUsdRate).toFixed()
+        const displayName = position.validatorName ?? getProviderName(position.providerId)
+        const displayLogo = position.validatorLogo ?? position.providerLogo
 
         return (
           <Tr
-            key={yieldItem.id}
-            _hover={{ bg: 'background.surface.raised.base', cursor: 'pointer' }}
-            onClick={() => handleRowClick(yieldItem.id)}
+            key={`${position.yieldItem.id}-${position.accountId}`}
+            _hover={hoverSx}
+            onClick={() =>
+              handlePositionClick({
+                yieldId: position.yieldItem.id,
+                accountId: position.accountId,
+                validatorAddress: position.validatorAddress,
+              })
+            }
           >
             <Td>
               <HStack spacing={2}>
                 <Avatar
                   size='xs'
-                  src={getProviderLogo(yieldItem.providerId)}
-                  name={yieldItem.providerId}
+                  src={displayLogo}
+                  name={displayName}
+                  bg='background.surface.raised.base'
                 />
-                <Text fontSize='sm' textTransform='capitalize'>
-                  {yieldItem.providerId}
-                </Text>
+                <Box>
+                  <Text fontSize='sm' textTransform='capitalize' fontWeight='medium'>
+                    {displayName}
+                  </Text>
+                  <RawText fontSize='xs' color='text.subtle' fontFamily='monospace'>
+                    {position.accountLabel}
+                  </RawText>
+                </Box>
               </HStack>
             </Td>
             <Td isNumeric>
@@ -180,19 +194,14 @@ export const YieldActivePositions = memo(
                 bgGradient='linear(to-r, green.300, blue.400)'
                 bgClip='text'
               >
-                {apy.toFixed(2)}%
-              </Text>
-            </Td>
-            <Td isNumeric>
-              <Text fontSize='sm' color='text.subtle'>
-                {tvlUsd ? <Amount.Fiat value={tvlUserCurrency} abbreviated /> : '-'}
+                {position.apy.toFixed(2)}%
               </Text>
             </Td>
             <Td isNumeric>
               <Box textAlign='right'>
                 <Amount.Fiat value={totalUserCurrency} fontWeight='bold' color='green.400' />
                 <Amount.Crypto
-                  value={totalCrypto}
+                  value={position.totalCrypto}
                   symbol={asset.symbol}
                   color='text.subtle'
                   fontSize='xs'
@@ -202,25 +211,95 @@ export const YieldActivePositions = memo(
           </Tr>
         )
       })
-    }, [activeYields, aggregated, asset, getProviderLogo, handleRowClick, userCurrencyToUsdRate])
+    }, [accountPositions, asset, getProviderName, handlePositionClick, userCurrencyToUsdRate])
+
+    const mobileRows = useMemo(() => {
+      if (!asset) return []
+
+      return accountPositions.map(position => {
+        const totalUserCurrency = bnOrZero(position.totalUsd).times(userCurrencyToUsdRate).toFixed()
+        const displayName = position.validatorName ?? getProviderName(position.providerId)
+        const displayLogo = position.validatorLogo ?? position.providerLogo
+
+        return (
+          <Box
+            key={`${position.yieldItem.id}-${position.accountId}-mobile`}
+            borderWidth='1px'
+            borderColor='border.base'
+            borderRadius='xl'
+            p={4}
+            bg='background.surface.raised.base'
+            onClick={() =>
+              handlePositionClick({
+                yieldId: position.yieldItem.id,
+                accountId: position.accountId,
+                validatorAddress: position.validatorAddress,
+              })
+            }
+          >
+            <HStack justifyContent='space-between' alignItems='center' mb={2} spacing={3}>
+              <HStack spacing={2} alignItems='center'>
+                <Avatar
+                  size='sm'
+                  src={displayLogo}
+                  name={displayName}
+                  bg='background.surface.raised.base'
+                />
+                <Box>
+                  <Text fontWeight='semibold' fontSize='sm'>
+                    {displayName}
+                  </Text>
+                  <RawText fontSize='xs' color='text.subtle' fontFamily='monospace'>
+                    {position.accountLabel}
+                  </RawText>
+                </Box>
+              </HStack>
+              <Text
+                fontWeight='bold'
+                fontSize='md'
+                bgGradient='linear(to-r, green.300, blue.400)'
+                bgClip='text'
+              >
+                {position.apy.toFixed(2)}%
+              </Text>
+            </HStack>
+            <Box textAlign='right'>
+              <Amount.Fiat value={totalUserCurrency} fontWeight='bold' color='green.400' />
+              <Amount.Crypto
+                value={position.totalCrypto}
+                symbol={asset.symbol}
+                color='text.subtle'
+                fontSize='xs'
+              />
+            </Box>
+          </Box>
+        )
+      })
+    }, [accountPositions, asset, getProviderName, handlePositionClick, userCurrencyToUsdRate])
 
     if (!asset) return null
-    if (activeYields.length === 0) return null
+    if (accountPositions.length === 0) return null
 
     return (
-      <TableContainer borderWidth='1px' borderColor='border.base' borderRadius='xl'>
-        <Table variant='simple'>
-          <Thead bg='background.surface.raised.base'>
-            <Tr>
-              <Th>{providerColumnHeader}</Th>
-              <Th isNumeric>{apyColumnHeader}</Th>
-              <Th isNumeric>{tvlColumnHeader}</Th>
-              <Th isNumeric>{balanceColumnHeader}</Th>
-            </Tr>
-          </Thead>
-          <Tbody>{tableRows}</Tbody>
-        </Table>
-      </TableContainer>
+      <>
+        <Display.Desktop>
+          <TableContainer borderWidth='1px' borderColor='border.base' borderRadius='xl'>
+            <Table variant='simple' size='sm'>
+              <Thead bg='background.surface.raised.base'>
+                <Tr>
+                  <Th>{translate('yieldXYZ.provider')}</Th>
+                  <Th isNumeric>{translate('yieldXYZ.apy')}</Th>
+                  <Th isNumeric>{translate('yieldXYZ.balance')}</Th>
+                </Tr>
+              </Thead>
+              <Tbody>{tableRows}</Tbody>
+            </Table>
+          </TableContainer>
+        </Display.Desktop>
+        <Display.Mobile>
+          <Stack spacing={3}>{mobileRows}</Stack>
+        </Display.Mobile>
+      </>
     )
   },
 )
diff --git a/src/pages/Yields/components/YieldAssetSection.tsx b/src/pages/Yields/components/YieldAssetSection.tsx
index fdeb1c864c0..b8f1a10ee1d 100644
--- a/src/pages/Yields/components/YieldAssetSection.tsx
+++ b/src/pages/Yields/components/YieldAssetSection.tsx
@@ -9,13 +9,14 @@ import { YieldEnterModal } from './YieldEnterModal'
 import { YieldItemSkeleton } from './YieldItem'
 import { YieldOpportunityCard } from './YieldOpportunityCard'
 
-import { getConfig } from '@/config'
 import { useFeatureFlag } from '@/hooks/useFeatureFlag/useFeatureFlag'
 import { useWallet } from '@/hooks/useWallet/useWallet'
 import type { AugmentedYieldDto } from '@/lib/yieldxyz/types'
-import type { YieldBalanceAggregate } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
+import type { AugmentedYieldBalanceWithAccountId } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
 import { useAllYieldBalances } from '@/react-queries/queries/yieldxyz/useAllYieldBalances'
 import { useYields } from '@/react-queries/queries/yieldxyz/useYields'
+import { selectEnabledWalletAccountIds } from '@/state/slices/selectors'
+import { useAppSelector } from '@/state/store'
 
 const LoadingContent = (
   <VStack spacing={4} align='stretch'>
@@ -32,11 +33,15 @@ type YieldAssetSectionProps = {
 export const YieldAssetSection = memo(({ assetId, accountId }: YieldAssetSectionProps) => {
   const translate = useTranslate()
   const isYieldXyzEnabled = useFeatureFlag('YieldXyz')
+  const enabledWalletAccountIds = useAppSelector(selectEnabledWalletAccountIds)
   const {
     state: { isConnected },
   } = useWallet()
   const { data: yieldsData, isLoading: isYieldsLoading } = useYields()
-  const balanceOptions = useMemo(() => (accountId ? { accountIds: [accountId] } : {}), [accountId])
+  const balanceOptions = useMemo(
+    () => (accountId ? { accountIds: [accountId] } : { accountIds: enabledWalletAccountIds }),
+    [accountId, enabledWalletAccountIds],
+  )
   const { data: allBalancesData, isLoading: isBalancesLoading } =
     useAllYieldBalances(balanceOptions)
   const isLoading = isYieldsLoading || isBalancesLoading
@@ -53,30 +58,27 @@ export const YieldAssetSection = memo(({ assetId, accountId }: YieldAssetSection
     })
   }, [yieldsData, assetId])
 
-  const aggregated = useMemo(() => {
-    const multiAccountEnabled = getConfig().VITE_FEATURE_YIELD_MULTI_ACCOUNT
-    if (multiAccountEnabled && !accountId) {
-      console.warn('[YieldAssetSection] Multi-account yield enabled but no accountId provided')
-      return {}
-    }
-    if (!allBalancesData?.aggregated || !yields.length) return {}
+  const filteredBalancesByYieldId = useMemo(() => {
+    if (!allBalancesData?.byYieldId || !yields.length) return undefined
 
     const accountFilter = accountId ? fromAccountId(accountId).account.toLowerCase() : null
-    const allBalances = allBalancesData.byYieldId
-
-    return yields.reduce(
-      (acc, yieldItem) => {
-        const aggregate = allBalancesData.aggregated[yieldItem.id]
-        if (!aggregate) return acc
-        if (accountFilter) {
-          const itemBalances = allBalances?.[yieldItem.id] || []
-          if (!itemBalances.some(b => b.address.toLowerCase() === accountFilter)) return acc
-        }
-        acc[yieldItem.id] = aggregate
-        return acc
-      },
-      {} as Record<string, YieldBalanceAggregate>,
-    )
+    const relevantYieldIds = new Set(yields.map(y => y.id))
+
+    const result: Record<string, AugmentedYieldBalanceWithAccountId[]> = {}
+
+    for (const [yieldId, balances] of Object.entries(allBalancesData.byYieldId)) {
+      if (!relevantYieldIds.has(yieldId)) continue
+
+      const filteredBalances = accountFilter
+        ? balances.filter(b => b.address.toLowerCase() === accountFilter)
+        : balances
+
+      if (filteredBalances.length > 0) {
+        result[yieldId] = filteredBalances
+      }
+    }
+
+    return Object.keys(result).length > 0 ? result : undefined
   }, [allBalancesData, yields, accountId])
 
   const sortedYields = useMemo(
@@ -86,7 +88,7 @@ export const YieldAssetSection = memo(({ assetId, accountId }: YieldAssetSection
 
   const bestYield = sortedYields[0]
 
-  const hasActivePositions = Object.keys(aggregated).length > 0
+  const hasActivePositions = Boolean(filteredBalancesByYieldId)
 
   const handleOpportunityClick = useCallback((yieldItem: AugmentedYieldDto) => {
     setSelectedYield(yieldItem)
@@ -111,8 +113,13 @@ export const YieldAssetSection = memo(({ assetId, accountId }: YieldAssetSection
         <CardBody pt={0}>
           <Stack spacing={4}>
             {hasActivePositions && (
-              <YieldActivePositions aggregated={aggregated} yields={yields} assetId={assetId} />
+              <YieldActivePositions
+                balancesByYieldId={filteredBalancesByYieldId}
+                yields={yields}
+                assetId={assetId}
+              />
             )}
+
             {isLoading && LoadingContent}
             {!isLoading && !hasActivePositions && bestYield && (
               <YieldOpportunityCard maxApyYield={bestYield} onClick={handleOpportunityClick} />
@@ -125,6 +132,7 @@ export const YieldAssetSection = memo(({ assetId, accountId }: YieldAssetSection
           isOpen={isEnterModalOpen}
           onClose={handleEnterModalClose}
           yieldItem={selectedYield}
+          accountId={accountId}
         />
       )}
     </>
diff --git a/src/pages/Yields/components/YieldEnterModal.tsx b/src/pages/Yields/components/YieldEnterModal.tsx
index 64ee396aafb..e486c288a46 100644
--- a/src/pages/Yields/components/YieldEnterModal.tsx
+++ b/src/pages/Yields/components/YieldEnterModal.tsx
@@ -1,4 +1,5 @@
 import { Avatar, Box, Button, Flex, HStack, Icon, Input, Skeleton, Text } from '@chakra-ui/react'
+import type { AccountId } from '@shapeshiftoss/caip'
 import { useQueryClient } from '@tanstack/react-query'
 import type { ChangeEvent } from 'react'
 import { memo, useCallback, useMemo, useState } from 'react'
@@ -38,6 +39,7 @@ import { useYieldValidators } from '@/react-queries/queries/yieldxyz/useYieldVal
 import { allowedDecimalSeparators } from '@/state/slices/preferencesSlice/preferencesSlice'
 import {
   selectAccountIdByAccountNumberAndChainId,
+  selectAccountNumberByAccountId,
   selectAssetById,
   selectMarketDataByAssetIdUserCurrency,
   selectPortfolioAccountIdsByAssetIdFilter,
@@ -49,6 +51,7 @@ type YieldEnterModalProps = {
   isOpen: boolean
   onClose: () => void
   yieldItem: AugmentedYieldDto
+  accountId?: AccountId
   accountNumber?: number
 }
 
@@ -106,7 +109,13 @@ const YieldEnterModalSkeleton = memo(() => (
 ))
 
 export const YieldEnterModal = memo(
-  ({ isOpen, onClose, yieldItem, accountNumber = 0 }: YieldEnterModalProps) => {
+  ({
+    isOpen,
+    onClose,
+    yieldItem,
+    accountId: accountIdProp,
+    accountNumber,
+  }: YieldEnterModalProps) => {
     const queryClient = useQueryClient()
     const translate = useTranslate()
     const { state: walletState, dispatch: walletDispatch } = useWallet()
@@ -118,7 +127,7 @@ export const YieldEnterModal = memo(
 
     const [cryptoAmount, setCryptoAmount] = useState('')
     const [isFiat, setIsFiat] = useState(false)
-    const [selectedAccountId, setSelectedAccountId] = useState<string | undefined>()
+    const [selectedAccountId, setSelectedAccountId] = useState<AccountId | undefined>(accountIdProp)
     const [selectedPercent, setSelectedPercent] = useState<number | null>(null)
 
     const { chainId } = yieldItem
@@ -133,13 +142,21 @@ export const YieldEnterModal = memo(
       selectPortfolioAccountIdsByAssetIdFilter(state, accountIdFilter),
     )
 
+    const derivedAccountNumber = useAppSelector(state => {
+      if (accountNumber !== undefined) return accountNumber
+      if (accountIdProp) return selectAccountNumberByAccountId(state, { accountId: accountIdProp })
+      return undefined
+    })
+
     const defaultAccountId = useAppSelector(state => {
+      if (accountIdProp) return accountIdProp
       if (!chainId) return undefined
+      if (derivedAccountNumber === undefined) return undefined
       const accountIdsByNumberAndChain = selectAccountIdByAccountNumberAndChainId(state)
-      return accountIdsByNumberAndChain[accountNumber]?.[chainId]
+      return accountIdsByNumberAndChain[derivedAccountNumber]?.[chainId]
     })
 
-    const accountId = selectedAccountId ?? defaultAccountId
+    const accountId = selectedAccountId ?? defaultAccountId ?? accountIds[0]
     const hasMultipleAccounts = accountIds.length > 1
     const isAccountSelectorDisabled = !isYieldMultiAccountEnabled || !hasMultipleAccounts
 
@@ -567,6 +584,7 @@ export const YieldEnterModal = memo(
           providerInfo={successProviderInfo}
           transactionSteps={transactionSteps}
           yieldId={yieldItem.id}
+          accountId={accountId}
           onDone={hookHandleClose}
           successMessageKey='successEnter'
         />
@@ -577,6 +595,7 @@ export const YieldEnterModal = memo(
         successProviderInfo,
         transactionSteps,
         yieldItem.id,
+        accountId,
         hookHandleClose,
       ],
     )
@@ -610,7 +629,7 @@ export const YieldEnterModal = memo(
                     assetId={inputTokenAssetId}
                     accountId={accountId}
                     onChange={handleAccountChange}
-                    disabled={isAccountSelectorDisabled}
+                    disabled={isAccountSelectorDisabled || isSubmitting}
                   />
                 </Flex>
               )}
diff --git a/src/pages/Yields/components/YieldForm.tsx b/src/pages/Yields/components/YieldForm.tsx
index 01e725c24f3..cfa9923af65 100644
--- a/src/pages/Yields/components/YieldForm.tsx
+++ b/src/pages/Yields/components/YieldForm.tsx
@@ -1,4 +1,5 @@
 import { Avatar, Box, Button, Flex, HStack, Icon, Input, Skeleton, Text } from '@chakra-ui/react'
+import type { AccountId } from '@shapeshiftoss/caip'
 import { useQueryClient } from '@tanstack/react-query'
 import type { ChangeEvent } from 'react'
 import { memo, useCallback, useEffect, useMemo, useState } from 'react'
@@ -34,6 +35,7 @@ import { useYieldValidators } from '@/react-queries/queries/yieldxyz/useYieldVal
 import { allowedDecimalSeparators } from '@/state/slices/preferencesSlice/preferencesSlice'
 import {
   selectAccountIdByAccountNumberAndChainId,
+  selectAccountNumberByAccountId,
   selectAssetById,
   selectMarketDataByAssetIdUserCurrency,
   selectPortfolioAccountIdsByAssetIdFilter,
@@ -46,6 +48,7 @@ type YieldFormProps = {
   balances?: NormalizedYieldBalances
   action: 'enter' | 'exit' | 'claim'
   validatorAddress?: string
+  accountId?: AccountId
   accountNumber?: number
   onClose: () => void
   onDone?: () => void
@@ -141,7 +144,8 @@ export const YieldForm = memo(
     balances,
     action,
     validatorAddress,
-    accountNumber = 0,
+    accountId: accountIdProp,
+    accountNumber,
     onClose,
     onDone,
   }: YieldFormProps) => {
@@ -156,7 +160,7 @@ export const YieldForm = memo(
 
     const [cryptoAmount, setCryptoAmount] = useState('')
     const [isFiat, setIsFiat] = useState(false)
-    const [selectedAccountId, setSelectedAccountId] = useState<string | undefined>()
+    const [selectedAccountId, setSelectedAccountId] = useState<AccountId | undefined>(accountIdProp)
     const [selectedPercent, setSelectedPercent] = useState<number | null>(null)
 
     const { chainId } = yieldItem
@@ -181,10 +185,18 @@ export const YieldForm = memo(
       selectPortfolioAccountIdsByAssetIdFilter(state, accountIdFilter),
     )
 
+    const derivedAccountNumber = useAppSelector(state => {
+      if (accountNumber !== undefined) return accountNumber
+      if (accountIdProp)
+        return selectAccountNumberByAccountId(state, { accountId: accountIdProp }) ?? 0
+      return 0
+    })
+
     const defaultAccountId = useAppSelector(state => {
+      if (accountIdProp) return accountIdProp
       if (!chainId) return undefined
       const accountIdsByNumberAndChain = selectAccountIdByAccountNumberAndChainId(state)
-      return accountIdsByNumberAndChain[accountNumber]?.[chainId]
+      return accountIdsByNumberAndChain[derivedAccountNumber]?.[chainId]
     })
 
     const accountId = selectedAccountId ?? defaultAccountId
@@ -365,7 +377,7 @@ export const YieldForm = memo(
       else onClose()
     }, [onClose, onDone, queryClient, yieldItem.id, action])
 
-    const handleAccountChange = useCallback((newAccountId: string) => {
+    const handleAccountChange = useCallback((newAccountId: AccountId) => {
       setSelectedAccountId(newAccountId)
       setCryptoAmount('')
       setSelectedPercent(null)
@@ -714,6 +726,7 @@ export const YieldForm = memo(
           providerInfo={successProviderInfo}
           transactionSteps={transactionSteps}
           yieldId={yieldItem.id}
+          accountId={accountId}
           onDone={handleFormDone}
           successMessageKey={successMessageKey}
         />
@@ -731,7 +744,7 @@ export const YieldForm = memo(
                 assetId={inputTokenAssetId}
                 accountId={accountId}
                 onChange={handleAccountChange}
-                disabled={isAccountSelectorDisabled}
+                disabled={isAccountSelectorDisabled || isSubmitting}
               />
             </Flex>
           )}
diff --git a/src/pages/Yields/components/YieldManager.tsx b/src/pages/Yields/components/YieldManager.tsx
index 70dd74070bd..cde4826198e 100644
--- a/src/pages/Yields/components/YieldManager.tsx
+++ b/src/pages/Yields/components/YieldManager.tsx
@@ -43,7 +43,7 @@ export const YieldManager = () => {
     }
     return validatorParam
   }, [yieldId, yieldItem?.chainId, validatorParam])
-  const { accountNumber } = useYieldAccount()
+  const { accountId, accountNumber } = useYieldAccount()
   const { data: allBalancesData } = useAllYieldBalances()
   const balances = yieldItem?.id ? allBalancesData?.normalized[yieldItem.id] : undefined
 
@@ -87,6 +87,7 @@ export const YieldManager = () => {
           balances={balances}
           action={action ?? 'enter'}
           validatorAddress={validatorAddress}
+          accountId={accountId}
           accountNumber={accountNumber}
           onClose={() => navigate(-1)}
           onDone={() => navigate(-1)}
diff --git a/src/pages/Yields/components/YieldOpportunityStats.tsx b/src/pages/Yields/components/YieldOpportunityStats.tsx
index 82537251a9a..04d927d5c6c 100644
--- a/src/pages/Yields/components/YieldOpportunityStats.tsx
+++ b/src/pages/Yields/components/YieldOpportunityStats.tsx
@@ -55,8 +55,10 @@ export const YieldOpportunityStats = memo(function YieldOpportunityStats({
     return positions.reduce((acc, position) => {
       const positionBalances = balances?.[position.id]
       if (!positionBalances) return acc
-      const activeBalance = positionBalances.find(b => b.type === 'active' || b.type === 'locked')
-      return acc.plus(bnOrZero(activeBalance?.amountUsd))
+      const activeBalances = positionBalances.filter(
+        b => b.type === 'active' || b.type === 'locked',
+      )
+      return activeBalances.reduce((sum, b) => sum.plus(bnOrZero(b.amountUsd)), acc)
     }, bnOrZero(0))
   }, [positions, balances])
 
diff --git a/src/pages/Yields/components/YieldPositionCard.tsx b/src/pages/Yields/components/YieldPositionCard.tsx
index 3595f47aea2..143b6da39d5 100644
--- a/src/pages/Yields/components/YieldPositionCard.tsx
+++ b/src/pages/Yields/components/YieldPositionCard.tsx
@@ -52,12 +52,13 @@ export const YieldPositionCard = memo(
     const validatorParam = searchParams.get('validator')
 
     const { chainId } = yieldItem
-    const { accountNumber } = useYieldAccount()
+    const { accountId: contextAccountId, accountNumber } = useYieldAccount()
 
     const defaultValidator = chainId ? DEFAULT_NATIVE_VALIDATOR_BY_CHAIN_ID[chainId] : undefined
     const selectedValidatorAddress = validatorParam || defaultValidator
 
     const accountId = useAppSelector(state => {
+      if (contextAccountId) return contextAccountId
       if (!chainId) return undefined
       const accountIdsByNumberAndChain = selectAccountIdByAccountNumberAndChainId(state)
       return accountIdsByNumberAndChain[accountNumber]?.[chainId]
diff --git a/src/pages/Yields/components/YieldSuccess.tsx b/src/pages/Yields/components/YieldSuccess.tsx
index 588d1469551..578a2837473 100644
--- a/src/pages/Yields/components/YieldSuccess.tsx
+++ b/src/pages/Yields/components/YieldSuccess.tsx
@@ -1,4 +1,5 @@
 import { Avatar, Box, Button, Flex, Heading, Icon, Text, VStack } from '@chakra-ui/react'
+import type { AccountId } from '@shapeshiftoss/caip'
 import { memo, useCallback, useEffect, useMemo } from 'react'
 import ReactCanvasConfetti from 'react-canvas-confetti'
 import { FaCheck } from 'react-icons/fa'
@@ -20,6 +21,7 @@ type YieldSuccessProps = {
   providerInfo: ProviderInfo | null
   transactionSteps: TransactionStep[]
   yieldId?: string
+  accountId?: AccountId
   onDone: () => void
   showConfetti?: boolean
   successMessageKey?: 'successEnter' | 'successExit' | 'successClaim'
@@ -32,6 +34,7 @@ export const YieldSuccess = memo(
     providerInfo,
     transactionSteps,
     yieldId,
+    accountId,
     onDone,
     showConfetti = true,
     successMessageKey = 'successEnter',
@@ -46,8 +49,11 @@ export const YieldSuccess = memo(
 
     const handleViewPosition = useCallback(() => {
       if (!yieldId) return
-      navigate(`/yields/${yieldId}`)
-    }, [yieldId, navigate])
+      const params = new URLSearchParams()
+      if (accountId) params.set('accountId', accountId)
+      const queryString = params.toString()
+      navigate(queryString ? `/yields/${yieldId}?${queryString}` : `/yields/${yieldId}`)
+    }, [yieldId, accountId, navigate])
 
     const providerPillProps = useMemo(
       () =>
diff --git a/src/pages/Yields/components/YieldsList.tsx b/src/pages/Yields/components/YieldsList.tsx
index 2b4cb68b625..bda30387abe 100644
--- a/src/pages/Yields/components/YieldsList.tsx
+++ b/src/pages/Yields/components/YieldsList.tsx
@@ -57,6 +57,7 @@ import { useYieldProviders } from '@/react-queries/queries/yieldxyz/useYieldProv
 import { useYields } from '@/react-queries/queries/yieldxyz/useYields'
 import {
   selectAssets,
+  selectEnabledWalletAccountIds,
   selectPortfolioAssetBalancesBaseUnit,
   selectPortfolioUserCurrencyBalances,
   selectUserCurrencyToUsdRate,
@@ -70,6 +71,7 @@ export const YieldsList = memo(() => {
   const navigate = useNavigate()
   const { state: walletState } = useWallet()
   const isConnected = useMemo(() => Boolean(walletState.walletInfo), [walletState.walletInfo])
+  const enabledWalletAccountIds = useAppSelector(selectEnabledWalletAccountIds)
   const [isMobile] = useMediaQuery('(max-width: 768px)')
   const [searchParams, setSearchParams] = useSearchParams()
   const tabParam = useMemo(() => searchParams.get('tab'), [searchParams])
@@ -122,8 +124,9 @@ export const YieldsList = memo(() => {
     provider: selectedProvider || undefined,
   })
 
-  // TODO: Multi-account support - currently defaulting to account 0
-  const { data: allBalancesData, isFetching: isLoadingBalances } = useAllYieldBalances()
+  const { data: allBalancesData, isFetching: isLoadingBalances } = useAllYieldBalances({
+    accountIds: enabledWalletAccountIds,
+  })
   const allBalances = allBalancesData?.byYieldId
   const { data: yieldProviders } = useYieldProviders()
 
@@ -1046,10 +1049,19 @@ export const YieldsList = memo(() => {
   return (
     <Container maxW='1200px' py={8} px={{ base: 4, md: 6 }}>
       <Box mb={8}>
-        <Heading as='h2' size='xl' mb={2}>
-          {translate('yieldXYZ.pageTitle')}
-        </Heading>
-        {!isMobile && <Text color='text.subtle'>{translate('yieldXYZ.pageSubtitle')}</Text>}
+        <Flex
+          justifyContent='space-between'
+          alignItems={{ base: 'flex-start', md: 'center' }}
+          direction={{ base: 'column', md: 'row' }}
+          gap={4}
+        >
+          <Box>
+            <Heading as='h2' size='xl' mb={2}>
+              {translate('yieldXYZ.pageTitle')}
+            </Heading>
+            {!isMobile && <Text color='text.subtle'>{translate('yieldXYZ.pageSubtitle')}</Text>}
+          </Box>
+        </Flex>
       </Box>
       {errorElement}
       {isConnected && (
diff --git a/src/pages/Yields/hooks/useYieldAccountSync.ts b/src/pages/Yields/hooks/useYieldAccountSync.ts
new file mode 100644
index 00000000000..3f651f232f8
--- /dev/null
+++ b/src/pages/Yields/hooks/useYieldAccountSync.ts
@@ -0,0 +1,65 @@
+import type { AccountId } from '@shapeshiftoss/caip'
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+import { useSearchParams } from 'react-router-dom'
+
+import { useYieldAccount } from '@/pages/Yields/YieldAccountContext'
+
+type UseYieldAccountSyncOptions = {
+  availableAccountIds: AccountId[]
+}
+
+type UseYieldAccountSyncReturn = {
+  selectedAccountId: AccountId | undefined
+  handleAccountChange: (accountId: AccountId) => void
+}
+
+export const useYieldAccountSync = ({
+  availableAccountIds,
+}: UseYieldAccountSyncOptions): UseYieldAccountSyncReturn => {
+  const [searchParams, setSearchParams] = useSearchParams()
+  const { accountId: contextAccountId, setAccountId } = useYieldAccount()
+
+  const accountIdParam = useMemo(() => searchParams.get('accountId') ?? undefined, [searchParams])
+
+  const selectedAccountId = useMemo(() => {
+    if (contextAccountId && availableAccountIds.includes(contextAccountId)) return contextAccountId
+    if (accountIdParam && availableAccountIds.includes(accountIdParam)) return accountIdParam
+    return availableAccountIds[0]
+  }, [contextAccountId, accountIdParam, availableAccountIds])
+
+  const prevSelectedRef = useRef<AccountId | undefined>(undefined)
+
+  useEffect(() => {
+    if (!selectedAccountId) return
+    if (contextAccountId === selectedAccountId) return
+    setAccountId(selectedAccountId)
+  }, [contextAccountId, selectedAccountId, setAccountId])
+
+  useEffect(() => {
+    if (!selectedAccountId) return
+    if (prevSelectedRef.current === selectedAccountId) return
+    prevSelectedRef.current = selectedAccountId
+
+    setSearchParams(
+      prev => {
+        if (prev.get('accountId') === selectedAccountId) return prev
+        const next = new URLSearchParams(prev)
+        next.set('accountId', selectedAccountId)
+        return next
+      },
+      { replace: true },
+    )
+  }, [selectedAccountId, setSearchParams])
+
+  const handleAccountChange = useCallback(
+    (newAccountId: AccountId) => {
+      setAccountId(newAccountId)
+    },
+    [setAccountId],
+  )
+
+  return {
+    selectedAccountId,
+    handleAccountChange,
+  }
+}
diff --git a/src/pages/Yields/hooks/useYieldTransactionFlow.ts b/src/pages/Yields/hooks/useYieldTransactionFlow.ts
index 81da1f75a1f..ac0c2266c4c 100644
--- a/src/pages/Yields/hooks/useYieldTransactionFlow.ts
+++ b/src/pages/Yields/hooks/useYieldTransactionFlow.ts
@@ -184,15 +184,17 @@ export const useYieldTransactionFlow = ({
   const inputTokenAssetId = useMemo(() => yieldItem?.inputTokens?.[0]?.assetId, [yieldItem])
 
   const yieldChainId = yieldItem?.chainId
-  const { accountNumber: contextAccountNumber } = useYieldAccount()
+  const { accountId: contextAccountId, accountNumber: contextAccountNumber } = useYieldAccount()
 
   const derivedAccountId = useAppSelector(state => {
-    if (accountIdProp) return undefined
+    if (accountIdProp) return accountIdProp
+    if (contextAccountId) return contextAccountId
     if (!yieldChainId) return undefined
+    if (contextAccountNumber === undefined) return undefined
     return selectAccountIdByAccountNumberAndChainId(state)[contextAccountNumber]?.[yieldChainId]
   })
 
-  const accountId = accountIdProp ?? derivedAccountId
+  const accountId = derivedAccountId
 
   const feeAsset = useAppSelector(state =>
     yieldChainId ? selectFeeAssetByChainId(state, yieldChainId) : undefined,
diff --git a/src/react-queries/queries/yieldxyz/useAllYieldBalances.ts b/src/react-queries/queries/yieldxyz/useAllYieldBalances.ts
index 3dff9bf86c0..b98920d9a8b 100644
--- a/src/react-queries/queries/yieldxyz/useAllYieldBalances.ts
+++ b/src/react-queries/queries/yieldxyz/useAllYieldBalances.ts
@@ -17,12 +17,16 @@ import type {
 } from '@/lib/yieldxyz/types'
 import { YieldBalanceType as YieldBalanceTypeEnum } from '@/lib/yieldxyz/types'
 import { useYieldAccount } from '@/pages/Yields/YieldAccountContext'
-import { selectAccountIdsByAccountNumberAndChainId } from '@/state/slices/selectors'
+import {
+  selectAccountIdsByAccountNumberAndChainId,
+  selectEnabledWalletAccountIds,
+} from '@/state/slices/selectors'
 import { useAppSelector } from '@/state/store'
 
 type UseAllYieldBalancesOptions = {
   networks?: YieldNetwork[]
   accountIds?: string[]
+  enabled?: boolean
 }
 
 export type AugmentedYieldBalanceWithAccountId = AugmentedYieldBalance & {
@@ -216,30 +220,37 @@ const normalizeBalances = (
 }
 
 export const useAllYieldBalances = (options: UseAllYieldBalancesOptions = {}) => {
-  const { networks = SUPPORTED_YIELD_NETWORKS, accountIds: filterAccountIds } = options
+  const { networks = SUPPORTED_YIELD_NETWORKS, accountIds: filterAccountIds, enabled } = options
+  const isEnabled = enabled ?? true
   const { state: walletState } = useWallet()
   const isConnected = Boolean(walletState.walletInfo)
-  const { accountNumber } = useYieldAccount()
+  const { accountId: contextAccountId, accountNumber } = useYieldAccount()
   const accountIdsByAccountNumberAndChainId = useAppSelector(
     selectAccountIdsByAccountNumberAndChainId,
   )
+  const enabledWalletAccountIds = useAppSelector(selectEnabledWalletAccountIds)
 
   const accountIdsForAccountNumber = useMemo((): AccountId[] => {
+    if (accountNumber === undefined) return []
     const byChainId = accountIdsByAccountNumberAndChainId[accountNumber]
     if (!byChainId) return []
     return Object.values(byChainId).flat().filter(isSome)
   }, [accountIdsByAccountNumberAndChainId, accountNumber])
 
+  const targetAccountIds: AccountId[] = useMemo(() => {
+    if (filterAccountIds?.length) return filterAccountIds
+    if (contextAccountId) return [contextAccountId]
+    if (accountIdsForAccountNumber.length) return accountIdsForAccountNumber
+    return enabledWalletAccountIds
+  }, [filterAccountIds, contextAccountId, accountIdsForAccountNumber, enabledWalletAccountIds])
+
   const queryPayloads = useMemo(() => {
-    if (!isConnected || accountIdsForAccountNumber.length === 0) return []
+    if (!isConnected || targetAccountIds.length === 0) return []
 
-    const targetAccountIds = filterAccountIds ?? accountIdsForAccountNumber
     const payloads: { address: string; network: string; chainId: ChainId; accountId: AccountId }[] =
       []
 
     for (const accountId of targetAccountIds) {
-      if (!accountIdsForAccountNumber.includes(accountId)) continue
-
       const { chainId, account } = fromAccountId(accountId)
       const network = CHAIN_ID_TO_YIELD_NETWORK[chainId]
 
@@ -249,7 +260,7 @@ export const useAllYieldBalances = (options: UseAllYieldBalancesOptions = {}) =>
     }
 
     return payloads
-  }, [isConnected, accountIdsForAccountNumber, filterAccountIds, networks])
+  }, [isConnected, targetAccountIds, networks])
 
   const { addressToAccountId, addressToChainId } = useMemo(() => {
     const accountIdMap: Record<string, AccountId> = {}
@@ -323,6 +334,7 @@ export const useAllYieldBalances = (options: UseAllYieldBalancesOptions = {}) =>
           }
         : skipToken,
     staleTime: 60000,
+    enabled: isEnabled,
   })
 
   const data = useMemo(() => {
diff --git a/src/react-queries/queries/yieldxyz/useYields.ts b/src/react-queries/queries/yieldxyz/useYields.ts
index 1648414cc75..bffc8202420 100644
--- a/src/react-queries/queries/yieldxyz/useYields.ts
+++ b/src/react-queries/queries/yieldxyz/useYields.ts
@@ -50,7 +50,14 @@ const isLowQualityYield = (yieldItem: YieldDto): boolean => {
   return true // filter out - low TVL AND low APY
 }
 
-export const useYields = (params?: { network?: string; provider?: string }) => {
+type UseYieldsParams = {
+  network?: string
+  provider?: string
+  enabled?: boolean
+}
+
+export const useYields = (params?: UseYieldsParams) => {
+  const isEnabled = params?.enabled ?? true
   const { data: allYields, ...queryResult } = useQuery({
     queryKey: ['yieldxyz', 'yields'],
     queryFn: async () => {
@@ -82,6 +89,7 @@ export const useYields = (params?: { network?: string; provider?: string }) => {
       return qualityYields.filter(item => isSupportedYieldNetwork(item.network)).map(augmentYield)
     },
     staleTime: 5 * 60 * 1000,
+    enabled: isEnabled,
   })
 
   const assets = useAppSelector(selectAssets)
diff --git a/src/state/slices/opportunitiesSlice/resolvers/cosmosSdk/index.ts b/src/state/slices/opportunitiesSlice/resolvers/cosmosSdk/index.ts
index 046c5b17ad4..246d290dee0 100644
--- a/src/state/slices/opportunitiesSlice/resolvers/cosmosSdk/index.ts
+++ b/src/state/slices/opportunitiesSlice/resolvers/cosmosSdk/index.ts
@@ -24,6 +24,7 @@ import type { ReduxState } from '@/state/reducer'
 import { selectAssetById } from '@/state/slices/assetsSlice/selectors'
 import { selectEnabledWalletAccountIds } from '@/state/slices/common-selectors'
 import { selectMarketDataByAssetIdUserCurrency } from '@/state/slices/marketDataSlice/selectors'
+import { selectFeatureFlag } from '@/state/slices/preferencesSlice/selectors'
 
 export const cosmosSdkOpportunityIdsResolver = async ({
   reduxApi,
@@ -31,6 +32,9 @@ export const cosmosSdkOpportunityIdsResolver = async ({
   data: GetOpportunityIdsOutput
 }> => {
   const state = reduxApi.getState() as ReduxState
+  const isYieldXyzEnabled = selectFeatureFlag(state, 'YieldXyz')
+
+  if (isYieldXyzEnabled) return { data: [] }
 
   const portfolioAccountIds = selectEnabledWalletAccountIds(state)
 
@@ -77,6 +81,9 @@ export const cosmosSdkStakingOpportunitiesMetadataResolver = async ({
   data: GetOpportunityMetadataOutput
 }> => {
   const state = reduxApi.getState() as ReduxState
+  const isYieldXyzEnabled = selectFeatureFlag(state, 'YieldXyz')
+  if (isYieldXyzEnabled) return { data: { byId: {}, type: defiType } }
+
   const metadataByValidatorId = await Promise.allSettled(
     validatorIds.map(async validatorId => {
       const { account: validatorAddress, chainId } = fromAccountId(validatorId)
@@ -170,6 +177,13 @@ export const cosmosSdkStakingOpportunitiesUserDataResolver = async ({
   const emptyStakingOpportunitiesUserDataByUserStakingId: OpportunitiesState['userStaking']['byId'] =
     {}
 
+  const isYieldXyzEnabled = selectFeatureFlag(state, 'YieldXyz')
+  if (isYieldXyzEnabled) {
+    return Promise.resolve({
+      data: { byId: emptyStakingOpportunitiesUserDataByUserStakingId, type: defiType },
+    })
+  }
+
   try {
     const { account: pubKey, chainId } = fromAccountId(accountId)
     if (chainId !== cosmosChainId) {