curvance 4.1.2 → 5.1.0

package/dist/classes/Market.js

@@ -8,11 +8,19 @@ const helpers_1 = require("../helpers");
 const CToken_1 = require("./CToken");
 const MarketManagerIsolated_json_1 = __importDefault(require("../abis/MarketManagerIsolated.json"));
 const decimal_js_1 = require("decimal.js");
-const setup_1 = require("../setup");
 const merkl_1 = require("../integrations/merkl");
 const BorrowableCToken_1 = require("./BorrowableCToken");
 const FormatConverter_1 = __importDefault(require("./FormatConverter"));
 const Api_1 = require("./Api");
+const chains_1 = require("../chains");
+function resolveDefaultSetupConfig(context) {
+    const config = require("../setup").setup_config;
+    if (config == undefined) {
+        throw new Error(`Setup config is not configured for ${context}. ` +
+            `Pass setup/provider context explicitly or initialize setupChain() first.`);
+    }
+    return config;
+}
 class Market {
     provider;
     signer;
@@ -26,6 +34,7 @@ class Market {
     cache;
     milestone = null;
     incentives = [];
+    _userDataScope;
     constructor(provider, signer, account, static_data, dynamic_data, user_data, deploy_data, oracle_manager, reader, setup) {
         this.provider = provider;
         this.signer = signer;
@@ -36,14 +45,10 @@ class Market {
         this.setup = setup;
         this.contract = (0, helpers_1.contractSetup)(provider, this.address, MarketManagerIsolated_json_1.default);
         this.cache = { static: static_data, dynamic: dynamic_data, user: user_data, deploy: deploy_data };
-        for (let i = 0; i < static_data.tokens.length; i++) {
+        this._userDataScope = "full";
+        for (const tokenData of Market.mergeTokenPayloads(static_data, dynamic_data, user_data)) {
             // @NOTE: Merged fields from the 3 types, so you wanna make sure there is no collisions
             // Otherwise we will have some dataloss
-            const tokenData = {
-                ...static_data.tokens[i],
-                ...dynamic_data.tokens[i],
-                ...user_data.tokens[i]
-            };
             if (tokenData.isBorrowable) {
                 const ctoken = new BorrowableCToken_1.BorrowableCToken(provider, tokenData.address, tokenData, this);
                 this.tokens.push(ctoken);
@@ -57,6 +62,44 @@ class Market {
     getAccountOrThrow() {
         return (0, helpers_1.requireAccount)(this.account, this.signer);
     }
+    assertRefreshAccountCompatible(account, allowSignerMismatch = false) {
+        if (allowSignerMismatch) {
+            return;
+        }
+        const signerAddress = this.signer?.address;
+        if (signerAddress == null || signerAddress.toLowerCase() === account.toLowerCase()) {
+            return;
+        }
+        throw new Error(`Cannot refresh signer-backed market ${this.address} for ${account}; ` +
+            `the active signer is ${signerAddress}.`);
+    }
+    bindRefreshedAccount(account, allowSignerMismatch = false) {
+        this.assertRefreshAccountCompatible(account, allowSignerMismatch);
+        this.account = account;
+    }
+    requireFullUserTokenData(accessLabel) {
+        if (this.userDataScope !== "summary") {
+            return;
+        }
+        throw new Error(`Market-level token-derived user data is stale for ${this.address} after a summary-only refresh. ` +
+            `Call market.reloadUserData(account) or Market.reloadUserMarkets(...) before ${accessLabel}.`);
+    }
+    requireValidCachedUserHealth(accessLabel) {
+        if (this.cache.user.errorCodeHit || this.cache.user.priceStale) {
+            throw new Error(`Cached market user data for ${this.address} is not reliable for ${accessLabel} because ` +
+                `the reader reported an oracle error or stale price.`);
+        }
+    }
+    cooldownDateFromUnlockTime(unlockTime, cooldownLength = this.cooldownLength) {
+        if (unlockTime === cooldownLength) {
+            return null;
+        }
+        const now = BigInt(Math.floor(Date.now() / 1000));
+        if (unlockTime <= now) {
+            return null;
+        }
+        return new Date(Number(unlockTime * 1000n));
+    }
     /** @returns {string} - The name of the market at deployment. */
     get name() { return this.cache.deploy.name; }
     /** @returns {Plugins} - The address of the market's plugins by deploy name. */
@@ -66,15 +109,27 @@ class Market {
     /** @returns {bigint[]} - A list of oracle identifiers which can be mapped to AdaptorTypes enum */
     get adapters() { return this.cache.static.adapters; }
     /** @returns {Date | null} - Market cooldown, activated by Collateralization or Borrowing. Lasts as long as {this.cooldownLength} which is currently 20mins */
-    get cooldown() { return this.cache.user.cooldown == this.cooldownLength ? null : new Date(Number(this.cache.user.cooldown * 1000n)); }
+    get cooldown() { return this.cooldownDateFromUnlockTime(this.cache.user.cooldown); }
+    /** @returns The scope of the latest whole-market user refresh. */
+    get userDataScope() { return this._userDataScope ?? "full"; }
     /** @returns {Decimal} - The user's collateral in Shares. */
-    get userCollateral() { return (0, helpers_1.toDecimal)(this.cache.user.collateral, 18n); }
+    get userCollateral() {
+        this.requireValidCachedUserHealth("reading userCollateral");
+        return (0, helpers_1.toDecimal)(this.cache.user.collateral, 18n);
+    }
     /** @returns {USD} - The user's debt in USD. */
-    get userDebt() { return (0, helpers_1.toDecimal)(this.cache.user.debt, 18n); }
+    get userDebt() {
+        this.requireValidCachedUserHealth("reading userDebt");
+        return (0, helpers_1.toDecimal)(this.cache.user.debt, 18n);
+    }
     /** @returns {USD} - The user's maximum debt in USD. */
-    get userMaxDebt() { return (0, helpers_1.toDecimal)(this.cache.user.maxDebt, 18n); }
+    get userMaxDebt() {
+        this.requireValidCachedUserHealth("reading userMaxDebt");
+        return (0, helpers_1.toDecimal)(this.cache.user.maxDebt, 18n);
+    }
     /** @returns {USD} - The user's remaining credit with a .1% buffer in USD */
     get userRemainingCredit() {
+        this.requireValidCachedUserHealth("reading userRemainingCredit");
         const remaining = this.cache.user.maxDebt - this.cache.user.debt;
         return (0, helpers_1.toDecimal)(remaining, 18n).mul(.999);
     }
@@ -83,6 +138,7 @@ class Market {
      * @returns {Percentage | null} - The user's position health Percentage or null if infinity
      */
     get positionHealth() {
+        this.requireValidCachedUserHealth("reading positionHealth");
         if (this.cache.user.positionHealth == helpers_1.UINT256_MAX) {
             return null;
         }
@@ -93,6 +149,7 @@ class Market {
      * @returns {USD} - The total user deposits in USD.
      */
     get userDeposits() {
+        this.requireFullUserTokenData("reading userDeposits");
         let total_deposits = (0, decimal_js_1.Decimal)(0);
         for (const token of this.tokens) {
             total_deposits = total_deposits.add(token.getUserAssetBalance(true));
@@ -104,6 +161,7 @@ class Market {
      * @returns {USD} - The user's net position in USD.
      */
     get userNet() {
+        this.requireFullUserTokenData("reading userNet");
         return this.userDeposits.sub(this.userDebt);
     }
     /** @returns Market LTV */
@@ -127,13 +185,17 @@ class Market {
         }
         return `${min.mul(100)}% - ${max.mul(100)}%`;
     }
-    /** @returns Total market deposits */
-    get tvl() {
-        let marketTvl = new decimal_js_1.Decimal(0);
+    /** @returns Total market deposits in USD, summed across the market's tokens.
+     *  Renamed from `tvl` to match the sibling getter naming
+     *  (`totalDebt`, `totalCollateral`). Backed by the per-token
+     *  `getDeposits` (which now values via `totalAssets`, not `totalSupply`,
+     *  so the liquidity ≤ deposits invariant holds). */
+    get totalDeposits() {
+        let total = new decimal_js_1.Decimal(0);
         for (const token of this.tokens) {
-            marketTvl = marketTvl.add(token.getTvl(true));
+            total = total.add(token.getDeposits(true));
         }
-        return marketTvl;
+        return total;
     }
     /** @returns Total market debt */
     get totalDebt() {
@@ -158,6 +220,7 @@ class Market {
      * @returns What tokens can and cannot be borrowed from
      */
     getBorrowableCTokens() {
+        this.requireFullUserTokenData("reading borrowable token eligibility");
         const result = {
             eligible: [],
             ineligible: []
@@ -181,6 +244,7 @@ class Market {
      * @returns The total user deposits change (ex: 50, which would be $50/day)
      */
     getUserDepositsChange(rate) {
+        this.requireFullUserTokenData(`reading user deposit change for rate ${rate}`);
         let total_change = (0, decimal_js_1.Decimal)(0);
         for (const token of this.tokens) {
             const amount = token.getUserAssetBalance(true);
@@ -194,6 +258,7 @@ class Market {
      * @returns The total user debt change (ex: 50, which would be $50/day)
      */
     getUserDebtChange(rate) {
+        this.requireFullUserTokenData(`reading user debt change for rate ${rate}`);
         let total_change = (0, decimal_js_1.Decimal)(0);
         for (const token of this.tokens) {
             if (!token.isBorrowable) {
@@ -210,6 +275,7 @@ class Market {
      * @returns The total user net change (ex: 50, which would be $50/day)
      */
     getUserNetChange(rate) {
+        this.requireFullUserTokenData(`reading user net change for rate ${rate}`);
         const earn = this.getUserDepositsChange(rate);
         const debt = this.getUserDebtChange(rate);
         return earn.sub(debt);
@@ -253,24 +319,82 @@ class Market {
         return Promise.all(this.tokens.map((token) => token.getSnapshot(account)));
     }
     hasUserActivity() {
+        this.requireFullUserTokenData("determining user activity");
         return this.tokens.some((token) => token.cache.userAssetBalance > 0n ||
             token.cache.userShareBalance > 0n ||
             token.cache.userCollateral > 0n ||
             token.cache.userDebt > 0n);
     }
+    requireRefreshTokenRows(rows, label) {
+        if (rows.length !== this.tokens.length) {
+            throw new Error(`Token row count mismatch for market ${this.address} during refresh: ` +
+                `expected=${this.tokens.length} ${label}=${rows.length}.`);
+        }
+        const rowsByAddress = new Map(rows.map((row) => [row.address.toLowerCase(), row]));
+        for (const token of this.tokens) {
+            if (!rowsByAddress.has(token.address.toLowerCase())) {
+                throw new Error(`Missing ${label} token data for ${token.address} in market ${this.address} during refresh.`);
+            }
+        }
+        return rowsByAddress;
+    }
+    requireRefreshMarketAddress(row, label) {
+        if (row.address.toLowerCase() !== this.address.toLowerCase()) {
+            throw new Error(`Mismatched ${label} market data during refresh: expected=${this.address} received=${row.address}.`);
+        }
+    }
+    validateStateRows(dynamicData, userData) {
+        this.requireRefreshMarketAddress(dynamicData, "dynamic");
+        if (userData != undefined) {
+            this.requireRefreshMarketAddress(userData, "user");
+        }
+        this.requireRefreshTokenRows(dynamicData.tokens, "dynamic");
+        if (userData != undefined) {
+            this.requireRefreshTokenRows(userData.tokens, "user");
+        }
+    }
+    validateRefreshState(dynamicData, userData) {
+        this.validateStateRows(dynamicData, userData);
+    }
+    static requireMarketRow(rows, market, label) {
+        const row = new Map(rows.map((entry) => [entry.address.toLowerCase(), entry])).get(market.address.toLowerCase());
+        if (row == undefined) {
+            throw new Error(`Could not reload ${label} data for market ${market.address}.`);
+        }
+        return row;
+    }
     applyState(dynamicData, userData) {
+        this.validateStateRows(dynamicData, userData);
+        const dynamicRowsByAddress = this.requireRefreshTokenRows(dynamicData.tokens, "dynamic");
+        const userRowsByAddress = userData != undefined
+            ? this.requireRefreshTokenRows(userData.tokens, "user")
+            : undefined;
         this.cache.dynamic = dynamicData;
         if (userData != undefined) {
             this.cache.user = userData;
+            this._userDataScope = "full";
         }
         for (const token of this.tokens) {
-            const nextDynamic = dynamicData.tokens.find((t) => t.address == token.address);
-            const nextUser = userData?.tokens.find((t) => t.address == token.address);
+            const nextDynamic = dynamicRowsByAddress.get(token.address.toLowerCase());
+            const nextUser = userRowsByAddress?.get(token.address.toLowerCase());
             token.cache = {
                 ...token.cache,
-                ...(nextDynamic ?? {}),
+                ...nextDynamic,
                 ...(nextUser ?? {}),
             };
+            if (nextUser != undefined) {
+                token.markUserCacheFresh?.();
+            }
+        }
+    }
+    applyUserSummary(userData) {
+        this.cache.user = {
+            ...this.cache.user,
+            ...userData,
+        };
+        this._userDataScope = "summary";
+        for (const token of this.tokens) {
+            token.invalidateUserCache?.();
         }
     }
     async reloadMarketData() {
@@ -281,48 +405,149 @@ class Market {
         }
         this.applyState(dynamic);
     }
-    async reloadUserData(account) {
+    async reloadUserData(account, options = {}) {
+        const allowSignerMismatch = options.allowSignerMismatch ?? false;
+        this.assertRefreshAccountCompatible(account, allowSignerMismatch);
         const { dynamicMarkets, userMarkets } = await this.reader.getMarketStates([this.address], account);
-        const dynamic = dynamicMarkets[0];
-        const user = userMarkets[0];
-        if (dynamic == undefined || user == undefined) {
-            throw new Error(`Could not reload market state for ${this.address}.`);
-        }
+        const dynamic = Market.requireMarketRow(dynamicMarkets, this, "dynamic");
+        const user = Market.requireMarketRow(userMarkets, this, "user");
         this.applyState(dynamic, user);
+        this.bindRefreshedAccount(account, allowSignerMismatch);
+    }
+    async reloadUserSummary(account) {
+        this.assertRefreshAccountCompatible(account);
+        const userMarkets = await this.reader.getMarketSummaries([this.address], account);
+        const user = Market.requireMarketRow(userMarkets, this, "user summary");
+        this.applyUserSummary(user);
+        this.bindRefreshedAccount(account);
     }
     static getActiveUserMarkets(markets) {
         return markets.filter((market) => market.hasUserActivity());
     }
-    static async reloadUserMarkets(markets, account) {
-        if (markets.length === 0) {
-            return [];
-        }
+    static groupByReaderDeployment(markets) {
         const groups = new Map();
         for (const market of markets) {
-            const existing = groups.get(market.reader);
+            const groupKey = market.reader.batchKey ?? market.reader;
+            const existing = groups.get(groupKey);
             if (existing) {
-                existing.push(market);
+                existing.markets.push(market);
             }
             else {
-                groups.set(market.reader, [market]);
+                groups.set(groupKey, {
+                    reader: market.reader,
+                    markets: [market],
+                });
             }
         }
-        for (const [reader, groupedMarkets] of groups) {
+        return groups.values();
+    }
+    static async reloadUserMarkets(markets, account) {
+        if (markets.length === 0) {
+            return [];
+        }
+        for (const market of markets) {
+            market.assertRefreshAccountCompatible(account);
+        }
+        const plans = [];
+        for (const { reader, markets: groupedMarkets } of this.groupByReaderDeployment(markets)) {
             const addresses = groupedMarkets.map((market) => market.address);
             const { dynamicMarkets, userMarkets } = await reader.getMarketStates(addresses, account);
-            const dynamicByAddress = new Map(dynamicMarkets.map((market) => [market.address, market]));
-            const userByAddress = new Map(userMarkets.map((market) => [market.address, market]));
+            const dynamicByAddress = new Map(dynamicMarkets.map((market) => [market.address.toLowerCase(), market]));
+            const userByAddress = new Map(userMarkets.map((market) => [market.address.toLowerCase(), market]));
             for (const market of groupedMarkets) {
-                const dynamic = dynamicByAddress.get(market.address);
-                const user = userByAddress.get(market.address);
+                const dynamic = dynamicByAddress.get(market.address.toLowerCase());
+                const user = userByAddress.get(market.address.toLowerCase());
                 if (dynamic == undefined || user == undefined) {
                     throw new Error(`Could not reload market state for ${market.address}.`);
                 }
-                market.applyState(dynamic, user);
+                market.validateStateRows(dynamic, user);
+                plans.push({ market, dynamic, user });
+            }
+        }
+        for (const { market, dynamic, user } of plans) {
+            market.applyState(dynamic, user);
+            market.bindRefreshedAccount(account);
+        }
+        return markets;
+    }
+    static async reloadUserMarketSummaries(markets, account) {
+        if (markets.length === 0) {
+            return [];
+        }
+        for (const market of markets) {
+            market.assertRefreshAccountCompatible(account);
+        }
+        const plans = [];
+        for (const { reader, markets: groupedMarkets } of this.groupByReaderDeployment(markets)) {
+            const addresses = groupedMarkets.map((market) => market.address);
+            const userMarkets = await reader.getMarketSummaries(addresses, account);
+            const userByAddress = new Map(userMarkets.map((market) => [market.address.toLowerCase(), market]));
+            for (const market of groupedMarkets) {
+                const user = userByAddress.get(market.address.toLowerCase());
+                if (user == undefined) {
+                    throw new Error(`Could not reload market user summary for ${market.address}.`);
+                }
+                market.requireRefreshMarketAddress(user, "user summary");
+                plans.push({ market, user });
             }
         }
+        for (const { market, user } of plans) {
+            market.applyUserSummary(user);
+            market.bindRefreshedAccount(account);
+        }
         return markets;
     }
+    static buildDeployDataIndex(setup) {
+        const index = new Map();
+        const deployments = setup.contracts.markets;
+        for (const [name, data] of Object.entries(deployments)) {
+            if (typeof data !== 'object' || data == null || typeof data.address !== 'string') {
+                continue;
+            }
+            const key = data.address.toLowerCase();
+            if (!index.has(key)) {
+                index.set(key, {
+                    name,
+                    plugins: 'plugins' in data ? data.plugins : {},
+                });
+            }
+        }
+        return index;
+    }
+    static buildYieldIndex(yields) {
+        const index = new Map();
+        for (const yieldEntry of yields) {
+            const key = yieldEntry.symbol.toUpperCase();
+            if (!index.has(key)) {
+                index.set(key, yieldEntry);
+            }
+        }
+        return index;
+    }
+    static buildMarketPayloadIndex(entries) {
+        return new Map(entries.map((entry) => [entry.address.toLowerCase(), entry]));
+    }
+    static requireTokenRow(rowsByAddress, tokenAddress, marketAddress, label) {
+        const row = rowsByAddress.get(tokenAddress.toLowerCase());
+        if (row == undefined) {
+            throw new Error(`Missing ${label} token data for ${tokenAddress} in market ${marketAddress} during Market boot.`);
+        }
+        return row;
+    }
+    static mergeTokenPayloads(staticData, dynamicData, userData) {
+        if (staticData.tokens.length !== dynamicData.tokens.length ||
+            staticData.tokens.length !== userData.tokens.length) {
+            throw new Error(`Token row count mismatch for market ${staticData.address} during Market boot: ` +
+                `static=${staticData.tokens.length} dynamic=${dynamicData.tokens.length} user=${userData.tokens.length}.`);
+        }
+        const dynamicByAddress = this.buildMarketPayloadIndex(dynamicData.tokens);
+        const userByAddress = this.buildMarketPayloadIndex(userData.tokens);
+        return staticData.tokens.map((staticToken) => ({
+            ...staticToken,
+            ...this.requireTokenRow(dynamicByAddress, staticToken.address, staticData.address, "dynamic"),
+            ...this.requireTokenRow(userByAddress, staticToken.address, staticData.address, "user"),
+        }));
+    }
     /**
      * Preview the impact of the user descision for their deposit/borrow/leverage
      * @param user - Wallet address
@@ -335,7 +560,14 @@ class Market {
     async previewAssetImpact(user, collateral_ctoken, debt_ctoken, deposit_amount, borrow_amount, rate_change) {
         const amount_in = (0, helpers_1.toBigInt)(deposit_amount, collateral_ctoken.asset.decimals);
         const amount_out = (0, helpers_1.toBigInt)(borrow_amount, debt_ctoken.asset.decimals);
-        const { supply, borrow } = await this.reader.previewAssetImpact(user, collateral_ctoken.address, debt_ctoken.address, amount_in, amount_out);
+        let { supply, borrow } = await this.reader.previewAssetImpact(user, collateral_ctoken.address, debt_ctoken.address, amount_in, amount_out);
+        if (amount_out > 0n) {
+            const irm = await debt_ctoken.dynamicIRM();
+            const currentAssetsHeld = await debt_ctoken.contract.assetsHeld();
+            const currentDebt = await debt_ctoken.contract.marketOutstandingDebt();
+            const projectedAssetsHeld = currentAssetsHeld > amount_out ? currentAssetsHeld - amount_out : 0n;
+            borrow = await irm.borrowRate(projectedAssetsHeld, currentDebt + amount_out);
+        }
         const supply_apy = (0, decimal_js_1.Decimal)(supply * (0, helpers_1.getRateSeconds)('year')).div(helpers_1.WAD);
         const borrow_apy = (0, decimal_js_1.Decimal)(borrow * (0, helpers_1.getRateSeconds)('year')).div(helpers_1.WAD);
         const supply_percent = (0, decimal_js_1.Decimal)(supply * (0, helpers_1.getRateSeconds)(rate_change)).div(helpers_1.WAD);
@@ -371,27 +603,26 @@ class Market {
         if (newLeverage.equals(1)) {
             return null;
         }
-        const { collateralAssetReduction } = deposit_ctoken.previewLeverageDown(newLeverage, currentLeverage);
-        const repayUsd = deposit_ctoken.convertTokensToUsd(collateralAssetReduction, true);
+        const preview = deposit_ctoken.previewLeverageDown(newLeverage, currentLeverage, borrow_ctoken);
+        const repayCollateralAssets = preview.collateralAssetReduction;
+        let { collateralAssetReduction } = preview;
+        if (preview.feeBps > 0n) {
+            collateralAssetReduction = collateralAssetReduction * 10000n / (10000n - preview.feeBps);
+        }
+        const repayUsd = deposit_ctoken.convertTokensToUsd(repayCollateralAssets, true);
         const repayTokens = borrow_ctoken.convertUsdToTokens(repayUsd, true);
         return this.previewPositionHealth(deposit_ctoken, borrow_ctoken, false, FormatConverter_1.default.bigIntToDecimal(collateralAssetReduction, deposit_ctoken.asset.decimals), true, repayTokens);
     }
-    async previewPositionHealthLeverageUp(deposit_ctoken, borrow_ctoken, newLeverage, depositAssets) {
-        const { borrowAmount } = deposit_ctoken.previewLeverageUp(newLeverage, borrow_ctoken, depositAssets);
-        // borrowAmount is the reduced amount sent to the contract — this is both
-        // what enters the vault/swap (becomes collateral) and what the user owes (debt).
-        // Use price-based conversion for collateral increase — this matches how the
-        // on-chain health reader values positions (via oracle prices, not vault rates).
-        const borrowUsd = borrowAmount.mul(borrow_ctoken.getPrice(true));
-        const collateralFromBorrow = borrowUsd.div(deposit_ctoken.getPrice(true));
-        // Total collateral increase = initial deposit + borrowed amount swapped to collateral.
-        // The on-chain reader starts from the user's current position, so the deposit
-        // must be included or the preview will undercount collateral (showing ~0% health).
-        const depositInTokens = depositAssets
-            ? FormatConverter_1.default.bigIntToDecimal(depositAssets, deposit_ctoken.asset.decimals)
-            : (0, decimal_js_1.Decimal)(0);
-        const collateralIncrease = collateralFromBorrow.add(depositInTokens);
-        return this.previewPositionHealth(deposit_ctoken, borrow_ctoken, true, collateralIncrease, false, borrowAmount);
+    async previewPositionHealthLeverageUp(deposit_ctoken, borrow_ctoken, newLeverage, depositAssets, positionManagerType) {
+        if ((depositAssets ?? 0n) > 0n) {
+            return this.previewPositionHealthDepositAndLeverage(deposit_ctoken, borrow_ctoken, newLeverage, depositAssets, positionManagerType);
+        }
+        const preview = deposit_ctoken.previewLeverageUp(newLeverage, borrow_ctoken, undefined, positionManagerType);
+        return this.previewPositionHealth(deposit_ctoken, borrow_ctoken, true, preview.collateralIncreaseInAssets, false, preview.debtIncreaseInAssets);
+    }
+    async previewPositionHealthDepositAndLeverage(deposit_ctoken, borrow_ctoken, newLeverage, depositAssets, positionManagerType) {
+        const preview = deposit_ctoken.previewDepositAndLeverage(newLeverage, borrow_ctoken, depositAssets, positionManagerType);
+        return this.previewPositionHealth(deposit_ctoken, borrow_ctoken, true, preview.collateralIncreaseInAssets, false, preview.debtIncreaseInAssets);
     }
     /**
      * A dynamic position health previewer for any action
@@ -434,12 +665,13 @@ class Market {
      */
     async previewPositionHealthRedeem(ctoken, amount) {
         const user = this.getAccountOrThrow();
-        const redeem_amount = ctoken.convertTokenInputToShares(amount);
-        const existing_collateral = ctoken.cache.userCollateral;
-        if (redeem_amount > existing_collateral) {
-            throw new Error(`Insufficient collateral: Existing (${existing_collateral}) < Redeem amount (${redeem_amount})`);
+        const redeemShares = ctoken.convertTokenInputToShares(amount);
+        const redeemAssets = FormatConverter_1.default.decimalToBigInt(amount, ctoken.asset.decimals);
+        const existing_collateral = ctoken.getUserCollateralShares();
+        if (redeemShares > existing_collateral) {
+            throw new Error(`Insufficient collateral: Existing (${existing_collateral}) < Redeem amount (${redeemShares})`);
         }
-        const data = await this.reader.getPositionHealth(this.address, user, ctoken.address, helpers_1.EMPTY_ADDRESS, false, redeem_amount, false, 0n, 0n);
+        const data = await this.reader.getPositionHealth(this.address, user, ctoken.address, helpers_1.EMPTY_ADDRESS, false, redeemAssets, false, 0n, 0n);
         if (data.errorCodeHit) {
             throw new Error(`Error code hit when calculating position health preview. This usually means price is stale so we couldn't get a valid health value.`);
         }
@@ -476,7 +708,10 @@ class Market {
      */
     async previewPositionHealthRepay(token, amount) {
         const user = this.getAccountOrThrow();
-        const data = await this.reader.getPositionHealth(this.address, user, helpers_1.EMPTY_ADDRESS, token.address, false, 0n, true, FormatConverter_1.default.decimalToBigInt(amount, token.decimals), 0n);
+        const repayAssets = amount.eq(0)
+            ? helpers_1.UINT256_MAX
+            : FormatConverter_1.default.decimalToBigInt(amount, token.decimals);
+        const data = await this.reader.getPositionHealth(this.address, user, helpers_1.EMPTY_ADDRESS, token.address, false, 0n, true, repayAssets, 0n);
         if (data.errorCodeHit) {
             throw new Error(`Error code hit when calculating position health preview. This usually means price is stale so we couldn't get a valid health value.`);
         }
@@ -490,8 +725,8 @@ class Market {
      * @param borrowAssets - Amount of assets being borrowed
      * @returns An object containing the hypothetical liquidity values
      */
-    async hypotheticalLiquidityOf(account, cTokenModified = helpers_1.EMPTY_ADDRESS, redemptionShares = 0n, borrowAssets = 0n) {
-        return this.contract.hypotheticalLiquidityOf(account, cTokenModified, redemptionShares, borrowAssets);
+    async hypotheticalLiquidityOf(account, cTokenModified = helpers_1.EMPTY_ADDRESS, redemptionShares = 0n, borrowAssets = 0n, bufferTime = 0n) {
+        return this.reader.hypotheticalLiquidityOf(this.address, account, cTokenModified, redemptionShares, borrowAssets, bufferTime);
     }
     /**
      * Fetch the expiration date of a user's cooldown period
@@ -503,7 +738,7 @@ class Market {
         const cooldownTimestamp = await this.contract.accountAssets(account);
         const cooldownLength = fetch || this.cooldownLength == 0n ? await this.contract.MIN_HOLD_PERIOD() : this.cooldownLength;
         const unlockTime = cooldownTimestamp + cooldownLength;
-        return unlockTime == cooldownLength ? null : new Date(Number(unlockTime * 1000n));
+        return this.cooldownDateFromUnlockTime(unlockTime, cooldownLength);
     }
     /**
      * Fetch multiple market cooldown expirations
@@ -522,7 +757,7 @@ class Market {
             const market = markets[i];
             const cooldownTimestamp = cooldownTimestamps[i];
             const cooldownLength = market.cooldownLength;
-            cooldowns[market.address] = cooldownTimestamp == cooldownLength ? null : new Date(Number(cooldownTimestamp * 1000n));
+            cooldowns[market.address] = market.cooldownDateFromUnlockTime(cooldownTimestamp, cooldownLength);
         }
         return cooldowns;
     }
@@ -533,68 +768,64 @@ class Market {
      * @param provider - The RPC provider
      * @returns An array of Market instances setup with protocol reader data
      */
-    static async getAll(reader, oracle_manager, provider = setup_1.setup_config.readProvider, signer = setup_1.setup_config.signer, account = setup_1.setup_config.account, milestones = {}, incentives = {}, setup = setup_1.setup_config) {
-        const all_data = await reader.getAllMarketData(account);
-        const deploy_keys = Object.keys(setup.contracts.markets);
+    static async getAll(reader, oracle_manager, provider, signer, account, milestones = {}, incentives = {}, setup) {
+        const resolvedSetup = setup ?? resolveDefaultSetupConfig("Market.getAll");
+        const resolvedProvider = provider ?? resolvedSetup.readProvider;
+        const resolvedSigner = signer === undefined ? resolvedSetup.signer : signer;
+        const resolvedAccount = account === undefined ? resolvedSetup.account : account;
+        const chainId = chains_1.chain_config[resolvedSetup.chain]?.chainId;
+        const all_data = await reader.getAllMarketData(resolvedAccount);
         // Filter out USDC — DeFiLlama incorrectly returns YZM vault yield labeled as USDC
         const [yields, merklLendOpps, merklBorrowOpps] = await Promise.all([
-            Api_1.Api.fetchNativeYields(setup).then(y => y.filter(y => y.symbol.toUpperCase() !== 'USDC')),
-            (0, merkl_1.fetchMerklOpportunities)({ action: 'LEND' }).catch(() => []),
-            (0, merkl_1.fetchMerklOpportunities)({ action: 'BORROW' }).catch(() => []),
+            Api_1.Api.fetchNativeYields(resolvedSetup).then(y => y.filter(y => y.symbol.toUpperCase() !== 'USDC')),
+            (0, merkl_1.fetchMerklOpportunities)({ action: 'LEND', chainId }).catch(() => []),
+            (0, merkl_1.fetchMerklOpportunities)({ action: 'BORROW', chainId }).catch(() => []),
         ]);
+        const deployIndex = this.buildDeployDataIndex(resolvedSetup);
+        const milestonesByAddress = new Map(Object.entries(milestones).map(([market, milestone]) => [market.toLowerCase(), milestone]));
+        const incentivesByAddress = new Map(Object.entries(incentives).map(([market, marketIncentives]) => [market.toLowerCase(), marketIncentives]));
+        const lendOppApyByToken = (0, helpers_1.aggregateMerklAprByToken)(merklLendOpps, "deposit");
+        const borrowOppApyByToken = (0, helpers_1.aggregateMerklAprByToken)(merklBorrowOpps, "borrow");
+        const yieldIndex = this.buildYieldIndex(yields);
+        const dynamicByAddress = this.buildMarketPayloadIndex(all_data.dynamicMarket);
+        const userByAddress = this.buildMarketPayloadIndex(all_data.userData.markets);
         let markets = [];
-        for (let i = 0; i < all_data.staticMarket.length; i++) {
-            const staticData = all_data.staticMarket[i];
-            const dynamicData = all_data.dynamicMarket[i];
-            const userData = all_data.userData.markets[i];
+        for (const staticData of all_data.staticMarket) {
             const market_address = staticData.address;
-            let deploy_data;
-            for (const obj_key of deploy_keys) {
-                const data = setup.contracts.markets[obj_key];
-                if (typeof data != 'object') {
-                    continue;
-                }
-                if (market_address == data.address) {
-                    deploy_data = {
-                        name: obj_key,
-                        plugins: 'plugins' in data ? data.plugins : {}
-                    };
-                    break;
-                }
-            }
+            const deploy_data = deployIndex.get(market_address.toLowerCase());
+            const dynamicData = dynamicByAddress.get(market_address.toLowerCase());
+            const userData = userByAddress.get(market_address.toLowerCase());
             if (deploy_data == undefined) {
                 console.warn(`Could not find deploy data for market: ${market_address}, skipping...`);
                 continue;
             }
-            if (staticData == undefined) {
-                console.warn(`Could not find static market data for index: ${i}`);
-                continue;
-            }
             if (dynamicData == undefined) {
-                console.warn(`Could not find dynamic market data for index: ${i}`);
-                continue;
+                throw new Error(`Missing dynamic market data for ${market_address} during Market.getAll boot.`);
             }
             if (userData == undefined) {
-                console.warn(`Could not find user market data for index: ${i}`);
-                continue;
+                throw new Error(`Missing user market data for ${market_address} during Market.getAll boot.`);
             }
-            const market = new Market(provider, signer, account, staticData, dynamicData, userData, deploy_data, oracle_manager, reader, setup);
-            if (milestones[market.address] != undefined) {
-                market.milestone = milestones[market.address];
+            const market = new Market(resolvedProvider, resolvedSigner, resolvedAccount, staticData, dynamicData, userData, deploy_data, oracle_manager, reader, resolvedSetup);
+            const rewardKey = market.address.toLowerCase();
+            const milestone = milestonesByAddress.get(rewardKey);
+            if (milestone != undefined) {
+                market.milestone = milestone;
             }
-            if (incentives[market.address] != undefined) {
-                market.incentives = incentives[market.address];
+            const marketIncentives = incentivesByAddress.get(rewardKey);
+            if (marketIncentives != undefined) {
+                market.incentives = marketIncentives;
             }
             for (const token of market.tokens) {
-                const lendOpp = merklLendOpps.find(o => o.identifier.toLowerCase() === token.address.toLowerCase());
-                if (lendOpp != undefined) {
-                    token.incentiveSupplyApy = new decimal_js_1.Decimal(lendOpp.apr / 100);
+                const tokenKey = token.address.toLowerCase();
+                const lendApy = lendOppApyByToken.get(tokenKey);
+                if (lendApy != undefined) {
+                    token.incentiveSupplyApy = lendApy;
                 }
-                const borrowOpp = merklBorrowOpps.find(o => o.identifier.toLowerCase() === token.address.toLowerCase());
-                if (borrowOpp != undefined) {
-                    token.incentiveBorrowApy = new decimal_js_1.Decimal(borrowOpp.apr / 100);
+                const borrowApy = borrowOppApyByToken.get(tokenKey);
+                if (borrowApy != undefined) {
+                    token.incentiveBorrowApy = borrowApy;
                 }
-                const api_yield = yields.find(y => y.symbol.toUpperCase() == token.asset.symbol.toUpperCase());
+                const api_yield = yieldIndex.get(token.asset.symbol.toUpperCase());
                 if (api_yield != undefined) {
                     token.nativeApy = new decimal_js_1.Decimal(api_yield.apy / 100);
                 }