@morpho-org/blue-sdk 1.0.0 → 1.0.1

package/lib/maths/MathLib.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathLib = void 0;
+const ethers_1 = require("ethers");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+/**
+ * Library to manage fixed-point arithmetic.
+ * This library reproduces the behaviour of the solidity library MathLib
+ * TODO: add library link
+ * @category Maths
+ *
+ */
+class MathLib {
+    /**
+     * Returns the smallest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    static min(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return x <= y ? x : y;
+    }
+    /**
+     * Returns the greatest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    static max(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return x <= y ? y : x;
+    }
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    static wMulDown(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return MathLib.wMul(x, y, "Down");
+    }
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    static wMulUp(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return MathLib.wMul(x, y, "Up");
+    }
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    static wMul(x, y, rounding) {
+        return MathLib.mulDiv(x, y, MathLib.WAD, rounding);
+    }
+    /**
+     * Perform the WAD-based division of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    static wDivDown(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return MathLib.wDiv(x, y, "Down");
+    }
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    static wDivUp(x, y) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        return MathLib.wDiv(x, y, "Up");
+    }
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    static wDiv(x, y, rounding) {
+        return MathLib.mulDiv(x, MathLib.WAD, y, rounding);
+    }
+    /**
+     * Multiply two numbers and divide by a denominator, rounding down the result
+     * @param x The first number
+     * @param y The second number
+     * @param denominator The denominator
+     */
+    static mulDivDown(x, y, denominator) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        denominator = (0, ethers_1.toBigInt)(denominator);
+        if (denominator === 0n)
+            throw Error("MathLib: DIVISION_BY_ZERO");
+        return (x * y) / denominator;
+    }
+    /**
+     * Multiply two numbers and divide by a denominator, rounding up the result
+     * @param x The first number
+     * @param y The second number
+     * @param denominator The denominator
+     */
+    static mulDivUp(x, y, denominator) {
+        x = (0, ethers_1.toBigInt)(x);
+        y = (0, ethers_1.toBigInt)(y);
+        denominator = (0, ethers_1.toBigInt)(denominator);
+        if (denominator === 0n)
+            throw Error("MathLib: DIVISION_BY_ZERO");
+        const roundup = (x * y) % denominator > 0 ? 1n : 0n;
+        return (x * y) / denominator + roundup;
+    }
+    static mulDiv(x, y, denominator, rounding) {
+        return MathLib[`mulDiv${rounding}`](x, y, denominator);
+    }
+    /**
+     * The sum of the first three non-zero terms of a Taylor expansion of e^(nx) - 1,
+     * to approximate a continuous compound interest rate.
+     *
+     * @param x The base of the exponent
+     * @param n The exponent
+     */
+    static wTaylorCompounded(x, n) {
+        x = (0, ethers_1.toBigInt)(x);
+        n = (0, ethers_1.toBigInt)(n);
+        const firstTerm = x * n;
+        const secondTerm = MathLib.mulDivDown(firstTerm, firstTerm, 2n * MathLib.WAD);
+        const thirdTerm = MathLib.mulDivDown(secondTerm, firstTerm, 3n * MathLib.WAD);
+        return firstTerm + secondTerm + thirdTerm;
+    }
+    /**
+     * Converts an apr to compounded apy
+     *
+     * @param apr The apr to convert (in WAD)
+     * @param compounding The compounding basis
+     */
+    static aprToApy(apr, compounding) {
+        const factor = morpho_ts_1.Time[compounding].from.y(1n);
+        const rate = apr / factor;
+        return ((0, ethers_1.parseUnits)(((+(0, ethers_1.formatUnits)(this.WAD + rate)) ** Number(factor)).toFixed(18)) - this.WAD);
+    }
+}
+exports.MathLib = MathLib;
+MathLib.WAD = (0, ethers_1.parseUnits)("1");
+MathLib.MAX_UINT_160 = BigInt("0x" + "f".repeat(40));
+MathLib.MAX_UINT_128 = BigInt("0x" + "f".repeat(32));
+MathLib.MAX_UINT_48 = BigInt("0x" + "f".repeat(12));

package/lib/maths/MathUtils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Math utilities
+ * This library reproduces the behaviour of the solidity library MathUtils
+ * TODO: add library link
+ * @category Maths
+ */
+export declare class MathUtils {
+    static zeroFloorSub(a: bigint, b: bigint): bigint;
+    static min(a: bigint, b: bigint): bigint;
+    static mins(...args: bigint[]): bigint;
+    static max(a: bigint, b: bigint): bigint;
+    static pos(a: bigint): bigint;
+    static neg(a: bigint): bigint;
+    static abs(a: bigint): bigint;
+}

