@kasufinance/kasu-sdk 2.12.0 → 2.13.1

package/src/services/Portfolio/yield-history.ts

@@ -537,38 +537,5 @@ export function buildYieldHistory(
     );
 }
 
-/**
- * A GraphQL VALIDATION error naming an entity, field or argument this
- * deployment's subgraph does not have. A network error, a timeout or an
- * indexing error is not one.
- */
-export function isMissingEntityError(error: unknown): boolean {
-    if (typeof error !== 'object' || error === null) return false;
-    const response = (error as { response?: { errors?: unknown } }).response;
-    const errors = response?.errors;
-    if (!Array.isArray(errors) || errors.length === 0) return false;
-    return errors.every((e: unknown) => {
-        const message = (e as { message?: unknown } | null)?.message;
-        return (
-            typeof message === 'string' &&
-            /has no field|cannot query field|unknown (type|field|argument)|no such (type|field)/i.test(
-                message,
-            )
-        );
-    });
-}
-
-/**
- * The only failure `getYieldHistory` turns into `[]`: a missing-schema error
- * on a LITE deployment, whose subgraph may predate the entities. On a full
- * deployment the entities are part of the schema, so the same error means a
- * broken query or subgraph and THROWS — an empty chart there would hide it.
- * Everything else (network, timeout, indexing) throws on every deployment, so
- * a consumer can tell "no history here" from "history unavailable".
- */
-export function isEmptyHistoryError(
-    error: unknown,
-    liteDeployment: boolean,
-): boolean {
-    return liteDeployment && isMissingEntityError(error);
-}
+// Shared with `getPoolTvlHistory`: one Lite-vs-full rule for every history.
+export { isEmptyHistoryError, isMissingEntityError } from '../shared';

package/src/services/UserLending/queries.ts

@@ -160,14 +160,13 @@ export const currentEpochFtdAmountQuery = gql`
                 user: $userId
                 lendingPool_in: $poolIds
                 epochId: $currentEpoch
+                type: DepositRequest
             }
         ) {
             fixedTermConfigId
             amountRequested
             tranche {
                 id
-                balance
-                shares
             }
         }
     }
@@ -183,11 +182,7 @@ export const currentFtdBalanceQuery = gql`
                 configId
                 lendingPoolTranche {
                     id
-                }
-            }
-            lendingPool {
-                balance
-                tranches {
+                    balance
                     shares
                 }
             }

package/src/services/UserLending/subgraph-types.ts

@@ -77,8 +77,6 @@ export interface CurrentEpochFtdAmountSubgraph {
         amountRequested: string;
         tranche: {
             id: string;
-            balance: string;
-            shares: string;
         };
     }[];
 }
@@ -161,13 +159,9 @@ export interface CurrentFtdBalanceSubgraph {
             configId: string;
             lendingPoolTranche: {
                 id: string;
-            };
-        };
-        lendingPool: {
-            balance: string;
-            tranches: {
+                balance: string;
                 shares: string;
-            }[];
+            };
         };
     }[];
 }

package/src/services/UserLending/types.ts

