@suilend/sdk 3.0.8 → 5.0.0

package/utils/simulate.d.ts

@@ -1,4 +1,4 @@
-import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
+import { PriceFeed, SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { Decimal } from "../_generated/suilend/decimal/structs";
 import { PoolRewardManager, UserRewardManager } from "../_generated/suilend/liquidity-mining/structs";
@@ -22,6 +22,73 @@ export declare const calculateDepositAprPercent: (reserve: Reserve<string>) => B
 export declare const compoundReserveInterest: (reserve: Reserve<string>, nowS: number) => Reserve<string>;
 export declare const updatePoolRewardsManager: (manager: PoolRewardManager, nowMs: number) => PoolRewardManager;
 export declare const refreshReservePrice: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection) => Promise<Reserve<string>[]>;
+/**
+ * A connection that can report which of the requested feeds it could not serve,
+ * instead of failing the whole batch. Structural on purpose: any object with
+ * this method qualifies, so a caller can inject its own client without this
+ * package depending on it.
+ */
+export interface PartialPriceFeedSource {
+    getLatestPriceFeedsPartial(ids: string[]): Promise<{
+        feeds: PriceFeed[];
+        missing: string[];
+    }>;
+}
+/**
+ * Whether this connection can report WHICH requested feeds it could not serve.
+ *
+ * Exported because it is a precondition callers need to check, not just an
+ * internal branch: `tolerateMissingPriceFeeds` is meaningless without it (see
+ * `refreshReservesForInitialize`, which refuses the combination).
+ */
+export declare function canReportMissingPriceFeeds(connection: SuiPriceServiceConnection | PartialPriceFeedSource): connection is PartialPriceFeedSource;
+/**
+ * The remedy both gap-tolerance failure paths point at.
+ *
+ * One constant because the two paths fail at different moments for the same
+ * underlying reason — `refreshReservesForInitialize` refuses up front on
+ * capability, `refreshReservePriceTolerant` only once an endpoint actually
+ * rejects a batch — and separately worded advice for one cause is how the two
+ * drift apart.
+ */
+export declare const PARTIAL_FETCH_REQUIRED_HINT = "inject a connection implementing getLatestPriceFeedsPartial (e.g. a failover connection that reports per-feed gaps)";
+/**
+ * Like `refreshReservePrice`, but a reserve whose feed no endpoint can serve
+ * keeps the price already in its on-chain state instead of failing every other
+ * reserve with it.
+ *
+ * `refreshReservePrice` is all-or-nothing in both directions, and both are
+ * hazardous once an endpoint stops carrying every feed: a missing feed throws
+ * (so one retired market blinds pricing for the whole lending market), while an
+ * undefined response silently returns EVERY reserve at its stale price with no
+ * signal at all. Hermes v2 rejects an entire batch when any requested id is
+ * unknown, which makes both reachable in practice.
+ *
+ * This reports `unpricedCoinTypes` rather than deciding what an unpriceable
+ * reserve means — that judgement needs reserve config the caller has and this
+ * function should not second-guess. Nothing is ever fabricated here.
+ *
+ * TWO THINGS A CALLER MUST KNOW:
+ *
+ * 1. An unpriced reserve is returned in `reserves` carrying whatever price its
+ *    on-chain state holds — which may be ZERO for a reserve that was never
+ *    priced on-chain. Folding `reserves` into collateral or borrow-limit math
+ *    without first excluding `unpricedCoinTypes` therefore prices that reserve
+ *    at literal zero. `unpricedCoinTypes` is the only thing distinguishing a
+ *    real price from a kept one; it is not optional to read.
+ * 2. Tolerance requires a connection that can REPORT a gap
+ *    (`getLatestPriceFeedsPartial`). Handed a stock `SuiPriceServiceConnection`,
+ *    this falls back to the all-or-nothing fetch, which Hermes v2 answers with
+ *    a 404 for the whole batch when any id is unknown — so there is nothing
+ *    left to be tolerant with. That fetch is kept because it is correct for an
+ *    endpoint that OMITS unknown ids rather than rejecting the batch, but the
+ *    failure is re-thrown with attribution rather than surfacing as a bare HTTP
+ *    error. `refreshReservesForInitialize` rejects the combination outright.
+ */
+export declare const refreshReservePriceTolerant: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection | PartialPriceFeedSource) => Promise<{
+    reserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
+}>;
 export declare const updateUserRewardManager: (poolManager: PoolRewardManager, userRewardManager: UserRewardManager, nowMs: number) => UserRewardManager;
 export declare const refreshObligation: (unrefreshedObligation: Obligation<string>, refreshedReserves: Reserve<string>[]) => Obligation<string>;
 export declare const numberToDecimal: (value: number) => Decimal;

