@morpho-org/blue-sdk 1.0.6 → 1.2.0

package/lib/market/Market.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Market = exports.CapacityLimitReason = void 0;
-const ethers_1 = require("ethers");
-const ethers_types_1 = require("ethers-types");
-const addresses_1 = require("../addresses");
-const chain_1 = require("../chain");
 const errors_1 = require("../errors");
 const maths_1 = require("../maths");
-const MarketConfig_1 = require("./MarketConfig");
 const MarketUtils_1 = require("./MarketUtils");
 var CapacityLimitReason;
 (function (CapacityLimitReason) {
@@ -17,53 +12,71 @@ var CapacityLimitReason;
     CapacityLimitReason["collateral"] = "Collateral";
     CapacityLimitReason["cap"] = "Cap";
 })(CapacityLimitReason || (exports.CapacityLimitReason = CapacityLimitReason = {}));
+/**
+ * Represents a lending market on Morpho Blue.
+ */
 class Market {
-    static async fetchFromId(id, runner, { chainId, overrides = {}, } = {}) {
-        chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
-        const config = await MarketConfig_1.MarketConfig.fetch(id, runner, chainId);
-        return Market.fetchFromConfig(config, runner, { chainId, overrides });
-    }
-    static async fetchFromConfig(config, runner, { chainId, overrides = {}, } = {}) {
-        chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
-        const { morpho, adaptiveCurveIrm } = (0, addresses_1.getChainAddresses)(chainId);
-        const [{ totalSupplyAssets, totalSupplyShares, totalBorrowShares, totalBorrowAssets, lastUpdate, fee, }, price, rateAtTarget,] = await Promise.all([
-            ethers_types_1.MorphoBlue__factory.connect(morpho, runner).market(config.id, overrides),
-            config.oracle !== ethers_1.ZeroAddress
-                ? ethers_types_1.BlueOracle__factory.connect(config.oracle, runner).price(overrides)
-                : 0n,
-            config.irm === adaptiveCurveIrm
-                ? await ethers_types_1.AdaptiveCurveIrm__factory.connect(config.irm, runner).rateAtTarget(config.id, overrides)
-                : undefined,
-        ]);
-        return new Market({
-            config,
-            totalSupplyAssets,
-            totalBorrowAssets,
-            totalSupplyShares,
-            totalBorrowShares,
-            lastUpdate,
-            fee,
-            price,
-            rateAtTarget,
-        });
-    }
+    /**
+     * The market's config.
+     */
+    config;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyAssets;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowAssets;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyShares;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowShares;
+    /**
+     * The block timestamp (in __seconds__) when the interest was last accrued.
+     */
+    lastUpdate;
+    /**
+     * The fee percentage of the market, scaled by WAD.
+     */
+    fee;
+    /**
+     * The price as returned by the market's oracle.
+     */
+    price;
+    /**
+     * If the market uses the Adaptive Curve IRM, the rate at target utilization.
+     * Undefined otherwise.
+     */
+    rateAtTarget;
     constructor({ config, totalSupplyAssets, totalBorrowAssets, totalSupplyShares, totalBorrowShares, lastUpdate, fee, price, rateAtTarget, }) {
         this.config = config;
-        this.totalSupplyAssets = (0, ethers_1.toBigInt)(totalSupplyAssets);
-        this.totalBorrowAssets = (0, ethers_1.toBigInt)(totalBorrowAssets);
-        this.totalSupplyShares = (0, ethers_1.toBigInt)(totalSupplyShares);
-        this.totalBorrowShares = (0, ethers_1.toBigInt)(totalBorrowShares);
-        this.lastUpdate = (0, ethers_1.toBigInt)(lastUpdate);
-        this.fee = (0, ethers_1.toBigInt)(fee);
-        this.price = (0, ethers_1.toBigInt)(price);
+        this.totalSupplyAssets = totalSupplyAssets;
+        this.totalBorrowAssets = totalBorrowAssets;
+        this.totalSupplyShares = totalSupplyShares;
+        this.totalBorrowShares = totalBorrowShares;
+        this.lastUpdate = lastUpdate;
+        this.fee = fee;
+        this.price = price;
         if (rateAtTarget != null)
-            this.rateAtTarget = (0, ethers_1.toBigInt)(rateAtTarget);
+            this.rateAtTarget = rateAtTarget;
     }
+    /**
+     * The market's hex-encoded id, defined as the hash of the market params.
+     */
     get id() {
         return this.config.id;
     }
+    /**
+     * Whether the market satisfies the canonical definition of an idle market (i.e. collateral token is the zero address).
+     */
     get isIdle() {
-        return this.config.collateralToken === ethers_1.ZeroAddress;
+        return (this.config.collateralToken ===
+            "0x0000000000000000000000000000000000000000");
     }
     /**
      * @warning Cannot be used to calculate the liquidity available inside a callback,
@@ -72,33 +85,59 @@ class Market {
     get liquidity() {
         return this.totalSupplyAssets - this.totalBorrowAssets;
     }
+    /**
+     * The market's utilization rate (scaled by WAD).
+     */
     get utilization() {
         return MarketUtils_1.MarketUtils.getUtilization(this);
     }
+    /**
+     * The market's Annual Percentage Yield (APY) at the IRM's target utilization rate, if applicable (scaled by WAD).
+     */
     get apyAtTarget() {
         if (this.rateAtTarget == null)
             return;
         return MarketUtils_1.MarketUtils.getApy(this.rateAtTarget);
     }
+    /**
+     * Returns the rate at which interest accrued on average for suppliers of this market,
+     * since the last time the market was updated (scaled by WAD).
+     */
     get supplyRate() {
         return MarketUtils_1.MarketUtils.getSupplyRate(this.borrowRate, this);
     }
+    /**
+     * Returns the rate at which interest accrued on average for borrowers of this market,
+     * since the last time the market was updated (scaled by WAD).
+     */
     get borrowRate() {
         if (this.rateAtTarget == null)
             return 0n;
         return maths_1.AdaptiveCurveIrmLib.getBorrowRate(this.utilization, this.rateAtTarget, 0n).avgBorrowRate;
     }
+    /**
+     * The market's supply Annual Percentage Yield (APY) (scaled by WAD).
+     */
     get supplyApy() {
         return MarketUtils_1.MarketUtils.getApy(this.supplyRate);
     }
+    /**
+     * The market's borrow Annual Percentage Yield (APY) (scaled by WAD).
+     */
     get borrowApy() {
         return MarketUtils_1.MarketUtils.getApy(this.borrowRate);
     }
+    /**
+     * Returns a new market derived from this market, whose interest has been accrued up to the given timestamp.
+     * @param timestamp The timestamp at which to accrue interest. Must be greater than or equal to `lastUpdate`.
+     */
     accrueInterest(timestamp) {
-        timestamp = (0, ethers_1.toBigInt)(timestamp);
+        timestamp = BigInt(timestamp);
         const elapsed = timestamp - this.lastUpdate;
         if (elapsed < 0n)
-            throw new errors_1.InvalidInterestAccrualError(this.id, timestamp, this.lastUpdate);
+            throw new errors_1.BlueErrors.InvalidInterestAccrual(this.id, timestamp, this.lastUpdate);
+        if (elapsed === 0n)
+            return this;
         let borrowRate = 0n;
         let { rateAtTarget } = this;
         if (this.rateAtTarget != null) {
@@ -116,63 +155,203 @@ class Market {
             rateAtTarget,
         });
     }
-    getLiquidityToUtilization(utilization) {
-        return MarketUtils_1.MarketUtils.getLiquidityToUtilization(this, utilization);
+    supply(assets, shares, timestamp = this.lastUpdate) {
+        if (assets === 0n && shares === 0n)
+            throw new errors_1.BlueErrors.InconsistentInput();
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toSupplyShares(assets, "Down");
+        else
+            assets = market.toSupplyAssets(shares, "Up");
+        market.totalSupplyAssets += assets;
+        market.totalSupplyShares += shares;
+        return { market, assets, shares };
+    }
+    withdraw(assets, shares, timestamp = this.lastUpdate) {
+        if (assets === 0n && shares === 0n)
+            throw new errors_1.BlueErrors.InconsistentInput();
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toSupplyShares(assets, "Up");
+        else
+            assets = market.toSupplyAssets(shares, "Down");
+        market.totalSupplyAssets -= assets;
+        market.totalSupplyShares -= shares;
+        if (market.totalBorrowAssets > market.totalSupplyAssets)
+            throw new errors_1.BlueErrors.InsufficientLiquidity(market.id);
+        return { market, assets, shares };
+    }
+    borrow(assets, shares, timestamp = this.lastUpdate) {
+        if (assets === 0n && shares === 0n)
+            throw new errors_1.BlueErrors.InconsistentInput();
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toBorrowShares(assets, "Up");
+        else
+            assets = market.toBorrowAssets(shares, "Down");
+        market.totalBorrowAssets += assets;
+        market.totalBorrowShares += shares;
+        if (market.totalBorrowAssets > market.totalSupplyAssets)
+            throw new errors_1.BlueErrors.InsufficientLiquidity(market.id);
+        return { market, assets, shares };
+    }
+    repay(assets, shares, timestamp = this.lastUpdate) {
+        if (assets === 0n && shares === 0n)
+            throw new errors_1.BlueErrors.InconsistentInput();
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toBorrowShares(assets, "Down");
+        else
+            assets = market.toBorrowAssets(shares, "Up");
+        market.totalBorrowAssets -= assets;
+        market.totalBorrowShares -= shares;
+        return { market, assets, shares };
+    }
+    /**
+     * Converts a given amount of supply shares into supply loan assets.
+     * @param shares The amount of shares to convert.
+     * @param rounding The rounding direction to use (defaults to "Down").
+     */
+    toSupplyAssets(shares, rounding) {
+        return MarketUtils_1.MarketUtils.toSupplyAssets(shares, this, rounding);
+    }
+    /**
+     * Converts a given amount of supply loan assets into supply shares.
+     * @param shares The amount of assets to convert.
+     * @param rounding The rounding direction to use (defaults to "Up").
+     */
+    toSupplyShares(assets, rounding) {
+        return MarketUtils_1.MarketUtils.toSupplyShares(assets, this, rounding);
+    }
+    /**
+     * Converts a given amount of borrow shares into borrow loan assets.
+     * @param shares The amount of shares to convert.
+     * @param rounding The rounding direction to use (defaults to "Up").
+     */
+    toBorrowAssets(shares, rounding) {
+        return MarketUtils_1.MarketUtils.toBorrowAssets(shares, this, rounding);
+    }
+    /**
+     * Converts a given amount of borrow loan assets into borrow shares.
+     * @param shares The amount of assets to convert.
+     * @param rounding The rounding direction to use (defaults to "Down").
+     */
+    toBorrowShares(assets, rounding) {
+        return MarketUtils_1.MarketUtils.toBorrowShares(assets, this, rounding);
+    }
+    /**
+     * Returns the liquidity available to borrow until the market reach the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getSupplyLiquidityToUtilization(utilization) {
+        return MarketUtils_1.MarketUtils.getSupplyLiquidityToUtilization(this, utilization);
     }
+    /**
+     * Returns the liquidity available to borrow until the market reach the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getBorrowLiquidityToUtilization(utilization) {
+        return MarketUtils_1.MarketUtils.getBorrowLiquidityToUtilization(this, utilization);
+    }
+    /**
+     * Returns the value of a given amount of collateral quoted in loan assets.
+     * @param collateral The amount of collateral to quote.
+     */
     getCollateralValue(collateral) {
         return MarketUtils_1.MarketUtils.getCollateralValue(collateral, this);
     }
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain amount of collateral.
+     * @param collateral The amount of collateral to consider.
+     */
     getMaxBorrowAssets(collateral) {
         return MarketUtils_1.MarketUtils.getMaxBorrowAssets(collateral, this, this.config);
     }
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position.
+     * @param position The borrow position to consider.
+     */
     getMaxBorrowableAssets(position) {
         return MarketUtils_1.MarketUtils.getMaxBorrowableAssets(position, this, this.config);
     }
+    /**
+     * Returns the amount of collateral that would be seized in a liquidation given a certain amount of repaid shares.
+     * @param repaidShares The amount of shares hypothetically repaid.
+     */
     getLiquidationSeizedAssets(repaidShares) {
         return MarketUtils_1.MarketUtils.getLiquidationSeizedAssets(repaidShares, this, this.config);
     }
+    /**
+     * Returns the amount of borrow shares that would be repaid in a liquidation given a certain amount of seized collateral.
+     * @param seizedAssets The amount of collateral hypothetically seized.
+     */
     getLiquidationRepaidShares(seizedAssets) {
         return MarketUtils_1.MarketUtils.getLiquidationRepaidShares(seizedAssets, this, this.config);
     }
+    /**
+     * Returns the maximum amount of collateral that is worth being seized in a liquidation given a certain borrow position.
+     * @param position The borrow position to consider.
+     */
     getSeizableCollateral(position) {
         return MarketUtils_1.MarketUtils.getSeizableCollateral(position, this, this.config);
     }
+    /**
+     * Returns the amount of collateral that can be withdrawn given a certain borrow position.
+     * @param position The borrow position to consider.
+     */
     getWithdrawableCollateral(position) {
         return MarketUtils_1.MarketUtils.getWithdrawableCollateral(position, this, this.config);
     }
+    /**
+     * Returns whether a given borrow position is healthy.
+     * @param position The borrow position to check.
+     */
     isHealthy(position) {
         return MarketUtils_1.MarketUtils.isHealthy(position, this, this.config);
     }
+    /**
+     * Returns the liquidation price of a given borrow position.
+     * @param position The borrow position to consider.
+     */
     getLiquidationPrice(position) {
         return MarketUtils_1.MarketUtils.getLiquidationPrice(position, this, this.config);
     }
+    /**
+     * Returns the price deviation required for the given borrow position to be unhealthy (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
     getPriceVariationToLiquidation(position) {
         return MarketUtils_1.MarketUtils.getPriceVariationToLiquidation(position, this, this.config);
     }
+    /**
+     * Returns the health factor of a given borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
     getHealthFactor(position) {
         return MarketUtils_1.MarketUtils.getHealthFactor(position, this, this.config);
     }
+    /**
+     * Returns the loan-to-value ratio of a given borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
     getLtv(position) {
         return MarketUtils_1.MarketUtils.getLtv(position, this);
     }
+    /**
+     * Returns the usage ratio of the maximum borrow capacity given a certain borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
     getBorrowCapacityUsage(position) {
         return MarketUtils_1.MarketUtils.getBorrowCapacityUsage(position, this, this.config);
     }
-    toSupplyAssets(shares, rounding) {
-        return MarketUtils_1.MarketUtils.toSupplyAssets(shares, this, rounding);
-    }
-    toSupplyShares(assets, rounding) {
-        return MarketUtils_1.MarketUtils.toSupplyShares(assets, this, rounding);
-    }
-    toBorrowAssets(shares, rounding) {
-        return MarketUtils_1.MarketUtils.toBorrowAssets(shares, this, rounding);
-    }
-    toBorrowShares(assets, rounding) {
-        return MarketUtils_1.MarketUtils.toBorrowShares(assets, this, rounding);
-    }
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position
+     * and the reason for the limit.
+     * @param position The borrow position to consider.
+     */
     getBorrowCapacityLimit({ collateral, borrowShares = 0n, }) {
         // handle edge cases when the user is liquidatable (maxBorrow < borrow)
-        const maxBorrowableAssets = maths_1.MathUtils.zeroFloorSub(this.getMaxBorrowAssets(collateral), this.toBorrowAssets(borrowShares));
+        const maxBorrowableAssets = maths_1.MathLib.zeroFloorSub(this.getMaxBorrowAssets(collateral), this.toBorrowAssets(borrowShares));
         const { liquidity } = this;
         if (maxBorrowableAssets > liquidity)
             return {
@@ -184,6 +363,11 @@ class Market {
             limiter: CapacityLimitReason.collateral,
         };
     }
+    /**
+     * Returns the maximum amount of loan assets that can be repaid given a certain borrow position
+     * and a balance of loan assets, and the reason for the limit.
+     * @param position The borrow position to consider.
+     */
     getRepayCapacityLimit(borrowShares, loanTokenBalance) {
         const borrowAssets = this.toBorrowAssets(borrowShares);
         if (borrowAssets > loanTokenBalance)
@@ -196,7 +380,12 @@ class Market {
             limiter: CapacityLimitReason.position,
         };
     }
-    getWithdrawCapacityLimit(supplyShares) {
+    /**
+     * Returns the maximum amount of loan assets that can be withdrawn given a certain supply position
+     * and a balance of loan assets, and the reason for the limit.
+     * @param position The supply position to consider.
+     */
+    getWithdrawCapacityLimit({ supplyShares, }) {
         const supplyAssets = this.toSupplyAssets(supplyShares);
         const { liquidity } = this;
         if (supplyAssets > liquidity)
@@ -209,6 +398,11 @@ class Market {
             limiter: CapacityLimitReason.position,
         };
     }
+    /**
+     * Returns the maximum amount of collateral assets that can be withdrawn given a certain borrow position
+     * and the reason for the limit.
+     * @param position The borrow position to consider.
+     */
     getWithdrawCollateralCapacityLimit(position) {
         const withdrawableCollateral = this.getWithdrawableCollateral(position);
         if (position.collateral > withdrawableCollateral)
@@ -221,13 +415,20 @@ class Market {
             limiter: CapacityLimitReason.position,
         };
     }
+    /**
+     * Returns the maximum capacity for all interactions with Morpho Blue given a certain position
+     * and loan and collateral balances.
+     * @param position The position to consider.
+     * @param loanTokenBalance The balance of loan assets.
+     * @param collateralTokenBalance The balance of collateral assets.
+     */
     getMaxCapacities(position, loanTokenBalance, collateralTokenBalance) {
         return {
             supply: {
                 value: loanTokenBalance,
                 limiter: CapacityLimitReason.balance,
             },
-            withdraw: this.getWithdrawCapacityLimit(position.supplyShares),
+            withdraw: this.getWithdrawCapacityLimit(position),
             borrow: this.getBorrowCapacityLimit(position),
             repay: this.getRepayCapacityLimit(position.borrowShares, loanTokenBalance),
             supplyCollateral: {

package/lib/market/MarketConfig.d.ts

@@ -1,19 +1,24 @@
-import { Provider } from "ethers";
-import { MarketParamsStruct } from "ethers-types/dist/protocols/morpho/blue/MorphoBlue";
-import { ChainId } from "../chain";
-import { Address, MarketId } from "../types";
-export interface MarketParams extends MarketParamsStruct {
+import { Address, BigIntish, MarketId } from "../types";
+export interface MarketParams {
     loanToken: Address;
     collateralToken: Address;
     oracle: Address;
     irm: Address;
+    lltv: BigIntish;
 }
+/**
+ * Represents a market's configuration (also called market params).
+ */
 export declare class MarketConfig implements MarketParams {
     private static readonly _CACHE;
+    /**
+     * Returns the previously cached market config for the given id, if any.
+     * @throws {UnknownMarketConfigError} If no market config is cached.
+     */
     static get(id: MarketId): MarketConfig;
-    static fetch(id: MarketId, runner: {
-        provider: Provider;
-    }, chainId?: ChainId): Promise<MarketConfig>;
+    /**
+     * Returns the canonical idle market configuration for the given loan token.
+     */
     static idle(token: Address): MarketConfig;
     /**
      * The market's collateral token address.
@@ -37,8 +42,11 @@ export declare class MarketConfig implements MarketParams {
     readonly lltv: bigint;
     constructor({ collateralToken, loanToken, oracle, irm, lltv }: MarketParams);
     /**
-     * The market's hex-encoded id, defined as the hash of the market's params.
+     * The market's hex-encoded id, defined as the hash of the market params.
      */
     get id(): MarketId;
+    /**
+     * The market's liquidation incentive factor.
+     */
     get liquidationIncentiveFactor(): bigint;
 }

package/lib/market/MarketConfig.js

@@ -1,56 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarketConfig = void 0;
-const ethers_1 = require("ethers");
-const ethers_types_1 = require("ethers-types");
-const addresses_1 = require("../addresses");
-const chain_1 = require("../chain");
 const errors_1 = require("../errors");
 const MarketUtils_1 = require("./MarketUtils");
+/**
+ * Represents a market's configuration (also called market params).
+ */
 class MarketConfig {
+    static _CACHE = {};
+    /**
+     * Returns the previously cached market config for the given id, if any.
+     * @throws {UnknownMarketConfigError} If no market config is cached.
+     */
     static get(id) {
         const marketConfig = MarketConfig._CACHE[id];
         if (!marketConfig)
             throw new errors_1.UnknownMarketConfigError(id);
         return marketConfig;
     }
-    static async fetch(id, runner, chainId) {
-        let config = (0, errors_1._try)(() => MarketConfig.get(id), errors_1.UnknownMarketConfigError);
-        if (!config) {
-            chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
-            const { morpho } = (0, addresses_1.getChainAddresses)(chainId);
-            config = new MarketConfig(
-            // Always fetch at latest block because config is immutable.
-            await ethers_types_1.MorphoBlue__factory.connect(morpho, runner).idToMarketParams(id));
-        }
-        return config;
-    }
+    /**
+     * Returns the canonical idle market configuration for the given loan token.
+     */
     static idle(token) {
         return new MarketConfig({
-            collateralToken: ethers_1.ZeroAddress,
+            collateralToken: "0x0000000000000000000000000000000000000000",
             loanToken: token,
-            oracle: ethers_1.ZeroAddress,
-            irm: ethers_1.ZeroAddress,
+            oracle: "0x0000000000000000000000000000000000000000",
+            irm: "0x0000000000000000000000000000000000000000",
             lltv: 0n,
         });
     }
+    /**
+     * The market's collateral token address.
+     */
+    collateralToken;
+    /**
+     * The market's loan token address.
+     */
+    loanToken;
+    /**
+     * The market's oracle address.
+     */
+    oracle;
+    /**
+     * The market's interest rate model address.
+     */
+    irm;
+    /**
+     * The market's liquidation Loan-To-Value (scaled by WAD).
+     */
+    lltv;
     constructor({ collateralToken, loanToken, oracle, irm, lltv }) {
         this.collateralToken = collateralToken;
         this.loanToken = loanToken;
         this.oracle = oracle;
         this.irm = irm;
-        this.lltv = (0, ethers_1.toBigInt)(lltv);
+        this.lltv = BigInt(lltv);
         MarketConfig._CACHE[this.id] = this;
     }
     /**
-     * The market's hex-encoded id, defined as the hash of the market's params.
+     * The market's hex-encoded id, defined as the hash of the market params.
      */
     get id() {
         return MarketUtils_1.MarketUtils.getMarketId(this);
     }
+    /**
+     * The market's liquidation incentive factor.
+     */
     get liquidationIncentiveFactor() {
         return MarketUtils_1.MarketUtils.getLiquidationIncentiveFactor(this);
     }
 }
 exports.MarketConfig = MarketConfig;
-MarketConfig._CACHE = {};