package/lib/maths/MathUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+/**
+ * Math utilities
+ * This library reproduces the behaviour of the solidity library MathUtils
+ * TODO: add library link
+ * @category Maths
+ */
+class MathUtils {
+    static zeroFloorSub(a, b) {
+        return a - b < 0n ? 0n : a - b;
+    }
+    static min(a, b) {
+        return a < b ? a : b;
+    }
+    static mins(...args) {
+        return args.reduce((a, b) => this.min(a, b));
+    }
+    static max(a, b) {
+        return a > b ? a : b;
+    }
+    static pos(a) {
+        return a >= 0n ? a : 0n;
+    }
+    static neg(a) {
+        return a < 0n ? -a : 0n;
+    }
+    static abs(a) {
+        return a >= 0 ? a : -a;
+    }
+}
+exports.MathUtils = MathUtils;

package/lib/maths/SharesMath.d.ts

@@ -0,0 +1,12 @@
+import { BigNumberish } from "ethers";
+import { RoundingDirection } from "./MathLib";
+/**
+ * JS implementation of {@link https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/SharesMathLib.sol SharesMathLib} used by Morpho Blue
+ * & MetaMorpho (via {@link https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC4626.sol ERC4626}).
+ */
+export declare namespace SharesMath {
+    const VIRTUAL_SHARES = 1000000n;
+    const VIRTUAL_ASSETS = 1n;
+    function toAssets(shares: BigNumberish, totalAssets: BigNumberish, totalShares: BigNumberish, rounding: RoundingDirection): bigint;
+    function toShares(assets: BigNumberish, totalAssets: BigNumberish, totalShares: BigNumberish, rounding: RoundingDirection): bigint;
+}

package/lib/maths/SharesMath.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharesMath = void 0;
+const ethers_1 = require("ethers");
+const MathLib_1 = require("./MathLib");
+/**
+ * JS implementation of {@link https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/SharesMathLib.sol SharesMathLib} used by Morpho Blue
+ * & MetaMorpho (via {@link https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC4626.sol ERC4626}).
+ */
+var SharesMath;
+(function (SharesMath) {
+    SharesMath.VIRTUAL_SHARES = 1000000n;
+    SharesMath.VIRTUAL_ASSETS = 1n;
+    function toAssets(shares, totalAssets, totalShares, rounding) {
+        return MathLib_1.MathLib.mulDiv(shares, (0, ethers_1.toBigInt)(totalAssets) + SharesMath.VIRTUAL_ASSETS, (0, ethers_1.toBigInt)(totalShares) + SharesMath.VIRTUAL_SHARES, rounding);
+    }
+    SharesMath.toAssets = toAssets;
+    function toShares(assets, totalAssets, totalShares, rounding) {
+        return MathLib_1.MathLib.mulDiv(assets, (0, ethers_1.toBigInt)(totalShares) + SharesMath.VIRTUAL_SHARES, (0, ethers_1.toBigInt)(totalAssets) + SharesMath.VIRTUAL_ASSETS, rounding);
+    }
+    SharesMath.toShares = toShares;
+})(SharesMath || (exports.SharesMath = SharesMath = {}));

package/lib/maths/index.js

@@ -0,0 +1,20 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MathLib"), exports);
+__exportStar(require("./SharesMath"), exports);
+__exportStar(require("./MathUtils"), exports);
+__exportStar(require("./AdaptiveCurveIrmLib"), exports);

package/lib/notifications.d.ts

