@suilend/sdk 14.2.0 → 14.2.1

package/lib/initialize.d.ts

@@ -31,7 +31,7 @@ export declare const resolveCoinMetadataForInitialize: (miscCoinTypes: string[],
     reserveCoinMetadataMap: Record<string, import("@suilend/sui-core").Token>;
     rewardCoinMetadataMap: Record<string, import("@suilend/sui-core").Token>;
 }>;
-export declare const refreshReservesForInitializeAll: (reservesByMarket: Reserve<string>[][], pythConnection: simulate.PriceFeedSource, tolerateMissingPriceFeeds?: boolean) => Promise<{
+export declare const refreshReservesForInitializeAll: (reservesByMarket: Reserve<string>[][], pythConnection: simulate.PriceFeedSource, tolerateMissingPriceFeeds?: boolean, marketVersions?: bigint[]) => Promise<{
     reserves: Reserve<string>[];
     unpricedCoinTypes: string[];
 }[]>;
@@ -42,7 +42,7 @@ export declare const refreshReservesForInitializeAll: (reservesByMarket: Reserve
  * 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: simulate.PriceFeedSource, tolerateMissingPriceFeeds?: boolean) => Promise<{
+export declare const refreshReservesForInitialize: (reserves: Reserve<string>[], pythConnection: simulate.PriceFeedSource, tolerateMissingPriceFeeds?: boolean, marketVersion?: bigint) => Promise<{
     reserves: Reserve<string>[];
     unpricedCoinTypes: string[];
 }>;

package/lib/initialize.js

@@ -162,7 +162,7 @@ export const resolveCoinMetadataForInitialize = async (miscCoinTypes, reserveCoi
     ]);
     return resolved;
 };