package/utils/simulate.js

@@ -1,14 +1,5 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { bcs } from "@mysten/sui/bcs";
-import { toHex } from "@mysten/sui/utils";
+import { normalizeStructTag, toHex } from "@mysten/sui/utils";
 import BigNumber from "bignumber.js";
 import { v4 as uuidv4 } from "uuid";
 import { Decimal } from "../_generated/suilend/decimal/structs.js";
@@ -68,7 +59,6 @@ export const calculateDepositAprPercent = (reserve) => {
     return calculateSupplyApr(reserve);
 };
 export const compoundReserveInterest = (reserve, nowS) => {
-    var _a, _b;
     const timeElapsedSeconds = nowS - Number(reserve.interestLastUpdateTimestampS);
     if (timeElapsedSeconds === 0) {
         return reserve;
@@ -79,13 +69,13 @@ export const compoundReserveInterest = (reserve, nowS) => {
         .div(100)
         .div(365 * 24 * 60 * 60))
         .pow(new BigNumber(timeElapsedSeconds).toNumber());
-    const updatedReserve = Object.assign({}, reserve);
+    const updatedReserve = { ...reserve };
     const oldBorrowedAmount = decimalToBigNumber(reserve.borrowedAmount);
     const oldCumulativeBorrowRate = decimalToBigNumber(reserve.cumulativeBorrowRate);
     const oldUnclaimedSpreadFees = decimalToBigNumber(reserve.unclaimedSpreadFees);
     updatedReserve.cumulativeBorrowRate = stringToDecimal(compoundedBorrowRate.multipliedBy(oldCumulativeBorrowRate).toString());
     const netNewDebt = oldBorrowedAmount.multipliedBy(compoundedBorrowRate.minus(1));
-    const spreadFee = new BigNumber(((_b = (_a = reserve.config.element) === null || _a === void 0 ? void 0 : _a.spreadFeeBps) === null || _b === void 0 ? void 0 : _b.toString()) || 0);
+    const spreadFee = new BigNumber(reserve.config.element?.spreadFeeBps?.toString() || 0);
     updatedReserve.unclaimedSpreadFees = stringToDecimal(oldUnclaimedSpreadFees
         .plus(netNewDebt.multipliedBy(spreadFee.dividedBy(10000)))
         .toString());
@@ -96,7 +86,7 @@ export const compoundReserveInterest = (reserve, nowS) => {
     return updatedReserve;
 };
 export const updatePoolRewardsManager = (manager, nowMs) => {
-    const updatedManager = Object.assign({}, manager);
+    const updatedManager = { ...manager };
     const timeElapsedMs = nowMs - Number(manager.lastUpdateTimeMs);
     if (manager.totalShares === BigInt(0) || timeElapsedMs === 0) {
         return updatedManager;
@@ -109,7 +99,7 @@ export const updatePoolRewardsManager = (manager, nowMs) => {
             manager.lastUpdateTimeMs >= poolReward.endTimeMs) {
             return poolReward;
         }
-        const updatedPoolReward = Object.assign({}, poolReward);
+        const updatedPoolReward = { ...poolReward };
         const endTimeMs = Number(poolReward.endTimeMs);
         const startTimeMs = Number(poolReward.startTimeMs);
         const lastUpdateTimeMs = Number(manager.lastUpdateTimeMs);
@@ -128,27 +118,153 @@ export const updatePoolRewardsManager = (manager, nowMs) => {
     updatedManager.lastUpdateTimeMs = BigInt(nowMs);
     return updatedManager;
 };
-export const refreshReservePrice = (reserves, pythConnection) => __awaiter(void 0, void 0, void 0, function* () {
-    const priceIdentifiers = Array.from(new Set(reserves.map((r) => toHex(new Uint8Array(r.priceIdentifier.bytes)))));
-    const priceFeeds = yield pythConnection.getLatestPriceFeeds(priceIdentifiers);
+/** The Pyth feed id a reserve is priced from, in the response's `id` encoding. */
+const reserveFeedId = (reserve) => toHex(new Uint8Array(reserve.priceIdentifier.bytes));
+/**
+ * Index feeds by id for O(1) lookup, keeping the FIRST entry per id.
+ *
+ * First-wins matches the `priceFeeds.find(...)` this replaced, so a duplicated
+ * id in a response resolves to the same feed it always did. Pyth does not
+ * duplicate ids today; the point is that switching to a Map is not allowed to
+ * quietly change which one is picked if it ever does.
+ */
+const indexFeedsById = (priceFeeds) => {
+    const byId = new Map();
+    for (const feed of priceFeeds)
+        if (!byId.has(feed.id))
+            byId.set(feed.id, feed);
+    return byId;
+};
+/**
+ * Apply a feed's price to a COPY of `reserve`.
+ *
+ * Shared by both refresh functions so the price-mapping math has exactly one
+ * definition. It was duplicated verbatim, which meant a change to how a feed
+ * becomes a price had to be made twice or the two silently diverged.
+ *
+ * The two functions still own their own control flow — what a MISSING feed
+ * means is precisely where they are supposed to differ (see
+ * `refreshReservePriceTolerant`).
+ */
+const withFeedPrice = (reserve, priceFeed) => {
+    const newReserve = { ...reserve };
+    newReserve.price = stringToDecimal(priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked().toString());
+    newReserve.smoothedPrice = stringToDecimal(priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked().toString());
+    newReserve.priceLastUpdateTimestampS = BigInt(priceFeed.getPriceUnchecked().publishTime);
+    return newReserve;
+};
+export const refreshReservePrice = async (reserves, pythConnection) => {
+    const priceIdentifiers = Array.from(new Set(reserves.map(reserveFeedId)));
+    const priceFeeds = await pythConnection.getLatestPriceFeeds(priceIdentifiers);
+    // Deliberately NOT a throw, and deliberately not expressed over the tolerant
+    // function below: consumers outside this repo depend on `undefined` meaning
+    // "keep every reserve's existing price". Hazardous (see the tolerant
+    // function's comment), but changing it here would turn a quiet failure loud
+    // under callers who never asked for that.
     if (!priceFeeds)
         return reserves;
+    const byId = indexFeedsById(priceFeeds);
     const updatedReserves = [];
     for (let i = 0; i < reserves.length; i++) {
         const reserve = reserves[i];
-        const priceFeed = priceFeeds.find((p) => p.id === toHex(new Uint8Array(reserve.priceIdentifier.bytes)));
+        const priceFeed = byId.get(reserveFeedId(reserve));
         if (!priceFeed)
             throw new Error(`Price feed not found for reserve ${reserve.coinType.name}`);
-        const newReserve = Object.assign({}, reserve);
-        newReserve.price = stringToDecimal(priceFeed.getPriceUnchecked().getPriceAsNumberUnchecked().toString());
-        newReserve.smoothedPrice = stringToDecimal(priceFeed.getEmaPriceUnchecked().getPriceAsNumberUnchecked().toString());
-        newReserve.priceLastUpdateTimestampS = BigInt(priceFeed.getPriceUnchecked().publishTime);
-        updatedReserves.push(newReserve);
+        updatedReserves.push(withFeedPrice(reserve, priceFeed));
     }
     return updatedReserves;
-});
+};
+/**
+ * Whether this connection can report WHICH requested feeds it could not serve.
+ *
+ * Exported because it is a precondition callers need to check, not just an
+ * internal branch: `tolerateMissingPriceFeeds` is meaningless without it (see
+ * `refreshReservesForInitialize`, which refuses the combination).
+ */
+export function canReportMissingPriceFeeds(connection) {
+    return (typeof connection.getLatestPriceFeedsPartial ===
+        "function");
+}
+/**
+ * The remedy both gap-tolerance failure paths point at.
+ *
+ * One constant because the two paths fail at different moments for the same
+ * underlying reason — `refreshReservesForInitialize` refuses up front on
+ * capability, `refreshReservePriceTolerant` only once an endpoint actually
+ * rejects a batch — and separately worded advice for one cause is how the two
+ * drift apart.
+ */
+export const PARTIAL_FETCH_REQUIRED_HINT = "inject a connection implementing getLatestPriceFeedsPartial (e.g. a failover connection that reports per-feed gaps)";
+/**
+ * Like `refreshReservePrice`, but a reserve whose feed no endpoint can serve
+ * keeps the price already in its on-chain state instead of failing every other
+ * reserve with it.
+ *
+ * `refreshReservePrice` is all-or-nothing in both directions, and both are
+ * hazardous once an endpoint stops carrying every feed: a missing feed throws
+ * (so one retired market blinds pricing for the whole lending market), while an
+ * undefined response silently returns EVERY reserve at its stale price with no
+ * signal at all. Hermes v2 rejects an entire batch when any requested id is
+ * unknown, which makes both reachable in practice.
+ *
+ * This reports `unpricedCoinTypes` rather than deciding what an unpriceable
+ * reserve means — that judgement needs reserve config the caller has and this
+ * function should not second-guess. Nothing is ever fabricated here.
+ *
+ * TWO THINGS A CALLER MUST KNOW:
+ *
+ * 1. An unpriced reserve is returned in `reserves` carrying whatever price its
+ *    on-chain state holds — which may be ZERO for a reserve that was never
+ *    priced on-chain. Folding `reserves` into collateral or borrow-limit math
+ *    without first excluding `unpricedCoinTypes` therefore prices that reserve
+ *    at literal zero. `unpricedCoinTypes` is the only thing distinguishing a
+ *    real price from a kept one; it is not optional to read.
+ * 2. Tolerance requires a connection that can REPORT a gap
+ *    (`getLatestPriceFeedsPartial`). Handed a stock `SuiPriceServiceConnection`,
+ *    this falls back to the all-or-nothing fetch, which Hermes v2 answers with
+ *    a 404 for the whole batch when any id is unknown — so there is nothing
+ *    left to be tolerant with. That fetch is kept because it is correct for an
+ *    endpoint that OMITS unknown ids rather than rejecting the batch, but the
+ *    failure is re-thrown with attribution rather than surfacing as a bare HTTP
+ *    error. `refreshReservesForInitialize` rejects the combination outright.
+ */
+export const refreshReservePriceTolerant = async (reserves, pythConnection) => {
+    const priceIdentifiers = Array.from(new Set(reserves.map(reserveFeedId)));
+    let priceFeeds;
+    if (canReportMissingPriceFeeds(pythConnection)) {
+        priceFeeds = (await pythConnection.getLatestPriceFeedsPartial(priceIdentifiers)).feeds;
+    }
+    else {
+        try {
+            priceFeeds = await pythConnection.getLatestPriceFeeds(priceIdentifiers);
+        }
+        catch (error) {
+            // Not swallowed — a transport failure must stay a failure, or every
+            // reserve silently reports as unpriced and the caller cannot tell a dead
+            // endpoint from a retired feed. Re-thrown only to name the cause, which a
+            // bare "HTTP error! status: 404" does not.
+            throw new Error(`Tolerant price refresh failed on an all-or-nothing connection: ${error instanceof Error ? error.message : String(error)}. This connection cannot report which feeds are missing, so an endpoint that rejects the whole batch over one unknown id (Hermes v2) defeats tolerance entirely — ${PARTIAL_FETCH_REQUIRED_HINT}.`, { cause: error });
+        }
+    }
+    const byId = indexFeedsById(priceFeeds ?? []);
+    const unpricedCoinTypes = [];
+    const updatedReserves = reserves.map((reserve) => {
+        const priceFeed = byId.get(reserveFeedId(reserve));
+        if (!priceFeed) {
+            // Normalized to match every other coin type this SDK returns
+            // (`reserveMap`, `reserveCoinTypes`, and the parsers are all
+            // normalizeStructTag'd). The raw on-chain form never compares equal to
+            // one of those keys — it lacks the `0x` prefix — so reporting it raw made
+            // the cross-reference this field exists for silently never match.
+            unpricedCoinTypes.push(normalizeStructTag(reserve.coinType.name));
+            return reserve;
+        }
+        return withFeedPrice(reserve, priceFeed);
+    });
+    return { reserves: updatedReserves, unpricedCoinTypes };
+};
 export const updateUserRewardManager = (poolManager, userRewardManager, nowMs) => {
-    const updatedUserRewardManager = Object.assign({}, userRewardManager);
+    const updatedUserRewardManager = { ...userRewardManager };
     for (let i = 0; i < poolManager.poolRewards.length; i++) {
         const poolReward = poolManager.poolRewards[i];
         if (poolReward == null) {
@@ -158,7 +274,7 @@ export const updateUserRewardManager = (poolManager, userRewardManager, nowMs) =
             userRewardManager.rewards.push(null);
         }
         const oldReward = updatedUserRewardManager.rewards[i];
-        const reward = Object.assign({}, oldReward);
+        const reward = { ...oldReward };
         if (oldReward != null) {
             const newRewards = decimalToBigNumber(poolReward.cumulativeRewardsPerShare)
                 .minus(decimalToBigNumber(oldReward.cumulativeRewardsPerShare))
@@ -183,13 +299,13 @@ export const updateUserRewardManager = (poolManager, userRewardManager, nowMs) =
     return updatedUserRewardManager;
 };
 export const refreshObligation = (unrefreshedObligation, refreshedReserves) => {
-    const obligation = Object.assign({}, unrefreshedObligation);
+    const obligation = { ...unrefreshedObligation };
     // Refresh Deposits
     let depositValueUsd = new BigNumber(0);
     let allowedBorrowValueUsd = new BigNumber(0);
     let unhealthyBorrowValueUsd = new BigNumber(0);
     for (let i = 0; i < obligation.deposits.length; i++) {
-        const deposit = Object.assign({}, obligation.deposits[i]);
+        const deposit = { ...obligation.deposits[i] };
         const reserve = refreshedReserves.find((r) => r.coinType.name === deposit.coinType.name);
         if (!reserve) {
             throw new Error(`Unable to find reserve for coin type ${deposit.coinType.name}`);
@@ -219,7 +335,9 @@ export const refreshObligation = (unrefreshedObligation, refreshedReserves) => {
             throw new Error(`Unable to find reserve for coin type ${unrefreshedBorrow.coinType.name}`);
         }
         const config = reserve.config.element;
-        const borrow = Object.assign({}, compoundDebt(unrefreshedBorrow, reserve));
+        const borrow = {
+            ...compoundDebt(unrefreshedBorrow, reserve),
+        };
         obligation.userRewardManagers[Number(borrow.userRewardManagerIndex)] =
             updateUserRewardManager(reserve.borrowsPoolRewardManager, obligation.userRewardManagers[Number(borrow.userRewardManagerIndex)], Date.now());
         const marketValue = decimalToBigNumber(borrow.borrowedAmount)
@@ -276,7 +394,7 @@ export const totalSupply = (reserve) => {
         .minus(decimalToBigNumber(reserve.unclaimedSpreadFees));
 };
 export const compoundDebt = (borrow, reserve) => {
-    const borrowCopy = Object.assign({}, borrow);
+    const borrowCopy = { ...borrow };
     const newCumulativeBorrowRate = decimalToBigNumber(reserve.cumulativeBorrowRate);
     const compoundedInterestRate = newCumulativeBorrowRate.dividedBy(decimalToBigNumber(borrow.cumulativeBorrowRate));
     borrowCopy.borrowedAmount = stringToDecimal(decimalToBigNumber(borrow.borrowedAmount)