@@ -0,0 +1,98 @@
+import { Signature, TransactionReceipt, TransactionRequest, TransactionResponse } from "ethers";
+import { Observable, Observer, ReplaySubject } from "rxjs";
+import { SignatureMessage } from "./signatures/types";
+export declare enum NotificationStatus {
+    signing = "signing",
+    success = "success",
+    error = "error",
+    pending = "pending"
+}
+export declare enum NotificationTopic {
+    tx = "tx",
+    signature = "signature"
+}
+export interface NotificationContext {
+    [NotificationTopic.tx]: {
+        [NotificationStatus.signing]: {
+            tx: TransactionRequest;
+        };
+        [NotificationStatus.pending]: {
+            args: Record<PropertyKey, any>;
+            tx: TransactionRequest;
+            response?: TransactionResponse;
+        };
+        [NotificationStatus.success]: {
+            args: Record<PropertyKey, any>;
+            tx: TransactionRequest;
+            response?: TransactionResponse;
+            receipt: TransactionReceipt | null;
+        };
+        [NotificationStatus.error]: {
+            args: Record<PropertyKey, any>;
+            tx: TransactionRequest;
+            response?: TransactionResponse;
+            error: Error;
+        };
+    };
+    [NotificationTopic.signature]: {
+        [NotificationStatus.signing]: never;
+        [NotificationStatus.pending]: {
+            message: SignatureMessage;
+            args: Record<PropertyKey, any>;
+        };
+        [NotificationStatus.success]: {
+            message: SignatureMessage;
+            args: Record<PropertyKey, any>;
+            signature: Signature;
+        };
+        [NotificationStatus.error]: {
+            message: SignatureMessage;
+            args: Record<PropertyKey, any>;
+            error: Error;
+        };
+    };
+}
+export interface NotificationBody<Topic extends NotificationTopic = NotificationTopic, Status extends NotificationStatus = NotificationStatus> {
+    id: string;
+    topic: Topic;
+    status: Status;
+}
+export type Notifications = {
+    [Topic in NotificationTopic]: {
+        [Status in NotificationStatus]: NotificationBody<Topic, Status> & (NotificationContext[Topic][Status] extends never ? unknown : {
+            context: NotificationContext[Topic][Status];
+        });
+    };
+};
+export type TxNotification = Notifications[NotificationTopic.tx][NotificationStatus];
+export type SignatureNotification = Notifications[NotificationTopic.signature][NotificationStatus];
+export type Notification = Notifications[NotificationTopic][NotificationStatus];
+export type NotificationsWithoutTopic = {
+    [Topic in NotificationTopic]: {
+        [Status in NotificationStatus]: Omit<NotificationBody<Topic, Status>, "topic"> & (NotificationContext[Topic][Status] extends never ? unknown : {
+            context: NotificationContext[Topic][Status];
+        });
+    };
+};
+export interface NotificationConsumer<Topic extends NotificationTopic> {
+    notifications$: Observable<Notifications[Topic][NotificationStatus]>;
+    wait: (observerOrNext?: Partial<Observer<Notifications[Topic][NotificationStatus]>> | ((value: Notifications[Topic][NotificationStatus]) => void)) => Promise<Notifications[Topic][NotificationStatus.success | NotificationStatus.error]>;
+}
+/**
+ * MUST receive a success or error notification at some point to ensure the result promise resolves.
+ */
+export declare class NotificationProducer<Topic extends NotificationTopic> {
+    readonly topic: Topic;
+    protected readonly _notifications$: ReplaySubject<Notifications[Topic][NotificationStatus]>;
+    readonly notifications$: Observable<Notifications[Topic][NotificationStatus]>;
+    protected readonly _result: Promise<Notifications[Topic][NotificationStatus]>;
+    readonly consumer: NotificationConsumer<Topic>;
+    /**
+     * Creates a notification producer.
+     * MUST receive a success or error notification at some point to ensure the result promise resolves.
+     * @param topic The notification topic to populate each notification with.
+     */
+    constructor(topic: Topic);
+    wait(observerOrNext?: Partial<Observer<Notifications[Topic][NotificationStatus]>> | ((value: Notifications[Topic][NotificationStatus]) => void)): Promise<Notifications[Topic][NotificationStatus.success | NotificationStatus.error]>;
+    next(notification: NotificationsWithoutTopic[Topic][NotificationStatus]): void;
+}

