@kasufinance/kasu-sdk 2.15.0 → 2.17.0

package/dist/services/Portfolio/yield-history.d.ts

@@ -1,4 +1,4 @@
-import { YieldHistoryEntry } from '../../domain/yield-history';
+import { EpochTrancheYield, YieldHistoryEntry } from '../../domain/yield-history';
 /**
  * Which settled epochs a history covers. Epochs are counted in the chain's
  * numbering (`SystemVariables.currentEpochNumber`). Only SETTLED epochs exist
@@ -40,13 +40,20 @@ export declare function resolveYieldHistoryWindow(options: YieldHistoryOptions,
  */
 export declare const yieldHistoryPositionsQuery: string;
 /**
- * Round trip 2 onwards: the four per-epoch series, one page of each per
+ * Round trip 2 onwards: the six per-epoch series, one page of each per
  * request, cursor-paginated by `id`. A series that is exhausted is skipped with
  * `@include`, so a history costs as many requests as its LONGEST series has
  * pages — normally one — never one per epoch.
  *
  * Share snapshots are read up to the window's end with no lower bound: the
- * value AS OF the first epoch may come from an update long before it.
+ * value AS OF the first epoch may come from an update long before it. Each
+ * carries its `timestamp`, and the window's clearings their start, because a
+ * cycle's interest is paired with the shares in force when the clearing
+ * APPLIED it (`sharesAtInterest`), which the epoch tag alone gets wrong for a
+ * withdrawal accepted between clearings — so the lender's updates are read one
+ * tag past the window (`$userSharesToEpoch`), where the subgraph puts it.
+ * Every share exit between clearings is read too (`trancheSharesAtInterest`
+ * rebuilds the tranche total from the previous clearing's snapshot).
  */
 export declare const yieldHistoryPageQuery: string;
 export interface YieldHistoryPositionsResult {
@@ -57,6 +64,8 @@ export interface YieldHistoryPositionsResult {
             };
             lendingPoolTrancheUserDetails: {
                 id: string;
+                /** The ledger's share count (accepted deposits − withdrawals ± top-ups). */
+                shares?: string;
                 tranche: {
                     id: string;
                     balance: string;
@@ -71,6 +80,12 @@ export interface YieldHistoryPositionsResult {
             }[];
         }[];
     } | null;
+    /** The block the subgraph answered at. */
+    _meta?: {
+        block: {
+            number: number;
+        };
+    };
 }
 /** One share snapshot: the value from `epochId` on, until the next one. */
 export interface ShareUpdateRow {
@@ -79,6 +94,13 @@ export interface ShareUpdateRow {
     shareUpdatesIndex: number;
     shares: string;
 }
+/** A tranche or lender share snapshot, with the block time it was written at. */
+export interface TimedShareUpdateRow extends ShareUpdateRow {
+    /** Unix seconds. */
+    timestamp: string;
+}
+/** What the share selection reads from a snapshot — no entity id needed. */
+export type TimedShareSnapshot = Pick<TimedShareUpdateRow, 'epochId' | 'shareUpdatesIndex' | 'shares' | 'timestamp'>;
 export interface InterestRow {
     id: string;
     epochId: string;
@@ -87,14 +109,40 @@ export interface InterestRow {
         id: string;
     };
 }
+/** A pool's clearing for one epoch: its first transaction applied the interest. */
+export interface ClearingRow {
+    id: string;
+    epochId: string;
+    /** Unix seconds of the clearing's first transaction. */
+    startTimestamp: string;
+    lendingPool: {
+        id: string;
+    };
+}
+/**
+ * Shares leaving a tranche (any lender): an accepted withdrawal or an
+ * immediate one. Each carries the pool's clearing epoch at the time
+ * (`epochClearingId`) — so one between clearings E − 1 and E is tagged E.
+ */
+export interface ShareExitRow {
+    id: string;
+    type: 'WithdrawalAccepted' | 'ImmediateWithdrawalExecuted';
+    epochId: string;
+    /** Unix seconds. */
+    createdOn: string;
+    sharesAmount: string | null;
+    tranche: {
+        id: string;
+    };
+}
 export interface YieldHistoryPageResult {
     interest?: InterestRow[];
-    trancheShares?: (ShareUpdateRow & {
+    trancheShares?: (TimedShareUpdateRow & {
         lendingPoolTranche: {
             id: string;
         };
     })[];
-    userShares?: (ShareUpdateRow & {
+    userShares?: (TimedShareUpdateRow & {
         lendingPoolTrancheUserDetails: {
             id: string;
         };
@@ -104,17 +152,19 @@ export interface YieldHistoryPageResult {
             id: string;
         };
     })[];
+    clearings?: ClearingRow[];
+    withdrawals?: ShareExitRow[];
 }
 /** Everything `buildYieldHistory` reads, keyed by the subgraph's entity ids. */
 export interface YieldHistoryRead {
     positions: YieldHistoryPositionsResult;
     interest: InterestRow[];
-    trancheShares: (ShareUpdateRow & {
+    trancheShares: (TimedShareUpdateRow & {
         lendingPoolTranche: {
             id: string;
         };
     })[];
-    userShares: (ShareUpdateRow & {
+    userShares: (TimedShareUpdateRow & {
         lendingPoolTrancheUserDetails: {
             id: string;
         };
@@ -124,6 +174,8 @@ export interface YieldHistoryRead {
             id: string;
         };
     })[];
+    clearings: ClearingRow[];
+    withdrawals: ShareExitRow[];
 }
 /** The chain's epoch clock: epoch E ends at `epochZeroStart + (E + 1) × duration`. */
 export interface EpochClock {
@@ -132,10 +184,11 @@ export interface EpochClock {
 }
 type PageRequest = (variables: Record<string, unknown>) => Promise<YieldHistoryPageResult>;
 /**
- * Fetch the four series for the window, paginating each by `id` until a short
+ * Fetch the six series for the window, paginating each by `id` until a short
  * page. Returns the rows and how many requests it took.
  */
 export declare function fetchYieldHistorySeries(request: PageRequest, ids: {
+    pools: string[];
     tranches: string[];
     userTranches: string[];
     locks: string[];
@@ -149,12 +202,97 @@ export declare function fetchYieldHistorySeries(request: PageRequest, ids: {
  * `lendingPortfolioQuery` selects with `orderBy: shareUpdatesIndex, desc,
  * first: 1, where: { epochId_lt: epoch + 1 }`. `undefined` when none.
  */
-export declare function sharesAsOf(updates: readonly ShareUpdateRow[], epoch: number): ShareUpdateRow | undefined;
+export declare function sharesAsOf<T extends Pick<ShareUpdateRow, 'epochId' | 'shareUpdatesIndex' | 'shares'>>(updates: readonly T[], epoch: number): T | undefined;
+/**
+ * The snapshot in force when the clearing of `epoch` APPLIED that epoch's
+ * interest — the shares the interest was actually spread over.
+ *
+ * A clearing applies interest FIRST (`ClearingCoordinator.doClearing`: the
+ * `applyInterests` call before steps 1–5), then accepts deposits and
+ * withdrawals. So an update is in force for epoch E's interest when it is
+ * tagged `≤ E` (the subgraph tags every update written during clearing E, or
+ * after it, `E + 1` or later), OR when it was written before clearing E began
+ * (`timestamp < clearingStart`). The second test is the one that matters: a
+ * withdrawal the pool manager accepts BETWEEN clearings
+ * (`forceAcceptWithdrawalRequest`) is tagged `E + 1` by the subgraph, as if a
+ * clearing had accepted it, yet the shares were gone before clearing E.
+ *
+ * Without a clearing start (none recorded) it is `sharesAsOf` — the tag alone.
+ */
+export declare function sharesAtInterest<T extends TimedShareSnapshot>(updates: readonly T[], epoch: number, clearingStart: number | undefined): T | undefined;
+/**
+ * The tranche's total shares when the clearing of `epoch` applied its
+ * interest.
+ *
+ * The subgraph writes a tranche snapshot when a clearing ENDS (tagged with
+ * the next epoch) and at each immediate withdrawal, but none when the manager
+ * accepts a withdrawal between clearings — so the newest snapshot can predate
+ * shares that had already left. Instead of guessing the order of events in a
+ * block, the total is rebuilt from the one snapshot whose place is certain:
+ * the FIRST one tagged `epoch`, written when clearing `epoch − 1` ended (the
+ * tag itself starts there). Every share exit between that and clearing
+ * `epoch` is tagged `epoch` (the pool's clearing epoch at the time), and none
+ * can happen during a clearing (`notPendingClearing`,
+ * `verifyClearingNotPending`), while deposits and top-ups only happen inside
+ * one. So: that snapshot less every exit tagged `epoch` before the clearing's
+ * start (the clearing's own acceptances come at or after it).
+ *
+ * Without a clearing start, or without a snapshot tagged `epoch` (a tranche's
+ * first clearing), it is the snapshot in force by tag alone.
+ */
+export declare function trancheSharesAtInterest(snapshots: readonly TimedShareSnapshot[], exits: readonly Pick<ShareExitRow, 'epochId' | 'createdOn' | 'sharesAmount'>[], epoch: number, clearingStart: number | undefined): number;
+/** A fixed-term lock inside one lender's tranche position. */
+export interface PositionLock {
+    epochLockStart: string;
+    epochLockEnd: string;
+    initialTrancheShares: string;
+    /** The lock's share snapshots (paired by tag: its tags are right). */
+    updates: readonly Pick<ShareUpdateRow, 'epochId' | 'shareUpdatesIndex' | 'shares'>[];
+}
+/** Everything one lender's tranche position needs to price one epoch. */
+export interface PositionSeries {
+    trancheBalanceNow: number;
+    trancheSharesNow: number;
+    userUpdates: readonly TimedShareSnapshot[];
+    trancheUpdates: readonly TimedShareSnapshot[];
+    exits: readonly Pick<ShareExitRow, 'epochId' | 'createdOn' | 'sharesAmount'>[];
+    locks: readonly PositionLock[];
+}
+/**
+ * THE per-position, per-epoch selection both `getYieldHistory` and
+ * `getPortfolioLendingData` run: the shares in force when clearing `epoch`
+ * applied its interest (`sharesAtInterest`, `trancheSharesAtInterest`), each
+ * lock's snapshots as of `epoch` and `epoch − 1`, then `epochTrancheYield`.
+ */
+export declare function positionEpochYield(series: PositionSeries, epoch: number, epochInterest: number, clearingStart: number | undefined): {
+    yield: EpochTrancheYield;
+    userShares: number;
+};
+/** One lender's tranche position, as the positions and portfolio queries read it. */
+export interface PositionRef {
+    id: string;
+    tranche: {
+        id: string;
+        balance: string;
+        shares: string;
+    };
+    userLendingPoolTrancheFixedTermDepositLocks: {
+        id?: string;
+        epochLockStart: string;
+        epochLockEnd: string;
+        initialTrancheShares: string;
+    }[];
+}
+/** A position's `PositionSeries` out of the fetched history series. */
+export declare function positionSeriesFrom(rows: Omit<YieldHistoryRead, 'positions'>, position: PositionRef): PositionSeries;
+/** `pool → epoch → clearing start`, from the clearing rows. */
+export declare function clearingStarts(clearings: readonly ClearingRow[]): Map<string, Map<number, number>>;
 /**
  * Pure: the fetched series → one entry per pool, tranche and settled epoch in
  * which the lender held shares (or a lock earned a top-up). Each entry runs the
  * same `epochTrancheYield` as the portfolio's last-epoch figure, with the same
- * share selection, so the newest entry equals that figure.
+ * share selection (`sharesAtInterest`, `trancheSharesAtInterest`), so the
+ * newest entry equals that figure.
  *
  * Sorted by `epochId`, then `poolId`, then `trancheId`.
  */

package/dist/services/Portfolio/yield-history.js

@@ -72,6 +72,7 @@ export const yieldHistoryPositionsQuery = gql `
                 }
                 lendingPoolTrancheUserDetails(first: $first) {
                     id
+                    shares
                     tranche {
                         id
                         balance
@@ -86,32 +87,50 @@ export const yieldHistoryPositionsQuery = gql `
                 }
             }
         }
+        _meta {
+            block {
+                number
+            }
+        }
     }
 `;
 /**
- * Round trip 2 onwards: the four per-epoch series, one page of each per
+ * Round trip 2 onwards: the six per-epoch series, one page of each per
  * request, cursor-paginated by `id`. A series that is exhausted is skipped with
  * `@include`, so a history costs as many requests as its LONGEST series has
  * pages — normally one — never one per epoch.
  *
  * Share snapshots are read up to the window's end with no lower bound: the
- * value AS OF the first epoch may come from an update long before it.
+ * value AS OF the first epoch may come from an update long before it. Each
+ * carries its `timestamp`, and the window's clearings their start, because a
+ * cycle's interest is paired with the shares in force when the clearing
+ * APPLIED it (`sharesAtInterest`), which the epoch tag alone gets wrong for a
+ * withdrawal accepted between clearings — so the lender's updates are read one
+ * tag past the window (`$userSharesToEpoch`), where the subgraph puts it.
+ * Every share exit between clearings is read too (`trancheSharesAtInterest`
+ * rebuilds the tranche total from the previous clearing's snapshot).
  */
 export const yieldHistoryPageQuery = gql `
     query YieldHistoryPage(
+        $pools: [String!]!
         $tranches: [String!]!
         $userTranches: [String!]!
         $locks: [String!]!
         $fromEpoch: BigInt!
         $toEpoch: BigInt!
+        $userSharesToEpoch: BigInt!
         $interestCursor: ID!
         $trancheSharesCursor: ID!
         $userSharesCursor: ID!
         $lockSharesCursor: ID!
+        $clearingsCursor: ID!
+        $withdrawalsCursor: ID!
         $withInterest: Boolean!
         $withTrancheShares: Boolean!
         $withUserShares: Boolean!
         $withLockShares: Boolean!
+        $withClearings: Boolean!
+        $withWithdrawals: Boolean!
         $first: Int!
     ) {
         interest: lendingPoolTrancheEpochInterests(
@@ -146,6 +165,7 @@ export const yieldHistoryPageQuery = gql `
             epochId
             shareUpdatesIndex
             shares
+            timestamp
             lendingPoolTranche {
                 id
             }
@@ -157,13 +177,14 @@ export const yieldHistoryPageQuery = gql `
             where: {
                 id_gt: $userSharesCursor
                 lendingPoolTrancheUserDetails_in: $userTranches
-                epochId_lte: $toEpoch
+                epochId_lte: $userSharesToEpoch
             }
         ) @include(if: $withUserShares) {
             id
             epochId
             shareUpdatesIndex
             shares
+            timestamp
             lendingPoolTrancheUserDetails {
                 id
             }
@@ -186,10 +207,49 @@ export const yieldHistoryPageQuery = gql `
                 id
             }
         }
+        clearings: lendingPoolClearings(
+            first: $first
+            orderBy: id
+            orderDirection: asc
+            where: {
+                id_gt: $clearingsCursor
+                lendingPool_in: $pools
+                epochId_gte: $fromEpoch
+                epochId_lte: $toEpoch
+            }
+        ) @include(if: $withClearings) {
+            id
+            epochId
+            startTimestamp
+            lendingPool {
+                id
+            }
+        }
+        withdrawals: userRequestEvents(
+            first: $first
+            orderBy: id
+            orderDirection: asc
+            where: {
+                id_gt: $withdrawalsCursor
+                type_in: [WithdrawalAccepted, ImmediateWithdrawalExecuted]
+                tranche_in: $tranches
+                epochId_gte: $fromEpoch
+                epochId_lte: $toEpoch
+            }
+        ) @include(if: $withWithdrawals) {
+            id
+            type
+            epochId
+            createdOn
+            sharesAmount
+            tranche {
+                id
+            }
+        }
     }
 `;
 /**
- * Fetch the four series for the window, paginating each by `id` until a short
+ * Fetch the six series for the window, paginating each by `id` until a short
  * page. Returns the rows and how many requests it took.
  */
 export function fetchYieldHistorySeries(request, ids, window) {
@@ -200,6 +260,8 @@ export function fetchYieldHistorySeries(request, ids, window) {
             trancheShares: [],
             userShares: [],
             lockShares: [],
+            clearings: [],
+            withdrawals: [],
         };
         const series = [
             { key: 'interest', flag: 'withInterest', cursor: 'interestCursor' },
@@ -218,18 +280,32 @@ export function fetchYieldHistorySeries(request, ids, window) {
                 flag: 'withLockShares',
                 cursor: 'lockSharesCursor',
             },
+            {
+                key: 'clearings',
+                flag: 'withClearings',
+                cursor: 'clearingsCursor',
+            },
+            {
+                key: 'withdrawals',
+                flag: 'withWithdrawals',
+                cursor: 'withdrawalsCursor',
+            },
         ];
         const cursors = {
             interest: '',
             trancheShares: '',
             userShares: '',
             lockShares: '',
+            clearings: '',
+            withdrawals: '',
         };
         const open = {
             interest: ids.tranches.length > 0,
             trancheShares: ids.tranches.length > 0,
             userShares: ids.userTranches.length > 0,
             lockShares: ids.locks.length > 0,
+            clearings: ids.pools.length > 0,
+            withdrawals: ids.tranches.length > 0,
         };
         let requests = 0;
         while (series.some(({ key }) => open[key])) {
@@ -237,11 +313,15 @@ export function fetchYieldHistorySeries(request, ids, window) {
                 throw new Error(`getYieldHistory: more than ${String(YIELD_HISTORY_MAX_PAGES)} pages for one lender`);
             }
             const variables = {
+                pools: ids.pools,
                 tranches: ids.tranches,
                 userTranches: ids.userTranches,
                 locks: ids.locks,
                 fromEpoch: String(window.fromEpoch),
                 toEpoch: String(window.toEpoch),
+                // One tag further for the lender: a withdrawal accepted between
+                // clearings is tagged with the epoch AFTER the one it counts in.
+                userSharesToEpoch: String(window.toEpoch + 1),
                 first: YIELD_HISTORY_PAGE_SIZE,
             };
             for (const { key, flag, cursor } of series) {
@@ -286,6 +366,144 @@ export function sharesAsOf(updates, epoch) {
     }
     return found;
 }
+/**
+ * The snapshot in force when the clearing of `epoch` APPLIED that epoch's
+ * interest — the shares the interest was actually spread over.
+ *
+ * A clearing applies interest FIRST (`ClearingCoordinator.doClearing`: the
+ * `applyInterests` call before steps 1–5), then accepts deposits and
+ * withdrawals. So an update is in force for epoch E's interest when it is
+ * tagged `≤ E` (the subgraph tags every update written during clearing E, or
+ * after it, `E + 1` or later), OR when it was written before clearing E began
+ * (`timestamp < clearingStart`). The second test is the one that matters: a
+ * withdrawal the pool manager accepts BETWEEN clearings
+ * (`forceAcceptWithdrawalRequest`) is tagged `E + 1` by the subgraph, as if a
+ * clearing had accepted it, yet the shares were gone before clearing E.
+ *
+ * Without a clearing start (none recorded) it is `sharesAsOf` — the tag alone.
+ */
+export function sharesAtInterest(updates, epoch, clearingStart) {
+    let found;
+    for (const update of updates) {
+        const inForce = Number(update.epochId) <= epoch ||
+            (clearingStart !== undefined &&
+                Number(update.timestamp) < clearingStart);
+        if (!inForce)
+            continue;
+        if (!found || update.shareUpdatesIndex > found.shareUpdatesIndex) {
+            found = update;
+        }
+    }
+    return found;
+}
+/**
+ * The tranche's total shares when the clearing of `epoch` applied its
+ * interest.
+ *
+ * The subgraph writes a tranche snapshot when a clearing ENDS (tagged with
+ * the next epoch) and at each immediate withdrawal, but none when the manager
+ * accepts a withdrawal between clearings — so the newest snapshot can predate
+ * shares that had already left. Instead of guessing the order of events in a
+ * block, the total is rebuilt from the one snapshot whose place is certain:
+ * the FIRST one tagged `epoch`, written when clearing `epoch − 1` ended (the
+ * tag itself starts there). Every share exit between that and clearing
+ * `epoch` is tagged `epoch` (the pool's clearing epoch at the time), and none
+ * can happen during a clearing (`notPendingClearing`,
+ * `verifyClearingNotPending`), while deposits and top-ups only happen inside
+ * one. So: that snapshot less every exit tagged `epoch` before the clearing's
+ * start (the clearing's own acceptances come at or after it).
+ *
+ * Without a clearing start, or without a snapshot tagged `epoch` (a tranche's
+ * first clearing), it is the snapshot in force by tag alone.
+ */
+export function trancheSharesAtInterest(snapshots, exits, epoch, clearingStart) {
+    var _a, _b, _c;
+    let base;
+    if (clearingStart !== undefined) {
+        for (const snapshot of snapshots) {
+            if (Number(snapshot.epochId) !== epoch)
+                continue;
+            if (!base || snapshot.shareUpdatesIndex < base.shareUpdatesIndex) {
+                base = snapshot;
+            }
+        }
+    }
+    if (clearingStart === undefined || !base) {
+        return parseFloat((_b = (_a = sharesAsOf(snapshots, epoch)) === null || _a === void 0 ? void 0 : _a.shares) !== null && _b !== void 0 ? _b : '0');
+    }
+    let shares = parseFloat(base.shares);
+    for (const exit of exits) {
+        if (Number(exit.epochId) === epoch &&
+            Number(exit.createdOn) < clearingStart) {
+            shares -= parseFloat((_c = exit.sharesAmount) !== null && _c !== void 0 ? _c : '0');
+        }
+    }
+    return shares;
+}
+/**
+ * THE per-position, per-epoch selection both `getYieldHistory` and
+ * `getPortfolioLendingData` run: the shares in force when clearing `epoch`
+ * applied its interest (`sharesAtInterest`, `trancheSharesAtInterest`), each
+ * lock's snapshots as of `epoch` and `epoch − 1`, then `epochTrancheYield`.
+ */
+export function positionEpochYield(series, epoch, epochInterest, clearingStart) {
+    var _a;
+    const userSnapshot = sharesAtInterest(series.userUpdates, epoch, clearingStart);
+    const userShares = parseFloat((_a = userSnapshot === null || userSnapshot === void 0 ? void 0 : userSnapshot.shares) !== null && _a !== void 0 ? _a : '0');
+    const locks = series.locks.map((lock) => {
+        var _a, _b, _c, _d;
+        return ({
+            active: parseFloat(lock.epochLockStart) < epoch &&
+                parseFloat(lock.epochLockEnd) >= epoch &&
+                userSnapshot !== undefined,
+            // No snapshot yet = the lock's opening shares: a lock made after
+            // clearing E starts at E but its first update is tagged E + 1, and
+            // reading that gap as 0 would book its principal as a top-up.
+            sharesAtEpoch: parseFloat((_b = (_a = sharesAsOf(lock.updates, epoch)) === null || _a === void 0 ? void 0 : _a.shares) !== null && _b !== void 0 ? _b : lock.initialTrancheShares),
+            sharesBeforeEpoch: parseFloat((_d = (_c = sharesAsOf(lock.updates, epoch - 1)) === null || _c === void 0 ? void 0 : _c.shares) !== null && _d !== void 0 ? _d : lock.initialTrancheShares),
+        });
+    });
+    return {
+        yield: epochTrancheYield({
+            epochInterest,
+            userShares,
+            trancheShares: trancheSharesAtInterest(series.trancheUpdates, series.exits, epoch, clearingStart),
+            trancheBalanceNow: series.trancheBalanceNow,
+            trancheSharesNow: series.trancheSharesNow,
+            locks,
+        }),
+        userShares,
+    };
+}
+/** A position's `PositionSeries` out of the fetched history series. */
+export function positionSeriesFrom(rows, position) {
+    const trancheId = position.tranche.id;
+    return {
+        trancheBalanceNow: parseFloat(position.tranche.balance),
+        trancheSharesNow: parseFloat(position.tranche.shares),
+        userUpdates: rows.userShares.filter((row) => row.lendingPoolTrancheUserDetails.id === position.id),
+        trancheUpdates: rows.trancheShares.filter((row) => row.lendingPoolTranche.id === trancheId),
+        exits: rows.withdrawals.filter((row) => row.tranche.id === trancheId),
+        locks: position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => (Object.assign(Object.assign({}, lock), { updates: rows.lockShares.filter((row) => row.userLendingPoolTrancheFixedTermDepositLock.id ===
+                lock.id) }))),
+    };
+}
+/** `pool → epoch → clearing start`, from the clearing rows. */
+export function clearingStarts(clearings) {
+    var _a;
+    const starts = new Map();
+    for (const clearing of clearings) {
+        const start = Number(clearing.startTimestamp);
+        // A clearing not yet started carries 0: no start to pair by.
+        if (!(start > 0))
+            continue;
+        const pool = clearing.lendingPool.id.toLowerCase();
+        const byEpoch = (_a = starts.get(pool)) !== null && _a !== void 0 ? _a : new Map();
+        byEpoch.set(Number(clearing.epochId), start);
+        starts.set(pool, byEpoch);
+    }
+    return starts;
+}
 function groupBy(rows, key) {
     const map = new Map();
     for (const row of rows) {
@@ -302,12 +520,13 @@ function groupBy(rows, key) {
  * Pure: the fetched series → one entry per pool, tranche and settled epoch in
  * which the lender held shares (or a lock earned a top-up). Each entry runs the
  * same `epochTrancheYield` as the portfolio's last-epoch figure, with the same
- * share selection, so the newest entry equals that figure.
+ * share selection (`sharesAtInterest`, `trancheSharesAtInterest`), so the
+ * newest entry equals that figure.
  *
  * Sorted by `epochId`, then `poolId`, then `trancheId`.
  */
 export function buildYieldHistory(read, window, clock) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d;
     const user = read.positions.user;
     if (!user)
         return [];
@@ -315,45 +534,36 @@ export function buildYieldHistory(read, window, clock) {
     const trancheSharesByTranche = groupBy(read.trancheShares, (row) => row.lendingPoolTranche.id);
     const userSharesByPosition = groupBy(read.userShares, (row) => row.lendingPoolTrancheUserDetails.id);
     const lockSharesByLock = groupBy(read.lockShares, (row) => row.userLendingPoolTrancheFixedTermDepositLock.id);
+    const withdrawalsByTranche = groupBy(read.withdrawals, (row) => row.tranche.id);
+    const starts = clearingStarts(read.clearings);
     const entries = [];
     for (const pool of user.lendingPoolUserDetails) {
+        const poolStarts = starts.get(pool.lendingPool.id.toLowerCase());
         for (const position of pool.lendingPoolTrancheUserDetails) {
             const trancheId = position.tranche.id;
             const trancheUpdates = (_a = trancheSharesByTranche.get(trancheId)) !== null && _a !== void 0 ? _a : [];
             const userUpdates = (_b = userSharesByPosition.get(position.id)) !== null && _b !== void 0 ? _b : [];
+            const trancheWithdrawals = (_c = withdrawalsByTranche.get(trancheId)) !== null && _c !== void 0 ? _c : [];
             const trancheBalanceNow = parseFloat(position.tranche.balance);
             const trancheSharesNow = parseFloat(position.tranche.shares);
-            for (const record of (_c = interestByTranche.get(trancheId)) !== null && _c !== void 0 ? _c : []) {
+            for (const record of (_d = interestByTranche.get(trancheId)) !== null && _d !== void 0 ? _d : []) {
                 const epoch = Number(record.epochId);
                 if (epoch < window.fromEpoch || epoch > window.toEpoch) {
                     continue;
                 }
-                const userSnapshot = sharesAsOf(userUpdates, epoch);
-                const userShares = parseFloat((_d = userSnapshot === null || userSnapshot === void 0 ? void 0 : userSnapshot.shares) !== null && _d !== void 0 ? _d : '0');
-                const locks = position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => {
-                    var _a, _b, _c, _d, _e;
-                    const lockUpdates = (_a = lockSharesByLock.get(lock.id)) !== null && _a !== void 0 ? _a : [];
-                    return {
-                        active: parseFloat(lock.epochLockStart) < epoch &&
-                            parseFloat(lock.epochLockEnd) >= epoch &&
-                            userSnapshot !== undefined,
-                        // No snapshot yet = the lock's opening
-                        // shares: a lock made after clearing E
-                        // starts at E but its first update is
-                        // tagged E + 1, and reading that gap as 0
-                        // would book its principal as a top-up.
-                        sharesAtEpoch: parseFloat((_c = (_b = sharesAsOf(lockUpdates, epoch)) === null || _b === void 0 ? void 0 : _b.shares) !== null && _c !== void 0 ? _c : lock.initialTrancheShares),
-                        sharesBeforeEpoch: parseFloat((_e = (_d = sharesAsOf(lockUpdates, epoch - 1)) === null || _d === void 0 ? void 0 : _d.shares) !== null && _e !== void 0 ? _e : lock.initialTrancheShares),
-                    };
-                });
-                const { total } = epochTrancheYield({
-                    epochInterest: parseFloat(record.epochInterestAmount),
-                    userShares,
-                    trancheShares: parseFloat((_f = (_e = sharesAsOf(trancheUpdates, epoch)) === null || _e === void 0 ? void 0 : _e.shares) !== null && _f !== void 0 ? _f : '0'),
+                const clearingStart = poolStarts === null || poolStarts === void 0 ? void 0 : poolStarts.get(epoch);
+                const { yield: epochYield, userShares } = positionEpochYield({
                     trancheBalanceNow,
                     trancheSharesNow,
-                    locks,
-                });
+                    userUpdates,
+                    trancheUpdates,
+                    exits: trancheWithdrawals,
+                    locks: position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => {
+                        var _a;
+                        return (Object.assign(Object.assign({}, lock), { updates: (_a = lockSharesByLock.get(lock.id)) !== null && _a !== void 0 ? _a : [] }));
+                    }),
+                }, epoch, parseFloat(record.epochInterestAmount), clearingStart);
+                const total = epochYield.total;
                 // Nothing held and nothing topped up: not part of this
                 // lender's history (a new lender's history is empty).
                 if (userShares <= 0 && total === 0)