gloomberb 0.18.2 → 0.18.4

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 };
+  });
 }
 
 /**

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

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { Box, TextAttributes } from "../../../ui";
+import { Box, TextAttributes, useUiCapabilities } from "../../../ui";
+import { withCompanyLogo } from "../../../components/company-logo";
 import {
   ChartTableHeader,
   DataTableView,
@@ -38,7 +39,9 @@ import { usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { INITIAL_STREAM_RANGE, streamWindowRows } from "../shared/use-quote-board";
-import { cachedCryptoMarkets, cachedStablecoinSupply, loadCryptoMarkets, loadStablecoinSupply } from "./client";
+import { cachedCryptoMarkets, cachedDefiTvl, cachedStablecoinSupply, loadCryptoMarkets, loadDefiTvl, loadStablecoinSupply } from "./client";
+import { defiFailure } from "./defi";
+import { DefiTvlView } from "./defi-view";
 import {
   buildCryptoColumns,
   buildCryptoRows,
@@ -56,6 +59,7 @@ import {
   type CryptoColumn,
   type CryptoRow,
   type CryptoSortPreference,
+  type CryptoTab,
 } from "./model";
 import { stackedSupply, SUPPLY_RANGES, supplyByCode, supplyFailure, type SupplyRangeId } from "./supply";
 
@@ -91,7 +95,8 @@ function quoteTargets(
   }));
 }
 
-function renderCryptoCell(row: CryptoRow, column: CryptoColumn): DataTableCell {
+/** `logos`: the desktop and the web lead each name with the coin's logo; the terminal draws none. */
+function renderCryptoCell(row: CryptoRow, column: CryptoColumn, logos: boolean): DataTableCell {
   const signed = (value: number | null) => ({
     text: formatCryptoPercent(value),
     color: value == null ? colors.textDim : priceColor(value),
@@ -102,7 +107,7 @@ function renderCryptoCell(row: CryptoRow, column: CryptoColumn): DataTableCell {
     case "code":
       return { text: row.code, color: colors.textBright, attributes: TextAttributes.BOLD };
     case "name":
-      return { text: row.name };
+      return withCompanyLogo({ text: row.name }, { symbol: row.code, assetCategory: "CRYPTO", name: row.name }, logos);
     case "price":
       return { text: row.priceText };
     case "changePercent":
@@ -183,7 +188,7 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
   const data = resource.data?.payload;
   const { pinTicker } = usePluginTickerActions();
   const liveStreaming = useLiveStreamingSetting();
-  const [activeTab, setActiveTab] = usePluginPaneState<CryptoAssetKind>("activeTab", "coin");
+  const [activeTab, setActiveTab] = usePluginPaneState<CryptoTab>("activeTab", "coin");
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selected", null);
   const [sort, setSort] = useState<CryptoSortPreference>(DEFAULT_CRYPTO_SORT);
   const [visibleRange, setVisibleRange] = useState(INITIAL_STREAM_RANGE);
@@ -202,16 +207,29 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
   const [supplyRange, setSupplyRange] = usePluginPaneState<SupplyRangeId>("supplyRange", "1Y");
   const stablecoins = activeTab === "stablecoin";
 
+  // DeFi TVL likewise loads once its tab is first shown; the server reads it once a UTC day.
+  const defi = activeTab === "defi";
+  const [defiShown, setDefiShown] = useState(defi);
+  useEffect(() => {
+    if (defi) setDefiShown(true);
+  }, [defi]);
+  const defiLoader = useCallback((force: boolean) => loadDefiTvl(force), [session.requestKey]);
+  const defiResource = useAsyncResource(defiShown ? defiLoader : null, { initialData: cachedDefiTvl });
+  const defiPayload = defiResource.data?.payload ?? null;
+  useAutoRefresh(defiResource.updatedAt, defiResource.load, { intervalMs: SUPPLY_REFRESH_MS });
+
+  // The DeFi tab lists no assets; the coin and stablecoin streams stop while it shows.
+  const assetKind: CryptoAssetKind = activeTab === "stablecoin" ? "stablecoin" : "coin";
   const tabAssets = useMemo(
-    () => data?.assets.filter((asset) => asset.kind === activeTab) ?? [],
-    [activeTab, data],
+    () => (defi ? [] : data?.assets.filter((asset) => asset.kind === activeTab) ?? []),
+    [activeTab, data, defi],
   );
   // The stream follows the rows on screen. Ordering by the board snapshot keeps
   // live ticks from reshuffling the subscription; the overscan covers the drift.
   const streamedAssets = useMemo(() => {
-    const ordered = sortCryptoRows(buildCryptoRows(tabAssets, activeTab, NO_QUOTES), sort).map((row) => row.asset);
+    const ordered = sortCryptoRows(buildCryptoRows(tabAssets, assetKind, NO_QUOTES), sort).map((row) => row.asset);
     return streamWindowRows(ordered, visibleRange, ordered.find((asset) => asset.symbol === selectedId));
-  }, [activeTab, selectedId, sort, tabAssets, visibleRange]);
+  }, [assetKind, selectedId, sort, tabAssets, visibleRange]);
   const targets = useMemo(() => quoteTargets(streamedAssets, selectedId), [selectedId, streamedAssets]);
   const { entries, freshnessNow } = useLiveQuoteEntries(targets, {
     freshnessScopeKey: `crypto-board:${activeTab}`,
@@ -221,20 +239,20 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
   const supplyRows = useMemo(() => (stablecoins ? supplyByCode(supply) : null), [stablecoins, supply]);
   const rows = useMemo(
     () => {
-      const built = buildCryptoRows(tabAssets, activeTab, entries, freshnessNow);
+      const built = buildCryptoRows(tabAssets, assetKind, entries, freshnessNow);
       return sortCryptoRows(supplyRows ? withCryptoSupply(built, supplyRows) : built, sort);
     },
-    [activeTab, entries, freshnessNow, sort, supplyRows, tabAssets],
+    [assetKind, entries, freshnessNow, sort, supplyRows, tabAssets],
   );
   const streamedIds = useMemo(() => new Set(streamedAssets.map((asset) => asset.symbol)), [streamedAssets]);
   const allStreamedLive = liveStreaming && streamedIds.size > 0
     && rows.every((row) => !streamedIds.has(row.id) || row.live);
   const boardRefreshMs = allStreamedLive ? CRYPTO_BOARD_STREAMING_REFRESH_MS : CRYPTO_BOARD_REFRESH_MS;
   useEffect(() => {
-    if (!paneVisible) return;
+    if (!paneVisible || defi) return;
     const timer = setInterval(() => void reloadBoard(false), boardRefreshMs);
     return () => clearInterval(timer);
-  }, [boardRefreshMs, paneVisible, reloadBoard]);
+  }, [boardRefreshMs, defi, paneVisible, reloadBoard]);
   useEffect(() => {
     if (!rows.length) return;
     if (!selectedId || !rows.some((row) => row.id === selectedId)) setSelectedId(rows[0]!.id);
@@ -254,7 +272,7 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
     : null, [now, observations]);
   // Supply columns join only once there is supply to show; an outage leaves the price columns as they are.
   const hasSupply = !!supplyRows && supplyRows.size > 0;
-  const columns = useMemo(() => buildCryptoColumns(width, activeTab, hasSupply), [activeTab, hasSupply, width]);
+  const columns = useMemo(() => buildCryptoColumns(width, assetKind, hasSupply), [assetKind, hasSupply, width]);
 
   // Other is muted against the theme it is drawn on; the coins take the shared series palette, which the chart themes.
   const otherColor = useThemeColors().textMuted;
@@ -282,7 +300,7 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
     value: tab.value,
   }));
   const selectTab = (value: string) => {
-    setActiveTab(value as CryptoAssetKind);
+    setActiveTab(value as CryptoTab);
     setSelectedId(null);
     setVisibleRange(INITIAL_STREAM_RANGE);
   };
