@kasufinance/kasu-sdk 2.15.0 → 2.16.0

package/src/services/UserLending/user-lending.ts

@@ -875,6 +875,52 @@ export 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.
+     */
+    async getUserTrancheActiveAssets(
+        user: string,
+        trancheIds: readonly string[],
+        provider?: Provider,
+        blockTag?: number,
+    ): Promise<BigNumber[]> {
+        return await Promise.all(
+            trancheIds.map((trancheId) =>
+                ILendingPoolTrancheAbi__factory.connect(
+                    trancheId,
+                    provider ?? this._signerOrProvider,
+                ).userActiveAssets(user, { blockTag: 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.
+     */
+    async getUserPoolBalancesAt(
+        user: string,
+        poolIds: readonly string[],
+        provider?: Provider,
+        blockTag?: number,
+    ): Promise<BigNumber[]> {
+        return await Promise.all(
+            poolIds.map((poolId) =>
+                ILendingPoolAbi__factory.connect(
+                    poolId,
+                    provider ?? this._signerOrProvider,
+                ).userBalance(user, { blockTag: blockTag ?? 'latest' }),
+            ),
+        );
+    }
+
     async getPortfolioUserTrancheBalances(
         user: string,
     ): Promise<PortfolioUserTrancheBalance> {

package/src/services/shared.ts

@@ -46,3 +46,51 @@ export function isEmptyHistoryError(
 ): boolean {
     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',
+] as const;
+
+function errorTexts(error: unknown, depth = 0): string[] {
+    if (depth > 4 || error === null || error === undefined) return [];
+    if (typeof error === 'string') return [error];
+    if (typeof error !== 'object') return [];
+    const record = error as Record<string, unknown>;
+    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.
+ */
+export function isBlockUnavailableError(error: unknown): boolean {
+    const text = errorTexts(error).join(' ').toLowerCase();
+    return BLOCK_UNAVAILABLE_PATTERNS.some((pattern) => text.includes(pattern));
+}