gloomberb 0.18.3 → 0.18.5

package/src/plugins/builtin/crypto-board/defi.ts

@@ -0,0 +1,239 @@
+import type { DefiTvlChain, DefiTvlPayload, DefiTvlProtocol } from "../../../api-client/crypto-markets";
+import type { DataTableColumn } from "../../../components";
+import { getTableWidth } from "../../../components/ui/table-layout";
+import { formatCompact, formatCompactAmount } from "../../../utils/format";
+import { compareSortValues, nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
+import { formatUtcTime } from "../../../utils/utc-time";
+import { formatCryptoPercent } from "./model";
+import { SUPPLY_RANGES, type SupplyRangeId } from "./supply";
+
+const DAY_MS = 86_400_000;
+
+/** What the DeFi tab ranks: protocols (their versions together) or chains. */
+export type DefiList = "protocol" | "chain";
+
+export const DEFI_LISTS: ReadonlyArray<{ value: DefiList; label: string }> = [
+  { value: "protocol", label: "Protocols" },
+  { value: "chain", label: "Chains" },
+];
+
+/** One row of the DeFi table; the fields a list has no figure for are null. */
+export interface DefiRow {
+  id: string;
+  rank: number;
+  name: string;
+  /** A protocol's category; a chain's gas token. */
+  detail: string | null;
+  tvl: number;
+  change1dPercent: number | null;
+  change7d: number | null;
+  change7dPercent: number | null;
+  change30d: number | null;
+  change30dPercent: number | null;
+  /** A chain's percent of the total DeFi TVL; null for a protocol, whose TVL double counts across protocols. */
+  share: number | null;
+  /** How many chains a protocol is on; null for a chain. */
+  chains: number | null;
+}
+
+const protocolRow = (protocol: DefiTvlProtocol, index: number): DefiRow => ({
+  id: `protocol:${protocol.name}`,
+  rank: index + 1,
+  name: protocol.name,
+  detail: protocol.category,
+  tvl: protocol.tvl,
+  change1dPercent: protocol.change1dPercent,
+  change7d: protocol.change7d,
+  change7dPercent: protocol.change7dPercent,
+  change30d: protocol.change30d,
+  change30dPercent: protocol.change30dPercent,
+  share: null,
+  chains: protocol.chains,
+});
+
+const chainRow = (chain: DefiTvlChain, index: number): DefiRow => ({
+  id: `chain:${chain.name}`,
+  rank: index + 1,
+  name: chain.name,
+  detail: chain.tokenSymbol,
+  tvl: chain.tvl,
+  change1dPercent: null,
+  change7d: chain.change7d,
+  change7dPercent: chain.change7dPercent,
+  change30d: chain.change30d,
+  change30dPercent: chain.change30dPercent,
+  share: chain.share,
+  chains: null,
+});
+
+const rowsByPayload = new WeakMap<DefiTvlPayload, Record<DefiList, DefiRow[]>>();
+
+/** The list's rows in the source's order, largest first; the same array for the same payload. */
+export function buildDefiRows(payload: DefiTvlPayload | null | undefined, list: DefiList): DefiRow[] {
+  if (!payload) return [];
+  let rows = rowsByPayload.get(payload);
+  if (!rows) {
+    rows = { protocol: payload.protocols.map(protocolRow), chain: payload.chains.map(chainRow) };
+    rowsByPayload.set(payload, rows);
+  }
+  return rows[list];
+}
+
+/**
+ * When the list's figures are from: a chain's are its daily chart's on the
+ * board's as-of day, a protocol's the source's latest at the read.
+ */
+export function defiListAsOf(payload: DefiTvlPayload | null | undefined, list: DefiList): string | null {
+  if (!payload) return null;
+  if (list === "chain") return payload.asOf;
+  return payload.protocolsAsOf ? formatUtcTime(payload.protocolsAsOf) : payload.asOf;
+}
+
+/** The first day the total's history has a value, the day `All` reaches back to. */
+export function defiHistoryStart(payload: DefiTvlPayload | null | undefined): string | null {
+  const history = payload?.history;
+  if (!history) return null;
+  const first = history.total.findIndex((value) => value != null);
+  return first < 0 ? null : new Date(Date.parse(`${history.start}T00:00:00Z`) + first * DAY_MS).toISOString().slice(0, 10);
+}
+
+/** The total's days in `range`, counted back from its newest, for the chart. */
+export function defiHistory(
+  payload: DefiTvlPayload | null | undefined,
+  range: SupplyRangeId,
+): { dates: Date[]; values: Array<number | null> } | null {
+  const history = payload?.history;
+  if (!history || history.total.length < 2) return null;
+  const last = history.total.findLastIndex((value) => value != null);
+  if (last < 1) return null;
+  const days = SUPPLY_RANGES.find((option) => option.value === range)?.days ?? null;
+  const first = days == null ? 0 : Math.max(0, last - days);
+  const startMs = Date.parse(`${history.start}T00:00:00Z`);
+  return {
+    dates: Array.from({ length: last - first + 1 }, (_, index) => new Date(startMs + (first + index) * DAY_MS)),
+    values: history.total.slice(first, last + 1).map((value) => value ?? null),
+  };
+}
+
+/** The total's daily history as dated rows, oldest first, for an export. */
+export function defiHistoryRows(payload: DefiTvlPayload): Array<{ date: string; tvl: number | null }> {
+  const history = defiHistory(payload, "ALL");
+  if (!history) return [];
+  return history.dates.map((date, index) => ({ date: date.toISOString().slice(0, 10), tvl: history.values[index] ?? null }));
+}
+
+const change = (amount: number | null, percent: number | null) =>
+  amount == null ? "—" : `${formatCompactAmount(amount, { signed: true })} (${formatCryptoPercent(percent)})`;
+
+/**
+ * `Total DeFi TVL 92.39B · 7D +2.01B (+2.23%) · 30D -1.06B (-1.14%) · as of
+ * 2026-10-21 · DefiLlama, daily since 2018-02-12`, as the CLI states it.
+ */
+export function defiSummaryLine(payload: DefiTvlPayload): string | null {
+  const total = payload.total;
+  if (!total) return null;
+  const since = defiHistoryStart(payload);
+  return [
+    `Total DeFi TVL ${formatCompact(total.tvl, { fixedDecimals: true })}`,
+    `7D ${change(total.change7d, total.change7dPercent)}`,
+    `30D ${change(total.change30d, total.change30dPercent)}`,
+    ...(payload.asOf ? [`as of ${payload.asOf}`] : []),
+    `${payload.source.name}${since ? `, daily since ${since}` : ""}`,
+  ].join(" · ");
+}
+
+/** A DeFi TVL failure as one sentence: what failed, named once, when the message does not name it. */
+export function defiFailure(message: string): string {
+  const named = /\bdefi tvl\b/i.test(message) ? message : `DeFi TVL: ${message}`;
+  return /[.!?]$/.test(named) ? named : `${named}.`;
+}
+
+// Sorting ---------------------------------------------------------------------
+
+type DefiColumnId =
+  | "rank"
+  | "name"
+  | "detail"
+  | "tvl"
+  | "change1dPercent"
+  | "change7d"
+  | "change7dPercent"
+  | "change30d"
+  | "change30dPercent"
+  | "share"
+  | "chains";
+
+export type DefiColumn = DataTableColumn & { id: DefiColumnId };
+
+export interface DefiSortPreference {
+  columnId: DefiColumnId | null;
+  direction: SortDirection;
+}
+
+export const DEFAULT_DEFI_SORT: DefiSortPreference = { columnId: null, direction: "asc" };
+
+const TEXT_COLUMNS = new Set<DefiColumnId>(["rank", "name", "detail"]);
+
+/** Numbers open largest-first; names open A-Z. */
+export function nextDefiSort(current: DefiSortPreference, columnId: string): DefiSortPreference {
+  const id = columnId as DefiColumnId;
+  return nextHeaderSort(current, id, { firstDirection: TEXT_COLUMNS.has(id) ? "asc" : "desc", resetTo: DEFAULT_DEFI_SORT });
+}
+
+export function sortDefiRows(rows: DefiRow[], sort: DefiSortPreference): DefiRow[] {
+  const columnId = sort.columnId;
+  if (!columnId) return rows;
+  return [...rows].sort((left, right) => compareSortValues(left[columnId], right[columnId], sort.direction));
+}
+
+// Columns ---------------------------------------------------------------------
+
+type DefiColumnSpec = DefiColumn & { optional?: number };
+
+const PROTOCOL_COLUMNS: DefiColumnSpec[] = [
+  { id: "rank", label: "#", width: 3, align: "right" },
+  { id: "name", label: "PROTOCOL", width: 14, align: "left" },
+  { id: "detail", label: "CATEGORY", width: 14, align: "left", optional: 2 },
+  { id: "tvl", label: "TVL", width: 8, align: "right" },
+  { id: "change1dPercent", label: "1D%", width: 8, align: "right", optional: 5 },
+  { id: "change7d", label: "7D", width: 8, align: "right", optional: 3 },
+  { id: "change7dPercent", label: "7D%", width: 8, align: "right" },
+  { id: "change30d", label: "30D", width: 8, align: "right", optional: 4 },
+  { id: "change30dPercent", label: "30D%", width: 8, align: "right", optional: 1 },
+  { id: "chains", label: "CHAINS", width: 6, align: "right", optional: 6 },
+];
+
+const CHAIN_COLUMNS: DefiColumnSpec[] = [
+  { id: "rank", label: "#", width: 3, align: "right" },
+  { id: "name", label: "CHAIN", width: 14, align: "left" },
+  { id: "detail", label: "TOKEN", width: 6, align: "left", optional: 2 },
+  { id: "tvl", label: "TVL", width: 8, align: "right" },
+  { id: "change7d", label: "7D", width: 8, align: "right", optional: 3 },
+  { id: "change7dPercent", label: "7D%", width: 8, align: "right" },
+  { id: "change30d", label: "30D", width: 8, align: "right", optional: 4 },
+  { id: "change30dPercent", label: "30D%", width: 8, align: "right", optional: 1 },
+  { id: "share", label: "SHARE", width: 7, align: "right" },
+];
+
+const MAX_NAME_WIDTH = 26;
+
+/**
+ * Optional columns leave in a fixed order as the pane narrows, dollar changes
+ * before percents as on the stablecoin list (the chain count and the day's
+ * move, the 30D then 7D dollar change, the category, the 30D percent); the
+ * name takes what width is left.
+ */
+export function buildDefiColumns(width: number, list: DefiList): DefiColumn[] {
+  const specs = list === "chain" ? CHAIN_COLUMNS : PROTOCOL_COLUMNS;
+  const optional = specs.flatMap((column) => column.optional ?? []).sort((a, b) => b - a);
+  const dropped = new Set<number>();
+  const visible = () => specs.filter((column) => !column.optional || !dropped.has(column.optional));
+  for (const priority of optional) {
+    if (getTableWidth(visible()) <= width) break;
+    dropped.add(priority);
+  }
+  const columns = visible();
+  const spare = Math.max(0, width - getTableWidth(columns));
+  return columns.map(({ optional: _optional, ...column }) =>
+    column.id === "name" ? { ...column, width: Math.min(MAX_NAME_WIDTH, column.width + spare) } : column);
+}

package/src/plugins/builtin/crypto-board/headless.ts

@@ -1,9 +1,10 @@
-import type { CryptoAssetKind, StablecoinSupplyPayload } from "../../../api-client/crypto-markets";
+import type { CryptoAssetKind, DefiTvlPayload, StablecoinSupplyPayload } from "../../../api-client/crypto-markets";
 import type { HeadlessExportTable, HeadlessPaneColumn } from "../../../types/headless";
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { formatCompact, formatCompactAmount } from "../../../utils/format";
 import { errorMessage } from "../../../utils/errors";
-import { fetchCryptoMarkets, fetchStablecoinSupply } from "./client";
+import { fetchCryptoMarkets, fetchDefiTvl, fetchStablecoinSupply } from "./client";
+import { buildDefiRows, defiHistoryRows, defiHistoryStart, defiSummaryLine, type DefiList, type DefiRow } from "./defi";
 import {
   buildCryptoRows,
   CRYPTO_BOARD_FRESHNESS,
@@ -102,30 +103,140 @@ function supplyMetadata(payload: StablecoinSupplyPayload) {
   };
 }
 
+const PROTOCOL_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "rank", header: "#", align: "right" },
+  { key: "name", header: "Protocol" },
+  { key: "category", header: "Category", stackPriority: 2, stackRows: 0 },
+  { key: "tvl", header: "TVL", align: "right", format: compact },
+  { key: "change1dPercent", header: "1D %", align: "right", format: percent, stackPriority: 3, stackRows: 0 },
+  { key: "change7d", header: "7D", align: "right", format: signedCompact, stackPriority: 1, stackRows: 0 },
+  { key: "change7dPercent", header: "7D %", align: "right", format: percent },
+  { key: "change30d", header: "30D", align: "right", format: signedCompact, stackPriority: 0.5, stackRows: 0 },
+  { key: "change30dPercent", header: "30D %", align: "right", format: percent },
+  { key: "chains", header: "Chains", align: "right", stackPriority: 4, stackRows: 0 },
+];
+
+const CHAIN_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "rank", header: "#", align: "right" },
+  { key: "name", header: "Chain" },
+  { key: "token", header: "Token", stackPriority: 2, stackRows: 0 },
+  { key: "tvl", header: "TVL", align: "right", format: compact },
+  { key: "change7d", header: "7D", align: "right", format: signedCompact, stackPriority: 1, stackRows: 0 },
+  { key: "change7dPercent", header: "7D %", align: "right", format: percent },
+  { key: "change30d", header: "30D", align: "right", format: signedCompact, stackPriority: 0.5, stackRows: 0 },
+  { key: "change30dPercent", header: "30D %", align: "right", format: percent },
+  { key: "share", header: "Share", align: "right", format: share },
+];
+
+function defiRecord(row: DefiRow, list: DefiList) {
+  return {
+    rank: row.rank,
+    name: row.name,
+    ...(list === "chain" ? { token: row.detail } : { category: row.detail, chains: row.chains, change1dPercent: row.change1dPercent }),
+    tvl: row.tvl,
+    change7d: row.change7d,
+    change7dPercent: row.change7dPercent,
+    change30d: row.change30d,
+    change30dPercent: row.change30dPercent,
+    ...(list === "chain" ? { share: row.share } : {}),
+  };
+}
+
+/** The other list and the total's daily history, for `--csv`: one file carries the whole tab. */
+function defiExportTables(payload: DefiTvlPayload, list: DefiList): HeadlessExportTable[] {
+  const other: DefiList = list === "chain" ? "protocol" : "chain";
+  const otherRows = buildDefiRows(payload, other).map((row) => defiRecord(row, other));
+  const history = defiHistoryRows(payload);
+  return [
+    ...(otherRows.length ? [{ title: other === "chain" ? "DeFi TVL by chain" : "DeFi TVL by protocol", unit: "USD", columns: other === "chain" ? CHAIN_COLUMNS : PROTOCOL_COLUMNS, rows: otherRows }] : []),
+    ...(history.length ? [{
+      title: "Total DeFi TVL",
+      unit: "USD",
+      interval: "1d",
+      columns: [{ key: "date", header: "Date" }, { key: "tvl", header: "TVL", align: "right" as const }],
+      rows: history,
+    }] : []),
+  ];
+}
+
+/**
+ * `--list defi`: the largest protocols (or chains, `--by chain`) by TVL with
+ * their 7D and 30D change, under the total's line. Dated by the total's day,
+ * from a source that publishes it daily.
+ */
+async function loadDefi(list: DefiList, ctx: Parameters<HeadlessPaneDefinition<"rows">["load"]>[1]) {
+  const payload = await fetchDefiTvl(ctx.apiClient);
+  const rows = buildDefiRows(payload, list).map((row) => defiRecord(row, list));
+  const summary = defiSummaryLine(payload);
+  const exportTables = defiExportTables(payload, list);
+  return {
+    rows,
+    columns: list === "chain" ? CHAIN_COLUMNS : PROTOCOL_COLUMNS,
+    ...(exportTables.length ? { exportTables } : {}),
+    errors: payload.warnings,
+    ...(list === "protocol" && payload.protocolsAsOf ? { notes: [`Protocols as of ${isoMinute(payload.protocolsAsOf)}, the source's latest; their versions are counted together.`] } : {}),
+    empty: list === "chain" ? "No chains returned." : "No protocols returned.",
+    freshness: {
+      source: "Gloom Cloud",
+      publisher: payload.source.name,
+      status: "not-a-feed" as const,
+      basis: "daily TVL",
+      asOf: payload.asOf,
+      maxAgeMinutes: 36 * 60,
+    },
+    metadata: {
+      list: "defi",
+      by: list,
+      status: payload.status,
+      asOf: payload.asOf,
+      fetchedAt: payload.fetchedAt,
+      protocolsAsOf: payload.protocolsAsOf,
+      source: payload.source,
+      total: payload.total,
+      historyStart: defiHistoryStart(payload),
+      ...(summary ? { notices: [summary] } : {}),
+    },
+  };
+}
+
 export const cryptoBoardHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
   argument: { kind: "none" },
   options: [{
     key: "list",
-    description: "Coins or stablecoins.",
+    description: "Coins, stablecoins, or DeFi TVL.",
     type: "enum",
     values: [
       { value: "coin", aliases: ["coins"] },
       { value: "stablecoin", aliases: ["stablecoins", "stable", "stables"] },
+      { value: "defi", aliases: ["tvl"] },
     ],
     defaultValue: "coin",
     example: "--list stablecoin",
     pluginState: { pluginId: "market-overview", key: "activeTab" },
+  }, {
+    key: "by",
+    // No default: the coin and stablecoin reports carry no `by`, and a missing one is by protocol.
+    description: "DeFi TVL by protocol (the default) or by chain, with --list defi.",
+    type: "enum",
+    values: [
+      { value: "protocol", aliases: ["protocols"] },
+      { value: "chain", aliases: ["chains"] },
+    ],
+    example: "--list defi --by chain",
+    pluginState: { pluginId: "market-overview", key: "defiList" },
   }],
   columns: COIN_COLUMNS,