@@ -291,7 +309,10 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
   usePaneNoticeFooter({
     registrationId: "crypto-board:notices",
     focused,
-    notices: [
+    notices: defi ? [
+      ...(defiPayload?.warnings ?? []),
+      ...(defiResource.data?.refreshError ? [defiFailure(defiResource.data.refreshError)] : []),
+    ] : [
       ...(data?.warnings ?? []),
       ...(resource.data?.refreshError ? [resource.data.refreshError] : []),
       ...(stablecoins ? [
@@ -302,16 +323,22 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
     ],
   });
   usePaneFooter("crypto-board", () => ({
-    info: [
+    info: defi ? [
+      ...(defiResource.loading && !defiPayload ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
+      ...(defiPayload && defiResource.error ? [{ id: "refresh", parts: [{ text: "refresh failed", tone: "warning" as const }] }] : []),
+      ...(defiResource.data?.stale ? [{ id: "cached", parts: [{ text: "cached", tone: "warning" as const }] }] : []),
+    ] : [
       // Background refreshes run every 15s; only the first load is worth a label.
       ...(resource.loading && !data ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
       ...(data && resource.error ? [{ id: "refresh", parts: [{ text: "refresh failed", tone: "warning" as const }] }] : []),
       ...(statusLine ? [{ id: "updated", asOf: true, parts: [{ text: statusLine, tone: "muted" as const }] }] : []),
       ...(resource.data?.stale ? [{ id: "cached", parts: [{ text: "cached", tone: "warning" as const }] }] : []),
     ],
-  }), [data, statusLine, resource.data?.stale, resource.error, resource.loading]);
+  }), [data, defi, defiPayload, defiResource.data?.stale, defiResource.error, defiResource.loading, statusLine, resource.data?.stale, resource.error, resource.loading]);
 
   const reloadSupply = supplyResource.reload;
+  const logos = useUiCapabilities().nativePaneChrome === true;
+  const renderCell = useCallback((row: CryptoRow, column: CryptoColumn) => renderCryptoCell(row, column, logos), [logos]);
   const handleKeyDown = useCallback((event: DataTableKeyEvent) => (
     handleRefreshKey(event, () => {
       void resource.reload();
@@ -321,10 +348,17 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
 
   const bodyHeight = Math.max(1, height - (tabStrip ? 1 : 0));
 
+  const defiState = useMemo(() => ({
+    payload: defiPayload,
+    loading: defiResource.loading,
+    error: defiResource.error,
+    reload: defiResource.reload,
+  }), [defiPayload, defiResource.error, defiResource.loading, defiResource.reload]);
+
   return (
     <Box width={width} height={height} flexDirection="column">
       {tabStrip && <Box height={1} paddingX={1}>{tabStrip}</Box>}
-      <PaneStatusBody
+      {defi ? <DefiTvlView width={width} height={bodyHeight} focused={focused} resource={defiState} /> : <PaneStatusBody
         loading={resource.loading && !data}
         error={!data ? resource.error : null}
         subject="crypto prices"
@@ -357,7 +391,7 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
           })}
           visibleRangeKey={`${activeTab}:${sort.columnId}:${sort.direction}`}
           onVisibleRangeChange={setVisibleRange}
-          renderCell={renderCryptoCell}
+          renderCell={renderCell}
           selectedTextOverridesCellColor
           emptyStateTitle="No crypto assets returned."
           rootBefore={stablecoins ? (
@@ -379,7 +413,7 @@ export function CryptoBoardPane({ width, height, focused }: PaneProps) {
             />
           ) : undefined}
         />
-      </PaneStatusBody>
+      </PaneStatusBody>}
     </Box>
   );
 }

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

@@ -1,6 +1,6 @@
 import type { SeriesDefinition, SeriesPoint } from "../../../series/types";
 import { cachedSeriesWarning } from "../shared/series-warning";
-import { loadStablecoinSupply, loadStablecoinSupplyHistory } from "./client";
+import { loadDefiTvl, loadStablecoinSupply, loadStablecoinSupplyHistory } from "./client";
 
 const DAY_MS = 86_400_000;
 
@@ -50,6 +50,23 @@ const STABLECOIN_SUPPLY_SERIES: readonly SeriesDefinition[] = [
   },
 ];
 
+/** Total value locked in DeFi, as CRYP's DeFi tab charts it. */
+const DEFI_TVL_SERIES: SeriesDefinition = {
+  id: "crypto:defi-tvl",
+  name: "Total DeFi TVL",
+  unit: "USD",
+  frequency: "daily",
+  group: "Crypto",
+  tags: ["defi", "tvl", "total value locked", "on-chain", "protocols", "chains"],
+  description: "Total value locked in DeFi protocols across every chain, valued in USD, daily since 2018, as DefiLlama measures it and CRYP's DeFi tab charts it.",
+  load: async () => {
+    const resource = await loadDefiTvl();
+    const history = resource.payload.history;
+    if (!history) throw new Error("DeFi TVL is not available yet.");
+    return { points: dailyPoints(history.start, history.total), warning: cachedSeriesWarning(resource) };
+  },
+};
+
 const PAIRS: ReadonlyArray<{ symbol: string; name: string }> = [
   { symbol: "BTC-USD", name: "Bitcoin" },
   { symbol: "ETH-USD", name: "Ethereum" },
@@ -96,4 +113,5 @@ export const CRYPTO_SERIES: readonly SeriesDefinition[] = [
     expression: "{ticker}:price",
   },
   ...STABLECOIN_SUPPLY_SERIES,
+  DEFI_TVL_SERIES,
 ];

package/src/plugins/builtin/crypto-etf-flows/client.ts

@@ -0,0 +1,60 @@
+import { apiClient } from "../../../api-client";
+import type { CryptoEtfFlowAsset, CryptoEtfFlowsPayload } from "../../../api-client/crypto-etf-flows";
+import { createPluginCache } from "../../../data/plugin-cache";
+import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+
+export const cryptoEtfFlowsCache = createPluginCache<CryptoEtfFlowsPayload>({
+  kind: "crypto-etf-flows", source: "gloom-cloud", schemaVersion: 1,
+  // Flows post once a trading day, in the US evening and the next morning in Europe.
+  policy: { staleMs: 15 * 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+});
+
+const date = (value: unknown): value is string => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)
+  && new Date(`${value}T00:00:00Z`).toISOString().slice(0, 10) === value;
+const flow = (value: unknown) => value === null || (typeof value === "number" && Number.isFinite(value));
+const text = (value: unknown): value is string => typeof value === "string" && value.trim().length > 0;
+const textOrNull = (value: unknown) => value === null || text(value);
+
+/**
+ * The flows as served, or an error: the asset asked for, its funds once each,
+ * every day newest first with a figure or none for each fund, and where they
+ * are from. A payload that breaks any of it is not drawn.
+ */
+export function validateCryptoEtfFlows(payload: CryptoEtfFlowsPayload, asset: CryptoEtfFlowAsset): CryptoEtfFlowsPayload {
+  const invalid = (): never => { throw new Error("The server returned invalid crypto ETF flows"); };
+  if (!payload || payload.asset !== asset || payload.unit !== "USD millions" || !Array.isArray(payload.funds)
+    || !Array.isArray(payload.days) || !date(payload.asOf) || !text(payload.fetchedAt) || !Number.isFinite(Date.parse(payload.fetchedAt))
+    || typeof payload.stale !== "boolean" || !payload.source || !text(payload.source.publisher) || !text(payload.source.url)) return invalid();
+  const tickers = payload.funds.map((fund) => fund?.ticker);
+  if (!tickers.length || tickers.some((ticker) => !text(ticker)) || new Set(tickers).size !== tickers.length
+    || payload.funds.some((fund) => !textOrNull(fund.name) || !textOrNull(fund.issuer))) return invalid();
+  const known = new Set(tickers);
+  for (const [index, day] of payload.days.entries()) {
+    if (!day || !date(day.date) || (index > 0 && day.date >= payload.days[index - 1]!.date) || !flow(day.total)
+      || !day.flows || typeof day.flows !== "object" || Object.entries(day.flows).some(([ticker, value]) => !known.has(ticker) || !flow(value))
+      || !Array.isArray(day.pending) || day.pending.some((ticker) => !known.has(ticker))) return invalid();
+  }
+  if (payload.days[0] && payload.days[0].date !== payload.asOf) return invalid();
+  return payload;
+}
+
+export async function fetchCryptoEtfFlows(
+  asset: CryptoEtfFlowAsset,
+  client: Pick<typeof apiClient, "getCloudCryptoEtfFlows"> = apiClient,
+): Promise<CryptoEtfFlowsPayload> {
+  try {
+    return validateCryptoEtfFlows(await client.getCloudCryptoEtfFlows(asset), asset);
+  } catch (error) {
+    // 404 from a server without the route; 503 until the first read is stored.
+    throw unavailableOnServer(error, "Crypto ETF flows are not available yet.", [404, 503]);
+  }
+}
+
+export function cachedCryptoEtfFlows(asset: CryptoEtfFlowAsset) {
+  return cachedCloudResource(cryptoEtfFlowsCache, asset, (payload) => validateCryptoEtfFlows(payload, asset));
+}
+
+export function loadCryptoEtfFlows(asset: CryptoEtfFlowAsset, force = false) {
+  return loadCloudResource(cryptoEtfFlowsCache, asset, () => fetchCryptoEtfFlows(asset),
+    { force, validate: (payload) => validateCryptoEtfFlows(payload, asset) });
+}