@kasufinance/kasu-sdk 2.15.0 → 2.17.0

package/dist/bundle.cjs.js

@@ -15951,6 +15951,54 @@ function isMissingEntityError(error) {
 function isEmptyHistoryError(error, liteDeployment) {
     return liteDeployment && isMissingEntityError(error);
 }
+/**
+ * What node implementations and RPC providers answer when they cannot serve
+ * state at a requested block: pruned history, or a block they have not seen
+ * yet. Matched on the error's text, lowercased.
+ */
+const BLOCK_UNAVAILABLE_PATTERNS = [
+    'missing trie node',
+    'header not found',
+    'unknown block',
+    'block not found',
+    'pruned',
+    'historical state',
+    'state is not available',
+    'state not available',
+    'missing state',
+    'state unavailable',
+    'state histories',
+    'block number out of range',
+    'beyond current head',
+    'is in the future',
+];
+function errorTexts(error, depth = 0) {
+    if (depth > 4 || error === null || error === undefined)
+        return [];
+    if (typeof error === 'string')
+        return [error];
+    if (typeof error !== 'object')
+        return [];
+    const record = error;
+    return [
+        'message',
+        'reason',
+        'body',
+        'error',
+        'data',
+        'serverError',
+    ].flatMap((key) => errorTexts(record[key], depth + 1));
+}
+/**
+ * True when a failed RPC read says the node cannot serve state at the block
+ * asked for (pruned, or not reached yet) — and ONLY then. A rate limit, a
+ * timeout, a refused connection or a revert is not this, and must surface as
+ * the error it is.
+ */
+function isBlockUnavailableError(error) {
+    const text = errorTexts(error).join(' ').toLowerCase();
+    return BLOCK_UNAVAILABLE_PATTERNS.some((pattern) => text.includes(pattern));
+}
 
 /**
  * The error a CMS-only call raises on a deployment configured without
@@ -18044,6 +18092,22 @@ class KSULocking {
             return (yield this._systemVariablesAbi.nextEpochStartTimestamp()).toNumber();
         });
     }
+    /**
+     * Unix SECONDS at which epoch 0 started:
+     * `SystemVariables.epochStartTimestamp(0)`. The contract writes this once,
+     * at initialisation, so it never changes for a deployment and may be cached
+     * for the life of the app. Every epoch boundary follows from it —
+     * `epochEndTimestamp(initial, epoch)` and `epochAccrual` in the domain
+     * layer.
+     *
+     * Available on every deployment, Full and Lite. A failed read rejects; the
+     * caller validates the value (a positive integer) before using it.
+     */
+    getInitialEpochStartTimestamp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._systemVariablesAbi.epochStartTimestamp(0)).toNumber();
+        });
+    }
     getNextClearingPeriodDate() {
         return __awaiter(this, void 0, void 0, function* () {
             const nextEpochDate = yield this.getNextEpochDate();
@@ -18080,101 +18144,6 @@ class KSULocking {
     }
 }
 
-/**
- * Settled interest per cycle (epoch): what a lender was credited at each close,
- * per pool and tranche, and the one formula that turns a tranche's credited
- * interest into one lender's share of it.
- *
- * **The figures are NET, and only net.** `LendingPool._applyTrancheInterest`
- * takes the performance fee off first and emits `InterestApplied` with the
- * lender side only (`interest × (1 − performanceFee)`); a fixed-term top-up
- * (`_applyFixedRateInterests`) is net of the fee the same way. So the figure
- * this module computes from those records IS what the lender was credited —
- * never take the fee off it again. No gross is offered: the subgraph keeps
- * only TODAY's fee, so a historical gross would be a guess.
- *
- * Units: amounts are display units of the DEPLOYMENT'S OWN stable token (USDC
- * on Base and XDC USDC, AUDD on XDC AUDD) — never converted to USD here;
- * shares are display units of tranche shares, as the subgraph's BigDecimals.
- */
-/**
- * The ONE per-epoch formula. `Portfolio.getPortfolioLendingData` runs it for
- * the last settled epoch and `getYieldHistory` for every epoch of a window, so
- * the two figures cannot drift apart.
- *
- * ```
- * base     = epochInterest × userShares / trancheShares
- * lockBase = base × lock.sharesBeforeEpoch / userShares          (active locks)
- * topUp    = (lock.sharesAtEpoch − lock.sharesBeforeEpoch) × trancheBalanceNow / trancheSharesNow
- * variable = base − Σ lockBase
- * total    = variable + Σ (lockBase + topUp)
- * ```
- *
- * A zero denominator contributes 0 (a tranche or a lender with no shares
- * earned nothing at that close), never `NaN`.
- */
-function epochTrancheYield(input) {
-    const base = input.trancheShares === 0
-        ? 0
-        : (input.epochInterest * input.userShares) / input.trancheShares;
-    let variable = base;
-    const locks = input.locks.map((lock) => {
-        if (!lock.active)
-            return 0;
-        const topUp = input.trancheSharesNow === 0
-            ? 0
-            : ((lock.sharesAtEpoch - lock.sharesBeforeEpoch) *
-                input.trancheBalanceNow) /
-                input.trancheSharesNow;
-        const lockBase = input.userShares === 0
-            ? 0
-            : (base * lock.sharesBeforeEpoch) / input.userShares;
-        variable -= lockBase;
-        return lockBase + topUp;
-    });
-    const total = locks.reduce((sum, lockYield) => sum + lockYield, variable);
-    return { total, variable, locks };
-}
-/**
- * Pool/tranche entries → one point per epoch, ascending by `epochId`. With no
- * filter it sums every strategy (the Lend tab's bars); with `poolId` it is one
- * strategy (a strategy page's bars).
- *
- * An epoch appears only if a kept entry has it — there is no zero padding, so
- * an empty input (a new lender) is an empty output.
- *
- * For a fixed-term lock holder the bars can sum to slightly MORE than the
- * lender's lifetime interest (up to about 0.2 %): each top-up is valued at the
- * tranche's CURRENT share price, which has grown since. Show "earned to date"
- * from the lifetime figure, never from this sum.
- */
-function aggregateYieldHistory(entries, filter = {}) {
-    var _a, _b;
-    const poolId = (_a = filter.poolId) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-    const trancheId = (_b = filter.trancheId) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-    const byEpoch = new Map();
-    for (const entry of entries) {
-        if (poolId !== undefined && entry.poolId.toLowerCase() !== poolId) {
-            continue;
-        }
-        if (trancheId !== undefined &&
-            entry.trancheId.toLowerCase() !== trancheId) {
-            continue;
-        }
-        const point = byEpoch.get(entry.epochId);
-        if (point) {
-            point.netYield += entry.netYield;
-            continue;
-        }
-        byEpoch.set(entry.epochId, {
-            epochId: entry.epochId,
-            epochEnd: entry.epochEnd,
-            netYield: entry.netYield,
-        });
-    }
-    return [...byEpoch.values()].sort((a, b) => a.epochId - b.epochId);
-}
-
 /**
  * Check if the SDK is configured for a Lite deployment.
  * Lite deployments don't have KSU token, locking, or loyalty features.
@@ -18852,6 +18821,30 @@ class UserLending {
             });
         });
     }
+    /**
+     * The lender's ACTIVE assets in each tranche, read from the chain
+     * (`LendingPoolTranche.userActiveAssets`), in the order of `trancheIds`,
+     * in the stable token's base units. Active shares are the ones the lender
+     * owns in the tranche — fixed-term-locked and withdrawal-pending shares
+     * included — whatever path brought them there; `LendingPool.userBalance`
+     * is their sum. One call per tranche.
+     */
+    getUserTrancheActiveAssets(user, trancheIds, provider, blockTag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(trancheIds.map((trancheId) => ILendingPoolTrancheAbi__factory.connect(trancheId, provider !== null && provider !== void 0 ? provider : this._signerOrProvider).userActiveAssets(user, { blockTag: blockTag !== null && blockTag !== void 0 ? blockTag : 'latest' })));
+        });
+    }
+    /**
+     * The lender's balance in each pool (`LendingPool.userBalance`, the sum
+     * of its tranches' active assets), in the order of `poolIds`, in the
+     * stable token's base units, at `blockTag` (default `latest`). One call
+     * per pool.
+     */
+    getUserPoolBalancesAt(user, poolIds, provider, blockTag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(poolIds.map((poolId) => ILendingPoolAbi__factory.connect(poolId, provider !== null && provider !== void 0 ? provider : this._signerOrProvider).userBalance(user, { blockTag: blockTag !== null && blockTag !== void 0 ? blockTag : 'latest' })));
+        });
+    }
     getPortfolioUserTrancheBalances(user) {
         return __awaiter(this, void 0, void 0, function* () {
             const userDetails = yield this._graph.request(portfolioUserTrancheDetailsQuery, {
@@ -19003,20 +18996,47 @@ gql `
         }
     }
 `;
+/**
+ * The portfolio read. Its last-epoch figures pair each tranche's newest
+ * interest (epoch E) with the shares in force when clearing E applied it —
+ * the selection `getYieldHistory` makes (`positionEpochYield`). For that it
+ * reads, per lender and tranche, the newest share snapshot tagged before
+ * `$recentEpoch` and EVERY snapshot tagged from it on (with their times), and,
+ * for the listed pools (`$poolIds`) and tranches (`$trancheIds`), the
+ * clearings and share exits of those recent epochs. `$recentEpoch` is six
+ * epochs back (`RECENT_PAIRING_EPOCHS`); a newest interest older than that (a
+ * pool that clears rarely) is priced from a history read of its own. Lock
+ * snapshots are read the same way from one epoch further back
+ * (`$lockRecentEpoch`), since a top-up compares E with E − 1. Every list read
+ * with `$first` must come back SHORT of it — a full one is refused, never
+ * used truncated. `_meta` is the block the answer describes: the chain is
+ * read at that same block.
+ */
 const lendingPortfolioQuery = gql `
     query LastEpochQuery(
         $userAddress: ID!
         $epochId: BigInt!
         $lastEpochId: BigInt!
+        $recentEpoch: BigInt!
+        $lockRecentEpoch: BigInt!
         $unusedPools: [String!]!
+        $poolIds: [String!]!
+        $trancheIds: [String!]!
         $first: Int!
     ) {
+        _meta {
+            block {
+                number
+            }
+        }
         user(id: $userAddress) {
             lendingPoolUserDetails(
                 first: $first
                 where: { lendingPool_not_in: $unusedPools }
             ) {
                 id
+                totalAcceptedDeposits
+                totalAcceptedWithdrawnAmount
                 lendingPool {
                     id
                     name
@@ -19026,16 +19046,34 @@ const lendingPortfolioQuery = gql `
                     }
                 }
                 lendingPoolTrancheUserDetails(first: $first) {
+                    id
                     shares
+                    totalAcceptedDeposits
+                    totalAcceptedWithdrawnAmount
                     lendingPoolTrancheUserEpochSharesUpdates(
                         orderDirection: desc
                         orderBy: shareUpdatesIndex
-                        where: { epochId_lt: $epochId }
+                        where: { epochId_lt: $recentEpoch }
                         first: 1
                     ) {
+                        epochId
+                        shareUpdatesIndex
                         shares
+                        timestamp
+                    }
+                    recentUserShareUpdates: lendingPoolTrancheUserEpochSharesUpdates(
+                        orderDirection: desc
+                        orderBy: shareUpdatesIndex
+                        where: { epochId_gte: $recentEpoch }
+                        first: $first
+                    ) {
+                        epochId
+                        shareUpdatesIndex
+                        shares
+                        timestamp
                     }
                     userLendingPoolTrancheFixedTermDepositLocks(first: $first) {
+                        id
                         isLocked
                         unlockAmount
                         initialAmount
@@ -19067,6 +19105,26 @@ const lendingPortfolioQuery = gql `
                         ) {
                             shares
                         }
+                        lockSharesBase: userLendingPoolTrancheFixedTermDepositLockShareUpdate(
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            first: 1
+                            where: { epochId_lt: $lockRecentEpoch }
+                        ) {
+                            epochId
+                            shareUpdatesIndex
+                            shares
+                        }
+                        lockSharesRecent: userLendingPoolTrancheFixedTermDepositLockShareUpdate(
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            first: $first
+                            where: { epochId_gte: $lockRecentEpoch }
+                        ) {
+                            epochId
+                            shareUpdatesIndex
+                            shares
+                        }
                     }
                     tranche {
                         id
@@ -19076,9 +19134,23 @@ const lendingPortfolioQuery = gql `
                             first: 1
                             orderBy: shareUpdatesIndex
                             orderDirection: desc
-                            where: { epochId_lt: $epochId }
+                            where: { epochId_lt: $recentEpoch }
                         ) {
+                            epochId
+                            shareUpdatesIndex
                             shares
+                            timestamp
+                        }
+                        recentTrancheShareUpdates: lendingPoolTrancheShareUpdates(
+                            first: $first
+                            orderBy: shareUpdatesIndex
+                            orderDirection: desc
+                            where: { epochId_gte: $recentEpoch }
+                        ) {
+                            epochId
+                            shareUpdatesIndex
+                            shares
+                            timestamp
                         }
                         lendingPoolTrancheEpochInterest(
                             first: 1
@@ -19086,12 +19158,50 @@ const lendingPortfolioQuery = gql `
                             orderDirection: desc
                             where: { epochId_lt: $epochId }
                         ) {
+                            epochId
                             epochInterestAmount
                         }
                     }
                 }
             }
         }
+        lendingPoolClearings(
+            first: $first
+            orderBy: id
+            orderDirection: asc
+            where: {
+                lendingPool_in: $poolIds
+                epochId_gte: $recentEpoch
+                epochId_lt: $epochId
+            }
+        ) {
+            id
+            epochId
+            startTimestamp
+            lendingPool {
+                id
+            }
+        }
+        recentWithdrawalsAccepted: userRequestEvents(
+            first: $first
+            orderBy: id
+            orderDirection: asc
+            where: {
+                type_in: [WithdrawalAccepted, ImmediateWithdrawalExecuted]
+                tranche_in: $trancheIds
+                epochId_gte: $recentEpoch
+                epochId_lt: $epochId
+            }
+        ) {
+            id
+            type
+            epochId
+            createdOn
+            sharesAmount
+            tranche {
+                id
+            }
+        }
         userRequests(
             first: $first
             where: {
@@ -19119,6 +19229,131 @@ const lendingPortfolioQuery = gql `
     }
 `;
 
+/**
+ * Settled interest per cycle (epoch): what a lender was credited at each close,
+ * per pool and tranche, and the one formula that turns a tranche's credited
+ * interest into one lender's share of it.
+ *
+ * **The figures are NET, and only net.** `LendingPool._applyTrancheInterest`
+ * takes the performance fee off first and emits `InterestApplied` with the
+ * lender side only (`interest × (1 − performanceFee)`); a fixed-term top-up
+ * (`_applyFixedRateInterests`) is net of the fee the same way. So the figure
+ * this module computes from those records IS what the lender was credited —
+ * never take the fee off it again. No gross is offered: the subgraph keeps
+ * only TODAY's fee, so a historical gross would be a guess.
+ *
+ * Units: amounts are display units of the DEPLOYMENT'S OWN stable token (USDC
+ * on Base and XDC USDC, AUDD on XDC AUDD) — never converted to USD here;
+ * shares are display units of tranche shares, as the subgraph's BigDecimals.
+ */
+/**
+ * The largest change of a lock's shares, as a fraction of its shares before
+ * the epoch, that one clearing's fixed-term top-up can make. The top-up is
+ * the fixed rate's difference from the variable one on one week's balance
+ * (`LendingPool._applyFixedRateInterests`) — a fraction of a percent at any
+ * real rate — so 5 % is far above every genuine top-up and far below any
+ * accounting fault. A lock-share change outside it is NOT interest: it is
+ * left out of the yield (a share movement is never booked as yield). The one
+ * seen on chain is a lock whose recorded shares were set to zero at a
+ * clearing while its shares stayed in the fixed-term contract.
+ */
+const MAX_TOP_UP_SHARE_FRACTION = 0.05;
+/**
+ * True when `sharesBefore → sharesAt` is a change one clearing's fixed-term
+ * top-up can make (`MAX_TOP_UP_SHARE_FRACTION`). A lock with no shares
+ * before has no top-up at all.
+ */
+function isPlausibleTopUp(sharesBefore, sharesAt) {
+    if (!(sharesBefore > 0))
+        return sharesAt === sharesBefore;
+    return (Math.abs(sharesAt - sharesBefore) <=
+        sharesBefore * MAX_TOP_UP_SHARE_FRACTION);
+}
+/**
+ * The ONE per-epoch formula. `Portfolio.getPortfolioLendingData` runs it for
+ * the last settled epoch and `getYieldHistory` for every epoch of a window, so
+ * the two figures cannot drift apart.
+ *
+ * ```
+ * base     = epochInterest × userShares / trancheShares
+ * lockBase = base × lock.sharesBeforeEpoch / userShares          (active locks)
+ * topUp    = (lock.sharesAtEpoch − lock.sharesBeforeEpoch) × trancheBalanceNow / trancheSharesNow
+ * variable = base − Σ lockBase
+ * total    = variable + Σ (lockBase + topUp)
+ * ```
+ *
+ * A zero denominator contributes 0 (a tranche or a lender with no shares
+ * earned nothing at that close), never `NaN`. So does a NEGATIVE share count:
+ * the subgraph's per-lender shares are a ledger of accepted deposits and
+ * withdrawals, and a wallet whose shares arrived some other way (moved to it
+ * from another wallet) withdraws more than the ledger ever credited it. That
+ * position is not one the ledger can describe, and its negative count is not
+ * a negative yield. A lock-share change no top-up can make
+ * (`isPlausibleTopUp`) contributes no top-up.
+ */
+function epochTrancheYield(input) {
+    const base = input.trancheShares > 0 && input.userShares > 0
+        ? (input.epochInterest * input.userShares) / input.trancheShares
+        : 0;
+    let variable = base;
+    const locks = input.locks.map((lock) => {
+        if (!lock.active)
+            return 0;
+        const topUp = input.trancheSharesNow > 0 &&
+            isPlausibleTopUp(lock.sharesBeforeEpoch, lock.sharesAtEpoch)
+            ? ((lock.sharesAtEpoch - lock.sharesBeforeEpoch) *
+                input.trancheBalanceNow) /
+                input.trancheSharesNow
+            : 0;
+        const lockBase = input.userShares > 0
+            ? (base * lock.sharesBeforeEpoch) / input.userShares
+            : 0;
+        variable -= lockBase;
+        return lockBase + topUp;
+    });
+    const total = locks.reduce((sum, lockYield) => sum + lockYield, variable);
+    return { total, variable, locks };
+}
+/**
+ * Pool/tranche entries → one point per epoch, ascending by `epochId`. With no
+ * filter it sums every strategy (the Lend tab's bars); with `poolId` it is one
+ * strategy (a strategy page's bars).
+ *
+ * An epoch appears only if a kept entry has it — there is no zero padding, so
+ * an empty input (a new lender) is an empty output.
+ *
+ * For a fixed-term lock holder the bars can sum to slightly MORE than the
+ * lender's lifetime interest (up to about 0.2 %): each top-up is valued at the
+ * tranche's CURRENT share price, which has grown since. Show "earned to date"
+ * from the lifetime figure, never from this sum.
+ */
+function aggregateYieldHistory(entries, filter = {}) {
+    var _a, _b;
+    const poolId = (_a = filter.poolId) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const trancheId = (_b = filter.trancheId) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    const byEpoch = new Map();
+    for (const entry of entries) {
+        if (poolId !== undefined && entry.poolId.toLowerCase() !== poolId) {
+            continue;
+        }
+        if (trancheId !== undefined &&
+            entry.trancheId.toLowerCase() !== trancheId) {
+            continue;
+        }
+        const point = byEpoch.get(entry.epochId);
+        if (point) {
+            point.netYield += entry.netYield;
+            continue;
+        }
+        byEpoch.set(entry.epochId, {
+            epochId: entry.epochId,
+            epochEnd: entry.epochEnd,
+            netYield: entry.netYield,
+        });
+    }
+    return [...byEpoch.values()].sort((a, b) => a.epochId - b.epochId);
+}
+
 /** The subgraph returns at most this many rows per collection per request. */
 const YIELD_HISTORY_PAGE_SIZE = 1000;
 /**
@@ -19182,6 +19417,7 @@ const yieldHistoryPositionsQuery = gql `
                 }
                 lendingPoolTrancheUserDetails(first: $first) {
                     id
+                    shares
                     tranche {
                         id
                         balance
@@ -19196,32 +19432,50 @@ 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).
  */
 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(
@@ -19256,6 +19510,7 @@ const yieldHistoryPageQuery = gql `
             epochId
             shareUpdatesIndex
             shares
+            timestamp
             lendingPoolTranche {
                 id
             }
@@ -19267,13 +19522,14 @@ 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
             }
@@ -19296,10 +19552,49 @@ 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.
  */
 function fetchYieldHistorySeries(request, ids, window) {
@@ -19310,6 +19605,8 @@ function fetchYieldHistorySeries(request, ids, window) {
             trancheShares: [],
             userShares: [],
             lockShares: [],
+            clearings: [],
+            withdrawals: [],
         };
         const series = [
             { key: 'interest', flag: 'withInterest', cursor: 'interestCursor' },
@@ -19328,18 +19625,32 @@ 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])) {
@@ -19347,11 +19658,15 @@ 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) {
@@ -19396,6 +19711,144 @@ 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.
+ */
+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.
+ */
+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`.
+ */
+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. */
+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. */
+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) {
@@ -19412,12 +19865,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`.
  */
 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 [];
@@ -19425,45 +19879,36 @@ 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)
@@ -19484,6 +19929,57 @@ function buildYieldHistory(read, window, clock) {
         a.trancheId.localeCompare(b.trancheId));
 }
 
+/**
+ * How many epochs back the portfolio read pairs a tranche's newest interest
+ * with the shares in force at its clearing (`lendingPortfolioQuery`): the last
+ * six settled epochs, so a pool whose clearings run late or lag a few weeks
+ * behind the others (Base has one) is paired too. A pool whose newest
+ * interest is older (pools clear independently; some only when the
+ * originator repays) is priced from a history read of its own, at that
+ * epoch. The extra rows are a few per lender and tranche.
+ */
+const RECENT_PAIRING_EPOCHS = 6;
+/**
+ * The ledger (subgraph) and the chain agree on a balance AT THE SAME BLOCK
+ * within a cent, or a millionth of it — the rounding of two share-price
+ * conversions.
+ */
+const BALANCE_RECONCILE_TOLERANCE = 0.01;
+const BALANCE_RECONCILE_RELATIVE = 1e-6;
+function ledgerAgrees(ledger, chain) {
+    return (Math.abs(ledger - chain) <=
+        Math.max(BALANCE_RECONCILE_TOLERANCE, Math.abs(chain) * BALANCE_RECONCILE_RELATIVE));
+}
+/**
+ * A list read with `first: $first` that comes back FULL may have been cut:
+ * refuse it rather than price from a truncated read.
+ */
+function refuseTruncated(data) {
+    var _a, _b;
+    const full = (rows) => { var _a; return ((_a = rows === null || rows === void 0 ? void 0 : rows.length) !== null && _a !== void 0 ? _a : 0) >= YIELD_HISTORY_PAGE_SIZE; };
+    const lists = [
+        ['lendingPoolClearings', full(data.lendingPoolClearings)],
+        ['recentWithdrawalsAccepted', full(data.recentWithdrawalsAccepted)],
+    ];
+    for (const pool of (_b = (_a = data.user) === null || _a === void 0 ? void 0 : _a.lendingPoolUserDetails) !== null && _b !== void 0 ? _b : []) {
+        for (const position of pool.lendingPoolTrancheUserDetails) {
+            lists.push([
+                'recentUserShareUpdates',
+                full(position.recentUserShareUpdates),
+            ], [
+                'recentTrancheShareUpdates',
+                full(position.tranche.recentTrancheShareUpdates),
+            ], ...position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => [
+                'lockSharesRecent',
+                full(lock.lockSharesRecent),
+            ]));
+        }
+    }
+    const cut = lists.find(([, isFull]) => isFull);
+    if (cut) {
+        throw new Error(`getPortfolioLendingData: ${cut[0]} reached ${String(YIELD_HISTORY_PAGE_SIZE)} rows; refusing a possibly truncated read`);
+    }
+}
 class Portfolio {
     constructor(_kasuConfig, signerOrProvider) {
         this._kasuConfig = _kasuConfig;
@@ -19701,23 +20197,52 @@ class Portfolio {
     }
     getPortfolioLendingData(userAddress, poolOverviews, currentEpoch, provider) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
             const SECONDS_PER_EPOCH = 604800; // seconds in a week
             const portfolioLendingPoolsPromise = [];
             const previousEpoch = ethers.BigNumber.from(currentEpoch).sub(ethers.BigNumber.from(1));
-            const [lastEpochData, portfolioUserTrancheBalances, userPoolBalances] = yield Promise.all([
-                this._graph.request(lendingPortfolioQuery, {
-                    userAddress: userAddress.toLowerCase(),
-                    epochId: parseFloat(currentEpoch),
-                    lastEpochId: previousEpoch.toNumber(),
-                    unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
-                    first: YIELD_HISTORY_PAGE_SIZE,
-                }),
-                this._userLendingService.getPortfolioUserTrancheBalances(userAddress),
-                this._userLendingService.getUserPoolBalance(userAddress, poolOverviews.map(({ id }) => id), provider),
-            ]);
+            const recentEpoch = Math.max(0, previousEpoch.toNumber() - (RECENT_PAIRING_EPOCHS - 1));
+            const unused = new Set(this._kasuConfig.UNUSED_LENDING_POOL_IDS.map((id) => id.toLowerCase()));
+            const listedPools = poolOverviews.filter(({ id }) => !unused.has(id.toLowerCase()));
+            const lastEpochData = yield this._graph.request(lendingPortfolioQuery, {
+                userAddress: userAddress.toLowerCase(),
+                epochId: parseFloat(currentEpoch),
+                lastEpochId: previousEpoch.toNumber(),
+                recentEpoch,
+                lockRecentEpoch: Math.max(0, recentEpoch - 1),
+                unusedPools: this._kasuConfig.UNUSED_LENDING_POOL_IDS,
+                poolIds: listedPools.map(({ id }) => id.toLowerCase()),
+                trancheIds: listedPools.flatMap(({ tranches }) => tranches.map(({ id }) => id.toLowerCase())),
+                first: YIELD_HISTORY_PAGE_SIZE,
+            });
             if (!lastEpochData.user)
                 return [];
+            refuseTruncated(lastEpochData);
+            // The pools the lender has a ledger in AND that are listed: the only
+            // ones read on chain, and the only ones reported.
+            const userPools = listedPools.flatMap((overview) => {
+                var _a;
+                const details = (_a = lastEpochData.user) === null || _a === void 0 ? void 0 : _a.lendingPoolUserDetails.find(({ lendingPool }) => lendingPool.id.toLowerCase() === overview.id.toLowerCase());
+                return details ? [{ overview, details }] : [];
+            });
+            const recentStarts = clearingStarts(lastEpochData.lendingPoolClearings);
+            const recentExits = new Map();
+            for (const exit of lastEpochData.recentWithdrawalsAccepted) {
+                const list = (_a = recentExits.get(exit.tranche.id)) !== null && _a !== void 0 ? _a : [];
+                list.push(exit);
+                recentExits.set(exit.tranche.id, list);
+            }
+            const [chain, staleYields] = yield Promise.all([
+                this.readChainAt((_b = lastEpochData._meta) === null || _b === void 0 ? void 0 : _b.block.number, (blockTag) => this._userLendingService.getUserPoolBalancesAt(userAddress, userPools.map(({ overview }) => overview.id), provider, blockTag)),
+                this.staleLastEpochYields(userPools.flatMap(({ overview, details }) => details.lendingPoolTrancheUserDetails.map((position) => ({
+                    poolId: overview.id,
+                    position,
+                }))), recentEpoch),
+            ]);
+            const reconciled = yield Promise.all(userPools.map(({ overview, details }, index) => {
+                var _a;
+                return this.reconcilePool(userAddress, overview, details, (_a = chain.values[index]) !== null && _a !== void 0 ? _a : ethers.BigNumber.from(0), chain.blockTag, provider);
+            }));
             const userRequestsMap = new Map();
             for (const userRequest of lastEpochData.userRequests) {
                 const trancheId = userRequest.tranche.id;
@@ -19743,28 +20268,22 @@ class Portfolio {
                         continue;
                     }
                     userRequestsMap.set(trancheId, Object.assign(Object.assign({}, mappedUserRequest), { [ftdId]: [
-                            ...((_a = mappedUserRequest[ftdId]) !== null && _a !== void 0 ? _a : []),
+                            ...((_c = mappedUserRequest[ftdId]) !== null && _c !== void 0 ? _c : []),
                             userRequestFtdItem,
                         ] }));
                 }
             }
-            let totalInvestments = ethers.BigNumber.from(0);
-            for (const poolOverview of poolOverviews) {
-                const userPoolBalance = userPoolBalances.find(({ poolId }) => poolId === poolOverview.id);
-                if (!userPoolBalance) {
-                    continue;
-                }
-                totalInvestments = userPoolBalance.balance.add(totalInvestments);
+            for (const [poolIndex, { overview: poolOverview, details },] of userPools.entries()) {
+                const pool = reconciled[poolIndex];
                 const tranches = [];
                 let poolYieldEarnedLastEpoch = 0;
-                const lendingPoolUserDetails = lastEpochData.user.lendingPoolUserDetails.find(({ lendingPool }) => lendingPool.id === poolOverview.id);
-                if (!lendingPoolUserDetails)
-                    continue;
-                const portfolioUserTrancheBalance = portfolioUserTrancheBalances.get(poolOverview.id);
+                // A ledger crediting shares the wallet does not hold earns
+                // nothing we can vouch for: its last-cycle figures are withheld.
+                const withheld = ((_d = pool.mismatch) === null || _d === void 0 ? void 0 : _d.kind) === 'ledger-exceeds-chain';
                 for (const tranche of poolOverview.tranches) {
-                    const lastEpochUserTrancheDetails = lendingPoolUserDetails.lendingPoolTrancheUserDetails.find((lendingPool) => lendingPool.tranche.id === tranche.id);
+                    const lastEpochUserTrancheDetails = details.lendingPoolTrancheUserDetails.find((lendingPool) => lendingPool.tranche.id === tranche.id);
                     const userRequest = userRequestsMap.get(tranche.id);
-                    const depositDetails = (_b = userRequest === null || userRequest === void 0 ? void 0 : userRequest['0']) !== null && _b !== void 0 ? _b : [];
+                    const depositDetails = (_e = userRequest === null || userRequest === void 0 ? void 0 : userRequest['0']) !== null && _e !== void 0 ? _e : [];
                     if (!lastEpochUserTrancheDetails) {
                         tranches.push(Object.assign(Object.assign({}, tranche), { investedAmount: {
                                 balance: '0',
@@ -19775,55 +20294,61 @@ class Portfolio {
                             }, depositDetails, fixedLoans: [] }));
                         continue;
                     }
-                    const lastEpoch = previousEpoch.toNumber();
-                    const userHasLastEpochShares = Boolean((_c = lastEpochUserTrancheDetails
-                        .lendingPoolTrancheUserEpochSharesUpdates) === null || _c === void 0 ? void 0 : _c.length);
+                    // The tranche's newest interest (epoch E), priced with the
+                    // shares in force when clearing E applied it — the one
+                    // selection `getYieldHistory` makes (`positionEpochYield`).
+                    // Inside the recent window the candidates below are complete.
+                    // An older E (a pool that clears rarely — some only when the
+                    // originator repays) is priced from a history read of its own,
+                    // and is 0 for a lender who has left the tranche.
+                    const newestInterest = (_f = lastEpochUserTrancheDetails.tranche
+                        .lendingPoolTrancheEpochInterest) === null || _f === void 0 ? void 0 : _f[0];
+                    const interestEpoch = (newestInterest === null || newestInterest === void 0 ? void 0 : newestInterest.epochId) === undefined
+                        ? undefined
+                        : Number(newestInterest.epochId);
                     const fixedTermDeposits = lastEpochUserTrancheDetails.userLendingPoolTrancheFixedTermDepositLocks;
-                    // The one per-epoch formula `getYieldHistory` runs too, with
-                    // the same share selection — so the last bar of a history
-                    // equals these figures.
-                    const lastEpochYield = epochTrancheYield({
-                        epochInterest: parseFloat((_f = (_e = (_d = lastEpochUserTrancheDetails.tranche
-                            .lendingPoolTrancheEpochInterest) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.epochInterestAmount) !== null && _f !== void 0 ? _f : '0'),
-                        userShares: parseFloat((_j = (_h = (_g = lastEpochUserTrancheDetails
-                            .lendingPoolTrancheUserEpochSharesUpdates) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h.shares) !== null && _j !== void 0 ? _j : '0'),
-                        trancheShares: parseFloat((_m = (_l = (_k = lastEpochUserTrancheDetails.tranche
-                            .lendingPoolTrancheShareUpdates) === null || _k === void 0 ? void 0 : _k[0]) === null || _l === void 0 ? void 0 : _l.shares) !== null && _m !== void 0 ? _m : '0'),
-                        trancheBalanceNow: parseFloat(lastEpochUserTrancheDetails.tranche.balance),
-                        trancheSharesNow: parseFloat(lastEpochUserTrancheDetails.tranche.shares),
-                        locks: fixedTermDeposits.map((fixedTermDeposit) => {
-                            var _a, _b, _c, _d, _e, _f;
-                            return ({
-                                active: parseFloat(fixedTermDeposit.epochLockStart) <
-                                    lastEpoch &&
-                                    parseFloat(fixedTermDeposit.epochLockEnd) >=
-                                        lastEpoch &&
-                                    userHasLastEpochShares,
-                                // No snapshot = the lock's opening shares, exactly
-                                // as `getYieldHistory` reads it: a lock made after
-                                // clearing E starts at E with its first update
-                                // tagged E + 1. Never the CURRENT shares, which
-                                // would carry a top-up from a clearing that ran
-                                // after the last settled epoch.
-                                sharesAtEpoch: parseFloat((_c = (_b = (_a = fixedTermDeposit.lockSharesAtLastEpoch) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.shares) !== null && _c !== void 0 ? _c : fixedTermDeposit.initialTrancheShares),
-                                sharesBeforeEpoch: parseFloat((_f = (_e = (_d = fixedTermDeposit
-                                    .userLendingPoolTrancheFixedTermDepositLockShareUpdate) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.shares) !== null && _f !== void 0 ? _f : fixedTermDeposit.initialTrancheShares),
-                            });
-                        }),
-                    });
-                    const userTrancheBalance = {
-                        balance: '0',
-                        yieldEarned: 0,
+                    const noYield = {
+                        total: 0,
+                        variable: 0,
+                        locks: fixedTermDeposits.map(() => 0),
                     };
-                    if (portfolioUserTrancheBalance) {
-                        const portfolioUserTranche = portfolioUserTrancheBalance.find(({ trancheId }) => trancheId === tranche.id);
-                        if (portfolioUserTranche) {
-                            userTrancheBalance.balance =
-                                portfolioUserTranche.userBalance;
-                            userTrancheBalance.yieldEarned =
-                                portfolioUserTranche.yieldEarned;
-                        }
+                    let lastEpochYield = noYield;
+                    if (interestEpoch !== undefined &&
+                        interestEpoch < recentEpoch &&
+                        !withheld) {
+                        lastEpochYield =
+                            (_g = staleYields.get(lastEpochUserTrancheDetails.id)) !== null && _g !== void 0 ? _g : noYield;
+                    }
+                    else if (interestEpoch !== undefined && !withheld) {
+                        lastEpochYield = positionEpochYield({
+                            trancheBalanceNow: parseFloat(lastEpochUserTrancheDetails.tranche.balance),
+                            trancheSharesNow: parseFloat(lastEpochUserTrancheDetails.tranche.shares),
+                            userUpdates: [
+                                ...((_h = lastEpochUserTrancheDetails.lendingPoolTrancheUserEpochSharesUpdates) !== null && _h !== void 0 ? _h : []),
+                                ...((_j = lastEpochUserTrancheDetails.recentUserShareUpdates) !== null && _j !== void 0 ? _j : []),
+                            ],
+                            trancheUpdates: [
+                                ...((_k = lastEpochUserTrancheDetails.tranche
+                                    .lendingPoolTrancheShareUpdates) !== null && _k !== void 0 ? _k : []),
+                                ...((_l = lastEpochUserTrancheDetails.tranche
+                                    .recentTrancheShareUpdates) !== null && _l !== void 0 ? _l : []),
+                            ],
+                            exits: (_m = recentExits.get(tranche.id)) !== null && _m !== void 0 ? _m : [],
+                            locks: fixedTermDeposits.map((lock) => {
+                                var _a, _b;
+                                return (Object.assign(Object.assign({}, lock), { updates: [
+                                        ...((_a = lock.lockSharesBase) !== null && _a !== void 0 ? _a : []),
+                                        ...((_b = lock.lockSharesRecent) !== null && _b !== void 0 ? _b : []),
+                                    ] }));
+                            }),
+                        }, interestEpoch, parseFloat((_o = newestInterest === null || newestInterest === void 0 ? void 0 : newestInterest.epochInterestAmount) !== null && _o !== void 0 ? _o : '0'), (_p = recentStarts
+                            .get(poolOverview.id.toLowerCase())) === null || _p === void 0 ? void 0 : _p.get(interestEpoch)).yield;
                     }
+                    const ledger = pool.tranches.get(tranche.id);
+                    const userTrancheBalance = {
+                        balance: (_q = ledger === null || ledger === void 0 ? void 0 : ledger.balance) !== null && _q !== void 0 ? _q : '0',
+                        yieldEarned: (_r = ledger === null || ledger === void 0 ? void 0 : ledger.yieldEarned) !== null && _r !== void 0 ? _r : 0,
+                    };
                     let totalLifetimeFtdYield = 0;
                     const fixedLoans = fixedTermDeposits.map((fixedTermDeposit, lockIndex) => {
                         var _a, _b;
@@ -19871,7 +20396,9 @@ class Portfolio {
                         }, fixedLoans,
                         depositDetails }));
                 }
-                portfolioLendingPoolsPromise.push(Object.assign(Object.assign({}, poolOverview), { totalYieldEarningsLastEpoch: this.precisionToString(poolYieldEarnedLastEpoch), totalInvestedAmount: userPoolBalance.balance.toString(), totalYieldEarningsLifetime: userPoolBalance.yieldEarned.toString(), tranches }));
+                portfolioLendingPoolsPromise.push(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, poolOverview), { totalYieldEarningsLastEpoch: this.precisionToString(poolYieldEarnedLastEpoch), totalInvestedAmount: pool.chainBalance.toString(), totalYieldEarningsLifetime: pool.lifetime.toString() }), (pool.mismatch ? { ledgerMismatch: pool.mismatch } : {})), (chain.blockTag === undefined
+                    ? { chainPinned: false }
+                    : {})), { tranches }));
             }
             const portfolioLendingPools = portfolioLendingPoolsPromise.map((pool) => (Object.assign(Object.assign({}, pool), { tranches: pool.tranches.map((tranche) => {
                     const trancheBalance = tranche.investedAmount;
@@ -19882,7 +20409,14 @@ class Portfolio {
                     }, ethers.BigNumber.from(0));
                     const totalTrancheYieldEarned = trancheBalance.yieldEarned.toFixed(6);
                     const totalTrancheFtdYieldEarned = parseFloat(tranche.yieldEarnings.lifetime).toFixed(6);
-                    return Object.assign(Object.assign({}, tranche), { investedAmount: utils$2.formatEther(utils$2.parseEther(trancheBalance.balance).sub(lockedAmount)), yieldEarnings: Object.assign(Object.assign({}, tranche.yieldEarnings), { lifetime: this.precisionToString(parseFloat(totalTrancheYieldEarned) -
+                    // Never negative: a variable balance below the locked
+                    // amount is a ledger the chain does not back (the pool
+                    // carries `ledgerMismatch`), not money owed — flagged.
+                    const variableBalance = utils$2.parseEther(trancheBalance.balance).sub(lockedAmount);
+                    const floored = variableBalance.isNegative();
+                    return Object.assign(Object.assign(Object.assign(Object.assign({}, tranche), { investedAmount: utils$2.formatEther(floored ? ethers.BigNumber.from(0) : variableBalance) }), (floored
+                        ? { investedAmountFloored: true }
+                        : {})), { yieldEarnings: Object.assign(Object.assign({}, tranche.yieldEarnings), { lifetime: this.precisionToString(parseFloat(totalTrancheYieldEarned) -
                                 parseFloat(totalTrancheFtdYieldEarned)) }) });
                 }) })));
             return portfolioLendingPools.filter((pool) => !utils$2.parseUnits(pool.totalInvestedAmount).isZero() ||
@@ -19908,7 +20442,12 @@ class Portfolio {
      * Cost: three parallel `SystemVariables` reads and the positions query in
      * one round, then one subgraph request per page of the longest series
      * (1000 rows a page) — normally two subgraph round trips in all, never one
-     * per epoch.
+     * per epoch — alongside one `LendingPool.userBalance` call per pool at
+     * the subgraph's block. A pool whose ledger credits more than the wallet
+     * holds at that block (shares moved away outside a withdrawal) is left
+     * out; if the node says it cannot serve that block, `latest` is read
+     * and nothing is. Any other failure of those reads (a rate limit, a
+     * network error) THROWS: the history needs a working RPC.
      *
      * On a LITE deployment, a subgraph that lacks the entities (a validation
      * error naming them) yields `[]`; on a full deployment that error throws,
@@ -19919,6 +20458,7 @@ class Portfolio {
      */
     getYieldHistory(userAddress_1) {
         return __awaiter(this, arguments, void 0, function* (userAddress, options = {}) {
+            var _a;
             validateYieldHistoryOptions(options);
             try {
                 const [currentEpoch, epochZeroStart, epochDuration, positions] = yield Promise.all([
@@ -19937,7 +20477,9 @@ class Portfolio {
                 const userTranches = [];
                 const tranches = new Set();
                 const locks = [];
+                const pools = [];
                 for (const pool of positions.user.lendingPoolUserDetails) {
+                    pools.push(pool.lendingPool.id);
                     for (const position of pool.lendingPoolTrancheUserDetails) {
                         userTranches.push(position.id);
                         tranches.add(position.tranche.id);
@@ -19948,11 +20490,33 @@ class Portfolio {
                 }
                 if (userTranches.length === 0)
                     return [];
-                const { rows } = yield fetchYieldHistorySeries((variables) => this._graph.request(yieldHistoryPageQuery, variables), { tranches: [...tranches], userTranches, locks }, window);
+                const [{ rows }, chain] = yield Promise.all([
+                    fetchYieldHistorySeries((variables) => this._graph.request(yieldHistoryPageQuery, variables), { pools, tranches: [...tranches], userTranches, locks }, window),
+                    this.readChainAt((_a = positions._meta) === null || _a === void 0 ? void 0 : _a.block.number, (blockTag) => this._userLendingService.getUserPoolBalancesAt(userAddress, pools, undefined, blockTag)),
+                ]);
+                // A pool whose ledger credits shares the wallet does not hold at
+                // the same block (shares moved away outside a withdrawal) has no
+                // history we can vouch for: it is left out. Unpinned, nothing is.
+                const decimals = this._kasuConfig.stableAssetDecimals;
+                const withheld = new Set();
+                if (chain.blockTag !== undefined) {
+                    positions.user.lendingPoolUserDetails.forEach((pool, index) => {
+                        var _a;
+                        const ledger = pool.lendingPoolTrancheUserDetails.reduce((sum, position) => {
+                            var _a;
+                            return sum +
+                                parseFloat(this._userLendingService.convertSharesToAssets((_a = position.shares) !== null && _a !== void 0 ? _a : '0', position.tranche.balance, position.tranche.shares));
+                        }, 0);
+                        const held = parseFloat(utils$2.formatUnits((_a = chain.values[index]) !== null && _a !== void 0 ? _a : ethers.BigNumber.from(0), decimals));
+                        if (ledger > held && !ledgerAgrees(ledger, held)) {
+                            withheld.add(pool.lendingPool.id.toLowerCase());
+                        }
+                    });
+                }
                 return buildYieldHistory(Object.assign({ positions }, rows), window, {
                     epochZeroStart: epochZeroStart.toNumber(),
                     epochDuration: epochDuration.toNumber(),
-                });
+                }).filter((entry) => !withheld.has(entry.poolId.toLowerCase()));
             }
             catch (error) {
                 if (isEmptyHistoryError(error, this._isLiteDeployment))
@@ -19961,6 +20525,164 @@ class Portfolio {
             }
         });
     }
+    /**
+     * Read the chain at the subgraph's block, so the chain and the ledger
+     * describe the same state: after every clearing the subgraph runs a few
+     * blocks behind, and a `latest` read would then disagree with an
+     * honest ledger (interest moved every balance, deposits were accepted)
+     * and book that difference as a ledger fault.
+     *
+     * Only when the node says it cannot serve that block (pruned, or behind
+     * the subgraph: `isBlockUnavailableError`) does it fall back to `latest`,
+     * and it says so (`blockTag: undefined`): unpinned figures are never
+     * compared with the ledger, and `getPortfolioLendingData` marks the pools
+     * `chainPinned: false`. Any other failure — a rate limit, a timeout, a
+     * network error — is thrown, never turned into an unpinned read.
+     */
+    readChainAt(block, read) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (block !== undefined) {
+                try {
+                    return { values: yield read(block), blockTag: block };
+                }
+                catch (error) {
+                    if (!isBlockUnavailableError(error))
+                        throw error;
+                }
+            }
+            return { values: yield read(undefined), blockTag: undefined };
+        });
+    }
+    /**
+     * One pool's balances: the ledger's (the subgraph counts a lender's
+     * shares as accepted deposits − accepted withdrawals ± top-ups) checked
+     * against the chain's `LendingPool.userBalance` at the SAME block.
+     *
+     * The ledger does not follow shares that move between wallets any other
+     * way (an administrative move of a position is the case seen on chain):
+     * the receiving wallet goes negative as it withdraws, the sending one
+     * keeps shares it no longer holds. Where the two disagree at that block —
+     * or any ledger balance is negative — the tranche balances are read from
+     * the chain at that block (`userActiveAssets`, one call per tranche), the
+     * tranche's ledger `yieldEarned` moves by the same difference, and the
+     * pool carries `ledgerMismatch`. Unpinned (the node could not serve the
+     * block), only a negative ledger balance is corrected. A pool that agrees
+     * — every ordinary lender — costs nothing extra.
+     *
+     * Lifetime figures stay ledger figures: they cannot tell moved principal
+     * from interest.
+     */
+    reconcilePool(userAddress, overview, details, chainBalance, blockTag, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const decimals = this._kasuConfig.stableAssetDecimals;
+            const chainTotal = parseFloat(utils$2.formatUnits(chainBalance, decimals));
+            const lifetime = chainTotal -
+                parseFloat(details.totalAcceptedDeposits) +
+                parseFloat(details.totalAcceptedWithdrawnAmount);
+            const tranches = new Map();
+            for (const position of details.lendingPoolTrancheUserDetails) {
+                const balance = this._userLendingService.convertSharesToAssets(position.shares, position.tranche.balance, position.tranche.shares);
+                tranches.set(position.tranche.id, {
+                    balance,
+                    yieldEarned: parseFloat(balance) -
+                        parseFloat(position.totalAcceptedDeposits) +
+                        parseFloat(position.totalAcceptedWithdrawnAmount),
+                });
+            }
+            const ledgerTotal = [...tranches.values()].reduce((sum, { balance }) => sum + parseFloat(balance), 0);
+            const negative = [...tranches.values()].some(({ balance }) => parseFloat(balance) < 0);
+            const disagrees = blockTag !== undefined && !ledgerAgrees(ledgerTotal, chainTotal);
+            if (!negative && !disagrees) {
+                return { chainBalance, lifetime, tranches };
+            }
+            const trancheIds = [
+                ...new Set([
+                    ...overview.tranches.map(({ id }) => id),
+                    ...tranches.keys(),
+                ]),
+            ];
+            const onChain = yield this._userLendingService.getUserTrancheActiveAssets(userAddress, trancheIds, provider, blockTag);
+            let phantom = false;
+            const reconciled = new Map();
+            for (const [index, trancheId] of trancheIds.entries()) {
+                const fromLedger = tranches.get(trancheId);
+                const ledgerBalance = parseFloat((_a = fromLedger === null || fromLedger === void 0 ? void 0 : fromLedger.balance) !== null && _a !== void 0 ? _a : '0');
+                const balance = utils$2.formatUnits((_b = onChain[index]) !== null && _b !== void 0 ? _b : ethers.BigNumber.from(0), decimals);
+                if (blockTag !== undefined &&
+                    ledgerBalance > parseFloat(balance) &&
+                    !ledgerAgrees(ledgerBalance, parseFloat(balance))) {
+                    phantom = true;
+                }
+                reconciled.set(trancheId, {
+                    balance,
+                    yieldEarned: ((_c = fromLedger === null || fromLedger === void 0 ? void 0 : fromLedger.yieldEarned) !== null && _c !== void 0 ? _c : 0) +
+                        parseFloat(balance) -
+                        ledgerBalance,
+                });
+            }
+            return {
+                chainBalance,
+                lifetime,
+                tranches: reconciled,
+                mismatch: {
+                    kind: phantom ? 'ledger-exceeds-chain' : 'chain-exceeds-ledger',
+                    ledgerBalance: String(ledgerTotal),
+                    chainBalance: String(chainTotal),
+                },
+            };
+        });
+    }
+    /**
+     * The last-epoch figures of positions whose newest interest is OLDER than
+     * the recent window. Pools clear independently, and some clear only when
+     * the originator repays, so a pool's last cycle can be weeks back: it is
+     * priced at THAT epoch, from a history read of just those positions over
+     * just those epochs, through the same `positionEpochYield` — so it equals
+     * the history's newest bar.
+     *
+     * A lender who has since left the tranche (no ledger shares now) gets no
+     * figure: an old pool's last cycle is not theirs to show. Costs nothing
+     * when no position qualifies.
+     */
+    staleLastEpochYields(positions, recentEpoch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const stale = positions.flatMap(({ poolId, position }) => {
+                var _a;
+                const interest = (_a = position.tranche.lendingPoolTrancheEpochInterest) === null || _a === void 0 ? void 0 : _a[0];
+                if ((interest === null || interest === void 0 ? void 0 : interest.epochId) === undefined)
+                    return [];
+                if (!(parseFloat(position.shares) > 0))
+                    return [];
+                const epoch = Number(interest.epochId);
+                return epoch < recentEpoch
+                    ? [{ poolId, position, epoch, interest }]
+                    : [];
+            });
+            const yields = new Map();
+            if (stale.length === 0)
+                return yields;
+            const lockId = (poolId, lock) => { var _a; return (_a = lock.id) !== null && _a !== void 0 ? _a : `${poolId.toLowerCase()}-${lock.lockId}`; };
+            const { rows } = yield fetchYieldHistorySeries((variables) => this._graph.request(yieldHistoryPageQuery, variables), {
+                pools: [...new Set(stale.map(({ poolId }) => poolId))].map((id) => id.toLowerCase()),
+                tranches: [
+                    ...new Set(stale.map(({ position }) => position.tranche.id)),
+                ],
+                userTranches: stale.map(({ position }) => position.id),
+                locks: stale.flatMap(({ poolId, position }) => position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => lockId(poolId, lock))),
+            }, {
+                fromEpoch: Math.min(...stale.map(({ epoch }) => epoch)),
+                toEpoch: Math.max(...stale.map(({ epoch }) => epoch)),
+            });
+            const starts = clearingStarts(rows.clearings);
+            for (const { poolId, position, epoch, interest } of stale) {
+                const series = positionSeriesFrom(rows, Object.assign(Object.assign({}, position), { userLendingPoolTrancheFixedTermDepositLocks: position.userLendingPoolTrancheFixedTermDepositLocks.map((lock) => (Object.assign(Object.assign({}, lock), { id: lockId(poolId, lock) }))) }));
+                yields.set(position.id, positionEpochYield(series, epoch, parseFloat(interest.epochInterestAmount), (_a = starts.get(poolId.toLowerCase())) === null || _a === void 0 ? void 0 : _a.get(epoch)).yield);
+            }
+            return yields;
+        });
+    }
     /**
      * A money figure as a plain decimal string. Below a millionth of a token
      * (the stable asset's own precision) is float noise, never money, so it
@@ -31536,6 +32258,16 @@ function getTrancheDisplayName(trancheName, pool) {
  * window, and the accrual spreads an epoch's interest across it.
  */
 const SECONDS_PER_WEEK = 604800;
+/**
+ * The most unpaid interest {@link accruedInterestSince} shows for one pool:
+ * this many epochs of its weekly figure (owner ruling 2026-11-07).
+ *
+ * A pool can stop being cleared without being flagged stopped. On Base, one
+ * pool is more than six epochs behind and another more than a hundred.
+ * Uncapped, the figure would show interest that may never be credited. Four
+ * epochs covers any ordinary late clearing.
+ */
+const MAX_ACCRUAL_EPOCHS = 4;
 function isUsableFeePercent(feePercent) {
     return (feePercent !== null &&
         Number.isFinite(feePercent) &&
@@ -31589,28 +32321,40 @@ function dailyInterest(weekly) {
     return weekly / 7;
 }
 /**
- * Interest accrued since each pool's OWN last cycle close — the moving part
- * of lifetime interest (lifetime = settled on chain + this).
+ * Interest accrued since each pool's OWN last clearing transaction, capped at
+ * one epoch per pool.
  *
  * ```
  * accrued = Σ_pool  weekly_pool × clamp(now − clearing_pool, 0, 604 800) / 604 800
  * ```
  *
- * **Per pool, because pools clear independently.** One shared anchor accrues
- * a stale pool's share from a close it never had, and when another pool
- * clears it drops the total by the stale pool's whole weekly share. Anchored
- * per pool, the total is monotonic across any single pool's clearing: that
- * pool swaps its accrued share for a capitalised one, and no other term moves.
- *
- * **The one-epoch cap is load-bearing.** Clearings are not exactly weekly,
- * and `weeklyInterest` is per EPOCH, so extrapolating past seven days would
- * promise interest the close will not credit; a late clearing under-reports
- * instead. The low clamp makes a close ahead of the local clock zero, never
- * negative.
- *
+ * Per pool, because pools clear independently: one shared anchor accrues a
+ * stale pool's share from a close it never had, and when another pool clears
+ * it drops the total by the stale pool's whole weekly share.
+ *
+ * **The one-epoch cap rested on a wrong premise.** It assumed a late
+ * clearing credits only one epoch, so accruing past seven days would promise
+ * interest no close pays. The contracts say otherwise. `ClearingCoordinator`
+ * states that clearing "must be executed once per epoch for each lending
+ * pool" and that "clearing epochs must be executed in order"; `doClearing`
+ * reverts unless the target epoch is the pool's `nextLendingPoolClearingEpoch`,
+ * and it calls `LendingPool.applyInterests(targetEpoch)` on every clearing,
+ * late or not ("if clearing for the epoch is executed only after the clearing
+ * period, only yield will be applied"). Every missed epoch's interest is
+ * therefore credited when the clearings catch up — on Base, one pool cleared
+ * epochs 116 to 119 in the same block, four weeks credited at once.
+ * Capped, the figure freezes as soon as a clearing is a week late; anchored
+ * on the transaction, it also DIPS on a catch-up (elapsed resets to zero
+ * while only one week is credited per clearing).
+ *
+ * The low clamp makes a close ahead of the local clock zero, never negative.
  * A non-finite term contributes nothing; a non-finite `nowSeconds` accrues
- * nothing. Callers fail closed upstream by not offering an accrual for a pool
- * whose weekly interest or anchor is unknown.
+ * nothing.
+ *
+ * @deprecated Use {@link accruedInterestSince} with {@link epochAccrual}:
+ * identical while clearings run on time, and it keeps accruing, up to four
+ * epochs, when they run late. Kept, behaviour-identical, for existing
+ * callers.
  */
 function accruedInterest(accruals, nowSeconds) {
     if (!Number.isFinite(nowSeconds))
@@ -31625,6 +32369,181 @@ function accruedInterest(accruals, nowSeconds) {
     }
     return accrued;
 }
+/**
+ * Unix SECONDS at which `epoch` ENDS — the start of the next one:
+ *
+ * ```
+ * epochEnd(e) = initialEpochStart + (e + 1) × 604 800
+ * ```
+ *
+ * `SystemVariables.epochStartTimestamp(e)` is `initial + e × EPOCH_DURATION`,
+ * and the initial start is written once, at initialisation, so the end of any
+ * epoch follows from `epochStartTimestamp(0)` with no further read.
+ *
+ * FAILS CLOSED with `NaN`: a non-integer, non-finite or negative epoch, an
+ * initial start that is not a positive integer, or a result past
+ * `Number.MAX_SAFE_INTEGER`.
+ *
+ * @param initialEpochStart unix seconds, `epochStartTimestamp(0)`.
+ * @param epoch the epoch number, 0-based.
+ */
+function epochEndTimestamp(initialEpochStart, epoch) {
+    if (!Number.isSafeInteger(initialEpochStart) || initialEpochStart <= 0) {
+        return NaN;
+    }
+    if (!Number.isSafeInteger(epoch) || epoch < 0)
+        return NaN;
+    const end = initialEpochStart + (epoch + 1) * SECONDS_PER_WEEK;
+    return Number.isSafeInteger(end) ? end : NaN;
+}
+/**
+ * Builds one pool's {@link EpochAccrual} from what the chain and the subgraph
+ * say about its last clearing:
+ *
+ * ```
+ * epochEnd    = epochEndTimestamp(initialEpochStart, lastClearedEpoch)
+ * accruesFrom = min(clearingStartedAt, epochEnd)
+ * ```
+ *
+ * - **On time** (the clearing started inside its window, before its epoch
+ *   ended): `accruesFrom` is the clearing's start. Clearing applies the
+ *   epoch's interest first and only then accepts requests, so today's
+ *   balance — which includes a deposit that clearing accepted — is never
+ *   charged for time before it: a new lender starts at exactly 0.
+ * - **Late** (it started at or after its epoch end): `accruesFrom` is the
+ *   epoch end. A late clearing accepts no requests and credits exactly one
+ *   epoch, so the time it did not credit is kept.
+ *
+ * `lastClearedEpoch` is the newest epoch whose clearing has STARTED (the
+ * subgraph has a `LendingPoolClearing` for it), not the newest that has
+ * finished, and `clearingStartedAt` is that clearing's `startTimestamp`.
+ * `ClearingCoordinator.doClearing` mints the epoch's interest in its FIRST
+ * transaction (`applyInterests`), while `nextLendingPoolClearingEpoch` only
+ * advances when the clearing ENDS, so it is the wrong source.
+ *
+ * FAILS CLOSED with `null`: whatever {@link epochEndTimestamp} rejects, a
+ * `clearingStartedAt` that is not a finite positive number, or a
+ * `weeklyInterest` that is not finite or is negative. The caller then offers
+ * no term for that pool.
+ *
+ * @param input.weeklyInterest the pool's net interest for one epoch.
+ * @param input.initialEpochStart unix seconds, `epochStartTimestamp(0)`.
+ * @param input.lastClearedEpoch the newest epoch whose clearing has started.
+ * @param input.clearingStartedAt unix seconds, that clearing's start.
+ */
+function epochAccrual(input) {
+    const { weeklyInterest: weekly, clearingStartedAt } = input;
+    if (!Number.isFinite(weekly) || weekly < 0)
+        return null;
+    if (!Number.isFinite(clearingStartedAt) || clearingStartedAt <= 0) {
+        return null;
+    }
+    const epochEnd = epochEndTimestamp(input.initialEpochStart, input.lastClearedEpoch);
+    if (Number.isNaN(epochEnd))
+        return null;
+    return {
+        weeklyInterest: weekly,
+        accruesFrom: Math.min(clearingStartedAt, epochEnd),
+        epochEnd,
+    };
+}
+/**
+ * Interest accrued and not yet credited — the moving part of lifetime
+ * interest (lifetime = settled on chain + this). Per term, with
+ * `W` = 604 800 s:
+ *
+ * ```
+ * accrued = min( weekly × ( min(max(now − accruesFrom, 0), W)
+ *                         + max(now − (epochEnd + W), 0) ) / W,
+ *                MAX_ACCRUAL_EPOCHS × weekly )
+ * ```
+ *
+ * Read along the clock, for one pool:
+ * 1. from `accruesFrom`, one epoch of interest accrues linearly;
+ * 2. it then HOLDS from `accruesFrom + W` until `epochEnd + W`, the end of
+ *    the next epoch — at most 48 h after an on-time clearing (its clearing
+ *    window), no time at all after a late one (`accruesFrom == epochEnd`);
+ * 3. then it resumes, up to {@link MAX_ACCRUAL_EPOCHS} (4) epochs of
+ *    `weekly` in all, and stops there.
+ *
+ * **Why it keeps accruing past one epoch.** Clearing must run once per
+ * epoch for each pool, in order (`ClearingCoordinator.doClearing` reverts
+ * unless the target epoch is the pool's `nextLendingPoolClearingEpoch`), and
+ * every clearing, on time or late, starts with
+ * `LendingPool.applyInterests(targetEpoch)`. A missed epoch is therefore
+ * credited when the clearings catch up (on Base, one pool cleared epochs 116
+ * to 119 in the same block).
+ *
+ * **Why it stops at four epochs** (owner ruling 2026-11-07). A pool can stop
+ * being cleared without being flagged stopped. On Base today one pool is
+ * more than six epochs behind and another more than a hundred. Past four
+ * epochs the figure would show interest that may never be credited. Four
+ * covers any ordinary late clearing.
+ *
+ * **Why the hold.** Without it an on-time anchor accrues past one epoch
+ * while the next on-time clearing — which credits exactly one — is still to
+ * come, and the total steps DOWN when it lands. With it, at a constant
+ * balance, `settled + accrued` never steps down at a clearing (`t` = the
+ * NEW clearing's start, `E` = the end of the epoch it clears):
+ * - on time after on time: identical to the deprecated `accruedInterest`
+ *   at every instant. With `gap` = `t` − the previous clearing's start, it
+ *   steps UP by `weekly × (W − gap) / W` when `gap < W` (at most 2/7 of one
+ *   weekly, as before), and not at all when `gap ≥ W`;
+ * - late after on time, and late after late: exactly continuous;
+ * - on time after late: steps UP by `weekly × (E − t) / W`, at most 2/7 of
+ *   one weekly.
+ * A deposit or top-up accepted at an on-time clearing starts at 0, so it
+ * never dips the total either.
+ *
+ * **At the cap.** All of the above holds for a pool below the cap, where
+ * the cap changes nothing. A pool AT the cap shows `4 × weekly` before a
+ * catch-up clearing; after it, one more `weekly` is settled and the new term
+ * shows `min(elapsed′, 4 × weekly)`, so `after = min(elapsed′ + weekly,
+ * 5 × weekly) ≥ before`. Each clearing steps the total UP by at most one
+ * weekly until the pool is back under the cap. Never down, and never above
+ * settled plus `4 × weekly` per pool.
+ *
+ * **Never negative**, and non-decreasing in `now`. A term is skipped — it
+ * contributes nothing — when `weeklyInterest` is not finite or is negative,
+ * when `accruesFrom` or `epochEnd` is not finite, when `accruesFrom >
+ * epochEnd` (inconsistent: the anchor is never after the epoch end), or when
+ * an elapsed time overflows. A non-finite `nowSeconds` accrues nothing.
+ *
+ * **Per pool, because pools clear independently.** One shared anchor accrues
+ * a stale pool's share from a close it never had.
+ *
+ * **Accepted approximation.** `weekly` is today's balance at today's epoch
+ * rate. Over a multi-week gap the chain compounds weekly and may apply other
+ * epochs' rates, so a long accrual reads slightly LOW. It is a ticking
+ * estimate, not a ledger.
+ *
+ * Callers fail closed upstream: no term for a pool whose weekly interest or
+ * clearing is unknown (`epochAccrual` returns `null`), and none for a pool
+ * that has stopped — it will never clear again.
+ */
+function accruedInterestSince(accruals, nowSeconds) {
+    if (!Number.isFinite(nowSeconds))
+        return 0;
+    let accrued = 0;
+    for (const { weeklyInterest: weekly, accruesFrom, epochEnd } of accruals) {
+        if (!Number.isFinite(weekly) || weekly < 0)
+            continue;
+        if (!Number.isFinite(accruesFrom) || !Number.isFinite(epochEnd)) {
+            continue;
+        }
+        if (accruesFrom > epochEnd)
+            continue;
+        const sinceAnchor = nowSeconds - accruesFrom;
+        const sinceHoldEnd = nowSeconds - (epochEnd + SECONDS_PER_WEEK);
+        if (!Number.isFinite(sinceAnchor) || !Number.isFinite(sinceHoldEnd)) {
+            continue;
+        }
+        const elapsed = Math.min(Math.max(sinceAnchor, 0), SECONDS_PER_WEEK) +
+            Math.max(sinceHoldEnd, 0);
+        accrued += Math.min((weekly * elapsed) / SECONDS_PER_WEEK, MAX_ACCRUAL_EPOCHS * weekly);
+    }
+    return accrued;
+}
 /**
  * What `amount` earns in a year at a NET rate — the "≈ $Y a year" line.
  * Feed it `netEffectiveApy(...)`, never a gross APY: the result is a lender's
@@ -31693,6 +32612,7 @@ exports.INVALID_AUTH_SIGNATURE_MESSAGE = INVALID_AUTH_SIGNATURE_MESSAGE;
 exports.INVOICEMATE = INVOICEMATE;
 exports.Kasu = Kasu;
 exports.KasuSdk = KasuSdk;
+exports.MAX_ACCRUAL_EPOCHS = MAX_ACCRUAL_EPOCHS;
 exports.MAX_LENDING_AMOUNT_FALLBACK = MAX_LENDING_AMOUNT_FALLBACK;
 exports.MIN_DAYS_FOR_MONTHS = MIN_DAYS_FOR_MONTHS;
 exports.MIN_LENDING_AMOUNT_FALLBACK = MIN_LENDING_AMOUNT_FALLBACK;
@@ -31722,6 +32642,7 @@ exports.TvlHistoryInputError = TvlHistoryInputError;
 exports.UPPER_MEZZANINE = UPPER_MEZZANINE;
 exports.WithdrawFlow = WithdrawFlow;
 exports.accruedInterest = accruedInterest;
+exports.accruedInterestSince = accruedInterestSince;
 exports.aggregateYieldHistory = aggregateYieldHistory;
 exports.apyToEpochRate = apyToEpochRate;
 exports.asContractType = asContractType;
@@ -31753,6 +32674,8 @@ exports.encodeDepositData = encodeDepositData;
 exports.encodeRequestWithdrawalCall = encodeRequestWithdrawalCall;
 exports.encodeStableTransfer = encodeStableTransfer;
 exports.encodeWithdrawAtExpiryCall = encodeWithdrawAtExpiryCall;
+exports.epochAccrual = epochAccrual;
+exports.epochEndTimestamp = epochEndTimestamp;
 exports.epochRateToApy = epochRateToApy;
 exports.epochTrancheYield = epochTrancheYield;
 exports.explorerAddressUrl = explorerAddressUrl;