@logswap/sdk 0.5.75 → 0.5.76

package/dist/views.js

@@ -0,0 +1,188 @@
+/**
+ * views.ts — the indexer's derived views (indexing phase 2, logswap-be `devnet/VIEWS.md`).
+ *
+ * The indexer records events and the snapshotter samples state; these views join the two in
+ * Postgres: holders, a wallet's positions and flows, per-swap volume and fee, price points and
+ * candles, TVL by the hour, the pools table's 24 h / 7 d figures, the generation steps and pad
+ * status, protocol revenue by day, and who did each routed action. Each reader returns typed rows:
+ *
+ * - **amounts** (Postgres `numeric`, GraphQL BigFloat strings) as `bigint`. The views floor every
+ *   amount they compute, so the integer part is the value;
+ * - **prices, APYs, progress** (`double precision`) as `number`. `priceRaw` is quote wei per base
+ *   wei: scale by 10^(baseDecimals − quoteDecimals) to display;
+ * - **times** as unix seconds (`number`), **addresses** checksummed, pool ids lowercase `0x…`.
+ *
+ * A view is a cache like any indexed table: the readers throw when the indexer cannot answer, and
+ * the SDK functions that use them ({@link holdingsOf}, {@link swapFees}, {@link fPoolShareHolders})
+ * keep their node path as the fallback.
+ */
+import { getAddress } from "viem";
+import { gql } from "./indexer.js";
+const PAGE = 1000; // postgraphile's cap
+const MAX_PAGES = 200;
+const PARALLEL_PAGES = 8;
+/** Every row of a view, paged by offset (a view has no primary key to page a cursor on). */
+async function viewRows(url, field, type, selection, q) {
+    for (const o of q.orderBy ?? [])
+        if (!/^[A-Z0-9_]+$/.test(o))
+            throw new Error(`views: orderBy ${JSON.stringify(o)} is not an enum name`);
+    const hasCondition = q.condition !== undefined && Object.keys(q.condition).length > 0;
+    const hasFilter = q.filter !== undefined && Object.keys(q.filter).length > 0;
+    const pageSize = Math.min(q.first ?? PAGE, PAGE);
+    // postgraphile refuses a null or empty condition/filter: each appears only when it has content
+    const decl = `$offset: Int${hasCondition ? `, $condition: ${type}Condition` : ""}${hasFilter ? `, $filter: ${type}Filter` : ""}`;
+    const args = [
+        `first: ${pageSize}`,
+        "offset: $offset",
+        q.orderBy?.length ? `orderBy: [${q.orderBy.join(", ")}]` : "",
+        hasCondition ? "condition: $condition" : "",
+        hasFilter ? "filter: $filter" : "",
+    ].filter(Boolean).join(", ");
+    const query = `query View(${decl}) { ${field}(${args}) { totalCount nodes { ${selection} } } }`;
+    const page = async (offset) => (await gql(url, query, { offset, ...(hasCondition ? { condition: q.condition } : {}), ...(hasFilter ? { filter: q.filter } : {}) }, q.signal))[field];
+    const first = await page(0);
+    const rows = [...first.nodes];
+    if (q.first === undefined && first.totalCount > first.nodes.length) {
+        const pages = Math.ceil(first.totalCount / PAGE);
+        if (pages > MAX_PAGES)
+            throw new Error(`views: ${field} has more than ${PAGE * MAX_PAGES} rows; narrow the query`);
+        const offsets = Array.from({ length: pages - 1 }, (_, i) => (i + 1) * PAGE);
+        for (let i = 0; i < offsets.length; i += PARALLEL_PAGES) {
+            for (const g of await Promise.all(offsets.slice(i, i + PARALLEL_PAGES).map(page)))
+                rows.push(...g.nodes);
+        }
+    }
+    else if (q.first !== undefined && q.first > PAGE) {
+        // a cap above one page: the next pages up to it
+        for (let offset = PAGE; offset < Math.min(q.first, first.totalCount); offset += PAGE)
+            rows.push(...(await page(offset)).nodes);
+        rows.length = Math.min(rows.length, q.first);
+    }
+    return rows;
+}
+// ─── column parsers ──────────────────────────────────────────────────────────
+/** A numeric / bigint column (BigFloat or BigInt string, or a number) → bigint; the integer part. */
+function big(v) {
+    if (typeof v === "bigint")
+        return v;
+    if (typeof v === "number")
+        return BigInt(Math.trunc(v));
+    if (typeof v !== "string" || v === "")
+        throw new Error(`views: not a number: ${JSON.stringify(v)}`);
+    return BigInt(v.split(".")[0]);
+}
+const bigOr = (v) => (v === null || v === undefined ? null : big(v));
+const num = (v) => Number(v);
+const numOr = (v) => (v === null || v === undefined ? null : Number(v));
+const intOr = (v) => (v === null || v === undefined ? null : Number(v));
+const addr = (v) => getAddress(String(v));
+const addrOr = (v) => (v === null || v === undefined ? null : getAddress(String(v)));
+const secs = (v) => Date.parse(String(v)) / 1000;
+const secsOr = (v) => (v === null || v === undefined ? null : secs(v));
+const hex = (v) => String(v).toLowerCase();
+const addrs = (v) => (v ?? []).map(addr);
+export async function poolDirectory(url, q = {}) {
+    const rows = await viewRows(url, "allPoolDirectories", "PoolDirectory", "side poolId manager kind quote bases swapFee tickSpacing policy creator birthBlock birthTime shareKey", q);
+    return rows.map((r) => ({
+        side: r.side, poolId: hex(r.poolId), manager: addr(r.manager), kind: String(r.kind), quote: addr(r.quote), bases: addrs(r.bases),
+        swapFee: big(r.swapFee), tickSpacing: bigOr(r.tickSpacing), policy: addrOr(r.policy), creator: addrOr(r.creator),
+        birthBlock: big(r.birthBlock), birthTime: secs(r.birthTime), shareKey: bigOr(r.shareKey),
+    }));
+}
+export async function eventUsers(url, q = {}) {
+    const rows = await viewRows(url, "allEventUsers", "EventUser", "side event poolId actor viaRouter user txHash logIndex blockNumber blockTimestamp manager", q);
+    return rows.map((r) => ({
+        side: r.side, event: String(r.event), poolId: hex(r.poolId), actor: addr(r.actor), viaRouter: Boolean(r.viaRouter), user: addr(r.user),
+        txHash: hex(r.txHash), logIndex: num(r.logIndex), blockNumber: big(r.blockNumber), blockTimestamp: secs(r.blockTimestamp), manager: addr(r.manager),
+    }));
+}
+export async function poolHolders(url, q = {}) {
+    const rows = await viewRows(url, "allPoolHolders", "PoolHolder", "side manager id poolId gen floor cap capped holder balance isBackstop isDead", q);
+    return rows.map((r) => ({
+        side: r.side, manager: addr(r.manager), id: big(r.id), poolId: r.poolId == null ? null : hex(r.poolId), gen: intOr(r.gen),
+        floor: bigOr(r.floor), cap: bigOr(r.cap), capped: r.capped == null ? null : Boolean(r.capped),
+        holder: addr(r.holder), balance: big(r.balance), isBackstop: Boolean(r.isBackstop), isDead: Boolean(r.isDead),
+    }));
+}
+export async function walletPositions(url, q = {}) {
+    const rows = await viewRows(url, "allWalletPositions", "WalletPosition", "side manager wallet poolId kind quote bases id gen floor cap capped shares valueQuote status valuedAtBlock", q);
+    return rows.map((r) => ({
+        side: r.side, manager: addr(r.manager), wallet: addr(r.wallet), poolId: r.poolId == null ? null : hex(r.poolId), kind: r.kind == null ? null : String(r.kind),
+        quote: addrOr(r.quote), bases: addrs(r.bases), id: big(r.id), gen: intOr(r.gen), floor: bigOr(r.floor), cap: bigOr(r.cap),
+        capped: r.capped == null ? null : Boolean(r.capped), shares: big(r.shares), valueQuote: bigOr(r.valueQuote), status: String(r.status), valuedAtBlock: bigOr(r.valuedAtBlock),
+    }));
+}
+export async function walletPoolFlows(url, q = {}) {
+    const rows = await viewRows(url, "allWalletPoolFlows", "WalletPoolFlow", "side manager wallet poolId baseIn quoteIn baseOut quoteOut feesRealised dividendsClaimed redeemedQuote entries exits firstTime lastTime", q);
+    return rows.map((r) => ({
+        side: r.side, manager: addr(r.manager), wallet: addr(r.wallet), poolId: hex(r.poolId),
+        baseIn: big(r.baseIn), quoteIn: big(r.quoteIn), baseOut: big(r.baseOut), quoteOut: big(r.quoteOut),
+        feesRealised: big(r.feesRealised), dividendsClaimed: big(r.dividendsClaimed), redeemedQuote: big(r.redeemedQuote),
+        entries: num(r.entries), exits: num(r.exits), firstTime: secs(r.firstTime), lastTime: secs(r.lastTime),
+    }));
+}
+export async function swapFlows(url, q = {}) {
+    const rows = await viewRows(url, "allSwapFlows", "SwapFlow", "side manager poolId txHash logIndex blockNumber blockTimestamp volumeQuote feeQuote tokenIn tokenOut reserveIn reserveOut lIn lOut", q);
+    return rows.map((r) => ({
+        side: r.side, manager: addr(r.manager), poolId: hex(r.poolId), txHash: hex(r.txHash), logIndex: num(r.logIndex),
+        blockNumber: big(r.blockNumber), blockTimestamp: secs(r.blockTimestamp), volumeQuote: big(r.volumeQuote), feeQuote: big(r.feeQuote),
+        tokenIn: addrOr(r.tokenIn), tokenOut: addrOr(r.tokenOut), reserveIn: bigOr(r.reserveIn), reserveOut: bigOr(r.reserveOut), lIn: bigOr(r.lIn), lOut: bigOr(r.lOut),
+    }));
+}
+export async function priceTicks(url, q = {}) {
+    const rows = await viewRows(url, "allPriceTicks", "PriceTick", "side poolId base blockNumber blockTimestamp logIndex priceRaw volumeQuote feeQuote", q);
+    return rows.map((r) => ({
+        side: r.side, poolId: hex(r.poolId), base: addr(r.base), blockNumber: big(r.blockNumber), blockTimestamp: secs(r.blockTimestamp),
+        logIndex: num(r.logIndex), priceRaw: num(r.priceRaw), volumeQuote: big(r.volumeQuote), feeQuote: big(r.feeQuote),
+    }));
+}
+const CANDLE = { minute: ["allCandleMinutes", "CandleMinute"], hour: ["allCandleHours", "CandleHour"], day: ["allCandleDays", "CandleDay"] };
+export async function candles(url, interval, q = {}) {
+    const [field, type] = CANDLE[interval];
+    const rows = await viewRows(url, field, type, "side poolId base bucket open high low close volumeQuote feeQuote swaps", q);
+    return rows.map((r) => ({
+        side: r.side, poolId: hex(r.poolId), base: addr(r.base), bucket: secs(r.bucket), open: num(r.open), high: num(r.high), low: num(r.low), close: num(r.close),
+        volumeQuote: big(r.volumeQuote), feeQuote: big(r.feeQuote), swaps: num(r.swaps),
+    }));
+}
+export async function poolTvlHours(url, q = {}) {
+    const rows = await viewRows(url, "allPoolTvlHours", "PoolTvlHour", "side poolId bucket blockNumber tvlQuote liquidity priceRaw feeGrowth shareValue gen", q);
+    return rows.map((r) => ({
+        side: r.side, poolId: hex(r.poolId), bucket: secs(r.bucket), blockNumber: big(r.blockNumber), tvlQuote: bigOr(r.tvlQuote),
+        liquidity: bigOr(r.liquidity), priceRaw: numOr(r.priceRaw), feeGrowth: bigOr(r.feeGrowth), shareValue: bigOr(r.shareValue), gen: intOr(r.gen),
+    }));
+}
+export async function poolSummaries(url, q = {}) {
+    const rows = await viewRows(url, "allPoolSummaries", "PoolSummary", "side poolId kind quote bases swapFee birthTime volume24H fees24H swaps24H volume7D fees7D volumeAll feesAll lastSwap tvlQuote liquidity priceRaw shareValue gen stateBlock seconds24H seconds7D apy24H apy7D", q);
+    return rows.map((r) => ({
+        side: r.side, poolId: hex(r.poolId), kind: String(r.kind), quote: addr(r.quote), bases: addrs(r.bases), swapFee: big(r.swapFee), birthTime: secs(r.birthTime),
+        volume24h: big(r.volume24H), fees24h: big(r.fees24H), swaps24h: num(r.swaps24H), volume7d: big(r.volume7D), fees7d: big(r.fees7D),
+        volumeAll: big(r.volumeAll), feesAll: big(r.feesAll), lastSwap: secsOr(r.lastSwap), tvlQuote: bigOr(r.tvlQuote), liquidity: bigOr(r.liquidity),
+        priceRaw: numOr(r.priceRaw), shareValue: bigOr(r.shareValue), gen: intOr(r.gen), stateBlock: bigOr(r.stateBlock),
+        seconds24h: num(r.seconds24H), seconds7d: num(r.seconds7D), apy24h: numOr(r.apy24H), apy7d: numOr(r.apy7D),
+    }));
+}
+export async function generationSteps(url, q = {}) {
+    const rows = await viewRows(url, "allGenerationSteps", "GenerationStep", "kind poolId genAfter pot payee toPayee cut burnt deepened rung txHash blockNumber blockTimestamp", q);
+    return rows.map((r) => ({
+        kind: r.kind == null ? null : String(r.kind), poolId: hex(r.poolId), genAfter: num(r.genAfter), pot: big(r.pot), payee: addr(r.payee),
+        toPayee: big(r.toPayee), cut: big(r.cut), burnt: big(r.burnt), deepened: big(r.deepened), rung: intOr(r.rung),
+        txHash: hex(r.txHash), blockNumber: big(r.blockNumber), blockTimestamp: secs(r.blockTimestamp),
+    }));
+}
+export async function padStatuses(url, q = {}) {
+    const rows = await viewRows(url, "allPadStatuses", "PadStatus", "kind poolId quote bases creator birthTime gen pot unharvested l q tvlQuote shareValue threshold progress stateBlock stateTime steps burntTotal cutTotal paidTotal deepenedTotal lastStep", q);
+    return rows.map((r) => ({
+        kind: String(r.kind), poolId: hex(r.poolId), quote: addr(r.quote), bases: addrs(r.bases), creator: addrOr(r.creator), birthTime: secs(r.birthTime),
+        gen: intOr(r.gen), pot: bigOr(r.pot), unharvested: bigOr(r.unharvested), l: bigOr(r.l), q: bigOr(r.q), tvlQuote: bigOr(r.tvlQuote),
+        shareValue: bigOr(r.shareValue), threshold: bigOr(r.threshold), progress: numOr(r.progress), stateBlock: bigOr(r.stateBlock), stateTime: secsOr(r.stateTime),
+        steps: num(r.steps), burntTotal: big(r.burntTotal), cutTotal: big(r.cutTotal), paidTotal: big(r.paidTotal), deepenedTotal: big(r.deepenedTotal), lastStep: secsOr(r.lastStep),
+    }));
+}
+export async function protocolRevenueDays(url, q = {}) {
+    const rows = await viewRows(url, "allProtocolRevenueDays", "ProtocolRevenueDay", "day side source basis token amount amountQuote events", q);
+    return rows.map((r) => ({
+        day: secs(r.day), side: r.side, source: String(r.source), basis: r.basis, token: addr(r.token),
+        amount: big(r.amount), amountQuote: big(r.amountQuote), events: num(r.events),
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logswap/sdk",
-  "version": "0.5.75",
+  "version": "0.5.76",
   "description": "TypeScript SDK for Logswap, the liquidity primitive introducing the logarithmic invariant — typed wrappers over the CPoolManager / FPoolManager / Router / Lens surface.",
   "license": "GPL-2.0-or-later",
   "type": "module",

package/src/fees.ts

@@ -15,6 +15,22 @@ import type { LogswapClient } from "./client.js";
 import { cPoolManagerAbi } from "./generated.js";
 import type { DiscoveredMarket } from "./pools.js";
 import { getEventLogs } from "./history.js";
+import { swapFlows } from "./views.js";
+
+/** A C market's swap fees over [fromBlock, toBlock] from the indexer's swap_flow view; null when the indexer cannot answer. */
+async function windowFromView(c: LogswapClient, indexer: string, poolId: string, fromBlock: bigint, toBlock: bigint): Promise<{ fees: bigint; swaps: number } | null> {
+  try {
+    const rows = await swapFlows(indexer, {
+      condition: { side: "C", poolId: poolId.toLowerCase(), manager: c.addresses.cPoolManager.toLowerCase() },
+      filter: { blockNumber: { greaterThanOrEqualTo: fromBlock.toString(), lessThanOrEqualTo: toBlock.toString() } },
+    });
+    let fees = 0n;
+    for (const r of rows) fees += r.feeQuote;
+    return { fees, swaps: rows.length };
+  } catch {
+    return null; // the view is a cache: the Swap rows answer the same
+  }
+}
 
 const WAD = 10n ** 18n;
 const YEAR_SECONDS = 31_536_000;
@@ -86,7 +102,7 @@ export async function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint, hi
 export async function swapFees(
   c: LogswapClient,
   m: DiscoveredMarket,
-  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint; /** The rindexer GraphQL endpoint: the Swap rows from there, the node otherwise. */ indexer?: string } = {},
+  opts: { since?: bigint; fromBlock?: bigint; toBlock?: bigint; /** The rindexer GraphQL endpoint: the window from its swap_flow view (the Swap rows as fallback), the node otherwise. */ indexer?: string } = {},
 ): Promise<SwapFeeWindow> {
   const toBlock = opts.toBlock ?? (await c.public.getBlockNumber());
   const [opened, last] = await Promise.all([
@@ -111,16 +127,21 @@ export async function swapFees(
   const ev = cPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "Swap");
   if (!ev) throw new Error("logswap: Swap event missing from the generated ABI");
 
-  const logs = fromBlock > toBlock
-    ? []
-    : (await getEventLogs<{ fee: bigint }>(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock })).logs;
-
-  // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ
+  // the event carries the fee the swap charged (decisions 050), exactly — no re-derivation from φ;
+  // the indexer's swap_flow view carries the same figure per swap (`feeQuote`, C)
   let fees = 0n;
-  for (const l of logs) fees += l.args.fee;
+  let swaps = 0;
+  const viewed = fromBlock > toBlock || !opts.indexer ? null : await windowFromView(c, opts.indexer, m.poolId, fromBlock, toBlock);
+  if (viewed) {
+    ({ fees, swaps } = viewed);
+  } else if (fromBlock <= toBlock) {
+    const { logs } = await getEventLogs<{ fee: bigint }>(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ev, args: { poolId: m.poolId }, fromBlock, toBlock });
+    for (const l of logs) fees += l.args.fee;
+    swaps = logs.length;
+  }
 
   const to = last.timestamp;
-  return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps: logs.length };
+  return { fromBlock, toBlock, from, to, seconds: to > from ? to - from : 0n, swapFees: fees, swaps };
 }
 
 /**

package/src/fpool.ts

@@ -50,6 +50,7 @@ export const fPolicyBaseAbi = polPolicyAbi;
 import type { LogswapClient } from "./client.js";
 import { fallBackUnlessRejected, signerFor } from "./write.js";
 import { getEventLogs } from "./history.js";
+import { poolHolders } from "./views.js";
 import { presetMintFee } from "./positions.js";
 
 const WAD = 10n ** 18n;
@@ -2016,7 +2017,7 @@ export async function fPoolsControlledBy(
 /**
  * Every holder of a pool's shares, from the ERC-6909 Transfer stream — the id is an indexed
  * topic, so one filtered log query aggregates the whole ledger. The 0xdead entry is the
- * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: a node
+ * MIN_SHARES lock from seeding; callers usually label rather than hide it. Pass `indexer`: the indexer's `pool_holder` view answers directly (the Transfer replay is the fallback) — a node
  * prunes its logs (anvil keeps about a day), and a ledger rebuilt from a pruned stream loses every
  * holder minted before the cut.
  */
@@ -2028,7 +2029,19 @@ export async function fPoolShareHolders(
   type Ev = Extract<(typeof fPoolManagerAbi)[number], { type: "event"; name: "Transfer" }>;
   const ev = fPoolManagerAbi.find((x): x is Ev => x.type === "event" && x.name === "Transfer");
   if (!ev) throw new Error("logswap: 6909 Transfer event missing from the generated ABI");
-  const id = fPoolShareId(poolIdHex, opts.gen ?? (await fPoolGen(c, poolIdHex)));
+  const gen = opts.gen ?? (await fPoolGen(c, poolIdHex));
+  if (opts.indexer) {
+    try {
+      const rows = await poolHolders(opts.indexer, { condition: { side: "F", poolId: poolIdHex.toLowerCase(), gen: Number(gen), manager: c.addresses.fPoolManager!.toLowerCase() } });
+      return rows
+        .filter((r) => r.balance > 0n)
+        .map((r) => ({ holder: r.holder, shares: r.balance }))
+        .sort((a, b) => (b.shares > a.shares ? 1 : -1));
+    } catch {
+      /* the view is a cache: the Transfer replay below answers the same */
+    }
+  }
+  const id = fPoolShareId(poolIdHex, gen);
   const { logs } = await getEventLogs(c, { indexer: opts.indexer, address: c.addresses.fPoolManager!, event: ev, args: { id }, fromBlock: opts.fromBlock });
   const bal = new Map<string, bigint>();
   for (const l of logs) {

package/src/index.ts

@@ -21,5 +21,6 @@ export * from "./tokencache.js";
 export * from "./fpool.js";
 export * from "./fees.js";
 export * from "./history.js";
+export * from "./views.js";
 export { cPoolManagerAbi, fPoolManagerAbi, logswapLensAbi, logswapRouterAbi, padPolicyAbi, polPolicyAbi, policyRegistryAbi, privatePolicyAbi, publicPolicyAbi } from "./generated.js";
 export * from "./admin.js";

package/src/positions.ts

@@ -17,6 +17,7 @@ const C_POSITIONS_SLOT = 4n;
 const U128 = (1n << 128n) - 1n;
 import { isPosition, NO_CAP, positionId, unpackFloorCap } from "./ids.js";
 import { getEventLogs } from "./history.js";
+import { poolHolders } from "./views.js";
 
 /** A class's aggregate state — the whole class, not one holder's slice. */
 export interface PositionClass {
@@ -263,6 +264,22 @@ export async function positionsOf(c: LogswapClient, key: PoolKey, owner: Address
 
 const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes32 indexed poolId, int256 floor, int256 cap, bool capped)");
 
+/** The class ids `owner` holds in `pool`, from the indexer's `pool_holder` view; null when the indexer cannot answer. */
+async function heldIdsFromView(c: LogswapClient, indexer: string, pool: Hex, owner: Address): Promise<bigint[] | null> {
+  try {
+    const rows = await poolHolders(indexer, { condition: { side: "C", poolId: pool.toLowerCase(), holder: owner.toLowerCase(), manager: c.addresses.cPoolManager.toLowerCase() } });
+    return rows.filter((r) => r.balance > 0n && !r.isBackstop).map((r) => r.id);
+  } catch {
+    return null; // the view is a cache: the IdRegistered replay below answers the same
+  }
+}
+
+/** Every class id ever registered in `pool` (`IdRegistered`), from the indexer's table or the node. */
+async function registeredIds(c: LogswapClient, pool: Hex, fromBlock: bigint, indexer?: string): Promise<bigint[]> {
+  const { logs } = await getEventLogs<{ id?: bigint }>(c, { indexer, address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock });
+  return logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
+}
+
 /**
  * EVERY class this owner holds in a pool, capped ones included — the complete book.
  *
@@ -273,10 +290,9 @@ const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes
  * holder's slice is L · shares_owner / shares_class, and fees from the lens. One log query plus
  * a read per registered class; fine for a pool's lifetime of classes.
  */
-export async function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock: bigint = 0n, opts: { /** The rindexer GraphQL endpoint: the class registry from there, the node otherwise. */ indexer?: string } = {}): Promise<HeldPositionRow[]> {
+export async function holdingsOf(c: LogswapClient, key: PoolKey, owner: Address, fromBlock: bigint = 0n, opts: { /** The rindexer GraphQL endpoint: the owner's held ids from its `pool_holder` view (the class registry as fallback), the node otherwise. */ indexer?: string } = {}): Promise<HeldPositionRow[]> {
   const pool = poolId(key);
-  const { logs } = await getEventLogs<{ id?: bigint }>(c, { indexer: opts.indexer, address: c.addresses.cPoolManager, event: ID_REGISTERED, args: { poolId: pool }, fromBlock });
-  const ids = logs.map((l) => l.args.id ?? 0n).filter((id) => id !== 0n);
+  const ids = (opts.indexer ? await heldIdsFromView(c, opts.indexer, pool, owner) : null) ?? (await registeredIds(c, pool, fromBlock, opts.indexer));
   if (ids.length === 0) return [];
   // one lens call: balance, class L, fees, floor and cap for every id the owner holds
   const rows = (await c.public.readContract({