feat(treasury): latest ETH and USDC inflows panel (#251)

Adds a card to /treasury listing the most recent value arriving at the
DAO treasury — amount, asset, sender, age and a link to the transaction.

The category set is the whole trick. Reaching for `external` + `erc20`,
which is the obvious pair, reports no ETH income since February 2025 and
misses the DAO's primary revenue: auction settlement is a
contract-to-contract move from the auction house, so it only appears
under `internal`. Those rows are badged as auction income, since "someone
sent us money" and "the DAO earned it" are different facts.

WETH is included alongside ETH and USDC and labelled as itself — it is
the treasury's most frequent recent inflow, and dropping it would leave
the panel looking emptier than the treasury actually is.

Fetches Alchemy directly on the server rather than routing through our
own /api/alchemy proxy: the treasury service already notes that pattern
made the server take an HTTP round trip to itself. Failures degrade to an
empty panel rather than taking the route down.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: sktbrd

messages/en/treasury.json

@@ -66,5 +66,12 @@
       "errorDescription": "Unable to load member activity data",
       "loadFailed": "Failed to load data"
     }
+  },
+  "inflows": {
+    "title": "Latest inflows",
+    "empty": "No recent inflows.",
+    "auction": "Auction",
+    "auctionHint": "Arrived from the auction house as an internal transfer",
+    "viewTx": "View transaction on Basescan"
   }
 }

messages/pt-br/treasury.json

@@ -66,5 +66,12 @@
       "errorDescription": "Não foi possível carregar dados de atividade dos membros",
       "loadFailed": "Falha ao carregar dados"
     }
+  },
+  "inflows": {
+    "title": "Últimas entradas",
+    "empty": "Nenhuma entrada recente.",
+    "auction": "Leilão",
+    "auctionHint": "Chegou do contrato de leilão como transferência interna",
+    "viewTx": "Ver transação no Basescan"
   }
 }

src/app/[locale]/treasury/page.tsx

@@ -8,9 +8,10 @@ import {
   TableSkeleton,
 } from "@/components/skeletons/treasury-skeletons";
 import { NftHoldings } from "@/components/treasury/NftHoldings";
+import { SponsorshipYield } from "@/components/treasury/SponsorshipYield";
 import { TokenHoldings } from "@/components/treasury/TokenHoldings";
 import { TreasuryBalance } from "@/components/treasury/TreasuryBalance";
-import { SponsorshipYield } from "@/components/treasury/SponsorshipYield";
+import { TreasuryInflows } from "@/components/treasury/TreasuryInflows";
 import { ZoraCoinHoldings } from "@/components/treasury/ZoraCoinHoldings";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { DAO_ADDRESSES } from "@/lib/config";
