diff --git a/components/entities/activity/ActivityAddress.vue b/components/entities/activity/ActivityAddress.vue
new file mode 100644
index 000000000..f56791fd2
--- /dev/null
+++ b/components/entities/activity/ActivityAddress.vue
@@ -0,0 +1,174 @@
+<script setup lang="ts">
+import type { ActivityVaultType } from '@eulerxyz/euler-v2-sdk'
+import { getExplorerLink } from '~/utils/block-explorer'
+import type { ActivityAddressLinkKind } from '~/utils/activity-display'
+import { shortenAddress } from '~/utils/string-utils'
+
+const props = withDefaults(defineProps<{
+  address: string
+  chainId: number
+  label?: string
+  linkKind?: ActivityAddressLinkKind
+  vaultType?: ActivityVaultType
+  compactVault?: boolean
+}>(), {
+  linkKind: 'explorer',
+  compactVault: false,
+})
+
+const route = useRoute()
+const { activateSpyMode } = useSpyMode()
+const {
+  getVault,
+  getType: getVaultType,
+  getOrFetch: getOrFetchVault,
+  getVaultCategory,
+  isVerifiedVault,
+  registryVersion,
+} = useVaultRegistry()
+const addressRef = toRef(props, 'address')
+const product = useEulerProductOfVault(addressRef)
+const copyKey = computed(() => `activity-address-${props.address.toLowerCase()}`)
+const explorerLink = computed(() => getExplorerLink(props.address, props.chainId, true))
+const resolvedVault = computed(() => {
+  void registryVersion.value
+  return props.linkKind === 'vault' ? getVault(props.address) : undefined
+})
+const resolvedVaultType = computed(() =>
+  getVaultType(props.address) ?? props.vaultType)
+const compactVaultName = computed(() => {
+  if (!resolvedVault.value) return props.label || shortenAddress(props.address)
+  if (getVaultCategory(resolvedVault.value.address) === 'escrow') {
+    return 'Escrowed collateral'
+  }
+  return product.name || resolvedVault.value.shares.name
+})
+const internalLink = computed(() => {
+  const query = typeof route.query.network === 'string'
+    ? { network: route.query.network }
+    : undefined
+  if (props.linkKind === 'spy') {
+    return { path: '/portfolio/activity', query: { ...query, spy: props.address } }
+  }
+  if (props.linkKind === 'vault') {
+    return {
+      path: resolvedVaultType.value === 'earn' ? `/earn/${props.address}` : `/lend/${props.address}`,
+      query,
+    }
+  }
+  return null
+})
+
+watch(
+  () => [props.address, props.linkKind] as const,
+  ([address, linkKind]) => {
+    if (linkKind === 'vault') void getOrFetchVault(address)
+  },
+  { immediate: true },
+)
+
+const fallbackCopy = (text: string) => {
+  const textarea = document.createElement('textarea')
+  textarea.value = text
+  textarea.setAttribute('readonly', '')
+  textarea.style.position = 'fixed'
+  textarea.style.opacity = '0'
+  document.body.appendChild(textarea)
+  textarea.select()
+  const copied = document.execCommand('copy')
+  document.body.removeChild(textarea)
+  return copied
+}
+
+const writeAddressToClipboard = async (address: string) => {
+  if (fallbackCopy(address)) return
+  if (navigator.clipboard?.writeText) await navigator.clipboard.writeText(address)
+  else throw new Error('Unable to copy address')
+}
+
+const { isCopied, copyToClipboard } = useClipboardCopy({ timeout: 5000, write: writeAddressToClipboard })
+
+const copyAddress = () => {
+  copyToClipboard(props.address, copyKey.value).catch(() => {})
+}
+
+const handleInternalClick = (event: MouseEvent) => {
+  if (
+    props.linkKind !== 'spy'
+    || event.button !== 0
+    || event.metaKey
+    || event.ctrlKey
+    || event.shiftKey
+    || event.altKey
+  ) return
+  activateSpyMode(props.address)
+}
+</script>
+
+<template>
+  <span class="inline-flex min-w-0 max-w-full items-center gap-2">
+    <NuxtLink
+      v-if="internalLink && resolvedVault && compactVault"
+      :to="internalLink"
+      class="inline-flex min-w-0 max-w-full items-center gap-6 rounded-8 transition-opacity hover:opacity-80"
+      :title="address"
+    >
+      <AssetAvatar
+        :asset="[resolvedVault.asset]"
+        size="20"
+      />
+      <span
+        class="min-w-0 truncate text-p4 text-content-secondary"
+        :title="compactVaultName"
+      >
+        <VaultDisplayName
+          :name="compactVaultName"
+          :is-unverified="!isVerifiedVault(resolvedVault.address)"
+        />
+      </span>
+      <span class="shrink-0 text-p4 font-medium text-content-primary">
+        {{ resolvedVault.asset.symbol }}
+      </span>
+    </NuxtLink>
+    <NuxtLink
+      v-else-if="internalLink && resolvedVault"
+      :to="internalLink"
+      class="inline-flex min-w-0 max-w-full rounded-8 transition-opacity hover:opacity-80"
+      :title="address"
+    >
+      <VaultLabelsAndAssets
+        :vault="resolvedVault"
+        :assets="[resolvedVault.asset]"
+        size="small"
+      />
+    </NuxtLink>
+    <NuxtLink
+      v-else-if="internalLink"
+      :to="internalLink"
+      class="min-w-0 truncate text-content-secondary transition-colors hover:text-accent-500 hover:underline"
+      :title="address"
+      @click="handleInternalClick"
+    >{{ label || shortenAddress(address) }}</NuxtLink>
+    <a
+      v-else
+      :href="explorerLink"
+      target="_blank"
+      rel="noopener noreferrer"
+      class="min-w-0 truncate text-content-secondary transition-colors hover:text-accent-500 hover:underline"
+      :title="address"
+    >{{ label || shortenAddress(address) }}</a>
+    <button
+      type="button"
+      class="inline-flex h-28 w-28 shrink-0 items-center justify-center rounded-6 text-content-muted transition-colors hover:bg-surface hover:text-content-primary"
+      :aria-label="isCopied(copyKey) ? `Copied address ${address}` : `Copy address ${address}`"
+      :title="isCopied(copyKey) ? 'Copied' : 'Copy address'"
+      @click.stop="copyAddress"
+    >
+      <SvgIcon
+        :name="isCopied(copyKey) ? 'check' : 'copy'"
+        class="!h-16 !w-16"
+        aria-hidden="true"
+      />
+    </button>
+  </span>
+</template>
diff --git a/components/entities/activity/ActivityCategoryFilters.vue b/components/entities/activity/ActivityCategoryFilters.vue
new file mode 100644
index 000000000..73c0c486d
--- /dev/null
+++ b/components/entities/activity/ActivityCategoryFilters.vue
@@ -0,0 +1,45 @@
+<script setup lang="ts">
+import type { ActivityFilterOption } from '~/utils/activity-display'
+
+const selected = defineModel<string[]>({ required: true })
+defineProps<{
+  options: readonly ActivityFilterOption[]
+}>()
+
+const selectAll = () => {
+  selected.value = []
+}
+
+const toggle = (filter: string) => {
+  selected.value = selected.value.includes(filter)
+    ? selected.value.filter(value => value !== filter)
+    : [...selected.value, filter]
+}
+</script>
+
+<template>
+  <div
+    class="flex max-w-full flex-wrap gap-8"
+    role="group"
+    aria-label="Activity categories"
+  >
+    <UiFilterChip
+      class="shrink-0"
+      :active="selected.length === 0"
+      :aria-pressed="selected.length === 0"
+      @click="selectAll"
+    >
+      All
+    </UiFilterChip>
+    <UiFilterChip
+      v-for="option in options"
+      :key="option.value"
+      class="shrink-0"
+      :active="selected.includes(option.value)"
+      :aria-pressed="selected.includes(option.value)"
+      @click="toggle(option.value)"
+    >
+      {{ option.count !== undefined ? `${option.label} (${option.count})` : option.label }}
+    </UiFilterChip>
+  </div>
+</template>
diff --git a/components/entities/activity/ActivityEventRow.vue b/components/entities/activity/ActivityEventRow.vue
new file mode 100644
index 000000000..29e3af50e
--- /dev/null
+++ b/components/entities/activity/ActivityEventRow.vue
@@ -0,0 +1,675 @@
+<script setup lang="ts">
+import type { ActivityCategory, ActivityEvent, LiquidationRecord } from '@eulerxyz/euler-v2-sdk'
+import { getAddress } from 'viem'
+import { getExplorerLink } from '~/utils/block-explorer'
+import {
+  getActivityAddressCollectionSummary,
+  getActivityLiquidationBonusEntry,
+} from '~/components/entities/activity/activityEventRowDetails'
+import {
+  enrichActivityAssetForDisplay,
+  formatActivityAssetAmount,
+  formatActivityAssetUsd,
+  formatActivityEventLabel,
+  formatActivityRelativeTimestamp,
+  formatActivityTimestamp,
+  formatActivityValuationForAssets,
+  getActivityAmountDirection,
+  getActivityAssetAddressLabel,
+  getActivityAssetLabel,
+  getActivityAssetsForDisplay,
+  getActivityCategoryLabel,
+  getActivityChangeEntries,
+  getActivityEventIcon,
+  getActivityLiquidationDisplayDetails,
+  getActivityResolvableVaultAddresses,
+  getPortfolioActivityPositionParticipant,
+  resolveActivityVaultDisplay,
+} from '~/utils/activity-display'
+
+const { event, showVault = false, hideCategory = false, hideTimestamp = false, grouped = false, hiddenCategory, showTransactionLink = true, nowMs, liquidationDetails } = defineProps<{
+  event: ActivityEvent
+  showVault?: boolean
+  /** Portfolio groups make the category redundant, while vault filters may still need it. */
+  hideCategory?: boolean
+  /** Transaction groups own their shared timestamp instead of repeating it on every event. */
+  hideTimestamp?: boolean
+  /** Applies the tighter visual treatment used inside transaction groups. */
+  grouped?: boolean
+  /** Category already implied by the active filter — omitted from the row to avoid restating it. */
+  hiddenCategory?: ActivityCategory
+  /** Composite portfolio operations link the transaction once at group level. */
+  showTransactionLink?: boolean
+  /** Feed-owned reactive clock shared by every visible event row. */
+  nowMs: number
+  /** Matching historical valuation record — enriches liquidation rows only. */
+  liquidationDetails?: LiquidationRecord
+}>()
+
+const route = useRoute()
+const expanded = ref(false)
+const {
+  getVault: getRegistryVault,
+  getType: getRegistryVaultType,
+  getVaultCategory,
+  getOrFetch: getOrFetchRegistryVault,
+  registryVersion,
+} = useVaultRegistry()
+const { getTokenByAddress } = useTokenList()
+const vaultAddress = computed(() => event.vault ?? '')
+const vaultProduct = useEulerProductOfVault(vaultAddress)
+const collateralVaultAddress = computed(() =>
+  event.assets?.find(asset => asset.kind === 'collateral')?.address ?? '',
+)
+const collateralProduct = useEulerProductOfVault(collateralVaultAddress)
+
+// Resolve registry metadata for every vault address the row may render —
+// collateral vaults, share tokens, and vault-typed governance change fields —
+// so none of them fall back to a raw shortened address.
+const metadataVaultAddresses = computed(() => getActivityResolvableVaultAddresses(event))
+
+watch(metadataVaultAddresses, (addresses) => {
+  for (const address of addresses) void getOrFetchRegistryVault(address)
+}, { immediate: true })
+
+const tokenMetadata = (address: `0x${string}`) => {
+  const token = getTokenByAddress(address)
+  if (!token) return undefined
+  return {
+    address: getAddress(token.address),
+    name: token.name,
+    symbol: token.symbol,
+    decimals: token.decimals,
+  }
+}
+
+const activityVaultMetadata = (address: `0x${string}`) => {
+  const vault = getRegistryVault(address)
+  if (!vault) return undefined
+  return {
+    asset: vault.asset,
+    shares: vault.shares,
+    vaultType: getRegistryVaultType(address),
+  }
+}
+
+const resolveAvatarAsset = (asset: ActivityEvent['assets'][number]) => {
+  const representsVaultShares = asset.kind === 'shares'
+    || (event.category === 'liquidations' && ['collateral', 'yield'].includes(asset.kind))
+  const underlyingAsset = representsVaultShares && asset.address
+    ? getRegistryVault(asset.address)?.asset
+    : undefined
+  if (underlyingAsset) {
+    return { address: underlyingAsset.address, symbol: underlyingAsset.symbol }
+  }
+  return asset.address ? { address: asset.address, symbol: asset.symbol ?? '' } : null
+}
+
+// Historical liquidation valuations resolve the collateral symbol from the
+// token list first, then from the seized collateral vault's registry asset.
+const liquidationDisplay = computed(() => {
+  if (!liquidationDetails || event.type !== 'liquidation') return null
+  void registryVersion.value
+  return getActivityLiquidationDisplayDetails(liquidationDetails, (address) => {
+    const token = tokenMetadata(address)
+    if (token) return token
+    const vaultAsset = getRegistryVault(liquidationDetails.collateral)?.asset
+    return vaultAsset && vaultAsset.address.toLowerCase() === address.toLowerCase()
+      ? vaultAsset
+      : undefined
+  }, (address) => {
+    const debtVault = getRegistryVault(liquidationDetails.vault)
+    const debtVaultUnitOfAccount = debtVault && 'unitOfAccount' in debtVault
+      ? debtVault.unitOfAccount
+      : undefined
+    if (
+      debtVaultUnitOfAccount
+      && debtVaultUnitOfAccount.address.toLowerCase() === address.toLowerCase()
+    ) {
+      return debtVaultUnitOfAccount.symbol
+    }
+    const unitOfAccountVault = getRegistryVault(address)
+    return unitOfAccountVault?.shares?.symbol
+  })
+})
+const assets = computed(() => {
+  // Re-resolve when vault or token metadata arrives after the activity page.
+  void registryVersion.value
+  const direction = event.type === 'approval' ? undefined : getActivityAmountDirection(event)
+  return getActivityAssetsForDisplay(event).map((asset, index) => {
+    const enriched = enrichActivityAssetForDisplay(
+      asset,
+      event,
+      getRegistryVault,
+      tokenMetadata,
+    )
+    const converted = enriched.kind === 'collateral'
+      ? liquidationDisplay.value?.collateralAmount
+      : undefined
+    const amount = converted ?? formatActivityAssetAmount(enriched, event.type)
+    // Portfolio event verbs already communicate direction. Signs there make
+    // borrow/repay read backwards, while vault history still benefits from
+    // explicit inflow/outflow direction.
+    const signed = !showVault && amount !== 'Amount unavailable' && direction
+    // Once converted to underlying units the quantity is no longer in shares.
+    const label = converted
+      ? 'Collateral seized'
+      : getActivityAssetLabel(enriched.kind, event.category, event.type)
+    return {
+      kind: 'asset' as const,
+      address: enriched.address,
+      amount: signed ? `${direction === 'in' ? '+' : '−'}${amount}` : amount,
+      amountClass: signed && direction === 'in' ? 'text-accent-600' : 'text-content-primary',
+      amountTitle: amount === 'Amount unavailable' ? `Raw units: ${enriched.amountRaw}` : undefined,
+      avatarAsset: showVault && event.category !== 'liquidations'
+        ? null
+        : resolveAvatarAsset(enriched),
+      key: `asset:${enriched.kind}:${enriched.address ?? 'unknown'}:${index}`,
+      // The generic "Assets" label restates what the amount already shows —
+      // keep only informative labels (Allowance, Debt repaid, …).
+      label: label === 'Assets' ? undefined : label,
+      usd: formatActivityAssetUsd(enriched)
+        ?? (enriched.kind === 'assets'
+          ? liquidationDisplay.value?.repayUsd
+          : liquidationDisplay.value?.collateralUsd)
+        ?? null,
+    }
+  })
+})
+const changes = computed(() => {
+  // Re-resolve human-readable vault names when registry metadata arrives.
+  void registryVersion.value
+  return getActivityChangeEntries(event, activityVaultMetadata)
+    .filter(entry => event.category !== 'liquidations' || entry.field !== 'collateral')
+    .map(entry => ({
+      kind: 'change' as const,
+      key: `change:${entry.field}`,
+      label: entry.label,
+      value: entry.value,
+      valueTitle: entry.value,
+      addresses: entry.addresses,
+    }))
+})
+// The seized collateral vault trails the numbers as its own metadata line, so
+// the amounts and the bonus read uninterrupted.
+const collateralVaultEntry = computed(() => {
+  if (event.category !== 'liquidations') return null
+  const address = event.assets?.find(asset => asset.kind === 'collateral')?.address
+  if (!address) return null
+  void registryVersion.value
+  const display = resolveActivityVaultDisplay(address, getRegistryVault, collateralProduct.name)
+  return {
+    kind: 'address' as const,
+    key: 'collateral-vault',
+    label: getActivityAssetAddressLabel('collateral', event.category),
+    inlineLabel: undefined,
+    address,
+    addressLabel: display?.name,
+    addressLinkKind: display ? 'vault' as const : undefined,
+    addressVaultType: getRegistryVaultType(address),
+  }
+})
+const valuation = computed(() => formatActivityValuationForAssets(event.valuation, event.assets ?? []))
+const liquidationBonusEntry = computed(() =>
+  getActivityLiquidationBonusEntry(liquidationDisplay.value))
+const details = computed(() => [
+  ...assets.value,
+  ...(liquidationBonusEntry.value ? [liquidationBonusEntry.value] : []),
+  ...changes.value,
+  ...(collateralVaultEntry.value ? [collateralVaultEntry.value] : []),
+  ...(valuation.value
+    ? [{
+        kind: 'valuation' as const,
+        key: 'valuation',
+        label: 'USD value',
+        value: valuation.value,
+        valueClass: undefined,
+        valueTitle: event.valuation?.reason,
+        addresses: undefined,
+      }]
+    : []),
+])
+const portfolioPosition = computed(() => showVault
+  ? getPortfolioActivityPositionParticipant(event)
+  : null)
+// Keep the default row scannable: the primary amount/change stays visible and
+// secondary liquidation or governance detail is available on demand.
+const COLLAPSED_ENTRY_COUNT = 1
+const hiddenEntryCount = computed(() =>
+  Math.max(0, details.value.length - COLLAPSED_ENTRY_COUNT))
+const addressCollectionSummary = (count: number) =>
+  getActivityAddressCollectionSummary(event.type, count)
+const detailAddressCount = (detail: (typeof details.value)[number]) =>
+  'addresses' in detail && Array.isArray(detail.addresses) ? detail.addresses.length : 0
+const hasExpandableDetails = computed(() =>
+  hiddenEntryCount.value > 0
+  || details.value
+    .slice(0, COLLAPSED_ENTRY_COUNT)
+    .some(detail => addressCollectionSummary(detailAddressCount(detail)) !== null))
+const eventIcon = computed(() => getActivityEventIcon(event))
+const eventLabel = computed(() => portfolioPosition.value
+  ? `${portfolioPosition.value.label} liquidated`
+  : formatActivityEventLabel(event))
+const transactionLink = computed(() => getExplorerLink(event.txHash, event.chainId))
+const vaultDisplay = computed(() => {
+  if (!showVault) return null
+  // Re-resolve when vault metadata arrives after the activity page.
+  void registryVersion.value
+  const productName = event.vault && getVaultCategory(event.vault) === 'escrow'
+    ? 'Escrowed collateral'
+    : vaultProduct.name
+  const display = resolveActivityVaultDisplay(event.vault, getRegistryVault, productName)
+  if (!display) return null
+  const vault = getRegistryVault(display.address)
+  // `event.vaultType` is optional on SDK events — prefer what the registry
+  // knows so Earn vaults never route to the lend page.
+  const vaultType = getRegistryVaultType(display.address) ?? event.vaultType
+  return {
+    ...display,
+    vault,
+    route: {
+      path: vaultType === 'earn' ? `/earn/${display.address}` : `/lend/${display.address}`,
+      query: { network: route.query.network },
+    },
+  }
+})
+</script>
+
+<template>
+  <li
+    class="activity-event-row relative -mx-12 grid items-center gap-10 rounded-8 border-b border-line-subtle px-12 py-12 transition-colors last:border-b-0 hover:bg-card-hover"
+    :class="{
+      'activity-event-row--grouped': grouped,
+      'activity-event-row--portfolio': showVault,
+      'activity-event-row--expanded': expanded,
+    }"
+  >
+    <div
+      v-if="!showVault"
+      class="activity-event-row__icon flex h-32 w-32 shrink-0 items-center justify-center rounded-full bg-surface text-content-secondary"
+    >
+      <SvgIcon
+        :name="eventIcon.name"
+        class="!h-18 !w-18"
+        aria-hidden="true"
+      />
+    </div>
+    <div class="activity-event-row__title min-w-0 pr-48">
+      <div
+        v-if="vaultDisplay"
+        class="mb-4 min-w-0"
+      >
+        <NuxtLink
+          :to="vaultDisplay.route"
+          class="inline-flex max-w-full rounded-8 transition-opacity hover:opacity-80"
+          :title="vaultDisplay.name || vaultDisplay.addressLabel"
+        >
+          <VaultLabelsAndAssets
+            v-if="vaultDisplay.vault"
+            :vault="vaultDisplay.vault"
+            :assets="[vaultDisplay.vault.asset]"
+            size="small"
+          />
+          <span
+            v-else
+            class="truncate text-p4 text-content-secondary hover:text-accent-500 hover:underline"
+          >
+            {{ vaultDisplay.name || vaultDisplay.addressLabel }}
+          </span>
+        </NuxtLink>
+      </div>
+      <div
+        class="activity-event-row__event-summary"
+        :class="{ 'activity-event-row__event-summary--with-vault': showVault && vaultDisplay?.vault }"
+      >
+        <div
+          class="line-clamp-2 break-words text-p2 font-medium text-content-primary"
+          :title="eventLabel"
+        >
+          {{ eventLabel }}
+        </div>
+        <div class="activity-event-row__meta mt-2 flex flex-wrap items-center gap-x-8 gap-y-2 text-p4 text-content-tertiary">
+          <span
+            v-if="showVault && !hideTimestamp"
+            aria-hidden="true"
+          >&middot;</span>
+          <template v-if="!hideCategory && event.category !== hiddenCategory">
+            <span>{{ getActivityCategoryLabel(event.category) }}</span>
+            <span
+              v-if="!hideTimestamp"
+              aria-hidden="true"
+            >&middot;</span>
+          </template>
+          <time
+            v-if="!hideTimestamp"
+            class="whitespace-nowrap"
+            :datetime="event.timestamp"
+            :title="formatActivityTimestamp(event.timestamp)"
+          >{{ formatActivityRelativeTimestamp(event.timestamp, nowMs) }}</time>
+        </div>
+      </div>
+    </div>
+
+    <div
+      class="activity-event-row__details flex min-w-0 flex-col gap-6 pl-40"
+      :class="{
+        'activity-event-row__details--with-vault': showVault && vaultDisplay?.vault,
+        'activity-event-row__details--expanded': expanded,
+      }"
+    >
+      <div
+        v-for="(detail, index) in details"
+        :key="detail.key"
+        class="activity-event-row__detail min-w-0"
+        :class="index >= COLLAPSED_ENTRY_COUNT && !expanded ? 'activity-event-row__secondary-detail hidden' : ''"
+      >
+        <div
+          v-if="detail.label"
+          class="activity-event-row__detail-label text-p4 text-content-tertiary"
+        >
+          {{ detail.label }}
+        </div>
+
+        <template v-if="detail.kind === 'asset'">
+          <div
+            class="activity-event-row__asset-amount mt-2 flex min-w-0 items-center gap-8"
+            :title="detail.address"
+          >
+            <AssetAvatar
+              v-if="detail.avatarAsset"
+              :asset="detail.avatarAsset"
+              size="20"
+            />
+            <div
+              class="min-w-0 break-words text-p3 font-medium"
+              :class="detail.amountClass"
+              :title="detail.amountTitle"
+            >
+              {{ detail.amount }}
+              <span
+                v-if="detail.usd"
+                class="whitespace-nowrap text-p4 font-normal text-content-tertiary"
+              >&middot; {{ detail.usd }}</span>
+            </div>
+          </div>
+        </template>
+
+        <div
+          v-else-if="detail.kind === 'address'"
+          class="activity-event-row__asset-address flex min-w-0 items-center gap-4 text-p4"
+        >
+          <span
+            v-if="detail.inlineLabel"
+            class="shrink-0 text-content-tertiary"
+          >{{ detail.inlineLabel }}</span>
+          <ActivityAddress
+            :address="detail.address"
+            :chain-id="event.chainId"
+            :label="detail.addressLabel"
+            :link-kind="detail.addressLinkKind"
+            :vault-type="detail.addressVaultType"
+            compact-vault
+          />
+        </div>
+
+        <template v-else>
+          <template v-if="detail.addresses?.length">
+            <div
+              v-if="!expanded && addressCollectionSummary(detail.addresses.length)"
+              class="break-words text-p3 text-content-primary"
+            >
+              {{ addressCollectionSummary(detail.addresses.length) }}
+            </div>
+            <div
+              v-else
+              class="activity-event-row__detail-addresses mt-2 flex min-w-0 flex-col items-start gap-2 text-p3"
+            >
+              <ActivityAddress
+                v-for="address in detail.addresses"
+                :key="address.address"
+                :address="address.address"
+                :chain-id="event.chainId"
+                :label="address.label"
+                :link-kind="address.linkKind"
+                :vault-type="address.vaultType"
+                compact-vault
+              />
+            </div>
+          </template>
+          <div
+            v-else
+            class="break-words text-p3"
+            :class="detail.kind === 'valuation' && detail.valueClass ? detail.valueClass : 'text-content-primary'"
+            :title="detail.valueTitle"
+          >
+            {{ detail.value }}
+          </div>
+        </template>
+      </div>
+
+      <button
+        v-if="hasExpandableDetails"
+        type="button"
+        class="activity-event-row__more inline-flex w-fit items-center gap-4 text-p4 text-content-tertiary transition-colors hover:text-content-primary"
+        :aria-expanded="expanded"
+        :aria-label="`${expanded ? 'Hide' : 'Show'} additional ${eventLabel} details`"
+        @click="expanded = !expanded"
+      >
+        <span>{{ expanded ? 'Less' : 'More' }}</span>
+        <SvgIcon
+          name="arrow-down"
+          class="!h-12 !w-12 transition-transform"
+          :class="{ 'rotate-180': expanded }"
+          aria-hidden="true"
+        />
+      </button>
+    </div>
+
+    <div
+      v-if="showTransactionLink"
+      class="activity-event-row__transaction absolute right-0 top-8"
+    >
+      <a
+        :href="transactionLink"
+        target="_blank"
+        rel="noopener noreferrer"
+        class="inline-flex h-40 w-40 items-center justify-center rounded-8 text-content-secondary transition-colors hover:bg-surface hover:text-accent-500"
+        :aria-label="`View ${eventLabel} transaction`"
+        title="View transaction"
+      >
+        <SvgIcon
+          name="arrow-top-right"
+          class="!h-18 !w-18"
+          aria-hidden="true"
+        />
+      </a>
+    </div>
+  </li>
+</template>
+
+<style scoped>
+/* Stacked (narrow) layout: icon + title on the first line, details as
+   full-width lines underneath. */
+.activity-event-row {
+  grid-template-columns: 32px minmax(0, 1fr);
+}
+
+.activity-event-row--portfolio {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.activity-event-row--grouped {
+  border-radius: 0;
+  padding-top: 10px;
+  padding-bottom: 10px;
+}
+
+.activity-event-row--portfolio .activity-event-row__event-summary {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  column-gap: 6px;
+}
+
+/* Indent the verb and stacked details to the identity text (32px avatar +
+   10px gap). */
+.activity-event-row--portfolio .activity-event-row__event-summary--with-vault,
+.activity-event-row--portfolio .activity-event-row__details--with-vault {
+  padding-left: 42px;
+}
+
+.activity-event-row--portfolio .activity-event-row__meta {
+  margin-top: 0;
+  column-gap: 6px;
+}
+
+.activity-event-row__details {
+  grid-column: 1 / -1;
+}
+
+@container activity-feed (min-width: 520px) {
+  /* One rule for every row: the icon, details column, and transaction link
+     center against the full card height beside the title line. */
+  .activity-event-row {
+    grid-template-columns: 32px minmax(200px, 1.4fr) minmax(180px, 1fr) 40px;
+    gap: 8px 16px;
+  }
+
+  .activity-event-row__icon,
+  .activity-event-row__details,
+  .activity-event-row__transaction {
+    grid-row: 1 / -1;
+  }
+
+  .activity-event-row__title {
+    grid-column: 2;
+    grid-row: 1;
+    padding-right: 0;
+  }
+
+  .activity-event-row__details {
+    grid-column: 3;
+    padding-left: 0;
+    flex-direction: row;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 4px 12px;
+  }
+
+  .activity-event-row__transaction {
+    position: static;
+    grid-column: 4;
+    justify-self: end;
+  }
+
+  .activity-event-row--portfolio {
+    grid-template-columns: minmax(220px, 1.4fr) minmax(200px, 1fr) 40px;
+  }
+
+  .activity-event-row--portfolio .activity-event-row__title {
+    grid-column: 1;
+  }
+
+  .activity-event-row--portfolio .activity-event-row__details {
+    grid-column: 2;
+    padding-left: 0;
+  }
+
+  /* Details live in their own column here — the stacked-layout indent would
+     only waste width. */
+  .activity-event-row--portfolio .activity-event-row__details--with-vault {
+    padding-left: 0;
+  }
+
+  .activity-event-row--portfolio .activity-event-row__transaction {
+    grid-column: 3;
+  }
+
+  .activity-event-row__asset-amount {
+    margin-top: 0;
+  }
+
+  .activity-event-row__asset-address {
+    margin-top: 0;
+  }
+
+  .activity-event-row__detail:not(.hidden) {
+    display: inline-flex;
+    min-width: 0;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 4px 8px;
+  }
+
+  .activity-event-row__details:not(.activity-event-row__details--expanded) .activity-event-row__detail-addresses {
+    margin-top: 0;
+    flex-direction: row;
+  }
+
+  .activity-event-row__details--expanded {
+    flex-direction: column;
+    align-items: flex-start;
+    flex-wrap: nowrap;
+    gap: 10px;
+  }
+}
+
+@container activity-feed (min-width: 700px) {
+  .activity-event-row--portfolio.activity-event-row--expanded {
+    grid-template-columns:
+      minmax(220px, 1fr)
+      minmax(320px, 1.2fr)
+      40px;
+  }
+
+  .activity-event-row__details--expanded .activity-event-row__detail:not(.hidden) {
+    display: grid;
+    width: 100%;
+    grid-template-columns: 130px minmax(0, 1fr);
+    align-items: center;
+    column-gap: 12px;
+  }
+
+  .activity-event-row__details--expanded .activity-event-row__detail > :not(.activity-event-row__detail-label) {
+    grid-column: 2;
+  }
+
+  .activity-event-row__details--expanded .activity-event-row__more {
+    margin-left: 142px;
+    margin-top: 2px;
+  }
+}
+
+@container activity-feed (min-width: 900px) {
+  .activity-event-row {
+    grid-template-columns:
+      32px
+      minmax(320px, 1.4fr)
+      minmax(280px, 1fr)
+      44px;
+  }
+
+  /* Events carry two text lines against a short amount — give them the
+     larger share so the amount column doesn't trail off into dead space. */
+  .activity-event-row--portfolio {
+    grid-template-columns:
+      minmax(320px, 1.4fr)
+      minmax(280px, 1fr)
+      44px;
+  }
+
+  .activity-event-row__asset-amount,
+  .activity-event-row__asset-address {
+    margin-top: 0;
+  }
+
+  .activity-event-row__details--expanded .activity-event-row__detail:not(.hidden) {
+    grid-template-columns: 150px minmax(0, 1fr);
+  }
+
+  .activity-event-row__details--expanded .activity-event-row__more {
+    margin-left: 162px;
+    margin-top: 2px;
+  }
+}
+</style>
diff --git a/components/entities/activity/ActivityFeed.vue b/components/entities/activity/ActivityFeed.vue
new file mode 100644
index 000000000..73bdc3751
--- /dev/null
+++ b/components/entities/activity/ActivityFeed.vue
@@ -0,0 +1,464 @@
+<script setup lang="ts">
+import type {
+  ActivityCategory,
+} from '@eulerxyz/euler-v2-sdk'
+import type { ActivityFeedScope } from '~/composables/useActivityFeed'
+import { getExplorerLink } from '~/utils/block-explorer'
+import {
+  formatActivityRelativeTimestamp,
+  formatActivityTimestamp,
+  getActivityCategoryLabel,
+  getActivityTransactionGroupLabel,
+  groupActivityEventsByTransaction,
+  isActivityScopeUnsupported,
+  resolveActivityFilterCategories,
+  type ActivityFilterOption,
+} from '~/utils/activity-display'
+
+const props = withDefaults(defineProps<{
+  scope: ActivityFeedScope
+  enabled: boolean
+  categoryOptions: readonly ActivityFilterOption[]
+  /** Filter selected when the feed is first mounted. */
+  defaultFilter?: string
+  /** Categories queried when no filter chip is selected — defaults to the union of the option categories. */
+  unfilteredCategories?: readonly ActivityCategory[]
+  subject?: 'account' | 'vault'
+}>(), {
+  subject: 'vault',
+})
+const emit = defineEmits<{
+  'settled': []
+  'update:unsupported': [unsupported: boolean]
+}>()
+
+const selectedFilters = ref<string[]>(props.defaultFilter ? [props.defaultFilter] : [])
+const selectedCategories = computed<ActivityCategory[]>(() =>
+  selectedFilters.value.length === 0 && props.unfilteredCategories
+    ? [...props.unfilteredCategories].sort()
+    : resolveActivityFilterCategories(props.categoryOptions, selectedFilters.value),
+)
+const activityNowMs = useActivityNowMs()
+const scopeLabel = computed(() => props.subject === 'account' ? 'account' : 'vault')
+// Coverage is complete here — the account/vault genuinely has no events, so
+// don't blame indexing. Accounts mention the network since switching chains
+// is the usual reason a wallet's history looks empty.
+const emptyMessage = computed(() => props.subject === 'account'
+  ? 'No activity for this account on this network yet.'
+  : 'No activity for this vault yet.')
+const feed = useActivityFeed({
+  scope: () => props.scope,
+  enabled: () => props.enabled,
+  categories: selectedCategories,
+})
+// Joins displayed liquidation events with their historical valuations
+// (event-time USD amounts, underlying collateral units, liquidator bonus).
+const { getLiquidationDetails } = useActivityLiquidationDetails({
+  events: () => feed.events.value,
+  enabled: () => props.enabled,
+})
+
+// A dedicated bounded query keeps the liquidation chip count honest — the
+// main feed only knows about the pages loaded so far.
+const LIQUIDATION_COUNT_LIMIT = 100
+const liquidationCountFeed = useActivityFeed({
+  scope: () => props.scope,
+  enabled: () => props.enabled && props.subject === 'account',
+  categories: () => ['liquidations'],
+  limit: LIQUIDATION_COUNT_LIMIT,
+})
+const liquidationCount = computed<number | string | undefined>(() => {
+  if (
+    props.subject !== 'account'
+    || !liquidationCountFeed.hasLoaded.value
+    || liquidationCountFeed.error.value
+  ) return undefined
+  const count = liquidationCountFeed.events.value.length
+  return liquidationCountFeed.hasMore.value ? `${count}+` : count
+})
+const displayCategoryOptions = computed(() => props.categoryOptions.map(option =>
+  option.value === 'liquidations' && liquidationCount.value !== undefined
+    ? { ...option, count: liquidationCount.value }
+    : option,
+))
+
+const missingCategoryLabels = computed(() =>
+  feed.coverage.value?.missingCategories
+    ?.map(getActivityCategoryLabel)
+    .join(', '),
+)
+const partialMessage = computed(() => missingCategoryLabels.value
+  ? `${missingCategoryLabels.value} activity may be incomplete.`
+  : undefined)
+const scopeUnsupported = computed(() =>
+  isActivityScopeUnsupported(feed.coverage.value?.status, selectedFilters.value),
+)
+// When the active filter narrows the feed to a single category, the rows'
+// category label would just restate the selected chip.
+const impliedCategory = computed(() =>
+  selectedCategories.value.length === 1 ? selectedCategories.value[0] : undefined,
+)
+const COLLAPSED_GROUP_EVENT_COUNT = 3
+const expandedGroupIds = ref(new Set<string>())
+const eventGroups = computed(() => props.subject === 'account'
+  ? groupActivityEventsByTransaction(feed.events.value)
+  : feed.events.value.map(event => ({
+      id: event.id,
+      chainId: event.chainId,
+      txHash: event.txHash,
+      timestamp: event.timestamp,
+      events: [event],
+    })),
+)
+const isGroupExpanded = (groupId: string) => expandedGroupIds.value.has(groupId)
+const visibleGroupEvents = (group: (typeof eventGroups.value)[number]) =>
+  group.events.length > COLLAPSED_GROUP_EVENT_COUNT && !isGroupExpanded(group.id)
+    ? group.events.slice(0, COLLAPSED_GROUP_EVENT_COUNT)
+    : group.events
+const toggleGroup = (groupId: string) => {
+  const next = new Set(expandedGroupIds.value)
+  if (next.has(groupId)) next.delete(groupId)
+  else next.add(groupId)
+  expandedGroupIds.value = next
+}
+const bodyElement = ref<HTMLElement | null>(null)
+const loadingBodyHeight = ref(232)
+const bodyStyle = computed(() => feed.isLoading.value
+  ? { minHeight: `${loadingBodyHeight.value}px` }
+  : undefined)
+
+watch(feed.isLoading, (isLoading) => {
+  if (!isLoading || !bodyElement.value) return
+  loadingBodyHeight.value = Math.max(
+    232,
+    Math.ceil(bodyElement.value.getBoundingClientRect().height),
+  )
+})
+
+watch(
+  () => props.categoryOptions.map(option => option.value),
+  (available) => {
+    selectedFilters.value = selectedFilters.value.filter(filter => available.includes(filter))
+  },
+)
+
+watch(scopeUnsupported, unsupported => emit('update:unsupported', unsupported), {
+  immediate: true,
+})
+
+watch(feed.hasLoaded, (hasLoaded) => {
+  if (hasLoaded) emit('settled')
+})
+</script>
+
+<template>
+  <div class="activity-feed flex flex-col gap-16">
+    <ActivityCategoryFilters
+      v-if="categoryOptions.length > 0"
+      v-model="selectedFilters"
+      :options="displayCategoryOptions"
+    />
+
+    <div
+      v-if="feed.isPartial.value && partialMessage"
+      class="flex items-start gap-8 rounded-12 bg-warning-100 p-12 text-p4 text-warning-500"
+    >
+      <SvgIcon
+        name="warning"
+        class="!h-18 !w-18 shrink-0"
+        aria-hidden="true"
+      />
+      <span>{{ partialMessage }}</span>
+    </div>
+
+    <div
+      v-if="feed.hasStaleError.value"
+      class="flex items-center gap-8 rounded-12 bg-warning-100 p-12 text-p4 text-warning-500"
+    >
+      <SvgIcon
+        name="warning"
+        class="!h-18 !w-18 shrink-0"
+        aria-hidden="true"
+      />
+      <span class="flex-1">Activity could not be refreshed. Showing the last loaded events.</span>
+      <button
+        type="button"
+        class="font-medium underline hover:no-underline"
+        :disabled="feed.isRefreshing.value"
+        @click="feed.refresh"
+      >
+        Retry
+      </button>
+    </div>
+
+    <div
+      ref="bodyElement"
+      class="activity-feed__body"
+      :style="bodyStyle"
+    >
+      <div
+        v-if="feed.isLoading.value"
+        class="flex flex-col gap-8"
+        aria-label="Loading activity"
+      >
+        <div
+          v-for="index in 3"
+          :key="index"
+          class="h-72 animate-pulse rounded-12 bg-surface"
+        />
+      </div>
+
+      <div
+        v-else-if="feed.hasColdError.value"
+        class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-24 text-center"
+      >
+        <div class="text-p3 text-content-primary">
+          Activity could not be loaded right now.
+        </div>
+        <button
+          type="button"
+          class="ui-button ui-button--medium ui-button--secondary"
+          @click="feed.refresh"
+        >
+          Retry
+        </button>
+      </div>
+
+      <div
+        v-else-if="feed.isUnsupported.value"
+        class="rounded-12 border border-line-subtle bg-surface p-16 text-p3 text-content-secondary"
+      >
+        {{ selectedFilters.length ? 'Activity is not available for the selected categories.' : `Activity is not available for this ${scopeLabel}.` }}
+      </div>
+
+      <div
+        v-else-if="feed.isSyncing.value && feed.events.value.length === 0"
+        class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-16 text-center text-p3 text-content-secondary"
+      >
+        <div>Activity is still indexing. Events will appear here shortly.</div>
+        <button
+          v-if="feed.hasMore.value"
+          type="button"
+          class="ui-button ui-button--medium ui-button--secondary"
+          :disabled="feed.isLoadingMore.value"
+          @click="feed.loadMore"
+        >
+          {{ feed.isLoadingMore.value ? 'Loading…' : 'Load older' }}
+        </button>
+      </div>
+
+      <div
+        v-else-if="feed.isPartial.value && feed.events.value.length === 0"
+        class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-16 text-center text-p3 text-content-secondary"
+      >
+        <div>No activity is available from the indexed sources. This history may be incomplete.</div>
+        <button
+          v-if="feed.hasMore.value"
+          type="button"
+          class="ui-button ui-button--medium ui-button--secondary"
+          :disabled="feed.isLoadingMore.value"
+          @click="feed.loadMore"
+        >
+          {{ feed.isLoadingMore.value ? 'Loading…' : 'Load older' }}
+        </button>
+      </div>
+
+      <div
+        v-else-if="feed.isEmpty.value"
+        :class="subject === 'account' ? 'flex min-h-160 flex-1 items-center justify-center' : 'rounded-12 border border-line-subtle bg-surface p-16 text-p3 text-content-secondary'"
+      >
+        <PortfolioEmptyState
+          v-if="subject === 'account'"
+          :active="true"
+          :active-text="selectedFilters.length ? 'No activity matches the selected categories' : emptyMessage"
+          inactive-text="Connect your wallet to see your activity"
+        />
+        <template v-else>
+          {{ selectedFilters.length ? 'No activity matches the selected categories.' : emptyMessage }}
+        </template>
+      </div>
+
+      <div
+        v-else-if="feed.hasLoaded.value && feed.events.value.length === 0 && feed.hasMore.value"
+        class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-16 text-center"
+      >
+        <div class="text-p3 text-content-secondary">
+          Nothing to show in the most recent history — older activity is available.
+        </div>
+        <button
+          type="button"
+          class="ui-button ui-button--medium ui-button--secondary"
+          :disabled="feed.isLoadingMore.value"
+          @click="feed.loadMore"
+        >
+          {{ feed.isLoadingMore.value ? 'Loading…' : 'Load older' }}
+        </button>
+      </div>
+
+      <template v-else-if="feed.events.value.length">
+        <div
+          class="transition-opacity"
+          :class="{ 'opacity-60': feed.isRefreshing.value }"
+        >
+          <div
+            class="activity-feed__header hidden gap-16 border-b border-line-subtle pb-8 text-p4 text-content-tertiary"
+            :class="{ 'activity-feed__header--portfolio': subject === 'account' }"
+          >
+            <span class="activity-feed__header-event">Event</span>
+            <span>Amount / change</span>
+            <span class="sr-only">Transaction</span>
+          </div>
+          <div>
+            <section
+              v-for="group in eventGroups"
+              :key="group.id"
+              :class="subject === 'account' ? '-mx-12 my-8 overflow-hidden rounded-12 border border-line-default bg-card px-12 shadow-card' : 'activity-feed__flat-event'"
+            >
+              <div
+                v-if="group.events.length > 1"
+                class="flex items-center justify-between gap-12 border-b border-line-subtle py-10 text-p4 text-content-tertiary"
+              >
+                <div class="flex min-w-0 flex-wrap items-center gap-x-6 gap-y-2">
+                  <span class="font-medium text-content-secondary">
+                    {{ getActivityTransactionGroupLabel(group) }}
+                  </span>
+                  <span aria-hidden="true">&middot;</span>
+                  <time
+                    :datetime="group.timestamp"
+                    :title="formatActivityTimestamp(group.timestamp)"
+                  >{{ formatActivityRelativeTimestamp(group.timestamp, activityNowMs) }}</time>
+                  <span aria-hidden="true">&middot;</span>
+                  <span>{{ group.events.length }} events</span>
+                </div>
+                <a
+                  :href="getExplorerLink(group.txHash, group.chainId)"
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  class="inline-flex h-32 w-32 items-center justify-center rounded-8 text-content-secondary transition-colors hover:bg-card-hover hover:text-accent-500"
+                  aria-label="View grouped transaction"
+                  title="View transaction"
+                >
+                  <SvgIcon
+                    name="arrow-top-right"
+                    class="!h-16 !w-16"
+                    aria-hidden="true"
+                  />
+                </a>
+              </div>
+              <ul>
+                <ActivityEventRow
+                  v-for="event in visibleGroupEvents(group)"
+                  :key="event.id"
+                  :event="event"
+                  :show-vault="subject === 'account'"
+                  :hide-category="subject === 'account'"
+                  :hide-timestamp="group.events.length > 1"
+                  :grouped="group.events.length > 1"
+                  :hidden-category="impliedCategory"
+                  :show-transaction-link="group.events.length === 1"
+                  :now-ms="activityNowMs"
+                  :liquidation-details="getLiquidationDetails(event)"
+                />
+              </ul>
+              <button
+                v-if="group.events.length > COLLAPSED_GROUP_EVENT_COUNT"
+                type="button"
+                class="flex w-full items-center justify-center gap-4 border-t border-line-subtle py-10 text-p4 font-medium text-content-secondary transition-colors hover:text-content-primary"
+                :aria-expanded="isGroupExpanded(group.id)"
+                @click="toggleGroup(group.id)"
+              >
+                <span>
+                  {{ isGroupExpanded(group.id)
+                    ? 'Show fewer events'
+                    : `Show ${group.events.length - COLLAPSED_GROUP_EVENT_COUNT} more events` }}
+                </span>
+                <SvgIcon
+                  name="arrow-down"
+                  class="!h-12 !w-12 transition-transform"
+                  :class="{ 'rotate-180': isGroupExpanded(group.id) }"
+                  aria-hidden="true"
+                />
+              </button>
+            </section>
+          </div>
+        </div>
+
+        <div
+          v-if="feed.loadMoreError.value"
+          class="flex items-center gap-8 rounded-12 bg-warning-100 p-12 text-p4 text-warning-500"
+        >
+          <span class="flex-1">Older activity could not be loaded.</span>
+          <button
+            type="button"
+            class="font-medium underline hover:no-underline"
+            @click="feed.loadMore"
+          >
+            Retry
+          </button>
+        </div>
+
+        <div
+          v-if="feed.hasMore.value"
+          class="flex justify-center"
+        >
+          <button
+            type="button"
+            class="ui-button ui-button--medium ui-button--secondary"
+            :disabled="feed.isLoadingMore.value"
+            @click="feed.loadMore"
+          >
+            {{ feed.isLoadingMore.value ? 'Loading…' : 'Load older' }}
+          </button>
+        </div>
+      </template>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+/* Flat vault feeds render each event as its own section — the separator has
+   to live between the sections. Same rule the portfolio transaction bundles
+   use between their rows. */
+.activity-feed__flat-event + .activity-feed__flat-event {
+  border-top: 1px solid var(--border-subtle);
+}
+
+.activity-feed {
+  container-name: activity-feed;
+  container-type: inline-size;
+}
+
+.activity-feed__body {
+  transition: min-height 150ms ease;
+}
+
+@container activity-feed (min-width: 900px) {
+  .activity-feed__header {
+    display: grid;
+    grid-template-columns:
+      32px
+      minmax(320px, 1.4fr)
+      minmax(280px, 1fr)
+      44px;
+  }
+
+  /* Skip the icon column so the label aligns with the event titles. */
+  .activity-feed__header-event {
+    grid-column: 2;
+  }
+
+  /* Portfolio rows drop the icon column and lead with the vault identity —
+     mirror their grid so both header labels sit over their columns. */
+  .activity-feed__header--portfolio {
+    grid-template-columns:
+      minmax(320px, 1.4fr)
+      minmax(280px, 1fr)
+      44px;
+  }
+
+  .activity-feed__header--portfolio .activity-feed__header-event {
+    grid-column: 1;
+    padding-left: 42px;
+  }
+}
+</style>
diff --git a/components/entities/activity/activityEventRowDetails.ts b/components/entities/activity/activityEventRowDetails.ts
new file mode 100644
index 000000000..14a3a2e71
--- /dev/null
+++ b/components/entities/activity/activityEventRowDetails.ts
@@ -0,0 +1,36 @@
+import type { ActivityEvent } from '@eulerxyz/euler-v2-sdk'
+import type { ActivityLiquidationDisplayDetails } from '~/utils/activity-display'
+
+const QUEUE_EVENT_TYPES: readonly ActivityEvent['type'][] = [
+  'set_supply_queue',
+  'set_withdraw_queue',
+]
+
+export const getActivityAddressCollectionSummary = (
+  eventType: ActivityEvent['type'],
+  count: number,
+): string | null => {
+  if (count <= 1) return null
+  return QUEUE_EVENT_TYPES.includes(eventType)
+    ? `${count} strategies`
+    : `${count} addresses`
+}
+
+export const getActivityLiquidationBonusEntry = (
+  display: ActivityLiquidationDisplayDetails | null,
+) => {
+  if (!display?.bonus) return null
+  return {
+    kind: 'valuation' as const,
+    key: 'liquidation-bonus',
+    label: 'Liquidator bonus',
+    value: display.bonus,
+    valueClass: display.bonusTone === 'positive'
+      ? 'text-accent-600'
+      : display.bonusTone === 'negative'
+        ? 'text-error-500'
+        : undefined,
+    valueTitle: display.bonusTitle,
+    addresses: undefined,
+  }
+}
diff --git a/components/entities/asset/AssetAvatar.vue b/components/entities/asset/AssetAvatar.vue
index 78e83ef79..f69041c34 100644
--- a/components/entities/asset/AssetAvatar.vue
+++ b/components/entities/asset/AssetAvatar.vue
@@ -3,7 +3,7 @@ import { getAssetLogoUrl } from '~/composables/useTokenList'
 
 const { asset, size, iconUrl } = defineProps<{
   asset: { address: string, symbol: string } | { address: string, symbol: string }[]
-  size?: '16' | '20' | '28' | '36' | '38' | '40' | '46'
+  size?: '16' | '20' | '28' | '32' | '36' | '38' | '40' | '46'
   iconUrl?: string
 }>()
 
diff --git a/components/entities/portfolio/PortfolioBorrowItem.vue b/components/entities/portfolio/PortfolioBorrowItem.vue
index 98be8484c..8a8bf4820 100644
--- a/components/entities/portfolio/PortfolioBorrowItem.vue
+++ b/components/entities/portfolio/PortfolioBorrowItem.vue
@@ -31,9 +31,11 @@ import { resolveComponent, type Component } from 'vue'
 const { position, clickable = true } = defineProps<{ position: PortfolioBorrowPosition<VaultEntity>, clickable?: boolean }>()
 const { getVaultCategory, isVerifiedVault } = useVaultRegistry()
 
-const { address } = useWagmi()
 const { portfolioAddress } = useEulerAccount()
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 const subAccountIndex = computed(() => {
   if (!ownerAddress.value || !position.subAccount) return 0
   return getSubAccountIndex(getAddress(ownerAddress.value), getAddress(position.subAccount))
diff --git a/components/entities/portfolio/PortfolioEarnItem.vue b/components/entities/portfolio/PortfolioEarnItem.vue
index cf508ddb6..c471173cd 100644
--- a/components/entities/portfolio/PortfolioEarnItem.vue
+++ b/components/entities/portfolio/PortfolioEarnItem.vue
@@ -15,9 +15,11 @@ import { getVaultIntrinsicApyInfo } from '~/utils/vault-intrinsic-apy'
 const { position } = defineProps<{ position: PortfolioSavingsPosition<VaultEntity> }>()
 const modal = useModal()
 
-const { address } = useWagmi()
 const { portfolioAddress } = useEulerAccount()
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 const subAccountIndex = computed(() => {
   if (!ownerAddress.value || !position.subAccount) return 0
   return getSubAccountIndex(getAddress(ownerAddress.value), getAddress(position.subAccount))
diff --git a/components/entities/portfolio/PortfolioSavingItem.vue b/components/entities/portfolio/PortfolioSavingItem.vue
index adeed29e2..31ac2ff24 100644
--- a/components/entities/portfolio/PortfolioSavingItem.vue
+++ b/components/entities/portfolio/PortfolioSavingItem.vue
@@ -15,9 +15,11 @@ import { getVaultIntrinsicApyInfo } from '~/utils/vault-intrinsic-apy'
 const { position } = defineProps<{ position: PortfolioSavingsPosition<VaultEntity> }>()
 const modal = useModal()
 
-const { address } = useWagmi()
 const { portfolioAddress } = useEulerAccount()
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 const subAccountIndex = computed(() => {
   if (!ownerAddress.value || !position.subAccount) return 0
   return getSubAccountIndex(getAddress(ownerAddress.value), getAddress(position.subAccount))
diff --git a/components/entities/portfolio/PortfolioUnsupportedBorrowItem.vue b/components/entities/portfolio/PortfolioUnsupportedBorrowItem.vue
index 4c13f2c31..0f86c0ae5 100644
--- a/components/entities/portfolio/PortfolioUnsupportedBorrowItem.vue
+++ b/components/entities/portfolio/PortfolioUnsupportedBorrowItem.vue
@@ -15,9 +15,11 @@ import { useEulerProductOfVault } from '~/composables/useEulerLabels'
 
 const { position } = defineProps<{ position: PortfolioBorrowPosition<VaultEntity> }>()
 
-const { address } = useWagmi()
 const { portfolio, portfolioAddress } = useEulerAccount()
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 const subAccountIndex = computed(() => {
   if (!ownerAddress.value || !position.subAccount) return 0
   return getSubAccountIndex(getAddress(ownerAddress.value), getAddress(position.subAccount))
diff --git a/components/entities/vault/ChooseCollateralModal.vue b/components/entities/vault/ChooseCollateralModal.vue
index b2dc719dd..4eb83661e 100644
--- a/components/entities/vault/ChooseCollateralModal.vue
+++ b/components/entities/vault/ChooseCollateralModal.vue
@@ -34,12 +34,14 @@ const {
 }>()
 
 const { isEscrowVault } = useVaultRegistry()
-const { address } = useWagmi()
 const { portfolioAddress } = useEulerAccount()
 
 const searchQuery = ref('')
 const selectedIdx = ref(selected)
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 const getOptionLabel = (option: CollateralOption) => {
   if (option.vaultAddress && isEscrowVault(option.vaultAddress)) return 'Escrowed collateral'
   if (option.label) return option.label
diff --git a/components/entities/vault/VaultLabelsAndAssets.vue b/components/entities/vault/VaultLabelsAndAssets.vue
index 3e2656d83..1f95e6088 100644
--- a/components/entities/vault/VaultLabelsAndAssets.vue
+++ b/components/entities/vault/VaultLabelsAndAssets.vue
@@ -8,7 +8,8 @@ import { getAddress } from 'viem'
 const { vault, assets, size, assetsLabel, pairVault, back, backFallback } = defineProps<{
   vault?: EVault | EulerEarn | SecuritizeCollateralVault
   assets: VaultAsset[]
-  size?: 'large'
+  /** `small` renders a compact identity for list contexts (e.g. activity rows) where surrounding content carries the emphasis. */
+  size?: 'large' | 'small'
   assetsLabel?: string
   pairVault?: EVault
   back?: boolean
@@ -91,7 +92,7 @@ const displayAssetsLabel = computed(() => assetsLabel || assets.map(asset => ass
 <template>
   <div
     v-if="vault"
-    :class="[size === 'large' ? 'gap-16' : 'gap-12']"
+    :class="[size === 'large' ? 'gap-16' : size === 'small' ? 'gap-10' : 'gap-12']"
     class="flex items-center min-w-0"
     data-id="vault-header"
     :data-key="pairVault ? `${vault.address.toLowerCase()}:${pairVault.address.toLowerCase()}` : vault.address.toLowerCase()"
@@ -105,11 +106,14 @@ const displayAssetsLabel = computed(() => assetsLabel || assets.map(asset => ass
     />
     <AssetAvatar
       :asset="assets"
-      :size="size === 'large' ? '46' : '38'"
+      :size="size === 'large' ? '46' : size === 'small' ? '32' : '38'"
     />
 
     <div class="min-w-0">
-      <div class="flex flex-wrap items-center gap-8 mb-4 min-w-0">
+      <div
+        class="flex flex-wrap items-center gap-8 min-w-0"
+        :class="size === 'small' ? 'mb-2 text-p4' : 'mb-4'"
+      >
         <span
           class="block min-w-0 max-w-full truncate text-content-tertiary"
           :title="pairVault ? displayLabel : displayName"
@@ -153,7 +157,8 @@ const displayAssetsLabel = computed(() => assetsLabel || assets.map(asset => ass
       </div>
 
       <p
-        class="flex flex-wrap items-center gap-8 text-p2 font-semibold text-content-primary min-w-0"
+        class="flex flex-wrap items-center gap-8 font-semibold text-content-primary min-w-0"
+        :class="size === 'small' ? 'text-p3' : 'text-p2'"
         data-id="data-point"
         :data-key="pairVault ? `${vault.address.toLowerCase()}:${pairVault.address.toLowerCase()}` : vault.address.toLowerCase()"
         data-field="asset-symbols"
diff --git a/components/entities/vault/overview/SecuritizeVaultOverview.vue b/components/entities/vault/overview/SecuritizeVaultOverview.vue
index 9d6ca46c4..5febee351 100644
--- a/components/entities/vault/overview/SecuritizeVaultOverview.vue
+++ b/components/entities/vault/overview/SecuritizeVaultOverview.vue
@@ -277,6 +277,12 @@ const supplyCapPercentageDisplay = computed(() => {
       </VaultOverviewLabelValue>
     </VaultOverviewAccordionSection>
 
+    <VaultOverviewBlockActivity
+      :vault="vault"
+      vault-type="securitize"
+      :default-open="false"
+    />
+
     <!-- Risk Parameters -->
     <VaultOverviewAccordionSection
       title="Risk parameters"
diff --git a/components/entities/vault/overview/VaultOverview.vue b/components/entities/vault/overview/VaultOverview.vue
index 2e72cadef..705f95dd8 100644
--- a/components/entities/vault/overview/VaultOverview.vue
+++ b/components/entities/vault/overview/VaultOverview.vue
@@ -32,6 +32,12 @@ const isCyclicalIRM = computed(() => isVaultCyclicalNote(vault.address))
       :default-open="true"
     />
 
+    <VaultOverviewBlockActivity
+      :vault="vault"
+      vault-type="evk"
+      :default-open="false"
+    />
+
     <VaultOverviewBlockRiskParameters
       :vault="vault"
       :default-open="false"
diff --git a/components/entities/vault/overview/VaultOverviewAccordionSection.vue b/components/entities/vault/overview/VaultOverviewAccordionSection.vue
index 8fbad768a..878d9e24c 100644
--- a/components/entities/vault/overview/VaultOverviewAccordionSection.vue
+++ b/components/entities/vault/overview/VaultOverviewAccordionSection.vue
@@ -4,23 +4,34 @@ const props = withDefaults(defineProps<{
   defaultOpen?: boolean
   contentClass?: string
   hasActions?: boolean
+  keepMounted?: boolean
 }>(), {
   defaultOpen: true,
   contentClass: 'flex flex-col gap-24',
   hasActions: true,
+  keepMounted: false,
 })
+const emit = defineEmits<{
+  'update:open': [open: boolean]
+}>()
 
 const isOpen = ref(props.defaultOpen)
 const panelId = useId()
 const sectionEl = ref<HTMLElement>()
 
+const setOpen = (open: boolean) => {
+  if (isOpen.value === open) return
+  isOpen.value = open
+  emit('update:open', open)
+}
+
 const expandIfOnlySection = () => {
   const parentEl = sectionEl.value?.parentElement
   if (!parentEl) return
 
   const sections = Array.from(parentEl.querySelectorAll<HTMLElement>(':scope > [data-vault-overview-accordion-section]'))
   if (sections.length === 1) {
-    isOpen.value = true
+    setOpen(true)
     return
   }
 
@@ -28,12 +39,12 @@ const expandIfOnlySection = () => {
     section.querySelector('button[aria-expanded="false"]'),
   )
   if (collapsedSections.length === 1 && collapsedSections[0] === sectionEl.value) {
-    isOpen.value = true
+    setOpen(true)
   }
 }
 
 const toggle = () => {
-  isOpen.value = !isOpen.value
+  setOpen(!isOpen.value)
 }
 
 onMounted(async () => {
@@ -86,7 +97,8 @@ onMounted(async () => {
     </div>
 
     <div
-      v-if="isOpen"
+      v-if="isOpen || keepMounted"
+      v-show="isOpen"
       :id="panelId"
       class="px-24 pb-24"
     >
diff --git a/components/entities/vault/overview/VaultOverviewBlockActivity.vue b/components/entities/vault/overview/VaultOverviewBlockActivity.vue
new file mode 100644
index 000000000..f69ec8c47
--- /dev/null
+++ b/components/entities/vault/overview/VaultOverviewBlockActivity.vue
@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import type {
+  ActivityVaultType,
+  VaultEntity,
+} from '@eulerxyz/euler-v2-sdk'
+import { getAddress } from 'viem'
+import {
+  buildActivityFeedContextKey,
+  type ActivityFeedScope,
+} from '~/composables/useActivityFeed'
+import {
+  getDefaultVaultActivityFilter,
+  getVaultActivityFilterOptions,
+} from '~/utils/activity-display'
+
+const props = withDefaults(defineProps<{
+  vault: VaultEntity
+  vaultType: ActivityVaultType
+  defaultOpen?: boolean
+}>(), {
+  defaultOpen: false,
+})
+
+const { chainId } = useEulerAddresses()
+const isOpen = ref(props.defaultOpen)
+const hasCheckedRuntimeSupport = ref(false)
+const isRuntimeUnsupported = ref(false)
+const availabilityScope = computed(() => ({
+  kind: 'vault' as const,
+  vaultType: props.vaultType,
+}))
+const availability = useActivityAvailability(availabilityScope, chainId)
+const feedScope = computed<ActivityFeedScope>(() => ({
+  kind: 'vault',
+  vault: getAddress(props.vault.address),
+  chainId: Number(chainId.value),
+  vaultType: props.vaultType,
+}))
+const feedContextKey = computed(() => buildActivityFeedContextKey(feedScope.value, []))
+const categoryOptions = computed(() => getVaultActivityFilterOptions(props.vaultType))
+const defaultFilter = computed(() => getDefaultVaultActivityFilter(props.vaultType))
+
+const setRuntimeUnsupported = (unsupported: boolean) => {
+  isRuntimeUnsupported.value = unsupported
+  if (unsupported) isOpen.value = false
+}
+
+// Compare by the string key, not the scope object: the computed produces a
+// fresh object whenever the page's vault prop refreshes, and resetting on
+// identity alone hid an already-settled section forever.
+watch(feedContextKey, () => {
+  hasCheckedRuntimeSupport.value = false
+  isRuntimeUnsupported.value = false
+  isOpen.value = props.defaultOpen
+})
+</script>
+
+<template>
+  <VaultOverviewAccordionSection
+    v-if="availability.shouldRender.value && !isRuntimeUnsupported"
+    v-show="availability.reason.value === 'capability-check-failed' || hasCheckedRuntimeSupport"
+    :key="feedContextKey"
+    title="Activity"
+    :default-open="defaultOpen"
+    :keep-mounted="true"
+    content-class="flex flex-col gap-16 pt-8"
+    @update:open="isOpen = $event"
+  >
+    <div
+      v-if="availability.reason.value === 'capability-check-failed'"
+      class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-24 text-center"
+      role="alert"
+    >
+      <div class="text-p3 text-content-primary">
+        Activity availability could not be checked right now.
+      </div>
+      <button
+        type="button"
+        class="ui-button ui-button--medium ui-button--secondary"
+        :disabled="availability.isChecking.value"
+        @click="availability.refreshAvailability"
+      >
+        {{ availability.isChecking.value ? 'Retrying…' : 'Retry' }}
+      </button>
+    </div>
+    <ActivityFeed
+      v-else
+      :scope="feedScope"
+      :enabled="availability.isSupported.value && (isOpen || !hasCheckedRuntimeSupport)"
+      :category-options="categoryOptions"
+      :default-filter="defaultFilter"
+      @settled="hasCheckedRuntimeSupport = true"
+      @update:unsupported="setRuntimeUnsupported"
+    />
+  </VaultOverviewAccordionSection>
+</template>
diff --git a/components/entities/vault/overview/earn/VaultOverviewEarn.vue b/components/entities/vault/overview/earn/VaultOverviewEarn.vue
index 8f361d8fe..18af563f4 100644
--- a/components/entities/vault/overview/earn/VaultOverviewEarn.vue
+++ b/components/entities/vault/overview/earn/VaultOverviewEarn.vue
@@ -27,6 +27,12 @@ const { vault } = defineProps<{ vault: EulerEarn, desktopOverview?: boolean }>()
       :default-open="true"
     />
 
+    <VaultOverviewBlockActivity
+      :vault="vault"
+      vault-type="earn"
+      :default-open="false"
+    />
+
     <VaultOverviewEarnBlockExposure
       :vault="vault"
       :default-open="false"
diff --git a/components/layout/SpyModeBanner.vue b/components/layout/SpyModeBanner.vue
index 3ea1981f3..4b3c16ab0 100644
--- a/components/layout/SpyModeBanner.vue
+++ b/components/layout/SpyModeBanner.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-const { isSpyMode, spyShortAddress, spyAddress, clearSpyMode } = useSpyMode()
+const { isSpyMode, isSpyResolving, spyShortAddress, spyAddress, clearSpyMode } = useSpyMode()
 </script>
 
 <template>
@@ -12,7 +12,17 @@ const { isSpyMode, spyShortAddress, spyAddress, clearSpyMode } = useSpyMode()
         name="search-user"
         class="!w-16 !h-16"
       />
-      <span class="text-p3">
+      <!-- The candidate address is never displayed until its owner resolves. -->
+      <span
+        v-if="isSpyResolving"
+        class="text-p3"
+      >
+        Verifying address…
+      </span>
+      <span
+        v-else
+        class="text-p3"
+      >
         Viewing as
         <UiHoverPreviewTooltip
           title="Spy address"
diff --git a/components/ui/UiCustomFilterChips.vue b/components/ui/UiCustomFilterChips.vue
index d6bd38ecc..27343bcc0 100644
--- a/components/ui/UiCustomFilterChips.vue
+++ b/components/ui/UiCustomFilterChips.vue
@@ -13,22 +13,19 @@ const emit = defineEmits<{
 </script>
 
 <template>
-  <div
+  <UiFilterChip
     v-for="filter in filters"
     :key="filter.id"
-    class="ui-select__chip"
-    :class="[
-      chipClass,
-      { 'ui-select__chip--active': filter.tone !== 'neutral' },
-    ]"
+    :class="chipClass"
+    :active="filter.tone !== 'neutral'"
     @click="emit('remove', filter.id)"
   >
     {{ filter.label }}
     <UiIcon
       name="close"
-      class="ui-select__chip-icon"
+      class="ui-filter-chip__icon"
     />
-  </div>
+  </UiFilterChip>
   <button
     class="flex items-center gap-6 shrink-0 min-h-36 py-6 px-16 bg-surface border border-dashed border-line-default rounded-[100px] cursor-pointer hover:border-line-emphasis hover:bg-surface-secondary transition-all text-content-tertiary text-[14px]"
     data-id="custom-filter-trigger"
diff --git a/components/ui/UiFilterChip.vue b/components/ui/UiFilterChip.vue
new file mode 100644
index 000000000..f6357d502
--- /dev/null
+++ b/components/ui/UiFilterChip.vue
@@ -0,0 +1,60 @@
+<script setup lang="ts">
+defineProps<{
+  active?: boolean
+}>()
+</script>
+
+<template>
+  <button
+    type="button"
+    class="ui-filter-chip"
+    :class="{ 'ui-filter-chip--active': active }"
+  >
+    <slot />
+  </button>
+</template>
+
+<!-- Unscoped so slotted content (e.g. `.ui-filter-chip__icon`) can be styled
+     alongside the pill itself. -->
+<style lang="scss">
+.ui-filter-chip {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 16px;
+  font-size: 14px;
+  font-weight: 400;
+  background: var(--ui-select-chip-background-color);
+  border: 1px solid var(--neutral-300);
+  border-radius: 100px;
+  cursor: pointer;
+  white-space: nowrap;
+  transition: all 0.15s ease;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
+
+  &:hover {
+    border-color: var(--neutral-400);
+    background: var(--neutral-50);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.06);
+  }
+
+  &--active {
+    font-weight: 600;
+    background: var(--ui-select-chip-active-background-color);
+    color: var(--ui-select-chip-active-color);
+    border-color: transparent;
+    box-shadow: var(--accent-shadow-md);
+
+    &:hover {
+      background: var(--accent-600);
+      border-color: transparent;
+      box-shadow: var(--accent-shadow-lg);
+    }
+  }
+
+  &__icon {
+    width: 16px;
+    height: 16px;
+  }
+}
+</style>
diff --git a/components/ui/UiSelect.vue b/components/ui/UiSelect.vue
index 1b793d75c..3c934dba4 100644
--- a/components/ui/UiSelect.vue
+++ b/components/ui/UiSelect.vue
@@ -40,6 +40,19 @@ const plusText = computed(() => {
   return `+${props.showSelectedOptions ? model.value.length - 2 : model.value.length}`
 })
 
+const accessibleLabel = computed(() => {
+  const label = props.title || props.placeholder || 'Select'
+  if (model.value.length === 0) return `${label}: ${displayText.value}`
+
+  const selectedLabels = [...props.options, ...(props.quickFilters ?? [])]
+    .filter(option => model.value.includes(option.value))
+    .map(option => option.label)
+  const selection = selectedLabels.length > 0
+    ? selectedLabels.join(', ')
+    : `${model.value.length} selected`
+  return `${label}: ${selection}`
+})
+
 const toggleOption = (value: string) => {
   if (model.value.includes(value)) {
     model.value = model.value.filter(v => v !== value)
@@ -69,12 +82,15 @@ const open = () => {
   <div
     :class="['ui-select', { 'ui-select--chips': chipOptions && chipOptions.length > 0 }]"
   >
-    <div
+    <button
+      type="button"
       class="ui-select__field"
       data-id="filter-trigger"
       :data-filter-title="title || placeholder || 'Select'"
       :data-filter-placeholder="placeholder || 'Select'"
       :data-selected-count="model.length"
+      :aria-label="accessibleLabel"
+      aria-haspopup="dialog"
       @click="open"
     >
       <UiIcon
@@ -92,21 +108,21 @@ const open = () => {
         name="arrow-down"
         class="ui-select__arrow"
       />
-    </div>
+    </button>
     <template v-if="chipOptions && chipOptions.length > 0">
-      <div
+      <UiFilterChip
         v-for="option in chipOptions"
         :key="option.value"
-        :class="['ui-select__chip', { 'ui-select__chip--active': model.includes(option.value) }]"
+        :active="model.includes(option.value)"
         @click="toggleOption(option.value)"
       >
         {{ option.label }}
         <UiIcon
           v-if="model.includes(option.value)"
           name="close"
-          class="ui-select__chip-icon"
+          class="ui-filter-chip__icon"
         />
-      </div>
+      </UiFilterChip>
     </template>
   </div>
 </template>
@@ -187,46 +203,5 @@ const open = () => {
     margin-left: auto;
     margin-right: -4px;
   }
-
-  &__chip {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-    padding: 8px 16px;
-    font-size: 14px;
-    font-weight: 400;
-    background: var(--ui-select-chip-background-color);
-    border: 1px solid var(--neutral-300);
-    border-radius: 100px;
-    cursor: pointer;
-    white-space: nowrap;
-    transition: all 0.15s ease;
-    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
-
-    &:hover {
-      border-color: var(--neutral-400);
-      background: var(--neutral-50);
-      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.06);
-    }
-
-    &--active {
-      font-weight: 600;
-      background: var(--ui-select-chip-active-background-color);
-      color: var(--ui-select-chip-active-color);
-      border-color: transparent;
-      box-shadow: var(--accent-shadow-md);
-
-      &:hover {
-        background: var(--accent-600);
-        border-color: transparent;
-        box-shadow: var(--accent-shadow-lg);
-      }
-    }
-  }
-
-  &__chip-icon {
-    width: 16px;
-    height: 16px;
-  }
 }
 </style>
diff --git a/components/ui/UiTabs.vue b/components/ui/UiTabs.vue
index 8f8e5976d..32865ae46 100644
--- a/components/ui/UiTabs.vue
+++ b/components/ui/UiTabs.vue
@@ -85,24 +85,51 @@ const checkScrollPosition = () => {
   scrollPosition.value = scrollLeft
   maxPosition.value = scrollWidth - offsetWidth
 }
-const onSelect = (value: string | number | undefined, index: number) => {
-  model.value = value
+const scrollItemIntoView = (index: number, behavior: ScrollBehavior = 'smooth') => {
+  const wrapper = scrollableRef.value
+  const el = listRef.value?.querySelectorAll('.ui-tabs__item')[index]
+  if (!wrapper || !el) return
+
+  const padding = props.pills ? 4 : 20
+  const itemLeft = el.offsetLeft
+  const itemRight = itemLeft + el.offsetWidth
+  const visibleLeft = wrapper.scrollLeft
+  const visibleRight = visibleLeft + wrapper.clientWidth
+  let left: number | undefined
+  if (itemLeft < visibleLeft + padding) {
+    left = itemLeft - padding
+  }
+  else if (itemRight > visibleRight - padding) {
+    left = itemRight - wrapper.clientWidth + padding
+  }
+  if (left === undefined) return
 
-  const el = listRef.value ? listRef.value.querySelectorAll('.ui-tabs__item')[index] : undefined
-  if (el) {
-    const isOutside = el.offsetLeft < scrollableRef.value.scrollLeft
-      || el.offsetLeft + el.offsetWidth > scrollableRef.value.scrollLeft + scrollableRef.value.clientWidth
-    const offset = props.pills && index === 0 ? -4 : -20
-    scrollableRef.value.scroll({
-      left: isOutside ? el.offsetLeft + offset : undefined,
-      top: 0,
-      behavior: 'smooth',
-    })
+  wrapper.scroll({
+    left: Math.max(0, left),
+    top: 0,
+    behavior,
+  })
+}
+const observeTabSizes = () => {
+  if (!resizeObserver || !listRef.value) return
+  resizeObserver.disconnect()
+  resizeObserver.observe(listRef.value)
+  listRef.value.querySelectorAll('.ui-tabs__item').forEach((item: Element) => {
+    resizeObserver?.observe(item)
+  })
+}
+const onSelect = (value: string | number | undefined, index: number) => {
+  if (model.value === value) {
+    scrollItemIntoView(index)
+    return
   }
+  model.value = value
 }
 
-watch(currentIdx, () => {
+watch(currentIdx, async (index) => {
+  await nextTick()
   updateBlockStyles()
+  scrollItemIntoView(index)
 })
 watch(() => props.list.length, async () => {
   await nextTick()
@@ -110,18 +137,25 @@ watch(() => props.list.length, async () => {
   // tab appearing/disappearing on account switch) resizes the remaining tabs
   // without changing the list element's own size — the ResizeObserver doesn't
   // fire and the active-pill block keeps its stale width/offset. Recompute it.
+  observeTabSizes()
   updateBlockStyles()
+  scrollItemIntoView(currentIdx.value, 'auto')
   checkScrollPosition()
 })
 
 onMounted(() => {
-  resizeObserver = new ResizeObserver(updateBlockStyles)
-  resizeObserver.observe(listRef.value)
+  resizeObserver = new ResizeObserver(() => {
+    updateBlockStyles()
+    scrollItemIntoView(currentIdx.value, 'auto')
+  })
+  observeTabSizes()
+  updateBlockStyles()
+  scrollItemIntoView(currentIdx.value, 'auto')
   checkScrollPosition()
 })
 onBeforeUnmount(() => {
   if (resizeObserver) {
-    resizeObserver.unobserve(listRef.value)
+    resizeObserver.disconnect()
     resizeObserver = null
   }
 })
diff --git a/composables/useActivityAvailability.ts b/composables/useActivityAvailability.ts
new file mode 100644
index 000000000..0ca0ade06
--- /dev/null
+++ b/composables/useActivityAvailability.ts
@@ -0,0 +1,132 @@
+import type {
+  ActivityCapabilities,
+  ActivityScopeSupport,
+  ActivityVaultType,
+} from '@eulerxyz/euler-v2-sdk'
+import {
+  computed,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  toValue,
+  watch,
+  type MaybeRefOrGetter,
+} from 'vue'
+
+export type ActivityAvailabilityScope
+  = | { kind: 'account' }
+    | { kind: 'vault', vaultType: ActivityVaultType }
+
+export type ActivityAvailabilityReason
+  = | 'invalid-chain'
+    | 'v3-disabled'
+    | 'source-not-configured'
+    | 'unsupported-scope'
+    | 'capability-check-failed'
+
+export const useActivityAvailability = (
+  scope: MaybeRefOrGetter<ActivityAvailabilityScope>,
+  chainId: MaybeRefOrGetter<number | string | null | undefined>,
+) => {
+  const { isV3EnabledForChain } = useV3ChainGate()
+  const capabilities = shallowRef<ActivityCapabilities>()
+  const isChecking = ref(false)
+  const isSupported = ref(false)
+  const scopeSupport = ref<ActivityScopeSupport>()
+  const reason = ref<ActivityAvailabilityReason>()
+  let activeRequestId = 0
+
+  const resolvedChainId = computed(() => Number(toValue(chainId)))
+  const scopeKey = computed(() => {
+    const value = toValue(scope)
+    return value.kind === 'account' ? 'account' : `vault:${value.vaultType}`
+  })
+  const shouldRender = computed(() =>
+    isSupported.value || reason.value === 'capability-check-failed',
+  )
+
+  const checkAvailability = async ({ preserveCapabilityFailure = false } = {}) => {
+    const requestId = ++activeRequestId
+    const targetChainId = resolvedChainId.value
+    const targetScope = toValue(scope)
+    const keepCapabilityFailure = preserveCapabilityFailure
+      && reason.value === 'capability-check-failed'
+
+    capabilities.value = undefined
+    isSupported.value = false
+    scopeSupport.value = undefined
+    if (!keepCapabilityFailure) reason.value = undefined
+
+    if (!Number.isSafeInteger(targetChainId) || targetChainId <= 0) {
+      reason.value = 'invalid-chain'
+      isChecking.value = false
+      return
+    }
+    if (!isV3EnabledForChain(targetChainId)) {
+      reason.value = 'v3-disabled'
+      isChecking.value = false
+      return
+    }
+
+    isChecking.value = true
+    try {
+      const { getEulerSdkForChain } = useEulerSdk()
+      const sdk = await getEulerSdkForChain(targetChainId)
+      if (requestId !== activeRequestId) return
+
+      const activityService = sdk.activityService
+      const nextCapabilities = activityService.getCapabilities()
+      capabilities.value = nextCapabilities
+      if (!nextCapabilities.configured) {
+        reason.value = nextCapabilities.reason === 'source-not-configured'
+          ? 'source-not-configured'
+          : 'v3-disabled'
+        return
+      }
+
+      const routeShapeSupported = targetScope.kind === 'account'
+        ? nextCapabilities.canQueryAccount
+        : nextCapabilities.requestableVaultTypes.includes(targetScope.vaultType)
+      if (!routeShapeSupported) {
+        reason.value = 'unsupported-scope'
+        return
+      }
+
+      const nextScopeSupport = activityService.getScopeSupport(targetScope.kind === 'account'
+        ? { kind: 'account', chainId: targetChainId }
+        : { kind: 'vault', chainId: targetChainId, vaultType: targetScope.vaultType })
+      scopeSupport.value = nextScopeSupport
+      // `unknown` means the route is requestable and response coverage is the
+      // authority. Only an explicit unsupported result hides the surface.
+      isSupported.value = nextScopeSupport !== 'unsupported'
+      reason.value = isSupported.value ? undefined : 'unsupported-scope'
+    }
+    catch {
+      if (requestId !== activeRequestId) return
+      reason.value = 'capability-check-failed'
+    }
+    finally {
+      if (requestId === activeRequestId) isChecking.value = false
+    }
+  }
+
+  watch([resolvedChainId, scopeKey], () => {
+    void checkAvailability()
+  }, { immediate: true })
+
+  const refreshAvailability = () => checkAvailability({ preserveCapabilityFailure: true })
+
+  onScopeDispose(() => {
+    activeRequestId++
+  })
+
+  return {
+    capabilities,
+    isChecking,
+    isSupported,
+    reason,
+    shouldRender,
+    scopeSupport,
+    refreshAvailability,
+  }
+}
diff --git a/composables/useActivityFeed.ts b/composables/useActivityFeed.ts
new file mode 100644
index 000000000..035eaf6f6
--- /dev/null
+++ b/composables/useActivityFeed.ts
@@ -0,0 +1,313 @@
+import type {
+  ActivityCategory,
+  ActivityCoverage,
+  ActivityEvent,
+  ActivityEventsMeta,
+  ActivityVaultType,
+} from '@eulerxyz/euler-v2-sdk'
+import type { Address } from 'viem'
+import {
+  computed,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  toValue,
+  watch,
+  type MaybeRefOrGetter,
+} from 'vue'
+import { subscribeToSdkQueryInvalidations } from '~/utils/sdk-query-cache'
+import { ACTIVITY_QUERY_STALE_TIME_MS } from '~/utils/sdk-query-policy'
+import {
+  filterActivityEventsForDisplay,
+  getDisplayActivityEventTypes,
+} from '~/utils/activity-display'
+
+export type ActivityFeedScope
+  = | { kind: 'account', owner: Address, chainId: number | readonly number[] }
+    | { kind: 'vault', vault: Address, chainId: number, vaultType: ActivityVaultType }
+
+interface UseActivityFeedOptions {
+  scope: MaybeRefOrGetter<ActivityFeedScope>
+  enabled: MaybeRefOrGetter<boolean>
+  categories: MaybeRefOrGetter<readonly ActivityCategory[]>
+  limit?: number
+}
+
+type ActivityLoadMode = 'initial' | 'refresh' | 'append'
+
+/** Bounded number of automatic follow-up pages fetched when display
+ *  filtering strips everything on the pages loaded so far. */
+const AUTO_DISPLAY_FILL_PAGE_LIMIT = 3
+
+const normalizedCategories = (categories: readonly ActivityCategory[]): ActivityCategory[] =>
+  [...new Set(categories)].sort()
+
+const scopeSdkChainId = (scope: ActivityFeedScope): number =>
+  typeof scope.chainId === 'number' ? scope.chainId : (scope.chainId[0] ?? 0)
+
+export const buildActivityFeedContextKey = (
+  scope: ActivityFeedScope,
+  categories: readonly ActivityCategory[],
+): string => {
+  const categoryKey = normalizedCategories(categories).join(',') || 'all'
+  if (scope.kind === 'account') {
+    const chainKey = typeof scope.chainId === 'number'
+      ? String(scope.chainId)
+      : [...scope.chainId].sort((left, right) => left - right).join(',')
+    return `account:${scope.owner.toLowerCase()}:${chainKey}:${categoryKey}`
+  }
+  return `vault:${scope.vaultType}:${scope.chainId}:${scope.vault.toLowerCase()}:${categoryKey}`
+}
+
+export const mergeActivityEvents = (
+  current: readonly ActivityEvent[],
+  incoming: readonly ActivityEvent[],
+): ActivityEvent[] => {
+  const seen = new Set<string>()
+  return [...current, ...incoming].filter((event) => {
+    if (seen.has(event.id)) return false
+    seen.add(event.id)
+    return true
+  })
+}
+
+const asError = (error: unknown): Error =>
+  error instanceof Error ? error : new Error(String(error))
+
+export const useActivityFeed = ({
+  scope,
+  enabled,
+  categories,
+  limit = 25,
+}: UseActivityFeedOptions) => {
+  const events = shallowRef<ActivityEvent[]>([])
+  const rawEvents = shallowRef<ActivityEvent[]>([])
+  const meta = shallowRef<ActivityEventsMeta>()
+  const error = shallowRef<Error>()
+  const loadMoreError = shallowRef<Error>()
+  const hasLoaded = ref(false)
+  const isLoading = ref(false)
+  const isRefreshing = ref(false)
+  const isLoadingMore = ref(false)
+  let activeRequestId = 0
+  let lastHeadLoadedAt: number | undefined
+  let pendingInvalidationRefresh = false
+  let pendingResumeRefresh = false
+  let pendingDisplayFill = false
+  let pendingDisplayFillPages = 0
+
+  const contextKey = computed(() =>
+    buildActivityFeedContextKey(toValue(scope), toValue(categories)),
+  )
+  const isEnabled = computed(() => Boolean(toValue(enabled)))
+  const coverage = computed<ActivityCoverage | undefined>(() => meta.value?.coverage)
+  const hasMore = computed(() => Boolean(meta.value?.hasMore && meta.value.nextCursor))
+  const isPartial = computed(() => coverage.value?.status === 'partial')
+  const isSyncing = computed(() => coverage.value?.status === 'syncing')
+  const isUnsupported = computed(() => coverage.value?.status === 'unsupported')
+  const hasColdError = computed(() => Boolean(error.value && events.value.length === 0))
+  const hasStaleError = computed(() => Boolean(error.value && events.value.length > 0))
+  const isEmpty = computed(() =>
+    hasLoaded.value
+    && !error.value
+    && coverage.value?.status === 'complete'
+    && events.value.length === 0
+    && !hasMore.value,
+  )
+
+  const resetForContext = () => {
+    events.value = []
+    rawEvents.value = []
+    meta.value = undefined
+    error.value = undefined
+    loadMoreError.value = undefined
+    hasLoaded.value = false
+    isLoading.value = false
+    isRefreshing.value = false
+    isLoadingMore.value = false
+    lastHeadLoadedAt = undefined
+    pendingInvalidationRefresh = false
+    pendingResumeRefresh = false
+    pendingDisplayFill = false
+    pendingDisplayFillPages = 0
+  }
+
+  const isHeadStale = () =>
+    lastHeadLoadedAt !== undefined
+    && Date.now() - lastHeadLoadedAt >= ACTIVITY_QUERY_STALE_TIME_MS
+
+  const fetchPage = async (mode: ActivityLoadMode) => {
+    if (!isEnabled.value) return
+    if (isLoading.value || isRefreshing.value || isLoadingMore.value) return
+    if (mode === 'append' && !hasMore.value) return
+
+    const requestId = ++activeRequestId
+    const requestContext = contextKey.value
+    const requestScope = toValue(scope)
+    const requestCategories = normalizedCategories(toValue(categories))
+    const cursor = mode === 'append' ? meta.value?.nextCursor ?? undefined : undefined
+    const coldRequest = mode === 'initial' || events.value.length === 0
+    if (mode !== 'append') {
+      pendingInvalidationRefresh = false
+      pendingResumeRefresh = false
+    }
+
+    if (mode === 'append') {
+      isLoadingMore.value = true
+      loadMoreError.value = undefined
+    }
+    else if (coldRequest) {
+      isLoading.value = true
+      error.value = undefined
+    }
+    else {
+      isRefreshing.value = true
+      error.value = undefined
+    }
+
+    try {
+      const { getEulerSdkForChain } = useEulerSdk()
+      const sdk = await getEulerSdkForChain(scopeSdkChainId(requestScope))
+      const eventTypes = getDisplayActivityEventTypes(requestScope)
+      const common = {
+        ...(requestCategories.length ? { categories: requestCategories } : {}),
+        ...(cursor ? { cursor } : {}),
+        eventTypes,
+        limit,
+      }
+      const page = requestScope.kind === 'account'
+        ? await sdk.activityService.fetchAccountActivityEvents({
+            owner: requestScope.owner,
+            chainId: requestScope.chainId,
+            ...common,
+          })
+        : await sdk.activityService.fetchVaultActivityEvents({
+            vault: requestScope.vault,
+            chainId: requestScope.chainId,
+            vaultType: requestScope.vaultType,
+            ...common,
+          })
+
+      if (requestId !== activeRequestId || requestContext !== contextKey.value || !isEnabled.value) return
+      if (mode === 'append' && page.meta.hasMore && page.meta.nextCursor === cursor) {
+        throw new Error('Activity pagination cursor did not advance')
+      }
+
+      rawEvents.value = mode === 'append'
+        ? mergeActivityEvents(rawEvents.value, page.data)
+        : mergeActivityEvents([], page.data)
+      // Zero-value liquidation rows are no-op artifacts on every scope.
+      events.value = filterActivityEventsForDisplay(rawEvents.value, eventTypes, {
+        hideZeroLiquidations: true,
+      })
+      meta.value = page.meta
+      error.value = undefined
+      loadMoreError.value = undefined
+      hasLoaded.value = true
+      if (mode !== 'append') {
+        lastHeadLoadedAt = Date.now()
+        pendingDisplayFillPages = AUTO_DISPLAY_FILL_PAGE_LIMIT
+      }
+      // Display filtering can strip an entire page (e.g. zero-value
+      // liquidations), presenting a false empty state while older pages hold
+      // visible rows. Keep fetching a bounded number of pages until something
+      // is displayable.
+      if (
+        events.value.length === 0
+        && page.meta.hasMore
+        && page.meta.nextCursor
+        && pendingDisplayFillPages > 0
+      ) {
+        pendingDisplayFillPages -= 1
+        pendingDisplayFill = true
+      }
+    }
+    catch (caught) {
+      if (requestId !== activeRequestId || requestContext !== contextKey.value || !isEnabled.value) return
+      if (mode === 'append') loadMoreError.value = asError(caught)
+      else error.value = asError(caught)
+      hasLoaded.value = true
+    }
+    finally {
+      if (requestId === activeRequestId) {
+        isLoading.value = false
+        isRefreshing.value = false
+        isLoadingMore.value = false
+        if (pendingInvalidationRefresh && isEnabled.value && hasLoaded.value) {
+          void fetchPage('refresh')
+        }
+        else if (pendingDisplayFill && isEnabled.value) {
+          pendingDisplayFill = false
+          void fetchPage('append')
+        }
+      }
+    }
+  }
+
+  const refresh = () => fetchPage('refresh')
+  const loadMore = () => fetchPage('append')
+
+  const unsubscribeFromInvalidations = subscribeToSdkQueryInvalidations((queryNames) => {
+    const queryName = toValue(scope).kind === 'account'
+      ? 'queryAccountActivityEvents'
+      : 'queryVaultActivityEvents'
+    if (!queryNames.has(queryName)) return
+
+    pendingInvalidationRefresh = true
+    if (isEnabled.value && hasLoaded.value) void fetchPage('refresh')
+  })
+
+  watch([contextKey, isEnabled], ([nextContext, nextEnabled], previous) => {
+    const previousContext = previous?.[0]
+    const previousEnabled = previous?.[1] ?? false
+    const contextChanged = previousContext === undefined || previousContext !== nextContext
+
+    if (contextChanged) {
+      activeRequestId++
+      resetForContext()
+    }
+    if (!nextEnabled) {
+      if (isLoading.value || isRefreshing.value) pendingResumeRefresh = true
+      activeRequestId++
+      isLoading.value = false
+      isRefreshing.value = false
+      isLoadingMore.value = false
+      return
+    }
+    if (contextChanged || !hasLoaded.value) {
+      void fetchPage('initial')
+    }
+    else if (
+      !previousEnabled
+      && (pendingInvalidationRefresh || pendingResumeRefresh || isHeadStale() || hasColdError.value)
+    ) {
+      void fetchPage('refresh')
+    }
+  }, { immediate: true })
+
+  onScopeDispose(() => {
+    activeRequestId++
+    unsubscribeFromInvalidations()
+  })
+
+  return {
+    coverage,
+    error,
+    events,
+    hasColdError,
+    hasLoaded,
+    hasMore,
+    hasStaleError,
+    isEmpty,
+    isLoading,
+    isLoadingMore,
+    isPartial,
+    isRefreshing,
+    isSyncing,
+    isUnsupported,
+    loadMore,
+    loadMoreError,
+    meta,
+    refresh,
+  }
+}
diff --git a/composables/useActivityLiquidationDetails.ts b/composables/useActivityLiquidationDetails.ts
new file mode 100644
index 000000000..5595a0414
--- /dev/null
+++ b/composables/useActivityLiquidationDetails.ts
@@ -0,0 +1,176 @@
+import type { ActivityEvent, LiquidationRecord } from '@eulerxyz/euler-v2-sdk'
+import {
+  computed,
+  onScopeDispose,
+  ref,
+  toValue,
+  watch,
+  type MaybeRefOrGetter,
+} from 'vue'
+import { logWarn } from '~/utils/errorHandling'
+
+/** Bounded offset pages fetched per vault window — beyond this, the affected
+ *  rows simply stay unenriched. */
+const MAX_LIQUIDATION_PAGES = 3
+const LIQUIDATION_PAGE_LIMIT = 100
+
+interface UseActivityLiquidationDetailsOptions {
+  events: MaybeRefOrGetter<readonly ActivityEvent[]>
+  enabled?: MaybeRefOrGetter<boolean>
+}
+
+interface LiquidationFetchGroup {
+  key: string
+  chainId: number
+  vault: string
+  from: number
+  to: number
+}
+
+const eventUnixTimestamp = (event: ActivityEvent): number | undefined => {
+  const parsed = Math.floor(Date.parse(event.timestamp) / 1_000)
+  return Number.isFinite(parsed) ? parsed : undefined
+}
+
+const readEventString = (value: unknown): string | undefined =>
+  typeof value === 'string' && value ? value : undefined
+
+/**
+ * A liquidation event and its `/v3/liquidations` record describe the same
+ * on-chain occurrence; there is no shared log index, so the join key is the
+ * full identifying tuple. Amounts disambiguate multiple liquidations of the
+ * same position inside one transaction.
+ */
+const liquidationEventJoinKey = (event: ActivityEvent): string | undefined => {
+  if (event.type !== 'liquidation' || !event.vault) return undefined
+  const violator = readEventString(event.payload?.violator) ?? event.account
+  const collateral = readEventString(event.payload?.collateral)
+    ?? event.assets?.find(asset => asset.kind === 'collateral')?.address
+  const repayAssets = readEventString(event.payload?.repay_assets)
+    ?? event.assets?.find(asset => asset.kind === 'assets')?.amountRaw
+  if (!violator || !collateral || repayAssets === undefined) return undefined
+  return [
+    event.chainId,
+    event.txHash,
+    event.vault,
+    violator,
+    collateral,
+    repayAssets,
+  ].join(':').toLowerCase()
+}
+
+const liquidationRecordJoinKey = (record: LiquidationRecord): string => [
+  record.chainId,
+  record.txHash,
+  record.vault,
+  record.violator,
+  record.collateral,
+  record.repayAssets,
+].join(':').toLowerCase()
+
+/**
+ * Enriches displayed liquidation events with historical valuations from the
+ * standalone `/v3/liquidations` endpoint (event-time USD amounts, seized
+ * collateral converted to underlying units, and the liquidator bonus).
+ *
+ * Fail-soft by design: rows without a matching record render exactly as they
+ * do today, so an unavailable endpoint never degrades the feed itself.
+ */
+export const useActivityLiquidationDetails = ({
+  events,
+  enabled = true,
+}: UseActivityLiquidationDetailsOptions) => {
+  const recordsByJoinKey = new Map<string, LiquidationRecord>()
+  const recordsVersion = ref(0)
+  /** Windows already fetched (or being fetched) per chain+vault group. */
+  const coveredWindows = new Map<string, { from: number, to: number }>()
+  let disposed = false
+
+  const liquidationEvents = computed(() =>
+    toValue(events).filter(event => event.type === 'liquidation' && event.vault))
+
+  const fetchGroups = computed<LiquidationFetchGroup[]>(() => {
+    const groups = new Map<string, LiquidationFetchGroup>()
+    for (const event of liquidationEvents.value) {
+      const timestamp = eventUnixTimestamp(event)
+      if (!event.vault || timestamp === undefined) continue
+      const key = `${event.chainId}:${event.vault.toLowerCase()}`
+      const group = groups.get(key)
+      if (!group) {
+        // ±1s pads Date.parse truncation on both window edges.
+        groups.set(key, {
+          key,
+          chainId: event.chainId,
+          vault: event.vault,
+          from: timestamp - 1,
+          to: timestamp + 1,
+        })
+      }
+      else {
+        group.from = Math.min(group.from, timestamp - 1)
+        group.to = Math.max(group.to, timestamp + 1)
+      }
+    }
+    return [...groups.values()]
+  })
+
+  const fetchGroup = async (group: LiquidationFetchGroup) => {
+    const covered = coveredWindows.get(group.key)
+    if (covered && covered.from <= group.from && covered.to >= group.to) return
+    // Claim the widened window up front so concurrent triggers do not refetch;
+    // on failure the claim is rolled back and the next window change retries.
+    const claimed = {
+      from: Math.min(group.from, covered?.from ?? group.from),
+      to: Math.max(group.to, covered?.to ?? group.to),
+    }
+    coveredWindows.set(group.key, claimed)
+
+    try {
+      const { getEulerSdkForChain } = useEulerSdk()
+      const sdk = await getEulerSdkForChain(group.chainId)
+      for (let page = 0; page < MAX_LIQUIDATION_PAGES; page++) {
+        const result = await sdk.activityService.fetchLiquidations({
+          chainId: group.chainId,
+          vault: group.vault as `0x${string}`,
+          from: claimed.from,
+          to: claimed.to,
+          limit: LIQUIDATION_PAGE_LIMIT,
+          offset: page * LIQUIDATION_PAGE_LIMIT,
+        })
+        if (disposed) return
+        for (const record of result.data) {
+          recordsByJoinKey.set(liquidationRecordJoinKey(record), record)
+        }
+        if (result.data.length) recordsVersion.value++
+        if (result.meta.offset + result.data.length >= result.meta.total) break
+      }
+    }
+    catch (err) {
+      if (covered) coveredWindows.set(group.key, covered)
+      else coveredWindows.delete(group.key)
+      logWarn('useActivityLiquidationDetails/fetchGroup', err)
+    }
+  }
+
+  watch(
+    [fetchGroups, () => Boolean(toValue(enabled))],
+    ([groups, isEnabled]) => {
+      if (!isEnabled) return
+      for (const group of groups) void fetchGroup(group)
+    },
+    { immediate: true },
+  )
+
+  onScopeDispose(() => {
+    disposed = true
+  })
+
+  const getLiquidationDetails = (event: ActivityEvent): LiquidationRecord | undefined => {
+    // Re-resolve as records arrive.
+    void recordsVersion.value
+    const key = liquidationEventJoinKey(event)
+    return key === undefined ? undefined : recordsByJoinKey.get(key)
+  }
+
+  return { getLiquidationDetails }
+}
diff --git a/composables/useActivityNowMs.ts b/composables/useActivityNowMs.ts
new file mode 100644
index 000000000..250492c70
--- /dev/null
+++ b/composables/useActivityNowMs.ts
@@ -0,0 +1,15 @@
+import { onScopeDispose, readonly, ref } from 'vue'
+
+export const ACTIVITY_CLOCK_INTERVAL_MS = 60_000
+
+export const useActivityNowMs = () => {
+  const nowMs = ref(Date.now())
+  if (typeof window === 'undefined') return readonly(nowMs)
+
+  const interval = window.setInterval(() => {
+    nowMs.value = Date.now()
+  }, ACTIVITY_CLOCK_INTERVAL_MS)
+  onScopeDispose(() => window.clearInterval(interval))
+
+  return readonly(nowMs)
+}
diff --git a/composables/useApyVisibility.ts b/composables/useApyVisibility.ts
index 2950a4989..0b4ca511a 100644
--- a/composables/useApyVisibility.ts
+++ b/composables/useApyVisibility.ts
@@ -8,12 +8,11 @@ import type { YieldApyBreakdown } from '@eulerxyz/euler-v2-sdk'
 //     toggles, so this lives Lite-side.
 export const useApyVisibility = () => {
   const { settings } = useUserSettings()
-  const { address: connectedAddress } = useWagmi()
-  const { spyAddress } = useSpyMode()
+  // Never falls back to the connected wallet while a spy candidate is still
+  // verifying — that would apply the wrong user's reward eligibility.
+  const { effectiveAddress } = useEffectiveAddress()
 
-  const viewer = computed<string | undefined>(() =>
-    spyAddress.value || connectedAddress.value || undefined,
-  )
+  const viewer = computed<string | undefined>(() => effectiveAddress.value || undefined)
 
   const visibleTotal = (breakdown: YieldApyBreakdown | undefined): number | undefined => {
     if (!breakdown) return undefined
diff --git a/composables/useEulerAccount.ts b/composables/useEulerAccount.ts
index 58f3f3b05..391ce35dc 100644
--- a/composables/useEulerAccount.ts
+++ b/composables/useEulerAccount.ts
@@ -87,9 +87,11 @@ export const useEulerAccount = () => {
   const { isReady: isLabelsReady } = useEulerLabels()
   const { isReady: isVaultsReady } = useVaults()
   const { isReady: isEulerAddressesReady, chainId } = useEulerAddresses()
-  const { address } = useWagmi()
-  const { spyAddress } = useSpyMode()
-  const portfolioAddress = computed(() => normalizeAddressOrEmpty(spyAddress.value) || normalizeAddressOrEmpty(address.value))
+  // Never falls back to the connected wallet while a spy candidate is still
+  // verifying — the portfolio must not show the connected user's positions
+  // under an active spy banner.
+  const { effectiveAddress } = useEffectiveAddress()
+  const portfolioAddress = computed(() => normalizeAddressOrEmpty(effectiveAddress.value ?? ''))
 
   const markLoaded = () => {
     isPositionsLoading.value = false
@@ -254,7 +256,9 @@ export const useEulerAccount = () => {
   }))
 
   const getPositionBySubAccountIndex = (subAccountIndex: number): PortfolioBorrowPosition<VaultEntity> | undefined => {
-    const owner = portfolioAddress.value || address.value
+    // portfolioAddress is already the spy-safe acting address (spied owner,
+    // or the connected wallet outside spy mode).
+    const owner = portfolioAddress.value
     if (!owner) return undefined
 
     return allBorrowPositions.value.find((position) => {
diff --git a/composables/usePortfolioActivityRuntimeSupport.ts b/composables/usePortfolioActivityRuntimeSupport.ts
new file mode 100644
index 000000000..09877d5a3
--- /dev/null
+++ b/composables/usePortfolioActivityRuntimeSupport.ts
@@ -0,0 +1,67 @@
+import { computed, toValue, type MaybeRefOrGetter } from 'vue'
+
+interface PortfolioActivityRuntimeState {
+  contextKey?: string
+  unsupported: boolean
+}
+
+export const buildPortfolioActivityContextKey = (
+  owner: string | null | undefined,
+  chainId: number | string | null | undefined,
+): string | undefined => {
+  const resolvedChainId = Number(chainId)
+  if (!owner || !Number.isSafeInteger(resolvedChainId) || resolvedChainId <= 0) return undefined
+  return `${owner.toLowerCase()}:${resolvedChainId}`
+}
+
+export const shouldShowPortfolioActivityTab = (
+  availabilityShouldRender: boolean,
+  runtimeUnsupported: boolean,
+): boolean => availabilityShouldRender && !runtimeUnsupported
+
+export const shouldLeavePortfolioActivityRoute = ({
+  routeName,
+  isChecking,
+  shouldShow,
+}: {
+  routeName: string | symbol | null | undefined
+  isChecking: boolean
+  shouldShow: boolean
+}): boolean => routeName === 'portfolio-activity' && !isChecking && !shouldShow
+
+export const usePortfolioActivityRuntimeSupport = (
+  owner: MaybeRefOrGetter<string | null | undefined>,
+  chainId: MaybeRefOrGetter<number | string | null | undefined>,
+) => {
+  const state = useState<PortfolioActivityRuntimeState>('portfolio-activity-runtime-support', () => ({
+    unsupported: false,
+  }))
+  const contextKey = computed(() =>
+    buildPortfolioActivityContextKey(toValue(owner), toValue(chainId)),
+  )
+  const isRuntimeUnsupported = computed(() =>
+    Boolean(
+      contextKey.value
+      && state.value.contextKey === contextKey.value
+      && state.value.unsupported,
+    ),
+  )
+
+  const setRuntimeUnsupported = (unsupported: boolean) => {
+    const key = contextKey.value
+    if (!key) return
+    state.value = { contextKey: key, unsupported }
+  }
+
+  const clearRuntimeUnsupported = () => {
+    if (state.value.contextKey !== contextKey.value) return
+    state.value = { unsupported: false }
+  }
+
+  return {
+    clearRuntimeUnsupported,
+    contextKey,
+    isRuntimeUnsupported,
+    setRuntimeUnsupported,
+  }
+}
diff --git a/composables/useREULLocks.ts b/composables/useREULLocks.ts
index 60634c627..91c94186c 100644
--- a/composables/useREULLocks.ts
+++ b/composables/useREULLocks.ts
@@ -14,12 +14,16 @@ let interval: NodeJS.Timeout | null = null
 const lockGuard = createRaceGuard()
 
 export const useREULLocks = () => {
-  const { isConnected, address: wagmiAddress, chainId: walletChainId } = useWagmi()
+  // The connected wallet stays the transaction signer; only display/query
+  // address selection is spy-aware.
+  const { address: wagmiAddress, chainId: walletChainId } = useWagmi()
   const { eulerTokenAddresses, chainId: addressesChainId } = useEulerAddresses()
-  const { spyAddress } = useSpyMode()
+  // Never falls back to the connected wallet while a spy candidate is still
+  // verifying — locks would otherwise show the wrong user's balances.
+  const { effectiveAddress: spySafeAddress } = useEffectiveAddress()
 
-  const effectiveAddress = computed(() => spyAddress.value || wagmiAddress.value || '')
-  const isActive = computed(() => isConnected.value || Boolean(spyAddress.value))
+  const effectiveAddress = computed(() => spySafeAddress.value || '')
+  const isActive = computed(() => Boolean(effectiveAddress.value))
   const selectedChainId = computed(() => addressesChainId.value || walletChainId.value)
 
   const reulTokenContractAddress = computed(() => eulerTokenAddresses.value?.rEUL ?? '')
diff --git a/composables/useRewardsApy.ts b/composables/useRewardsApy.ts
index f5eb43a5a..d81749bf1 100644
--- a/composables/useRewardsApy.ts
+++ b/composables/useRewardsApy.ts
@@ -9,8 +9,7 @@ export const useRewardsApy = () => {
   const { settings } = useUserSettings()
   const { enableMerkl, enableIncentra, enableFuul, enableTurtle } = useDeployConfig()
   const { getVault, registryVersion } = useVaultRegistry()
-  const { address: connectedAddress } = useWagmi()
-  const { spyAddress } = useSpyMode()
+  const { effectiveAddress } = useEffectiveAddress()
 
   const isEnabled = computed(() => settings.value.enableRewardsApy)
 
@@ -18,9 +17,9 @@ export const useRewardsApy = () => {
   // to see what the spied user actually earns), otherwise the connected
   // wallet. When neither is set the filter is a no-op — discovery surfaces
   // keep the full "headline" APR visible to unconnected visitors.
-  const eligibilityAddress = computed(() =>
-    spyAddress.value || connectedAddress.value || undefined,
-  )
+  // `effectiveAddress` never falls back to the connected wallet while a spy
+  // candidate is still verifying — that would show the wrong user's rewards.
+  const eligibilityAddress = computed(() => effectiveAddress.value || undefined)
 
   // Reactive version counter — bumps when any underlying data or settings change.
   // Consumers should read `version.value` in the sync phase of watchEffect(async)
diff --git a/composables/useSpyMode.ts b/composables/useSpyMode.ts
index c55f8788e..192fceb55 100644
--- a/composables/useSpyMode.ts
+++ b/composables/useSpyMode.ts
@@ -4,6 +4,8 @@ import { logWarn } from '~/utils/errorHandling'
 import { evcGetAccountOwnerAbi } from '~/abis/evc'
 
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+const OWNER_RESOLUTION_RETRY_DELAY_MS = 4_000
+const OWNER_RESOLUTION_MAX_RETRIES = 5
 
 /** viem's isAddress validates EIP-55 checksum on mixed-case input — normalize to lowercase first */
 const isValidAddress = (value: string): boolean =>
@@ -12,43 +14,69 @@ const isValidAddress = (value: string): boolean =>
 const normalizeAddress = (value: string): string =>
   getAddress(value.toLowerCase() as `0x${string}`)
 
+/** Owner-verified address — the only value consumers may query or display. */
 const spyAddress = ref('')
+/** Unverified candidate awaiting EVC owner resolution. Never consumed. */
+const pendingSpyAddress = ref('')
 let watchersInitialized = false
-let ownerResolved = false
 let explicitlyCleared = false
+let ownerResolutionRequestId = 0
 
 /** Lightweight accessor for middleware — avoids useRoute() */
 export const getSpyModeState = () => ({
   spyAddress: computed(() => spyAddress.value),
-  isSpyMode: computed(() => Boolean(spyAddress.value)),
+  /** Value to persist in the URL: the verified address, or the user-supplied
+   *  candidate while resolution is still pending. Never render this. */
+  spyQueryValue: computed(() => spyAddress.value || pendingSpyAddress.value),
+  isSpyMode: computed(() => Boolean(spyAddress.value || pendingSpyAddress.value)),
 })
 
 export const useSpyMode = () => {
   const route = useRoute()
   const router = useRouter()
 
-  const isSpyMode = computed(() => Boolean(spyAddress.value))
+  const isSpyMode = computed(() => Boolean(spyAddress.value || pendingSpyAddress.value))
+  const isSpyResolving = computed(() => Boolean(pendingSpyAddress.value))
   const spyShortAddress = computed(() => spyAddress.value ? truncate(spyAddress.value) : '')
 
+  const activateSpyMode = (address: string): boolean => {
+    if (!isValidAddress(address)) return false
+    explicitlyCleared = false
+    const normalized = normalizeAddress(address)
+    // Already verified — re-verification would only blank the UI.
+    if (normalized === spyAddress.value && !pendingSpyAddress.value) return true
+    // Already pending — the in-flight owner resolution stays authoritative.
+    // Bumping the request id here would discard its result and strand the
+    // candidate in the unresolved state forever.
+    if (normalized === pendingSpyAddress.value) return true
+    // Fail closed: the candidate stays out of `spyAddress` (and therefore out
+    // of every query and display surface) until the EVC confirms its owner.
+    pendingSpyAddress.value = normalized
+    spyAddress.value = ''
+    ownerResolutionRequestId += 1
+    return true
+  }
+
   // Try to pick up ?spy= — route.query may not be populated yet, so read from window.location
-  if (!spyAddress.value && !explicitlyCleared && import.meta.client) {
+  if (!spyAddress.value && !explicitlyCleared && typeof window !== 'undefined') {
     const spy = new URLSearchParams(window.location.search).get('spy')
       || (route.query.spy as string | undefined)
     if (spy && isValidAddress(spy)) {
-      spyAddress.value = normalizeAddress(spy)
+      activateSpyMode(spy)
     }
   }
 
-  if (!watchersInitialized && import.meta.client) {
+  if (!watchersInitialized && typeof window !== 'undefined') {
     watchersInitialized = true
 
     const { eulerCoreAddresses, chainId } = useEulerAddresses()
     const { client: rpcClient } = useRpcClient()
 
-    const resolveOwner = async (address: string): Promise<string> => {
+    /** `null` = the lookup could not run or failed — NOT an answer. */
+    const resolveOwner = async (address: string): Promise<string | null> => {
       try {
         const evcAddress = eulerCoreAddresses.value?.evc
-        if (!evcAddress || !chainId.value || !rpcClient.value) return address
+        if (!evcAddress || !chainId.value || !rpcClient.value) return null
 
         const owner = await rpcClient.value.readContract({
           address: evcAddress as `0x${string}`,
@@ -61,43 +89,71 @@ export const useSpyMode = () => {
         if (owner && owner !== ZERO_ADDRESS && getAddress(owner) !== getAddress(address)) {
           return getAddress(owner)
         }
+        // Authoritative answer: the address is its own owner (or was never
+        // EVC-registered, in which case it cannot be a sub-account).
+        return address
       }
       catch (err) {
         logWarn('useSpyMode/resolveOwner', err)
+        return null
       }
-      return address
     }
 
-    const applyResolved = (resolved: string) => {
-      if (resolved !== spyAddress.value) {
-        spyAddress.value = resolved
+    const applyResolved = (
+      sourceAddress: string,
+      resolved: string | null,
+      requestId: number,
+      attempt = 0,
+    ) => {
+      if (requestId !== ownerResolutionRequestId || pendingSpyAddress.value !== sourceAddress) return
+
+      if (resolved === null) {
+        // Fail closed: a failed lookup never counts as resolution — the
+        // candidate stays pending (unconsumed, undisplayed). Retry while this
+        // spy session is still active.
+        if (attempt < OWNER_RESOLUTION_MAX_RETRIES) {
+          setTimeout(() => {
+            if (requestId !== ownerResolutionRequestId || pendingSpyAddress.value !== sourceAddress) return
+            resolveOwner(sourceAddress).then(nextResolved =>
+              applyResolved(sourceAddress, nextResolved, requestId, attempt + 1))
+          }, OWNER_RESOLUTION_RETRY_DELAY_MS)
+        }
+        return
+      }
+
+      pendingSpyAddress.value = ''
+      spyAddress.value = resolved
+      if (resolved !== sourceAddress || route.query.spy !== resolved) {
         router.replace({
           path: route.path,
           query: { ...route.query, spy: resolved },
           hash: route.hash,
         })
       }
-      ownerResolved = true
     }
 
     // Watch route query to pick up ?spy= on initial load and navigation
     watch(
       () => route.query.spy,
       (spy) => {
-        if (spy && typeof spy === 'string' && isValidAddress(spy) && !spyAddress.value && !explicitlyCleared) {
-          spyAddress.value = normalizeAddress(spy)
-          ownerResolved = false
+        if (!spy || typeof spy !== 'string' || !isValidAddress(spy)) return
+        const nextAddress = normalizeAddress(spy)
+        if (nextAddress !== spyAddress.value && nextAddress !== pendingSpyAddress.value) {
+          activateSpyMode(nextAddress)
         }
       },
       { immediate: true },
     )
 
-    // Resolve owner once both spy address AND EVC are available
+    // Resolve the pending candidate once the EVC and RPC client are both
+    // available — resolution is the only path that promotes a candidate into
+    // the consumable spyAddress.
     watch(
-      [() => spyAddress.value, () => eulerCoreAddresses.value?.evc],
-      ([addr, evc]) => {
-        if (addr && evc && !ownerResolved) {
-          resolveOwner(addr).then(applyResolved)
+      [() => pendingSpyAddress.value, () => eulerCoreAddresses.value?.evc, rpcClient],
+      ([candidate, evc, client]) => {
+        if (candidate && evc && client) {
+          const requestId = ++ownerResolutionRequestId
+          resolveOwner(candidate).then(resolved => applyResolved(candidate, resolved, requestId))
         }
       },
       { immediate: true },
@@ -105,14 +161,13 @@ export const useSpyMode = () => {
   }
 
   const setSpyMode = async (address: string) => {
-    if (!isValidAddress(address)) return
-    explicitlyCleared = false
-    spyAddress.value = normalizeAddress(address)
-    ownerResolved = false
+    if (!activateSpyMode(address)) return
 
     await router.replace({
       path: route.path,
-      query: { ...route.query, spy: spyAddress.value },
+      // The candidate is what was just activated; the verified address only
+      // exists when activation short-circuited on an already-verified value.
+      query: { ...route.query, spy: pendingSpyAddress.value || spyAddress.value },
       hash: route.hash,
     })
   }
@@ -120,7 +175,8 @@ export const useSpyMode = () => {
   const clearSpyMode = async () => {
     explicitlyCleared = true
     spyAddress.value = ''
-    ownerResolved = false
+    pendingSpyAddress.value = ''
+    ownerResolutionRequestId += 1
     const { spy: _spy, ...rest } = route.query
     await router.replace({
       path: route.path,
@@ -132,7 +188,9 @@ export const useSpyMode = () => {
   return {
     spyAddress: computed(() => spyAddress.value),
     isSpyMode,
+    isSpyResolving,
     spyShortAddress,
+    activateSpyMode,
     setSpyMode,
     clearSpyMode,
   }
diff --git a/middleware/02.spy-param.global.ts b/middleware/02.spy-param.global.ts
index c793502f1..5824574d8 100644
--- a/middleware/02.spy-param.global.ts
+++ b/middleware/02.spy-param.global.ts
@@ -5,13 +5,13 @@ export default defineNuxtRouteMiddleware((to) => {
 
   // If spy mode is active (address in memory) but ?spy missing from target route — re-add it
   if (!spyParam) {
-    const { spyAddress, isSpyMode } = getSpyModeState()
+    const { spyQueryValue, isSpyMode } = getSpyModeState()
     if (isSpyMode.value) {
       return navigateTo({
         path: to.path,
         query: {
           ...to.query,
-          spy: spyAddress.value,
+          spy: spyQueryValue.value,
         },
         hash: to.hash,
       })
diff --git a/package-lock.json b/package-lock.json
index 6a34c2bf1..ed2e04861 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,7 +8,7 @@
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
-        "@eulerxyz/euler-v2-sdk": "1.2.2",
+        "@eulerxyz/euler-v2-sdk": "1.2.3",
         "@floating-ui/vue": "2.0.1",
         "@gvade/nuxt3-svg-sprite": "1.0.3",
         "@keyringnetwork/keyring-connect-sdk": "3.2.0",
@@ -1507,9 +1507,9 @@
       }
     },
     "node_modules/@eulerxyz/euler-v2-sdk": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/@eulerxyz/euler-v2-sdk/-/euler-v2-sdk-1.2.2.tgz",
-      "integrity": "sha512-AqPplPeKqokwoRE0ZGbSSdGdZJVt1T9n9Kn1rXm8sgWAxbylh1KF1YaKQwLbjxfwSFxh9FY+ggMFb+l1rLocmw==",
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@eulerxyz/euler-v2-sdk/-/euler-v2-sdk-1.2.3.tgz",
+      "integrity": "sha512-lvuzHnmSlbzXRSwsSJqWcOTzqtf4FzGePxxrxvPBUe19TLxN6/BkUwlgrH0esnYKWOxTw8nJbXxhV/GeXd+WPA==",
       "license": "MIT",
       "dependencies": {
         "viem": "2.48.8"
@@ -2186,6 +2186,28 @@
         }
       }
     },
+    "node_modules/@nuxt/cli/node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@nuxt/cli/node_modules/commander": {
+      "version": "13.1.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
+      "integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@nuxt/devalue": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/@nuxt/devalue/-/devalue-2.0.2.tgz",
@@ -9870,6 +9892,22 @@
         }
       }
     },
+    "node_modules/devframe/node_modules/crossws": {
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/crossws/-/crossws-0.4.10.tgz",
+      "integrity": "sha512-pz3oubH/dt12KjqsUB0IuXW4nwRDQ583iDsP4555Cpdqx0NoU7pGlWBcayyFI8f/l/idRpgjMEfwuOxSWJYlIA==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "peerDependencies": {
+        "srvx": ">=0.11.5"
+      },
+      "peerDependenciesMeta": {
+        "srvx": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/devframe/node_modules/h3": {
       "version": "2.0.1-rc.22",
       "resolved": "https://registry.npmjs.org/h3/-/h3-2.0.1-rc.22.tgz",
diff --git a/package.json b/package.json
index 54fdb4e9f..e9f493ff1 100644
--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
     ]
   },
   "dependencies": {
-    "@eulerxyz/euler-v2-sdk": "1.2.2",
+    "@eulerxyz/euler-v2-sdk": "1.2.3",
     "@floating-ui/vue": "2.0.1",
     "@gvade/nuxt3-svg-sprite": "1.0.3",
     "@keyringnetwork/keyring-connect-sdk": "3.2.0",
diff --git a/pages/portfolio.vue b/pages/portfolio.vue
index ad0eee945..3cb6ec7a0 100644
--- a/pages/portfolio.vue
+++ b/pages/portfolio.vue
@@ -26,7 +26,7 @@ const { rewards } = useSdkRewards()
 const { locks, refreshLocks } = useREULLocks()
 const { isConnected, address, spyAddress, effectiveAddress, isSpyMode } = useEffectiveAddress()
 const { isLoaded: isBalancesLoaded, updateBalances } = useWallets()
-const { eulerLensAddresses } = useEulerAddresses()
+const { chainId, eulerLensAddresses } = useEulerAddresses()
 const { portfolioRefreshCounter } = usePortfolioRefresh()
 const showAllLabelEntries = useShowAllLabelEntries()
 const {
@@ -35,6 +35,12 @@ const {
   error: migrationError,
   hasLoaded: hasMigrationLoaded,
 } = useExternalMigrationPositions()
+const activityAvailability = useActivityAvailability({ kind: 'account' }, chainId)
+const activityRuntimeSupport = usePortfolioActivityRuntimeSupport(effectiveAddress, chainId)
+const showActivityTab = computed(() => shouldShowPortfolioActivityTab(
+  activityAvailability.shouldRender.value,
+  activityRuntimeSupport.isRuntimeUnsupported.value,
+))
 
 const interval: Ref<NodeJS.Timeout | null> = ref(null)
 const hasShownMigrationTab = ref(false)
@@ -107,6 +113,13 @@ const tabs = computed(() => {
     },
   ]
 
+  if (showActivityTab.value) {
+    items.push({
+      label: 'Activity',
+      value: 'portfolio-activity',
+    })
+  }
+
   if (showMigrationTab.value) {
     items.push({
       label: 'Migrate',
@@ -133,6 +146,21 @@ watch([() => route.name, showMigrationTab, hasMigrationLoaded, isMigrationLoadin
   }
 })
 
+watch([
+  () => route.name,
+  showActivityTab,
+  activityAvailability.isChecking,
+  activityAvailability.reason,
+], () => {
+  if (shouldLeavePortfolioActivityRoute({
+    routeName: route.name,
+    isChecking: activityAvailability.isChecking.value,
+    shouldShow: showActivityTab.value,
+  })) {
+    router.replace({ name: 'portfolio', query: route.query })
+  }
+}, { immediate: true })
+
 const portfolioNetApyDisplay = computed(() =>
   Number.isFinite(portfolioNetApy.value) ? `${formatNumber(portfolioNetApy.value)}%` : '-',
 )
diff --git a/pages/portfolio/activity.vue b/pages/portfolio/activity.vue
new file mode 100644
index 000000000..8a896aef7
--- /dev/null
+++ b/pages/portfolio/activity.vue
@@ -0,0 +1,97 @@
+<script setup lang="ts">
+import type { Address } from 'viem'
+import { getAddress, isAddress } from 'viem'
+import type { ActivityFeedScope } from '~/composables/useActivityFeed'
+import { getAccountActivityCategories, getAccountActivityFilterOptions } from '~/utils/activity-display'
+
+defineOptions({
+  name: 'PortfolioActivityPage',
+})
+
+const route = useRoute()
+const { chainId } = useEulerAddresses()
+const { effectiveAddress } = useEffectiveAddress()
+const owner = computed<Address | undefined>(() => {
+  const value = effectiveAddress.value
+  return value && isAddress(value) ? getAddress(value) : undefined
+})
+const availability = useActivityAvailability({ kind: 'account' }, chainId)
+const runtimeSupport = usePortfolioActivityRuntimeSupport(owner, chainId)
+const categoryOptions = getAccountActivityFilterOptions()
+const unfilteredCategories = getAccountActivityCategories()
+const isActive = computed(() => route.name === 'portfolio-activity')
+const feedScope = computed<ActivityFeedScope | undefined>(() => owner.value
+  ? {
+      kind: 'account',
+      owner: owner.value,
+      chainId: Number(chainId.value),
+    }
+  : undefined,
+)
+
+watch([owner, () => Number(chainId.value)], () => {
+  runtimeSupport.setRuntimeUnsupported(false)
+})
+</script>
+
+<template>
+  <section class="mx-16 flex flex-col gap-16">
+    <div
+      v-if="!owner"
+      class="flex min-h-160 flex-1 items-center justify-center"
+    >
+      <PortfolioEmptyState
+        :active="false"
+        active-text="You don't have activity yet"
+        inactive-text="Connect your wallet to see your activity"
+      />
+    </div>
+
+    <div
+      v-else-if="availability.isChecking.value"
+      class="flex flex-col gap-8"
+      aria-label="Checking activity availability"
+    >
+      <div
+        v-for="index in 3"
+        :key="index"
+        class="h-72 animate-pulse rounded-12 bg-surface"
+      />
+    </div>
+
+    <div
+      v-else-if="availability.reason.value === 'capability-check-failed'"
+      class="flex flex-col items-center gap-12 rounded-12 border border-line-subtle bg-surface p-24 text-center"
+      role="alert"
+    >
+      <div class="text-p3 text-content-primary">
+        Activity availability could not be checked right now.
+      </div>
+      <button
+        type="button"
+        class="ui-button ui-button--medium ui-button--secondary"
+        :disabled="availability.isChecking.value"
+        @click="availability.refreshAvailability"
+      >
+        {{ availability.isChecking.value ? 'Retrying…' : 'Retry' }}
+      </button>
+    </div>
+
+    <ActivityFeed
+      v-else-if="feedScope && availability.isSupported.value"
+      :scope="feedScope"
+      :enabled="isActive"
+      :category-options="categoryOptions"
+      :unfiltered-categories="unfilteredCategories"
+      subject="account"
+      @update:unsupported="runtimeSupport.setRuntimeUnsupported"
+    />
+
+    <div
+      v-else
+      class="rounded-12 border border-line-subtle bg-surface p-16 text-p3 text-content-secondary"
+    >
+      Activity is not available on this network.
+    </div>
+  </section>
+</template>
diff --git a/pages/portfolio/index.vue b/pages/portfolio/index.vue
index 2e0d2a060..6ca7c6730 100644
--- a/pages/portfolio/index.vue
+++ b/pages/portfolio/index.vue
@@ -2,13 +2,16 @@
 import { getSubAccountId as getSubAccountIndex } from '@eulerxyz/euler-v2-sdk'
 import { getAddress } from 'viem'
 
-const { isConnected, address } = useWagmi()
+const { isConnected } = useWagmi()
 const { isSpyMode } = useSpyMode()
 const { borrowPositions, removedBorrowPositions, isPositionsLoaded, portfolioAddress } = useEulerAccount()
 const { isReady } = useVaults()
 
 const hasActiveSession = computed(() => isConnected.value || isSpyMode.value)
-const ownerAddress = computed(() => portfolioAddress.value || address.value || '')
+// portfolioAddress is already the spy-safe acting address; a wallet
+// fallback here would compute wrong position indices while a spy
+// candidate is still verifying.
+const ownerAddress = computed(() => portfolioAddress.value)
 
 const sortedBorrowPositions = computed(() => {
   const positions = [...removedBorrowPositions.value, ...borrowPositions.value]
diff --git a/server/api/internal/v3/[...path].ts b/server/api/internal/v3/[...path].ts
index 87aa23349..ba5f6392c 100644
--- a/server/api/internal/v3/[...path].ts
+++ b/server/api/internal/v3/[...path].ts
@@ -9,7 +9,7 @@ import {
 } from 'h3'
 import { fetchWithTimeout } from '~/server/utils/fetchWithTimeout'
 import { logger } from '~/server/utils/logger'
-import { safePathTemplate, urlHost } from '~/server/utils/observability'
+import { safeErrorLogFields, safePathTemplate, urlHost } from '~/server/utils/observability'
 import { createRateLimiter } from '~/server/utils/rate-limit'
 import {
   buildV3ProxyBackoffKey,
@@ -90,7 +90,9 @@ export default defineEventHandler(async (event) => {
         bodyBytes: body?.length,
         durationMs: Date.now() - startedAt,
         reason: timedOut ? 'upstream-timeout' : 'upstream-error',
-        ...(!timedOut ? { err } : {}),
+        // Sanitized fields only — raw transport errors can embed request
+        // URLs (addresses, cursors) and abort text is client-controlled.
+        ...(!timedOut ? { err: safeErrorLogFields(err) } : {}),
       },
       timedOut ? 'upstream timed out' : 'upstream fetch failed',
     )
diff --git a/server/utils/v3-proxy-backoff.ts b/server/utils/v3-proxy-backoff.ts
index b3e8f7ddc..5ff490c60 100644
--- a/server/utils/v3-proxy-backoff.ts
+++ b/server/utils/v3-proxy-backoff.ts
@@ -1,4 +1,5 @@
 export const V3_PROXY_FAILURE_BACKOFF_MS = 10_000
+export const V3_PROXY_MAX_BACKOFF_ENTRIES = 256
 
 const RETRYABLE_V3_PROXY_STATUSES = new Set([429, 500, 502, 503, 504])
 
@@ -8,6 +9,12 @@ type V3ProxyBackoffEntry = {
 
 const backoffs = new Map<string, V3ProxyBackoffEntry>()
 
+const pruneV3ProxyBackoffs = (now: number) => {
+  for (const [key, entry] of backoffs) {
+    if (entry.until <= now) backoffs.delete(key)
+  }
+}
+
 const normalizeV3ProxyBackoffPath = (pathname: string) => {
   if (/^\/v3\/accounts\/[^/]+\/positions$/.test(pathname)) {
     return '/v3/accounts/:address/positions'
@@ -15,9 +22,46 @@ const normalizeV3ProxyBackoffPath = (pathname: string) => {
   if (/^\/v3\/earn\/vaults\/[^/]+\/[^/]+$/.test(pathname)) {
     return '/v3/earn/vaults/:chainId/:vault'
   }
+  if (/^\/v3\/activity\/accounts\/[^/]+\/events$/.test(pathname)) {
+    return '/v3/activity/accounts/:owner/events'
+  }
+  const vaultActivity = pathname.match(/^\/v3\/activity\/vaults\/([^/]+)\/[^/]+\/events$/)
+  if (vaultActivity) {
+    return `/v3/activity/vaults/${vaultActivity[1]}/:vault/events`
+  }
   return pathname
 }
 
+const ACTIVITY_FILTER_RE = /^(?=.{1,256}$)[a-z][a-z0-9_]*(?:,[a-z][a-z0-9_]*)*$/
+const ACTIVITY_RANGE_RE = /^[0-9]{1,16}$/
+const ACTIVITY_CHAIN_IDS_RE = /^(?=.{1,256}$)[1-9][0-9]{0,15}(?:,[1-9][0-9]{0,15})*$/
+
+const buildActivityContextKey = (
+  pathname: string,
+  searchParams?: URLSearchParams,
+) => {
+  if (!/^\/v3\/activity\/(?:accounts\/[^/]+|vaults\/[^/]+\/[^/]+)\/events$/.test(pathname) || !searchParams) {
+    return pathname
+  }
+
+  const contextParams = new URLSearchParams()
+  const safeParams: Array<[string, RegExp]> = [
+    ['chainId', ACTIVITY_CHAIN_IDS_RE],
+    ['vaultType', /^(?:evk|earn|securitize)$/],
+    ['from', ACTIVITY_RANGE_RE],
+    ['to', ACTIVITY_RANGE_RE],
+    ['category', ACTIVITY_FILTER_RE],
+    ['eventType', ACTIVITY_FILTER_RE],
+  ]
+  for (const [name, pattern] of safeParams) {
+    const value = searchParams.get(name)
+    if (value && pattern.test(value)) contextParams.set(name, value)
+  }
+
+  const context = contextParams.toString()
+  return context ? `${pathname}?${context}` : pathname
+}
+
 const buildVaultTotalsRangeKey = (
   pathname: string,
   searchParams?: URLSearchParams,
@@ -41,7 +85,10 @@ export const buildV3ProxyBackoffKey = (
   pathname: string,
   searchParams?: URLSearchParams,
 ) =>
-  `${method.toUpperCase()} ${buildVaultTotalsRangeKey(normalizeV3ProxyBackoffPath(pathname), searchParams)}`
+  `${method.toUpperCase()} ${buildActivityContextKey(
+    buildVaultTotalsRangeKey(normalizeV3ProxyBackoffPath(pathname), searchParams),
+    searchParams,
+  )}`
 
 export const readV3ProxyBackoffMs = (
   key: string,
@@ -61,6 +108,13 @@ export const recordV3ProxyBackoff = (
   key: string,
   now = Date.now(),
 ) => {
+  pruneV3ProxyBackoffs(now)
+  backoffs.delete(key)
+  while (backoffs.size >= V3_PROXY_MAX_BACKOFF_ENTRIES) {
+    const oldestKey = backoffs.keys().next().value
+    if (oldestKey === undefined) break
+    backoffs.delete(oldestKey)
+  }
   backoffs.set(key, { until: now + V3_PROXY_FAILURE_BACKOFF_MS })
 }
 
@@ -81,3 +135,5 @@ export const updateV3ProxyBackoffFromResponse = (
 export const resetV3ProxyBackoffsForTest = () => {
   backoffs.clear()
 }
+
+export const getV3ProxyBackoffCountForTest = () => backoffs.size
diff --git a/server/utils/v3-proxy.ts b/server/utils/v3-proxy.ts
index 43274e4d5..291753dd5 100644
--- a/server/utils/v3-proxy.ts
+++ b/server/utils/v3-proxy.ts
@@ -16,6 +16,7 @@ const GET_ONLY_PATHS = new Set([
   '/v3/evk/vaults/bad-debt',
   '/v3/evk/vaults/open-interest',
   '/v3/evk/vaults/open-interest/by-collateral',
+  '/v3/liquidations',
   '/v3/prices',
   '/v3/rewards/breakdown',
   '/v3/tokens',
@@ -23,6 +24,8 @@ const GET_ONLY_PATHS = new Set([
 
 const GET_ONLY_PATH_PATTERNS = [
   /^\/v3\/accounts\/[^/]+\/positions$/,
+  /^\/v3\/activity\/accounts\/0x[a-fA-F0-9]{40}\/events$/,
+  /^\/v3\/activity\/vaults\/[1-9][0-9]{0,15}\/0x[a-fA-F0-9]{40}\/events$/,
   /^\/v3\/earn\/vaults\/[^/]+\/[^/]+$/,
   /^\/v3\/earn\/vaults\/[^/]+\/[^/]+\/totals$/,
   /^\/v3\/evk\/vaults\/[^/]+\/[^/]+\/totals$/,
@@ -34,8 +37,10 @@ const POST_ONLY_PATHS = new Set([
 ])
 
 const ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/
-const INTEGER_RE = /^[0-9]+$/
+const INTEGER_RE = /^[0-9]{1,16}$/
+const CHAIN_ID_LIST_RE = /^(?=.{1,256}$)[1-9][0-9]{0,15}(?:,[1-9][0-9]{0,15})*$/
 const DECIMAL_RE = /^[0-9]+(?:\.[0-9]+)?$/
+const ACTIVITY_FILTER_RE = /^(?=.{1,256}$)[a-z][a-z0-9_]*(?:,[a-z][a-z0-9_]*)*$/
 const SAFE_QUERY_FIELDS = {
   from: INTEGER_RE,
   limit: INTEGER_RE,
@@ -178,6 +183,51 @@ export function buildV3ProxyLogFields(requestUrl: URL): Record<string, string> {
     if (vaultAddress != null) fields.v3VaultAddress = vaultAddress
   }
 
+  if (parts.length === 2 && parts[0] === 'v3' && parts[1] === 'liquidations') {
+    fields.v3ActivityScope = 'liquidations'
+    // Violator and liquidator filters identify wallets and are intentionally
+    // omitted; the vault filter is enough to diagnose upstream failures.
+    const vaultAddress = cleanParam(requestUrl.searchParams.get('vault'), ADDRESS_RE)
+    if (vaultAddress != null) fields.v3VaultAddress = vaultAddress
+  }
+
+  if (
+    parts.length === 5
+    && parts[0] === 'v3'
+    && parts[1] === 'activity'
+    && parts[2] === 'accounts'
+    && ADDRESS_RE.test(parts[3])
+    && parts[4] === 'events'
+  ) {
+    fields.v3ActivityScope = 'account'
+    delete fields.v3ChainId
+    // Account addresses are intentionally omitted. They identify the wallet
+    // being viewed and are not needed to diagnose upstream activity failures.
+    const activityChainIds = cleanParam(requestUrl.searchParams.get('chainId'), CHAIN_ID_LIST_RE)
+    if (activityChainIds != null) fields.v3ChainIds = activityChainIds
+  }
+
+  if (
+    parts.length === 6
+    && parts[0] === 'v3'
+    && parts[1] === 'activity'
+    && parts[2] === 'vaults'
+    && INTEGER_RE.test(parts[3])
+    && ADDRESS_RE.test(parts[4])
+    && parts[5] === 'events'
+  ) {
+    fields.v3ActivityScope = 'vault'
+    fields.v3ChainId = parts[3]
+    fields.v3VaultAddress = parts[4]
+    const vaultType = cleanParam(requestUrl.searchParams.get('vaultType'), /^(?:evk|earn|securitize)$/)
+    if (vaultType != null) fields.v3VaultKind = vaultType
+  }
+
+  const activityCategories = cleanParam(requestUrl.searchParams.get('category'), ACTIVITY_FILTER_RE)
+  if (activityCategories != null && fields.v3ActivityScope) fields.v3ActivityCategories = activityCategories
+  const activityEventTypes = cleanParam(requestUrl.searchParams.get('eventType'), ACTIVITY_FILTER_RE)
+  if (activityEventTypes != null && fields.v3ActivityScope) fields.v3ActivityEventTypes = activityEventTypes
+
   return {
     ...fields,
     ...readSafeQueryFields(requestUrl.searchParams),
diff --git a/tests/components/activityEventRow.test.ts b/tests/components/activityEventRow.test.ts
new file mode 100644
index 000000000..9f0769eb8
--- /dev/null
+++ b/tests/components/activityEventRow.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getActivityAddressCollectionSummary,
+  getActivityLiquidationBonusEntry,
+} from '~/components/entities/activity/activityEventRowDetails'
+
+describe('ActivityEventRow liquidation bonus details', () => {
+  it('summarizes multi-strategy queues in collapsed rows', () => {
+    expect(getActivityAddressCollectionSummary('set_withdraw_queue', 14)).toBe('14 strategies')
+    expect(getActivityAddressCollectionSummary('set_supply_queue', 4)).toBe('4 strategies')
+    expect(getActivityAddressCollectionSummary('set_withdraw_queue', 1)).toBeNull()
+  })
+
+  it('renders protocol-oracle fallback text with the existing signed tone', () => {
+    expect(getActivityLiquidationBonusEntry({
+      bonus: '+1.14 USD',
+      bonusTone: 'positive',
+      bonusTitle: 'Collateral seized minus debt repaid, quoted by the protocol oracle at the liquidation',
+    })).toMatchObject({
+      label: 'Liquidator bonus',
+      value: '+1.14 USD',
+      valueClass: 'text-accent-600',
+      valueTitle: 'Collateral seized minus debt repaid, quoted by the protocol oracle at the liquidation',
+    })
+
+    expect(getActivityLiquidationBonusEntry({
+      bonus: '−0.25 USDC',
+      bonusTone: 'negative',
+    })).toMatchObject({
+      value: '−0.25 USDC',
+      valueClass: 'text-error-500',
+    })
+  })
+
+  it('omits the row when neither USD nor a usable fallback is available', () => {
+    expect(getActivityLiquidationBonusEntry(null)).toBeNull()
+    expect(getActivityLiquidationBonusEntry({})).toBeNull()
+  })
+})
diff --git a/tests/composables/useActivityAvailability.test.ts b/tests/composables/useActivityAvailability.test.ts
new file mode 100644
index 000000000..f24531c9c
--- /dev/null
+++ b/tests/composables/useActivityAvailability.test.ts
@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { effectScope, nextTick, ref, type EffectScope } from 'vue'
+
+describe('useActivityAvailability', () => {
+  let scope: EffectScope | undefined
+
+  beforeEach(() => {
+    vi.resetModules()
+    vi.unstubAllGlobals()
+  })
+
+  afterEach(() => {
+    scope?.stop()
+    scope = undefined
+  })
+
+  it('does not build the SDK when V3 is disabled for the chain', async () => {
+    const getEulerSdkForChain = vi.fn()
+    vi.stubGlobal('useV3ChainGate', () => ({ isV3EnabledForChain: () => false }))
+    vi.stubGlobal('useEulerSdk', () => ({ getEulerSdkForChain }))
+
+    const { useActivityAvailability } = await import('~/composables/useActivityAvailability')
+    let availability: ReturnType<typeof useActivityAvailability> | undefined
+    scope = effectScope()
+    scope.run(() => {
+      availability = useActivityAvailability({ kind: 'vault', vaultType: 'evk' }, 1)
+    })
+    await nextTick()
+
+    expect(getEulerSdkForChain).not.toHaveBeenCalled()
+    expect(availability?.isSupported.value).toBe(false)
+    expect(availability?.reason.value).toBe('v3-disabled')
+  })
+
+  it('requires both adapter and scope capability support', async () => {
+    const getCapabilities = vi.fn(() => ({
+      configured: true,
+      adapter: 'v3',
+      canQueryAccount: true,
+      requestableVaultTypes: ['evk', 'earn', 'securitize'] as const,
+    }))
+    const getScopeSupport = vi.fn((scope: { kind: string, vaultType?: string }) =>
+      scope.vaultType === 'securitize' ? 'unsupported' as const : 'unknown' as const)
+    vi.stubGlobal('useV3ChainGate', () => ({ isV3EnabledForChain: () => true }))
+    vi.stubGlobal('useEulerSdk', () => ({
+      getEulerSdkForChain: vi.fn(async () => ({ activityService: { getCapabilities, getScopeSupport } })),
+    }))
+
+    const { useActivityAvailability } = await import('~/composables/useActivityAvailability')
+    const availabilityScope = ref<{
+      kind: 'vault'
+      vaultType: 'evk' | 'securitize'
+    }>({ kind: 'vault', vaultType: 'evk' })
+    let availability: ReturnType<typeof useActivityAvailability> | undefined
+    scope = effectScope()
+    scope.run(() => {
+      availability = useActivityAvailability(availabilityScope, 1)
+    })
+
+    await vi.waitFor(() => expect(availability?.isSupported.value).toBe(true))
+    expect(availability?.scopeSupport.value).toBe('unknown')
+
+    availabilityScope.value = { kind: 'vault', vaultType: 'securitize' }
+    await vi.waitFor(() => expect(availability?.reason.value).toBe('unsupported-scope'))
+    expect(availability?.isSupported.value).toBe(false)
+  })
+
+  it('ignores a capability result from a superseded chain', async () => {
+    let resolveFirst: ((sdk: unknown) => void) | undefined
+    const first = new Promise((resolve) => {
+      resolveFirst = resolve
+    })
+    const getEulerSdkForChain = vi.fn((chainId: number) => chainId === 1
+      ? first
+      : Promise.resolve({
+          activityService: {
+            getCapabilities: () => ({
+              configured: true,
+              adapter: 'v3',
+              canQueryAccount: true,
+              requestableVaultTypes: ['evk'],
+            }),
+            getScopeSupport: () => 'unknown',
+          },
+        }))
+    vi.stubGlobal('useV3ChainGate', () => ({ isV3EnabledForChain: () => true }))
+    vi.stubGlobal('useEulerSdk', () => ({ getEulerSdkForChain }))
+
+    const { useActivityAvailability } = await import('~/composables/useActivityAvailability')
+    const chainId = ref(1)
+    let availability: ReturnType<typeof useActivityAvailability> | undefined
+    scope = effectScope()
+    scope.run(() => {
+      availability = useActivityAvailability({ kind: 'vault', vaultType: 'evk' }, chainId)
+    })
+
+    await vi.waitFor(() => expect(getEulerSdkForChain).toHaveBeenCalledWith(1))
+    chainId.value = 8453
+    await vi.waitFor(() => expect(availability?.isSupported.value).toBe(true))
+
+    resolveFirst?.({
+      activityService: {
+        getCapabilities: () => ({
+          configured: false,
+          adapter: null,
+          canQueryAccount: false,
+          requestableVaultTypes: [],
+          reason: 'source-not-configured',
+        }),
+        getScopeSupport: () => 'unsupported',
+      },
+    })
+    await nextTick()
+
+    expect(availability?.isSupported.value).toBe(true)
+    expect(availability?.reason.value).toBeUndefined()
+  })
+
+  it('keeps capability-check failures renderable and retryable', async () => {
+    const getEulerSdkForChain = vi.fn()
+      .mockRejectedValueOnce(new Error('SDK build failed'))
+      .mockResolvedValueOnce({
+        activityService: {
+          getCapabilities: () => ({
+            configured: true,
+            adapter: 'v3',
+            canQueryAccount: true,
+            requestableVaultTypes: ['evk'],
+          }),
+          getScopeSupport: () => 'unknown',
+        },
+      })
+    vi.stubGlobal('useV3ChainGate', () => ({ isV3EnabledForChain: () => true }))
+    vi.stubGlobal('useEulerSdk', () => ({ getEulerSdkForChain }))
+
+    const { useActivityAvailability } = await import('~/composables/useActivityAvailability')
+    let availability: ReturnType<typeof useActivityAvailability> | undefined
+    scope = effectScope()
+    scope.run(() => {
+      availability = useActivityAvailability({ kind: 'vault', vaultType: 'evk' }, 1)
+    })
+
+    await vi.waitFor(() => expect(availability?.reason.value).toBe('capability-check-failed'))
+    expect(availability?.isSupported.value).toBe(false)
+    expect(availability?.shouldRender.value).toBe(true)
+
+    const retry = availability?.refreshAvailability()
+    expect(availability?.shouldRender.value).toBe(true)
+    expect(availability?.isChecking.value).toBe(true)
+    await retry
+
+    expect(availability?.isSupported.value).toBe(true)
+    expect(availability?.shouldRender.value).toBe(true)
+    expect(availability?.reason.value).toBeUndefined()
+  })
+})
diff --git a/tests/composables/useActivityFeed.test.ts b/tests/composables/useActivityFeed.test.ts
new file mode 100644
index 000000000..ee83683f6
--- /dev/null
+++ b/tests/composables/useActivityFeed.test.ts
@@ -0,0 +1,606 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ActivityEvent } from '@eulerxyz/euler-v2-sdk'
+import { effectScope, nextTick, ref, type EffectScope } from 'vue'
+import { buildActivityFeedContextKey } from '~/composables/useActivityFeed'
+
+const VAULT = '0x0000000000000000000000000000000000000001' as const
+const OTHER_VAULT = '0x0000000000000000000000000000000000000002' as const
+const TX_HASH = `0x${'1'.repeat(64)}` as const
+
+const event = (
+  id: string,
+  vault: typeof VAULT | typeof OTHER_VAULT = VAULT,
+  type = 'set_caps',
+  overrides: Partial<ActivityEvent> = {},
+): ActivityEvent => ({
+  id,
+  chainId: 1,
+  type,
+  rawType: type === 'mint' || type === 'burn' ? 'transfer' : type,
+  category: 'lending' as const,
+  timestamp: '2026-07-13T10:30:00.000Z',
+  blockNumber: '123',
+  logIndex: 0,
+  txHash: TX_HASH,
+  source: 'v3-ponder',
+  payload: {},
+  vault,
+  ...overrides,
+} as ActivityEvent)
+
+const page = (
+  data: ActivityEvent[],
+  { nextCursor = null, status = 'complete' }: {
+    nextCursor?: string | null
+    status?: 'complete' | 'partial' | 'unsupported' | 'syncing'
+  } = {},
+) => ({
+  data,
+  meta: {
+    hasMore: nextCursor !== null,
+    nextCursor,
+    source: 'v3-ponder',
+    timestamp: '2026-07-13T10:30:00.000Z',
+    coverage: {
+      status,
+      chains: [{ chainId: 1, status, missingCategories: [] }],
+      missingCategories: [],
+    },
+  },
+})
+
+describe('useActivityFeed', () => {
+  let effect: EffectScope | undefined
+
+  beforeEach(() => {
+    vi.resetModules()
+    vi.unstubAllGlobals()
+  })
+
+  afterEach(() => {
+    effect?.stop()
+    effect = undefined
+    vi.restoreAllMocks()
+  })
+
+  const setup = async (
+    fetchVaultActivityEvents: ReturnType<typeof vi.fn>,
+    fetchAccountActivityEvents: ReturnType<typeof vi.fn> = vi.fn(),
+  ) => {
+    vi.stubGlobal('useEulerSdk', () => ({
+      getEulerSdkForChain: vi.fn(async () => ({
+        activityService: { fetchAccountActivityEvents, fetchVaultActivityEvents },
+      })),
+    }))
+    return import('~/composables/useActivityFeed')
+  }
+
+  it('changes the key used to remount the activity accordion when vault scope changes', () => {
+    expect(buildActivityFeedContextKey(
+      { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+      [],
+    )).not.toBe(buildActivityFeedContextKey(
+      { kind: 'vault', vault: OTHER_VAULT, chainId: 1, vaultType: 'evk' },
+      [],
+    ))
+  })
+
+  it('does not request activity until enabled and forwards server-side categories', async () => {
+    const fetchVaultActivityEvents = vi.fn(async (_args: { eventTypes?: readonly string[] }) => page([event('one')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(false)
+    const categories = ref(['lending', 'governance'] as const)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories,
+      })
+    })
+    await nextTick()
+    expect(fetchVaultActivityEvents).not.toHaveBeenCalled()
+
+    enabled.value = true
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledWith({
+      vault: VAULT,
+      chainId: 1,
+      vaultType: 'evk',
+      categories: ['governance', 'lending'],
+      eventTypes: expect.any(Array),
+      limit: 25,
+    })
+    const requestedEventTypes = fetchVaultActivityEvents.mock.calls[0]?.[0]?.eventTypes
+    expect(requestedEventTypes).toEqual(expect.arrayContaining([
+      'deposit',
+      'withdraw',
+      'transfer',
+      'borrow',
+      'repay',
+      'set_caps',
+      'set_ltv',
+      'liquidation',
+    ]))
+    expect(requestedEventTypes).not.toEqual(expect.arrayContaining([
+      'interest_accrued',
+      'accrue_interest',
+      'mint',
+      'burn',
+    ]))
+  })
+
+  it('keeps core vault operations while dropping low-level accounting noise', async () => {
+    const fetchVaultActivityEvents = vi.fn(async () => page([
+      event('set-caps', VAULT, 'set_caps'),
+      event('liquidation', VAULT, 'liquidation'),
+      event('deposit', VAULT, 'deposit'),
+      event('borrow', VAULT, 'borrow'),
+      event('mint-shadow', VAULT, 'mint'),
+      event('evk-interest', VAULT, 'interest_accrued'),
+      event('earn-interest', VAULT, 'accrue_interest'),
+      event('transfer', VAULT, 'transfer'),
+      event('withdraw', VAULT, 'withdraw'),
+      event('burn-shadow', VAULT, 'burn'),
+    ]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: [],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual([
+      'set-caps',
+      'liquidation',
+      'deposit',
+      'borrow',
+      'transfer',
+      'withdraw',
+    ]))
+  })
+
+  it('suppresses zero-value liquidation artifacts on every scope', async () => {
+    const zeroLiquidation = event('zero-liquidation', VAULT, 'liquidation', {
+      category: 'liquidations',
+      assets: [
+        { kind: 'assets', amountRaw: '0' },
+        { kind: 'collateral', amountRaw: '0', address: OTHER_VAULT },
+      ],
+    })
+    const liquidation = event('liquidation', VAULT, 'liquidation', {
+      category: 'liquidations',
+      assets: [
+        { kind: 'assets', amountRaw: '1' },
+        { kind: 'collateral', amountRaw: '2', address: OTHER_VAULT },
+      ],
+    })
+    const fetchVaultActivityEvents = vi.fn(async () => page([zeroLiquidation, liquidation]))
+    const fetchAccountActivityEvents = vi.fn(async () => page([zeroLiquidation, liquidation]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents, fetchAccountActivityEvents)
+    let vaultFeed: ReturnType<typeof useActivityFeed> | undefined
+    let accountFeed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      vaultFeed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: ['liquidations'],
+      })
+      accountFeed = useActivityFeed({
+        scope: { kind: 'account', owner: VAULT, chainId: 1 },
+        enabled: true,
+        categories: ['liquidations'],
+      })
+    })
+
+    await vi.waitFor(() => expect(vaultFeed?.events.value.map(item => item.id)).toEqual([
+      'liquidation',
+    ]))
+    await vi.waitFor(() => expect(accountFeed?.events.value.map(item => item.id)).toEqual([
+      'liquidation',
+    ]))
+  })
+
+  it('auto-fetches older pages when display filtering empties the visible page', async () => {
+    const zero = (id: string) => event(id, VAULT, 'liquidation', {
+      category: 'liquidations',
+      assets: [
+        { kind: 'assets', amountRaw: '0' },
+        { kind: 'collateral', amountRaw: '0', address: OTHER_VAULT },
+      ],
+    })
+    const real = event('real-liquidation', VAULT, 'liquidation', {
+      category: 'liquidations',
+      assets: [
+        { kind: 'assets', amountRaw: '5' },
+        { kind: 'collateral', amountRaw: '6', address: OTHER_VAULT },
+      ],
+    })
+    const pages = [
+      page([zero('zero-one')], { nextCursor: 'cursor-1' }),
+      page([zero('zero-two')], { nextCursor: 'cursor-2' }),
+      page([real]),
+    ]
+    const fetchVaultActivityEvents = vi.fn(async () => pages.shift() ?? page([]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: ['liquidations'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['real-liquidation']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(3)
+    // The intermediate all-filtered pages never presented an empty state.
+    expect(feed?.isEmpty.value).toBe(false)
+  })
+
+  it('removes a vault shadow transfer when its matching primary event arrives on an older page', async () => {
+    const shadowTransfer = event('transfer-shadow', VAULT, 'transfer', {
+      groupId: 'paired-transaction',
+      assets: [{ kind: 'shares', address: VAULT, amountRaw: '100' }],
+    })
+    const deposit = event('deposit', VAULT, 'deposit', {
+      groupId: 'paired-transaction',
+      assets: [{ kind: 'shares', address: VAULT, amountRaw: '100' }],
+    })
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([shadowTransfer], { nextCursor: 'next' }))
+      .mockResolvedValueOnce(page([deposit]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: [],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['transfer-shadow']))
+    await feed?.loadMore()
+
+    expect(feed?.events.value.map(item => item.id)).toEqual(['deposit'])
+  })
+
+  it('retains loaded rows without refetching when collapsed and reopened', async () => {
+    const fetchVaultActivityEvents = vi.fn(async () => page([event('one')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    enabled.value = false
+    await nextTick()
+    enabled.value = true
+    await nextTick()
+
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(1)
+    expect(feed?.events.value.map(item => item.id)).toEqual(['one'])
+  })
+
+  it('refreshes stale rows when reopened while retaining the last-good page', async () => {
+    let now = 1_000
+    vi.spyOn(Date, 'now').mockImplementation(() => now)
+    let resolveRefresh: ((value: ReturnType<typeof page>) => void) | undefined
+    const refresh = new Promise<ReturnType<typeof page>>((resolve) => {
+      resolveRefresh = resolve
+    })
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')]))
+      .mockReturnValueOnce(refresh)
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    enabled.value = false
+    await nextTick()
+    now += 60_001
+    enabled.value = true
+
+    await vi.waitFor(() => expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2))
+    expect(feed?.events.value.map(item => item.id)).toEqual(['one'])
+    expect(feed?.isRefreshing.value).toBe(true)
+
+    resolveRefresh?.(page([event('new')]))
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['new']))
+  })
+
+  it('retries a cold failure when the collapsed feed is opened', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockRejectedValueOnce(new Error('backend unavailable'))
+      .mockResolvedValueOnce(page([event('recovered')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.hasColdError.value).toBe(true))
+    enabled.value = false
+    await nextTick()
+    enabled.value = true
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['recovered']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2)
+  })
+
+  it('retries a cold refresh that was interrupted by collapsing the feed', async () => {
+    let resolveInterrupted: ((value: ReturnType<typeof page>) => void) | undefined
+    const interrupted = new Promise<ReturnType<typeof page>>((resolve) => {
+      resolveInterrupted = resolve
+    })
+    const fetchVaultActivityEvents = vi.fn()
+      .mockRejectedValueOnce(new Error('backend unavailable'))
+      .mockReturnValueOnce(interrupted)
+      .mockResolvedValueOnce(page([event('recovered')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.hasColdError.value).toBe(true))
+    enabled.value = false
+    await nextTick()
+    enabled.value = true
+    await vi.waitFor(() => expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2))
+
+    enabled.value = false
+    await nextTick()
+    enabled.value = true
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['recovered']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(3)
+
+    resolveInterrupted?.(page([event('interrupted')]))
+    await nextTick()
+    expect(feed?.events.value.map(item => item.id)).toEqual(['recovered'])
+  })
+
+  it('refreshes an invalidated activity query when the feed is reopened', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')]))
+      .mockResolvedValueOnce(page([event('new')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    enabled.value = false
+    await nextTick()
+
+    const { invalidateSdkQueries } = await import('~/utils/sdk-query-cache')
+    await invalidateSdkQueries(['queryVaultActivityEvents' as never])
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(1)
+
+    enabled.value = true
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['new']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2)
+  })
+
+  it('refreshes an invalidated activity query while the feed is open', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')]))
+      .mockResolvedValueOnce(page([event('new')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    const { invalidateSdkQueries } = await import('~/utils/sdk-query-cache')
+    await invalidateSdkQueries(['queryVaultActivityEvents' as never])
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['new']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2)
+  })
+
+  it('retries an invalidation refresh that was interrupted by collapsing the feed', async () => {
+    let resolveInterrupted: ((value: ReturnType<typeof page>) => void) | undefined
+    const interrupted = new Promise<ReturnType<typeof page>>((resolve) => {
+      resolveInterrupted = resolve
+    })
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')]))
+      .mockReturnValueOnce(interrupted)
+      .mockResolvedValueOnce(page([event('new')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const enabled = ref(true)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled,
+        categories: ['lending'],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['one']))
+    const { invalidateSdkQueries } = await import('~/utils/sdk-query-cache')
+    await invalidateSdkQueries(['queryVaultActivityEvents' as never])
+    await vi.waitFor(() => expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2))
+
+    enabled.value = false
+    await nextTick()
+    enabled.value = true
+
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['new']))
+    expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(3)
+
+    resolveInterrupted?.(page([event('interrupted')]))
+    await nextTick()
+    expect(feed?.events.value.map(item => item.id)).toEqual(['new'])
+  })
+
+  it('ignores superseded context responses', async () => {
+    let resolveFirst: ((value: ReturnType<typeof page>) => void) | undefined
+    let resolveSecond: ((value: ReturnType<typeof page>) => void) | undefined
+    const first = new Promise<ReturnType<typeof page>>((resolve) => {
+      resolveFirst = resolve
+    })
+    const second = new Promise<ReturnType<typeof page>>((resolve) => {
+      resolveSecond = resolve
+    })
+    const fetchVaultActivityEvents = vi.fn(({ vault }: { vault: string }) => vault === VAULT ? first : second)
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    const feedScope = ref<{
+      kind: 'vault'
+      vault: typeof VAULT | typeof OTHER_VAULT
+      chainId: 1
+      vaultType: 'evk'
+    }>({ kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' })
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({ scope: feedScope, enabled: true, categories: [] })
+    })
+
+    await vi.waitFor(() => expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(1))
+    feedScope.value = { kind: 'vault', vault: OTHER_VAULT, chainId: 1, vaultType: 'evk' }
+    await vi.waitFor(() => expect(fetchVaultActivityEvents).toHaveBeenCalledTimes(2))
+
+    resolveSecond?.(page([event('new', OTHER_VAULT)]))
+    await vi.waitFor(() => expect(feed?.events.value.map(item => item.id)).toEqual(['new']))
+    resolveFirst?.(page([event('old')]))
+    await nextTick()
+
+    expect(feed?.events.value.map(item => item.id)).toEqual(['new'])
+  })
+
+  it('retains last-good rows when a same-context refresh fails', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')]))
+      .mockRejectedValueOnce(new Error('backend unavailable'))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: [],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.events.value).toHaveLength(1))
+    await feed?.refresh()
+
+    expect(feed?.events.value.map(item => item.id)).toEqual(['one'])
+    expect(feed?.hasStaleError.value).toBe(true)
+    expect(feed?.hasColdError.value).toBe(false)
+    expect(feed?.isEmpty.value).toBe(false)
+  })
+
+  it('keeps load-more failures separate and deduplicates a retried page', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([event('one')], { nextCursor: 'next' }))
+      .mockRejectedValueOnce(new Error('older page unavailable'))
+      .mockResolvedValueOnce(page([event('one'), event('two')]))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: [],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.hasMore.value).toBe(true))
+    await feed?.loadMore()
+    expect(feed?.events.value.map(item => item.id)).toEqual(['one'])
+    expect(feed?.loadMoreError.value?.message).toBe('older page unavailable')
+    expect(feed?.error.value).toBeUndefined()
+
+    await feed?.loadMore()
+    expect(fetchVaultActivityEvents).toHaveBeenLastCalledWith(expect.objectContaining({ cursor: 'next' }))
+    expect(feed?.events.value.map(item => item.id)).toEqual(['one', 'two'])
+    expect(feed?.loadMoreError.value).toBeUndefined()
+  })
+
+  it('distinguishes empty, partial, syncing and unsupported coverage', async () => {
+    const fetchVaultActivityEvents = vi.fn()
+      .mockResolvedValueOnce(page([], { status: 'complete' }))
+      .mockResolvedValueOnce(page([], { status: 'partial' }))
+      .mockResolvedValueOnce(page([], { status: 'syncing' }))
+      .mockResolvedValueOnce(page([], { status: 'unsupported' }))
+    const { useActivityFeed } = await setup(fetchVaultActivityEvents)
+    let feed: ReturnType<typeof useActivityFeed> | undefined
+    effect = effectScope()
+    effect.run(() => {
+      feed = useActivityFeed({
+        scope: { kind: 'vault', vault: VAULT, chainId: 1, vaultType: 'evk' },
+        enabled: true,
+        categories: [],
+      })
+    })
+
+    await vi.waitFor(() => expect(feed?.isEmpty.value).toBe(true))
+    await feed?.refresh()
+    expect(feed?.isPartial.value).toBe(true)
+    expect(feed?.isEmpty.value).toBe(false)
+    await feed?.refresh()
+    expect(feed?.isSyncing.value).toBe(true)
+    expect(feed?.isEmpty.value).toBe(false)
+    await feed?.refresh()
+    expect(feed?.isUnsupported.value).toBe(true)
+    expect(feed?.isEmpty.value).toBe(false)
+  })
+})
diff --git a/tests/composables/useActivityLiquidationDetails.test.ts b/tests/composables/useActivityLiquidationDetails.test.ts
new file mode 100644
index 000000000..9fd868492
--- /dev/null
+++ b/tests/composables/useActivityLiquidationDetails.test.ts
@@ -0,0 +1,125 @@
+import { effectScope } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ActivityEvent } from '@eulerxyz/euler-v2-sdk'
+import { useActivityLiquidationDetails } from '~/composables/useActivityLiquidationDetails'
+
+const VAULT = '0xe0a80d35bB6618CBA260120b279d357978c42BCE'
+const COLLATERAL = '0x61aAC438453d6e3513C0c8dbb69F13860E2B5028'
+const VIOLATOR = '0x9f2a560CfA7616f53691a57404a9fFB50dA1e483'
+const LIQUIDATOR = '0x356B4853c5aFEa804518Aceaa25885B38eceFc72'
+const TX = `0x${'ab'.repeat(32)}`
+
+const liquidationEvent = (overrides: Partial<ActivityEvent> = {}): ActivityEvent => ({
+  id: 'v3-ponder:1:liquidation:1',
+  chainId: 1,
+  type: 'liquidation',
+  rawType: 'liquidation',
+  category: 'liquidations',
+  timestamp: '2026-07-18T23:13:35.000Z',
+  blockNumber: '25562800',
+  logIndex: 1065,
+  txHash: TX as ActivityEvent['txHash'],
+  source: 'v3-ponder',
+  vault: VAULT as ActivityEvent['vault'],
+  payload: {
+    violator: VIOLATOR.toLowerCase(),
+    collateral: COLLATERAL.toLowerCase(),
+    repay_assets: '724612',
+    yield_balance: '812035276912150036',
+  },
+  ...overrides,
+} as ActivityEvent)
+
+const liquidationRecord = () => ({
+  chainId: 1,
+  vault: VAULT,
+  violator: VIOLATOR,
+  liquidator: LIQUIDATOR,
+  collateral: COLLATERAL,
+  repayAssets: '724612',
+  yieldBalance: '812035276912150036',
+  repayAssetsUsd: 0.72,
+  bonusUsd: 0.13,
+  unitOfAccountValuation: {
+    source: 'historical-protocol-oracle' as const,
+    unitOfAccount: '0x0000000000000000000000000000000000000348',
+    unitOfAccountDecimals: 18,
+    repayValue: '720000000000000000',
+    collateralValue: '850000000000000000',
+    bonusValue: '130000000000000000',
+    blockNumber: '25562800',
+  },
+  valuation: { status: 'available' as const },
+  blockNumber: '25562800',
+  txHash: TX,
+  timestamp: '2026-07-18T23:13:35.000Z',
+})
+
+const inScope = <T>(setup: () => T): T => {
+  const scope = effectScope()
+  return scope.run(setup) as T
+}
+
+describe('useActivityLiquidationDetails', () => {
+  beforeEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('fetches per chain+vault window and joins records to their events', async () => {
+    const fetchLiquidations = vi.fn(async () => ({
+      data: [liquidationRecord()],
+      meta: { total: 1, offset: 0, limit: 100, timestamp: '2026-07-23T00:00:00.000Z' },
+    }))
+    vi.stubGlobal('useEulerSdk', () => ({
+      getEulerSdkForChain: vi.fn(async () => ({ activityService: { fetchLiquidations } })),
+    }))
+
+    const event = liquidationEvent()
+    const details = inScope(() => useActivityLiquidationDetails({
+      events: () => [event],
+    }))
+
+    await vi.waitFor(() =>
+      expect(details.getLiquidationDetails(event)).toMatchObject({
+        bonusUsd: 0.13,
+        unitOfAccountValuation: {
+          source: 'historical-protocol-oracle',
+          bonusValue: '130000000000000000',
+        },
+      }))
+
+    const eventUnix = Math.floor(Date.parse(event.timestamp) / 1000)
+    expect(fetchLiquidations).toHaveBeenCalledTimes(1)
+    expect(fetchLiquidations).toHaveBeenCalledWith({
+      chainId: 1,
+      vault: VAULT,
+      from: eventUnix - 1,
+      to: eventUnix + 1,
+      limit: 100,
+      offset: 0,
+    })
+
+    // Non-liquidation events never resolve details.
+    expect(details.getLiquidationDetails(
+      liquidationEvent({ type: 'deposit', category: 'lending' } as Partial<ActivityEvent>),
+    )).toBeUndefined()
+  })
+
+  it('leaves rows unenriched when the lookup fails', async () => {
+    const fetchLiquidations = vi.fn(async () => {
+      throw new Error('upstream down')
+    })
+    vi.stubGlobal('useEulerSdk', () => ({
+      getEulerSdkForChain: vi.fn(async () => ({ activityService: { fetchLiquidations } })),
+    }))
+
+    const event = liquidationEvent()
+    const details = inScope(() => useActivityLiquidationDetails({
+      events: () => [event],
+    }))
+
+    await vi.waitFor(() => expect(fetchLiquidations).toHaveBeenCalled())
+    await new Promise(resolve => setTimeout(resolve, 10))
+    expect(details.getLiquidationDetails(event)).toBeUndefined()
+  })
+})
diff --git a/tests/composables/useActivityNowMs.test.ts b/tests/composables/useActivityNowMs.test.ts
new file mode 100644
index 000000000..407171254
--- /dev/null
+++ b/tests/composables/useActivityNowMs.test.ts
@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { effectScope } from 'vue'
+import {
+  ACTIVITY_CLOCK_INTERVAL_MS,
+  useActivityNowMs,
+} from '~/composables/useActivityNowMs'
+
+const NOW = Date.parse('2026-07-21T10:00:00.000Z')
+
+afterEach(() => {
+  vi.useRealTimers()
+  vi.unstubAllGlobals()
+})
+
+describe('useActivityNowMs', () => {
+  it('advances the shared Activity clock without another feed update', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(NOW)
+    vi.stubGlobal('window', {
+      setInterval: globalThis.setInterval,
+      clearInterval: globalThis.clearInterval,
+    })
+
+    const scope = effectScope()
+    const nowMs = scope.run(useActivityNowMs)
+    if (!nowMs) throw new Error('Activity clock failed to mount')
+
+    expect(nowMs.value).toBe(NOW)
+
+    await vi.advanceTimersByTimeAsync(ACTIVITY_CLOCK_INTERVAL_MS)
+
+    expect(nowMs.value).toBe(NOW + ACTIVITY_CLOCK_INTERVAL_MS)
+
+    scope.stop()
+    await vi.advanceTimersByTimeAsync(ACTIVITY_CLOCK_INTERVAL_MS)
+    expect(nowMs.value).toBe(NOW + ACTIVITY_CLOCK_INTERVAL_MS)
+  })
+})
diff --git a/tests/composables/useEffectiveAddress.test.ts b/tests/composables/useEffectiveAddress.test.ts
index 86ebdb370..897e93533 100644
--- a/tests/composables/useEffectiveAddress.test.ts
+++ b/tests/composables/useEffectiveAddress.test.ts
@@ -62,3 +62,66 @@ describe('useEffectiveAddress', () => {
     expect(result.spyAddress).toBe(spyAddress)
   })
 })
+
+describe('useEffectiveAddress with real spy-mode verification', () => {
+  const TARGET = '0x0000000000000000000000000000000000000003'
+  const TARGET_OWNER = '0x0000000000000000000000000000000000000033'
+  const EVC = '0x00000000000000000000000000000000000000e0'
+
+  const deferred = <T>() => {
+    let resolve!: (value: T) => void
+    const promise = new Promise<T>((resolvePromise) => {
+      resolve = resolvePromise
+    })
+    return { promise, resolve }
+  }
+
+  beforeEach(() => {
+    vi.resetModules()
+    vi.stubGlobal('computed', computed)
+    vi.stubGlobal('window', { location: { search: '' } })
+    vi.stubGlobal('useRoute', () => ({ path: '/portfolio/activity', query: {}, hash: '' }))
+    vi.stubGlobal('useRouter', () => ({ replace: vi.fn() }))
+    vi.stubGlobal('useEulerAddresses', () => ({
+      eulerCoreAddresses: ref({ evc: EVC }),
+      chainId: ref(1),
+    }))
+    vi.stubGlobal('useWagmi', () => ({ address: ref(WALLET), isConnected: ref(true) }))
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('never falls back to the connected wallet while spy verification is pending', async () => {
+    const owner = deferred<string>()
+    vi.stubGlobal('useRpcClient', () => ({
+      client: ref({ readContract: vi.fn(() => owner.promise) }),
+    }))
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    vi.stubGlobal('useSpyMode', useSpyMode)
+    const { useEffectiveAddress: useEffectiveAddressFresh }
+      = await import('~/composables/useEffectiveAddress')
+
+    const { effectiveAddress } = useEffectiveAddressFresh()
+    const spy = useSpyMode()
+
+    // No spy context: the connected wallet is the acting address.
+    expect(effectiveAddress.value).toBe(WALLET)
+
+    // Spy activated but unverified — the banner says "Verifying address…",
+    // so consumers must not show or query the connected wallet's data. This
+    // is also the steady state after owner-resolution retries exhaust.
+    spy.activateSpyMode(TARGET)
+    expect(spy.isSpyResolving.value).toBe(true)
+    expect(effectiveAddress.value).toBeFalsy()
+
+    // Verified: the spied owner becomes the acting address.
+    owner.resolve(TARGET_OWNER)
+    await vi.waitFor(() => expect(effectiveAddress.value).toBe(TARGET_OWNER))
+
+    // Exiting spy mode returns to the connected wallet.
+    await spy.clearSpyMode()
+    expect(effectiveAddress.value).toBe(WALLET)
+  })
+})
diff --git a/tests/composables/usePortfolioActivityRuntimeSupport.test.ts b/tests/composables/usePortfolioActivityRuntimeSupport.test.ts
new file mode 100644
index 000000000..3a279647b
--- /dev/null
+++ b/tests/composables/usePortfolioActivityRuntimeSupport.test.ts
@@ -0,0 +1,62 @@
+import { ref } from 'vue'
+import { describe, expect, it } from 'vitest'
+import {
+  buildPortfolioActivityContextKey,
+  shouldLeavePortfolioActivityRoute,
+  shouldShowPortfolioActivityTab,
+  usePortfolioActivityRuntimeSupport,
+} from '../../composables/usePortfolioActivityRuntimeSupport'
+
+const OWNER = '0x1000000000000000000000000000000000000000'
+
+describe('portfolio activity runtime support', () => {
+  it('shares an authoritative result only within the active owner and chain', () => {
+    const owner = ref<string | undefined>(OWNER)
+    const chainId = ref(1)
+    const writer = usePortfolioActivityRuntimeSupport(owner, chainId)
+    const reader = usePortfolioActivityRuntimeSupport(owner, chainId)
+
+    writer.setRuntimeUnsupported(false)
+    expect(reader.isRuntimeUnsupported.value).toBe(false)
+
+    writer.setRuntimeUnsupported(true)
+    expect(reader.isRuntimeUnsupported.value).toBe(true)
+
+    chainId.value = 8453
+    expect(reader.isRuntimeUnsupported.value).toBe(false)
+
+    chainId.value = 1
+    expect(reader.isRuntimeUnsupported.value).toBe(true)
+
+    owner.value = '0x2000000000000000000000000000000000000000'
+    expect(reader.isRuntimeUnsupported.value).toBe(false)
+  })
+
+  it('normalizes the owner and rejects incomplete contexts', () => {
+    expect(buildPortfolioActivityContextKey(OWNER.toUpperCase(), 1)).toBe(`${OWNER}:1`)
+    expect(buildPortfolioActivityContextKey(undefined, 1)).toBeUndefined()
+    expect(buildPortfolioActivityContextKey(OWNER, 0)).toBeUndefined()
+  })
+
+  it('keeps transient failures visible and redirects only after support settles', () => {
+    expect(shouldShowPortfolioActivityTab(true, false)).toBe(true)
+    expect(shouldShowPortfolioActivityTab(true, true)).toBe(false)
+    expect(shouldShowPortfolioActivityTab(false, false)).toBe(false)
+
+    expect(shouldLeavePortfolioActivityRoute({
+      routeName: 'portfolio-activity',
+      isChecking: true,
+      shouldShow: false,
+    })).toBe(false)
+    expect(shouldLeavePortfolioActivityRoute({
+      routeName: 'portfolio-activity',
+      isChecking: false,
+      shouldShow: false,
+    })).toBe(true)
+    expect(shouldLeavePortfolioActivityRoute({
+      routeName: 'portfolio-rewards',
+      isChecking: false,
+      shouldShow: false,
+    })).toBe(false)
+  })
+})
diff --git a/tests/composables/useREULLocks.test.ts b/tests/composables/useREULLocks.test.ts
index a44898353..b89eb7870 100644
--- a/tests/composables/useREULLocks.test.ts
+++ b/tests/composables/useREULLocks.test.ts
@@ -54,6 +54,11 @@ const importUseREULLocks = async (wallet: {
   vi.stubGlobal('useSpyMode', () => ({
     spyAddress: ref(owner),
   }))
+  // Mirrors the real helper: verified spy address wins, the connected wallet
+  // is only used outside spy mode.
+  vi.stubGlobal('useEffectiveAddress', () => ({
+    effectiveAddress: ref(owner || wallet.address),
+  }))
 
   const module = await import('~/composables/useREULLocks')
   return {
diff --git a/tests/composables/useRewardsApy.test.ts b/tests/composables/useRewardsApy.test.ts
index 76a24e57d..1f15358a7 100644
--- a/tests/composables/useRewardsApy.test.ts
+++ b/tests/composables/useRewardsApy.test.ts
@@ -41,6 +41,7 @@ describe('useRewardsApy multi-collateral rewards', () => {
     }))
     vi.stubGlobal('useWagmi', () => ({ address: ref(undefined) }))
     vi.stubGlobal('useSpyMode', () => ({ spyAddress: ref(undefined) }))
+    vi.stubGlobal('useEffectiveAddress', () => ({ effectiveAddress: ref(undefined) }))
     vi.stubGlobal('useVaultRegistry', () => ({
       registryVersion: ref(1),
       getVault: vi.fn(() => ({
diff --git a/tests/composables/useSpyMode.test.ts b/tests/composables/useSpyMode.test.ts
new file mode 100644
index 000000000..b487bda2c
--- /dev/null
+++ b/tests/composables/useSpyMode.test.ts
@@ -0,0 +1,290 @@
+import { nextTick, reactive, ref } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const FIRST = '0x0000000000000000000000000000000000000001'
+const SECOND = '0x0000000000000000000000000000000000000002'
+const FIRST_OWNER = '0x0000000000000000000000000000000000000011'
+const EVC = '0x00000000000000000000000000000000000000e0'
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise
+  })
+  return { promise, resolve }
+}
+
+const ZERO = '0x0000000000000000000000000000000000000000'
+
+/** EVC answering "never registered" — the address is safe as itself. */
+const selfOwnedClient = () => ({ readContract: vi.fn(async () => ZERO) })
+
+describe('useSpyMode', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.stubGlobal('window', { location: { search: '' } })
+    vi.stubGlobal('useRoute', () => ({ path: '/portfolio/activity', query: {}, hash: '' }))
+    vi.stubGlobal('useRouter', () => ({ replace: vi.fn() }))
+    vi.stubGlobal('useEulerAddresses', () => ({
+      eulerCoreAddresses: ref({ evc: EVC }),
+      chainId: ref(1),
+    }))
+    vi.stubGlobal('useRpcClient', () => ({ client: ref(null) }))
+  })
+
+  it('engages spy mode immediately but only consumes verified addresses', async () => {
+    vi.stubGlobal('useRpcClient', () => ({ client: ref(selfOwnedClient()) }))
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    expect(spy.activateSpyMode(FIRST)).toBe(true)
+    // Spy context is active, but the unverified candidate is not consumable.
+    expect(spy.isSpyMode.value).toBe(true)
+    expect(spy.isSpyResolving.value).toBe(true)
+    expect(spy.spyAddress.value).toBe('')
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(FIRST))
+    expect(spy.isSpyResolving.value).toBe(false)
+
+    expect(spy.activateSpyMode(SECOND)).toBe(true)
+    expect(spy.spyAddress.value).toBe('')
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(SECOND))
+  })
+
+  it('follows valid spy query changes from browser history', async () => {
+    const route = reactive({
+      path: '/portfolio/activity',
+      query: { spy: FIRST },
+      hash: '',
+    })
+    vi.stubGlobal('window', { location: { search: `?spy=${FIRST}` } })
+    vi.stubGlobal('useRoute', () => route)
+    vi.stubGlobal('useRpcClient', () => ({ client: ref(selfOwnedClient()) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(FIRST))
+
+    route.query.spy = SECOND
+    await nextTick()
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(SECOND))
+
+    route.query.spy = FIRST
+    await nextTick()
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(FIRST))
+  })
+
+  it('ignores an owner resolution for a superseded spy address', async () => {
+    const firstOwner = deferred<string>()
+    const replace = vi.fn()
+    const readContract = vi.fn(({ args }: { args: [string] }) =>
+      args[0].toLowerCase() === FIRST ? firstOwner.promise : Promise.resolve(SECOND),
+    )
+    vi.stubGlobal('useRouter', () => ({ replace }))
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await nextTick()
+    expect(readContract).toHaveBeenCalledTimes(1)
+
+    spy.activateSpyMode(SECOND)
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(SECOND))
+    firstOwner.resolve(FIRST_OWNER)
+    await firstOwner.promise
+    await nextTick()
+
+    expect(spy.spyAddress.value.toLowerCase()).toBe(SECOND)
+    expect(replace).not.toHaveBeenCalledWith(expect.objectContaining({
+      query: expect.objectContaining({ spy: FIRST_OWNER }),
+    }))
+  })
+
+  it('resolves the owner once the RPC client becomes available', async () => {
+    const client = ref<null | { readContract: ReturnType<typeof vi.fn> }>(null)
+    const readContract = vi.fn(async () => FIRST_OWNER)
+    vi.stubGlobal('useRpcClient', () => ({ client }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await nextTick()
+    // No client yet — nothing to resolve with, and nothing consumable.
+    expect(readContract).not.toHaveBeenCalled()
+    expect(spy.spyAddress.value).toBe('')
+    expect(spy.isSpyResolving.value).toBe(true)
+
+    client.value = { readContract }
+    await nextTick()
+    await vi.waitFor(() => expect(spy.spyAddress.value).toBe(FIRST_OWNER))
+  })
+
+  it('retries a rejected owner lookup instead of accepting the address', async () => {
+    vi.useFakeTimers()
+    try {
+      const readContract = vi.fn()
+        .mockRejectedValueOnce(new Error('rpc down'))
+        .mockResolvedValue(FIRST_OWNER)
+      vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+      const { useSpyMode } = await import('~/composables/useSpyMode')
+      const spy = useSpyMode()
+
+      spy.activateSpyMode(FIRST)
+      await vi.waitFor(() => expect(readContract).toHaveBeenCalledTimes(1))
+      await Promise.resolve()
+      // The failed lookup keeps the candidate pending — never consumable.
+      expect(spy.spyAddress.value).toBe('')
+      expect(spy.isSpyResolving.value).toBe(true)
+
+      await vi.advanceTimersByTimeAsync(5_000)
+      await vi.waitFor(() => expect(readContract).toHaveBeenCalledTimes(2))
+      await vi.waitFor(() => expect(spy.spyAddress.value).toBe(FIRST_OWNER))
+    }
+    finally {
+      vi.useRealTimers()
+    }
+  })
+  it('rewrites a sub-account candidate to its owner in state and URL', async () => {
+    const replace = vi.fn()
+    // EVC answers with a different owner — the candidate is a sub-account.
+    const readContract = vi.fn(async () => FIRST_OWNER)
+    vi.stubGlobal('useRouter', () => ({ replace }))
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await vi.waitFor(() => expect(spy.spyAddress.value).toBe(FIRST_OWNER))
+    expect(replace).toHaveBeenCalledWith(expect.objectContaining({
+      query: expect.objectContaining({ spy: FIRST_OWNER }),
+    }))
+  })
+
+  it('never adopts a candidate cleared while resolution was pending', async () => {
+    const pendingLookup = deferred<string>()
+    const replace = vi.fn()
+    const readContract = vi.fn(() => pendingLookup.promise)
+    vi.stubGlobal('useRouter', () => ({ replace }))
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await vi.waitFor(() => expect(readContract).toHaveBeenCalledTimes(1))
+    await spy.clearSpyMode()
+    expect(spy.isSpyMode.value).toBe(false)
+
+    pendingLookup.resolve(FIRST_OWNER)
+    await pendingLookup.promise
+    await nextTick()
+    expect(spy.spyAddress.value).toBe('')
+    expect(spy.isSpyMode.value).toBe(false)
+  })
+
+  it('stays pending and unconsumed after exhausting every retry', async () => {
+    vi.useFakeTimers()
+    try {
+      const readContract = vi.fn().mockRejectedValue(new Error('rpc down'))
+      vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+      const { useSpyMode } = await import('~/composables/useSpyMode')
+      const spy = useSpyMode()
+
+      spy.activateSpyMode(FIRST)
+      // initial attempt + 5 retries, then no further scheduling
+      for (let round = 0; round < 8; round++) {
+        await vi.advanceTimersByTimeAsync(4_500)
+      }
+      expect(readContract.mock.calls.length).toBe(6)
+      expect(spy.spyAddress.value).toBe('')
+      expect(spy.isSpyMode.value).toBe(true)
+      expect(spy.isSpyResolving.value).toBe(true)
+    }
+    finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('short-circuits re-activation of an already verified address', async () => {
+    const readContract = vi.fn(async () => ZERO)
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await vi.waitFor(() => expect(spy.spyAddress.value.toLowerCase()).toBe(FIRST))
+    const callsAfterFirst = readContract.mock.calls.length
+
+    expect(spy.activateSpyMode(FIRST)).toBe(true)
+    await nextTick()
+    // No blanking, no second verification round.
+    expect(spy.spyAddress.value.toLowerCase()).toBe(FIRST)
+    expect(spy.isSpyResolving.value).toBe(false)
+    expect(readContract.mock.calls.length).toBe(callsAfterFirst)
+  })
+
+  it('keeps the in-flight resolution when the pending address is re-activated', async () => {
+    const owner = deferred<string>()
+    const readContract = vi.fn(() => owner.promise)
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    spy.activateSpyMode(FIRST)
+    await nextTick()
+    expect(readContract).toHaveBeenCalledTimes(1)
+
+    // An Activity click activates spy mode, then another consumer re-reads
+    // the same ?spy= value while the owner lookup is still in flight. The
+    // same-value ref write cannot re-trigger the watcher, so invalidating
+    // the request id here would discard the only pending result and strand
+    // the candidate unresolved forever.
+    expect(spy.activateSpyMode(FIRST)).toBe(true)
+    await nextTick()
+    expect(readContract).toHaveBeenCalledTimes(1)
+    expect(spy.isSpyResolving.value).toBe(true)
+
+    owner.resolve(FIRST_OWNER)
+    await vi.waitFor(() => expect(spy.spyAddress.value).toBe(FIRST_OWNER))
+    expect(spy.isSpyResolving.value).toBe(false)
+  })
+
+  it('rejects invalid input without touching spy state', async () => {
+    vi.stubGlobal('useRpcClient', () => ({ client: ref(selfOwnedClient()) }))
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    expect(spy.activateSpyMode('not-an-address')).toBe(false)
+    expect(spy.activateSpyMode('0x1234')).toBe(false)
+    expect(spy.isSpyMode.value).toBe(false)
+    expect(spy.spyAddress.value).toBe('')
+  })
+
+  it('persists the unverified candidate in the URL via setSpyMode', async () => {
+    const replace = vi.fn()
+    const never = deferred<string>()
+    const readContract = vi.fn(() => never.promise)
+    vi.stubGlobal('useRouter', () => ({ replace }))
+    vi.stubGlobal('useRpcClient', () => ({ client: ref({ readContract }) }))
+
+    const { useSpyMode } = await import('~/composables/useSpyMode')
+    const spy = useSpyMode()
+
+    await spy.setSpyMode(FIRST)
+    // The URL carries the user-supplied candidate while verification runs…
+    expect(replace).toHaveBeenCalledWith(expect.objectContaining({
+      query: expect.objectContaining({ spy: expect.stringMatching(/^0x0{39}1$/i) }),
+    }))
+    // …but nothing consumable exists yet.
+    expect(spy.spyAddress.value).toBe('')
+    expect(spy.isSpyResolving.value).toBe(true)
+  })
+})
diff --git a/tests/server/v3-proxy-backoff.test.ts b/tests/server/v3-proxy-backoff.test.ts
new file mode 100644
index 000000000..b07a9b44f
--- /dev/null
+++ b/tests/server/v3-proxy-backoff.test.ts
@@ -0,0 +1,110 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  buildV3ProxyBackoffKey,
+  getV3ProxyBackoffCountForTest,
+  readV3ProxyBackoffMs,
+  recordV3ProxyBackoff,
+  resetV3ProxyBackoffsForTest,
+  V3_PROXY_FAILURE_BACKOFF_MS,
+  V3_PROXY_MAX_BACKOFF_ENTRIES,
+} from '~/server/utils/v3-proxy-backoff'
+
+const ACCOUNT = '0x0000000000000000000000000000000000000001'
+const OTHER_ACCOUNT = '0x0000000000000000000000000000000000000002'
+const VAULT = '0x0000000000000000000000000000000000000003'
+const OTHER_VAULT = '0x0000000000000000000000000000000000000004'
+
+describe('activity V3 proxy backoff keys', () => {
+  afterEach(() => resetV3ProxyBackoffsForTest())
+
+  it('does not key account cooldowns by wallet address', () => {
+    const params = new URLSearchParams({
+      chainId: '1',
+      from: '1782380000',
+      to: '1782984800',
+      category: 'lending,borrowing',
+      cursor: 'private-opaque-cursor',
+      limit: '25',
+    })
+
+    const first = buildV3ProxyBackoffKey('GET', `/v3/activity/accounts/${ACCOUNT}/events`, params)
+    const second = buildV3ProxyBackoffKey('GET', `/v3/activity/accounts/${OTHER_ACCOUNT}/events`, params)
+
+    expect(first).toBe(second)
+    expect(first).toBe('GET /v3/activity/accounts/:owner/events?chainId=1&from=1782380000&to=1782984800&category=lending%2Cborrowing')
+    expect(first).not.toContain(ACCOUNT)
+    expect(first).not.toContain('private-opaque-cursor')
+  })
+
+  it('keeps account cooldowns scoped to chain and time window', () => {
+    const first = buildV3ProxyBackoffKey(
+      'GET',
+      `/v3/activity/accounts/${ACCOUNT}/events`,
+      new URLSearchParams({ chainId: '1', from: '100', to: '200' }),
+    )
+    const otherWindow = buildV3ProxyBackoffKey(
+      'GET',
+      `/v3/activity/accounts/${ACCOUNT}/events`,
+      new URLSearchParams({ chainId: '1', from: '200', to: '300' }),
+    )
+    const otherChain = buildV3ProxyBackoffKey(
+      'GET',
+      `/v3/activity/accounts/${ACCOUNT}/events`,
+      new URLSearchParams({ chainId: '8453', from: '100', to: '200' }),
+    )
+
+    expect(first).not.toBe(otherWindow)
+    expect(first).not.toBe(otherChain)
+  })
+
+  it('omits unbounded activity context values', () => {
+    const key = buildV3ProxyBackoffKey(
+      'GET',
+      `/v3/activity/accounts/${ACCOUNT}/events`,
+      new URLSearchParams({
+        chainId: '1'.repeat(300),
+        from: '1'.repeat(17),
+        category: 'a'.repeat(300),
+      }),
+    )
+
+    expect(key).toBe('GET /v3/activity/accounts/:owner/events')
+  })
+
+  it('normalizes public vault addresses while preserving kind and chain context', () => {
+    const params = new URLSearchParams({ vaultType: 'earn', category: 'governance' })
+    const first = buildV3ProxyBackoffKey('GET', `/v3/activity/vaults/1/${VAULT}/events`, params)
+    const second = buildV3ProxyBackoffKey('GET', `/v3/activity/vaults/1/${OTHER_VAULT}/events`, params)
+    const otherChain = buildV3ProxyBackoffKey('GET', `/v3/activity/vaults/8453/${VAULT}/events`, params)
+
+    expect(first).toBe(second)
+    expect(first).toBe('GET /v3/activity/vaults/1/:vault/events?vaultType=earn&category=governance')
+    expect(first).not.toBe(otherChain)
+    expect(first).not.toContain(VAULT)
+  })
+
+  it('prunes expired entries whenever a backoff is recorded', () => {
+    recordV3ProxyBackoff('expired-one', 0)
+    recordV3ProxyBackoff('expired-two', 1)
+
+    recordV3ProxyBackoff('current', V3_PROXY_FAILURE_BACKOFF_MS + 1)
+
+    expect(getV3ProxyBackoffCountForTest()).toBe(1)
+    expect(readV3ProxyBackoffMs('current', V3_PROXY_FAILURE_BACKOFF_MS + 1)).toBe(
+      V3_PROXY_FAILURE_BACKOFF_MS,
+    )
+  })
+
+  it('bounds active backoffs and evicts the oldest recorded key', () => {
+    for (let index = 0; index <= V3_PROXY_MAX_BACKOFF_ENTRIES; index++) {
+      recordV3ProxyBackoff(`key-${index}`, 0)
+    }
+
+    expect(getV3ProxyBackoffCountForTest()).toBe(V3_PROXY_MAX_BACKOFF_ENTRIES)
+    expect(readV3ProxyBackoffMs('key-0', 0)).toBe(0)
+    expect(readV3ProxyBackoffMs('key-1', 0)).toBe(V3_PROXY_FAILURE_BACKOFF_MS)
+    expect(readV3ProxyBackoffMs(`key-${V3_PROXY_MAX_BACKOFF_ENTRIES}`, 0)).toBe(
+      V3_PROXY_FAILURE_BACKOFF_MS,
+    )
+  })
+})
diff --git a/tests/server/v3-proxy-route.test.ts b/tests/server/v3-proxy-route.test.ts
index 709eab0c5..fbed5ddb6 100644
--- a/tests/server/v3-proxy-route.test.ts
+++ b/tests/server/v3-proxy-route.test.ts
@@ -300,6 +300,36 @@ describe('/api/internal/v3 proxy route', () => {
     expect(mocks.fetchWithTimeout).toHaveBeenCalledTimes(1)
   })
 
+  it('sanitizes owner-scoped activity transport errors before logging', async () => {
+    const cursor = 'private-opaque-cursor'
+    const requestUrl = `https://app.example/api/internal/v3/activity/accounts/${ACCOUNT}/events?chainId=1&cursor=${cursor}`
+    const cause = new TypeError(`Failed to fetch ${requestUrl}`)
+    mocks.fetchWithTimeout.mockRejectedValueOnce(Object.assign(
+      new Error(`Activity request failed for ${requestUrl}`),
+      { code: 'UND_ERR_CONNECT_TIMEOUT', cause },
+    ))
+
+    await expect(handler(makeEvent('GET', requestUrl))).rejects.toMatchObject({
+      statusCode: 503,
+      statusMessage: 'V3 upstream unavailable',
+    })
+
+    const logRecord = mocks.warn.mock.calls.find(([, message]) => message === 'upstream fetch failed')?.[0]
+    expect(logRecord).toMatchObject({
+      ctx: 'v3-proxy',
+      pathTemplate: '/v3/activity/accounts/:address/events',
+      v3ActivityScope: 'account',
+      v3ChainIds: '1',
+      err: {
+        name: 'Error',
+        code: 'UND_ERR_CONNECT_TIMEOUT',
+        causeName: 'TypeError',
+      },
+    })
+    expect(JSON.stringify(logRecord)).not.toContain(ACCOUNT)
+    expect(JSON.stringify(logRecord)).not.toContain(cursor)
+  })
+
   it('classifies aborts as upstream timeouts without forwarding client-controlled error fields', async () => {
     mocks.fetchWithTimeout.mockRejectedValueOnce(new DOMException('attacker-controlled text', 'AbortError'))
     const event = makeEvent('GET', `https://app.example/api/internal/v3/rewards/breakdown?chainId=1&account=${ACCOUNT}`)
diff --git a/tests/server/v3-proxy.test.ts b/tests/server/v3-proxy.test.ts
index ce98bf904..f0f6f6d88 100644
--- a/tests/server/v3-proxy.test.ts
+++ b/tests/server/v3-proxy.test.ts
@@ -32,6 +32,8 @@ describe('v3 proxy utilities', () => {
 
   it('allows only SDK-owned V3 path shapes', () => {
     expect(isV3ProxyPathAllowed(`/v3/accounts/${ACCOUNT}/positions`)).toBe(true)
+    expect(isV3ProxyPathAllowed(`/v3/activity/accounts/${ACCOUNT}/events`)).toBe(true)
+    expect(isV3ProxyPathAllowed(`/v3/activity/vaults/1/${VAULT}/events`)).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/apys/intrinsic')).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/apys/rewards')).toBe(true)
     expect(isV3ProxyPathAllowed(`/v3/earn/vaults/1/${VAULT}`)).toBe(true)
@@ -41,6 +43,7 @@ describe('v3 proxy utilities', () => {
     expect(isV3ProxyPathAllowed(`/v3/evk/vaults/1/${VAULT}/totals`)).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/evk/vaults/open-interest')).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/evk/vaults/open-interest/by-collateral')).toBe(true)
+    expect(isV3ProxyPathAllowed('/v3/liquidations')).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/prices')).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/resolve/vaults')).toBe(true)
     expect(isV3ProxyPathAllowed('/v3/rewards/breakdown')).toBe(true)
@@ -53,7 +56,14 @@ describe('v3 proxy utilities', () => {
     expect(isV3ProxyPathAllowed('/v3/evk/vaults/bad-debt/history')).toBe(false)
     expect(isV3ProxyPathAllowed('/v3/evk/vaults-admin')).toBe(false)
     expect(isV3ProxyPathAllowed('/v3/apys/unknown')).toBe(false)
+    expect(isV3ProxyPathAllowed('/v3/liquidations/admin')).toBe(false)
+    expect(isV3ProxyPathAllowed('/v3/liquidations-extra')).toBe(false)
     expect(isV3ProxyPathAllowed('/v3/resolve')).toBe(false)
+    expect(isV3ProxyPathAllowed('/v3/activity/accounts/not-an-address/events')).toBe(false)
+    expect(isV3ProxyPathAllowed(`/v3/activity/accounts/${ACCOUNT}/events/admin`)).toBe(false)
+    expect(isV3ProxyPathAllowed(`/v3/activity/vaults/0/${VAULT}/events`)).toBe(false)
+    expect(isV3ProxyPathAllowed(`/v3/activity/vaults/${'1'.repeat(17)}/${VAULT}/events`)).toBe(false)
+    expect(isV3ProxyPathAllowed(`/v3/activity/vaults/1/not-an-address/events`)).toBe(false)
   })
 
   it('allows query strings on SDK-owned endpoints for V3 to validate', () => {
@@ -85,6 +95,18 @@ describe('v3 proxy utilities', () => {
       'GET',
       new URL('https://app.example/api/internal/v3/tokens?chainId=1&limit=500&type=base'),
     )).toEqual({ ok: true })
+    expect(validateV3ProxyUrl(
+      'GET',
+      new URL(`https://app.example/api/internal/v3/activity/accounts/${ACCOUNT}/events?chainId=1,8453&category=lending,borrowing&cursor=opaque`),
+    )).toEqual({ ok: true })
+    expect(validateV3ProxyUrl(
+      'GET',
+      new URL(`https://app.example/api/internal/v3/activity/vaults/1/${VAULT}/events?vaultType=evk&category=governance`),
+    )).toEqual({ ok: true })
+    expect(validateV3ProxyUrl(
+      'GET',
+      new URL(`https://app.example/api/internal/v3/liquidations?chainId=1&vault=${VAULT}&violator=${ACCOUNT}&from=1782380000&to=1782984800&limit=100&offset=0`),
+    )).toEqual({ ok: true })
     expect(validateV3ProxyUrl(
       'GET',
       new URL(`https://app.example/api/internal/v3/prices?chainId=1&assets=${ACCOUNT}&limit=100&debug=true`),
@@ -144,6 +166,54 @@ describe('v3 proxy utilities', () => {
     })
   })
 
+  it('logs bounded activity context without account addresses', () => {
+    expect(buildV3ProxyLogFields(
+      new URL(`https://app.example/api/internal/v3/activity/accounts/${ACCOUNT}/events?chainId=1,8453&from=1782380000&to=1782984800&category=lending,borrowing&eventType=deposit,borrow&offset=0&limit=25`),
+    )).toEqual({
+      v3ActivityCategories: 'lending,borrowing',
+      v3ActivityEventTypes: 'deposit,borrow',
+      v3ActivityScope: 'account',
+      v3ChainIds: '1,8453',
+      v3From: '1782380000',
+      v3Limit: '25',
+      v3Offset: '0',
+      v3To: '1782984800',
+    })
+
+    expect(buildV3ProxyLogFields(
+      new URL(`https://app.example/api/internal/v3/activity/accounts/${ACCOUNT}/events?chainId=${'1'.repeat(300)}&from=${'1'.repeat(17)}&category=${'a'.repeat(300)}`),
+    )).toEqual({
+      v3ActivityScope: 'account',
+    })
+  })
+
+  it('logs public vault activity context', () => {
+    expect(buildV3ProxyLogFields(
+      new URL(`https://app.example/api/internal/v3/activity/vaults/1/${VAULT}/events?vaultType=securitize&category=lending,governance&limit=25`),
+    )).toEqual({
+      v3ActivityCategories: 'lending,governance',
+      v3ActivityScope: 'vault',
+      v3ChainId: '1',
+      v3Limit: '25',
+      v3VaultAddress: VAULT,
+      v3VaultKind: 'securitize',
+    })
+  })
+
+  it('logs liquidations context without violator or liquidator addresses', () => {
+    expect(buildV3ProxyLogFields(
+      new URL(`https://app.example/api/internal/v3/liquidations?chainId=1&vault=${VAULT}&violator=${ACCOUNT}&liquidator=${ACCOUNT}&from=1782380000&to=1782984800&limit=100&offset=0`),
+    )).toEqual({
+      v3ActivityScope: 'liquidations',
+      v3ChainId: '1',
+      v3From: '1782380000',
+      v3Limit: '100',
+      v3Offset: '0',
+      v3To: '1782984800',
+      v3VaultAddress: VAULT,
+    })
+  })
+
   it('injects only fixed SDK headers and the server-side API key', () => {
     const headers = buildV3ProxyRequestHeaders('POST', {
       EULER_SDK_V3_API_KEY: 'server-key',
diff --git a/tests/utils/activity-display.test.ts b/tests/utils/activity-display.test.ts
new file mode 100644
index 000000000..c9f873740
--- /dev/null
+++ b/tests/utils/activity-display.test.ts
@@ -0,0 +1,1102 @@
+import { describe, expect, it } from 'vitest'
+import type { ActivityEvent } from '@eulerxyz/euler-v2-sdk'
+import { maxUint256, type Address } from 'viem'
+import {
+  decodeEvkAmountCap,
+  enrichActivityAssetForDisplay,
+  filterActivityEventsForDisplay,
+  formatActivityAssetAmount,
+  formatActivityAssetUsd,
+  formatActivityEventLabel,
+  formatActivityRelativeTimestamp,
+  formatActivityTimestamp,
+  formatActivityValuation,
+  formatActivityValuationForAssets,
+  getAccountActivityCategories,
+  getAccountActivityFilterOptions,
+  getActivityAmountDirection,
+  getActivityAssetAddressLabel,
+  getActivityAssetLabel,
+  getActivityAssetsForDisplay,
+  getActivityChangeEntries,
+  getActivityEventIcon,
+  getActivityLiquidationDisplayDetails,
+  getPortfolioActivityPositionParticipant,
+  getActivityTransferDirection,
+  getActivityTransactionGroupLabel,
+  getDefaultVaultActivityFilter,
+  getDisplayActivityEventTypes,
+  getVaultActivityFilterOptions,
+  groupActivityEventsByTransaction,
+  isActivityScopeUnsupported,
+  resolveActivityFilterCategories,
+  resolveActivityVaultDisplay,
+} from '~/utils/activity-display'
+import { isVaultBorrowable } from '~/utils/vault/classification'
+
+const ASSET = '0x0000000000000000000000000000000000000001' as const
+const VAULT = '0x0000000000000000000000000000000000000002' as const
+const SHARES = '0x0000000000000000000000000000000000000003' as const
+const OTHER_VAULT = '0x0000000000000000000000000000000000000004' as const
+const VIOLATOR = '0x0000000000000000000000000000000000000005' as const
+const LIQUIDATOR = '0x0000000000000000000000000000000000000006' as const
+const USD_UNIT_OF_ACCOUNT = '0x0000000000000000000000000000000000000348' as const
+
+describe('activity display helpers', () => {
+  it('uses bounded scope-specific event filters without display noise', () => {
+    const scopes = [
+      { kind: 'account' },
+      { kind: 'vault', vaultType: 'evk' },
+      { kind: 'vault', vaultType: 'earn' },
+      { kind: 'vault', vaultType: 'securitize' },
+    ] as const
+    const hiddenTypes = ['interest_accrued', 'accrue_interest', 'mint', 'burn']
+
+    for (const scope of scopes) {
+      const eventTypes = getDisplayActivityEventTypes(scope)
+      expect(eventTypes.join(',').length).toBeLessThanOrEqual(1_024)
+      expect(eventTypes).not.toEqual(expect.arrayContaining(hiddenTypes))
+    }
+
+    expect(getDisplayActivityEventTypes({ kind: 'account' })).toEqual([
+      'deposit',
+      'withdraw',
+      'borrow',
+      'repay',
+      'pull_debt',
+      'liquidation',
+    ])
+    expect(getDisplayActivityEventTypes({ kind: 'vault', vaultType: 'evk' })).toEqual(expect.arrayContaining([
+      'deposit',
+      'withdraw',
+      'borrow',
+      'repay',
+      'set_caps',
+      'set_ltv',
+      'liquidation',
+    ]))
+
+    const earnEventTypes = getDisplayActivityEventTypes({ kind: 'vault', vaultType: 'earn' })
+    expect(earnEventTypes).toEqual(expect.arrayContaining([
+      'deposit',
+      'withdraw',
+      'transfer',
+      'reallocate_supply',
+      'reallocate_withdraw',
+      'public_reallocate_to',
+      'public_withdrawal',
+      'set_cap',
+      'set_fee',
+    ]))
+    expect(earnEventTypes).not.toEqual(expect.arrayContaining([
+      'approval',
+      'update_last_total_assets',
+      'update_lost_assets',
+    ]))
+  })
+
+  it('returns the focused portfolio position category filters in display order', () => {
+    // Only liquidations is exposed as a chip — verbs and transaction grouping
+    // already communicate lending/borrowing — while the unfiltered feed still
+    // queries every displayable category. No `account` category anywhere:
+    // none of its event types are displayed on Lite.
+    expect(getAccountActivityFilterOptions()).toEqual([
+      { value: 'liquidations', label: 'Liquidations', categories: ['liquidations'] },
+    ])
+    expect(getAccountActivityCategories()).toEqual(['lending', 'borrowing', 'liquidations'])
+  })
+
+  it('returns vault-specific category filters with category-accurate labels', () => {
+    expect(getVaultActivityFilterOptions('evk')).toEqual([
+      { value: 'lending-borrowing', label: 'Lending and borrowing', categories: ['lending', 'borrowing'] },
+      { value: 'governance', label: 'Governance', categories: ['governance'] },
+      { value: 'liquidations', label: 'Liquidations', categories: ['liquidations'] },
+    ])
+    expect(getVaultActivityFilterOptions('earn')).toEqual([
+      { value: 'lending', label: 'Lending', categories: ['lending'] },
+      { value: 'governance', label: 'Governance', categories: ['governance'] },
+    ])
+    expect(getVaultActivityFilterOptions('securitize')).toEqual([
+      { value: 'lending', label: 'Lending', categories: ['lending'] },
+      { value: 'governance', label: 'Governance', categories: ['governance'] },
+    ])
+
+    const options = getVaultActivityFilterOptions('evk')
+    expect(resolveActivityFilterCategories(options, [])).toEqual([
+      'borrowing',
+      'governance',
+      'lending',
+      'liquidations',
+    ])
+    expect(resolveActivityFilterCategories(options, ['lending-borrowing'])).toEqual([
+      'borrowing',
+      'lending',
+    ])
+  })
+
+  it('defaults vault activity to lending and borrowing without hiding other filters', () => {
+    expect(getDefaultVaultActivityFilter('evk')).toBe('lending-borrowing')
+    expect(getDefaultVaultActivityFilter('earn')).toBe('lending')
+    expect(getDefaultVaultActivityFilter('securitize')).toBe('lending')
+  })
+
+  it('keeps historical borrowing filters for a currently non-borrowable EVK', () => {
+    expect(isVaultBorrowable({ isBorrowable: false, totalBorrowed: 0n })).toBe(false)
+
+    expect(resolveActivityFilterCategories(getVaultActivityFilterOptions('evk'), [])).toEqual([
+      'borrowing',
+      'governance',
+      'lending',
+      'liquidations',
+    ])
+  })
+
+  it('distinguishes same-token account activity from different markets', () => {
+    const getVaultMetadata = (address: Address) => ({
+      asset: { address: ASSET, name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+      shares: {
+        address,
+        name: 'Euler USDC',
+        symbol: 'eUSDC',
+        decimals: 18,
+      },
+    })
+
+    const firstMarket = resolveActivityVaultDisplay(VAULT, getVaultMetadata, 'USDC Prime')
+    const secondMarket = resolveActivityVaultDisplay(OTHER_VAULT, getVaultMetadata)
+
+    expect(firstMarket).toMatchObject({
+      name: 'USDC Prime',
+      addressLabel: '0x0000...0002',
+    })
+    expect(secondMarket).toMatchObject({
+      name: 'Euler USDC',
+      addressLabel: '0x0000...0004',
+    })
+    expect(firstMarket?.addressLabel).not.toBe(secondMarket?.addressLabel)
+  })
+
+  it('falls back to a shortened market address when registry metadata is unavailable', () => {
+    expect(resolveActivityVaultDisplay(VAULT, () => undefined)).toEqual({
+      address: VAULT,
+      addressLabel: '0x0000...0002',
+    })
+    expect(resolveActivityVaultDisplay(undefined, () => undefined)).toBeNull()
+  })
+
+  it('treats only explicit-All unsupported coverage as scope-wide', () => {
+    expect(isActivityScopeUnsupported('unsupported', [])).toBe(true)
+    expect(isActivityScopeUnsupported('unsupported', ['governance'])).toBe(false)
+    expect(isActivityScopeUnsupported('partial', [])).toBe(false)
+  })
+
+  it('uses normalized labels and titleizes fallback event types', () => {
+    expect(formatActivityEventLabel({ label: 'Borrowed USDC', type: 'borrow' })).toBe('Borrowed USDC')
+    expect(formatActivityEventLabel({ type: 'set_supply_cap' })).toBe('Set supply cap')
+    expect(formatActivityEventLabel({ type: 'set_ltv' })).toBe('Set LTV')
+    expect(formatActivityEventLabel({ type: 'set_interest_rate_model' })).toBe('Set interest rate model')
+  })
+
+  it('labels and styles vault share transfers relative to the event position', () => {
+    const sent = {
+      account: VAULT,
+      category: 'lending' as const,
+      payload: { from: VAULT, to: OTHER_VAULT },
+      type: 'transfer',
+    }
+    const received = {
+      account: VAULT,
+      category: 'lending' as const,
+      payload: { from: OTHER_VAULT, to: VAULT },
+      type: 'transfer',
+    }
+
+    expect(getActivityTransferDirection(sent)).toBe('sent')
+    expect(formatActivityEventLabel(sent)).toBe('Vault shares sent')
+    expect(getActivityEventIcon(sent)).toEqual({ name: 'borrow-outline' })
+    expect(getActivityTransferDirection(received)).toBe('received')
+    expect(formatActivityEventLabel(received)).toBe('Vault shares received')
+    expect(getActivityEventIcon(received)).toEqual({ name: 'lend-outline' })
+    expect(formatActivityEventLabel({ ...sent, label: 'Custom transfer' })).toBe('Custom transfer')
+  })
+
+  it('hides only exact paired vault share transfers from the same transaction', () => {
+    const base = {
+      chainId: 1,
+      category: 'lending' as const,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      logIndex: 0,
+      txHash: `0x${'1'.repeat(64)}`,
+      source: 'v3-ponder',
+      payload: {},
+      vault: VAULT,
+      groupId: 'transaction-one',
+    }
+    const events = [
+      {
+        ...base,
+        id: 'deposit',
+        type: 'deposit',
+        rawType: 'deposit',
+        assets: [{ kind: 'shares', address: SHARES, amountRaw: '100' }],
+      },
+      {
+        ...base,
+        id: 'paired-transfer',
+        type: 'transfer',
+        rawType: 'transfer',
+        assets: [{ kind: 'shares', address: SHARES, amountRaw: '100' }],
+      },
+      {
+        ...base,
+        id: 'independent-transfer',
+        type: 'transfer',
+        rawType: 'transfer',
+        assets: [{ kind: 'shares', address: SHARES, amountRaw: '25' }],
+      },
+      {
+        ...base,
+        id: 'other-transaction',
+        txHash: `0x${'2'.repeat(64)}`,
+        type: 'transfer',
+        rawType: 'transfer',
+        assets: [{ kind: 'shares', address: SHARES, amountRaw: '100' }],
+      },
+    ] as ActivityEvent[]
+
+    expect(filterActivityEventsForDisplay(events, ['deposit', 'transfer']).map(event => event.id)).toEqual([
+      'deposit',
+      'independent-transfer',
+      'other-transaction',
+    ])
+  })
+
+  it('hides only the violator repay emitted alongside a liquidation', () => {
+    const base = {
+      chainId: 1,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      txHash: '0x830d02459a26d4893b105cd7edbf4720bd2cd649f5fa382cdbed5fee4b64895c',
+      source: 'v3-ponder',
+      payload: {},
+      vault: VAULT,
+    }
+    const events = [
+      {
+        ...base,
+        id: 'violator-repay',
+        category: 'borrowing',
+        logIndex: 259,
+        type: 'repay',
+        rawType: 'repay',
+        account: VIOLATOR,
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '2584055565' }],
+      },
+      {
+        ...base,
+        id: 'liquidator-borrow',
+        category: 'borrowing',
+        logIndex: 261,
+        type: 'borrow',
+        rawType: 'borrow',
+        account: LIQUIDATOR,
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '2584055565' }],
+      },
+      {
+        ...base,
+        id: 'liquidation',
+        category: 'liquidations',
+        logIndex: 265,
+        type: 'liquidation',
+        rawType: 'liquidation',
+        account: VIOLATOR,
+        counterparty: VIOLATOR,
+        payload: { violator: VIOLATOR },
+        assets: [
+          { kind: 'assets', address: ASSET, amountRaw: '2584055565' },
+          { kind: 'collateral', address: OTHER_VAULT, amountRaw: '200' },
+        ],
+      },
+      {
+        ...base,
+        id: 'liquidator-repay',
+        category: 'borrowing',
+        logIndex: 268,
+        type: 'repay',
+        rawType: 'repay',
+        account: LIQUIDATOR,
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '2584055565' }],
+      },
+    ] as ActivityEvent[]
+
+    expect(filterActivityEventsForDisplay(events, ['borrow', 'repay', 'liquidation']).map(event => event.id)).toEqual([
+      'liquidator-borrow',
+      'liquidation',
+      'liquidator-repay',
+    ])
+  })
+
+  it('preserves a liquidator repay when the liquidation is projected onto their account', () => {
+    const base = {
+      chainId: 1,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      txHash: '0x830d02459a26d4893b105cd7edbf4720bd2cd649f5fa382cdbed5fee4b64895c',
+      source: 'v3-ponder',
+      vault: VAULT,
+    }
+    const events = [
+      {
+        ...base,
+        id: 'liquidation',
+        category: 'liquidations',
+        logIndex: 265,
+        type: 'liquidation',
+        rawType: 'liquidation',
+        account: LIQUIDATOR,
+        counterparty: VIOLATOR,
+        payload: { violator: VIOLATOR },
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '2584055565' }],
+      },
+      {
+        ...base,
+        id: 'liquidator-repay',
+        category: 'borrowing',
+        logIndex: 268,
+        type: 'repay',
+        rawType: 'repay',
+        account: LIQUIDATOR,
+        payload: {},
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '2584055565' }],
+      },
+    ] as ActivityEvent[]
+
+    expect(filterActivityEventsForDisplay(events, ['repay', 'liquidation']).map(event => event.id)).toEqual([
+      'liquidation',
+      'liquidator-repay',
+    ])
+  })
+
+  it('keeps matching repayments when the liquidation violator is unavailable', () => {
+    const base = {
+      chainId: 1,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      txHash: `0x${'1'.repeat(64)}`,
+      source: 'v3-ponder',
+      payload: {},
+      vault: VAULT,
+    }
+    const events = [
+      {
+        ...base,
+        id: 'repay',
+        category: 'borrowing',
+        logIndex: 1,
+        type: 'repay',
+        rawType: 'repay',
+        account: VIOLATOR,
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '100' }],
+      },
+      {
+        ...base,
+        id: 'liquidation',
+        category: 'liquidations',
+        logIndex: 2,
+        type: 'liquidation',
+        rawType: 'liquidation',
+        assets: [{ kind: 'assets', address: ASSET, amountRaw: '100' }],
+      },
+    ] as ActivityEvent[]
+
+    expect(filterActivityEventsForDisplay(events, ['repay', 'liquidation']).map(event => event.id)).toEqual([
+      'repay',
+      'liquidation',
+    ])
+  })
+
+  it('suppresses zero-value liquidation artifacts but keeps unknown and non-zero rows', () => {
+    const base = {
+      chainId: 1,
+      category: 'liquidations' as const,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      logIndex: 0,
+      txHash: `0x${'a'.repeat(64)}`,
+      type: 'liquidation' as const,
+      rawType: 'liquidation',
+      source: 'v3-ponder',
+      payload: {},
+    }
+    const events = [
+      {
+        ...base,
+        id: 'zero',
+        assets: [
+          { kind: 'assets' as const, amountRaw: '0' },
+          { kind: 'collateral' as const, amountRaw: '0' },
+        ],
+      },
+      {
+        ...base,
+        id: 'non-zero',
+        logIndex: 1,
+        assets: [
+          { kind: 'assets' as const, amountRaw: '1' },
+          { kind: 'collateral' as const, amountRaw: '0' },
+        ],
+      },
+      { ...base, id: 'unknown', logIndex: 2 },
+    ] as ActivityEvent[]
+
+    expect(filterActivityEventsForDisplay(events, ['liquidation'], {
+      hideZeroLiquidations: true,
+    }).map(event => event.id)).toEqual([
+      'non-zero',
+      'unknown',
+    ])
+    expect(filterActivityEventsForDisplay(events, ['liquidation']).map(event => event.id)).toEqual([
+      'zero',
+      'non-zero',
+      'unknown',
+    ])
+  })
+
+  it('groups composite portfolio operations by chain and transaction hash', () => {
+    const base = {
+      chainId: 1,
+      category: 'lending' as const,
+      timestamp: '2026-07-13T10:30:00.000Z',
+      blockNumber: '123',
+      logIndex: 0,
+      txHash: `0x${'a'.repeat(64)}`,
+      source: 'v3-ponder',
+      payload: {},
+    }
+    const events = [
+      { ...base, id: 'deposit', type: 'deposit', rawType: 'deposit' },
+      { ...base, id: 'borrow', type: 'borrow', rawType: 'borrow', txHash: base.txHash.toUpperCase() },
+      { ...base, id: 'withdraw', type: 'withdraw', rawType: 'withdraw', txHash: `0x${'b'.repeat(64)}` },
+    ] as ActivityEvent[]
+
+    expect(groupActivityEventsByTransaction(events).map(group => group.events.map(event => event.id))).toEqual([
+      ['deposit', 'borrow'],
+      ['withdraw'],
+    ])
+  })
+
+  it('labels transaction groups containing a liquidation', () => {
+    expect(getActivityTransactionGroupLabel({
+      events: [
+        { type: 'repay' } as ActivityEvent,
+        { type: 'liquidation' } as ActivityEvent,
+      ],
+    })).toBe('Liquidation transaction')
+    expect(getActivityTransactionGroupLabel({
+      events: [{ type: 'repay' } as ActivityEvent],
+    })).toBe('Transaction')
+  })
+
+  it('shows only underlying asset amounts', () => {
+    const event = {
+      category: 'lending',
+      assets: [
+        { kind: 'assets', address: ASSET, amountRaw: '100' },
+        { kind: 'shares', address: VAULT, amountRaw: '90' },
+        { kind: 'collateral', address: OTHER_VAULT, amountRaw: '80' },
+      ],
+    } as Pick<ActivityEvent, 'assets' | 'category'>
+
+    expect(getActivityAssetsForDisplay(event)).toEqual([
+      { kind: 'assets', address: ASSET, amountRaw: '100' },
+    ])
+  })
+
+  it('includes collateral seized by liquidations without relabeling the debt token as a vault', () => {
+    const event = {
+      category: 'liquidations',
+      assets: [
+        { kind: 'assets', address: ASSET, amountRaw: '100' },
+        { kind: 'collateral', address: OTHER_VAULT, amountRaw: '80' },
+        { kind: 'shares', address: VAULT, amountRaw: '70' },
+      ],
+    } as Pick<ActivityEvent, 'assets' | 'category'>
+
+    expect(getActivityAssetsForDisplay(event)).toEqual([
+      { kind: 'assets', address: ASSET, amountRaw: '100' },
+      { kind: 'collateral', address: OTHER_VAULT, amountRaw: '80' },
+    ])
+    expect(getActivityAssetAddressLabel('assets', 'liquidations')).toBe('Asset')
+    expect(getActivityAssetAddressLabel('collateral', 'liquidations')).toBe('Collateral vault')
+  })
+
+  it('formats normalized and raw asset amounts without inventing USD values', () => {
+    expect(formatActivityAssetAmount({ kind: 'assets', address: ASSET, amountRaw: '1234500000', amount: '1234.5', symbol: 'USDC' })).toBe('1.23K USDC')
+    expect(formatActivityAssetAmount({ kind: 'assets', address: ASSET, amountRaw: '100445960000', decimals: 6, symbol: 'USDC' })).toBe('100.45K USDC')
+    expect(formatActivityAssetAmount({ kind: 'assets', address: ASSET, amountRaw: '1500000', decimals: 6, symbol: 'USDC' })).toBe('1.5 USDC')
+    expect(formatActivityAssetAmount({ kind: 'assets', amountRaw: '1500000' })).toBe('Amount unavailable')
+    expect(formatActivityAssetUsd({ kind: 'assets', amountRaw: '1', amountUsd: '1234.5' })).toBe('$1.23K')
+    expect(formatActivityAssetUsd({ kind: 'assets', amountRaw: '1' })).toBeNull()
+    expect(formatActivityValuation({ status: 'unavailable', reason: 'No historical price' })).toBeNull()
+    expect(formatActivityValuation({ status: 'partial', amountUsd: '1234.5' })).toBe('$1.23K (partial)')
+    expect(formatActivityAssetAmount({ kind: 'assets', amountRaw: maxUint256.toString(), decimals: 18, symbol: 'USDC' }, 'approval')).toBe('Unlimited')
+    expect(formatActivityAssetAmount({ kind: 'assets', amountRaw: '0', decimals: 18, symbol: 'USDC' }, 'approval')).toBe('Revoked')
+    expect(getActivityAssetLabel('assets', 'account', 'approval')).toBe('Allowance')
+    expect(formatActivityValuationForAssets(
+      { status: 'available', amountUsd: '1234.5' },
+      [{ kind: 'assets', amountRaw: '1', amountUsd: '1234.5' }],
+    )).toBeNull()
+  })
+
+  it('enriches raw amounts from registry metadata without overriding source fields', () => {
+    const getVaultMetadata = (address: string) => address.toLowerCase() === VAULT.toLowerCase()
+      ? {
+          asset: { address: ASSET, symbol: 'USDC', decimals: 6 },
+          shares: { address: SHARES, symbol: 'eUSDC', decimals: 18 },
+        }
+      : undefined
+
+    expect(enrichActivityAssetForDisplay(
+      { kind: 'assets', amountRaw: '1500000' },
+      { category: 'lending', vault: VAULT },
+      getVaultMetadata,
+    )).toEqual({
+      kind: 'assets',
+      amountRaw: '1500000',
+      address: ASSET,
+      symbol: 'USDC',
+      decimals: 6,
+    })
+
+    expect(enrichActivityAssetForDisplay(
+      { kind: 'shares', amountRaw: '1', address: VAULT, symbol: 'Source shares' },
+      { category: 'lending', vault: VAULT },
+      getVaultMetadata,
+    )).toEqual({
+      kind: 'shares',
+      amountRaw: '1',
+      address: VAULT,
+      symbol: 'Source shares',
+      decimals: 18,
+    })
+
+    expect(enrichActivityAssetForDisplay(
+      { kind: 'value', amountRaw: '100', address: ASSET },
+      { category: 'rewards' },
+      getVaultMetadata,
+      address => address === ASSET
+        ? { address: ASSET, symbol: 'EUL', decimals: 18 }
+        : undefined,
+    )).toEqual({
+      kind: 'value',
+      amountRaw: '100',
+      address: ASSET,
+      symbol: 'EUL',
+      decimals: 18,
+    })
+
+    const unpriced = enrichActivityAssetForDisplay(
+      { kind: 'assets', amountRaw: '1500000' },
+      { category: 'lending', vault: VAULT },
+      getVaultMetadata,
+    )
+    expect(unpriced.amountUsd).toBeUndefined()
+  })
+
+  it('decodes EVK caps and formats vault configuration changes semantically', () => {
+    const getVaultMetadata = (address: Address) => address.toLowerCase() === VAULT.toLowerCase()
+      ? {
+          asset: { address: ASSET, name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+          shares: { address: VAULT, name: 'Euler USDC', symbol: 'eUSDC', decimals: 18 },
+        }
+      : address.toLowerCase() === OTHER_VAULT.toLowerCase()
+        ? {
+            asset: { address: ASSET, name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+            shares: { address: OTHER_VAULT, name: 'Collateral vault', symbol: 'eUSDC', decimals: 18 },
+            vaultType: 'evk' as const,
+          }
+        : undefined
+
+    expect(decodeEvkAmountCap('8974')).toBe(140_000_000_000_000n)
+    expect(decodeEvkAmountCap('65536')).toBeNull()
+    expect(getActivityChangeEntries({
+      type: 'set_caps',
+      vault: VAULT,
+      vaultType: 'evk',
+      change: {
+        fields: {
+          borrow_cap: '8974',
+          supply_cap: '9934',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'borrow_cap', label: 'Borrow cap', value: '140M USDC' },
+      { field: 'supply_cap', label: 'Supply cap', value: '155M USDC' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'set_ltv',
+      vault: VAULT,
+      vaultType: 'evk',
+      change: {
+        fields: {
+          collateral: OTHER_VAULT,
+          borrow_ltv: '8500',
+          liquidation_ltv: '9000',
+          ramp_duration: '90000',
+          target_timestamp: '1767225600',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      {
+        field: 'collateral',
+        label: 'Collateral',
+        addresses: [{
+          address: OTHER_VAULT,
+          label: 'Collateral vault',
+          linkKind: 'vault',
+          vaultType: 'evk',
+        }],
+      },
+      { field: 'borrow_ltv', label: 'Borrow LTV', value: '85%' },
+      { field: 'liquidation_ltv', label: 'Liquidation LTV', value: '90%' },
+      { field: 'ramp_duration', label: 'Ramp duration', value: '1 day 1 hour' },
+      { field: 'target_timestamp', label: 'Target timestamp', value: expect.stringContaining('1 Jan 2026') },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'submit_cap',
+      vault: VAULT,
+      vaultType: 'earn',
+      change: {
+        fields: {
+          cap: '1000000000',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'cap', label: 'Cap', value: '1K USDC' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'set_cap',
+      vault: VAULT,
+      vaultType: 'earn',
+      change: {
+        fields: {
+          cap: (2n ** 136n).toString(),
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'cap', label: 'Cap', value: 'Unlimited' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'set_supply_cap',
+      vault: VAULT,
+      vaultType: 'securitize',
+      change: {
+        fields: {
+          new_supply_cap: '155000000000000',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'new_supply_cap', label: 'New supply cap', value: '155M USDC' },
+    ])
+  })
+
+  it('orders LTV change fields and trims ramp fields on immediate changes', () => {
+    // Upstream field order is unhelpful; an immediate change never ramps, so
+    // the ramp target fields are dropped.
+    expect(getActivityChangeEntries({
+      type: 'set_ltv',
+      vault: VAULT,
+      vaultType: 'evk',
+      change: {
+        fields: {
+          borrow_ltv: '9000',
+          ramp_duration: '0',
+          initial_liquidation_ltv: '0',
+          liquidation_ltv: '9300',
+          target_timestamp: '1767225600',
+          collateral: OTHER_VAULT,
+        },
+      },
+    }).map(entry => `${entry.field}:${entry.value ?? 'addresses'}`)).toEqual([
+      'collateral:addresses',
+      'borrow_ltv:90%',
+      'liquidation_ltv:93%',
+      'ramp_duration:Immediately',
+    ])
+  })
+
+  it('decodes config flag bitmasks and renders zero addresses as None', () => {
+    const configFlagEntries = (newConfigFlags: string) => getActivityChangeEntries({
+      type: 'set_config_flags',
+      change: { fields: { new_config_flags: newConfigFlags } },
+    })
+    expect(configFlagEntries('0')).toEqual([
+      { field: 'new_config_flags', label: 'New config flags', value: 'Debt socialization enabled' },
+    ])
+    expect(configFlagEntries('1')).toEqual([
+      { field: 'new_config_flags', label: 'New config flags', value: 'Debt socialization disabled' },
+    ])
+    // Unknown bit combinations fall back to the raw bitmask.
+    expect(configFlagEntries('5')).toEqual([
+      { field: 'new_config_flags', label: 'New config flags', value: '5' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'set_governor_admin',
+      change: { fields: { new_governor_admin: '0x0000000000000000000000000000000000000000' } },
+    })).toEqual([
+      { field: 'new_governor_admin', label: 'New governor admin', value: 'None' },
+    ])
+  })
+
+  it('drops redundant share amounts from reallocation change entries', () => {
+    const getVaultMetadata = () => ({
+      asset: { address: ASSET, name: 'USD Coin', symbol: 'USDC', decimals: 6 },
+      shares: { address: SHARES, name: 'Euler USDC', symbol: 'eUSDC', decimals: 18 },
+      vaultType: 'evk' as const,
+    })
+
+    // The share amount restates the asset amount in strategy share units.
+    expect(getActivityChangeEntries({
+      type: 'reallocate_supply',
+      vault: VAULT,
+      vaultType: 'earn',
+      change: {
+        fields: {
+          strategy: OTHER_VAULT,
+          supplied_assets: '20003',
+          supplied_shares: '20003',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      {
+        field: 'strategy',
+        label: 'Strategy',
+        addresses: [{
+          address: OTHER_VAULT,
+          label: 'Euler USDC',
+          linkKind: 'vault',
+          vaultType: 'evk',
+        }],
+      },
+      { field: 'supplied_assets', label: 'Supplied assets', value: '0.02 USDC' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'reallocate_supply',
+      vault: VAULT,
+      vaultType: 'earn',
+      change: {
+        fields: {
+          supplied_assets: '100445960000',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'supplied_assets', label: 'Supplied assets', value: '100.45K USDC' },
+    ])
+
+    expect(getActivityChangeEntries({
+      type: 'reallocate_withdraw',
+      vault: VAULT,
+      vaultType: 'earn',
+      change: {
+        fields: {
+          withdrawn_assets: '100445960000',
+        },
+      },
+    }, getVaultMetadata)).toEqual([
+      { field: 'withdrawn_assets', label: 'Withdrawn assets', value: '100.45K USDC' },
+    ])
+  })
+
+  it('formats EVK config amounts as percentages and empty hooked ops as None', () => {
+    expect(getActivityChangeEntries({
+      type: 'set_interest_fee',
+      change: { fields: { new_fee: '500' } },
+    })).toEqual([{ field: 'new_fee', label: 'New fee', value: '5%' }])
+
+    expect(getActivityChangeEntries({
+      type: 'set_max_liquidation_discount',
+      change: { fields: { new_discount: '350' } },
+    })).toEqual([{ field: 'new_discount', label: 'New discount', value: '3.5%' }])
+
+    expect(getActivityChangeEntries({
+      type: 'set_hook_config',
+      change: { fields: { new_hooked_ops: '0' } },
+    })).toEqual([{ field: 'new_hooked_ops', label: 'New hooked ops', value: 'None' }])
+    // Non-empty bitmasks stay raw — the operation names are not decoded.
+    expect(getActivityChangeEntries({
+      type: 'set_hook_config',
+      change: { fields: { new_hooked_ops: '4096' } },
+    })).toEqual([{ field: 'new_hooked_ops', label: 'New hooked ops', value: 'Flash loan' }])
+    expect(getActivityChangeEntries({
+      type: 'set_hook_config',
+      change: { fields: { new_hooked_ops: '192' } },
+    })).toEqual([{ field: 'new_hooked_ops', label: 'New hooked ops', value: 'Borrow, Repay' }])
+    expect(getActivityChangeEntries({
+      type: 'set_hook_config',
+      change: { fields: { new_hooked_ops: '32768' } },
+    })).toEqual([{ field: 'new_hooked_ops', label: 'New hooked ops', value: 'Unknown flags (32768)' }])
+  })
+
+  it('links protocol addresses externally and user identities through spy mode', () => {
+    expect(getActivityChangeEntries({
+      type: 'set_interest_rate_model',
+      vault: VAULT,
+      vaultType: 'evk',
+      change: { fields: { new_interest_rate_model: OTHER_VAULT } },
+    })).toEqual([{
+      field: 'new_interest_rate_model',
+      label: 'New interest rate model',
+      addresses: [{ address: OTHER_VAULT, linkKind: 'explorer' }],
+    }])
+  })
+
+  it('labels a viewed liquidated subaccount by position number', () => {
+    expect(getPortfolioActivityPositionParticipant({
+      account: VAULT,
+      actor: ASSET,
+      category: 'liquidations',
+      counterparty: VAULT,
+      owner: OTHER_VAULT,
+      subAccountIndex: 7,
+    })).toEqual({ index: 7, label: 'Position 7' })
+
+    expect(getPortfolioActivityPositionParticipant({
+      account: VAULT,
+      actor: OTHER_VAULT,
+      category: 'liquidations',
+      counterparty: ASSET,
+      owner: VAULT,
+      subAccountIndex: 0,
+    })).toBeNull()
+  })
+
+  it('formats all governance changes and category-specific liquidation details', () => {
+    expect(getActivityChangeEntries({
+      type: 'set_config_flags',
+      change: {
+        fields: {
+          supply_cap: '2000',
+          is_allocator: true,
+          queue: ['one', 'two'],
+        },
+      },
+    })).toEqual([
+      { field: 'supply_cap', label: 'Supply cap', value: '2000' },
+      { field: 'is_allocator', label: 'Is allocator', value: 'Enabled' },
+      { field: 'queue', label: 'Queue', value: 'one, two' },
+    ])
+    expect(getActivityAssetLabel('assets', 'liquidations')).toBe('Debt repaid')
+    expect(getActivityAssetLabel('collateral', 'liquidations')).toBe('Collateral shares seized')
+    expect(getActivityAssetAddressLabel('assets', 'liquidations')).toBe('Asset')
+    expect(getActivityAssetAddressLabel('collateral', 'liquidations')).toBe('Collateral vault')
+  })
+
+  it('formats timestamps', () => {
+    expect(formatActivityTimestamp('not-a-date')).toBe('-')
+    expect(formatActivityTimestamp('2026-07-13T10:30:00.000Z')).toContain('13 Jul 2026')
+  })
+
+  it('formats timestamps relatively at every age', () => {
+    const now = Date.parse('2026-07-13T10:30:00.000Z')
+    expect(formatActivityRelativeTimestamp('not-a-date', now)).toBe('-')
+    expect(formatActivityRelativeTimestamp('2026-07-13T10:29:40.000Z', now)).toBe('Just now')
+    expect(formatActivityRelativeTimestamp('2026-07-13T10:05:00.000Z', now)).toBe('25 min ago')
+    expect(formatActivityRelativeTimestamp('2026-07-13T04:30:00.000Z', now)).toBe('6 h ago')
+    expect(formatActivityRelativeTimestamp('2026-07-10T10:30:00.000Z', now)).toBe('3 d ago')
+    expect(formatActivityRelativeTimestamp('2026-07-01T10:30:00.000Z', now)).toBe('1 w ago')
+    expect(formatActivityRelativeTimestamp('2026-05-13T10:30:00.000Z', now)).toBe('2 mo ago')
+    expect(formatActivityRelativeTimestamp('2024-07-13T10:30:00.000Z', now)).toBe('2 y ago')
+    // Future timestamps (clock skew) fall back to the absolute date.
+    expect(formatActivityRelativeTimestamp('2026-07-14T10:30:00.000Z', now)).toBe('14 Jul 2026')
+  })
+
+  it('derives asset flow direction from the event type and transfer sides', () => {
+    expect(getActivityAmountDirection({ type: 'deposit' })).toBe('in')
+    expect(getActivityAmountDirection({ type: 'repay' })).toBe('in')
+    expect(getActivityAmountDirection({ type: 'withdraw' })).toBe('out')
+    expect(getActivityAmountDirection({ type: 'borrow' })).toBe('out')
+    expect(getActivityAmountDirection({ type: 'set_caps' })).toBeUndefined()
+    expect(getActivityAmountDirection({
+      account: VAULT,
+      payload: { from: VAULT, to: OTHER_VAULT },
+      type: 'transfer',
+    })).toBe('out')
+    expect(getActivityAmountDirection({
+      account: VAULT,
+      payload: { from: OTHER_VAULT, to: VAULT },
+      type: 'transfer',
+    })).toBe('in')
+    expect(getActivityAmountDirection({ type: 'transfer' })).toBeUndefined()
+  })
+
+  it('formats historical liquidation valuations for display', () => {
+    const record = {
+      chainId: 1,
+      vault: VAULT as Address,
+      violator: ASSET as Address,
+      liquidator: OTHER_VAULT as Address,
+      collateral: SHARES as Address,
+      repayAssets: '724612',
+      yieldBalance: '812035276912150036',
+      debtAsset: ASSET as Address,
+      debtAssetDecimals: 6,
+      repayAssetsUsd: 0.7245298289992,
+      collateralAsset: ASSET as Address,
+      collateralAssetDecimals: 18,
+      collateralAssets: '852576641882433905',
+      collateralAssetsUsd: 0.8525394439635485,
+      bonusUsd: 0.12800961496434857,
+      unitOfAccountValuation: null,
+      valuation: { status: 'available' as const },
+      blockNumber: '25562800',
+      txHash: `0x${'ab'.repeat(32)}` as `0x${string}`,
+      timestamp: '2026-07-18T23:13:35.000Z',
+    }
+
+    expect(getActivityLiquidationDisplayDetails(record, address =>
+      address === ASSET
+        ? { address: ASSET as Address, symbol: 'wM', decimals: 18 }
+        : undefined,
+    )).toEqual({
+      repayUsd: '$0.72',
+      collateralAmount: '0.85 wM',
+      collateralUsd: '$0.85',
+      bonus: '+$0.13',
+      bonusTitle: 'Collateral seized minus debt repaid, valued in event-time USD',
+      bonusTone: 'positive',
+    })
+
+    // Symbol lookup misses keep the bare converted quantity.
+    expect(getActivityLiquidationDisplayDetails(record).collateralAmount).toBe('0.85')
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      collateralAssets: '100445960000000000000000',
+    }, address => address === ASSET
+      ? { address: ASSET as Address, symbol: 'wM', decimals: 18 }
+      : undefined).collateralAmount).toBe('100.45K wM')
+
+    // Money values pad cents — "$2.70", never "$2.7".
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      repayAssetsUsd: 2.7,
+    }).repayUsd).toBe('$2.70')
+
+    // Unprofitable liquidations show an explicitly negative, danger-toned bonus.
+    const unprofitable = getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: -0.25,
+    })
+    expect(unprofitable.bonus).toBe('−$0.25')
+    expect(unprofitable.bonusTone).toBe('negative')
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: -0.001,
+    }).bonus).toBe('−<$0.01')
+    const breakeven = getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: 0,
+    })
+    expect(breakeven.bonus).toBe('$0.00')
+    expect(breakeven.bonusTone).toBeUndefined()
+
+    const unitOfAccountValuation = {
+      source: 'historical-protocol-oracle' as const,
+      unitOfAccount: USD_UNIT_OF_ACCOUNT as Address,
+      unitOfAccountDecimals: 18,
+      repayValue: '1000000000000000000',
+      collateralValue: '2140000000000000000',
+      bonusValue: '1140000000000000000',
+      blockNumber: record.blockNumber,
+    }
+    // Event-time USD remains authoritative when both enrichments are present.
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      unitOfAccountValuation,
+    }).bonus).toBe('+$0.13')
+
+    // Without USD, the protocol-oracle quote uses the sentinel denomination.
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: undefined,
+      unitOfAccountValuation,
+    })).toMatchObject({
+      bonus: '+1.14 USD',
+      bonusTone: 'positive',
+      bonusTitle: 'Collateral seized minus debt repaid, quoted by the protocol oracle at the liquidation',
+    })
+
+    // Ordinary unit-of-account tokens resolve through existing token metadata.
+    const negativeFallback = getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: undefined,
+      unitOfAccountValuation: {
+        ...unitOfAccountValuation,
+        unitOfAccount: ASSET as Address,
+        repayValue: '1250000',
+        collateralValue: '1000000',
+        bonusValue: '-250000',
+        unitOfAccountDecimals: 6,
+      },
+    }, address => address === ASSET
+      ? { address: ASSET as Address, symbol: 'USDC', decimals: 6 }
+      : undefined)
+    expect(negativeFallback).toMatchObject({
+      bonus: '−0.25 USDC',
+      bonusTone: 'negative',
+    })
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: undefined,
+      unitOfAccountValuation: {
+        ...unitOfAccountValuation,
+        unitOfAccount: ASSET as Address,
+        bonusValue: '100445960000',
+        unitOfAccountDecimals: 6,
+      },
+    }, address => address === ASSET
+      ? { address: ASSET as Address, symbol: 'USDC', decimals: 6 }
+      : undefined).bonus).toBe('+100.45K USDC')
+
+    // An unsafe raw integer is never shown without decimals or a denomination.
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: undefined,
+      unitOfAccountValuation: {
+        ...unitOfAccountValuation,
+        unitOfAccountDecimals: null,
+      },
+    }).bonus).toBeUndefined()
+    expect(getActivityLiquidationDisplayDetails({
+      ...record,
+      bonusUsd: undefined,
+      unitOfAccountValuation: {
+        ...unitOfAccountValuation,
+        unitOfAccount: OTHER_VAULT as Address,
+      },
+    }).bonus).toBeUndefined()
+
+    // Fields the endpoint could not reconstruct stay absent, leaving the
+    // event's own share-quantity display in place.
+    const sparse = getActivityLiquidationDisplayDetails({
+      ...record,
+      debtAsset: undefined,
+      debtAssetDecimals: undefined,
+      repayAssetsUsd: undefined,
+      collateralAsset: undefined,
+      collateralAssetDecimals: undefined,
+      collateralAssets: undefined,
+      collateralAssetsUsd: undefined,
+      bonusUsd: undefined,
+      unitOfAccountValuation: null,
+      valuation: { status: 'unavailable' as const },
+    })
+    expect(sparse).toEqual({})
+  })
+})
diff --git a/tests/utils/vault-hooks.test.ts b/tests/utils/vault-hooks.test.ts
index 3ceb6d4d9..9a54dc6d6 100644
--- a/tests/utils/vault-hooks.test.ts
+++ b/tests/utils/vault-hooks.test.ts
@@ -16,6 +16,7 @@ import {
   OP_LIQUIDATE,
   OP_PULL_DEBT,
   areAllUserOpsHooked,
+  decodeHookedOperationsMask,
   findBlockingDisabledOp,
   formatHookedOpsSummary,
   getHookedOperationMetas,
@@ -182,6 +183,17 @@ describe('getHookedOperationMetas', () => {
   })
 })
 
+describe('decodeHookedOperationsMask', () => {
+  it('decodes protocol operation bits and preserves unknown flags', () => {
+    const decoded = decodeHookedOperationsMask((1n << 0n) | (1n << 6n) | (1n << 15n))
+
+    expect(decoded.hookedOperations.deposit).toBe(true)
+    expect(decoded.hookedOperations.borrow).toBe(true)
+    expect(decoded.hookedOperations.repay).toBe(false)
+    expect(decoded.unknownMask).toBe(1n << 15n)
+  })
+})
+
 describe('hasAnyHookedOperation', () => {
   it('detects user and internal operation flags by default', () => {
     expect(hasAnyHookedOperation(hookedOperations(OP_DEPOSIT))).toBe(true)
diff --git a/utils/activity-display.ts b/utils/activity-display.ts
new file mode 100644
index 000000000..dcfc9eb87
--- /dev/null
+++ b/utils/activity-display.ts
@@ -0,0 +1,1183 @@
+import type {
+  ActivityAssetAmount,
+  ActivityAssetKind,
+  ActivityCategory,
+  ActivityChangeValue,
+  ActivityCoverageStatus,
+  ActivityEvent,
+  ActivityValuation,
+  ActivityVaultType,
+  LiquidationRecord,
+} from '@eulerxyz/euler-v2-sdk'
+import { formatUnits, isAddress, maxUint256, zeroAddress, type Address } from 'viem'
+import { compactNumber, formatCompactUsdValue, formatSmartAmount, shortenAddress } from '~/utils/string-utils'
+import { CFG_DONT_SOCIALIZE_DEBT } from '~/entities/constants'
+import { decodeHookedOperationsMask, getHookedOperationMetas } from '~/utils/vault-hooks'
+import { getSpecialAddressLabel } from '~/utils/special-addresses'
+
+interface ActivityTokenMetadata {
+  address: Address
+  name?: string
+  symbol: string
+  decimals: number
+}
+
+interface ActivityVaultMetadata {
+  asset?: ActivityTokenMetadata
+  shares?: ActivityTokenMetadata
+  vaultType?: ActivityVaultType
+}
+
+interface ActivityAssetContext {
+  category: ActivityCategory
+  vault?: Address
+}
+
+type ActivityVaultMetadataLookup = (address: Address) => ActivityVaultMetadata | undefined
+type ActivityTokenMetadataLookup = (address: Address) => ActivityTokenMetadata | undefined
+type ActivityAddressLabelLookup = (address: Address) => string | undefined
+
+export interface ActivityVaultDisplay {
+  address: Address
+  addressLabel: string
+  name?: string
+}
+
+/**
+ * Resolves position-history market context from Euler Labels and the vault
+ * registry. The address remains visible so markets with the same name are
+ * still distinguishable.
+ */
+export const resolveActivityVaultDisplay = (
+  vaultAddress: Address | undefined,
+  getVaultMetadata: ActivityVaultMetadataLookup,
+  productName?: string,
+): ActivityVaultDisplay | null => {
+  if (!vaultAddress) return null
+
+  const name = productName?.trim()
+    || getVaultMetadata(vaultAddress)?.shares?.name?.trim()
+    || undefined
+  const addressLabel = shortenAddress(vaultAddress)
+  return {
+    address: vaultAddress,
+    addressLabel,
+    ...(name ? { name } : {}),
+  }
+}
+
+const CATEGORY_LABELS: Record<ActivityCategory, string> = {
+  lending: 'Lending',
+  borrowing: 'Borrowing',
+  swaps: 'Swaps',
+  liquidations: 'Liquidations',
+  account: 'Position',
+  rewards: 'Rewards',
+  governance: 'Governance',
+}
+
+const UINT136_MAX = 2n ** 136n - 1n
+
+const ACCOUNT_ACTIVITY_EVENT_TYPES = [
+  'deposit',
+  'withdraw',
+  'borrow',
+  'repay',
+  'pull_debt',
+  'liquidation',
+] as const satisfies readonly ActivityEvent['type'][]
+
+const VAULT_ACTIVITY_EVENT_TYPES = {
+  evk: [
+    'deposit',
+    'withdraw',
+    'transfer',
+    'borrow',
+    'repay',
+    'debt_socialized',
+    'pull_debt',
+    'liquidation',
+    'approval',
+    'balance_forwarder_status',
+    'convert_fees',
+    'set_caps',
+    'set_ltv',
+    'set_governor_admin',
+    'set_config_flags',
+    'set_fee_receiver',
+    'set_hook_config',
+    'set_interest_fee',
+    'set_interest_rate_model',
+    'set_liquidation_cool_off_time',
+    'set_max_liquidation_discount',
+  ],
+  earn: [
+    'deposit',
+    'withdraw',
+    'transfer',
+    'reallocate_supply',
+    'reallocate_withdraw',
+    'set_name',
+    'set_symbol',
+    'set_fee',
+    'set_fee_recipient',
+    'set_curator',
+    'set_guardian',
+    'set_timelock',
+    'set_cap',
+    'set_is_allocator',
+    'set_supply_queue',
+    'set_withdraw_queue',
+    'submit_cap',
+    'submit_guardian',
+    'submit_timelock',
+    'submit_market_removal',
+    'revoke_pending_cap',
+    'revoke_pending_guardian',
+    'revoke_pending_timelock',
+    'revoke_pending_market_removal',
+    'ownership_transfer_started',
+    'ownership_transferred',
+    'public_reallocate_to',
+    'public_withdrawal',
+    'set_admin',
+    'set_allocation_fee',
+    'set_flow_caps',
+    'transfer_allocation_fee',
+  ],
+  securitize: [
+    'deposit',
+    'withdraw',
+    'transfer',
+    'approval',
+    'seized',
+    'frozen',
+    'unfrozen',
+    'paused',
+    'unpaused',
+    'set_controller_perspective',
+    'set_governor_admin',
+    'set_supply_cap',
+  ],
+} as const satisfies Record<ActivityVaultType, readonly ActivityEvent['type'][]>
+
+type ActivityDisplayScope
+  = | { kind: 'account' }
+    | { kind: 'vault', vaultType: ActivityVaultType }
+
+export const getDisplayActivityEventTypes = (
+  scope: ActivityDisplayScope,
+): readonly ActivityEvent['type'][] =>
+  scope.kind === 'account'
+    ? ACCOUNT_ACTIVITY_EVENT_TYPES
+    : VAULT_ACTIVITY_EVENT_TYPES[scope.vaultType]
+
+export const filterActivityEventsForDisplay = (
+  events: readonly ActivityEvent[],
+  eventTypes: readonly ActivityEvent['type'][],
+  { hideZeroLiquidations = false }: { hideZeroLiquidations?: boolean } = {},
+): ActivityEvent[] => {
+  const displayEventTypes = new Set<string>(eventTypes)
+  const hasMeaningfulLiquidationAmount = (event: ActivityEvent) => {
+    if (event.type !== 'liquidation') return true
+
+    const relevantAssets = event.assets?.filter(asset =>
+      asset.kind === 'assets' || asset.kind === 'collateral',
+    ) ?? []
+    if (relevantAssets.length === 0) return true
+
+    return relevantAssets.some((asset) => {
+      try {
+        return BigInt(asset.amountRaw) !== 0n
+      }
+      catch {
+        // Keep malformed/unknown values visible rather than silently losing
+        // potentially meaningful history.
+        return true
+      }
+    })
+  }
+  const visibleEvents = events.filter(event =>
+    displayEventTypes.has(event.type)
+    && (!hideZeroLiquidations || hasMeaningfulLiquidationAmount(event)),
+  )
+  const pairedTypes = new Set<ActivityEvent['type']>([
+    'deposit',
+    'withdraw',
+    'liquidation',
+    'reallocate_supply',
+    'reallocate_withdraw',
+    'public_reallocate_to',
+    'public_withdrawal',
+  ])
+
+  const sameTransaction = (left: ActivityEvent, right: ActivityEvent) =>
+    left.chainId === right.chainId
+    && left.txHash.toLowerCase() === right.txHash.toLowerCase()
+
+  const sameAddress = (left: string | undefined, right: string | undefined) =>
+    left !== undefined
+    && right !== undefined
+    && left.toLowerCase() === right.toLowerCase()
+
+  const getLiquidationViolator = (event: ActivityEvent) => {
+    const payloadViolator = event.payload.violator
+    return typeof payloadViolator === 'string'
+      ? payloadViolator
+      : event.counterparty
+  }
+
+  const hasMatchingAssetAmount = (left: ActivityEvent, right: ActivityEvent) => {
+    const leftAssets = left.assets?.filter(asset => asset.kind === 'assets') ?? []
+    const rightAssets = right.assets?.filter(asset => asset.kind === 'assets') ?? []
+    return leftAssets.some((leftAsset) => {
+      const leftAddress = leftAsset.address ?? left.vault
+      if (!leftAddress || leftAsset.amountRaw === undefined) return false
+      return rightAssets.some((rightAsset) => {
+        const rightAddress = rightAsset.address ?? right.vault
+        return rightAddress !== undefined
+          && rightAsset.amountRaw !== undefined
+          && leftAddress.toLowerCase() === rightAddress.toLowerCase()
+          && leftAsset.amountRaw === rightAsset.amountRaw
+      })
+    })
+  }
+
+  return visibleEvents.filter((event) => {
+    if (event.type === 'repay') {
+      return !events.some(candidate =>
+        candidate.type === 'liquidation'
+        && sameTransaction(event, candidate)
+        && sameAddress(event.account, getLiquidationViolator(candidate))
+        && hasMatchingAssetAmount(event, candidate),
+      )
+    }
+
+    if (event.type !== 'transfer') return true
+
+    const shareMovements = event.assets?.filter(asset => asset.kind === 'shares') ?? []
+    if (shareMovements.length === 0) return true
+
+    return !events.some((candidate) => {
+      if (
+        candidate.id === event.id
+        || !sameTransaction(event, candidate)
+        || !pairedTypes.has(candidate.type)
+      ) return false
+
+      return shareMovements.some((transferAsset) => {
+        const transferAddress = transferAsset.address ?? event.vault
+        if (!transferAddress) return false
+        return candidate.assets?.some((candidateAsset) => {
+          const candidateAddress = candidateAsset.address ?? candidate.vault
+          return candidateAddress !== undefined
+            && candidateAddress.toLowerCase() === transferAddress.toLowerCase()
+            && candidateAsset.amountRaw === transferAsset.amountRaw
+        }) ?? false
+      })
+    })
+  })
+}
+
+export interface ActivityTransactionGroup {
+  id: string
+  chainId: number
+  txHash: string
+  timestamp: string
+  events: ActivityEvent[]
+}
+
+export const getActivityTransactionGroupLabel = (
+  group: Pick<ActivityTransactionGroup, 'events'>,
+) => group.events.some(event => event.type === 'liquidation')
+  ? 'Liquidation transaction'
+  : 'Transaction'
+
+export const groupActivityEventsByTransaction = (
+  events: readonly ActivityEvent[],
+): ActivityTransactionGroup[] => {
+  const groups = new Map<string, ActivityTransactionGroup>()
+
+  for (const event of events) {
+    const id = `${event.chainId}:${event.txHash.toLowerCase()}`
+    const existing = groups.get(id)
+    if (existing) existing.events.push(event)
+    else {
+      groups.set(id, {
+        id,
+        chainId: event.chainId,
+        txHash: event.txHash,
+        timestamp: event.timestamp,
+        events: [event],
+      })
+    }
+  }
+
+  return [...groups.values()]
+}
+
+export interface ActivityFilterOption {
+  value: string
+  label: string
+  categories: readonly ActivityCategory[]
+  /** Optional event count rendered after the label, e.g. "Liquidations (2)". */
+  count?: number | string
+}
+
+export const resolveActivityFilterCategories = (
+  options: readonly ActivityFilterOption[],
+  selectedFilters: readonly string[],
+): ActivityCategory[] => {
+  const selected = new Set(selectedFilters)
+  const activeOptions = selected.size === 0
+    ? options
+    : options.filter(option => selected.has(option.value))
+  return [...new Set(activeOptions.flatMap(option => option.categories))].sort()
+}
+
+export const isActivityScopeUnsupported = (
+  coverageStatus: ActivityCoverageStatus | undefined,
+  selectedFilters: readonly string[],
+): boolean => coverageStatus === 'unsupported' && selectedFilters.length === 0
+
+const CATEGORY_ICONS: Record<ActivityCategory, string> = {
+  lending: 'lend-outline',
+  borrowing: 'borrow-outline',
+  swaps: 'swap-horizontal',
+  liquidations: 'warning',
+  account: 'wallet',
+  rewards: 'sparks',
+  governance: 'governed',
+}
+
+export const getActivityCategoryLabel = (category: ActivityCategory): string =>
+  CATEGORY_LABELS[category]
+
+export const getActivityCategoryIcon = (category: ActivityCategory): string =>
+  CATEGORY_ICONS[category]
+
+export const getVaultActivityFilterOptions = (
+  vaultType: ActivityVaultType,
+): ActivityFilterOption[] => {
+  const lendingCategories: ActivityCategory[] = vaultType === 'evk'
+    ? ['lending', 'borrowing']
+    : ['lending']
+  const options: ActivityFilterOption[] = [
+    {
+      value: vaultType === 'evk' ? 'lending-borrowing' : 'lending',
+      label: vaultType === 'evk' ? 'Lending and borrowing' : 'Lending',
+      categories: lendingCategories,
+    },
+    { value: 'governance', label: 'Governance', categories: ['governance'] },
+  ]
+  if (vaultType === 'evk') {
+    options.push({ value: 'liquidations', label: 'Liquidations', categories: ['liquidations'] })
+  }
+  return options
+}
+
+export const getDefaultVaultActivityFilter = (
+  vaultType: ActivityVaultType,
+): string => vaultType === 'evk' ? 'lending-borrowing' : 'lending'
+
+// The `account` category (controller/collateral/operator status, ToS
+// signatures, …) is deliberately absent: none of its event types are
+// displayed on Lite, so querying it would only surface empty results.
+const ACCOUNT_ACTIVITY_CATEGORIES = [
+  'lending',
+  'borrowing',
+  'liquidations',
+] as const satisfies readonly ActivityCategory[]
+
+/** Categories the unfiltered portfolio feed queries. */
+export const getAccountActivityCategories = (): readonly ActivityCategory[] =>
+  ACCOUNT_ACTIVITY_CATEGORIES
+
+/**
+ * The portfolio chip row exposes only liquidations: event verbs and
+ * transaction grouping already communicate lending/borrowing, while "was I
+ * ever liquidated?" deserves a one-click answer.
+ */
+export const getAccountActivityFilterOptions = (): ActivityFilterOption[] => [
+  {
+    value: 'liquidations',
+    label: getActivityCategoryLabel('liquidations'),
+    categories: ['liquidations'],
+  },
+]
+
+const applyActivityAcronyms = (label: string): string => label
+  .replace(/\bltv\b/gi, 'LTV')
+  .replace(/\birm\b/gi, 'IRM')
+  .replace(/\busd\b/gi, 'USD')
+
+export const titleizeActivityType = (type: string): string => {
+  const words = type
+    .replace(/[_-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .trim()
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : 'Activity'
+}
+
+type ActivityEventLabelSource = {
+  label?: string
+  type: string
+  account?: Address
+  payload?: Record<string, unknown>
+}
+
+export type ActivityTransferDirection = 'received' | 'sent' | 'unknown'
+
+export const getActivityTransferDirection = (
+  event: Pick<ActivityEventLabelSource, 'account' | 'payload' | 'type'>,
+): ActivityTransferDirection => {
+  if (event.type !== 'transfer' || !event.account) return 'unknown'
+  const account = event.account.toLowerCase()
+  const from = typeof event.payload?.from === 'string' ? event.payload.from.toLowerCase() : undefined
+  const to = typeof event.payload?.to === 'string' ? event.payload.to.toLowerCase() : undefined
+  if (from === account && to !== account) return 'sent'
+  if (to === account && from !== account) return 'received'
+  return 'unknown'
+}
+
+export const formatActivityEventLabel = (
+  event: ActivityEventLabelSource,
+): string => {
+  const sourceLabel = event.label?.trim()
+  if (sourceLabel) return sourceLabel
+  if (event.type === 'transfer') {
+    const direction = getActivityTransferDirection(event)
+    if (direction === 'sent') return 'Vault shares sent'
+    if (direction === 'received') return 'Vault shares received'
+    return 'Vault shares transferred'
+  }
+  return applyActivityAcronyms(titleizeActivityType(event.type))
+}
+
+export interface ActivityEventIcon {
+  name: string
+}
+
+const OUTFLOW_EVENT_TYPES: readonly string[] = ['withdraw', 'borrow', 'reallocate_withdraw', 'public_withdrawal']
+const INFLOW_EVENT_TYPES: readonly string[] = ['deposit', 'repay', 'reallocate_supply', 'public_reallocate_to']
+
+export type ActivityAmountDirection = 'in' | 'out'
+
+/**
+ * Direction of the asset flow relative to the vault: `in` for events that add
+ * assets (deposit, repay), `out` for events that remove them (withdraw,
+ * borrow). Undefined when the event has no clear single direction.
+ */
+export const getActivityAmountDirection = (
+  event: Pick<ActivityEventLabelSource, 'account' | 'payload' | 'type'>,
+): ActivityAmountDirection | undefined => {
+  if (event.type === 'transfer') {
+    const direction = getActivityTransferDirection(event)
+    if (direction === 'sent') return 'out'
+    if (direction === 'received') return 'in'
+    return undefined
+  }
+  if (OUTFLOW_EVENT_TYPES.includes(event.type)) return 'out'
+  if (INFLOW_EVENT_TYPES.includes(event.type)) return 'in'
+  return undefined
+}
+
+export const getActivityEventIcon = (
+  event: Pick<ActivityEventLabelSource, 'account' | 'payload' | 'type'> & { category: ActivityCategory },
+): ActivityEventIcon => {
+  const direction = getActivityAmountDirection(event)
+  if (direction === 'out') return { name: 'borrow-outline' }
+  if (direction === 'in') return { name: 'lend-outline' }
+  if (event.type === 'transfer') return { name: 'swap-horizontal' }
+  return { name: getActivityCategoryIcon(event.category) }
+}
+
+export const formatActivityTimestamp = (timestamp: string): string => {
+  const date = new Date(timestamp)
+  if (!Number.isFinite(date.getTime())) return '-'
+  return new Intl.DateTimeFormat('en-GB', {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    timeZoneName: 'short',
+  }).format(date)
+}
+
+/**
+ * Compact relative feed timestamp, used consistently across the vault and
+ * portfolio feeds. The full absolute timestamp stays available via
+ * `formatActivityTimestamp` (rendered as the hover title). Future timestamps
+ * (clock skew) fall back to the absolute date.
+ */
+export const formatActivityRelativeTimestamp = (
+  timestamp: string,
+  nowMs: number = Date.now(),
+): string => {
+  const date = new Date(timestamp)
+  if (!Number.isFinite(date.getTime())) return '-'
+  const elapsedMs = nowMs - date.getTime()
+  if (elapsedMs < 0) {
+    return new Intl.DateTimeFormat('en-GB', {
+      day: 'numeric',
+      month: 'short',
+      year: 'numeric',
+    }).format(date)
+  }
+  const minutes = Math.floor(elapsedMs / 60_000)
+  if (minutes < 1) return 'Just now'
+  if (minutes < 60) return `${minutes} min ago`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours} h ago`
+  const days = Math.floor(hours / 24)
+  if (days < 7) return `${days} d ago`
+  const weeks = Math.floor(days / 7)
+  if (weeks < 5) return `${weeks} w ago`
+  const months = Math.floor(days / 30)
+  if (months < 12) return `${months} mo ago`
+  return `${Math.max(1, Math.floor(days / 365))} y ago`
+}
+
+const resolveAssetAmount = (asset: ActivityAssetAmount): string | undefined => {
+  if (asset.amount !== undefined && asset.amount.trim()) return asset.amount
+  if (asset.amountRaw === undefined || asset.decimals === undefined) return undefined
+  try {
+    return formatUnits(BigInt(asset.amountRaw), asset.decimals)
+  }
+  catch {
+    return undefined
+  }
+}
+
+const formatActivityCompactAmount = (value: string): string => {
+  const numericValue = Number(value)
+  return Math.abs(numericValue) >= 1e15
+    ? Intl.NumberFormat('en-US', {
+        notation: 'scientific',
+        maximumFractionDigits: 2,
+      }).format(numericValue)
+    : compactNumber(value)
+}
+
+export const formatActivityAssetAmount = (
+  asset: ActivityAssetAmount,
+  eventType?: ActivityEvent['type'],
+): string => {
+  if (eventType === 'approval') {
+    try {
+      const allowance = BigInt(asset.amountRaw)
+      if (allowance === maxUint256) return 'Unlimited'
+      if (allowance === 0n) return 'Revoked'
+    }
+    catch {
+      return 'Amount unavailable'
+    }
+  }
+  const amount = resolveAssetAmount(asset)
+  if (amount === undefined) return 'Amount unavailable'
+  const formatted = formatActivityCompactAmount(amount)
+  return asset.symbol ? `${formatted} ${asset.symbol}` : formatted
+}
+
+/**
+ * Routine activity displays underlying asset units and omits share movements.
+ * Liquidations also expose the collateral quantity — shown as shares until the
+ * historical underlying conversion arrives from `/v3/liquidations`.
+ */
+export const getActivityAssetsForDisplay = (
+  event: Pick<ActivityEvent, 'assets' | 'category'>,
+): ActivityAssetAmount[] => (event.assets ?? []).filter(asset =>
+  asset.kind === 'assets'
+  || (event.category === 'liquidations' && asset.kind === 'collateral'),
+)
+
+/**
+ * Fills display-only token metadata from Lite's existing vault registry.
+ * Fields supplied by the activity source always win, and historical USD value
+ * remains source-owned.
+ */
+export const enrichActivityAssetForDisplay = (
+  asset: ActivityAssetAmount,
+  event: ActivityAssetContext,
+  getVaultMetadata: ActivityVaultMetadataLookup,
+  getTokenMetadata?: ActivityTokenMetadataLookup,
+): ActivityAssetAmount => {
+  let token: ActivityTokenMetadata | undefined
+
+  if (asset.kind === 'assets' && event.vault) {
+    token = getVaultMetadata(event.vault)?.asset
+  }
+  else if (asset.kind === 'shares') {
+    const shareVault = asset.address ?? event.vault
+    if (shareVault) token = getVaultMetadata(shareVault)?.shares
+  }
+  else if (
+    event.category === 'liquidations'
+    && (asset.kind === 'collateral' || asset.kind === 'yield')
+    && asset.address
+  ) {
+    token = getVaultMetadata(asset.address)?.shares
+  }
+
+  if (!token && asset.address && getTokenMetadata) {
+    token = getTokenMetadata(asset.address)
+  }
+
+  if (!token) return asset
+  return {
+    ...asset,
+    address: asset.address ?? token.address,
+    symbol: asset.symbol ?? token.symbol,
+    decimals: asset.decimals ?? token.decimals,
+  }
+}
+
+/**
+ * Money-style USD for activity details: cents pad to two decimals below
+ * $1000 ("$2.70", never "$2.7"), compact notation and the `<$0.01` forms
+ * apply above and below those bounds.
+ */
+export const formatActivityUsd = (value: string | number): string => {
+  const numeric = Number(value)
+  const abs = Math.abs(numeric)
+  if (!Number.isFinite(numeric) || abs >= 1000 || (abs > 0 && abs < 0.01)) {
+    return formatCompactUsdValue(value)
+  }
+  return numeric < 0 ? `-$${abs.toFixed(2)}` : `$${abs.toFixed(2)}`
+}
+
+export const formatActivityAssetUsd = (asset: ActivityAssetAmount): string | null =>
+  asset.amountUsd === undefined
+    ? null
+    : formatActivityUsd(asset.amountUsd)
+
+export interface ActivityLiquidationDisplayDetails {
+  /** Event-time USD value of the repaid debt. */
+  repayUsd?: string
+  /** Seized collateral converted to underlying units, with symbol when known. */
+  collateralAmount?: string
+  collateralUsd?: string
+  /** Signed event-time bonus, preferring USD and otherwise using the protocol unit of account. */
+  bonus?: string
+  bonusTitle?: string
+  /** Rendering tone for the signed bonus. Absent for a zero bonus. */
+  bonusTone?: 'positive' | 'negative'
+}
+
+const formatActivitySignedUnitValue = (
+  rawValue: string,
+  decimals: number,
+  denomination: string,
+): Pick<ActivityLiquidationDisplayDetails, 'bonus' | 'bonusTone'> | null => {
+  try {
+    const value = BigInt(rawValue)
+    const amount = formatActivityCompactAmount(
+      formatUnits(value < 0n ? -value : value, decimals),
+    )
+    return {
+      bonus: `${value > 0n ? '+' : value < 0n ? '−' : ''}${amount} ${denomination}`,
+      ...(value > 0n
+        ? { bonusTone: 'positive' as const }
+        : value < 0n
+          ? { bonusTone: 'negative' as const }
+          : {}),
+    }
+  }
+  catch {
+    return null
+  }
+}
+
+/**
+ * Formats a `/v3/liquidations` record for display on the matching liquidation
+ * event row. Every field is optional: the endpoint omits historical values it
+ * cannot reconstruct, and missing pieces leave the event's own display as-is.
+ */
+export const getActivityLiquidationDisplayDetails = (
+  record: LiquidationRecord,
+  getTokenMetadata?: ActivityTokenMetadataLookup,
+  getAddressLabel?: ActivityAddressLabelLookup,
+): ActivityLiquidationDisplayDetails => {
+  const details: ActivityLiquidationDisplayDetails = {}
+  if (record.repayAssetsUsd !== undefined) {
+    details.repayUsd = formatActivityUsd(record.repayAssetsUsd)
+  }
+  if (
+    record.collateralAssets !== undefined
+    && record.collateralAssetDecimals !== undefined
+  ) {
+    try {
+      const amount = formatActivityCompactAmount(
+        formatUnits(BigInt(record.collateralAssets), record.collateralAssetDecimals),
+      )
+      const symbol = record.collateralAsset
+        ? getTokenMetadata?.(record.collateralAsset)?.symbol
+        : undefined
+      details.collateralAmount = symbol ? `${amount} ${symbol}` : amount
+    }
+    catch {
+      // Malformed conversion — keep the event's share-quantity display.
+    }
+  }
+  if (record.collateralAssetsUsd !== undefined) {
+    details.collateralUsd = formatActivityUsd(record.collateralAssetsUsd)
+  }
+  if (record.bonusUsd !== undefined) {
+    // The bonus is the row's P&L figure — signed and toned like one.
+    if (record.bonusUsd < 0) {
+      details.bonus = `−${formatActivityUsd(Math.abs(record.bonusUsd))}`
+      details.bonusTone = 'negative'
+    }
+    else if (record.bonusUsd > 0) {
+      details.bonus = `+${formatActivityUsd(record.bonusUsd)}`
+      details.bonusTone = 'positive'
+    }
+    else {
+      details.bonus = formatActivityUsd(0)
+    }
+    details.bonusTitle = 'Collateral seized minus debt repaid, valued in event-time USD'
+  }
+  else if (
+    record.unitOfAccountValuation
+    && record.unitOfAccountValuation.unitOfAccountDecimals !== null
+  ) {
+    const valuation = record.unitOfAccountValuation
+    const denomination = getSpecialAddressLabel(valuation.unitOfAccount)
+      ?? getTokenMetadata?.(valuation.unitOfAccount)?.symbol
+      ?? getAddressLabel?.(valuation.unitOfAccount)
+    if (denomination) {
+      const fallback = formatActivitySignedUnitValue(
+        valuation.bonusValue,
+        valuation.unitOfAccountDecimals,
+        denomination,
+      )
+      if (fallback) {
+        Object.assign(details, fallback)
+        details.bonusTitle = 'Collateral seized minus debt repaid, quoted by the protocol oracle at the liquidation'
+      }
+    }
+  }
+  return details
+}
+
+const ASSET_KIND_LABELS: Record<ActivityAssetKind, string> = {
+  assets: 'Assets',
+  shares: 'Shares',
+  value: 'Value',
+  collateral: 'Collateral',
+  yield: 'Yield',
+}
+
+export const getActivityAssetLabel = (
+  kind: ActivityAssetKind,
+  category: ActivityCategory,
+  eventType?: ActivityEvent['type'],
+): string => {
+  if (eventType === 'approval') return 'Allowance'
+  if (category === 'liquidations' && kind === 'assets') return 'Debt repaid'
+  if (category === 'liquidations' && (kind === 'collateral' || kind === 'yield')) {
+    return 'Collateral shares seized'
+  }
+  return ASSET_KIND_LABELS[kind]
+}
+
+export const getActivityAssetAddressLabel = (
+  kind: ActivityAssetKind,
+  category: ActivityCategory,
+): string => {
+  if (category === 'liquidations' && (kind === 'collateral' || kind === 'yield')) {
+    return 'Collateral vault'
+  }
+  return 'Asset'
+}
+
+export const formatActivityChangeValue = (value: ActivityChangeValue): string => {
+  if (value === null) return 'None'
+  if (typeof value === 'boolean') return value ? 'Enabled' : 'Disabled'
+  if (Array.isArray(value)) return value.length ? value.join(', ') : 'None'
+  return String(value)
+}
+
+export type ActivityAddressLinkKind = 'explorer' | 'spy' | 'vault'
+
+export interface ActivityChangeAddress {
+  address: Address
+  label?: string
+  linkKind: Exclude<ActivityAddressLinkKind, 'spy'>
+  vaultType?: ActivityVaultType
+}
+
+export interface ActivityChangeEntry {
+  field: string
+  label: string
+  value?: string
+  addresses?: ActivityChangeAddress[]
+}
+
+type ActivityChangeEventSource = Pick<ActivityEvent, 'change' | 'type' | 'vault' | 'vaultType'>
+
+const VAULT_ADDRESS_FIELDS_BY_EVENT: Partial<Record<ActivityEvent['type'], readonly string[]>> = {
+  liquidation: ['collateral'],
+  public_reallocate_to: ['market', 'strategy', 'to', 'vault'],
+  public_withdrawal: ['market', 'strategy', 'from', 'vault'],
+  reallocate_supply: ['market', 'strategy', 'to', 'vault'],
+  reallocate_withdraw: ['market', 'strategy', 'from', 'vault'],
+  revoke_pending_cap: ['market', 'strategy', 'vault'],
+  revoke_pending_market_removal: ['market', 'strategy', 'vault'],
+  set_cap: ['market', 'strategy', 'vault'],
+  set_flow_caps: ['market', 'strategy', 'from', 'to', 'vault'],
+  set_ltv: ['collateral'],
+  set_supply_queue: ['queue', 'supply_queue', 'new_supply_queue'],
+  set_withdraw_queue: ['queue', 'withdraw_queue', 'new_withdraw_queue'],
+  submit_cap: ['market', 'strategy', 'vault'],
+  submit_market_removal: ['market', 'strategy', 'vault'],
+}
+
+const parseActivityInteger = (value: ActivityChangeValue): bigint | null => {
+  if (typeof value !== 'string' && typeof value !== 'number') return null
+  try {
+    return BigInt(value)
+  }
+  catch {
+    return null
+  }
+}
+
+/** Decodes the EVK AmountCap uint16 encoding into underlying token units. */
+export const decodeEvkAmountCap = (value: ActivityChangeValue): bigint | null => {
+  const raw = parseActivityInteger(value)
+  if (raw === null || raw < 0n || raw > 65_535n) return null
+  if (raw === 0n) return 0n
+  const exponent = raw & 0x3fn
+  const mantissa = raw >> 6n
+  return (mantissa * 10n ** exponent) / 100n
+}
+
+const formatActivityCap = (
+  value: ActivityChangeValue,
+  vault: Address | undefined,
+  getVaultMetadata: ActivityVaultMetadataLookup | undefined,
+): string | null => {
+  const decoded = decodeEvkAmountCap(value)
+  const asset = vault && getVaultMetadata?.(vault)?.asset
+  if (decoded === null || !asset) return null
+  return formatActivityTokenAmount(decoded.toString(), asset, true)
+}
+
+const formatActivityTokenAmount = (
+  value: ActivityChangeValue,
+  token: ActivityTokenMetadata | undefined,
+  compact = false,
+): string | null => {
+  const amount = parseActivityInteger(value)
+  if (amount === null || !token) return null
+  const formattedAmount = formatUnits(amount, token.decimals)
+  const displayAmount = compact
+    ? formatActivityCompactAmount(formattedAmount)
+    : formatSmartAmount(formattedAmount)
+  return `${displayAmount} ${token.symbol}`
+}
+
+const formatActivityBps = (value: ActivityChangeValue): string | null => {
+  const bps = parseActivityInteger(value)
+  if (bps === null) return null
+  const whole = bps / 100n
+  const fraction = (bps % 100n).toString().padStart(2, '0').replace(/0+$/, '')
+  return `${whole}${fraction ? `.${fraction}` : ''}%`
+}
+
+const formatActivityDuration = (value: ActivityChangeValue): string | null => {
+  const seconds = parseActivityInteger(value)
+  if (seconds === null || seconds < 0n) return null
+  if (seconds === 0n) return 'Immediately'
+  const units = [
+    { label: 'day', seconds: 86_400n },
+    { label: 'hour', seconds: 3_600n },
+    { label: 'minute', seconds: 60n },
+    { label: 'second', seconds: 1n },
+  ]
+  let remaining = seconds
+  const parts: string[] = []
+  for (const unit of units) {
+    const count = remaining / unit.seconds
+    if (count === 0n) continue
+    parts.push(`${count} ${unit.label}${count === 1n ? '' : 's'}`)
+    remaining %= unit.seconds
+    if (parts.length === 2) break
+  }
+  return parts.join(' ')
+}
+
+const formatActivityUnixTimestamp = (value: ActivityChangeValue): string | null => {
+  const seconds = parseActivityInteger(value)
+  if (seconds === null || seconds < 0n || seconds > BigInt(Number.MAX_SAFE_INTEGER)) return null
+  const date = new Date(Number(seconds) * 1_000)
+  if (!Number.isFinite(date.getTime())) return null
+  return formatActivityTimestamp(date.toISOString())
+}
+
+const formatActivityChangeLabel = (field: string): string =>
+  applyActivityAcronyms(titleizeActivityType(field))
+
+/** Decodes the EVK configFlags bitmask — CFG_DONT_SOCIALIZE_DEBT is the only
+ *  publicly-defined bit today. Unknown bit combinations fall back to raw. */
+const formatActivityConfigFlags = (value: ActivityChangeValue): string | null => {
+  const mask = parseActivityInteger(value)
+  if (mask === 0n) return 'Debt socialization enabled'
+  if (mask === CFG_DONT_SOCIALIZE_DEBT) return 'Debt socialization disabled'
+  return null
+}
+
+const formatActivityHookedOperations = (value: ActivityChangeValue): string | null => {
+  const mask = parseActivityInteger(value)
+  if (mask === null || mask < 0n) return null
+  if (mask === 0n) return 'None'
+
+  const { hookedOperations, unknownMask } = decodeHookedOperationsMask(mask)
+  const names = getHookedOperationMetas(hookedOperations, { includeInternal: true })
+    .map(operation => operation.name)
+  if (unknownMask !== 0n) names.push(`Unknown flags (${unknownMask})`)
+  return names.join(', ')
+}
+
+const isZeroAddressValue = (value: ActivityChangeValue): boolean => {
+  const values = Array.isArray(value) ? value : [value]
+  return values.length > 0 && values.every(item =>
+    typeof item === 'string' && item.toLowerCase() === zeroAddress,
+  )
+}
+
+/** Display order for change fields whose upstream order is unhelpful. */
+const CHANGE_FIELD_PRIORITY: Partial<Record<ActivityEvent['type'], readonly string[]>> = {
+  set_ltv: [
+    'collateral',
+    'borrow_ltv',
+    'liquidation_ltv',
+    'ramp_duration',
+    'initial_liquidation_ltv',
+    'target_timestamp',
+  ],
+}
+
+const REALLOCATION_EVENT_TYPES: readonly ActivityEvent['type'][] = [
+  'reallocate_supply',
+  'reallocate_withdraw',
+  'public_reallocate_to',
+  'public_withdrawal',
+]
+
+const orderedActivityChangeFields = (
+  event: ActivityChangeEventSource,
+): [string, ActivityChangeValue][] => {
+  let fields = Object.entries(event.change?.fields ?? {})
+
+  // An immediate LTV change never ramps — the ramp target fields are noise.
+  if (
+    event.type === 'set_ltv'
+    && parseActivityInteger(event.change?.fields.ramp_duration ?? null) === 0n
+  ) {
+    fields = fields.filter(([field]) =>
+      field !== 'initial_liquidation_ltv' && field !== 'target_timestamp',
+    )
+  }
+
+  // Reallocations report the same movement in underlying assets and in
+  // strategy shares — the share amount is redundant next to the asset amount.
+  if (REALLOCATION_EVENT_TYPES.includes(event.type)) {
+    fields = fields.filter(([field]) => field !== 'shares' && !field.endsWith('_shares'))
+  }
+
+  const priority = CHANGE_FIELD_PRIORITY[event.type]
+  if (!priority) return fields
+  const rank = (field: string) => {
+    const index = priority.indexOf(field)
+    return index === -1 ? priority.length : index
+  }
+  return fields.sort((left, right) => rank(left[0]) - rank(right[0]))
+}
+
+const resolveChangeAddresses = (
+  event: ActivityChangeEventSource,
+  field: string,
+  value: ActivityChangeValue,
+  getVaultMetadata: ActivityVaultMetadataLookup | undefined,
+): ActivityChangeAddress[] | null => {
+  const values = Array.isArray(value) ? value : [value]
+  if (!values.length || !values.every(item => typeof item === 'string' && isAddress(item))) return null
+
+  const isVaultAddress = VAULT_ADDRESS_FIELDS_BY_EVENT[event.type]?.includes(field) ?? false
+  return values.map((item) => {
+    const address = item as Address
+    if (!isVaultAddress) return { address, linkKind: 'explorer' as const }
+    const display = getVaultMetadata
+      ? resolveActivityVaultDisplay(address, getVaultMetadata)
+      : null
+    return {
+      address,
+      linkKind: 'vault' as const,
+      label: display?.name ?? display?.addressLabel,
+      vaultType: getVaultMetadata?.(address)?.vaultType ?? event.vaultType,
+    }
+  })
+}
+
+export const getActivityChangeEntries = (
+  event: ActivityChangeEventSource,
+  getVaultMetadata?: ActivityVaultMetadataLookup,
+): ActivityChangeEntry[] => orderedActivityChangeFields(event).map(([field, value]) => {
+  // The zero address reads better as an explicit "None" than as a linked,
+  // copyable 0x0000…0000 (e.g. a renounced governor or cleared receiver).
+  if (isZeroAddressValue(value)) {
+    return { field, label: formatActivityChangeLabel(field), value: 'None' }
+  }
+  const addresses = resolveChangeAddresses(event, field, value, getVaultMetadata)
+  if (addresses) return { field, label: formatActivityChangeLabel(field), addresses }
+
+  let formatted: string | null = null
+  const vaultMetadata = event.vault ? getVaultMetadata?.(event.vault) : undefined
+  if (event.type === 'set_caps' && (field === 'supply_cap' || field === 'borrow_cap')) {
+    formatted = formatActivityCap(value, event.vault, getVaultMetadata)
+  }
+  else if (
+    (event.type === 'set_cap' || event.type === 'submit_cap')
+    && field === 'cap'
+  ) {
+    const cap = parseActivityInteger(value)
+    formatted = event.vaultType === 'earn' && cap !== null && cap >= UINT136_MAX
+      ? 'Unlimited'
+      : formatActivityTokenAmount(value, vaultMetadata?.asset, true)
+  }
+  else if (
+    event.type === 'set_supply_cap'
+    && (field === 'cap' || field === 'supply_cap' || field === 'new_supply_cap')
+  ) {
+    formatted = formatActivityTokenAmount(value, vaultMetadata?.asset, true)
+  }
+  else if (
+    (event.type === 'reallocate_supply' || event.type === 'reallocate_withdraw')
+    && (field === 'supplied_assets' || field === 'withdrawn_assets')
+  ) {
+    formatted = formatActivityTokenAmount(value, vaultMetadata?.asset, true)
+  }
+  else if (event.type === 'set_ltv' && field.endsWith('_ltv')) {
+    formatted = formatActivityBps(value)
+  }
+  else if (
+    event.type === 'set_config_flags'
+    && (field === 'config_flags' || field === 'new_config_flags')
+  ) {
+    formatted = formatActivityConfigFlags(value)
+  }
+  // EVK ConfigAmounts are scaled over 1e4 — 500 reads as 5%, 350 as 3.5%.
+  else if (
+    event.type === 'set_interest_fee'
+    && ['fee', 'new_fee', 'interest_fee', 'new_interest_fee'].includes(field)
+  ) {
+    formatted = formatActivityBps(value)
+  }
+  else if (
+    event.type === 'set_max_liquidation_discount'
+    && ['discount', 'new_discount', 'max_liquidation_discount', 'new_max_liquidation_discount'].includes(field)
+  ) {
+    formatted = formatActivityBps(value)
+  }
+  else if (
+    event.type === 'set_hook_config'
+    && (field === 'hooked_ops' || field === 'new_hooked_ops')
+  ) {
+    formatted = formatActivityHookedOperations(value)
+  }
+  else if (field === 'target_timestamp') {
+    formatted = formatActivityUnixTimestamp(value)
+  }
+  else if (field === 'ramp_duration' || field.endsWith('_timelock') || field.endsWith('_cool_off_time')) {
+    formatted = formatActivityDuration(value)
+  }
+
+  return {
+    field,
+    label: formatActivityChangeLabel(field),
+    value: formatted ?? formatActivityChangeValue(value),
+  }
+})
+
+interface ActivityParticipantSource {
+  account?: Address
+  actor?: Address
+  category: ActivityCategory
+  counterparty?: Address
+  owner?: Address
+  subAccountIndex?: number
+  type?: ActivityEvent['type']
+}
+
+export interface PortfolioActivityPositionParticipant {
+  index: number
+  label: string
+}
+
+export const getPortfolioActivityPositionParticipant = (
+  event: ActivityParticipantSource,
+): PortfolioActivityPositionParticipant | null => {
+  if (
+    event.category !== 'liquidations'
+    || event.subAccountIndex === undefined
+    || !event.account
+    || !event.counterparty
+    || event.account.toLowerCase() !== event.counterparty.toLowerCase()
+  ) return null
+
+  return {
+    index: event.subAccountIndex,
+    label: `Position ${event.subAccountIndex}`,
+  }
+}
+
+/**
+ * Vault registry lookups worth attempting for an event: the event's vault,
+ * share/collateral asset addresses, and vault-typed change fields. Resolving
+ * these turns raw addresses into named vault links.
+ */
+export const getActivityResolvableVaultAddresses = (
+  event: Pick<ActivityEvent, 'vault' | 'type' | 'assets' | 'change'>,
+): Address[] => {
+  const addresses = new Set<Address>()
+  if (event.vault) addresses.add(event.vault)
+  for (const asset of event.assets ?? []) {
+    if (asset.address && ['collateral', 'shares', 'yield'].includes(asset.kind)) {
+      addresses.add(asset.address)
+    }
+  }
+  for (const field of VAULT_ADDRESS_FIELDS_BY_EVENT[event.type] ?? []) {
+    const value = event.change?.fields[field]
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (typeof item === 'string' && isAddress(item)) addresses.add(item as Address)
+    }
+  }
+  return [...addresses]
+}
+
+export const formatActivityValuation = (
+  valuation: ActivityValuation | undefined,
+): string | null => {
+  if (!valuation) return null
+  if (valuation.status === 'unavailable') return null
+  if (valuation.amountUsd === undefined) {
+    return valuation.status === 'partial' ? 'Partial USD valuation' : null
+  }
+  const amount = formatActivityUsd(valuation.amountUsd)
+  return valuation.status === 'partial' ? `${amount} (partial)` : amount
+}
+
+export const formatActivityValuationForAssets = (
+  valuation: ActivityValuation | undefined,
+  assets: readonly ActivityAssetAmount[],
+): string | null => {
+  if (
+    valuation?.status === 'available'
+    && assets.some(asset => asset.amountUsd !== undefined)
+  ) return null
+  return formatActivityValuation(valuation)
+}
diff --git a/utils/sdk-query-cache.ts b/utils/sdk-query-cache.ts
index a5a42a764..787f4c4dc 100644
--- a/utils/sdk-query-cache.ts
+++ b/utils/sdk-query-cache.ts
@@ -32,6 +32,16 @@ type SdkQueryRecorderWindow = Window & {
 
 const failureCache = new Map<string, { error: unknown, expiresAt: number }>()
 
+type SdkQueryInvalidationListener = (queryNames: ReadonlySet<string>) => void
+const sdkQueryInvalidationListeners = new Set<SdkQueryInvalidationListener>()
+
+export const subscribeToSdkQueryInvalidations = (
+  listener: SdkQueryInvalidationListener,
+) => {
+  sdkQueryInvalidationListeners.add(listener)
+  return () => sdkQueryInvalidationListeners.delete(listener)
+}
+
 const buildSdkQuery = (staleTimes: Partial<Record<EulerSDKQueryName, number>>): BuildQueryFn => {
   return ((queryName: string, fn, _target: object, context) => {
     const wrapped = (async (...args: Parameters<typeof fn>) => {
@@ -140,12 +150,22 @@ export const invalidateSdkQueries = (queryNames: EulerSDKQueryName[]) => {
     const [, queryName] = JSON.parse(key) as [string, string, string]
     if (names.has(queryName)) failureCache.delete(key)
   }
-  return sdkQueryClient.invalidateQueries({
+  const invalidation = sdkQueryClient.invalidateQueries({
     predicate: query =>
       query.queryKey[0] === 'sdk'
       && typeof query.queryKey[1] === 'string'
       && names.has(query.queryKey[1]),
   })
+  for (const listener of sdkQueryInvalidationListeners) {
+    try {
+      listener(names)
+    }
+    catch {
+      // Query invalidation is a global transaction side effect. A display
+      // subscriber must not be able to interrupt the remaining invalidation.
+    }
+  }
+  return invalidation
 }
 
 export const clearSdkQueryFailureCacheForTest = () => {
diff --git a/utils/sdk-query-policy.ts b/utils/sdk-query-policy.ts
index 538e93211..98655ada1 100644
--- a/utils/sdk-query-policy.ts
+++ b/utils/sdk-query-policy.ts
@@ -55,6 +55,8 @@ export interface SdkQueryPolicyEntry {
 const SECOND = 1_000
 const MINUTE = 60 * SECOND
 
+export const ACTIVITY_QUERY_STALE_TIME_MS = MINUTE
+
 export const DEFAULT_STALE_TIME_MS = 5 * MINUTE
 
 export const SDK_QUERY_POLICY: Partial<Record<EulerSDKQueryName, SdkQueryPolicyEntry>> = {
@@ -96,10 +98,6 @@ export const SDK_QUERY_POLICY: Partial<Record<EulerSDKQueryName, SdkQueryPolicyE
   queryV3RewardsApyPage: { staleTimeMs: DEFAULT_STALE_TIME_MS },
   queryVaultInfoERC4626: { staleTimeMs: DEFAULT_STALE_TIME_MS },
 
-  // === Activity feeds ===
-  queryAccountActivityEvents: { staleTimeMs: MINUTE, invalidateAfterTx: true },
-  queryVaultActivityEvents: { staleTimeMs: MINUTE, invalidateAfterTx: true },
-
   // === Plan-critical chain reads ===
   queryAccountVaults: { staleTimeMs: DEFAULT_STALE_TIME_MS, formStaleTimeMs: MINUTE, invalidateAfterTx: true },
   queryEVaultInfoFull: { staleTimeMs: 5 * MINUTE, formStaleTimeMs: MINUTE, invalidateAfterTx: true },
@@ -111,6 +109,13 @@ export const SDK_QUERY_POLICY: Partial<Record<EulerSDKQueryName, SdkQueryPolicyE
   queryVaultAccountInfo: { staleTimeMs: 5 * MINUTE, formStaleTimeMs: MINUTE, invalidateAfterTx: true },
   queryVaultFactories: { staleTimeMs: 5 * MINUTE, invalidateAfterTx: true },
 
+  // === Activity: V3-indexed event history ===
+  queryAccountActivityEvents: { staleTimeMs: ACTIVITY_QUERY_STALE_TIME_MS, invalidateAfterTx: true },
+  queryVaultActivityEvents: { staleTimeMs: ACTIVITY_QUERY_STALE_TIME_MS, invalidateAfterTx: true },
+  // Historical liquidation valuations are immutable once indexed, but new
+  // liquidations append — same freshness window as the feeds they enrich.
+  queryLiquidations: { staleTimeMs: ACTIVITY_QUERY_STALE_TIME_MS, invalidateAfterTx: true },
+
   // === Position migration (SDK 1.1.3) ===
   // Discovery lists are heavier connector reads (GraphQL + balance
   // multicalls). External position balances and authorization state back
diff --git a/utils/vault-hooks.ts b/utils/vault-hooks.ts
index b13322956..890c96298 100644
--- a/utils/vault-hooks.ts
+++ b/utils/vault-hooks.ts
@@ -19,6 +19,27 @@ export const OP_FLASHLOAN = 'flashloan' satisfies VaultOperation
 export const OP_TOUCH = 'touch' satisfies VaultOperation
 export const OP_VAULT_STATUS_CHECK = 'vaultStatusCheck' satisfies VaultOperation
 
+const VAULT_OPERATION_BITS: Record<VaultOperation, bigint> = {
+  deposit: 1n << 0n,
+  mint: 1n << 1n,
+  withdraw: 1n << 2n,
+  redeem: 1n << 3n,
+  transfer: 1n << 4n,
+  skim: 1n << 5n,
+  borrow: 1n << 6n,
+  repay: 1n << 7n,
+  repayWithShares: 1n << 8n,
+  pullDebt: 1n << 9n,
+  convertFees: 1n << 10n,
+  liquidate: 1n << 11n,
+  flashloan: 1n << 12n,
+  touch: 1n << 13n,
+  vaultStatusCheck: 1n << 14n,
+}
+
+const KNOWN_VAULT_OPERATION_MASK = Object.values(VAULT_OPERATION_BITS)
+  .reduce((mask, bit) => mask | bit, 0n)
+
 export interface VaultOpMeta {
   op: VaultOperation
   name: string
@@ -185,6 +206,16 @@ export const getHookedOperationMetas = (
 ): VaultOpMeta[] =>
   VAULT_OPS.filter(meta => hookedOperations[meta.op] && (includeInternal || !meta.internal))
 
+export const decodeHookedOperationsMask = (mask: bigint): {
+  hookedOperations: EVaultHookedOperations
+  unknownMask: bigint
+} => ({
+  hookedOperations: Object.fromEntries(
+    VAULT_OPS.map(meta => [meta.op, (mask & VAULT_OPERATION_BITS[meta.op]) !== 0n]),
+  ) as EVaultHookedOperations,
+  unknownMask: mask & ~KNOWN_VAULT_OPERATION_MASK,
+})
+
 export const hasAnyHookedOperation = (
   hookedOperations: EVaultHookedOperations,
   { includeInternal = true }: { includeInternal?: boolean } = {},