@@ -39,8 +39,18 @@ export interface UserRequest {
     requestType: 'Deposit' | 'Withdrawal';
     trancheId: string;
     trancheName: string;
+    /**
+     * The amount still OUTSTANDING on the request, in assets (the
+     * deployment's stable token, display units) — not the amount first asked
+     * for: the subgraph takes accepted and rejected amounts off it, and a
+     * cancellation zeroes it. A deposit's figure is the asset amount as the
+     * subgraph holds it (top-ups included); a withdrawal's is its remaining
+     * tranche shares at the tranche's current share price.
+     */
     requestedAmount: string;
+    /** Assets accepted so far — deposited, or paid out for a withdrawal. */
     acceptedAmount: string;
+    /** Assets rejected and returned — deposits only; 0 for a withdrawal. */
     rejectedAmount: string;
     timestamp: EpochTimeStamp;
     status: UserRequestStatus;

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

@@ -8,13 +8,7 @@ import {
     ethers,
     Signer,
 } from 'ethers';
-import {
-    defaultAbiCoder,
-    formatEther,
-    formatUnits,
-    parseEther,
-    parseUnits,
-} from 'ethers/lib/utils';
+import { defaultAbiCoder, formatUnits, parseUnits } from 'ethers/lib/utils';
 import { GraphQLClient } from 'graphql-request';
 
 import {
@@ -70,6 +64,20 @@ import {
     UserTrancheBalance,
 } from './types';
 
+/** Thrown when the subgraph reports a request type with no known unit. */
+export const UNKNOWN_REQUEST_TYPE_MESSAGE =
+    'UserLending: unknown request type, its amount unit is unknown';
+
+const KNOWN_REQUEST_TYPES: readonly string[] = [
+    'DepositRequest',
+    'WithdrawalRequest',
+];
+
+const isKnownRequestType = (
+    type: unknown,
+): type is UserRequestsSubgraph['userRequests'][number]['type'] =>
+    typeof type === 'string' && KNOWN_REQUEST_TYPES.includes(type);
+
 export class UserLending {
     private readonly _graph: GraphQLClient;
 
@@ -406,6 +414,17 @@ export class UserLending {
         const retn: UserRequest[] = [];
 
         for (const userRequest of subgraphResult.userRequests) {
+            // A request type this SDK does not know has no known amount unit
+            // (the schema also declares types no live deployment emits yet).
+            // Skip that ONE row before anything is priced or read on chain,
+            // rather than failing — and blanking — the lender's whole list.
+            if (!isKnownRequestType(userRequest.type)) {
+                console.error(
+                    `${UNKNOWN_REQUEST_TYPE_MESSAGE}: ${String(userRequest.type)} (request ${userRequest.id}); row skipped`,
+                );
+                continue;
+            }
+
             const directusPool = directusResult.find(
                 ({ id }) => id === userRequest.lendingPool.id,
             );
@@ -552,13 +571,7 @@ export class UserLending {
                         : 'Withdrawal',
                 trancheName: trancheName,
                 trancheId: userRequest.tranche.id,
-                requestedAmount: parseUnits(userRequest.tranche.shares).isZero()
-                    ? userRequest.amountRequested
-                    : this.convertSharesToAssets(
-                          userRequest.amountRequested,
-                          userRequest.tranche.balance,
-                          userRequest.tranche.shares,
-                      ).toString(),
+                requestedAmount: this.requestedAmountInAssets(userRequest),
                 acceptedAmount: userRequest.amountAccepted,
                 rejectedAmount: userRequest.amountRejected,
                 status: userRequest.status,
@@ -606,15 +619,16 @@ export class UserLending {
             const trancheID =
                 userFTD.lendingPoolTrancheFixedTermConfig.lendingPoolTranche.id.toLowerCase();
 
-            const totalSupply = userFTD.lendingPool.tranches.reduce(
-                (total, cur) => total.add(parseEther(cur.shares)),
-                BigNumber.from(0),
-            );
+            // The lock holds shares of ONE tranche, so they are worth that
+            // tranche's share price — not the pool's average across tranches,
+            // which differs whenever the tranches have earned differently.
+            const lockTranche =
+                userFTD.lendingPoolTrancheFixedTermConfig.lendingPoolTranche;
 
             const amount = this.convertSharesToAssets(
                 userFTD.trancheShares,
-                userFTD.lendingPool.balance,
-                formatEther(totalSupply),
+                lockTranche.balance,
+                lockTranche.shares,
             );
 
             const item = trancheMap.get(trancheID) ?? [];
@@ -643,33 +657,43 @@ export class UserLending {
                 currentEpoch: parseFloat(currentEpoch),
             });
 
-        const currentEpochFtdAmounts = new Map<string, string[]>();
+        // Deposit requests only (the query filters on type): a deposit's
+        // `amountRequested` is already an ASSET amount, so it is summed as it
+        // is — never put through a share price. Summed, not assigned: a
+        // cancelled request and its replacement share a tranche and a config
+        // in one epoch, and the cancelled one's 0 must not overwrite the live
+        // amount.
+        const totals = new Map<string, Map<number, BigNumber>>();
 
         for (const userRequest of currentEpochFtdAmountRes.userRequests) {
             const ftdID = parseFloat(userRequest.fixedTermConfigId);
-
-            const item = currentEpochFtdAmounts.get(userRequest.tranche.id);
-
-            const amountRequested = this.convertSharesToAssets(
-                userRequest.amountRequested,
-                userRequest.tranche.balance,
-                userRequest.tranche.shares,
+            if (!Number.isInteger(ftdID) || ftdID < 0) continue;
+
+            const perConfig =
+                totals.get(userRequest.tranche.id) ??
+                new Map<number, BigNumber>();
+            perConfig.set(
+                ftdID,
+                (perConfig.get(ftdID) ?? BigNumber.from(0)).add(
+                    parseUnits(userRequest.amountRequested),
+                ),
             );
+            totals.set(userRequest.tranche.id, perConfig);
+        }
 
-            if (item) {
-                const clonedItem = [...item];
-
-                clonedItem[ftdID] = amountRequested;
-
-                currentEpochFtdAmounts.set(userRequest.tranche.id, clonedItem);
+        // A slot whose total is zero is left out — `'0.0'` is a truthy
+        // string, and a caller testing the slot would read it as an amount.
+        // A tranche with no non-zero slot is left out entirely.
+        const currentEpochFtdAmounts = new Map<string, string[]>();
 
-                continue;
-            }
+        for (const [trancheId, perConfig] of totals) {
             const ftdAmounts: string[] = [];
-
-            ftdAmounts[ftdID] = amountRequested;
-
-            currentEpochFtdAmounts.set(userRequest.tranche.id, ftdAmounts);
+            for (const [ftdID, total] of perConfig) {
+                if (total.gt(0)) ftdAmounts[ftdID] = formatUnits(total);
+            }
+            if (ftdAmounts.length) {
+                currentEpochFtdAmounts.set(trancheId, ftdAmounts);
+            }
         }
 
         return currentEpochFtdAmounts;
@@ -708,6 +732,40 @@ export class UserLending {
         return amountMap;
     }
 
+    /**
+     * A request's outstanding amount in ASSETS (the deployment's stable token).
+     *
+     * The subgraph's `UserRequest.amountRequested` is denominated by request
+     * type. A DEPOSIT request holds assets: the deposit NFT's `assetAmount`,
+     * top-ups added, accepted and rejected amounts taken off. A WITHDRAWAL
+     * request holds tranche SHARES: the withdrawal NFT's `sharesAmount`,
+     * accepted shares taken off. So only a withdrawal is converted, at the
+     * tranche's current share price; a deposit passes through unchanged —
+     * pricing it as shares overstated it by the share price.
+     */
+    private requestedAmountInAssets(
+        userRequest: UserRequestsSubgraph['userRequests'][number],
+    ): string {
+        switch (userRequest.type) {
+            case 'DepositRequest':
+                return userRequest.amountRequested;
+            case 'WithdrawalRequest':
+                return this.convertSharesToAssets(
+                    userRequest.amountRequested,
+                    userRequest.tranche.balance,
+                    userRequest.tranche.shares,
+                );
+            default: {
+                // Fail closed: a type this SDK does not know has no known
+                // unit, and pricing it either way would print a wrong figure.
+                const unknownType: string = userRequest.type;
+                throw new Error(
+                    `${UNKNOWN_REQUEST_TYPE_MESSAGE}: ${unknownType}`,
+                );
+            }
+        }
+    }
+
     convertSharesToAssets(
         sharesAmount: string,
         totalAssets: string,

package/src/services/shared.ts

@@ -8,4 +8,41 @@ export function filterArray<T>(array: T[], id_in?: string[]): T[] {
             return id_in.includes(id);
         });
     }
-}
+}
+
+/**
+ * A GraphQL VALIDATION error naming an entity, field or argument this
+ * deployment's subgraph does not have. A network error, a timeout or an
+ * indexing error is not one.
+ */
+export function isMissingEntityError(error: unknown): boolean {
+    if (typeof error !== 'object' || error === null) return false;
+    const response = (error as { response?: { errors?: unknown } }).response;
+    const errors = response?.errors;
+    if (!Array.isArray(errors) || errors.length === 0) return false;
+    return errors.every((e: unknown) => {
+        const message = (e as { message?: unknown } | null)?.message;
+        return (
+            typeof message === 'string' &&
+            /has no field|cannot query field|unknown (type|field|argument)|no such (type|field)/i.test(
+                message,
+            )
+        );
+    });
+}
+
+/**
+ * The only failure a history read (`getYieldHistory`, `getPoolTvlHistory`)
+ * turns into `[]`: a missing-schema error
+ * on a LITE deployment, whose subgraph may predate the entities. On a full
+ * deployment the entities are part of the schema, so the same error means a
+ * broken query or subgraph and THROWS — an empty chart there would hide it.
+ * Everything else (network, timeout, indexing) throws on every deployment, so
+ * a consumer can tell "no history here" from "history unavailable".
+ */
+export function isEmptyHistoryError(
+    error: unknown,
+    liteDeployment: boolean,
+): boolean {
+    return liteDeployment && isMissingEntityError(error);
+}