gloomberb 0.17.6 → 0.18.0

package/src/plugins/builtin/credit-boards/index.tsx

@@ -1,9 +1,20 @@
+import type { PaneTemplateCreateOptions, PaneTemplateInstanceConfig } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
 import { fixedIncomeShortcut } from "../fixed-income/shortcut";
 import { cdxBoardCache, sovrBoardCache } from "./client";
 import { cdxHeadless, sovrHeadless } from "./headless";
 import { CREDIT_BOARD_SERIES } from "./series";
 
+/**
+ * What `CDX HY` or `SOVR Brazil` asks the board to open on. Always named, empty for the bare command, so a
+ * pane the command reuses is not asked again for what an earlier command named.
+ */
+function openingOn(param: string) {
+  return (_context: unknown, options?: PaneTemplateCreateOptions): PaneTemplateInstanceConfig => (
+    { placement: "floating", params: { [param]: options?.arg?.trim() ?? "" } }
+  );
+}
+
 export const creditBoardsModule: PluginModule = {
   series: CREDIT_BOARD_SERIES,
   paneTemplates: [
@@ -14,9 +25,9 @@ export const creditBoardsModule: PluginModule = {
         label: "Index CDS",
         description: "CDX IG, HY, EM, iTraxx Main and Crossover on the run from DTCC public dissemination: level, 1D and 1W moves, 1Y rank. Sovereign CDS is the other tab.",
         keywords: ["cdx", "itraxx", "crossover", "xover", "index", "cds", "credit", "ig", "hy", "em", "spread", "dtcc"],
-        shortcut: { prefix: "CDX" },
+        shortcut: { prefix: "CDX", argKind: "text", argOptional: true, argPlaceholder: "index" },
         headless: cdxHeadless,
-        createInstance: () => ({ placement: "floating" }),
+        createInstance: openingOn("index"),
       }, "credit", "index"),
     },
     {
@@ -26,9 +37,9 @@ export const creditBoardsModule: PluginModule = {
         label: "Sovereign CDS",
         description: "The CDS pane on Sovereign: 5Y CDS from DTCC public dissemination, ranked by the month's move, beside each local currency's month.",
         keywords: ["sovr", "wcds", "sovereign", "country", "cds", "credit", "em", "emerging", "spread", "dtcc"],
-        shortcut: { prefix: "SOVR", aliases: ["WCDS"] },
+        shortcut: { prefix: "SOVR", aliases: ["WCDS"], argKind: "text", argOptional: true, argPlaceholder: "country" },
         headless: sovrHeadless,
-        createInstance: () => ({ placement: "floating" }),
+        createInstance: openingOn("country"),
       }, "credit", "sovereign"),
     },
   ],

package/src/plugins/builtin/credit-boards/model.ts

@@ -26,6 +26,83 @@ export function quoteUnits(quote: CreditIndexQuote): { level: "bp" | "price"; mo
   return quote === "spread" ? { level: "bp", move: "bp" } : { level: "price", move: "pts" };
 }
 
