@morpho-org/blue-sdk 1.0.0 → 1.0.1

package/lib/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vault = exports.ethers = exports.helpers = exports.user = exports.signatures = exports.notifications = exports.maths = exports.types = exports.holding = exports.position = exports.token = exports.chain = exports.market = exports.errors = exports.constants = exports.evm = void 0;
+__exportStar(require("./addresses"), exports);
+__exportStar(require("./evm"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./market"), exports);
+__exportStar(require("./chain"), exports);
+__exportStar(require("./token"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./maths"), exports);
+__exportStar(require("./notifications"), exports);
+__exportStar(require("./signatures"), exports);
+__exportStar(require("./user"), exports);
+__exportStar(require("./holding"), exports);
+__exportStar(require("./position"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./ethers"), exports);
+__exportStar(require("./vault"), exports);
+exports.evm = __importStar(require("./evm"));
+exports.constants = __importStar(require("./constants"));
+exports.errors = __importStar(require("./errors"));
+exports.market = __importStar(require("./market"));
+exports.chain = __importStar(require("./chain"));
+exports.token = __importStar(require("./token"));
+exports.position = __importStar(require("./position"));
+exports.holding = __importStar(require("./holding"));
+exports.types = __importStar(require("./types"));
+exports.maths = __importStar(require("./maths"));
+exports.notifications = __importStar(require("./notifications"));
+exports.signatures = __importStar(require("./signatures"));
+exports.user = __importStar(require("./user"));
+exports.helpers = __importStar(require("./helpers"));
+exports.ethers = __importStar(require("./ethers"));
+exports.vault = __importStar(require("./vault"));

package/lib/market/Market.d.ts

@@ -0,0 +1,159 @@
+import { BigNumberish, Provider } from "ethers";
+import { ViewOverrides } from "ethers-types/dist/common";
+import { ChainId } from "../chain";
+import { RoundingDirection } from "../maths";
+import { MarketId } from "../types";
+import { MarketConfig } from "./MarketConfig";
+export declare enum CapacityLimitReason {
+    liquidity = "Liquidity",
+    balance = "Balance",
+    position = "Position",
+    collateral = "Collateral",
+    cap = "Cap"
+}
+export interface CapacityLimit {
+    value: bigint;
+    limiter: CapacityLimitReason;
+}
+export interface MaxPositionCapacities {
+    supply: CapacityLimit;
+    withdraw: CapacityLimit;
+    borrow: CapacityLimit;
+    repay: CapacityLimit;
+    supplyCollateral: CapacityLimit;
+    withdrawCollateral: CapacityLimit;
+}
+export interface InputMarket {
+    config: MarketConfig;
+    totalSupplyAssets: BigNumberish;
+    totalBorrowAssets: BigNumberish;
+    totalSupplyShares: BigNumberish;
+    totalBorrowShares: BigNumberish;
+    lastUpdate: BigNumberish;
+    fee: BigNumberish;
+    price: BigNumberish;
+    rateAtTarget?: BigNumberish;
+}
+export declare class Market implements InputMarket {
+    static fetchFromId(id: MarketId, runner: {
+        provider: Provider;
+    }, { chainId, overrides, }?: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<Market>;
+    static fetchFromConfig(config: MarketConfig, runner: {
+        provider: Provider;
+    }, { chainId, overrides, }?: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<Market>;
+    /**
+     * The market's config.
+     */
+    readonly config: MarketConfig;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyAssets: bigint;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowAssets: bigint;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyShares: bigint;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowShares: bigint;
+    /**
+     * The block timestamp (in __seconds__) when the interest was last accrued.
+     */
+    lastUpdate: bigint;
+    /**
+     * The fee percentage of the market, scaled by WAD.
+     */
+    fee: bigint;
+    /**
+     * The price as returned by the market's oracle.
+     */
+    price: bigint;
+    /**
+     * If the market uses the Adaptive Curve IRM, the rate at target utilization.
+     * Undefined otherwise.
+     */
+    rateAtTarget?: bigint;
+    constructor({ config, totalSupplyAssets, totalBorrowAssets, totalSupplyShares, totalBorrowShares, lastUpdate, fee, price, rateAtTarget, }: InputMarket);
+    get id(): MarketId;
+    get isIdle(): boolean;
+    /**
+     * @warning Cannot be used to calculate the liquidity available inside a callback,
+     * because the balance of Blue may be lower than the market's liquidity due to assets being transferred out prior to the callback.
+     */
+    get liquidity(): bigint;
+    get utilization(): bigint;
+    get apyAtTarget(): bigint | undefined;
+    get supplyRate(): bigint;
+    get borrowRate(): bigint;
+    get supplyApy(): bigint;
+    get borrowApy(): bigint;
+    accrueInterest(timestamp: BigNumberish): Market;
+    getLiquidityToUtilization(utilization: BigNumberish): bigint;
+    getCollateralValue(collateral: BigNumberish): bigint;
+    getMaxBorrowAssets(collateral: BigNumberish): bigint;
+    getMaxBorrowableAssets(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint;
+    getLiquidationSeizedAssets(repaidShares: BigNumberish): bigint;
+    getLiquidationRepaidShares(seizedAssets: BigNumberish): bigint;
+    getSeizableCollateral(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint;
+    getWithdrawableCollateral(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint;
+    isHealthy(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): boolean;
+    getLiquidationPrice(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint | null;
+    getPriceVariationToLiquidation(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint | null;
+    getHealthFactor(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint | null;
+    getLtv(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint | null;
+    getBorrowCapacityUsage(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }): bigint | null;
+    toSupplyAssets(shares: BigNumberish, rounding?: RoundingDirection): bigint;
+    toSupplyShares(assets: BigNumberish, rounding?: RoundingDirection): bigint;
+    toBorrowAssets(shares: BigNumberish, rounding?: RoundingDirection): bigint;
+    toBorrowShares(assets: BigNumberish, rounding?: RoundingDirection): bigint;
+    getBorrowCapacityLimit(collateral: bigint): CapacityLimit;
+    getRepayCapacityLimit(borrowShares: bigint, loanTokenBalance: bigint): CapacityLimit;
+    getWithdrawCapacityLimit(supplyShares: bigint): CapacityLimit;
+    getWithdrawCollateralCapacityLimit(position: {
+        collateral: bigint;
+        borrowShares: bigint;
+    }): CapacityLimit;
+    getMaxCapacities(position: {
+        collateral: bigint;
+        supplyShares: bigint;
+        borrowShares: bigint;
+    }, loanTokenBalance: bigint, collateralTokenBalance: bigint): MaxPositionCapacities;
+}

package/lib/market/Market.js

@@ -0,0 +1,240 @@
+"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) {
+    CapacityLimitReason["liquidity"] = "Liquidity";
+    CapacityLimitReason["balance"] = "Balance";
+    CapacityLimitReason["position"] = "Position";
+    CapacityLimitReason["collateral"] = "Collateral";
+    CapacityLimitReason["cap"] = "Cap";
+})(CapacityLimitReason || (exports.CapacityLimitReason = CapacityLimitReason = {}));
+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,
+        });
+    }
+    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);
+        if (rateAtTarget != null)
+            this.rateAtTarget = (0, ethers_1.toBigInt)(rateAtTarget);
+    }
+    get id() {
+        return this.config.id;
+    }
+    get isIdle() {
+        return this.config.collateralToken === ethers_1.ZeroAddress;
+    }
+    /**
+     * @warning Cannot be used to calculate the liquidity available inside a callback,
+     * because the balance of Blue may be lower than the market's liquidity due to assets being transferred out prior to the callback.
+     */
+    get liquidity() {
+        return this.totalSupplyAssets - this.totalBorrowAssets;
+    }
+    get utilization() {
+        return MarketUtils_1.MarketUtils.getUtilization(this);
+    }
+    get apyAtTarget() {
+        if (this.rateAtTarget == null)
+            return;
+        return MarketUtils_1.MarketUtils.getApy(this.rateAtTarget);
+    }
+    get supplyRate() {
+        return MarketUtils_1.MarketUtils.getSupplyRate(this.borrowRate, this);
+    }
+    get borrowRate() {
+        if (this.rateAtTarget == null)
+            return 0n;
+        return maths_1.AdaptiveCurveIrmLib.getBorrowRate(this.utilization, this.rateAtTarget, 0n).avgBorrowRate;
+    }
+    get supplyApy() {
+        return MarketUtils_1.MarketUtils.getApy(this.supplyRate);
+    }
+    get borrowApy() {
+        return MarketUtils_1.MarketUtils.getApy(this.borrowRate);
+    }
+    accrueInterest(timestamp) {
+        timestamp = (0, ethers_1.toBigInt)(timestamp);
+        const elapsed = timestamp - this.lastUpdate;
+        if (elapsed < 0n)
+            throw new errors_1.InvalidInterestAccrualError(this.id, timestamp, this.lastUpdate);
+        let borrowRate = 0n;
+        let { rateAtTarget } = this;
+        if (this.rateAtTarget != null) {
+            const { avgBorrowRate, endRateAtTarget } = maths_1.AdaptiveCurveIrmLib.getBorrowRate(this.utilization, this.rateAtTarget, elapsed);
+            borrowRate = avgBorrowRate;
+            rateAtTarget = endRateAtTarget;
+        }
+        const { interest, feeShares } = MarketUtils_1.MarketUtils.getAccruedInterest(borrowRate, this, elapsed);
+        return new Market({
+            ...this,
+            totalSupplyAssets: this.totalSupplyAssets + interest,
+            totalBorrowAssets: this.totalBorrowAssets + interest,
+            totalSupplyShares: this.totalSupplyShares + feeShares,
+            lastUpdate: timestamp,
+            rateAtTarget,
+        });
+    }
+    getLiquidityToUtilization(utilization) {
+        return MarketUtils_1.MarketUtils.getLiquidityToUtilization(this, utilization);
+    }
+    getCollateralValue(collateral) {
+        return MarketUtils_1.MarketUtils.getCollateralValue(collateral, this);
+    }
+    getMaxBorrowAssets(collateral) {
+        return MarketUtils_1.MarketUtils.getMaxBorrowAssets(collateral, this, this.config);
+    }
+    getMaxBorrowableAssets(position) {
+        return MarketUtils_1.MarketUtils.getMaxBorrowableAssets(position, this, this.config);
+    }
+    getLiquidationSeizedAssets(repaidShares) {
+        return MarketUtils_1.MarketUtils.getLiquidationSeizedAssets(repaidShares, this, this.config);
+    }
+    getLiquidationRepaidShares(seizedAssets) {
+        return MarketUtils_1.MarketUtils.getLiquidationRepaidShares(seizedAssets, this, this.config);
+    }
+    getSeizableCollateral(position) {
+        return MarketUtils_1.MarketUtils.getSeizableCollateral(position, this, this.config);
+    }
+    getWithdrawableCollateral(position) {
+        return MarketUtils_1.MarketUtils.getWithdrawableCollateral(position, this, this.config);
+    }
+    isHealthy(position) {
+        return MarketUtils_1.MarketUtils.isHealthy(position, this, this.config);
+    }
+    getLiquidationPrice(position) {
+        return MarketUtils_1.MarketUtils.getLiquidationPrice(position, this, this.config);
+    }
+    getPriceVariationToLiquidation(position) {
+        return MarketUtils_1.MarketUtils.getPriceVariationToLiquidation(position, this, this.config);
+    }
+    getHealthFactor(position) {
+        return MarketUtils_1.MarketUtils.getHealthFactor(position, this, this.config);
+    }
+    getLtv(position) {
+        return MarketUtils_1.MarketUtils.getLtv(position, this);
+    }
+    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);
+    }
+    getBorrowCapacityLimit(collateral) {
+        const maxBorrowableAssets = this.getMaxBorrowAssets(collateral);
+        const { liquidity } = this;
+        if (maxBorrowableAssets > liquidity)
+            return {
+                value: liquidity,
+                limiter: CapacityLimitReason.liquidity,
+            };
+        return {
+            value: maxBorrowableAssets,
+            limiter: CapacityLimitReason.collateral,
+        };
+    }
+    getRepayCapacityLimit(borrowShares, loanTokenBalance) {
+        const borrowAssets = this.toBorrowAssets(borrowShares);
+        if (borrowAssets > loanTokenBalance)
+            return {
+                value: loanTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            };
+        return {
+            value: borrowAssets,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    getWithdrawCapacityLimit(supplyShares) {
+        const supplyAssets = this.toSupplyAssets(supplyShares);
+        const { liquidity } = this;
+        if (supplyAssets > liquidity)
+            return {
+                value: liquidity,
+                limiter: CapacityLimitReason.liquidity,
+            };
+        return {
+            value: supplyAssets,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    getWithdrawCollateralCapacityLimit(position) {
+        const withdrawableCollateral = this.getWithdrawableCollateral(position);
+        if (position.collateral > withdrawableCollateral)
+            return {
+                value: withdrawableCollateral,
+                limiter: CapacityLimitReason.collateral,
+            };
+        return {
+            value: position.collateral,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    getMaxCapacities(position, loanTokenBalance, collateralTokenBalance) {
+        return {
+            supply: {
+                value: loanTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdraw: this.getWithdrawCapacityLimit(position.supplyShares),
+            borrow: this.getBorrowCapacityLimit(position.collateral),
+            repay: this.getRepayCapacityLimit(position.borrowShares, loanTokenBalance),
+            supplyCollateral: {
+                value: collateralTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdrawCollateral: this.getWithdrawCollateralCapacityLimit(position),
+        };
+    }
+}
+exports.Market = Market;

package/lib/market/MarketConfig.d.ts

@@ -0,0 +1,44 @@
+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 {
+    loanToken: Address;
+    collateralToken: Address;
+    oracle: Address;
+    irm: Address;
+}
+export declare class MarketConfig implements MarketParams {
+    private static readonly _CACHE;
+    static get(id: MarketId): MarketConfig;
+    static fetch(id: MarketId, runner: {
+        provider: Provider;
+    }, chainId?: ChainId): Promise<MarketConfig>;
+    static idle(token: Address): MarketConfig;
+    /**
+     * The market's collateral token address.
+     */
+    readonly collateralToken: Address;
+    /**
+     * The market's loan token address.
+     */
+    readonly loanToken: Address;
+    /**
+     * The market's oracle address.
+     */
+    readonly oracle: Address;
+    /**
+     * The market's interest rate model address.
+     */
+    readonly irm: Address;
+    /**
+     * The market's liquidation Loan-To-Value (scaled by WAD).
+     */
+    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.
+     */
+    get id(): MarketId;
+    get liquidationIncentiveFactor(): bigint;
+}

package/lib/market/MarketConfig.js

@@ -0,0 +1,56 @@
+"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");
+class MarketConfig {
+    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;
+    }
+    static idle(token) {
+        return new MarketConfig({
+            collateralToken: ethers_1.ZeroAddress,
+            loanToken: token,
+            oracle: ethers_1.ZeroAddress,
+            irm: ethers_1.ZeroAddress,
+            lltv: 0n,
+        });
+    }
+    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);
+        MarketConfig._CACHE[this.id] = this;
+    }
+    /**
+     * The market's hex-encoded id, defined as the hash of the market's params.
+     */
+    get id() {
+        return MarketUtils_1.MarketUtils.getMarketId(this);
+    }
+    get liquidationIncentiveFactor() {
+        return MarketUtils_1.MarketUtils.getLiquidationIncentiveFactor(this);
+    }
+}
+exports.MarketConfig = MarketConfig;
+MarketConfig._CACHE = {};