-export const refreshReservesForInitializeAll = async (reservesByMarket, pythConnection, tolerateMissingPriceFeeds) => {
+export const refreshReservesForInitializeAll = async (reservesByMarket, pythConnection, tolerateMissingPriceFeeds, marketVersions) => {
     const allReserves = reservesByMarket.flat();
     if (tolerateMissingPriceFeeds) {
         // Tolerance is only expressible over a connection that can report WHICH
@@ -184,13 +184,13 @@ export const refreshReservesForInitializeAll = async (reservesByMarket, pythConn
             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 a client prototype does NOT satisfy this: it can reroute getLatestPriceFeeds but cannot add a per-feed gap report.`);
         }
         const priceFeeds = await simulate.fetchReservePriceFeedsTolerant(allReserves, pythConnection);
-        return reservesByMarket.map((reserves) => simulate.applyReservePriceFeedsTolerant(reserves, priceFeeds));
+        return reservesByMarket.map((reserves, i) => simulate.applyReservePriceFeedsTolerant(reserves, priceFeeds, marketVersions?.[i]));
     }
     // Default path, behaviourally identical to what this function did before the
     // flag existed: throws if any requested feed is absent from the response.
     const priceFeeds = await pythConnection.getLatestPriceFeeds(simulate.reservePriceFeedIds(allReserves));
-    return reservesByMarket.map((reserves) => ({
-        reserves: simulate.applyReservePriceFeeds(reserves, priceFeeds),
+    return reservesByMarket.map((reserves, i) => ({
+        reserves: simulate.applyReservePriceFeeds(reserves, priceFeeds, marketVersions?.[i]),
         unpricedCoinTypes: [],
     }));
 };
@@ -201,8 +201,8 @@ export const refreshReservesForInitializeAll = async (reservesByMarket, pythConn
  * 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) => {
-    const [refreshed] = await refreshReservesForInitializeAll([reserves], pythConnection, tolerateMissingPriceFeeds);
+export const refreshReservesForInitialize = async (reserves, pythConnection, tolerateMissingPriceFeeds, marketVersion) => {
+    const [refreshed] = await refreshReservesForInitializeAll([reserves], pythConnection, tolerateMissingPriceFeeds, marketVersion === undefined ? undefined : [marketVersion]);
     return refreshed;
 };
 /**
@@ -360,7 +360,7 @@ const initializeSuilendMarkets = async (suiGrpcClient, markets, fallbackPythEndp
     const reservelessActiveRewardCoinTypesByMarket = coinTypesByMarket.map(reservelessActiveRewardCoinTypes);
     const [[refreshedWithoutTemporaryByMarket, fabricatedPriceCoinTypesByMarket], coinMetadataByMarket, rewardUsdPrices, kBpsByMarket,] = await Promise.all([
         Promise.all([
-            resolvePythConnection(options?.pythConnection, fallbackPythEndpoint, options?.pythConnectionConfig).then((pythConnection) => refreshReservesForInitializeAll(reservesByMarket.map((r) => r.withoutTemporaryPythPriceFeeds), pythConnection, options?.tolerateMissingPriceFeeds)),
+            resolvePythConnection(options?.pythConnection, fallbackPythEndpoint, options?.pythConnectionConfig).then((pythConnection) => refreshReservesForInitializeAll(reservesByMarket.map((r) => r.withoutTemporaryPythPriceFeeds), pythConnection, options?.tolerateMissingPriceFeeds, markets.map(({ suilendClient }) => suilendClient.lendingMarket.version))),
             priceTemporaryPythFeedReservesAll(reservesByMarket.map((r) => r.withTemporaryPythPriceFeeds), fetchPrices),
         ]),
         resolveCoinMetadataForInitializeAll(coinTypesByMarket.map(({ uniqueMiscCoinTypes, uniqueReserveCoinTypes, uniqueRewardCoinTypes, }) => ({

package/package.json

@@ -1 +1 @@
-{"name":"@suilend/sdk","version":"14.2.0","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./client":"./client.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./api/events":"./api/events.js","./api":"./api/index.js","./lib/constants":"./lib/constants.js","./lib":"./lib/index.js","./lib/initialize":"./lib/initialize.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/proCompatible":"./lib/proCompatible.js","./lib/pyth":"./lib/pyth.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/transactions":"./lib/transactions.js","./lib/types":"./lib/types.js","./margin":"./margin/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers":"./parsers/index.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./parsers/obligation":"./parsers/obligation.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers/reserve":"./parsers/reserve.js","./swap":"./swap/index.js","./swap/quote":"./swap/quote.js","./swap/transaction":"./swap/transaction.js","./utils/events":"./utils/events.js","./utils/feedId":"./utils/feedId.js","./utils":"./utils/index.js","./utils/interpolate":"./utils/interpolate.js","./utils/obligation":"./utils/obligation.js","./utils/priceGuard":"./utils/priceGuard.js","./utils/simulate":"./utils/simulate.js","./_generated/_envs":"./_generated/_envs/index.js","./_generated/_envs/mainnet":"./_generated/_envs/mainnet.js","./_generated/_framework/env":"./_generated/_framework/env.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend":"./_generated/suilend/index.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/permissions":"./margin/margin/permissions.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/version":"./margin/margin/version.js","./margin/utils":"./margin/utils/index.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/_dependencies/pyth-2/price-identifier/structs":"./_generated/_dependencies/pyth-2/price-identifier/structs.js","./_generated/_dependencies/std/ascii/structs":"./_generated/_dependencies/std/ascii/structs.js","./_generated/_dependencies/std/option/structs":"./_generated/_dependencies/std/option/structs.js","./_generated/_dependencies/std/type-name/structs":"./_generated/_dependencies/std/type-name/structs.js","./_generated/_dependencies/sui/bag/structs":"./_generated/_dependencies/sui/bag/structs.js","./_generated/_dependencies/sui/balance/structs":"./_generated/_dependencies/sui/balance/structs.js","./_generated/_dependencies/sui/object/structs":"./_generated/_dependencies/sui/object/structs.js","./_generated/_dependencies/sui/object-table/structs":"./_generated/_dependencies/sui/object-table/structs.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js"},"types":"./index.d.ts","scripts":{"codegen":"node ./codegen.js","codegen:install":"node ./install-codegen.js","build":"rm -rf ./dist && tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit && tsc --noEmit -p tsconfig.test.json","test":"vitest run","lint:ci":"yarn run typecheck","prettier":"prettier --write src/ tests/","release":"yarn run build && node ./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":{"@cetusprotocol/aggregator-sdk":"1.7.3","@flowx-finance/sdk":"2.1.0","@pythnetwork/hermes-client":"3.1.0","@pythnetwork/pyth-sui-js":"4.0.0","@suilend/springsui-sdk":"4.1.0","bignumber.js":"11.1.5","bn.js":"5.2.5","crypto-js":"4.2.0","lodash":"4.18.1","p-limit":"7.3.3","uuid":"14.0.2"},"devDependencies":{"@mysten/bcs":"2.1.2","@mysten/sui":"2.35.0","@suilend/sui-core":"2.2.0","@tsconfig/recommended":"1.0.13","@types/bn.js":"5.2.0","@types/lodash":"4.17.26","@types/node":"26.6.5","fast-check":"4.10.2","prettier":"3.9.10","ts-node":"10.9.2","typescript":"6.0.3","vite":"8.3.4","vitest":"5.0.4"},"peerDependencies":{"@mysten/bcs":"^2.1.1","@mysten/sui":">=2.31.3 <3","@suilend/sui-core":"^2.0.1"},"type":"module"}
+{"name":"@suilend/sdk","version":"14.2.1","private":false,"description":"A TypeScript SDK for interacting with the Suilend program","author":"Suilend","license":"MIT","main":"./index.js","exports":{".":"./index.js","./client":"./client.js","./mmt":"./mmt.js","./strategies":"./strategies.js","./api/events":"./api/events.js","./api":"./api/index.js","./lib/constants":"./lib/constants.js","./lib":"./lib/index.js","./lib/initialize":"./lib/initialize.js","./lib/liquidityMining":"./lib/liquidityMining.js","./lib/proCompatible":"./lib/proCompatible.js","./lib/pyth":"./lib/pyth.js","./lib/strategyOwnerCap":"./lib/strategyOwnerCap.js","./lib/transactions":"./lib/transactions.js","./lib/types":"./lib/types.js","./margin":"./margin/index.js","./parsers/apiReserveAssetDataEvent":"./parsers/apiReserveAssetDataEvent.js","./parsers":"./parsers/index.js","./parsers/lendingMarket":"./parsers/lendingMarket.js","./parsers/obligation":"./parsers/obligation.js","./parsers/rateLimiter":"./parsers/rateLimiter.js","./parsers/reserve":"./parsers/reserve.js","./swap":"./swap/index.js","./swap/quote":"./swap/quote.js","./swap/transaction":"./swap/transaction.js","./utils/events":"./utils/events.js","./utils/feedId":"./utils/feedId.js","./utils":"./utils/index.js","./utils/interpolate":"./utils/interpolate.js","./utils/obligation":"./utils/obligation.js","./utils/priceGuard":"./utils/priceGuard.js","./utils/simulate":"./utils/simulate.js","./_generated/_envs":"./_generated/_envs/index.js","./_generated/_envs/mainnet":"./_generated/_envs/mainnet.js","./_generated/_framework/env":"./_generated/_framework/env.js","./_generated/_framework/reified":"./_generated/_framework/reified.js","./_generated/_framework/util":"./_generated/_framework/util.js","./_generated/_framework/vector":"./_generated/_framework/vector.js","./_generated/suilend":"./_generated/suilend/index.js","./margin/margin/admin_cap":"./margin/margin/admin_cap.js","./margin/margin/market":"./margin/margin/market.js","./margin/margin/permissions":"./margin/margin/permissions.js","./margin/margin/position":"./margin/margin/position.js","./margin/margin/router":"./margin/margin/router.js","./margin/margin/version":"./margin/margin/version.js","./margin/utils":"./margin/utils/index.js","./_generated/suilend/cell/structs":"./_generated/suilend/cell/structs.js","./_generated/suilend/decimal/structs":"./_generated/suilend/decimal/structs.js","./_generated/suilend/lending-market/functions":"./_generated/suilend/lending-market/functions.js","./_generated/suilend/lending-market/structs":"./_generated/suilend/lending-market/structs.js","./_generated/suilend/lending-market-registry/functions":"./_generated/suilend/lending-market-registry/functions.js","./_generated/suilend/liquidity-mining/structs":"./_generated/suilend/liquidity-mining/structs.js","./_generated/suilend/obligation/structs":"./_generated/suilend/obligation/structs.js","./_generated/suilend/rate-limiter/functions":"./_generated/suilend/rate-limiter/functions.js","./_generated/suilend/rate-limiter/structs":"./_generated/suilend/rate-limiter/structs.js","./_generated/suilend/reserve/structs":"./_generated/suilend/reserve/structs.js","./_generated/suilend/reserve-config/functions":"./_generated/suilend/reserve-config/functions.js","./_generated/suilend/reserve-config/structs":"./_generated/suilend/reserve-config/structs.js","./_generated/_dependencies/pyth-2/price-identifier/structs":"./_generated/_dependencies/pyth-2/price-identifier/structs.js","./_generated/_dependencies/std/ascii/structs":"./_generated/_dependencies/std/ascii/structs.js","./_generated/_dependencies/std/option/structs":"./_generated/_dependencies/std/option/structs.js","./_generated/_dependencies/std/type-name/structs":"./_generated/_dependencies/std/type-name/structs.js","./_generated/_dependencies/sui/bag/structs":"./_generated/_dependencies/sui/bag/structs.js","./_generated/_dependencies/sui/balance/structs":"./_generated/_dependencies/sui/balance/structs.js","./_generated/_dependencies/sui/object/structs":"./_generated/_dependencies/sui/object/structs.js","./_generated/_dependencies/sui/object-table/structs":"./_generated/_dependencies/sui/object-table/structs.js","./margin/margin/deps/std/type_name":"./margin/margin/deps/std/type_name.js","./margin/margin/deps/sui/vec_set":"./margin/margin/deps/sui/vec_set.js","./margin/margin/deps/suilend/lending_market":"./margin/margin/deps/suilend/lending_market.js"},"types":"./index.d.ts","scripts":{"codegen":"node ./codegen.js","codegen:install":"node ./install-codegen.js","build":"rm -rf ./dist && tsc && node ./fix-esm-imports.js","typecheck":"tsc --noEmit && tsc --noEmit -p tsconfig.test.json","test":"vitest run","lint:ci":"yarn run typecheck","prettier":"prettier --write src/ tests/","release":"yarn run build && node ./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":{"@cetusprotocol/aggregator-sdk":"1.7.5","@flowx-finance/sdk":"2.1.0","@pythnetwork/hermes-client":"3.1.0","@pythnetwork/pyth-sui-js":"4.0.0","@suilend/springsui-sdk":"4.1.0","bignumber.js":"11.1.5","bn.js":"5.2.5","crypto-js":"4.2.0","lodash":"4.18.1","p-limit":"7.3.3","uuid":"14.0.3"},"devDependencies":{"@mysten/bcs":"2.1.3","@mysten/sui":"2.37.0","@suilend/sui-core":"2.2.0","@tsconfig/recommended":"1.0.13","@types/bn.js":"5.2.0","@types/lodash":"4.17.27","@types/node":"26.6.5","fast-check":"4.10.2","prettier":"3.9.10","ts-node":"10.9.2","typescript":"6.0.3","vite":"8.3.5","vitest":"5.0.5"},"peerDependencies":{"@mysten/bcs":"^2.1.1","@mysten/sui":">=2.31.3 <3","@suilend/sui-core":"^2.0.1"},"type":"module"}

package/strategies.js

@@ -274,6 +274,37 @@ export const getStrategySuiReserve = (
 // AppContext
 reserveMap) => reserveMap[NORMALIZED_SUI_COINTYPE] ??
     { price: new BigNumber(1) };
+const getStrategyDepositUnitValueUsd = (reserveMap, lstMap, coinType) => {
+    const suiPrice = getStrategySuiReserve(reserveMap).price;
+    const lstToSuiExchangeRate = lstMap[coinType]?.lstToSuiExchangeRate;
+    if (isSui(coinType))
+        return suiPrice;
+    if (lstToSuiExchangeRate !== undefined)
+        return new BigNumber(lstToSuiExchangeRate).times(suiPrice);
+    return reserveMap[coinType].price;
+};
+const getStrategyExtraDeposits = (reserveMap, lstMap, strategyType, deposits) => {
+    const { depositBaseCoinType, depositLstCoinType } = STRATEGY_TYPE_INFO_MAP[strategyType];
+    const getValueUsd = (deposit) => deposit.depositedAmount.times(getStrategyDepositUnitValueUsd(reserveMap, lstMap, deposit.coinType));
+    return deposits
+        .filter((deposit) => {
+        const reserve = reserveMap[deposit.coinType];
+        return (deposit.coinType !== depositBaseCoinType &&
+            deposit.coinType !== depositLstCoinType &&
+            reserve !== undefined &&
+            deposit.depositedAmount
+                .decimalPlaces(reserve.token.decimals, BigNumber.ROUND_DOWN)
+                .gt(0));
+    })
+        .sort((a, b) => getValueUsd(b).comparedTo(getValueUsd(a)) ?? 0);
+};
+const getStrategyWithdrawnCtokenAmount = (reserve, amount) => BigInt(new BigNumber(amount
+    .times(10 ** reserve.token.decimals)
+    .integerValue(BigNumber.ROUND_DOWN)
+    .toString())
+    .div(reserve.cTokenExchangeRate)
+    .integerValue(BigNumber.ROUND_UP)
+    .toString());
 export const fetchStrategyLstMap = async (suiGrpcClient) => {
     try {
         const lstCoinTypes = Array.from(new Set([
@@ -1310,6 +1341,87 @@ dryRunTransaction) => {
     }));
     if (borrowedAmount.eq(targetBorrowedAmount))
         return { deposits, borrowedAmount, transaction };
+    const repayBorrowsUsingExtraDeposits = async () => {
+        const skippedCoinTypes = new Set();
+        for (let i = 0; i < 30; i++) {
+            const pendingBorrowedAmount = borrowedAmount.minus(targetBorrowedAmount);
+            if (pendingBorrowedAmount.lte(STRATEGY_E))
+                return false;
+            const extraDeposit = getStrategyExtraDeposits(reserveMap, lstMap, strategyType, deposits).find((deposit) => !skippedCoinTypes.has(deposit.coinType));
+            if (extraDeposit === undefined)
+                return false;
+            const extraReserve = reserveMap[extraDeposit.coinType];
+            const extraToBorrowExchangeRate = extraReserve.minPrice.div(borrowReserve.maxPrice);
+            const stepMaxWithdrawnAmount = getStrategyStepMaxWithdrawnAmount(reserveMap, lstMap, strategyType, deposits, borrowedAmount, extraReserve.coinType, 0.9);
+            const stepMaxRepaidAmount = stepMaxWithdrawnAmount
+                .times(extraToBorrowExchangeRate)
+                .decimalPlaces(borrowReserve.token.decimals, BigNumber.ROUND_DOWN);
+            const stepTargetRepaidAmount = pendingBorrowedAmount.div(1 - SWAP_MAX_DEVIATION_PERCENT / 100);
+            const isFinalStep = stepTargetRepaidAmount.lte(stepMaxRepaidAmount);
+            const stepWithdrawnAmount = BigNumber.min(stepTargetRepaidAmount, stepMaxRepaidAmount)
+                .div(extraToBorrowExchangeRate)
+                .decimalPlaces(extraReserve.token.decimals, BigNumber.ROUND_DOWN);
+            console.log(`[unloopStrategyToExposure] ${i} repay_using_extra_deposit |`, JSON.stringify({
+                coinType: extraReserve.coinType,
+                pendingBorrowedAmount: pendingBorrowedAmount.toFixed(20),
+                stepMaxWithdrawnAmount: stepMaxWithdrawnAmount.toFixed(20),
+                stepWithdrawnAmount: stepWithdrawnAmount.toFixed(20),
+                isFinalStep,
+            }, null, 2));
+            if (!extraToBorrowExchangeRate.gt(0) || !stepWithdrawnAmount.gt(0)) {
+                skippedCoinTypes.add(extraReserve.coinType);
+                continue;
+            }
+            const transactionBeforeStep = Transaction.from(transaction);
+            const depositsBeforeStep = cloneDeep(deposits);
+            try {
+                const [stepWithdrawnCoin] = strategyWithdraw(strategyType, extraReserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(extraReserve.coinType), getStrategyWithdrawnCtokenAmount(extraReserve, stepWithdrawnAmount), transaction);
+                deposits = addOrInsertStrategyDeposit(deposits, {
+                    coinType: extraReserve.coinType,
+                    depositedAmount: stepWithdrawnAmount.times(-1),
+                });
+                const routers = await cetusSdk.findRouters({
+                    from: extraReserve.coinType,
+                    target: borrowReserve.coinType,
+                    amount: new BN(stepWithdrawnAmount
+                        .times(10 ** extraReserve.token.decimals)
+                        .integerValue(BigNumber.ROUND_DOWN)
+                        .toString()),
+                    byAmountIn: true,
+                    splitCount: 0,
+                });
+                if (!routers)
+                    throw new Error("No swap quote found");
+                const { slippagePercent, guaranteedAmountOut } = resolveSwapSlippage(stepWithdrawnAmount, new BigNumber(routers.amountOut.toString()).div(10 ** borrowReserve.token.decimals), extraReserve, borrowReserve);
+                const stepBorrowCoin = (await cetusSdk.fixableRouterSwapV3({
+                    router: routers,
+                    inputCoin: stepWithdrawnCoin,
+                    slippage: slippagePercent / 100,
+                    txb: transaction,
+                    partner: cetusPartnerId,
+                }));
+                const txCopy = Transaction.from(transaction);
+                suilendClient.repay(obligationId, borrowReserve.coinType, stepBorrowCoin, txCopy);
+                txCopy.transferObjects([stepBorrowCoin], _address);
+                await dryRunTransaction(txCopy);
+                transaction = txCopy;
+                if (isFinalStep) {
+                    borrowedAmount = targetBorrowedAmount;
+                    return true;
+                }
+                borrowedAmount = borrowedAmount.minus(guaranteedAmountOut.decimalPlaces(borrowReserve.token.decimals, BigNumber.ROUND_DOWN));
+            }
+            catch (err) {
+                console.error(err);
+                transaction = transactionBeforeStep;
+                deposits = depositsBeforeStep;
+                skippedCoinTypes.add(extraReserve.coinType);
+            }
+        }
+        return false;
+    };
+    if (await repayBorrowsUsingExtraDeposits())
+        return { deposits, borrowedAmount, transaction };
     const fullyRepayBorrowsUsingLst = async (maxWithdrawRemainingLstAndRedepositAsBase) => {
         if (depositReserves.lst === undefined)
             throw new Error("LST reserve not found");
@@ -2288,6 +2400,100 @@ const sendStrategyWithdrawnCoin = async (transaction, coin, estimatedAmount, add
 const getRedeemedSuiAmount = (lstAmount, lst) => lstAmount
     .times(new BigNumber(lst?.lstToSuiExchangeRate ?? 1).times(1 - +(lst?.redeemFeePercent ?? 0) / 100))
     .decimalPlaces(SUI_DECIMALS, BigNumber.ROUND_DOWN);
+const swapStrategyWithdrawnCoin = async (cetusSdk, cetusPartnerId, transaction, coin, amount, fromReserve, toReserve) => {
+    const swapTransaction = Transaction.from(transaction);
+    try {
+        const routers = await cetusSdk.findRouters({
+            from: fromReserve.coinType,
+            target: toReserve.coinType,
+            amount: new BN(amount
+                .times(10 ** fromReserve.token.decimals)
+                .integerValue(BigNumber.ROUND_DOWN)
+                .toString()),
+            byAmountIn: true,
+            splitCount: 0,
+        });
+        if (!routers)
+            return undefined;
+        const swappedAmount = new BigNumber(routers.amountOut.toString()).div(10 ** toReserve.token.decimals);
+        const { slippagePercent } = resolveSwapSlippage(amount, swappedAmount, fromReserve, toReserve);
+        const swappedCoin = (await cetusSdk.fixableRouterSwapV3({
+            router: routers,
+            inputCoin: coin,
+            slippage: slippagePercent / 100,
+            txb: swapTransaction,
+            partner: cetusPartnerId,
+        }));
+        return {
+            transaction: swapTransaction,
+            withdrawnCoin: { coin: swappedCoin, estimatedAmount: swappedAmount },
+        };
+    }
+    catch (err) {
+        console.error(err);
+        return undefined;
+    }
+};
+const withdrawStrategyExtraDepositsTx = async (strategyType, suilendClient, cetusSdk, cetusPartnerId, address, strategyOwnerCapId, extraWithdrawals, withdrawReserve, withdrawnCoin, transaction, dryRunTransaction) => {
+    if (extraWithdrawals.length === 0)
+        return { transaction, withdrawnCoin, isWithdrawn: false };
+    console.log(`[strategyWithdraw] extra_deposits |`, JSON.stringify(extraWithdrawals.map(({ reserve, amount, isMax }) => ({
+        coinType: reserve.coinType,
+        amount: amount.toFixed(20),
+        isMax,
+    })), null, 2));
+    const build = async (swap) => {
+        let extraTransaction = Transaction.from(transaction);
+        const coins = withdrawnCoin !== undefined ? [withdrawnCoin] : [];
+        for (const { reserve, amount, isMax } of extraWithdrawals) {
+            const [coin] = strategyWithdraw(strategyType, reserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(reserve.coinType), isMax
+                ? BigInt(MAX_U64.toString())
+                : getStrategyWithdrawnCtokenAmount(reserve, amount), extraTransaction);
+            if (reserve.coinType === withdrawReserve.coinType) {
+                coins.push({ coin, estimatedAmount: amount });
+                continue;
+            }
+            const swapped = swap
+                ? await swapStrategyWithdrawnCoin(cetusSdk, cetusPartnerId, extraTransaction, coin, amount, reserve, withdrawReserve)
+                : undefined;
+            if (swapped === undefined) {
+                extraTransaction.transferObjects([coin], address);
+                continue;
+            }
+            extraTransaction = swapped.transaction;
+            coins.push(swapped.withdrawnCoin);
+        }
+        const [mergedCoin, ...otherCoins] = coins;
+        if (mergedCoin !== undefined && otherCoins.length > 0)
+            extraTransaction.mergeCoins(mergedCoin.coin, otherCoins.map(({ coin }) => coin));
+        return {
+            transaction: extraTransaction,
+            withdrawnCoin: mergedCoin === undefined
+                ? undefined
+                : {
+                    coin: mergedCoin.coin,
+                    estimatedAmount: coins.reduce((acc, { estimatedAmount }) => acc.plus(estimatedAmount), new BigNumber(0)),
+                },
+        };
+    };
+    const needsSwap = extraWithdrawals.some(({ reserve }) => reserve.coinType !== withdrawReserve.coinType);
+    let error;
+    for (const swap of needsSwap ? [true, false] : [false]) {
+        try {
+            const built = await build(swap);
+            const probe = Transaction.from(built.transaction);
+            if (built.withdrawnCoin !== undefined)
+                probe.transferObjects([built.withdrawnCoin.coin], address);
+            await dryRunTransaction(probe);
+            return { ...built, isWithdrawn: true };
+        }
+        catch (err) {
+            console.error(err);
+            error = err;
+        }
+    }
+    return { transaction, withdrawnCoin, isWithdrawn: false, error };
+};
 const tryClaimStrategyRewardsToUser = async (strategyType, rewardsMap, strategyOwnerCapId, address, transaction, dryRunTransaction) => {
     const transactionBeforeClaim = Transaction.from(transaction);
     try {
@@ -2400,18 +2606,51 @@ lstMap, strategyType, suiGrpcClient, suilendClient, cetusSdk, cetusPartnerId, _a
         remainingDepositedAmount: remainingDepositedAmount.toFixed(20),
         finalWithdrawnAmount: finalWithdrawnAmount.toFixed(20),
     }, null, 2));
-    const [withdrawnCoin] = strategyWithdraw(strategyType, depositReserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(depositReserve.coinType), BigInt(new BigNumber(finalWithdrawnAmount
-        .times(10 ** depositReserve.token.decimals)
-        .integerValue(BigNumber.ROUND_DOWN)
-        .toString())
-        .div(depositReserve.cTokenExchangeRate)
-        .integerValue(BigNumber.ROUND_UP)
-        .toString()), transaction);
-    // 2.2) Update state
-    deposits = addOrInsertStrategyDeposit(deposits, {
-        coinType: depositReserve.coinType,
-        depositedAmount: finalWithdrawnAmount.times(-1),
-    });
+    const finalWithdrawnCtokenAmount = getStrategyWithdrawnCtokenAmount(depositReserve, finalWithdrawnAmount);
+    let withdrawnCoin;
+    if (finalWithdrawnCtokenAmount > BigInt(0)) {
+        [withdrawnCoin] = strategyWithdraw(strategyType, depositReserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(depositReserve.coinType), finalWithdrawnCtokenAmount, transaction);
+        // 2.2) Update state
+        deposits = addOrInsertStrategyDeposit(deposits, {
+            coinType: depositReserve.coinType,
+            depositedAmount: finalWithdrawnAmount.times(-1),
+        });
+    }
+    const extraWithdrawals = [];
+    if (!returnWithdrawnCoin) {
+        let shortfallUsd = withdrawnAmount.gt(0)
+            ? withdrawnAmountUsd
+                .times(withdrawnAmount.minus(finalWithdrawnAmount))
+                .div(withdrawnAmount)
+            : new BigNumber(0);
+        let remainingDeposits = deposits;
+        for (const extraDeposit of getStrategyExtraDeposits(reserveMap, lstMap, strategyType, deposits)) {
+            if (!shortfallUsd.gt(0))
+                break;
+            const reserve = reserveMap[extraDeposit.coinType];
+            const unitValueUsd = getStrategyDepositUnitValueUsd(reserveMap, lstMap, reserve.coinType);
+            if (!unitValueUsd.gt(0))
+                continue;
+            const amount = BigNumber.min(shortfallUsd
+                .div(unitValueUsd)
+                .decimalPlaces(reserve.token.decimals, BigNumber.ROUND_UP), getStrategyStepMaxWithdrawnAmount(reserveMap, lstMap, strategyType, remainingDeposits, borrowedAmount, reserve.coinType, borrowedAmount.gt(0) ? 0.9 : 1));
+            if (!amount.gt(0))
+                continue;
+            extraWithdrawals.push({
+                reserve,
+                amount,
+                isMax: borrowedAmount.lte(0) &&
+                    amount.gte(extraDeposit.depositedAmount.decimalPlaces(reserve.token.decimals, BigNumber.ROUND_DOWN)),
+            });
+            remainingDeposits = addOrInsertStrategyDeposit(remainingDeposits, {
+                coinType: reserve.coinType,
+                depositedAmount: amount.times(-1),
+            });
+            shortfallUsd = shortfallUsd.minus(amount.times(unitValueUsd));
+        }
+    }
+    if (withdrawnCoin === undefined && extraWithdrawals.length === 0)
+        throw new Error("Nothing left to withdraw");
     const newExposure = getStrategyExposure(reserveMap, lstMap, strategyType, getStrategySimulatedObligation(reserveMap, lstMap, strategyType, deposits, borrowedAmount));
     const newTvlAmountUsd = getStrategyTvlAmount(reserveMap, lstMap, strategyType, getStrategySimulatedObligation(reserveMap, lstMap, strategyType, deposits, borrowedAmount)).times(defaultCurrencyReserve.price);
     console.log(`[withdraw] withdraw.update_state |`, JSON.stringify({
@@ -2430,7 +2669,8 @@ lstMap, strategyType, suiGrpcClient, suilendClient, cetusSdk, cetusPartnerId, _a
     const sendWithdrawnCoin = (coin, estimatedAmount) => sendStrategyWithdrawnCoin(transaction, coin, estimatedAmount, _address, consumeWithdrawnCoin, dryRunTransaction);
     if (returnWithdrawnCoin)
         return { deposits, borrowedAmount, transaction, withdrawnCoin };
-    else {
+    let finalWithdrawnCoin;
+    if (withdrawnCoin !== undefined) {
         if (depositReserve.coinType === depositReserves.base?.coinType) {
             if (withdraw.coinType !== depositReserve.coinType) {
                 const routers = await cetusSdk.findRouters({
@@ -2460,25 +2700,47 @@ lstMap, strategyType, suiGrpcClient, suilendClient, cetusSdk, cetusPartnerId, _a
                 catch (err) {
                     throw new Error("No swap quote found");
                 }
-                await sendWithdrawnCoin(swappedCoin, swappedAmount);
+                finalWithdrawnCoin = {
+                    coin: swappedCoin,
+                    estimatedAmount: swappedAmount,
+                };
             }
             else {
-                await sendWithdrawnCoin(withdrawnCoin, finalWithdrawnAmount);
+                finalWithdrawnCoin = {
+                    coin: withdrawnCoin,
+                    estimatedAmount: finalWithdrawnAmount,
+                };
             }
         }
         else {
             if (isSui(withdraw.coinType)) {
                 // 3.1) Unstake LST for SUI
                 const suiWithdrawnCoin = lst.client.redeem(transaction, withdrawnCoin);
-                // 3.2) Transfer SUI to user
-                await sendWithdrawnCoin(suiWithdrawnCoin, getRedeemedSuiAmount(finalWithdrawnAmount, lst));
+                finalWithdrawnCoin = {
+                    coin: suiWithdrawnCoin,
+                    estimatedAmount: getRedeemedSuiAmount(finalWithdrawnAmount, lst),
+                };
             }
             else {
-                // 3.1) Transfer LST to user
-                await sendWithdrawnCoin(withdrawnCoin, finalWithdrawnAmount);
+                finalWithdrawnCoin = {
+                    coin: withdrawnCoin,
+                    estimatedAmount: finalWithdrawnAmount,
+                };
             }
         }
     }
+    const extras = await withdrawStrategyExtraDepositsTx(strategyType, suilendClient, cetusSdk, cetusPartnerId, _address, strategyOwnerCapId, extraWithdrawals, reserveMap[withdraw.coinType], finalWithdrawnCoin, transaction, dryRunTransaction);
+    if (extras.withdrawnCoin === undefined && !extras.isWithdrawn)
+        throw extras.error ?? new Error("Nothing left to withdraw");
+    transaction = extras.transaction;
+    if (extras.isWithdrawn)
+        for (const { reserve, amount } of extraWithdrawals)
+            deposits = addOrInsertStrategyDeposit(deposits, {
+                coinType: reserve.coinType,
+                depositedAmount: amount.times(-1),
+            });
+    if (extras.withdrawnCoin !== undefined)
+        await sendWithdrawnCoin(extras.withdrawnCoin.coin, extras.withdrawnCoin.estimatedAmount);
     if (hasStrategyRewardsToClaim(rewardsMap) &&
         isStrategyPositionClosed(reserveMap, deposits))
         transaction = await tryClaimStrategyRewardsToUser(strategyType, rewardsMap, strategyOwnerCapId, _address, transaction, dryRunTransaction);
@@ -2639,7 +2901,14 @@ lstMap, strategyType, suiGrpcClient, suilendClient, cetusSdk, cetusPartnerId, _a
     }
     const estimatedWithdrawnAmount = deposits.find((d) => d.coinType === depositReserve.coinType)
         ?.depositedAmount ?? new BigNumber(0);
-    const [withdrawnCoin] = strategyWithdraw(strategyType, depositReserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(depositReserve.coinType), BigInt(MAX_U64.toString()), transaction);
+    const extraDeposits = getStrategyExtraDeposits(reserveMap, lstMap, strategyType, deposits);
+    const withdrawsDepositReserve = _borrowedAmount.gt(0) ||
+        deposits.some((d) => d.coinType === depositReserve.coinType);
+    if (!withdrawsDepositReserve && extraDeposits.length === 0)
+        throw new Error("Nothing left to withdraw");
+    let withdrawnCoin;
+    if (withdrawsDepositReserve)
+        [withdrawnCoin] = strategyWithdraw(strategyType, depositReserve.coinType, strategyOwnerCapId, suilendClient.findReserveArrayIndex(depositReserve.coinType), BigInt(MAX_U64.toString()), transaction);
     // 2.2) Update state
     deposits = [];
     console.log(`[strategyMaxWithdraw] max_withdraw.update_state |`, JSON.stringify({
@@ -2651,81 +2920,107 @@ lstMap, strategyType, suiGrpcClient, suilendClient, cetusSdk, cetusPartnerId, _a
     }, null, 2));
     const sendWithdrawnCoin = (coin, estimatedAmount) => sendStrategyWithdrawnCoin(transaction, coin, estimatedAmount, _address, consumeWithdrawnCoin, dryRunTransaction);
     // 3) Transfer coin to user
-    if (depositReserve.coinType === depositReserves.base?.coinType) {
-        if (withdrawCoinType !== depositReserve.coinType) {
-            const routers = await cetusSdk.findRouters({
-                from: depositReserve.coinType,
-                target: withdrawCoinType,
-                amount: new BN(estimatedWithdrawnAmount
-                    .times(10 ** depositReserve.token.decimals)
-                    .integerValue(BigNumber.ROUND_DOWN)
-                    .toString()),
-                byAmountIn: true,
-                splitCount: 0,
-            });
-            if (!routers)
-                throw new Error("No swap quote found");
-            const swappedAmount = new BigNumber(routers.amountOut.toString()).div(10 ** reserveMap[withdrawCoinType].token.decimals);
-            const { slippagePercent } = resolveSwapSlippage(estimatedWithdrawnAmount, swappedAmount, depositReserve, reserveMap[withdrawCoinType]);
-            let swappedCoin;
-            try {
-                swappedCoin = (await cetusSdk.fixableRouterSwapV3({
-                    router: routers,
-                    inputCoin: withdrawnCoin,
-                    slippage: slippagePercent / 100,
-                    txb: transaction,
-                    partner: cetusPartnerId,
-                }));
+    let finalWithdrawnCoin;
+    if (withdrawnCoin !== undefined) {
+        if (depositReserve.coinType === depositReserves.base?.coinType) {
+            if (withdrawCoinType !== depositReserve.coinType) {
+                const routers = await cetusSdk.findRouters({
+                    from: depositReserve.coinType,
+                    target: withdrawCoinType,
+                    amount: new BN(estimatedWithdrawnAmount
+                        .times(10 ** depositReserve.token.decimals)
+                        .integerValue(BigNumber.ROUND_DOWN)
+                        .toString()),
+                    byAmountIn: true,
+                    splitCount: 0,
+                });
+                if (!routers)
+                    throw new Error("No swap quote found");
+                const swappedAmount = new BigNumber(routers.amountOut.toString()).div(10 ** reserveMap[withdrawCoinType].token.decimals);
+                const { slippagePercent } = resolveSwapSlippage(estimatedWithdrawnAmount, swappedAmount, depositReserve, reserveMap[withdrawCoinType]);
+                let swappedCoin;
+                try {
+                    swappedCoin = (await cetusSdk.fixableRouterSwapV3({
+                        router: routers,
+                        inputCoin: withdrawnCoin,
+                        slippage: slippagePercent / 100,
+                        txb: transaction,
+                        partner: cetusPartnerId,
+                    }));
+                }
+                catch (err) {
+                    throw new Error("No swap quote found");
+                }
+                finalWithdrawnCoin = {
+                    coin: swappedCoin,
+                    estimatedAmount: swappedAmount,
+                };
             }
-            catch (err) {
-                throw new Error("No swap quote found");
+            else {
+                finalWithdrawnCoin = {
+                    coin: withdrawnCoin,
+                    estimatedAmount: estimatedWithdrawnAmount,
+                };
             }
-            await sendWithdrawnCoin(swappedCoin, swappedAmount);
         }
         else {
-            await sendWithdrawnCoin(withdrawnCoin, estimatedWithdrawnAmount);
-        }
-    }
-    else {
-        if (isSui(withdrawCoinType)) {
-            // 3.1) Unstake LST for SUI
-            const suiWithdrawnCoin = lst.client.redeem(transaction, withdrawnCoin);
-            // 3.2) Repay flash loan + fee
-            if (flashLoan !== undefined) {
-                transaction.mergeCoins(suiWithdrawnCoin, [flashLoan.remainingCoin]);
-                const receiptDebts = transaction.moveCall({
-                    target: `${MMT_CONTRACT_PACKAGE_ID}::trade::flash_receipt_debts`,
-                    typeArguments: [],
-                    arguments: [flashLoan.receipt],
-                });
-                const [flashLoanRepayCoin] = transaction.splitCoins(suiWithdrawnCoin, [
-                    receiptDebts[1],
-                ]);
-                const flashLoanRepayBalance = transaction.moveCall({
-                    target: "0x2::coin::into_balance",
-                    typeArguments: [flashLoan.obj.coinTypeB],
-                    arguments: [flashLoanRepayCoin],
-                });
-                transaction.moveCall({
-                    target: `${MMT_CONTRACT_PACKAGE_ID}::trade::repay_flash_loan`,
-                    typeArguments: [flashLoan.obj.coinTypeA, flashLoan.obj.coinTypeB],
-                    arguments: [
-                        transaction.object(flashLoan.obj.poolId),
-                        flashLoan.receipt,
-                        flashLoan.borrowedBalanceA,
-                        flashLoanRepayBalance,
-                        transaction.object(MMT_VERSION_OBJECT_ID),
-                    ],
-                });
+            if (isSui(withdrawCoinType)) {
+                // 3.1) Unstake LST for SUI
+                const suiWithdrawnCoin = lst.client.redeem(transaction, withdrawnCoin);
+                // 3.2) Repay flash loan + fee
+                if (flashLoan !== undefined) {
+                    transaction.mergeCoins(suiWithdrawnCoin, [flashLoan.remainingCoin]);
+                    const receiptDebts = transaction.moveCall({
+                        target: `${MMT_CONTRACT_PACKAGE_ID}::trade::flash_receipt_debts`,
+                        typeArguments: [],
+                        arguments: [flashLoan.receipt],
+                    });
+                    const [flashLoanRepayCoin] = transaction.splitCoins(suiWithdrawnCoin, [receiptDebts[1]]);
+                    const flashLoanRepayBalance = transaction.moveCall({
+                        target: "0x2::coin::into_balance",
+                        typeArguments: [flashLoan.obj.coinTypeB],
+                        arguments: [flashLoanRepayCoin],
+                    });
+                    transaction.moveCall({
+                        target: `${MMT_CONTRACT_PACKAGE_ID}::trade::repay_flash_loan`,
+                        typeArguments: [flashLoan.obj.coinTypeA, flashLoan.obj.coinTypeB],
+                        arguments: [
+                            transaction.object(flashLoan.obj.poolId),
+                            flashLoan.receipt,
+                            flashLoan.borrowedBalanceA,
+                            flashLoanRepayBalance,
+                            transaction.object(MMT_VERSION_OBJECT_ID),
+                        ],
+                    });
+                }
+                finalWithdrawnCoin = {
+                    coin: suiWithdrawnCoin,
+                    estimatedAmount: BigNumber.max(0, getRedeemedSuiAmount(estimatedWithdrawnAmount, lst).minus(flashLoan?.borrowedAmount ?? 0)),
+                };
+            }
+            else {
+                finalWithdrawnCoin = {
+                    coin: withdrawnCoin,
+                    estimatedAmount: estimatedWithdrawnAmount,
+                };
             }
-            // 3.3) Transfer SUI to user
-            await sendWithdrawnCoin(suiWithdrawnCoin, BigNumber.max(0, getRedeemedSuiAmount(estimatedWithdrawnAmount, lst).minus(flashLoan?.borrowedAmount ?? 0)));
-        }
-        else {
-            // 3.1) Transfer LST to user
-            await sendWithdrawnCoin(withdrawnCoin, estimatedWithdrawnAmount);
         }
     }
+    const extras = await withdrawStrategyExtraDepositsTx(strategyType, suilendClient, cetusSdk, cetusPartnerId, _address, strategyOwnerCapId, extraDeposits.map((deposit) => {
+        const reserve = reserveMap[deposit.coinType];
+        return {
+            reserve,
+            amount: deposit.depositedAmount.decimalPlaces(reserve.token.decimals, BigNumber.ROUND_DOWN),
+            isMax: true,
+        };
+    }), reserveMap[withdrawCoinType], finalWithdrawnCoin, transaction, dryRunTransaction);
+    if (extras.withdrawnCoin === undefined && !extras.isWithdrawn)
+        throw extras.error ?? new Error("Nothing left to withdraw");
+    transaction = extras.transaction;
+    if (!extras.isWithdrawn)
+        deposits = extraDeposits;
+    if (extras.withdrawnCoin !== undefined)
+        await sendWithdrawnCoin(extras.withdrawnCoin.coin, extras.withdrawnCoin.estimatedAmount);
     // 4) Claim rewards and transfer to user
     if (hasClaimableRewards) {
         // Claiming is a bonus, so a failure must not block the withdraw — but the calls

package/utils/simulate.d.ts

@@ -56,9 +56,17 @@ export interface PriceFeedSource {
     getLatestPriceFeeds(ids: string[]): Promise<FeedPrice[] | undefined>;
 }
 export { normalizeFeedId };
+/**
+ * The first lending market version whose refresh aborts `EInvalidPrice` on a
+ * spot that parses to a zero `Decimal`, instead of storing it. Earlier versions
+ * store the zero, so the model follows the market's own version. The chain
+ * builds that `Decimal` with flooring division, so any spot below 1e-18 is
+ * zero there, while `stringToDecimal` rounds 7e-19 up to 1e-18.
+ */
+export declare const ZERO_PRICE_ABORT_MARKET_VERSION: bigint;
 export declare const reservePriceFeedIds: (reserves: Reserve<string>[]) => string[];
-export declare const applyReservePriceFeeds: (reserves: Reserve<string>[], priceFeeds: FeedPrice[] | undefined) => Reserve<string>[];
-export declare const refreshReservePrice: (reserves: Reserve<string>[], pythConnection: PriceFeedSource) => Promise<Reserve<string>[]>;
+export declare const applyReservePriceFeeds: (reserves: Reserve<string>[], priceFeeds: FeedPrice[] | undefined, marketVersion?: bigint) => Reserve<string>[];
+export declare const refreshReservePrice: (reserves: Reserve<string>[], pythConnection: PriceFeedSource, marketVersion?: bigint) => 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
@@ -123,11 +131,11 @@ export declare const PARTIAL_FETCH_REQUIRED_HINT = "inject a connection implemen
  *    error. `refreshReservesForInitialize` rejects the combination outright.
  */
 export declare const fetchReservePriceFeedsTolerant: (reserves: Reserve<string>[], pythConnection: PriceFeedSource | PartialPriceFeedSource) => Promise<FeedPrice[] | undefined>;
-export declare const applyReservePriceFeedsTolerant: (reserves: Reserve<string>[], priceFeeds: FeedPrice[] | undefined) => {
+export declare const applyReservePriceFeedsTolerant: (reserves: Reserve<string>[], priceFeeds: FeedPrice[] | undefined, marketVersion?: bigint) => {
     reserves: Reserve<string>[];
     unpricedCoinTypes: string[];
 };
-export declare const refreshReservePriceTolerant: (reserves: Reserve<string>[], pythConnection: PriceFeedSource | PartialPriceFeedSource) => Promise<{
+export declare const refreshReservePriceTolerant: (reserves: Reserve<string>[], pythConnection: PriceFeedSource | PartialPriceFeedSource, marketVersion?: bigint) => Promise<{
     reserves: Reserve<string>[];
     unpricedCoinTypes: string[];
 }>;

package/utils/simulate.js

@@ -180,8 +180,19 @@ const withFeedPrice = (reserve, priceFeed) => {
     newReserve.unclampedPrices = undefined;
     return newReserve;
 };
+/**
+ * The first lending market version whose refresh aborts `EInvalidPrice` on a
+ * spot that parses to a zero `Decimal`, instead of storing it. Earlier versions
+ * store the zero, so the model follows the market's own version. The chain
+ * builds that `Decimal` with flooring division, so any spot below 1e-18 is
+ * zero there, while `stringToDecimal` rounds 7e-19 up to 1e-18.
+ */
+export const ZERO_PRICE_ABORT_MARKET_VERSION = BigInt(8);
+const refreshAbortsOnZeroPrice = (marketVersion, priceFeed) => marketVersion !== undefined &&
+    marketVersion >= ZERO_PRICE_ABORT_MARKET_VERSION &&
+    new BigNumber(priceFeed.price).shiftedBy(18).lt(1);
 export const reservePriceFeedIds = (reserves) => Array.from(new Set(reserves.map(reserveFeedId)));
-export const applyReservePriceFeeds = (reserves, priceFeeds) => {
+export const applyReservePriceFeeds = (reserves, priceFeeds, marketVersion) => {
     // 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
@@ -194,10 +205,12 @@ export const applyReservePriceFeeds = (reserves, priceFeeds) => {
         const priceFeed = byId.get(reserveFeedId(reserve));
         if (!priceFeed)
             throw new Error(`Price feed not found for reserve ${reserve.coinType}`);
+        if (refreshAbortsOnZeroPrice(marketVersion, priceFeed))
+            throw new Error(`Price feed for reserve ${reserve.coinType} reads a zero price, which a market at version ${marketVersion} rejects with EInvalidPrice`);
         return withFeedPrice(reserve, priceFeed);
     });
 };
-export const refreshReservePrice = async (reserves, pythConnection) => applyReservePriceFeeds(reserves, await pythConnection.getLatestPriceFeeds(reservePriceFeedIds(reserves)));
+export const refreshReservePrice = async (reserves, pythConnection, marketVersion) => applyReservePriceFeeds(reserves, await pythConnection.getLatestPriceFeeds(reservePriceFeedIds(reserves)), marketVersion);
 /**
  * Whether this connection can report WHICH requested feeds it could not serve.
  *
@@ -269,12 +282,12 @@ export const fetchReservePriceFeedsTolerant = async (reserves, pythConnection) =
         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 });
     }
 };
-export const applyReservePriceFeedsTolerant = (reserves, priceFeeds) => {
+export const applyReservePriceFeedsTolerant = (reserves, priceFeeds, marketVersion) => {
     const byId = indexFeedsById(priceFeeds ?? []);
     const unpricedCoinTypes = [];
     const updatedReserves = reserves.map((reserve) => {
         const priceFeed = byId.get(reserveFeedId(reserve));
-        if (!priceFeed) {
+        if (!priceFeed || refreshAbortsOnZeroPrice(marketVersion, 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
@@ -287,7 +300,7 @@ export const applyReservePriceFeedsTolerant = (reserves, priceFeeds) => {
     });
     return { reserves: updatedReserves, unpricedCoinTypes };
 };
-export const refreshReservePriceTolerant = async (reserves, pythConnection) => applyReservePriceFeedsTolerant(reserves, await fetchReservePriceFeedsTolerant(reserves, pythConnection));
+export const refreshReservePriceTolerant = async (reserves, pythConnection, marketVersion) => applyReservePriceFeedsTolerant(reserves, await fetchReservePriceFeedsTolerant(reserves, pythConnection), marketVersion);
 const warnedStaleRewardSnapshots = new Set();
 const warnStaleRewardSnapshot = (poolRewardId, poolCumulative, userCumulative) => {
     if (warnedStaleRewardSnapshots.has(poolRewardId))