@@ -129,6 +130,12 @@ export default async function TreasuryPage({ params }: { params: Promise<{ local
           <SponsorshipYield />
         </div>
 
+        {/* What has actually come in lately. Sits directly under the balances:
+            the KPIs say how much there is, this says where it came from. */}
+        <Suspense fallback={<TableSkeleton />}>
+          <TreasuryInflows locale={locale} />
+        </Suspense>
+
         {/* Charts */}
         <div className="grid grid-cols-1 gap-6 lg:grid-cols-3">
           <div className="lg:col-span-1 min-w-0">

src/components/treasury/TreasuryInflows.tsx

@@ -0,0 +1,113 @@
+import { getTranslations } from "next-intl/server";
+import { ArrowDownLeft, ExternalLink, Gavel } from "lucide-react";
+import { AddressDisplay } from "@/components/ui/address-display";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { loadTreasuryInflows, type InflowAsset } from "@/services/treasury-inflows";
+
+/** Per-asset accent. Deliberately not the semantic tokens — these identify a currency. */
+const ASSET_TONE: Record<InflowAsset, string> = {
+  ETH: "text-[#627eea]",
+  WETH: "text-[#627eea]",
+  USDC: "text-[#2775ca]",
+};
+
+/**
+ * ETH is worth ~4 decimals; USDC is a dollar figure and reads wrong with more
+ * than two. `maximumFractionDigits` alone would print `0` for auction dust, so
+ * very small ETH amounts keep enough significant digits to stay non-zero.
+ */
+function formatAmount(amount: number, asset: InflowAsset, locale: string): string {
+  if (asset === "USDC") {
+    return amount.toLocaleString(locale, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  }
+  if (amount > 0 && amount < 0.0001) {
+    return amount.toLocaleString(locale, { maximumSignificantDigits: 2 });
+  }
+  return amount.toLocaleString(locale, { maximumFractionDigits: 4 });
+}
+
+function ageLabel(at: string, now: number): string {
+  const ms = now - new Date(at).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 60) return `${Math.max(1, mins)}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d`;
+  return `${Math.floor(days / 30)}mo`;
+}
+
+/**
+ * The treasury's most recent income, newest first.
+ *
+ * Auction settlements arrive as internal transfers and are marked as such — it
+ * is the difference between "someone sent us money" and "the DAO earned it".
+ */
+export async function TreasuryInflows({ locale }: { locale: string }) {
+  const t = await getTranslations("treasury.inflows");
+  const inflows = await loadTreasuryInflows(8);
+  // Rendered once per request on the server; the timestamp IS the snapshot.
+  // eslint-disable-next-line react-hooks/purity -- server component, render-time clock read for relative ages
+  const now = Date.now();
+
+  return (
+    <Card className="gap-2">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2 text-sm font-medium">
+          <ArrowDownLeft className="size-4 text-emerald-500" />
+          {t("title")}
+        </CardTitle>
+      </CardHeader>
+      <CardContent>
+        {inflows.length === 0 ? (
+          <p className="py-6 text-center text-sm text-muted-foreground">{t("empty")}</p>
+        ) : (
+          <ul className="divide-y divide-border">
+            {inflows.map((flow) => (
+              <li key={flow.hash} className="flex items-center gap-3 py-2.5">
+                <div className="flex min-w-0 flex-1 items-center gap-2">
+                  <AddressDisplay
+                    address={flow.from}
+                    variant="compact"
+                    showCopy={false}
+                    showExplorer={false}
+                    truncateLength={4}
+                  />
+                  {flow.internal ? (
+                    <span
+                      className="inline-flex shrink-0 items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-[10px] font-medium text-muted-foreground"
+                      title={t("auctionHint")}
+                    >
+                      <Gavel className="size-3" />
+                      {t("auction")}
+                    </span>
+                  ) : null}
+                </div>
+
+                <span className="shrink-0 whitespace-nowrap font-mono text-sm font-semibold tabular-nums">
+                  +{formatAmount(flow.amount, flow.asset, locale)}{" "}
+                  <span className={ASSET_TONE[flow.asset]}>{flow.asset}</span>
+                </span>
+
+                <span className="w-9 shrink-0 text-right font-mono text-[11px] text-muted-foreground">
+                  {ageLabel(flow.at, now)}
+                </span>
+
+                <a
+                  href={`https://basescan.org/tx/${flow.hash}`}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  aria-label={t("viewTx")}
+                  className="shrink-0 text-muted-foreground hover:text-foreground"
+                >
+                  <ExternalLink className="size-3.5" />
+                </a>
+              </li>
+            ))}
+          </ul>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

src/services/treasury-inflows.ts

@@ -0,0 +1,117 @@
+import { cache } from "react";
+import { DAO_ADDRESSES, TREASURY_TOKEN_ALLOWLIST } from "@/lib/config";
+
+/**
+ * Recent value arriving at the treasury.
+ *
+ * Three transfer categories are needed, not the two you would reach for:
+ *
+ * - `erc20`     — USDC and WETH.
+ * - `external`  — someone sending ETH straight from a wallet. Rare; the last
+ *                 one landed in February 2025.
+ * - `internal`  — **where auction proceeds actually arrive.** Settlement is a
+ *                 contract-to-contract move from the auction house, which is
+ *                 invisible to `external`. Querying only `external` + `erc20`
+ *                 reports no ETH income for over a year and misses the DAO's
+ *                 primary revenue entirely.
+ */
+
+const USDC = TREASURY_TOKEN_ALLOWLIST.USDC.toLowerCase();
+const WETH = TREASURY_TOKEN_ALLOWLIST.WETH.toLowerCase();
+
+/** Assets this panel reports. Everything else the treasury receives is noise here. */
+const TRACKED = new Set([USDC, WETH]);
+
+export type InflowAsset = "ETH" | "WETH" | "USDC";
+
+export interface TreasuryInflow {
+  /** Transaction hash — unique per row for keying and for the explorer link. */
+  hash: string;
+  asset: InflowAsset;
+  /** Human units, already scaled by the asset's decimals. */
+  amount: number;
+  from: string;
+  /** ISO timestamp of the containing block. */
+  at: string;
+  /** True when the value arrived contract-to-contract (auction settlement). */
+  internal: boolean;
+}
+
+interface AlchemyTransfer {
+  hash?: string;
+  from?: string;
+  value?: number | null;
+  asset?: string | null;
+  category?: string;
+  rawContract?: { address?: string | null };
+  metadata?: { blockTimestamp?: string };
+}
+
+const ALCHEMY_KEY = process.env.ALCHEMY_API_KEY;
+
+/**
+ * Newest inflows first.
+ *
+ * Returns `[]` rather than throwing on any failure: this renders inside the
+ * treasury page, and a Goldsky/Alchemy hiccup should cost one panel, not the
+ * whole route.
+ */
+export const loadTreasuryInflows = cache(async (limit = 8): Promise<TreasuryInflow[]> => {
+  if (!ALCHEMY_KEY) return [];
+
+  try {
+    const res = await fetch(`https://base-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "alchemy_getAssetTransfers",
+        params: [
+          {
+            fromBlock: "0x0",
+            toBlock: "latest",
+            toAddress: DAO_ADDRESSES.treasury,
+            category: ["external", "internal", "erc20"],
+            withMetadata: true,
+            excludeZeroValue: true,
+            // Over-fetch: the window is filtered down to three assets, and a
+            // burst of one token would otherwise crowd out everything else.
+            maxCount: "0x32",
+            order: "desc",
+          },
+        ],
+      }),
+      next: { revalidate: 300 },
+    });
+    if (!res.ok) return [];
+
+    const json = (await res.json()) as { result?: { transfers?: AlchemyTransfer[] } };
+
+    return (json.result?.transfers ?? [])
+      .flatMap<TreasuryInflow>((t) => {
+        const amount = typeof t.value === "number" ? t.value : 0;
+        if (!t.hash || !t.from || amount <= 0) return [];
+
+        const contract = t.rawContract?.address?.toLowerCase();
+        const isNative = t.category === "external" || t.category === "internal";
+        if (!isNative && (!contract || !TRACKED.has(contract))) return [];
+
+        const asset: InflowAsset = isNative ? "ETH" : contract === USDC ? "USDC" : "WETH";
+
+        return [
+          {
+            hash: t.hash,
+            asset,
+            amount,
+            from: t.from,
+            at: t.metadata?.blockTimestamp ?? "",
+            internal: t.category === "internal",
+          },
+        ];
+      })
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+});