@kasufinance/kasu-sdk 2.14.0 → 2.16.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
@@ -18080,101 +18128,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 +18805,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 +18980,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 +19030,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 +19089,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 +19118,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 +19142,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 +19213,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 +19401,7 @@ const yieldHistoryPositionsQuery = gql `
                 }
                 lendingPoolTrancheUserDetails(first: $first) {
                     id
+                    shares
                     tranche {
                         id
                         balance
@@ -19196,32 +19416,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 +19494,7 @@ const yieldHistoryPageQuery = gql `
             epochId
             shareUpdatesIndex
             shares
+            timestamp
             lendingPoolTranche {
                 id
             }
@@ -19267,13 +19506,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 +19536,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 +19589,8 @@ function fetchYieldHistorySeries(request, ids, window) {
             trancheShares: [],
             userShares: [],
             lockShares: [],
+            clearings: [],
+            withdrawals: [],
         };
         const series = [
             { key: 'interest', flag: 'withInterest', cursor: 'interestCursor' },
@@ -19328,18 +19609,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 +19642,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) {
@@ -19380,21 +19679,159 @@ function fetchYieldHistorySeries(request, ids, window) {
     });
 }
 /**
- * The snapshot in force at `epoch`: among updates with `epochId ≤ epoch`, the
- * one with the highest `shareUpdatesIndex` — exactly what
- * `lendingPortfolioQuery` selects with `orderBy: shareUpdatesIndex, desc,
- * first: 1, where: { epochId_lt: epoch + 1 }`. `undefined` when none.
+ * The snapshot in force at `epoch`: among updates with `epochId ≤ epoch`, the
+ * one with the highest `shareUpdatesIndex` — exactly what
+ * `lendingPortfolioQuery` selects with `orderBy: shareUpdatesIndex, desc,
+ * first: 1, where: { epochId_lt: epoch + 1 }`. `undefined` when none.
+ */
+function sharesAsOf(updates, epoch) {
+    let found;
+    for (const update of updates) {
+        if (Number(update.epochId) > epoch)
+            continue;
+        if (!found || update.shareUpdatesIndex > found.shareUpdatesIndex) {
+            found = update;
+        }
+    }
+    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 sharesAsOf(updates, epoch) {
-    let found;
-    for (const update of updates) {
-        if (Number(update.epochId) > epoch)
+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;
-        if (!found || update.shareUpdatesIndex > found.shareUpdatesIndex) {
-            found = update;
-        }
+        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 found;
+    return starts;
 }
 function groupBy(rows, key) {
     const map = new Map();
@@ -19412,12 +19849,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 +19863,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 +19913,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 +20181,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 +20252,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 +20278,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 +20380,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 +20393,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 +20426,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 +20442,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 +20461,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 +20474,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 +20509,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
@@ -27878,19 +28584,30 @@ function buildLoanAgreementSignMessage(p) {
     ].join('\n');
 }
 /**
- * The legacy `/contract/generate` and `/contract/resolve` message.
+ * The legacy `/contract/generate` message.
  *
  * ⚠️ BYTE-EXACT PROTOCOL STRING. kasu-backend rebuilds it as
  * `` `I request contract content for ${address} at ${timestamp}.` `` from the
  * `address` and `timestamp` fields of the request body — so the string signed
  * and the body sent must agree exactly, INCLUDING the address casing. This
  * builder lowercases, and the request body must carry the same lowercased
- * address; that is what both apps signing this format do today.
+ * address.
  *
  * The backend takes this path whenever the four human-readable display fields
- * are absent, and documents it as permanent until the legacy app is
- * decommissioned. `/contract/resolve` has no other format — every consumer
- * signs this one to retrieve an existing agreement.
+ * are absent. Only the retired kasu-fe-next app (retired 2026-11-05) and
+ * kasu-mobile builds from before 2026-09-06 signed it; every current consumer
+ * signs `buildLoanAgreementSignMessage`. The backend keeps accepting it until
+ * no such mobile build is left in use.
+ *
+ * It is NOT the `/contract/resolve` message. Resolve has a message of its own
+ * (`Requesting contract content for {address}/{id} at {timestamp}.`), which
+ * kasu-backend rebuilds and verifies, so it does not depend on this format.
+ *
+ * @deprecated Sign the human-readable loan-agreement message
+ *   (`buildLoanAgreementSignMessage`, `contractMessage.format:
+ *   'loan-agreement'`) instead. Only the retired kasu-fe-next app and
+ *   pre-2026-09-06 kasu-mobile builds used this format; it will be removed in
+ *   the next major version.
  *
  * @param timestampMs ms-epoch, and the same value sent as the body's
  *   `timestamp`.
@@ -29309,6 +30026,381 @@ function maxNetRateCeiling(pools, feePercent) {
     return rate;
 }
 
+/**
+ * The CMS-authored figures and text a strategy's Details screen shows, read
+ * the way kasu-ui's Details tab reads them, so every app shows the same
+ * thing.
+ *
+ * Lifted from kasu-ui (`lib/details-fields.ts`, `lib/directus-text.ts` and
+ * the parsers inside `deposit-dialog/details-tab.tsx`). The rules are facts
+ * about how the CMS is authored, not presentation:
+ *
+ *   - EMPTY IS UNAUTHORED. The CMS stores an emptied field as `''`, and its
+ *     "numeric" fields arrive as a number, a numeric string, `''` or `null`.
+ *     Anything that is not real data reads as `undefined` — never a `0`, a
+ *     placeholder or a sentence of the SDK's own. A field the caller cannot
+ *     read is a row the caller omits.
+ *   - A START DATE MUST DATE. A value that is not an ISO date, or a real
+ *     calendar date, or is before 2000 or in the future, is refused: rendered
+ *     as elapsed time it would claim a history nobody authored.
+ *   - SOME FIELDS CARRY TWO LINES IN ONE STRING. Business Types and Facility
+ *     Type are a primary value and a qualifying clause; risk-item
+ *     descriptions can be numbered enumerations. Splitting them is the same
+ *     everywhere, so it lives here.
+ *
+ * Like `pickShortDescription`, this authors no string of its own: it selects,
+ * splits and trims text the CMS already holds. None of it is sanitised —
+ * render every string as text, never as HTML or markdown.
+ *
+ * Pure. No clock: the date reader takes `now` from its caller.
+ */
+// ---------------------------------------------------------------------------
+// Start dates
+// ---------------------------------------------------------------------------
+/**
+ * `YYYY-MM-DD`, optionally followed by a time part — the two shapes a CMS
+ * date column serialises to. Checked BEFORE any parse: `new Date('Jun 2024')`
+ * is a valid date in V8, so an editorial string would otherwise become a
+ * confident duration.
+ */
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ].*)?$/;
+/** Nothing on Kasu has a lending history from before this year. */
+const EARLIEST_YEAR = 2000;
+/**
+ * A CMS start date as its `YYYY-MM-DD` date head, or `undefined`.
+ *
+ * Accepts an ISO date, optionally with a time part (only the date head is
+ * kept — a time changes nothing at year/month granularity, and converting it
+ * through a timezone could move it a day). Refused, as `undefined`:
+ *
+ *   - anything that is not a string (or, with `unixSeconds`, a number);
+ *   - an empty or blank string (unauthored);
+ *   - a string that is not ISO-shaped (`'Jun 2024'`);
+ *   - a date that does not exist (`'2024-02-30'`, `'2024-13-01'`) — never
+ *     rolled over into the next month;
+ *   - a year before 2000;
+ *   - a date after `now` (a typo such as 2062 for 2026 — no history has
+ *     begun in the future).
+ *
+ * `now` is the caller's clock; the facade passes the current time.
+ */
+function readCmsStartDate(value, now, options = {}) {
+    let head;
+    if (typeof value === 'number' && options.unixSeconds) {
+        // `0` is formatDuration's "unset" sentinel; negatives are pre-1970.
+        if (!Number.isFinite(value) || value <= 0)
+            return undefined;
+        const date = new Date(value * 1000);
+        if (Number.isNaN(date.getTime()))
+            return undefined;
+        head = date.toISOString().slice(0, 10);
+    }
+    else if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!ISO_DATE.test(trimmed))
+            return undefined;
+        head = trimmed.slice(0, 10);
+    }
+    else {
+        return undefined;
+    }
+    const match = ISO_DATE.exec(head);
+    if (!match)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    // Round-trip through UTC: a day or month out of range comes back as a
+    // different date, which is how a non-existent date is caught.
+    const utc = new Date(Date.UTC(year, month - 1, day));
+    if (utc.getUTCFullYear() !== year ||
+        utc.getUTCMonth() !== month - 1 ||
+        utc.getUTCDate() !== day) {
+        return undefined;
+    }
+    if (year < EARLIEST_YEAR)
+        return undefined;
+    if (utc.getTime() > now.getTime())
+        return undefined;
+    return head;
+}
+/**
+ * Business Types (the CMS `industryExposure`), split into the value and its
+ * supporting clause on the FIRST newline, else the FIRST parenthesised
+ * segment (a trailing `)` dropped):
+ *
+ *   `'SMEs & Large Businesses (diversified industries – exclusions apply)'`
+ *   → `{ primary: 'SMEs & Large Businesses', detail: 'diversified industries – exclusions apply' }`
+ *
+ * A value with neither delimiter is `{ primary }` alone. `undefined` for a
+ * missing, non-string, empty or blank value.
+ *
+ * REFINED over kasu-ui: a value that OPENS with `(` would split to an empty
+ * primary there; here the whole value is the primary instead, so `primary`
+ * is never empty. No live record has that shape.
+ */
+function splitBusinessTypes(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value)
+        return undefined;
+    let primary = value;
+    let detail = '';
+    const newlineAt = value.indexOf('\n');
+    if (newlineAt !== -1) {
+        primary = value.slice(0, newlineAt).trim();
+        detail = value.slice(newlineAt + 1).trim();
+    }
+    else {
+        const parenAt = value.indexOf('(');
+        if (parenAt !== -1) {
+            primary = value.slice(0, parenAt).trim();
+            detail = value.slice(parenAt + 1).trim();
+            if (detail.endsWith(')'))
+                detail = detail.slice(0, -1).trim();
+        }
+    }
+    if (!primary)
+        return { primary: value };
+    return detail ? { primary, detail } : { primary };
+}
+/**
+ * The start of the label, or a character that is neither a word character
+ * nor a hyphen, before `revolv` — not `\b`, which treats a hyphen as a
+ * boundary, so "Non-Revolving" would match. kasu-ui writes the same rule as
+ * the lookbehind `(?<![\w-])`; this form needs no lookbehind support from the
+ * JavaScript engine.
+ */
+const REVOLVING_FACILITY = /(?:^|[^\w-])revolv\w*\b/i;
+/**
+ * Facility Type (the CMS `loanStructure`): the label on the FIRST line, and
+ * everything after the first newline as its clause, so a clause with line
+ * breaks of its own stays whole.
+ *
+ *   `'Revolving Instalment Facility\n12-24 months instalment loan, subject to annual review'`
+ *   → `{ label: 'Revolving Instalment Facility', detail: '12-24 months …', revolving: true }`
+ *
+ * `undefined` for a missing, non-string, empty or blank value. The value is
+ * trimmed first, so a leading blank line still yields a label.
+ */
+function parseFacility(raw) {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (!value)
+        return undefined;
+    const breakAt = value.indexOf('\n');
+    const label = (breakAt === -1 ? value : value.slice(0, breakAt)).trim();
+    const detail = breakAt === -1 ? '' : value.slice(breakAt + 1).trim();
+    const revolving = REVOLVING_FACILITY.test(label);
+    return detail ? { label, detail, revolving } : { label, revolving };
+}
+// ---------------------------------------------------------------------------
+// Risk Management
+// ---------------------------------------------------------------------------
+/**
+ * The order the Risk Management groups read in, by group name (compared
+ * trimmed, case-insensitively). The CMS returns items in authoring order,
+ * which is not this. A group not listed still appears — after these, in CMS
+ * order.
+ */
+const RISK_GROUP_ORDER = Object.freeze([
+    'Security & Recourse',
+    'Structural Controls',
+    'Financial Covenants',
+    'Reporting Covenants',
+    'Key Eligibility Criteria',
+]);
+/** Zero-width paste artifacts, which `\s` does not match. */
+const ZERO_WIDTH = /[​-‍]/g;
+/** An `N)` marker at the start, or after a `;` / `; and,` separator. */
+const HAS_ENUMERATION = /(?:^\d+\)|;\s*(?:and,?\s*)?\d+\))/;
+const ENUMERATION_SPLIT = /(?:^|\s*;\s*(?:and,?\s*)?)\d+\)\s*/;
+/** kasu-ui's stub for an unauthored description; never a clause. */
+const EMPTY_DESCRIPTION = '—';
+/**
+ * A risk-item description as the lines beneath the item's name.
+ *
+ * A numbered enumeration (`'1) Foo; and, 2) Bar'`, or one that omits its
+ * leading `1)`: `'Foo; 2) Bar'`) is one line per clause; anything else is
+ * one line. Zero-width characters are stripped first. An unauthored
+ * description is NO lines (`[]`), never a dash.
+ */
+function splitNumberedClauses(description) {
+    const raw = cleanDescription(description);
+    if (!raw)
+        return [];
+    const clauses = HAS_ENUMERATION.test(raw)
+        ? raw
+            .split(ENUMERATION_SPLIT)
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0)
+        : [raw];
+    const lines = clauses.length > 0 ? clauses : [raw];
+    return lines.filter((line) => line !== EMPTY_DESCRIPTION);
+}
+/** A description with zero-width characters stripped, trimmed; `''` when not a string. */
+function cleanDescription(description) {
+    return typeof description === 'string'
+        ? description.replace(ZERO_WIDTH, '').trim()
+        : '';
+}
+/**
+ * Risk-management items grouped by their group, the groups in
+ * `RISK_GROUP_ORDER` and, within a group, the items in CMS order.
+ *
+ * An item with no name, or no group, is left out: there is nothing to head
+ * its lines with, or no group to place it in. (The CMS joins items to groups
+ * by name, so neither occurs in live data.) No group is ever empty, so an
+ * item list with nothing usable gives `[]`.
+ */
+function groupRiskManagementItems(items) {
+    const groups = new Map();
+    for (const source of items) {
+        const name = trimmedOrUndefined(source.name);
+        const group = trimmedOrUndefined(source.group);
+        if (!name || !group)
+            continue;
+        const clauses = splitNumberedClauses(source.description);
+        // The same cleaned text the clauses come from, and only when they
+        // say something: a description of "—" or of zero-width characters
+        // alone is unauthored, so it is absent here too, never a stray dash.
+        const description = clauses.length > 0 ? cleanDescription(source.description) : '';
+        const tooltip = trimmedOrUndefined(source.tooltip);
+        const item = Object.assign(Object.assign(Object.assign({ name }, (description ? { description } : {})), { clauses }), (tooltip ? { tooltip } : {}));
+        const existing = groups.get(group);
+        if (existing)
+            existing.items.push(item);
+        else
+            groups.set(group, { group, items: [item] });
+    }
+    // Array.prototype.sort is stable, so unlisted groups keep CMS order.
+    return [...groups.values()].sort((a, b) => riskGroupRank(a.group) - riskGroupRank(b.group));
+}
+const RISK_GROUP_RANK = new Map(RISK_GROUP_ORDER.map((group, index) => [group.toLowerCase(), index]));
+function riskGroupRank(group) {
+    var _a;
+    return ((_a = RISK_GROUP_RANK.get(group.trim().toLowerCase())) !== null && _a !== void 0 ? _a : RISK_GROUP_ORDER.length);
+}
+/**
+ * The pool's security tags (the CMS `security` list), trimmed, blanks
+ * dropped. `undefined` when none remain.
+ *
+ * kasu-ui shows these under "Security Structure over End Borrowers" ONLY
+ * when the pool has no risk-management items.
+ */
+function securityStructureOf(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const tags = raw
+        .map((tag) => trimmedOrUndefined(tag))
+        .filter((tag) => tag !== undefined);
+    return tags.length > 0 ? tags : undefined;
+}
+// ---------------------------------------------------------------------------
+// Numbers
+// ---------------------------------------------------------------------------
+/**
+ * A CMS or subgraph "numeric" value as a finite number, or `undefined`. An
+ * empty or blank string is UNAUTHORED, not zero; a genuine `0` survives.
+ */
+function finiteOrUndefined(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string') {
+        if (value.trim() === '')
+            return undefined;
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    return undefined;
+}
+/**
+ * A leg `strategyTotalsUsd` cannot place: two legs for one deployment
+ * (`duplicate-leg`, which would double-count it), or a leg for a deployment
+ * not in `expectedDeployments` (`unexpected-leg`, a pool of some other
+ * strategy). Thrown, because both are caller bugs, not data states.
+ */
+class StrategyTotalsInputError extends Error {
+    constructor(code, deployment) {
+        super(code === 'duplicate-leg'
+            ? `strategyTotalsUsd: two legs for deployment "${deployment}"`
+            : `strategyTotalsUsd: leg for deployment "${deployment}" is not in expectedDeployments`);
+        this.code = code;
+        this.deployment = deployment;
+        this.name = 'StrategyTotalsInputError';
+    }
+}
+/**
+ * Total Active Lending and Lender Interest Earned for a strategy across the
+ * deployments it lends on, in USD: each leg's native amount times that leg's
+ * own `usdRate`, summed. Tax Pay lends on Base (USDC) and XDC (AUDD);
+ * 2,567,901 AUDD is not US$2,567,901.
+ *
+ * `expectedDeployments` is every deployment the strategy has a pool on —
+ * `strategyDeployments(poolId, chain).map((d) => d.chain)` — and `legs` the
+ * ones whose pool the caller actually loaded. What is guaranteed:
+ *
+ *   - **`null` — WITHHELD** when there are no legs, or ANY leg's rate is
+ *     missing or unusable (not a finite number above 0). The total is never
+ *     built on a guessed rate, and never silently drops a loaded leg; the
+ *     caller shows the held pool's own figure, or nothing.
+ *   - **Otherwise the sum over `legs`**, with `isPartial` /
+ *     `missingDeployments` stating exactly which expected deployments it
+ *     does NOT cover. `isPartial: false` is the only case in which the
+ *     figures are the whole strategy.
+ *   - An amount that is absent or malformed contributes nothing (a real `0`
+ *     is still `0`).
+ *   - Throws `StrategyTotalsInputError` for a duplicated leg or one not in
+ *     `expectedDeployments`, before summing anything.
+ *
+ * Only these two figures are summed. The CMS-authored ones — every
+ * originator figure, `operatingSince`, the loss rates — are shared by a
+ * strategy's pools and already strategy-wide: summing them double-counts.
+ *
+ * Mirrors the money half of kasu-ui's `aggregateStrategyPools` and its
+ * withhold gate.
+ */
+function strategyTotalsUsd(legs, expectedDeployments) {
+    var _a, _b;
+    const expected = new Set(expectedDeployments);
+    const seen = new Set();
+    for (const leg of legs) {
+        if (seen.has(leg.deployment)) {
+            throw new StrategyTotalsInputError('duplicate-leg', leg.deployment);
+        }
+        if (!expected.has(leg.deployment)) {
+            throw new StrategyTotalsInputError('unexpected-leg', leg.deployment);
+        }
+        seen.add(leg.deployment);
+    }
+    if (legs.length === 0)
+        return null;
+    let totalActiveLendingUsd = 0;
+    let lenderInterestEarnedUsd = 0;
+    for (const leg of legs) {
+        const rate = leg.usdRate;
+        if (typeof rate !== 'number' || !Number.isFinite(rate) || rate <= 0) {
+            return null;
+        }
+        totalActiveLendingUsd +=
+            ((_a = finiteOrUndefined(leg.totalActiveLending)) !== null && _a !== void 0 ? _a : 0) * rate;
+        lenderInterestEarnedUsd +=
+            ((_b = finiteOrUndefined(leg.lenderInterestEarned)) !== null && _b !== void 0 ? _b : 0) * rate;
+    }
+    const missingDeployments = [...expected].filter((d) => !seen.has(d));
+    return {
+        totalActiveLendingUsd,
+        lenderInterestEarnedUsd,
+        isPartial: missingDeployments.length > 0,
+        missingDeployments,
+    };
+}
+function trimmedOrUndefined(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+
 /**
  * A strategy's SHORT blurb, as plain text: the CMS `liteDescription` first,
  * else the first paragraph of the long `description`, else nothing.
@@ -29396,10 +30488,55 @@ class StrategiesFacade {
      * Chain pool id → the pool id its CMS record is keyed by (XDC pools
      * share their Base counterpart's editorial record). Lowercase keys.
      */
-    _poolMetadataMapping = {}) {
+    _poolMetadataMapping = {}, 
+    /**
+     * The clock the CMS start dates are checked against (a date after it
+     * is refused). Injected for tests; the current time otherwise.
+     */
+    _now = () => new Date(), 
+    /**
+     * Milliseconds on a clock that only moves forward, for the shared
+     * CMS reads' 30-second lifetime — separate from `_now`, so a pinned
+     * date clock cannot keep a read alive for ever. Injected for tests;
+     * `Date.now` otherwise.
+     */
+    _memoClockMs = () => Date.now()) {
         this._dataService = _dataService;
         this._userLending = _userLending;
         this._poolMetadataMapping = _poolMetadataMapping;
+        this._now = _now;
+        this._memoClockMs = _memoClockMs;
+        /**
+         * Short-lived, per-instance memo of the two CMS-wide reads the pool
+         * getters share, so a Details screen asking for the loss rate, the risk
+         * groups and the originator together reads each collection once. Keyed
+         * by read; holds the in-flight promise, so concurrent callers share it.
+         * A REJECTED read is dropped at once, never served again — the next call
+         * retries.
+         */
+        this._cmsReads = new Map();
+    }
+    _memoCmsRead(key, read) {
+        const nowMs = this._memoClockMs();
+        const cached = this._cmsReads.get(key);
+        if (cached && cached.expiresAt > nowMs) {
+            return cached.promise;
+        }
+        const promise = read();
+        const entry = { promise, expiresAt: nowMs + CMS_READ_TTL_MS };
+        this._cmsReads.set(key, entry);
+        promise.catch(() => {
+            // Only our own entry: a newer read may have replaced it.
+            if (this._cmsReads.get(key) === entry)
+                this._cmsReads.delete(key);
+        });
+        return promise;
+    }
+    _riskManagementRecords() {
+        return this._memoCmsRead('riskManagement', () => this._dataService.getRiskManagement());
+    }
+    _originatorProfiles() {
+        return this._memoCmsRead('originatorProfiles', () => this._dataService.getPoolDelegateProfileAndHistory());
     }
     /**
      * The pool's loss rate and first-loss capital, from its CMS
@@ -29412,12 +30549,14 @@ class StrategiesFacade {
      * 0..1 fraction.
      *
      * Requires `directusUrl`; without it the call rejects with
-     * `NO_DIRECTUS_URL_MESSAGE`, like every CMS-only read.
+     * `NO_DIRECTUS_URL_MESSAGE`, like every CMS-only read. Shares its CMS
+     * read with `getRiskManagementGroups` for 30 seconds per instance; a
+     * failed read is never reused.
      */
     getRiskPerformance(poolId) {
         return __awaiter(this, void 0, void 0, function* () {
             const metadataId = this._metadataIdOf(poolId);
-            const records = yield this._dataService.getRiskManagement();
+            const records = yield this._riskManagementRecords();
             const record = records.find((r) => String(r.poolIdFK).toLowerCase() === metadataId);
             if (!record)
                 return null;
@@ -29441,16 +30580,95 @@ class StrategiesFacade {
      * deployment every profile lists no pools and this resolves `null` —
      * the same answer kasu-ui's own lookup gives there today. The metadata
      * candidate becomes live once the service resolves the mapping.
+     *
+     * Shares its reads with `getOriginatorHistory` for 30 seconds per
+     * instance; a failed read is never reused. Each call returns its own
+     * copy of the profile, so mutating it changes nothing shared.
      */
     getOriginator(poolId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const candidates = new Set([
                 poolId.toLowerCase(),
                 this._metadataIdOf(poolId),
             ]);
-            const profiles = yield this._dataService.getPoolDelegateProfileAndHistory();
-            return ((_a = profiles.find((profile) => profile.otherKASUPools.some((pool) => candidates.has(String(pool.id).toLowerCase())))) !== null && _a !== void 0 ? _a : null);
+            const profiles = yield this._originatorProfiles();
+            const profile = profiles.find((candidate) => candidate.otherKASUPools.some((pool) => candidates.has(String(pool.id).toLowerCase())));
+            // A copy: the profiles are shared between calls (see
+            // `_memoCmsRead`), so a caller sorting or editing its result must
+            // not change what the next call returns.
+            return profile
+                ? Object.assign(Object.assign({}, profile), { otherKASUPools: profile.otherKASUPools.map((pool) => (Object.assign({}, pool))) }) : null;
+        });
+    }
+    /**
+     * The credit originator's ENTIRE lending history for a pool — since when,
+     * total originated, loans outstanding, loss rate — read from the profile
+     * `getOriginator` finds, each figure validated. `null` when no profile
+     * lists the pool, or the profile authors none of the four.
+     *
+     * kasu-ui's Details tab shows these as its Credit Originator strip, and
+     * hides the strip when there is no profile. The money figures are
+     * editorial USD on every deployment: never FX-convert them. An XDC pool
+     * resolves `null` today, as it does in kasu-ui (see `getOriginator`).
+     *
+     * Requires `directusUrl`, like every CMS-only read; rejects when the
+     * read fails. Shares its reads with `getOriginator` for 30 seconds per
+     * instance; a failed read is never reused.
+     */
+    getOriginatorHistory(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const profile = yield this.getOriginator(poolId);
+            if (!profile)
+                return null;
+            const history = {};
+            const since = readCmsStartDate(profile.delegateLendingHistory, this._now(), { unixSeconds: true });
+            if (since !== undefined)
+                history.since = since;
+            const totalOriginated = finiteOrUndefined(profile.totalLoanFundsOriginated);
+            if (totalOriginated !== undefined) {
+                history.totalOriginated = totalOriginated;
+            }
+            const loansOutstanding = finiteOrUndefined(profile.loansUnderManagement);
+            if (loansOutstanding !== undefined) {
+                history.loansOutstanding = loansOutstanding;
+            }
+            const lossRate = finiteOrUndefined(profile.historicLossRate);
+            if (lossRate !== undefined)
+                history.lossRate = lossRate;
+            return Object.keys(history).length > 0 ? history : null;
+        });
+    }
+    /**
+     * The pool's Risk Management groups, from its CMS risk-management record:
+     * each group with its items (name, the pool's description of it split
+     * into lines, the shared tooltip), the groups in `RISK_GROUP_ORDER`
+     * (Security & Recourse, Structural Controls, Financial Covenants,
+     * Reporting Covenants, Key Eligibility Criteria, then any other in CMS
+     * order). See `groupRiskManagementItems`.
+     *
+     * `null` when the pool has no record, or the record has no usable item —
+     * then kasu-ui falls back to `Strategy.securityStructure`. XDC pools
+     * resolve through the metadata mapping to their Base record, like
+     * `getRiskPerformance`.
+     *
+     * REJECTS when the CMS read fails (an outage, or no `directusUrl` —
+     * `NO_DIRECTUS_URL_MESSAGE`), so a failure stays visible rather than
+     * reading as "no items". For what to SHOW, treat a rejection like `null`:
+     * fall back to `Strategy.securityStructure`, which arrives with the
+     * strategy and needs no second read.
+     *
+     * Shares its CMS read with `getRiskPerformance` for 30 seconds per
+     * instance; a failed read is never reused.
+     */
+    getRiskManagementGroups(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadataId = this._metadataIdOf(poolId);
+            const records = yield this._riskManagementRecords();
+            const record = records.find((r) => String(r.poolIdFK).toLowerCase() === metadataId);
+            if (!record || !Array.isArray(record.items))
+                return null;
+            const groups = groupRiskManagementItems(record.items);
+            return groups.length > 0 ? groups : null;
         });
     }
     _metadataIdOf(poolId) {
@@ -29624,10 +30842,39 @@ class StrategiesFacade {
             apyStructure: pool.poolApyStructure,
             thumbnailUrl: pool.thumbnailImageUrl,
             bannerUrl: pool.bannerImageUrl,
+            strategyHistory: strategyHistoryOf(pool, this._now()),
+            endBorrowers: endBorrowersOf(pool),
+            securityStructure: securityStructureOf(pool.security),
             _raw: pool,
         };
     }
 }