+/** Today's trade date in New York, the date DTCC's index prints are dated by. */
+const NEW_YORK_DATE = new Intl.DateTimeFormat("en-CA", { timeZone: "America/New_York", year: "numeric", month: "2-digit", day: "2-digit" });
+
+function newYorkTradeDate(now: number): string {
+  return NEW_YORK_DATE.format(new Date(now));
+}
+
+function addDays(date: string, days: number): string {
+  return new Date(Date.parse(`${date}T00:00:00Z`) + days * 86_400_000).toISOString().slice(0, 10);
+}
+
+/** Where an index's latest day stands, and its moves between complete days. */
+export interface CdxDay {
+  /** The latest day is today's New York trade date, still trading: its level and prints are so far. */
+  partial: boolean;
+  /** When the latest day's last print was executed, ISO UTC, when the server says. */
+  lastPrintAt: string | null;
+  /** The last complete day, which the moves run to. */
+  changeDate: string | null;
+  change1D: number | null;
+  change1W: number | null;
+  change1M: number | null;
+}
+
+/**
+ * An index's latest day and the moves the board shows: always between
+ * complete days, so a morning's few prints never make a 1D. A server that
+ * says (`partial`) has already measured them that way, across a roll on one
+ * contract. An older one dates them from the latest day; when that day is
+ * today's New York trade date or later (Asia's prints) the moves are measured
+ * again here from the complete days before it, on the same contract only
+ * (none across a roll).
+ */
+export function cdxDay(index: CdxBoardIndex, now = Date.now()): CdxDay {
+  const served = { change1D: index.change1D, change1W: index.change1W, change1M: index.change1M ?? null };
+  if (typeof index.partial === "boolean") {
+    return {
+      partial: index.partial, lastPrintAt: index.lastPrintAt ?? null,
+      changeDate: index.changeDate !== undefined ? index.changeDate : index.partial ? null : index.date, ...served,
+    };
+  }
+  // Asia-session prints are dated the next local day, so from about 00:00 to 04:00 UTC (and from
+  // Sunday evening in New York) the latest day can be New York's tomorrow: still trading too.
+  if (!index.date || index.date < newYorkTradeDate(now)) return { partial: false, lastPrintAt: null, changeDate: index.date, ...served };
+  const complete = index.points.filter((point) => point.date < index.date!);
+  const anchor = complete.at(-1) ?? null;
+  const move = (base: string, maxLagDays: number): number | null => {
+    const baseline = complete.findLast((point) => point.date <= base);
+    if (!anchor || !baseline || baseline.maturity !== anchor.maturity || daysBetween(baseline.date, base) > maxLagDays) return null;
+    return Math.round((anchor.level - baseline.level) * 1e6) / 1e6;
+  };
+  return {
+    partial: true,
+    lastPrintAt: null,
+    changeDate: anchor?.date ?? null,
+    change1D: anchor ? move(addDays(anchor.date, -1), 5) : null,
+    change1W: anchor ? move(addDays(anchor.date, -7), 5) : null,
+    change1M: anchor ? move(monthBefore(anchor.date), 7) : null,
+  };
+}
+
+/** `08:09`: a print's time of day in UTC. */
+function utcClock(instant: string): string | null {
+  const time = Date.parse(instant);
+  return Number.isFinite(time) ? new Date(time).toISOString().slice(11, 16) : null;
+}
+
+/**
+ * What a day still trading rests on: `so far, 38 prints, last 08:09 UTC`.
+ * The print time is left out when the server does not say it.
+ */
+export function partialDayText(prints: number | null, lastPrintAt: string | null): string {
+  const clock = lastPrintAt ? utcClock(lastPrintAt) : null;
+  return ["so far", ...(prints == null ? [] : [`${prints} ${prints === 1 ? "print" : "prints"}`]),
+    ...(clock ? [`last ${clock} UTC`] : [])].join(", ");
+}
+
 /** Spreads in bp with a decimal; prices as quoted, to the cent. */
 export function formatLevel(quote: CreditIndexQuote, value: number | null): string {
   if (value == null || !Number.isFinite(value)) return "--";
@@ -93,33 +170,55 @@ export function formatContract(maturity: string | null): string {
     : date.toLocaleDateString("en-US", { month: "short", year: "numeric", timeZone: "UTC" });
 }
 
+const boardKey = (text: string) => text.toLowerCase().replace(/[^a-z0-9]/g, "");
+
+/**
+ * `IG`, `cdx hy`, `itraxx main`, `crossover`: an index by its code, its name or the name's last word. `fn CDX`
+ * and the board's own selection (`CDX HY` opens on it) read the argument through this.
+ */
+export function findIndex<T extends { id: string; name: string }>(indexes: readonly T[], query: string): T | null {
+  const wanted = boardKey(query) === "crossover" ? "xover" : boardKey(query);
+  return indexes.find((index) => [index.id, index.name, index.name.split(" ").at(-1) ?? ""]
+    .some((name) => boardKey(name) === wanted)) ?? null;
+}
+
+/** `Brazil`, `br`, `ivory coast`: a sovereign by its name or its country code, in any case. */
+export function findSovereign<T extends { id: string; name: string }>(sovereigns: readonly T[], query: string): T | null {
+  const wanted = boardKey(query);
+  return wanted ? sovereigns.find((sovereign) => [sovereign.id, sovereign.name].some((name) => boardKey(name) === wanted)) ?? null : null;
+}
+
 export interface CdxRow extends MarketBoardRow {
   index: CdxBoardIndex;
   year: YearStatistics;
+  /** The latest day's standing and the moves between complete days. */
+  day: CdxDay;
   /** The 1W and 1M moves as shown. */
   week: number | null;
   month: number | null;
 }
 
-export function cdxRows(indexes: readonly CdxBoardIndex[], asOf: string | null): CdxRow[] {
+export function cdxRows(indexes: readonly CdxBoardIndex[], asOf: string | null, now = Date.now()): CdxRow[] {
   return indexes.map((index) => {
     const year = yearStatistics(index.points, index.level, index.date);
+    const day = cdxDay(index, now);
     return {
       id: index.id,
       label: index.name,
       value: index.level,
       valueText: formatLevel(index.quote, index.level),
-      change: shown(index.quote, index.change1D),
-      changeText: formatMove(index.quote, index.change1D),
+      change: shown(index.quote, day.change1D),
+      changeText: formatMove(index.quote, day.change1D),
       percentile: year.percentile,
       asOf: index.date,
       history: pointHistory(index.points),
-      status: index.level == null ? "unavailable" : stale(index.date, asOf) ? "stale" : "available",
+      status: index.level == null ? "unavailable" : stale(index.date, asOf) ? "stale" : day.partial ? "partial" : "available",
       adverseMove: adverseMove(index.quote),
       index,
       year,
-      week: shown(index.quote, index.change1W),
-      month: shown(index.quote, index.change1M ?? null),
+      day,
+      week: shown(index.quote, day.change1W),
+      month: shown(index.quote, day.change1M),
     };
   });
 }

package/src/plugins/builtin/credit-boards/sovr-pane.tsx

@@ -21,8 +21,11 @@ import type { PaneProps } from "../../../types/plugin";
 import { formatPercentileRank } from "../../../utils/format";
 import { useAssetData, usePluginPaneState } from "../../runtime";
 import { formatAsOf } from "../cds/model";
+import { FIXED_INCOME_PANE_ID } from "../fixed-income/model";
+import { useCommandValue } from "../shared/command-tab";
 import { getCachedSovrBoard, loadCurrencyMoves, loadSovrBoard } from "./client";
 import {
+  findSovereign,
   formatContract,
   formatCurrencyMove,
   formatLevel,
@@ -82,7 +85,13 @@ export function SovrPane({ focused, width, height }: PaneProps) {
   const resource = useAsyncResource(loadSovrBoard, { initialData: getCachedSovrBoard });
   const { loading, load: refresh, reload } = resource;
   const payload = resource.data?.payload ?? null;
-  const [selectedId, setSelectedId] = usePluginPaneState<string | null>("sovr:selected", null);
+  // `SOVR Brazil` opens on that country, named as `fn SOVR Brazil` names it; a later `SOVR Chile` replaces it.
+  const [selectedId, setSelectedId] = useCommandValue<string | null>(
+    FIXED_INCOME_PANE_ID,
+    "sovr:selected",
+    (params) => params.view === "sovereign" && params.country ? params.country : null,
+    null,
+  );
   const [openId, setOpenId] = usePluginPaneState<string | null>("sovr:open", null);
   useAutoRefresh(resource.updatedAt, refresh);
 
@@ -131,12 +140,14 @@ export function SovrPane({ focused, width, height }: PaneProps) {
     );
   }
 
-  const selected = rows.find((row) => row.id === selectedId) ?? rows[0];
+  // A country the command named that the board does not have leaves the board on its first.
+  const named = selectedId ? findSovereign(payload?.sovereigns ?? [], selectedId) : null;
+  const selected = rows.find((row) => row.id === selectedId) ?? rows.find((row) => row.id === named?.id) ?? rows[0];
   return (
     <MarketBoardStack rows={rows} width={width} height={height} focused={focused}
       rootBefore={({ columns }) => <ChartTableHeader width={width} height={height} tableRows={rows.length}
         tableColumns={columns} chart={selected ? historyChart(selected) : null} />}
-      selectedId={selectedId} onSelectedIdChange={setSelectedId} openId={openId} onOpenIdChange={setOpenId}
+      selectedId={selected?.id ?? null} onSelectedIdChange={setSelectedId} openId={openId} onOpenIdChange={setOpenId}
       labelHeader="SOVEREIGN" labelWidth={18} valueLabel="5Y" valueWidth={9} changeLabel="1M" signedChange
       extraColumns={extraColumns}
       renderDetail={(row) => <SovereignDetail row={row} width={width} height={Math.max(5, height - 2)} focused={focused} />} />

package/src/plugins/builtin/credit-documents/detail.tsx

@@ -4,6 +4,7 @@ import { Button, ChartTableHeader, DataTableStackView, DetailScrollBody, Externa
 import { useAsyncResource, usePluginPaneState } from "../../../public/react";
 import { useThemeColors } from "../../../theme/theme-context";
 import { Box, Text, TextAttributes, useRendererHost, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
+import { quoteBlockStyle } from "../../../components/ui/quote";
 import { fetchCreditInstrument } from "./client";
 import { comparatorSymbol, covenantNumber, covenantTerms, creditPercent, factColumns, factValue, fieldLabel, hasAmendments, headroomTone, NO_VALUE, sentence, structuredFields } from "./model";
 
@@ -14,7 +15,7 @@ const MATCH = { exact: "Exact", whitespace: "Whitespace normalized", nfkc_whites
 function Quote({ text, width }: { text: string; width: number }) {
   const colors = useThemeColors(), desktop = useUiCapabilities().nativePaneChrome === true;
   return <Box paddingLeft={1} border={desktop ? undefined : ["left"]} borderColor={colors.borderFocused}
-    style={desktop ? { borderLeft: `2px solid ${colors.borderFocused}`, paddingLeft: "calc(1.5 * var(--cell-w))" } : undefined} data-gloom-role="credit-quote">
+    style={desktop ? quoteBlockStyle() : undefined} data-gloom-role="credit-quote">
     <Text width={Math.max(1, width - 2)} wrapMode="word" wrapText fg={colors.textBright}>{text}</Text>
   </Box>;
 }

package/src/plugins/builtin/credit-documents/index.tsx

@@ -1,6 +1,7 @@
 import type { PluginModule } from "../plugin-module";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { fixedIncomeShortcut } from "../fixed-income/shortcut";
+import { SEC_FILINGS_VIEW } from "../shared/report-freshness";
 import { creditCache } from "./client";
 import { creditHeadless, covenantsHeadless } from "./headless";
 
@@ -18,6 +19,7 @@ export const creditDocumentsModule: PluginModule = {
         shortcut: "CRDOC",
       }),
       headless: creditHeadless,
+      reportFreshness: SEC_FILINGS_VIEW,
     }, "issuer-debt", "documents"),
     fixedIncomeShortcut({
       ...createTickerSurfacePaneTemplate({
@@ -31,6 +33,7 @@ export const creditDocumentsModule: PluginModule = {
         settings: () => ({ tab: "covenants" }),
       }),
       headless: covenantsHeadless,
+      reportFreshness: SEC_FILINGS_VIEW,
     }, "issuer-debt", "documents"),
   ],
 };

package/src/plugins/builtin/credit-documents/model.ts

@@ -1,7 +1,7 @@
 import type { CreditDocumentsPayload, CreditFact, CreditHeadroom, CreditInstrument, CreditMaturityBucket, CreditScreenRow, CreditValue } from "../../../api-client/credit-documents";
 import type { DataTableColumn, StatItem } from "../../../components";
 import { scalarPoint, staticSeries } from "../../../components/chart/static/series";
-import { getTableWidth } from "../../../components/ui/table-layout";
+import { dropColumnsToFit } from "../../../components/ui/table-layout";
 import type { ResolvedSeries } from "../../../time-series/types";
 import { displayWidth } from "../../../utils/format";
 
@@ -199,16 +199,9 @@ export function capitalFigures(data: CreditDocumentsPayload): StatItem[] {
 }
 
 type Column<Id extends string> = DataTableColumn & { id: Id };
-/** The table's width with its gaps and padding, plus the vertical scrollbar's cell. */
-const fits = (columns: readonly DataTableColumn[], width: number) => getTableWidth(columns) + 1 <= width;
-/** Narrow panes drop whole columns, least important first, instead of scrolling sideways. */
+/** Narrow panes drop whole columns, least important first, instead of scrolling sideways; the scrollbar keeps its cell. */
 function fitColumns<Id extends string>(columns: readonly Column<Id>[], width: number, dropOrder: readonly Id[]): Column<Id>[] {
-  let shown = [...columns];
-  for (const id of dropOrder) {
-    if (fits(shown, width)) break;
-    shown = shown.filter((column) => column.id !== id);
-  }
-  return shown;
+  return dropColumnsToFit(columns, width - 1, dropOrder);
 }
 
 type CapitalColumnId = "name" | "facility" | "coupon" | "maturity" | "principal" | "currency" | "ranking" | "control";

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

@@ -1,6 +1,11 @@
 import { apiClient } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
-import type { CryptoMarketAsset, CryptoMarketsPayload } from "../../../api-client/crypto-markets";
+import type {
+  CryptoMarketAsset,
+  CryptoMarketsPayload,
+  StablecoinSupplyHistoryPayload,
+  StablecoinSupplyPayload,
+} from "../../../api-client/crypto-markets";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
 import { isFiniteNumber } from "../../../utils/guards";
@@ -58,6 +63,27 @@ function validAsset(asset: CryptoMarketAsset): boolean {
   );
 }
 
+const validPeg = (peg: CryptoMarketAsset["peg"]) =>
+  !!peg
+  && typeof peg.currency === "string"
+  && /^[A-Z]{3}$/.test(peg.currency)
+  && typeof peg.accrues === "boolean"
+  && (peg.price === null || (isFiniteNumber(peg.price) && peg.price > 0))
+  && nullableInstant(peg.asOf);
+
+const validRange = (range: CryptoMarketAsset["range24h"]) =>
+  !!range
+  && [range.low, range.high].every((value) => isFiniteNumber(value) && value > 0)
+  && [range.lowAt, range.highAt, range.start, range.end].every(instant);
+
+/** A malformed peg or 24h range is dropped from its coin alone; the coin and the rest of the board stay. */
+function withValidStablecoinFields(asset: CryptoMarketAsset): CryptoMarketAsset {
+  const peg = asset.peg != null && !validPeg(asset.peg);
+  const range = asset.range24h != null && !validRange(asset.range24h);
+  if (!peg && !range) return asset;
+  return { ...asset, ...(peg ? { peg: null } : {}), ...(range ? { range24h: null } : {}) };
+}
+
 export function validateCryptoMarkets(data: CryptoMarketsPayload): CryptoMarketsPayload {
   if (
     !data
@@ -77,7 +103,8 @@ export function validateCryptoMarkets(data: CryptoMarketsPayload): CryptoMarkets
   ) {
     throw new Error("The server returned an invalid crypto board");
   }
-  return data;
+  const assets = data.assets.map(withValidStablecoinFields);
+  return assets.every((asset, index) => asset === data.assets[index]) ? data : { ...data, assets };
 }
 
 export async function fetchCryptoMarkets(
@@ -100,3 +127,126 @@ export function cachedCryptoMarkets() {
 export function loadCryptoMarkets(force = false) {
   return loadCloudResource(cryptoMarketsCache, "usd", () => fetchCryptoMarkets(), { force, validate: validateCryptoMarkets });
 }
+
+// Stablecoin supply ------------------------------------------------------------
+
+const stablecoinSupplyCache = createPluginCache<StablecoinSupplyPayload>({
+  kind: "stablecoin-supply",
+  source: "gloom-cloud",
+  schemaVersion: 1,
+  // The server reads the source once a UTC day; a month-old copy still dates itself.
+  policy: { staleMs: 30 * 60_000, expireMs: 30 * 86_400_000 },
+});
+
+const stablecoinSupplyHistoryCache = createPluginCache<StablecoinSupplyHistoryPayload>({
+  kind: "stablecoin-supply-history",
+  source: "gloom-cloud",
+  schemaVersion: 1,
+  policy: { staleMs: 30 * 60_000, expireMs: 30 * 86_400_000 },
+});
+
+export const STABLECOIN_SUPPLY_CACHES = [stablecoinSupplyCache, stablecoinSupplyHistoryCache] as const;
+
+const MAX_SUPPLY_DAYS = 20_000;
+const supplyValues = (values: unknown) =>
+  Array.isArray(values) && values.length <= MAX_SUPPLY_DAYS && values.every((value) => value === null || (isFiniteNumber(value) && value >= 0));
+const nullableString = (value: unknown) => value === null || typeof value === "string";
+const supplyStatus = (value: unknown) => value === "available" || value === "stale" || value === "unavailable";
+
+export function validateStablecoinSupply(data: StablecoinSupplyPayload): StablecoinSupplyPayload {
+  const history = data?.history;
+  if (
+    !data
+    || data.version !== 1
+    || !instant(data.generatedAt)
+    || !nullableInstant(data.fetchedAt)
+    || !(data.asOf === null || date(data.asOf))
+    || !supplyStatus(data.status)
+    || (data.total !== null && (
+      !data.total
+      || !isFiniteNumber(data.total.supply)
+      || ![data.total.change7d, data.total.change7dPercent, data.total.change30d, data.total.change30dPercent].every(nullableNumber)
+    ))
+    || !Array.isArray(data.coins)
+    || data.coins.length > 500
+    || !data.coins.every((coin) => !!coin
+      && typeof coin.symbol === "string"
+      && coin.symbol.length > 0
+      && typeof coin.name === "string"
+      && typeof coin.pegType === "string"
+      && nullableString(coin.pegMechanism)
+      && isFiniteNumber(coin.supply)
+      && coin.supply >= 0
+      && [coin.price, coin.change7d, coin.change7dPercent, coin.change30d, coin.change30dPercent, coin.share].every(nullableNumber))
+    || (history !== null && (
+      !history
+      || !date(history.start)
+      || !supplyValues(history.total)
+      || !Array.isArray(history.coins)
+      || history.coins.length > 20
+      || !history.coins.every((coin) => !!coin
+        && typeof coin.symbol === "string"
+        && typeof coin.name === "string"
+        && supplyValues(coin.values)
+        && coin.values.length === history.total.length)
+    ))
+    || !Array.isArray(data.warnings)
+    || data.warnings.some((warning) => typeof warning !== "string")
+  ) {
+    throw new Error("The server returned invalid stablecoin supply");
+  }
+  return data;
+}
+
+function validateStablecoinSupplyHistory(data: StablecoinSupplyHistoryPayload): StablecoinSupplyHistoryPayload {
+  if (
+    !data
+    || data.version !== 1
+    || !instant(data.generatedAt)
+    || !(data.asOf === null || date(data.asOf))
+    || !supplyStatus(data.status)
+    || typeof data.symbol !== "string"
+    || typeof data.name !== "string"
+    || (data.history !== null && (!data.history || !date(data.history.start) || !supplyValues(data.history.values)))
+    || !Array.isArray(data.warnings)
+  ) {
+    throw new Error("The server returned invalid stablecoin supply history");
+  }
+  return data;
+}
+
+function supplyError(error: unknown, what: string): unknown {
+  if (error instanceof ApiRequestError && error.status === 503) return new Error(`${what} is temporarily unavailable`);
+  return unavailableOnServer(error, `${what} is not available yet.`);
+}
+
+export async function fetchStablecoinSupply(
+  client: Pick<typeof apiClient, "getCloudStablecoinSupply"> = apiClient,
+): Promise<StablecoinSupplyPayload> {
+  try {
+    return validateStablecoinSupply(await client.getCloudStablecoinSupply());
+  } catch (error) {
+    throw supplyError(error, "Stablecoin supply");
+  }
+}
+
+export function cachedStablecoinSupply() {
+  return cachedCloudResource(stablecoinSupplyCache, "all", validateStablecoinSupply);
+}
+
+export function loadStablecoinSupply(force = false) {
+  return loadCloudResource(stablecoinSupplyCache, "all", () => fetchStablecoinSupply(), { force, validate: validateStablecoinSupply });
+}
+
+/** One listed stablecoin's daily supply, by its symbol (USDT). */
+export function loadStablecoinSupplyHistory(symbol: string) {
+  const key = symbol.trim().toUpperCase();
+  return loadCloudResource(stablecoinSupplyHistoryCache, key, async () => {
+    try {
+      return validateStablecoinSupplyHistory(await apiClient.getCloudStablecoinSupplyHistory(key));
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) throw new Error(`No stablecoin supply series for ${key}: it is not among the stablecoins CRYP lists.`);
+      throw supplyError(error, `${key} supply history`);
+    }
+  }, { validate: validateStablecoinSupplyHistory });
+}