@suilend/sdk 4.0.0 → 5.0.0

package/lib/initialize.d.ts

@@ -1,5 +1,6 @@
 import { SuiClientTypes } from "@mysten/sui/client";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { Reserve } from "../_generated/suilend/reserve/structs";
 import { SuilendClient } from "../client";
@@ -9,7 +10,87 @@ export declare const RESERVES_CUSTOM_ORDER: Record<string, string[]>;
 export declare const NORMALIZED_MAYA_COINTYPE: string;
 export declare const NORMALIZED_mPOINTS_COINTYPE: string;
 export declare const NORMALIZED_TREATS_COINTYPE: string;
-export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendClient: SuilendClient, lendingMarketMetadata?: LendingMarketMetadata, fallbackPythEndpoint?: string) => Promise<{
+/**
+ * Price reserves for `initializeSuilend`, honouring the opt-in tolerance flag.
+ *
+ * Extracted so both branches are directly testable — the difference between
+ * them is a throw, which is the whole reason the flag exists and is exactly
+ * what a regression here would silently change.
+ */
+export declare const refreshReservesForInitialize: (reserves: Reserve<string>[], pythConnection: SuiPriceServiceConnection, tolerateMissingPriceFeeds?: boolean) => Promise<{
+    reserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
+}>;
+/**
+ * Price the temporary-Pyth-feed reserves from the cached-price service, in
+ * place, and report which ones ended up with a FABRICATED price.
+ *
+ * These reserves never reach the Pyth refresh at all, so nothing else can
+ * report them. When the cached lookup fails the price falls back to a
+ * hardcoded 0.0001 — a placeholder chosen to be non-zero, not a market price —
+ * and previously that was indistinguishable from a real quote: the reserve
+ * carried a plausible-looking number and appeared in no gap report.
+ *
+ * Extracted for the same reason as `refreshReservesForInitialize`:
+ * `initializeSuilend` needs a gRPC client and a SuilendClient, so logic left
+ * inline in it cannot be tested, and "is this price real" is not something to
+ * leave unverified.
+ */
+export declare const priceTemporaryPythFeedReserves: (reserves: Reserve<string>[], fetchPrice?: (coinType: string) => Promise<number | undefined>) => Promise<string[]>;
+export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendClient: SuilendClient, lendingMarketMetadata?: LendingMarketMetadata, fallbackPythEndpoint?: string, options?: {
+    /**
+     * Price connection to use instead of the one this function would build.
+     *
+     * Without this, the connection is constructed here and never exposed, so a
+     * caller cannot authenticate it, point it at a different Hermes deployment,
+     * or give it failover — it is unreachable from outside.
+     *
+     * SUPERSEDES `fallbackPythEndpoint`, which is ignored when this is set.
+     * That parameter is a hint for building a connection, and there is nothing
+     * left to build; it engages only when a `/live` probe fails, which tests
+     * whether Hermes is UP, not whether it still serves your feeds (a 401 or a
+     * per-feed 404 never trips it). Supply failover on the connection you
+     * inject — a multi-endpoint connection covers strictly more than the probe
+     * did.
+     *
+     * YOU ALSO OWN THE TIMEOUT. The connection this function builds for itself
+     * uses 30s; pyth-sui-js defaults to 5s, so an injected connection
+     * constructed with default options gets a 6x tighter deadline than
+     * initializeSuilend used to guarantee. Nothing here can impose a timeout on
+     * an object it did not construct — set it when you build the connection.
+     *
+     * Must be a `SuiPriceServiceConnection` (a subclass is fine, and is how you
+     * add `getLatestPriceFeedsPartial`). Not the structural
+     * `PartialPriceFeedSource` shape: with `tolerateMissingPriceFeeds` off this
+     * connection goes to `refreshReservePrice`, which needs the class's own
+     * `getLatestPriceFeeds`. The lower-level `refreshReservePriceTolerant` does
+     * accept the structural shape, since it only ever needs the partial fetch.
+     */
+    pythConnection?: SuiPriceServiceConnection;
+    /**
+     * Let a reserve whose feed no endpoint can serve keep the price already in
+     * its on-chain state, instead of failing the whole market. Off by default.
+     *
+     * OPT-IN because it trades a loud failure for a quiet one, and only the
+     * caller knows which it wants. A UI is usually better off failing visibly
+     * than rendering a stale price with no indication; a liquidator watching 45
+     * reserves is better off pricing the 41 it can than going blind over the 4
+     * it cannot.
+     *
+     * REQUIRES `pythConnection` to implement `getLatestPriceFeedsPartial` —
+     * throws otherwise, rather than degrading to the identical hard failure
+     * this flag exists to avoid. The connection this function builds for itself
+     * is all-or-nothing, so the flag cannot be used alone.
+     *
+     * Callers that enable this MUST read `unpricedCoinTypes` and decide per
+     * reserve what a kept price is allowed to mean — nothing here makes that
+     * judgement for them. An unpriced reserve stays in `refreshedRawReserves`
+     * carrying its on-chain price, which may be zero, so folding that array
+     * into collateral or borrow-limit math without excluding those coin types
+     * prices them at literal zero.
+     */
+    tolerateMissingPriceFeeds?: boolean;
+}) => Promise<{
     lendingMarket: {
         version: bigint;
         reserves: {
@@ -148,6 +229,7 @@ export declare const initializeSuilend: (suiGrpcClient: SuiGrpcClient, suilendCl
     };
     coinMetadataMap: Record<string, SuiClientTypes.CoinMetadata>;
     refreshedRawReserves: Reserve<string>[];
+    unpricedCoinTypes: string[];
     reserveMap: Record<string, {
         config: {
             $typeName: string;

package/lib/initialize.js

@@ -1,12 +1,11 @@
 import { normalizeStructTag } from "@mysten/sui/utils";
-import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 import BigNumber from "bignumber.js";
 import { NORMALIZED_ALKIMI_COINTYPE, NORMALIZED_AUSD_COINTYPE, NORMALIZED_BLUE_COINTYPE, NORMALIZED_BUCK_COINTYPE, NORMALIZED_DEEP_COINTYPE, NORMALIZED_DMC_COINTYPE, NORMALIZED_FUD_COINTYPE, NORMALIZED_HAEDAL_COINTYPE, NORMALIZED_HIPPO_COINTYPE, NORMALIZED_IKA_COINTYPE, NORMALIZED_KOBAN_COINTYPE, NORMALIZED_LBTC_COINTYPE, NORMALIZED_NS_COINTYPE, NORMALIZED_SEND_COINTYPE, NORMALIZED_SEND_POINTS_S1_COINTYPE, NORMALIZED_SEND_POINTS_S2_COINTYPE, NORMALIZED_SOL_COINTYPE, NORMALIZED_SUI_COINTYPE, NORMALIZED_UP_COINTYPE, NORMALIZED_USDB_COINTYPE, NORMALIZED_USDC_COINTYPE, NORMALIZED_USDsui_COINTYPE, NORMALIZED_WAL_COINTYPE, NORMALIZED_WBTC_COINTYPE, NORMALIZED_WETH_COINTYPE, NORMALIZED_XAUm_COINTYPE, NORMALIZED_eEARN_COINTYPE, NORMALIZED_eTHIRD_COINTYPE, NORMALIZED_flSUI_COINTYPE, NORMALIZED_fpSUI_COINTYPE, NORMALIZED_fudSUI_COINTYPE, NORMALIZED_iSUI_COINTYPE, NORMALIZED_jugSUI_COINTYPE, NORMALIZED_kSUI_COINTYPE, NORMALIZED_mSUI_COINTYPE, NORMALIZED_mUSD_COINTYPE, NORMALIZED_oshiSUI_COINTYPE, NORMALIZED_sSUI_COINTYPE, NORMALIZED_sdeUSD_COINTYPE, NORMALIZED_stratSUI_COINTYPE, NORMALIZED_suiETH_COINTYPE, NORMALIZED_suiUSDT_COINTYPE, NORMALIZED_suiUSDe_COINTYPE, NORMALIZED_suiWBTC_COINTYPE, NORMALIZED_trevinSUI_COINTYPE, NORMALIZED_upSUI_COINTYPE, NORMALIZED_wUSDC_COINTYPE, NORMALIZED_wUSDT_COINTYPE, NORMALIZED_xBTC_COINTYPE, NORMALIZED_yapSUI_COINTYPE, TEMPORARY_PYTH_PRICE_FEED_COINTYPES, getAllOwnedObjects, getCoinMetadataMap, getPrice, isSendPoints, isSteammPoints, } from "@suilend/sui-core";
 import { LENDING_MARKET_ID, SuilendClient } from "../client.js";
 import { parseLendingMarket, parseObligation } from "../parsers/index.js";
 import * as simulate from "../utils/simulate.js";
 import { WAD } from "./constants.js";
-import { getWorkingPythEndpoint } from "./pyth.js";
+import { resolvePythConnection } from "./pyth.js";
 import { STRATEGY_TYPE_INFO_MAP, STRATEGY_WRAPPER_PACKAGE_ID_V1, } from "./strategyOwnerCap.js";
 export const RESERVES_CUSTOM_ORDER = {
     [LENDING_MARKET_ID]: [
@@ -85,7 +84,79 @@ const TREATS_COINTYPE = "0x0dadb7fa2771c2952f96161fc1f0c105d1f22d53926b9ff2498a8
 export const NORMALIZED_MAYA_COINTYPE = normalizeStructTag(MAYA_COINTYPE);
 export const NORMALIZED_mPOINTS_COINTYPE = normalizeStructTag(mPOINTS_COINTYPE);
 export const NORMALIZED_TREATS_COINTYPE = normalizeStructTag(TREATS_COINTYPE);
-export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMarketMetadata, fallbackPythEndpoint) => {
+/**
+ * Price reserves for `initializeSuilend`, honouring the opt-in tolerance flag.
+ *
+ * Extracted so both branches are directly testable — the difference between
+ * them is a throw, which is the whole reason the flag exists and is exactly
+ * what a regression here would silently change.
+ */
+export const refreshReservesForInitialize = async (reserves, pythConnection, tolerateMissingPriceFeeds) => {
+    if (tolerateMissingPriceFeeds) {
+        // Tolerance is only expressible over a connection that can report WHICH
+        // feeds it could not serve. A stock SuiPriceServiceConnection cannot: the
+        // method does not exist in pyth-sui-js, so the tolerant path would fall
+        // back to the all-or-nothing fetch, and Hermes v2 404s the whole batch over
+        // one unknown id — the caller would get the same hard failure as before the
+        // flag existed, having explicitly asked not to.
+        //
+        // Rejected here rather than left to degrade quietly, because the pairing is
+        // otherwise invisible: nothing in the flag's name or type says it needs a
+        // connection the SDK cannot build for itself. Checked on CAPABILITY, not on
+        // whether a connection was injected — injecting a stock one is equally
+        // useless. Direct callers of refreshReservePriceTolerant keep the strict
+        // fallback, which is correct for an endpoint that omits unknown ids.
+        if (!simulate.canReportMissingPriceFeeds(pythConnection)) {
+            throw new Error(`tolerateMissingPriceFeeds requires a connection that can report per-feed gaps. The connection in use is all-or-nothing, so an endpoint that rejects the whole batch over one unknown feed would fail initialization regardless of this flag — ${simulate.PARTIAL_FETCH_REQUIRED_HINT}. Note that patching SuiPriceServiceConnection.prototype does NOT satisfy this: it can reroute getLatestPriceFeeds but cannot add a per-feed gap report.`);
+        }
+        return simulate.refreshReservePriceTolerant(reserves, pythConnection);
+    }
+    // Default path, behaviourally identical to what this function did before the
+    // flag existed: throws if any requested feed is absent from the response.
+    return {
+        reserves: await simulate.refreshReservePrice(reserves, pythConnection),
+        unpricedCoinTypes: [],
+    };
+};
+/**
+ * Price the temporary-Pyth-feed reserves from the cached-price service, in
+ * place, and report which ones ended up with a FABRICATED price.
+ *
+ * These reserves never reach the Pyth refresh at all, so nothing else can
+ * report them. When the cached lookup fails the price falls back to a
+ * hardcoded 0.0001 — a placeholder chosen to be non-zero, not a market price —
+ * and previously that was indistinguishable from a real quote: the reserve
+ * carried a plausible-looking number and appeared in no gap report.
+ *
+ * Extracted for the same reason as `refreshReservesForInitialize`:
+ * `initializeSuilend` needs a gRPC client and a SuilendClient, so logic left
+ * inline in it cannot be tested, and "is this price real" is not something to
+ * leave unverified.
+ */
+export const priceTemporaryPythFeedReserves = async (reserves, fetchPrice = getPrice) => {
+    const fabricatedPriceCoinTypes = [];
+    await Promise.all(reserves.map(async (reserve) => {
+        const coinType = normalizeStructTag(reserve.coinType.name);
+        let cachedUsdPrice;
+        try {
+            cachedUsdPrice = await fetchPrice(coinType);
+        }
+        catch (err) {
+            console.error(err);
+        }
+        if (cachedUsdPrice === undefined) {
+            cachedUsdPrice = 0.0001; // Non-zero price override if no price
+            fabricatedPriceCoinTypes.push(coinType);
+        }
+        const parsedCachedUsdPrice = BigInt(+new BigNumber(cachedUsdPrice)
+            .times(WAD)
+            .integerValue(BigNumber.ROUND_DOWN));
+        reserve.price.value = parsedCachedUsdPrice;
+        reserve.smoothedPrice.value = parsedCachedUsdPrice;
+    }));
+    return fabricatedPriceCoinTypes;
+};
+export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMarketMetadata, fallbackPythEndpoint, options) => {
     const nowMs = Date.now();
     const nowS = Math.floor(nowMs / 1000);
     const interestCompoundedRawReserves = suilendClient.lendingMarket.reserves.map((r) => simulate.compoundReserveInterest(r, nowS));
@@ -100,35 +171,35 @@ export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMar
             reservesWithoutTemporaryPythPriceFeeds.push(reserve);
         }
     }
-    // Get a working Pyth endpoint (try primary, fallback to fallbackPythEndpoint if provided)
-    const pythEndpoint = await getWorkingPythEndpoint(fallbackPythEndpoint);
-    const pythConnection = new SuiPriceServiceConnection(pythEndpoint, {
-        timeout: 30 * 1000,
-    });
-    const [refreshedReservesWithoutTemporaryPythPriceFeeds] = await Promise.all([
-        simulate.refreshReservePrice(reservesWithoutTemporaryPythPriceFeeds, pythConnection),
-        Promise.all(reservesWithTemporaryPythPriceFeeds.map((reserve) => (async () => {
-            let cachedUsdPrice;
-            try {
-                cachedUsdPrice = await getPrice(normalizeStructTag(reserve.coinType.name));
-            }
-            catch (err) {
-                console.error(err);
-            }
-            if (cachedUsdPrice === undefined)
-                cachedUsdPrice = 0.0001; // Non-zero price override if no price
-            const parsedCachedUsdPrice = BigInt(+new BigNumber(cachedUsdPrice)
-                .times(WAD)
-                .integerValue(BigNumber.ROUND_DOWN));
-            reserve.price.value = parsedCachedUsdPrice;
-            reserve.smoothedPrice.value = parsedCachedUsdPrice;
-        })())),
+    const pythConnection = await resolvePythConnection(options?.pythConnection, fallbackPythEndpoint);
+    const [refreshedWithoutTemporary, fabricatedPriceCoinTypes] = await Promise.all([
+        refreshReservesForInitialize(reservesWithoutTemporaryPythPriceFeeds, pythConnection, options?.tolerateMissingPriceFeeds),
+        priceTemporaryPythFeedReserves(reservesWithTemporaryPythPriceFeeds),
     ]);
     // Recombine reserves back into a single array
     const refreshedRawReserves = [
-        ...refreshedReservesWithoutTemporaryPythPriceFeeds,
+        ...refreshedWithoutTemporary.reserves,
         ...reservesWithTemporaryPythPriceFeeds,
     ];
+    // Reserves NOT carrying a real refreshed price, from either cause: no endpoint
+    // served the Pyth feed (needs `tolerateMissingPriceFeeds`, else the refresh
+    // threw), or a temporary-feed reserve fell back to a fabricated placeholder
+    // (independent of that flag). Surfaced rather than logged-and-forgotten: only
+    // the caller knows whether a given reserve can safely hold such a price.
+    //
+    // Normalized, matching `reserveMap` / `reserveCoinTypes` keys. Entries in
+    // `refreshedRawReserves` carry the RAW on-chain `coinType.name`, which never
+    // compares equal to these (no `0x` prefix), so filtering that array means
+    // normalizing first:
+    //
+    //   const unpriced = new Set(unpricedCoinTypes);
+    //   refreshedRawReserves.filter(
+    //     (r) => !unpriced.has(normalizeStructTag(r.coinType.name)),
+    //   );
+    const unpricedCoinTypes = [
+        ...refreshedWithoutTemporary.unpricedCoinTypes,
+        ...fabricatedPriceCoinTypes,
+    ];
     const miscCoinTypes = [
         NORMALIZED_SEND_POINTS_S1_COINTYPE,
         NORMALIZED_SEND_POINTS_S2_COINTYPE,
@@ -193,6 +264,7 @@ export const initializeSuilend = async (suiGrpcClient, suilendClient, lendingMar
         lendingMarket,
         coinMetadataMap,
         refreshedRawReserves,
+        unpricedCoinTypes,
         reserveMap,
         reserveCoinTypes: uniqueReserveCoinTypes,
         reserveCoinMetadataMap,

package/lib/pyth.d.ts

@@ -1,3 +1,4 @@
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 export declare const PRIMARY_PYTH_ENDPOINT = "https://hermes.pyth.network";
 /**
  * Tests if the primary Pyth connection endpoint is working by checking the /live endpoint
@@ -10,3 +11,18 @@ export declare const testPrimaryPythConnection: () => Promise<boolean>;
  * @returns The endpoint URL that is working, or the primary endpoint if fallback fails
  */
 export declare const getWorkingPythEndpoint: (fallbackPythEndpoint?: string) => Promise<string>;
+/**
+ * Pick the price connection `initializeSuilend` will use.
+ *
+ * Lives here rather than in initialize.ts for two reasons: it belongs beside
+ * getWorkingPythEndpoint, the thing it decides whether to call; and this module
+ * imports nothing, so the seam is testable without resolving
+ * `@suilend/sui-core` (whose in-repo `exports` points at a .js file that does
+ * not exist, making initialize.ts unimportable from source).
+ *
+ * Skipping the probe for an injected connection is deliberate, not an
+ * optimisation. getWorkingPythEndpoint fetches hermes.pyth.network/live, which
+ * answers for whether Hermes is up — not for whether it still serves the
+ * caller's feeds, and not for whether the caller is even pointed at Hermes.
+ */
+export declare const resolvePythConnection: (pythConnectionOverride?: SuiPriceServiceConnection, fallbackPythEndpoint?: string) => Promise<SuiPriceServiceConnection>;

package/lib/pyth.js

@@ -1,3 +1,4 @@
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
 export const PRIMARY_PYTH_ENDPOINT = "https://hermes.pyth.network";
 /**
  * Tests if the primary Pyth connection endpoint is working by checking the /live endpoint
@@ -37,3 +38,26 @@ export const getWorkingPythEndpoint = async (fallbackPythEndpoint) => {
         return PRIMARY_PYTH_ENDPOINT;
     }
 };
+/**
+ * Pick the price connection `initializeSuilend` will use.
+ *
+ * Lives here rather than in initialize.ts for two reasons: it belongs beside
+ * getWorkingPythEndpoint, the thing it decides whether to call; and this module
+ * imports nothing, so the seam is testable without resolving
+ * `@suilend/sui-core` (whose in-repo `exports` points at a .js file that does
+ * not exist, making initialize.ts unimportable from source).
+ *
+ * Skipping the probe for an injected connection is deliberate, not an
+ * optimisation. getWorkingPythEndpoint fetches hermes.pyth.network/live, which
+ * answers for whether Hermes is up — not for whether it still serves the
+ * caller's feeds, and not for whether the caller is even pointed at Hermes.
+ */
+export const resolvePythConnection = async (pythConnectionOverride, fallbackPythEndpoint) => {
+    if (pythConnectionOverride)
+        return pythConnectionOverride;
+    // Get a working Pyth endpoint (try primary, fallback to fallbackPythEndpoint if provided)
+    const pythEndpoint = await getWorkingPythEndpoint(fallbackPythEndpoint);
+    return new SuiPriceServiceConnection(pythEndpoint, {
+        timeout: 30 * 1000,
+    });
+};

package/package.json

@@ -1 +1 @@
-{"name":"@suilend/sdk","version":"4.0.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./client":"./client.js","./utils":"./utils/index.js","./utils/simulate":"./utils/simulate.js","./utils/obligation":"./utils/obligation.js","./utils/events":"./utils/events.js","./margin":"./margin/index.js","./lib/transactions":"./lib/transactions.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/constants":"./lib/constants.js","./lib/types":"./lib/types.js","./lib":"./lib/index.js","./lib/pyth":"./lib/pyth.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/initialize":"./lib/initialize.js","./lib/pythAdapter":"./lib/pythAdapter.js","./swap":"./swap/index.js","./swap/transaction":"./swap/transaction.js","./swap/quote":"./swap/quote.js","./parsers/reserve":"./parsers/reserve.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers":"./parsers/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers/obligation":"./parsers/obligation.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./api":"./api/index.js","./api/events":"./api/events.js","./margin/utils":"./margin/utils/index.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/version":"./margin/margin/version.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/permissions":"./margin/margin/permissions.js","./_generated/suilend":"./_generated/suilend/index.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./_generated/_dependencies/source/0x1":"./_generated/_dependencies/source/0x1/index.js","./_generated/_dependencies/source/0x2":"./_generated/_dependencies/source/0x2/index.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/index.js","./_generated/_dependencies/source/0x1/option/structs":"./_generated/_dependencies/source/0x1/option/structs.js","./_generated/_dependencies/source/0x1/ascii/structs":"./_generated/_dependencies/source/0x1/ascii/structs.js","./_generated/_dependencies/source/0x1/type-name/structs":"./_generated/_dependencies/source/0x1/type-name/structs.js","./_generated/_dependencies/source/0x2/balance/structs":"./_generated/_dependencies/source/0x2/balance/structs.js","./_generated/_dependencies/source/0x2/object/structs":"./_generated/_dependencies/source/0x2/object/structs.js","./_generated/_dependencies/source/0x2/object-table/structs":"./_generated/_dependencies/source/0x2/object-table/structs.js","./_generated/_dependencies/source/0x2/bag/structs":"./_generated/_dependencies/source/0x2/bag/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs.js"},"types":"./index.d.ts","scripts":{"build":"rm -rf ./dist && bun tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit","lint:ci":"tsc --noEmit","prettier":"prettier --write src/","release":"bun run build && bun ./release.js && cd ./dist && npm publish --access public"},"repository":{"type":"git","url":"git+https://github.com/fireflyprotocol/lending-mono.git","directory":"ts/sdks/sdk"},"dependencies":{"@bluefin-exchange/bluefin7k-aggregator-sdk":"^7.3.0","@cetusprotocol/aggregator-sdk":"^1.5.7","@flowx-finance/sdk":"^2.1.0","@pythnetwork/pyth-sui-js":"2.2.0","@suilend/springsui-sdk":"^4.0.0","bignumber.js":"^9.1.2","bn.js":"^5.2.2","crypto-js":"^4.2.0","lodash":"^4.17.21","p-limit":"3.1.0","uuid":"^11.0.3"},"devDependencies":{"@types/bn.js":"^5.2.0","@types/lodash":"^4.17.20","ts-node":"^10.9.2","typescript":"^5.6.3","@tsconfig/recommended":"^1.0.8","@types/node":"^22.9.0"},"peerDependencies":{"@mysten/bcs":"^2.0.5","@mysten/sui":"2.17.0","@suilend/sui-core":"^0.1.0"},"type":"module"}
+{"name":"@suilend/sdk","version":"5.0.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./client":"./client.js","./utils":"./utils/index.js","./utils/simulate":"./utils/simulate.js","./utils/obligation":"./utils/obligation.js","./utils/events":"./utils/events.js","./margin":"./margin/index.js","./lib/transactions":"./lib/transactions.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/constants":"./lib/constants.js","./lib/types":"./lib/types.js","./lib":"./lib/index.js","./lib/pyth":"./lib/pyth.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/initialize":"./lib/initialize.js","./lib/pythAdapter":"./lib/pythAdapter.js","./swap":"./swap/index.js","./swap/transaction":"./swap/transaction.js","./swap/quote":"./swap/quote.js","./parsers/reserve":"./parsers/reserve.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers":"./parsers/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers/obligation":"./parsers/obligation.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./api":"./api/index.js","./api/events":"./api/events.js","./margin/utils":"./margin/utils/index.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/version":"./margin/margin/version.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/permissions":"./margin/margin/permissions.js","./_generated/suilend":"./_generated/suilend/index.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./_generated/_dependencies/source/0x1":"./_generated/_dependencies/source/0x1/index.js","./_generated/_dependencies/source/0x2":"./_generated/_dependencies/source/0x2/index.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/index.js","./_generated/_dependencies/source/0x1/option/structs":"./_generated/_dependencies/source/0x1/option/structs.js","./_generated/_dependencies/source/0x1/ascii/structs":"./_generated/_dependencies/source/0x1/ascii/structs.js","./_generated/_dependencies/source/0x1/type-name/structs":"./_generated/_dependencies/source/0x1/type-name/structs.js","./_generated/_dependencies/source/0x2/balance/structs":"./_generated/_dependencies/source/0x2/balance/structs.js","./_generated/_dependencies/source/0x2/object/structs":"./_generated/_dependencies/source/0x2/object/structs.js","./_generated/_dependencies/source/0x2/object-table/structs":"./_generated/_dependencies/source/0x2/object-table/structs.js","./_generated/_dependencies/source/0x2/bag/structs":"./_generated/_dependencies/source/0x2/bag/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-identifier/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-info/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/price-feed/structs.js","./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs":"./_generated/_dependencies/source/0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e/i64/structs.js"},"types":"./index.d.ts","scripts":{"build":"rm -rf ./dist && bun tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit && tsc --noEmit -p tsconfig.test.json","test":"bun test tests/","lint:ci":"bun run typecheck","prettier":"prettier --write src/ tests/","release":"bun run build && bun ./release.js && cd ./dist && npm publish --access public"},"repository":{"type":"git","url":"git+https://github.com/fireflyprotocol/lending-mono.git","directory":"ts/sdks/sdk"},"dependencies":{"@bluefin-exchange/bluefin7k-aggregator-sdk":"^7.3.0","@cetusprotocol/aggregator-sdk":"^1.5.7","@flowx-finance/sdk":"^2.1.0","@pythnetwork/pyth-sui-js":"2.2.0","@suilend/springsui-sdk":"^4.0.0","bignumber.js":"^9.1.2","bn.js":"^5.2.2","crypto-js":"^4.2.0","lodash":"^4.17.21","p-limit":"3.1.0","uuid":"^11.0.3"},"devDependencies":{"@types/bn.js":"^5.2.0","@types/lodash":"^4.17.20","ts-node":"^10.9.2","typescript":"^6.0.3","@tsconfig/recommended":"^1.0.8","@types/node":"^22.9.0"},"peerDependencies":{"@mysten/bcs":"^2.0.5","@mysten/sui":"2.17.0","@suilend/sui-core":"^1.0.0"},"type":"module"}

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,5 +1,5 @@
 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";
@@ -118,25 +118,151 @@ export const updatePoolRewardsManager = (manager, nowMs) => {
     updatedManager.lastUpdateTimeMs = BigInt(nowMs);
     return updatedManager;
 };
+/** 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((r) => toHex(new Uint8Array(r.priceIdentifier.bytes)))));
+    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 = { ...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 = { ...userRewardManager };
     for (let i = 0; i < poolManager.poolRewards.length; i++) {