@kasufinance/kasu-sdk 2.13.0 → 2.13.1

package/dist/bundle.cjs.js

@@ -18015,14 +18015,13 @@ const currentEpochFtdAmountQuery = gql `
                 user: $userId
                 lendingPool_in: $poolIds
                 epochId: $currentEpoch
+                type: DepositRequest
             }
         ) {
             fixedTermConfigId
             amountRequested
             tranche {
                 id
-                balance
-                shares
             }
         }
     }
@@ -18037,11 +18036,7 @@ const currentFtdBalanceQuery = gql `
                 configId
                 lendingPoolTranche {
                     id
-                }
-            }
-            lendingPool {
-                balance
-                tranches {
+                    balance
                     shares
                 }
             }
@@ -18049,6 +18044,13 @@ const currentFtdBalanceQuery = gql `
     }
 `;
 
+/** Thrown when the subgraph reports a request type with no known unit. */
+const UNKNOWN_REQUEST_TYPE_MESSAGE = 'UserLending: unknown request type, its amount unit is unknown';
+const KNOWN_REQUEST_TYPES = [
+    'DepositRequest',
+    'WithdrawalRequest',
+];
+const isKnownRequestType = (type) => typeof type === 'string' && KNOWN_REQUEST_TYPES.includes(type);
 class UserLending {
     constructor(_kasuConfig, signerOrProvider) {
         this._kasuConfig = _kasuConfig;
@@ -18210,6 +18212,14 @@ class UserLending {
             ]);
             const retn = [];
             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);
                 const trancheName = trancheNames[userRequest.lendingPool.tranches.length - 1][parseInt(userRequest.tranche.orderId)];
                 const events = [];