package/lib/notifications.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProducer = exports.NotificationTopic = exports.NotificationStatus = void 0;
+const rxjs_1 = require("rxjs");
+var NotificationStatus;
+(function (NotificationStatus) {
+    NotificationStatus["signing"] = "signing";
+    NotificationStatus["success"] = "success";
+    NotificationStatus["error"] = "error";
+    NotificationStatus["pending"] = "pending";
+})(NotificationStatus || (exports.NotificationStatus = NotificationStatus = {}));
+var NotificationTopic;
+(function (NotificationTopic) {
+    NotificationTopic["tx"] = "tx";
+    NotificationTopic["signature"] = "signature";
+})(NotificationTopic || (exports.NotificationTopic = NotificationTopic = {}));
+/**
+ * MUST receive a success or error notification at some point to ensure the result promise resolves.
+ */
+class NotificationProducer {
+    /**
+     * Creates a notification producer.
+     * MUST receive a success or error notification at some point to ensure the result promise resolves.
+     * @param topic The notification topic to populate each notification with.
+     */
+    constructor(topic) {
+        this.topic = topic;
+        this._notifications$ = new rxjs_1.ReplaySubject(Infinity);
+        this.notifications$ = this._notifications$.asObservable();
+        this._result = (0, rxjs_1.lastValueFrom)(this._notifications$);
+        this.consumer = {
+            notifications$: this.notifications$,
+            wait: this.wait.bind(this),
+        };
+    }
+    async wait(observerOrNext) {
+        const subscription = this.notifications$.subscribe(observerOrNext);
+        const notification = (await this._result);
+        subscription.unsubscribe();
+        return notification;
+    }
+    next(notification) {
+        this._notifications$.next({
+            ...notification,
+            topic: this.topic,
+        });
+        if (notification.status === NotificationStatus.success ||
+            notification.status === NotificationStatus.error)
+            this._notifications$.complete();
+    }
+}
+exports.NotificationProducer = NotificationProducer;

package/lib/position/Position.d.ts

@@ -0,0 +1,118 @@
+import { BigNumberish, Provider } from "ethers";
+import { ViewOverrides } from "ethers-types/dist/common";
+import { ChainId } from "../chain";
+import { Market, MarketConfig } from "../market";
+import { Address, MarketId } from "../types";
+export interface InputPosition {
+    user: Address;
+    marketId: MarketId;
+    supplyShares: BigNumberish;
+    borrowShares: BigNumberish;
+    collateral: BigNumberish;
+}
+export declare class Position implements InputPosition {
+    static fetch(user: Address, marketId: MarketId, runner: {
+        provider: Provider;
+    }, { chainId, overrides, }?: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<Position>;
+    /**
+     * The user holding this position.
+     */
+    readonly user: Address;
+    /**
+     * The id of the market on which this position is held.
+     */
+    readonly marketId: MarketId;
+    /**
+     * The amount of supply shares held with this position.
+     */
+    supplyShares: bigint;
+    /**
+     * The amount of borrow shares held with this position.
+     */
+    borrowShares: bigint;
+    /**
+     * The amount of collateral assets held with this position.
+     */
+    collateral: bigint;
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }: InputPosition);
+}
+export interface InputAccrualPosition extends Omit<InputPosition, "marketId"> {
+}
+export declare class AccrualPosition extends Position implements InputAccrualPosition {
+    static fetchFromId(user: Address, marketId: MarketId, runner: {
+        provider: Provider;
+    }, options: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<AccrualPosition>;
+    static fetchFromConfig(user: Address, config: MarketConfig, runner: {
+        provider: Provider;
+    }, options: {
+        chainId?: ChainId;
+        overrides?: ViewOverrides;
+    }): Promise<AccrualPosition>;
+    /**
+     * The market on which this position is held.
+     */
+    readonly market: Market;
+    constructor(position: InputAccrualPosition, market: Market);
+    get supplyAssets(): bigint;
+    get borrowAssets(): bigint;
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     */
+    get collateralValue(): bigint;
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowAssets(): bigint;
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowableAssets(): bigint;
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     */
+    get seizableCollateral(): bigint;
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     */
+    get withdrawableCollateral(): bigint;
+    /**
+     * Whether this position is healthy.
+     */
+    get isHealthy(): boolean;
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     */
+    get liquidationPrice(): bigint | null;
+    /**
+     * The variation of the price of the collateral quoted in loan assets that would allow this position to be liquidated,
+     * relative to the current collateral price (scaled by WAD).
+     */
+    get priceVariationToLiquidation(): bigint | null;
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     */
+    get ltv(): bigint | null;
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     */
+    get healthFactor(): bigint | null;
+    /**
+     * The percentage of this position's borrow power currently used (scaled by WAD).
+     * If the collateral price is 0, usage is `MaxUint256`.
+     */
+    get borrowCapacityUsage(): bigint | null;
+    get borrowCapacityLimit(): import("../market").CapacityLimit;
+    get withdrawCapacityLimit(): import("../market").CapacityLimit;
+    get withdrawCollateralCapacityLimit(): import("../market").CapacityLimit;
+    accrueInterest(timestamp: BigNumberish): AccrualPosition;
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market").CapacityLimit;
+    getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint): import("../market").MaxPositionCapacities;
+}