+/**
+ * How long a CMS-wide read is shared between the pool getters. Long enough
+ * for one screen's worth of calls, short enough that a CMS edit shows on the
+ * next visit; apps cache further on their own terms.
+ */
+const CMS_READ_TTL_MS = 30000;
+/** `Strategy.strategyHistory`: an absent figure is an absent key. */
+function strategyHistoryOf(pool, now) {
+    const history = {};
+    const since = readCmsStartDate(pool.operatingSince, now);
+    if (since !== undefined)
+        history.since = since;
+    const lenderInterestEarned = finiteOrUndefined(pool.yieldEarned);
+    if (lenderInterestEarned !== undefined) {
+        history.lenderInterestEarned = lenderInterestEarned;
+    }
+    return history;
+}
+/** Business Types and Facility Type, or `undefined` when neither is authored. */
+function endBorrowersOf(pool) {
+    const businessTypes = splitBusinessTypes(pool.industryExposure);
+    const facility = parseFacility(pool.loanStructure);
+    if (!businessTypes && !facility)
+        return undefined;
+    return Object.assign(Object.assign({}, (businessTypes ? { businessTypes } : {})), (facility ? { facility } : {}));
+}
 /**
  * A CMS text field as a string, or `undefined` when it is absent, not a
  * string, or empty (blank included) — the CMS stores an emptied field as `''`, and an empty
@@ -31167,6 +32414,7 @@ exports.PoolTvlHistoryAbortedError = PoolTvlHistoryAbortedError;
 exports.PoolTvlHistoryTimeoutError = PoolTvlHistoryTimeoutError;
 exports.PortfolioFacade = PortfolioFacade;
 exports.READ_ONLY_MESSAGE = READ_ONLY_MESSAGE;
+exports.RISK_GROUP_ORDER = RISK_GROUP_ORDER;
 exports.RIXON_CAPITAL = RIXON_CAPITAL;
 exports.SECONDS_PER_WEEK = SECONDS_PER_WEEK;
 exports.SPONSORED_CALL_KINDS = SPONSORED_CALL_KINDS;
@@ -31175,6 +32423,7 @@ exports.SdkConfig = SdkConfig;
 exports.SponsoredCallInputError = SponsoredCallInputError;
 exports.StrategiesFacade = StrategiesFacade;
 exports.StrategyDeploymentInputError = StrategyDeploymentInputError;
+exports.StrategyTotalsInputError = StrategyTotalsInputError;
 exports.TvlHistoryInputError = TvlHistoryInputError;
 exports.UPPER_MEZZANINE = UPPER_MEZZANINE;
 exports.WithdrawFlow = WithdrawFlow;
@@ -31223,6 +32472,7 @@ exports.getCreditOriginator = getCreditOriginator;
 exports.getInstitutionalLender = getInstitutionalLender;
 exports.getStrategyRegion = getStrategyRegion;
 exports.getTrancheDisplayName = getTrancheDisplayName;
+exports.groupRiskManagementItems = groupRiskManagementItems;
 exports.isAuMinimumExempt = isAuMinimumExempt;
 exports.isAustralianKyc = isAustralianKyc;
 exports.isBelowMinimumCapacity = isBelowMinimumCapacity;
@@ -31238,6 +32488,7 @@ exports.maxNetRateCeiling = maxNetRateCeiling;
 exports.netEffectiveApy = netEffectiveApy;
 exports.netTrancheApyBounds = netTrancheApyBounds;
 exports.nextCycleBoundary = nextCycleBoundary;
+exports.parseFacility = parseFacility;
 exports.parseFormattedMessage = parseFormattedMessage;
 exports.parseMinorUnits = parseMinorUnits;
 exports.parseTrancheBound = parseTrancheBound;
@@ -31250,10 +32501,15 @@ exports.poolTvl = poolTvl;
 exports.projectedAnnualEarnings = projectedAnnualEarnings;
 exports.proveDepositInReceipt = proveDepositInReceipt;
 exports.proveUserOperationInReceipt = proveUserOperationInReceipt;
+exports.readCmsStartDate = readCmsStartDate;
 exports.resolveBoundShortcuts = resolveBoundShortcuts;
 exports.resolveDepositBounds = resolveDepositBounds;
+exports.securityStructureOf = securityStructureOf;
 exports.selectVisiblePools = selectVisiblePools;
+exports.splitBusinessTypes = splitBusinessTypes;
+exports.splitNumberedClauses = splitNumberedClauses;
 exports.strategyDeployments = strategyDeployments;
+exports.strategyTotalsUsd = strategyTotalsUsd;
 exports.submissionEvents = submissionEvents;
 exports.submitBatch = submitBatch;
 exports.submitSponsoredCall = submitSponsoredCall;