@logswap/sdk 0.5.75 → 0.5.76

package/README.md

@@ -84,6 +84,38 @@ answers only partly.
   shared tables with `contract: indexedContractOf(kind, event)` (or `kind` on `getEventsLogs`).
 - `tokensCreated` lists the factory's tokens (`addresses.tokenFactory`): the token list's provenance.
 
+## Indexer views (indexing phase 2)
+
+The indexer also serves derived views (logswap-be `devnet/VIEWS.md`), joining its event tables with
+the snapshotter's state. `views.ts` reads each as typed rows: amounts as `bigint`, prices, APYs and
+progress as `number`, times as unix seconds. Every reader takes the GraphQL endpoint and a
+`{ condition, filter, orderBy, first, signal }` query, and pages by offset.
+
+| Reader | View | What a row is |
+| --- | --- | --- |
+| `poolDirectory` | `allPoolDirectories` | a pool of either manager, its kind and birth |
+| `eventUsers` | `allEventUsers` | a manager event and who did it (the router's caller when routed) |
+| `poolHolders` | `allPoolHolders` | a current ERC-6909 balance, with C's backstop and F's dead shares flagged |
+| `walletPositions` | `allWalletPositions` | a wallet's holding; F valued at the latest share value |
+| `walletPoolFlows` | `allWalletPoolFlows` | a wallet's in/out, fees and dividends per pool |
+| `swapFlows` | `allSwapFlows` | a swap's volume and fee in quote |
+| `priceTicks` | `allPriceTicks` | a price point per (pool, base) |
+| `candles(url, "minute" \| "hour" \| "day")` | `allCandle…s` | OHLC with volume and fees |
+| `poolTvlHours` | `allPoolTvlHours` | the hour's last snapshot: TVL, liquidity |
+| `poolSummaries` | `allPoolSummaries` | 24 h / 7 d volume, fees, APY; latest TVL |
+| `generationSteps` | `allGenerationSteps` | a `regenerate` step and its pot split |
+| `padStatuses` | `allPadStatuses` | each pad and POL now, with the next threshold and progress |
+| `protocolRevenueDays` | `allProtocolRevenueDays` | protocol revenue per day and source |
+
+Given an `indexer`, three functions now take their figure from a view and keep their previous path
+as the fallback, with the same answer on the same data:
+- `holdingsOf`: the owner's held class ids from `pool_holder`, then the lens as before;
+- `fPoolShareHolders`: the holders from `pool_holder`;
+- `swapFees`: the window from `swap_flow`.
+
+What stays a live read: a C position's value and every unclaimed fee or dividend (the lens: `legsOf`,
+`heldByIds`, `fDividendOf`). They accrue without events, so no view holds them.
+
 ## Capped F pools and the lien (F version 25)
 
 - **The cap** (decisions 061) is a key field: `FPoolKey.cap` / `FPoolCreateArgs.cap`, d =

package/dist/fees.d.ts