package/lib/position/Position.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccrualPosition = exports.Position = 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 market_1 = require("../market");
+class Position {
+    static async fetch(user, marketId, runner, { chainId, overrides = {}, } = {}) {
+        chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
+        const { morpho } = (0, addresses_1.getChainAddresses)(chainId);
+        const { supplyShares, borrowShares, collateral } = await ethers_types_1.MorphoBlue__factory.connect(morpho, runner).position(marketId, user, overrides);
+        return new Position({
+            user,
+            marketId,
+            supplyShares,
+            borrowShares,
+            collateral,
+        });
+    }
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }) {
+        this.user = user;
+        this.marketId = marketId;
+        this.supplyShares = (0, ethers_1.toBigInt)(supplyShares);
+        this.borrowShares = (0, ethers_1.toBigInt)(borrowShares);
+        this.collateral = (0, ethers_1.toBigInt)(collateral);
+    }
+}
+exports.Position = Position;
+class AccrualPosition extends Position {
+    static async fetchFromId(user, marketId, runner, options) {
+        const [position, market] = await Promise.all([
+            await Position.fetch(user, marketId, runner, options),
+            await market_1.Market.fetchFromId(marketId, runner, options),
+        ]);
+        return new AccrualPosition(position, market);
+    }
+    static async fetchFromConfig(user, config, runner, options) {
+        const [position, market] = await Promise.all([
+            await Position.fetch(user, config.id, runner, options),
+            await market_1.Market.fetchFromConfig(config, runner, options),
+        ]);
+        return new AccrualPosition(position, market);
+    }
+    constructor(position, market) {
+        super({ ...position, marketId: market.id });
+        this.market = market;
+    }
+    get supplyAssets() {
+        return this.market.toSupplyAssets(this.supplyShares);
+    }
+    get borrowAssets() {
+        return this.market.toBorrowAssets(this.borrowShares);
+    }
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     */
+    get collateralValue() {
+        return this.market.getCollateralValue(this.collateral);
+    }
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowAssets() {
+        return this.market.getMaxBorrowAssets(this.collateral);
+    }
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     */
+    get maxBorrowableAssets() {
+        return this.market.getMaxBorrowableAssets(this);
+    }
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     */
+    get seizableCollateral() {
+        return this.market.getSeizableCollateral(this);
+    }
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     */
+    get withdrawableCollateral() {
+        return this.market.getWithdrawableCollateral(this);
+    }
+    /**
+     * Whether this position is healthy.
+     */
+    get isHealthy() {
+        return this.market.isHealthy(this);
+    }
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     */
+    get liquidationPrice() {
+        return this.market.getLiquidationPrice(this);
+    }
+    /**
+     * The variation of the price of the collateral quoted in loan assets that would allow this position to be liquidated,
+     * relative to the current collateral price (scaled by WAD).
+     */
+    get priceVariationToLiquidation() {
+        return this.market.getPriceVariationToLiquidation(this);
+    }
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     */
+    get ltv() {
+        return this.market.getLtv(this);
+    }
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     */
+    get healthFactor() {
+        return this.market.getHealthFactor(this);
+    }
+    /**
+     * The percentage of this position's borrow power currently used (scaled by WAD).
+     * If the collateral price is 0, usage is `MaxUint256`.
+     */
+    get borrowCapacityUsage() {
+        return this.market.getBorrowCapacityUsage(this);
+    }
+    get borrowCapacityLimit() {
+        return this.market.getBorrowCapacityLimit(this.collateral);
+    }
+    get withdrawCapacityLimit() {
+        return this.market.getWithdrawCapacityLimit(this.supplyShares);
+    }
+    get withdrawCollateralCapacityLimit() {
+        return this.market.getWithdrawCollateralCapacityLimit(this);
+    }
+    accrueInterest(timestamp) {
+        return new AccrualPosition(this, this.market.accrueInterest(timestamp));
+    }
+    getRepayCapacityLimit(loanTokenBalance) {
+        return this.market.getRepayCapacityLimit(this.borrowShares, loanTokenBalance);
+    }
+    getMaxCapacities(loanTokenBalance, collateralTokenBalance) {
+        return this.market.getMaxCapacities(this, loanTokenBalance, collateralTokenBalance);
+    }
+}
+exports.AccrualPosition = AccrualPosition;