-  describe: (args) => `Crypto | ${args.options.list === "stablecoin" ? "Stablecoins" : "Coins"}`,
+  describe: (args) => `Crypto | ${args.options.list === "defi" ? `DeFi TVL by ${args.options.by === "chain" ? "chain" : "protocol"}` : args.options.list === "stablecoin" ? "Stablecoins" : "Coins"}`,
   discovery: {
     aliases: ["CRYP"],
     dataRequirements: ["Gloom Cloud crypto markets"],
   },
-  // A board snapshot refreshed every few minutes; the pane streams, the report does not.
-  freshness: { status: "delayed", ...CRYPTO_BOARD_FRESHNESS },
+  // The board as the server read it, at most 15 seconds before; the pane streams, the report does not.
+  // Each row keeps the time of its own last trade, so a coin that has not traded lately reads its age.
+  freshness: CRYPTO_BOARD_FRESHNESS,
   async load(args, ctx) {
+    if (args.options.list === "defi") return loadDefi(args.options.by === "chain" ? "chain" : "protocol", ctx);
     const kind = args.options.list === "stablecoin" ? "stablecoin" : "coin" satisfies CryptoAssetKind;
     // Supply is its own request: a failure there leaves the prices whole.
     const [data, supplyResult] = await Promise.all([

package/src/plugins/builtin/crypto-board/index.tsx

@@ -1,6 +1,6 @@
 import type { PluginModule } from "../plugin-module";
 import { LIVE_STREAMING_QUICK_SETTING, withLiveStreamingSetting } from "../../../state/hooks/live-streaming";
-import { cryptoMarketsCache, STABLECOIN_SUPPLY_CACHES } from "./client";
+import { cryptoMarketsCache, DEFI_TVL_CACHES, STABLECOIN_SUPPLY_CACHES } from "./client";
 import { cryptoBoardHeadless } from "./headless";
 import { CryptoBoardPane } from "./pane";
 import { CRYPTO_SERIES } from "./series";
@@ -27,8 +27,11 @@ export const cryptoBoardModule: PluginModule = {
       id: "crypto-board-pane",
       paneId: "crypto-board",
       label: "Crypto",
-      description: "Top crypto assets by market cap with live prices, 7D, 30D and 1Y returns, volume and market cap, and stablecoin supply.",
-      keywords: ["crypto", "cryp", "bitcoin", "ethereum", "coins", "stablecoins", "stablecoin supply", "digital", "currency"],
+      description: "Top crypto assets by market cap with live prices, 7D, 30D and 1Y returns, volume and market cap, stablecoin supply, and DeFi TVL by protocol and chain.",
+      keywords: [
+        "crypto", "cryp", "bitcoin", "ethereum", "coins", "stablecoins", "stablecoin supply", "digital", "currency",
+        "defi", "tvl", "total value locked", "defi tvl", "on-chain", "onchain", "aave", "lido", "protocols", "chains",
+      ],
       shortcut: { prefix: "CRYP" },
       headless: cryptoBoardHeadless,
     },
@@ -36,9 +39,11 @@ export const cryptoBoardModule: PluginModule = {
   setup(ctx) {
     cryptoMarketsCache.attach(ctx.persistence);
     for (const cache of STABLECOIN_SUPPLY_CACHES) cache.attach(ctx.persistence);
+    for (const cache of DEFI_TVL_CACHES) cache.attach(ctx.persistence);
   },
   dispose() {
     cryptoMarketsCache.reset();
     for (const cache of STABLECOIN_SUPPLY_CACHES) cache.reset();
+    for (const cache of DEFI_TVL_CACHES) cache.reset();
   },
 };

package/src/plugins/builtin/crypto-board/model.ts

@@ -2,6 +2,7 @@ import type { CryptoAssetKind, CryptoMarketAsset, CryptoPeg } from "../../../api
 import type { DataTableColumn } from "../../../components";
 import { getTableWidth } from "../../../components/ui/table-layout";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
+import { delayedFeedLagMs } from "../../../market-data/market/freshness";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { PricePoint, Quote } from "../../../types/financials";
 import type { HeadlessPaneFreshness } from "../../../types/headless";
@@ -12,15 +13,24 @@ import { formatUtcWeekdayTime } from "../../../utils/utc-time";
 
 const DAY_MS = 86_400_000;
 
+/** The venue code every coin is quoted under (`cryptoQuoteKey`). */
+const CRYPTO_EXCHANGE = "CCC";
+
 /**
- * How the board's report, capture and footer date its prices: crypto trades around the clock, so a price an hour old
- * has stopped refreshing, and coins are quoted apart, so the line says how old the oldest is.
+ * How the board's report, capture and footer date its prices. Coins are priced apart, and a coin that has not traded
+ * lately keeps its own time, so the line says when the newest price is from and how old the oldest is, and no more: a
+ * price read from the board is neither real-time nor held back, so it claims no feed (`ageOnly`). Crypto trades
+ * around the clock, so a newest price an hour old means the board has stopped refreshing.
  */
-export const CRYPTO_BOARD_FRESHNESS: HeadlessPaneFreshness = { maxAgeMinutes: 60, oldestAge: true };
+export const CRYPTO_BOARD_FRESHNESS: HeadlessPaneFreshness = { ageOnly: true, maxAgeMinutes: 60 };
+
+/** A tab of the board: a list of assets, or DeFi's value locked. */
+export type CryptoTab = CryptoAssetKind | "defi";
 
-export const CRYPTO_TABS: Array<{ value: CryptoAssetKind; label: string }> = [
+export const CRYPTO_TABS: Array<{ value: CryptoTab; label: string }> = [
   { value: "coin", label: "Coins" },
   { value: "stablecoin", label: "Stablecoins" },
+  { value: "defi", label: "DeFi" },
 ];
 
 /** A stablecoin's supply as its row shows it; every field is null on the coin tab and for a coin the supply list lacks. */
@@ -72,7 +82,10 @@ export interface CryptoRow extends CryptoRowSupply {
   history: PricePoint[];
   /** Epoch ms of the price shown. */
   updatedAt: number | null;
+  /** The price is a streamed quote, so it moves between board refreshes. */
   live: boolean;
+  /** The price is a quote from a delayed feed, held back from the market. A price read from the board is not. */
+  delayed: boolean;
   /** A stablecoin's peg; null for a coin, or a server that does not send it. */
   peg: CryptoPeg | null;
   /** `USD`, `EUR 1.1242` (the target in dollars), `USD yield`; empty without a peg. */
@@ -90,7 +103,7 @@ export interface CryptoRow extends CryptoRowSupply {
 }
 
 export const cryptoQuoteKey = (asset: Pick<CryptoMarketAsset, "symbol">) =>
-  buildQuoteKey({ symbol: asset.symbol, exchange: "CCC" });
+  buildQuoteKey({ symbol: asset.symbol, exchange: CRYPTO_EXCHANGE });
 
 const positive = (value: number | null | undefined): value is number => isFiniteNumber(value) && value > 0;
 
@@ -200,6 +213,7 @@ function buildCryptoRow(
     history,
     updatedAt: updated,
     live: !!quote && quote.delivery === "stream" && quote.stale !== true,
+    delayed: quote?.dataSource === "delayed",
     peg,
     pegText: formatPegTarget(peg),
     offPegBp: offPegBasisPoints(price, peg),
@@ -313,9 +327,27 @@ export function withCryptoSupply(rows: readonly CryptoRow[], supply: ReadonlyMap
   });
 }
 
-/** What a capture and the footer read of each row: when its price is from, and whether it is streaming live. */
-export function cryptoRowObservations(rows: readonly CryptoRow[]): Array<{ quoteTime: string; dataSource: "live" | "delayed" }> {
-  return rows.flatMap((row) => row.updatedAt == null ? [] : [{ quoteTime: new Date(row.updatedAt).toISOString(), dataSource: row.live ? "live" as const : "delayed" as const }]);
+/** One row's price as a capture and the footer date it: when it is from and, when it says so, how current it is. */
+type CryptoRowObservation = {
+  quoteTime: string;
+  dataSource?: "live" | "delayed";
+  delayMinutes?: number;
+};
+
+/**
+ * What a capture and the footer read of each row: when its price is from and, when it is a feed's, how current it
+ * is. A quote from a delayed feed is held back by the feed's lag. A price read from the board (a coin the live feed
+ * does not carry, every coin without real-time access) states no feed, and is dated by its own time. A streamed row
+ * says `live` only when the whole view is streamed: one price minutes old beside it, and the line would call
+ * minutes-old data live.
+ */
+export function cryptoRowObservations(rows: readonly CryptoRow[]): CryptoRowObservation[] {
+  const dated = rows.flatMap((row) => row.updatedAt == null ? [] : [{ row, quoteTime: new Date(row.updatedAt).toISOString() }]);
+  const allLive = dated.length > 0 && dated.every(({ row }) => row.live && !row.delayed);
+  return dated.map(({ row, quoteTime }): CryptoRowObservation => {
+    if (row.delayed) return { quoteTime, dataSource: "delayed", delayMinutes: delayedFeedLagMs(CRYPTO_EXCHANGE) / 60_000 };
+    return allLive ? { quoteTime, dataSource: "live" } : { quoteTime };
+  });
 }
 
 /**