@@ -55,7 +55,7 @@ export declare function blockAtOrAfter(c: LogswapClient, t: bigint, lo: bigint,
 export declare 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. */
+    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>;
 /**

package/dist/fees.js

@@ -12,6 +12,23 @@
  */
 import { cPoolManagerAbi } from "./generated.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, indexer, poolId, fromBlock, toBlock) {
+    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;
 /**
@@ -88,15 +105,22 @@ export async function swapFees(c, m, opts = {}) {
     const ev = cPoolManagerAbi.find((x) => 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(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(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 };
 }
 /**
  * The window's swap fees over the market's CURRENT active L, annualised linearly over the window.

package/dist/fpool.d.ts

@@ -1914,7 +1914,7 @@ export declare function fPoolsControlledBy(c: LogswapClient, who: Address, opts?
 /**
  * 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.
  */

package/dist/fpool.js

@@ -47,6 +47,7 @@ export { fPoolManagerAbi, padPolicyAbi, polPolicyAbi, privatePolicyAbi, publicPo
 export const fPolicyBaseAbi = polPolicyAbi;
 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;
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -1422,7 +1423,7 @@ export async function fPoolsControlledBy(c, who, opts = {}) {
 /**
  * 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.
  */
@@ -1430,7 +1431,20 @@ export async function fPoolShareHolders(c, poolIdHex, opts = {}) {
     const ev = fPoolManagerAbi.find((x) => 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();
     for (const l of logs) {

package/dist/index.d.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/dist/index.js

@@ -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/dist/positions.js

@@ -13,6 +13,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, read through `extsload` (C version 7: the manager's public
  * `positions` mapping is gone behind it, decisions 065). The slot is `CPoolState`'s:
@@ -182,6 +183,21 @@ export async function positionsOf(c, key, owner) {
     return rows.map((r) => ({ id: r.id, floor: r.floor, cap: NO_CAP, capped: false, shares: r.shares, L: r.L, fees: r.fees }));
 }
 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, indexer, pool, owner) {
+    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, pool, fromBlock, indexer) {
+    const { logs } = await getEventLogs(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.
  *
@@ -194,8 +210,7 @@ const ID_REGISTERED = parseAbiItem("event IdRegistered(uint256 indexed id, bytes
  */
 export async function holdingsOf(c, key, owner, fromBlock = 0n, opts = {}) {
     const pool = poolId(key);
-    const { logs } = await getEventLogs(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

package/dist/views.d.ts

@@ -0,0 +1,285 @@
+/**
+ * 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 { type Address, type Hex } from "viem";
+/** What a view query takes: postgraphile's `condition` (equality), `filter` (the connection-filter plugin's operators), an `orderBy` of the view's enum names, a row cap. */
+export interface ViewQuery {
+    condition?: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+    /** e.g. `["BLOCK_NUMBER_ASC"]`, `["VOLUME_24H_DESC"]`: the column's CONSTANT_CASE name and a direction. */
+    orderBy?: string[];
+    /** At most this many rows (one page up to 1000). All rows when omitted. */
+    first?: number;
+    signal?: AbortSignal;
+}
+export type Side = "C" | "F";
+/** A pool of either manager: C markets are kind `market`; F pools carry their policy's registry name (`public`, `private`, `pol`, `pad`). */
+export interface PoolDirectoryRow {
+    side: Side;
+    poolId: Hex;
+    manager: Address;
+    kind: string;
+    quote: Address;
+    bases: Address[];
+    swapFee: bigint;
+    /** C only. */
+    tickSpacing: bigint | null;
+    /** F only. */
+    policy: Address | null;
+    creator: Address | null;
+    birthBlock: bigint;
+    birthTime: number;
+    /** F only: the pool's share-id key (the id's bits above the generation). */
+    shareKey: bigint | null;
+}
+export declare function poolDirectory(url: string, q?: ViewQuery): Promise<PoolDirectoryRow[]>;
+/** A manager event and who did it: the router's caller when the transaction went through the router (`viaRouter`), else the address the event names (`actor`). */
+export interface EventUserRow {
+    side: Side;
+    /** `Swap` `Mint` `Burn` `Update` `Claim` (C); `FSwap` `FMint` `FBurn` `Harvest` `DividendClaimed` `Redeem` (F). */
+    event: string;
+    poolId: Hex;
+    actor: Address;
+    viaRouter: boolean;
+    user: Address;
+    txHash: Hex;
+    logIndex: number;
+    blockNumber: bigint;
+    blockTimestamp: number;
+    manager: Address;
+}
+export declare function eventUsers(url: string, q?: ViewQuery): Promise<EventUserRow[]>;
+/** A current ERC-6909 balance: C ids resolve to their class (floor, cap), F ids to their pool and generation. C's backstop lock is held by address(0) (`isBackstop`), F's dead shares by 0xdead (`isDead`). */
+export interface PoolHolderRow {
+    side: Side;
+    manager: Address;
+    id: bigint;
+    poolId: Hex | null;
+    /** F only. */
+    gen: number | null;
+    /** C only. */
+    floor: bigint | null;
+    cap: bigint | null;
+    capped: boolean | null;
+    holder: Address;
+    balance: bigint;
+    isBackstop: boolean;
+    isDead: boolean;
+}
+export declare function poolHolders(url: string, q?: ViewQuery): Promise<PoolHolderRow[]>;
+/** A wallet's holding (backstop and dead excluded). `valueQuote`: an F share of the live generation at the latest snapshot's share value, a retired one at its bundle's quote per share; NULL for C (a lens read: {@link legsOf}). */
+export interface WalletPositionRow {
+    side: Side;
+    manager: Address;
+    wallet: Address;
+    poolId: Hex | null;
+    kind: string | null;
+    quote: Address | null;
+    bases: Address[];
+    id: bigint;
+    gen: number | null;
+    floor: bigint | null;
+    cap: bigint | null;
+    capped: boolean | null;
+    shares: bigint;
+    valueQuote: bigint | null;
+    /** `live` / `retired` / `unknown` (F), `class` (C). */
+    status: string;
+    valuedAtBlock: bigint | null;
+}
+export declare function walletPositions(url: string, q?: ViewQuery): Promise<WalletPositionRow[]>;
+/** A wallet's flows in a pool, from its own events: what it put in and took out, fees and dividends realised. F mints and burns carry the quote leg only. C `Update` is not counted (it repeats its Burn and Mint). */
+export interface WalletPoolFlowRow {
+    side: Side;
+    manager: Address;
+    wallet: Address;
+    poolId: Hex;
+    baseIn: bigint;
+    quoteIn: bigint;
+    baseOut: bigint;
+    quoteOut: bigint;
+    feesRealised: bigint;
+    dividendsClaimed: bigint;
+    redeemedQuote: bigint;
+    entries: number;
+    exits: number;
+    firstTime: number;
+    lastTime: number;
+}
+export declare function walletPoolFlows(url: string, q?: ViewQuery): Promise<WalletPoolFlowRow[]>;
+/** A swap's volume and fee in quote, the app's definitions (C: the quote leg and the event's fee; F: see VIEWS.md). F rows carry the traded legs and their L_j = w_j·L. */
+export interface SwapFlowRow {
+    side: Side;
+    manager: Address;
+    poolId: Hex;
+    txHash: Hex;
+    logIndex: number;
+    blockNumber: bigint;
+    blockTimestamp: number;
+    volumeQuote: bigint;
+    feeQuote: bigint;
+    tokenIn: Address | null;
+    tokenOut: Address | null;
+    reserveIn: bigint | null;
+    reserveOut: bigint | null;
+    lIn: bigint | null;
+    lOut: bigint | null;
+}
+export declare function swapFlows(url: string, q?: ViewQuery): Promise<SwapFlowRow[]>;
+/** A price point per (pool, base) after a swap: C e^newX, F the traded leg's mark L_j / R_j. Quote wei per base wei. */
+export interface PriceTickRow {
+    side: Side;
+    poolId: Hex;
+    base: Address;
+    blockNumber: bigint;
+    blockTimestamp: number;
+    logIndex: number;
+    priceRaw: number;
+    volumeQuote: bigint;
+    feeQuote: bigint;
+}
+export declare function priceTicks(url: string, q?: ViewQuery): Promise<PriceTickRow[]>;
+/** OHLC per (pool, base, UTC bucket). A base → base F swap counts in both legs' candles; pool totals come from {@link poolSummaries}. */
+export interface CandleRow {
+    side: Side;
+    poolId: Hex;
+    base: Address;
+    /** Bucket start, unix seconds. */
+    bucket: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volumeQuote: bigint;
+    feeQuote: bigint;
+    swaps: number;
+}
+export type CandleInterval = "minute" | "hour" | "day";
+export declare function candles(url: string, interval: CandleInterval, q?: ViewQuery): Promise<CandleRow[]>;
+/** The hour's last snapshot per pool (forward-fill hours with none). `liquidity` is C's active L or F's L. */
+export interface PoolTvlHourRow {
+    side: Side;
+    poolId: Hex;
+    bucket: number;
+    blockNumber: bigint;
+    tvlQuote: bigint | null;
+    liquidity: bigint | null;
+    /** C only. */
+    priceRaw: number | null;
+    feeGrowth: bigint | null;
+    /** F only. */
+    shareValue: bigint | null;
+    gen: number | null;
+}
+export declare function poolTvlHours(url: string, q?: ViewQuery): Promise<PoolTvlHourRow[]>;
+/**
+ * A pool's trailing 24 h / 7 d figures and its latest state. APY, as the app shows it: the window's
+ * swap fees over the pool's current L, annualised over the window measured (clipped to the pool's
+ * birth) — `fees / L × 31 536 000 / seconds`; the same formula as {@link swapFeeApy}.
+ */
+export interface PoolSummaryRow {
+    side: Side;
+    poolId: Hex;
+    kind: string;
+    quote: Address;
+    bases: Address[];
+    swapFee: bigint;
+    birthTime: number;
+    volume24h: bigint;
+    fees24h: bigint;
+    swaps24h: number;
+    volume7d: bigint;
+    fees7d: bigint;
+    volumeAll: bigint;
+    feesAll: bigint;
+    lastSwap: number | null;
+    tvlQuote: bigint | null;
+    liquidity: bigint | null;
+    priceRaw: number | null;
+    shareValue: bigint | null;
+    gen: number | null;
+    stateBlock: bigint | null;
+    seconds24h: number;
+    seconds7d: number;
+    apy24h: number | null;
+    apy7d: number | null;
+}
+export declare function poolSummaries(url: string, q?: ViewQuery): Promise<PoolSummaryRow[]>;
+/** A `regenerate` step: the pot and its split (payee, the protocol's cut, the burn, the rest deepening the bid); a pad's `rung` from `Graduated`. */
+export interface GenerationStepRow {
+    kind: string | null;
+    poolId: Hex;
+    /** The pool's generation after this step. */
+    genAfter: number;
+    pot: bigint;
+    payee: Address;
+    toPayee: bigint;
+    cut: bigint;
+    burnt: bigint;
+    deepened: bigint;
+    rung: number | null;
+    txHash: Hex;
+    blockNumber: bigint;
+    blockTimestamp: number;
+}
+export declare function generationSteps(url: string, q?: ViewQuery): Promise<GenerationStepRow[]>;
+/** Every pad and POL now: the latest snapshot's state, the next graduation's threshold (pads) and the pot's progress to it, and the steps so far. */
+export interface PadStatusRow {
+    kind: string;
+    poolId: Hex;
+    quote: Address;
+    bases: Address[];
+    creator: Address | null;
+    birthTime: number;
+    gen: number | null;
+    pot: bigint | null;
+    unharvested: bigint | null;
+    l: bigint | null;
+    q: bigint | null;
+    tvlQuote: bigint | null;
+    shareValue: bigint | null;
+    threshold: bigint | null;
+    /** pot / threshold, a fraction; null without a threshold. */
+    progress: number | null;
+    stateBlock: bigint | null;
+    stateTime: number | null;
+    steps: number;
+    burntTotal: bigint;
+    cutTotal: bigint;
+    paidTotal: bigint;
+    deepenedTotal: bigint;
+    lastStep: number | null;
+}
+export declare function padStatuses(url: string, q?: ViewQuery): Promise<PadStatusRow[]>;
+/**
+ * Protocol revenue per UTC day, side, source and token. Sources: F `mint_fee` (shares minted to the
+ * collector, valued at the share value) and `pot_cut`; C `accrued` (the swap-fee tax and the mint fee
+ * together, from the snapshots) and `collected` — basis `collected`, cash moved, not revenue on top
+ * of `accrued`.
+ */
+export interface ProtocolRevenueDayRow {
+    day: number;
+    side: Side;
+    source: string;
+    basis: "earned" | "collected";
+    token: Address;
+    amount: bigint;
+    amountQuote: bigint;
+    events: number;
+}
+export declare function protocolRevenueDays(url: string, q?: ViewQuery): Promise<ProtocolRevenueDayRow[]>;