@@ -18305,9 +18315,7 @@ class UserLending {
                         : 'Withdrawal',
                     trancheName: trancheName,
                     trancheId: userRequest.tranche.id,
-                    requestedAmount: utils$2.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,
@@ -18340,8 +18348,11 @@ class UserLending {
             for (const userFTD of currentFtdBalance.userLendingPoolTrancheFixedTermDepositLocks) {
                 const ftdID = parseFloat(userFTD.lendingPoolTrancheFixedTermConfig.configId);
                 const trancheID = userFTD.lendingPoolTrancheFixedTermConfig.lendingPoolTranche.id.toLowerCase();
-                const totalSupply = userFTD.lendingPool.tranches.reduce((total, cur) => total.add(utils$2.parseEther(cur.shares)), ethers.BigNumber.from(0));
-                const amount = this.convertSharesToAssets(userFTD.trancheShares, userFTD.lendingPool.balance, utils$2.formatEther(totalSupply));
+                // 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, lockTranche.balance, lockTranche.shares);
                 const item = (_a = trancheMap.get(trancheID)) !== null && _a !== void 0 ? _a : [];
                 if (item[ftdID]) {
                     item[ftdID] += parseFloat(amount);
@@ -18356,25 +18367,40 @@ class UserLending {
     }
     getCurrentEpochFtdAmount(poolIds, userId, currentEpoch) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const currentEpochFtdAmountRes = yield this._graph.request(currentEpochFtdAmountQuery, {
                 userId: userId.toLowerCase(),
                 poolIds: poolIds.map((id) => id.toLowerCase()),
                 currentEpoch: parseFloat(currentEpoch),
             });
-            const currentEpochFtdAmounts = new Map();
+            // 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();
             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 (item) {
-                    const clonedItem = [...item];
-                    clonedItem[ftdID] = amountRequested;
-                    currentEpochFtdAmounts.set(userRequest.tranche.id, clonedItem);
+                if (!Number.isInteger(ftdID) || ftdID < 0)
                     continue;
-                }
+                const perConfig = (_a = totals.get(userRequest.tranche.id)) !== null && _a !== void 0 ? _a : new Map();
+                perConfig.set(ftdID, ((_b = perConfig.get(ftdID)) !== null && _b !== void 0 ? _b : ethers.BigNumber.from(0)).add(utils$2.parseUnits(userRequest.amountRequested)));
+                totals.set(userRequest.tranche.id, perConfig);
+            }
+            // 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();
+            for (const [trancheId, perConfig] of totals) {
                 const ftdAmounts = [];
-                ftdAmounts[ftdID] = amountRequested;
-                currentEpochFtdAmounts.set(userRequest.tranche.id, ftdAmounts);
+                for (const [ftdID, total] of perConfig) {
+                    if (total.gt(0))
+                        ftdAmounts[ftdID] = utils$2.formatUnits(total);
+                }
+                if (ftdAmounts.length) {
+                    currentEpochFtdAmounts.set(trancheId, ftdAmounts);
+                }
             }
             return currentEpochFtdAmounts;
         });
@@ -18395,6 +18421,31 @@ 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.
+     */
+    requestedAmountInAssets(userRequest) {
+        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 = userRequest.type;
+                throw new Error(`${UNKNOWN_REQUEST_TYPE_MESSAGE}: ${unknownType}`);
+            }
+        }
+    }
     convertSharesToAssets(sharesAmount, totalAssets, totalSupply) {
         if (utils$2.parseUnits(totalSupply).isZero())
             return '0';
@@ -29463,17 +29514,24 @@ function cancelDeadline(request, nextEpochStart, nowSeconds) {
 const isCancelled = (events) => events.some((e) => e.requestType === 'Cancelled');
 const isForced = (events) => events.some((e) => e.requestType === 'Forced');
 const initiatedEvent = (events) => events.find((e) => e.requestType === 'Initiated');
-/**
- * Subgraph behaviour: when a request is cancelled, the on-request
- * `requestedAmount` field is reset to 0 (the lender's effective balance is
- * restored). The original amount survives on the `Initiated` event's
- * `assetAmount`. Recover from there so cancelled rows still carry the amount
- * the lender originally asked for.
- */
+/** `assetAmount` of the `Initiated` event, or 0 when there is none. */
 const initiatedAmountOf = (events) => {
     const initiated = initiatedEvent(events);
     return initiated ? Number(initiated.assetAmount || '0') : 0;
 };
+/**
+ * Subgraph behaviour: when a request is cancelled, the on-request
+ * `requestedAmount` field is reset to 0 (the lender's effective balance is
+ * restored). The amount cancelled survives on the `Cancelled` event's
+ * `assetAmount` — everything still outstanding at the cancel, top-ups
+ * included. Only when that event carries no figure does this fall back to the
+ * `Initiated` event, which holds the FIRST submission alone and so misses
+ * every top-up.
+ */
+const cancelledAmountOf = (events) => {
+    const cancelledEvent = events.find((e) => e.requestType === 'Cancelled');
+    return num(cancelledEvent === null || cancelledEvent === void 0 ? void 0 : cancelledEvent.assetAmount) || initiatedAmountOf(events);
+};
 /**
  * A deposit is REALLOCATED when the timeline carries a `Reallocated` event, or
  * an `Accepted` event into a tranche other than the one requested.
@@ -29498,17 +29556,15 @@ const numOrNull = (str) => {
  * Convert a `UserRequest` into a `RequestState`. Pure — no clock, no network,
  * no copy.
  *
- * BRANCH ORDER (this IS the behaviour; it reproduces kasu-ui's
- * `deriveTransactionView` check for check):
+ * BRANCH ORDER (this IS the behaviour):
  *
  *   1. a `Cancelled` event                      → `cancelled`, neutral, 0
  *   2. a withdrawal with a `Forced` event       → `forced`, outflow, −accepted
  *   3. a reallocated deposit                    → `reallocated`, inflow, +accepted
- *   4. a withdrawal partly filled with a LIVE
- *      remainder (cycle still open)             → `partial`, outflow, −accepted
+ *   4. a withdrawal partly filled (paid > 0) with
+ *      a LIVE remainder (queued > 0, cycle open) → `partial`, outflow, −accepted
  *   5. resolved (`status === 'Processed'`):
- *        withdrawal, partly filled              → `partial`, outflow, −accepted
- *        withdrawal, fully filled               → `complete`, outflow, −accepted
+ *        withdrawal (nothing left queued)       → `complete`, outflow, −accepted
  *        deposit, nothing accepted              → `rejected`, neutral, 0
  *        deposit, part rejected                 → `partial`, inflow, +accepted
  *        deposit, fully accepted                → `complete`, inflow, +accepted
@@ -29536,10 +29592,10 @@ function deriveRequestState(request) {
     const isWithdrawal = request.requestType === 'Withdrawal';
     const cancelled = isCancelled(request.events);
     // Cancelled requests have `requestedAmount` zeroed on the request itself;
-    // pull the original value from the Initiated event so the row still
-    // carries "100 cancelled" instead of "0 cancelled".
+    // take the amount from the Cancelled event so the row still carries
+    // "1500 cancelled" (1000 + a 500 top-up) instead of "0 cancelled".
     const requested = cancelled
-        ? num(request.requestedAmount) || initiatedAmountOf(request.events)
+        ? num(request.requestedAmount) || cancelledAmountOf(request.events)
         : num(request.requestedAmount);
     const accepted = num(request.acceptedAmount);
     const rejected = num(request.rejectedAmount);
@@ -29590,18 +29646,23 @@ function deriveRequestState(request) {
     }
     // 4. Withdrawal partly filled with a LIVE remainder: the request returns
     // to the queue with a live Cancel. Checked BEFORE the resolved branch and
-    // via `isCycleClosed`, never via the sticky raw status.
+    // via `isCycleClosed`, never via the sticky raw status. `requested` is
+    // what is still OUTSTANDING, so "partly filled" is "something paid AND
+    // something still queued" — never a comparison of the two, which would
+    // turn on whether more was paid than is left.
     if (isWithdrawal &&
         accepted > 0 &&
-        accepted < requested &&
+        requested > 0 &&
         !isCycleClosed(request)) {
         return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'partial' });
     }
     // 5. Resolved — a rejection IS a resolution.
     if (request.status === UserRequestStatus.PROCESSED) {
+        // A withdrawal is resolved only once nothing is left queued — a
+        // partly filled one returns to the queue (branch 4), and one cancelled
+        // with a remainder is branch 1 — so a resolved withdrawal is complete.
         if (isWithdrawal) {
-            const partly = accepted < requested;
-            return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: partly ? 'partial' : 'complete' });
+            return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'complete' });
         }
         // Deposit: full reject vs partial vs full accept.
         if (accepted === 0) {

package/dist/bundle.esm.js

@@ -18013,14 +18013,13 @@ const currentEpochFtdAmountQuery = gql `
                 user: $userId
                 lendingPool_in: $poolIds
                 epochId: $currentEpoch
+                type: DepositRequest
             }
         ) {
             fixedTermConfigId
             amountRequested
             tranche {
                 id
-                balance
-                shares
             }
         }
     }
@@ -18035,11 +18034,7 @@ const currentFtdBalanceQuery = gql `
                 configId
                 lendingPoolTranche {
                     id
-                }
-            }
-            lendingPool {
-                balance
-                tranches {
+                    balance
                     shares
                 }
             }
@@ -18047,6 +18042,13 @@ const currentFtdBalanceQuery = gql `
     }
 `;
 
+/** Thrown when the subgraph reports a request type with no known unit. */
+const UNKNOWN_REQUEST_TYPE_MESSAGE = 'UserLending: unknown request type, its amount unit is unknown';
+const KNOWN_REQUEST_TYPES = [
+    'DepositRequest',
+    'WithdrawalRequest',
+];
+const isKnownRequestType = (type) => typeof type === 'string' && KNOWN_REQUEST_TYPES.includes(type);
 class UserLending {
     constructor(_kasuConfig, signerOrProvider) {
         this._kasuConfig = _kasuConfig;
@@ -18208,6 +18210,14 @@ class UserLending {
             ]);
             const retn = [];
             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);
                 const trancheName = trancheNames[userRequest.lendingPool.tranches.length - 1][parseInt(userRequest.tranche.orderId)];
                 const events = [];
@@ -18303,9 +18313,7 @@ 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,
@@ -18338,8 +18346,11 @@ class UserLending {
             for (const userFTD of currentFtdBalance.userLendingPoolTrancheFixedTermDepositLocks) {
                 const ftdID = parseFloat(userFTD.lendingPoolTrancheFixedTermConfig.configId);
                 const trancheID = userFTD.lendingPoolTrancheFixedTermConfig.lendingPoolTranche.id.toLowerCase();
-                const totalSupply = userFTD.lendingPool.tranches.reduce((total, cur) => total.add(parseEther(cur.shares)), BigNumber.from(0));
-                const amount = this.convertSharesToAssets(userFTD.trancheShares, userFTD.lendingPool.balance, formatEther(totalSupply));
+                // 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, lockTranche.balance, lockTranche.shares);
                 const item = (_a = trancheMap.get(trancheID)) !== null && _a !== void 0 ? _a : [];
                 if (item[ftdID]) {
                     item[ftdID] += parseFloat(amount);
@@ -18354,25 +18365,40 @@ class UserLending {
     }
     getCurrentEpochFtdAmount(poolIds, userId, currentEpoch) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const currentEpochFtdAmountRes = yield this._graph.request(currentEpochFtdAmountQuery, {
                 userId: userId.toLowerCase(),
                 poolIds: poolIds.map((id) => id.toLowerCase()),
                 currentEpoch: parseFloat(currentEpoch),
             });
-            const currentEpochFtdAmounts = new Map();
+            // 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();
             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 (item) {
-                    const clonedItem = [...item];
-                    clonedItem[ftdID] = amountRequested;
-                    currentEpochFtdAmounts.set(userRequest.tranche.id, clonedItem);
+                if (!Number.isInteger(ftdID) || ftdID < 0)
                     continue;
-                }
+                const perConfig = (_a = totals.get(userRequest.tranche.id)) !== null && _a !== void 0 ? _a : new Map();
+                perConfig.set(ftdID, ((_b = perConfig.get(ftdID)) !== null && _b !== void 0 ? _b : BigNumber.from(0)).add(parseUnits(userRequest.amountRequested)));
+                totals.set(userRequest.tranche.id, perConfig);
+            }
+            // 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();
+            for (const [trancheId, perConfig] of totals) {
                 const ftdAmounts = [];
-                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;
         });
@@ -18393,6 +18419,31 @@ 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.
+     */
+    requestedAmountInAssets(userRequest) {
+        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 = userRequest.type;
+                throw new Error(`${UNKNOWN_REQUEST_TYPE_MESSAGE}: ${unknownType}`);
+            }
+        }
+    }
     convertSharesToAssets(sharesAmount, totalAssets, totalSupply) {
         if (parseUnits(totalSupply).isZero())
             return '0';
@@ -29461,17 +29512,24 @@ function cancelDeadline(request, nextEpochStart, nowSeconds) {
 const isCancelled = (events) => events.some((e) => e.requestType === 'Cancelled');
 const isForced = (events) => events.some((e) => e.requestType === 'Forced');
 const initiatedEvent = (events) => events.find((e) => e.requestType === 'Initiated');
-/**
- * Subgraph behaviour: when a request is cancelled, the on-request
- * `requestedAmount` field is reset to 0 (the lender's effective balance is
- * restored). The original amount survives on the `Initiated` event's
- * `assetAmount`. Recover from there so cancelled rows still carry the amount
- * the lender originally asked for.
- */
+/** `assetAmount` of the `Initiated` event, or 0 when there is none. */
 const initiatedAmountOf = (events) => {
     const initiated = initiatedEvent(events);
     return initiated ? Number(initiated.assetAmount || '0') : 0;
 };
+/**
+ * Subgraph behaviour: when a request is cancelled, the on-request
+ * `requestedAmount` field is reset to 0 (the lender's effective balance is
+ * restored). The amount cancelled survives on the `Cancelled` event's
+ * `assetAmount` — everything still outstanding at the cancel, top-ups
+ * included. Only when that event carries no figure does this fall back to the
+ * `Initiated` event, which holds the FIRST submission alone and so misses
+ * every top-up.
+ */
+const cancelledAmountOf = (events) => {
+    const cancelledEvent = events.find((e) => e.requestType === 'Cancelled');
+    return num(cancelledEvent === null || cancelledEvent === void 0 ? void 0 : cancelledEvent.assetAmount) || initiatedAmountOf(events);
+};
 /**
  * A deposit is REALLOCATED when the timeline carries a `Reallocated` event, or
  * an `Accepted` event into a tranche other than the one requested.
@@ -29496,17 +29554,15 @@ const numOrNull = (str) => {
  * Convert a `UserRequest` into a `RequestState`. Pure — no clock, no network,
  * no copy.
  *
- * BRANCH ORDER (this IS the behaviour; it reproduces kasu-ui's
- * `deriveTransactionView` check for check):
+ * BRANCH ORDER (this IS the behaviour):
  *
  *   1. a `Cancelled` event                      → `cancelled`, neutral, 0
  *   2. a withdrawal with a `Forced` event       → `forced`, outflow, −accepted
  *   3. a reallocated deposit                    → `reallocated`, inflow, +accepted
- *   4. a withdrawal partly filled with a LIVE
- *      remainder (cycle still open)             → `partial`, outflow, −accepted
+ *   4. a withdrawal partly filled (paid > 0) with
+ *      a LIVE remainder (queued > 0, cycle open) → `partial`, outflow, −accepted
  *   5. resolved (`status === 'Processed'`):
- *        withdrawal, partly filled              → `partial`, outflow, −accepted
- *        withdrawal, fully filled               → `complete`, outflow, −accepted
+ *        withdrawal (nothing left queued)       → `complete`, outflow, −accepted
  *        deposit, nothing accepted              → `rejected`, neutral, 0
  *        deposit, part rejected                 → `partial`, inflow, +accepted
  *        deposit, fully accepted                → `complete`, inflow, +accepted
@@ -29534,10 +29590,10 @@ function deriveRequestState(request) {
     const isWithdrawal = request.requestType === 'Withdrawal';
     const cancelled = isCancelled(request.events);
     // Cancelled requests have `requestedAmount` zeroed on the request itself;
-    // pull the original value from the Initiated event so the row still
-    // carries "100 cancelled" instead of "0 cancelled".
+    // take the amount from the Cancelled event so the row still carries
+    // "1500 cancelled" (1000 + a 500 top-up) instead of "0 cancelled".
     const requested = cancelled
-        ? num(request.requestedAmount) || initiatedAmountOf(request.events)
+        ? num(request.requestedAmount) || cancelledAmountOf(request.events)
         : num(request.requestedAmount);
     const accepted = num(request.acceptedAmount);
     const rejected = num(request.rejectedAmount);
@@ -29588,18 +29644,23 @@ function deriveRequestState(request) {
     }
     // 4. Withdrawal partly filled with a LIVE remainder: the request returns
     // to the queue with a live Cancel. Checked BEFORE the resolved branch and
-    // via `isCycleClosed`, never via the sticky raw status.
+    // via `isCycleClosed`, never via the sticky raw status. `requested` is
+    // what is still OUTSTANDING, so "partly filled" is "something paid AND
+    // something still queued" — never a comparison of the two, which would
+    // turn on whether more was paid than is left.
     if (isWithdrawal &&
         accepted > 0 &&
-        accepted < requested &&
+        requested > 0 &&
         !isCycleClosed(request)) {
         return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'partial' });
     }
     // 5. Resolved — a rejection IS a resolution.
     if (request.status === UserRequestStatus.PROCESSED) {
+        // A withdrawal is resolved only once nothing is left queued — a
+        // partly filled one returns to the queue (branch 4), and one cancelled
+        // with a remainder is branch 1 — so a resolved withdrawal is complete.
         if (isWithdrawal) {
-            const partly = accepted < requested;
-            return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: partly ? 'partial' : 'complete' });
+            return Object.assign(Object.assign({}, base), { kind: 'outflow', amount: -accepted, statusCode: 'complete' });
         }
         // Deposit: full reject vs partial vs full accept.
         if (accepted === 0) {

package/dist/domain/requests.d.ts

@@ -65,10 +65,13 @@ export interface RequestState {
     statusCode: RequestStatusCode;
     kind: RequestKind;
     /**
-     * The amount originally asked for, always positive. A cancelled request
-     * has its on-request `requestedAmount` zeroed by the subgraph, so the
-     * original is recovered from the `Initiated` event (see
-     * `initiatedAmount`).
+     * `UserRequest.requestedAmount`, in assets: the amount still OUTSTANDING,
+     * which the subgraph reduces as parts are accepted or rejected (0 once a
+     * request is fully resolved). A cancelled request has it zeroed by the
+     * subgraph, so for a cancellation it is the `Cancelled` event's amount —
+     * what was outstanding when cancelled, top-ups included — falling back to
+     * the `Initiated` event (see `initiatedAmount`) only when that event
+     * carries none.
      */
     requestedAmount: number;
     /**
@@ -207,17 +210,15 @@ export declare function cancelDeadline(request: Pick<RequestState, 'canCancel' |
  * Convert a `UserRequest` into a `RequestState`. Pure — no clock, no network,
  * no copy.
  *
- * BRANCH ORDER (this IS the behaviour; it reproduces kasu-ui's
- * `deriveTransactionView` check for check):
+ * BRANCH ORDER (this IS the behaviour):
  *
  *   1. a `Cancelled` event                      → `cancelled`, neutral, 0
  *   2. a withdrawal with a `Forced` event       → `forced`, outflow, −accepted
  *   3. a reallocated deposit                    → `reallocated`, inflow, +accepted
- *   4. a withdrawal partly filled with a LIVE
- *      remainder (cycle still open)             → `partial`, outflow, −accepted
+ *   4. a withdrawal partly filled (paid > 0) with
+ *      a LIVE remainder (queued > 0, cycle open) → `partial`, outflow, −accepted
  *   5. resolved (`status === 'Processed'`):
- *        withdrawal, partly filled              → `partial`, outflow, −accepted
- *        withdrawal, fully filled               → `complete`, outflow, −accepted
+ *        withdrawal (nothing left queued)       → `complete`, outflow, −accepted
  *        deposit, nothing accepted              → `rejected`, neutral, 0
  *        deposit, part rejected                 → `partial`, inflow, +accepted
  *        deposit, fully accepted                → `complete`, inflow, +accepted

package/dist/services/UserLending/subgraph-types.d.ts

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

package/dist/services/UserLending/types.d.ts

@@ -36,8 +36,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/dist/services/UserLending/user-lending.d.ts

@@ -3,6 +3,8 @@ import { BigNumber, BigNumberish, BytesLike, ContractTransaction, Signer } from
 import { IKasuAllowListAbi__factory } from '../../contracts';
 import { SdkConfig } from '../../sdk-config';
 import { PortfolioUserTrancheBalance, UserApyBonus, UserPoolBalance, UserRequest, UserTrancheBalance } from './types';
+/** Thrown when the subgraph reports a request type with no known unit. */
+export declare const UNKNOWN_REQUEST_TYPE_MESSAGE = "UserLending: unknown request type, its amount unit is unknown";
 export declare class UserLending {
     private _kasuConfig;
     private readonly _graph;
@@ -60,6 +62,18 @@ export declare class UserLending {
     getCurrentFtdBalance(poolId: string, userId: string): Promise<Map<string, number[]>>;
     getCurrentEpochFtdAmount(poolIds: string[], userId: string, currentEpoch: string): Promise<Map<string, string[]>>;
     getCurrentEpochDepositedAmount(lendingPoolIds: string[], userId: string): Promise<Map<string, string>>;
+    /**
+     * 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;
     convertSharesToAssets(sharesAmount: string, totalAssets: string, totalSupply: string): string;
     isClearingPending(poolId: string): Promise<boolean>;
     isCancelable(status: string, lendingPoolId: string): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kasufinance/kasu-sdk",
-    "version": "2.13.0",
+    "version": "2.13.1",
     "description": "TypeScript SDK for the Kasu Finance protocol — pool data, portfolio analytics, and KYC-gated deposits and withdrawals on Base and XDC",
     "keywords": [
         "kasu",

package/src/domain/requests.ts

@@ -82,10 +82,13 @@ export interface RequestState {
     statusCode: RequestStatusCode;
     kind: RequestKind;
     /**
-     * The amount originally asked for, always positive. A cancelled request
-     * has its on-request `requestedAmount` zeroed by the subgraph, so the
-     * original is recovered from the `Initiated` event (see
-     * `initiatedAmount`).
+     * `UserRequest.requestedAmount`, in assets: the amount still OUTSTANDING,
+     * which the subgraph reduces as parts are accepted or rejected (0 once a
+     * request is fully resolved). A cancelled request has it zeroed by the
+     * subgraph, so for a cancellation it is the `Cancelled` event's amount —
+     * what was outstanding when cancelled, top-ups included — falling back to
+     * the `Initiated` event (see `initiatedAmount`) only when that event
+     * carries none.
      */
     requestedAmount: number;
     /**
@@ -287,16 +290,24 @@ const initiatedEvent = (
 ): UserRequestEvent | undefined =>
     events.find((e) => e.requestType === 'Initiated');
 
+/** `assetAmount` of the `Initiated` event, or 0 when there is none. */
+const initiatedAmountOf = (events: UserRequestEvent[]): number => {
+    const initiated = initiatedEvent(events);
+    return initiated ? Number(initiated.assetAmount || '0') : 0;
+};
+
 /**
  * Subgraph behaviour: when a request is cancelled, the on-request
  * `requestedAmount` field is reset to 0 (the lender's effective balance is
- * restored). The original amount survives on the `Initiated` event's
- * `assetAmount`. Recover from there so cancelled rows still carry the amount
- * the lender originally asked for.
+ * restored). The amount cancelled survives on the `Cancelled` event's
+ * `assetAmount` — everything still outstanding at the cancel, top-ups
+ * included. Only when that event carries no figure does this fall back to the
+ * `Initiated` event, which holds the FIRST submission alone and so misses
+ * every top-up.
  */
-const initiatedAmountOf = (events: UserRequestEvent[]): number => {
-    const initiated = initiatedEvent(events);
-    return initiated ? Number(initiated.assetAmount || '0') : 0;
+const cancelledAmountOf = (events: UserRequestEvent[]): number => {
+    const cancelledEvent = events.find((e) => e.requestType === 'Cancelled');
+    return num(cancelledEvent?.assetAmount) || initiatedAmountOf(events);
 };
 
 /**
@@ -332,17 +343,15 @@ const numOrNull = (str: string | null | undefined): number | null => {
  * Convert a `UserRequest` into a `RequestState`. Pure — no clock, no network,
  * no copy.
  *
- * BRANCH ORDER (this IS the behaviour; it reproduces kasu-ui's
- * `deriveTransactionView` check for check):
+ * BRANCH ORDER (this IS the behaviour):
  *
  *   1. a `Cancelled` event                      → `cancelled`, neutral, 0
  *   2. a withdrawal with a `Forced` event       → `forced`, outflow, −accepted
  *   3. a reallocated deposit                    → `reallocated`, inflow, +accepted
- *   4. a withdrawal partly filled with a LIVE
- *      remainder (cycle still open)             → `partial`, outflow, −accepted
+ *   4. a withdrawal partly filled (paid > 0) with
+ *      a LIVE remainder (queued > 0, cycle open) → `partial`, outflow, −accepted
  *   5. resolved (`status === 'Processed'`):
- *        withdrawal, partly filled              → `partial`, outflow, −accepted
- *        withdrawal, fully filled               → `complete`, outflow, −accepted
+ *        withdrawal (nothing left queued)       → `complete`, outflow, −accepted
  *        deposit, nothing accepted              → `rejected`, neutral, 0
  *        deposit, part rejected                 → `partial`, inflow, +accepted
  *        deposit, fully accepted                → `complete`, inflow, +accepted
@@ -369,10 +378,10 @@ export function deriveRequestState(request: UserRequest): RequestState {
     const isWithdrawal = request.requestType === 'Withdrawal';
     const cancelled = isCancelled(request.events);
     // Cancelled requests have `requestedAmount` zeroed on the request itself;
-    // pull the original value from the Initiated event so the row still
-    // carries "100 cancelled" instead of "0 cancelled".
+    // take the amount from the Cancelled event so the row still carries
+    // "1500 cancelled" (1000 + a 500 top-up) instead of "0 cancelled".
     const requested = cancelled
-        ? num(request.requestedAmount) || initiatedAmountOf(request.events)
+        ? num(request.requestedAmount) || cancelledAmountOf(request.events)
         : num(request.requestedAmount);
     const accepted = num(request.acceptedAmount);
     const rejected = num(request.rejectedAmount);
@@ -441,11 +450,14 @@ export function deriveRequestState(request: UserRequest): RequestState {
 
     // 4. Withdrawal partly filled with a LIVE remainder: the request returns
     // to the queue with a live Cancel. Checked BEFORE the resolved branch and
-    // via `isCycleClosed`, never via the sticky raw status.
+    // via `isCycleClosed`, never via the sticky raw status. `requested` is
+    // what is still OUTSTANDING, so "partly filled" is "something paid AND
+    // something still queued" — never a comparison of the two, which would
+    // turn on whether more was paid than is left.
     if (
         isWithdrawal &&
         accepted > 0 &&
-        accepted < requested &&
+        requested > 0 &&
         !isCycleClosed(request)
     ) {
         return {
@@ -458,13 +470,15 @@ export function deriveRequestState(request: UserRequest): RequestState {
 
     // 5. Resolved — a rejection IS a resolution.
     if (request.status === UserRequestStatus.PROCESSED) {
+        // A withdrawal is resolved only once nothing is left queued — a
+        // partly filled one returns to the queue (branch 4), and one cancelled
+        // with a remainder is branch 1 — so a resolved withdrawal is complete.
         if (isWithdrawal) {
-            const partly = accepted < requested;
             return {
                 ...base,
                 kind: 'outflow',
                 amount: -accepted,
-                statusCode: partly ? 'partial' : 'complete',
+                statusCode: 'complete',
             };
         }
 

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,