@morpho-org/blue-sdk 2.0.0-alpha.5 → 2.0.0-next.1

package/lib/maths/AdaptiveCurveIrmLib.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveCurveIrmLib = void 0;
-const constants_1 = require("../constants");
-const MathLib_1 = require("./MathLib");
-/**
- * JS implementation of {@link https://github.com/morpho-org/morpho-blue-irm/blob/main/src/libraries/adaptive-curve/ExpLib.sol ExpLib} used by the Adaptive Curve IRM.
- */
-var AdaptiveCurveIrmLib;
-(function (AdaptiveCurveIrmLib) {
-    AdaptiveCurveIrmLib.CURVE_STEEPNESS = 4000000000000000000n;
-    AdaptiveCurveIrmLib.TARGET_UTILIZATION = 900000000000000000n;
-    AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET = 40000000000000000n / constants_1.SECONDS_PER_YEAR;
-    AdaptiveCurveIrmLib.ADJUSTMENT_SPEED = 50000000000000000000n / constants_1.SECONDS_PER_YEAR;
-    AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET = 1000000000000000n / constants_1.SECONDS_PER_YEAR;
-    AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET = 2000000000000000000n / constants_1.SECONDS_PER_YEAR;
-    /**
-     * ln(2), scaled by WAD.
-     */
-    AdaptiveCurveIrmLib.LN_2_INT = 693147180559945309n;
-    /**
-     * ln(1e-18), scaled by WAD.
-     */
-    AdaptiveCurveIrmLib.LN_WEI_INT = -41446531673892822312n;
-    /**
-     * Above this bound, `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
-     * This upper bound corresponds to: ln(type(int256).max / 1e36) (scaled by WAD, floored).
-     */
-    AdaptiveCurveIrmLib.WEXP_UPPER_BOUND = 93859467695000404319n;
-    /**
-     * The value of wExp(`WEXP_UPPER_BOUND`).
-     */
-    AdaptiveCurveIrmLib.WEXP_UPPER_VALUE = 57716089161558943949701069502944508345128422502756744429568n;
-    /**
-     * Returns an approximation of exp(x) used by the Adaptive Curve IRM.
-     * @param x
-     */
-    function wExp(x) {
-        x = BigInt(x);
-        // If x < ln(1e-18) then exp(x) < 1e-18 so it is rounded to zero.
-        if (x < AdaptiveCurveIrmLib.LN_WEI_INT)
-            return 0n;
-        // `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
-        if (x >= AdaptiveCurveIrmLib.WEXP_UPPER_BOUND)
-            return AdaptiveCurveIrmLib.WEXP_UPPER_VALUE;
-        // Decompose x as x = q * ln(2) + r with q an integer and -ln(2)/2 <= r <= ln(2)/2.
-        // q = x / ln(2) rounded half toward zero.
-        const roundingAdjustment = x < 0n ? -(AdaptiveCurveIrmLib.LN_2_INT / 2n) : AdaptiveCurveIrmLib.LN_2_INT / 2n;
-        const q = (x + roundingAdjustment) / AdaptiveCurveIrmLib.LN_2_INT;
-        const r = x - q * AdaptiveCurveIrmLib.LN_2_INT;
-        // Compute e^r with a 2nd-order Taylor polynomial.
-        const expR = MathLib_1.MathLib.WAD + r + (r * r) / MathLib_1.MathLib.WAD / 2n;
-        // Return e^x = 2^q * e^r.
-        if (q === 0n)
-            return expR << q;
-        return expR >> -q;
-    }
-    AdaptiveCurveIrmLib.wExp = wExp;
-    function getBorrowRate(startUtilization, startRateAtTarget, elapsed) {
-        startUtilization = BigInt(startUtilization);
-        startRateAtTarget = BigInt(startRateAtTarget);
-        elapsed = BigInt(elapsed);
-        const errNormFactor = startUtilization > AdaptiveCurveIrmLib.TARGET_UTILIZATION
-            ? MathLib_1.MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
-            : AdaptiveCurveIrmLib.TARGET_UTILIZATION;
-        const err = MathLib_1.MathLib.wDivDown(startUtilization - AdaptiveCurveIrmLib.TARGET_UTILIZATION, errNormFactor);
-        let avgRateAtTarget;
-        let endRateAtTarget;
-        if (startRateAtTarget === 0n) {
-            // First interaction.
-            avgRateAtTarget = AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET;
-            endRateAtTarget = AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET;
-        }
-        else {
-            // The speed is assumed constant between two updates, but it is in fact not constant because of interest.
-            // So the rate is always underestimated.
-            const speed = MathLib_1.MathLib.wMulDown(AdaptiveCurveIrmLib.ADJUSTMENT_SPEED, err);
-            const linearAdaptation = speed * elapsed;
-            if (linearAdaptation === 0n) {
-                // If linearAdaptation == 0, avgRateAtTarget = endRateAtTarget = startRateAtTarget;
-                avgRateAtTarget = startRateAtTarget;
-                endRateAtTarget = startRateAtTarget;
-            }
-            else {
-                // Non negative because MIN_RATE_AT_TARGET > 0.
-                const _newRateAtTarget = (linearAdaptation) => MathLib_1.MathLib.min(MathLib_1.MathLib.max(MathLib_1.MathLib.wMulDown(startRateAtTarget, wExp(linearAdaptation)), AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET), AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET);
-                // Formula of the average rate that should be returned to Morpho Blue:
-                // avg = 1/T * ∫_0^T curve(startRateAtTarget*exp(speed*x), err) dx
-                // The integral is approximated with the trapezoidal rule:
-                // avg ~= 1/T * Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / 2 * T/N
-                // Where f(x) = startRateAtTarget*exp(speed*x)
-                // avg ~= Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / (2 * N)
-                // As curve is linear in its first argument:
-                // avg ~= curve([Σ_i=1^N [f((i-1) * T/N) + f(i * T/N)] / (2 * N), err)
-                // avg ~= curve([(f(0) + f(T))/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
-                // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
-                // With N = 2:
-                // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + startRateAtTarget*exp(speed*T/2)] / 2, err)
-                // avg ~= curve([startRateAtTarget + endRateAtTarget + 2*startRateAtTarget*exp(speed*T/2)] / 4, err)
-                endRateAtTarget = _newRateAtTarget(linearAdaptation);
-                avgRateAtTarget =
-                    (startRateAtTarget +
-                        endRateAtTarget +
-                        2n * _newRateAtTarget(linearAdaptation / 2n)) /
-                        4n;
-            }
-        }
-        // Non negative because 1 - 1/C >= 0, C - 1 >= 0.
-        const coeff = err < 0
-            ? MathLib_1.MathLib.WAD - MathLib_1.MathLib.wDivDown(MathLib_1.MathLib.WAD, AdaptiveCurveIrmLib.CURVE_STEEPNESS)
-            : AdaptiveCurveIrmLib.CURVE_STEEPNESS - MathLib_1.MathLib.WAD;
-        // Non negative if avgRateAtTarget >= 0 because if err < 0, coeff <= 1.
-        return {
-            avgBorrowRate: MathLib_1.MathLib.wMulDown(MathLib_1.MathLib.wMulDown(coeff, err) + MathLib_1.MathLib.WAD, avgRateAtTarget),
-            endRateAtTarget,
-        };
-    }
-    AdaptiveCurveIrmLib.getBorrowRate = getBorrowRate;
-    function getUtilizationAtBorrowRate(borrowRate, rateAtTarget) {
-        borrowRate = BigInt(borrowRate);
-        rateAtTarget = BigInt(rateAtTarget);
-        if (borrowRate >= rateAtTarget) {
-            const maxBorrowRate = MathLib_1.MathLib.wMulDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
-            const diffToMaxBorrowRate = maxBorrowRate - rateAtTarget;
-            if (diffToMaxBorrowRate === 0n)
-                return MathLib_1.MathLib.WAD;
-            return MathLib_1.MathLib.min(MathLib_1.MathLib.WAD, AdaptiveCurveIrmLib.TARGET_UTILIZATION +
-                MathLib_1.MathLib.mulDivDown(MathLib_1.MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - rateAtTarget, diffToMaxBorrowRate));
-        }
-        const minBorrowRate = MathLib_1.MathLib.wDivDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
-        return MathLib_1.MathLib.max(0n, MathLib_1.MathLib.mulDivDown(AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - minBorrowRate, rateAtTarget - minBorrowRate));
-    }
-    AdaptiveCurveIrmLib.getUtilizationAtBorrowRate = getUtilizationAtBorrowRate;
-})(AdaptiveCurveIrmLib || (exports.AdaptiveCurveIrmLib = AdaptiveCurveIrmLib = {}));

package/lib/maths/MathLib.d.ts

@@ -1,114 +0,0 @@
-import { Time } from "@morpho-org/morpho-ts";
-import { BigIntish } from "../types";
-export type RoundingDirection = "Up" | "Down";
-/**
- * Library to manage fixed-point arithmetic.
- * This library reproduces the behaviour of the solidity library MathLib
- * TODO: add library link
- * @category Maths
- *
- */
-export declare class MathLib {
-    static WAD: bigint;
-    static MAX_UINT_256: bigint;
-    static MAX_UINT_160: bigint;
-    static MAX_UINT_128: bigint;
-    static MAX_UINT_48: bigint;
-    static maxUint(nBits: number): bigint;
-    /**
-     * Returns the absolute value of a number
-     * @param a The number
-     */
-    static abs(a: BigIntish): bigint;
-    /**
-     * Returns the smallest number given as param
-     * @param x The first number
-     * @param y The second number
-     */
-    static min(...xs: BigIntish[]): bigint;
-    /**
-     * Returns the greatest number given as param
-     * @param x The first number
-     * @param y The second number
-     */
-    static max(...xs: BigIntish[]): bigint;
-    /**
-     * Returns the subtraction of b from a, floored to zero if negative
-     * @param x The first number
-     * @param y The second number
-     */
-    static zeroFloorSub(x: BigIntish, y: BigIntish): bigint;
-    /**
-     * Perform the WAD-based multiplication of 2 numbers, rounded down
-     * @param x The first number
-     * @param y The second number
-     */
-    static wMulDown(x: BigIntish, y: BigIntish): bigint;
-    /**
-     * Perform the WAD-based multiplication of 2 numbers, rounded up
-     * @param x The first number
-     * @param y The second number
-     */
-    static wMulUp(x: BigIntish, y: BigIntish): bigint;
-    /**
-     * 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: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
-    /**
-     * Perform the WAD-based division of 2 numbers, rounded down
-     * @param x The first number
-     * @param y The second number
-     */
-    static wDivDown(x: BigIntish, y: BigIntish): bigint;
-    /**
-     * Perform the WAD-based multiplication of 2 numbers, rounded up
-     * @param x The first number
-     * @param y The second number
-     */
-    static wDivUp(x: BigIntish, y: BigIntish): bigint;
-    /**
-     * 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: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
-    /**
-     * 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: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
-    /**
-     * 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: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
-    static mulDiv(x: BigIntish, y: BigIntish, denominator: BigIntish, rounding: RoundingDirection): bigint;
-    /**
-     * 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: BigIntish, n: BigIntish): bigint;
-    /**
-     * Converts an rate to compounded apy
-     *
-     * @param rate The rate to convert (in WAD)
-     * @param period The compounding basis
-     */
-    static rateToApy(rate: BigIntish, period: Time.PeriodLike): number;
-    /**
-     * Converts an apr to compounded apy
-     *
-     * @param apr The apr to convert (in WAD)
-     * @param compounding The compounding basis
-     */
-    static aprToApy(apr: BigIntish, compounding: Time.PeriodLike): number;
-}

package/lib/maths/MathLib.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathLib = void 0;
-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 {
-    static WAD = 1000000000000000000n;
-    static MAX_UINT_256 = MathLib.maxUint(256);
-    static MAX_UINT_160 = MathLib.maxUint(160);
-    static MAX_UINT_128 = MathLib.maxUint(128);
-    static MAX_UINT_48 = MathLib.maxUint(48);
-    static maxUint(nBits) {
-        if (nBits % 4 !== 0)
-            throw new Error(`Invalid number of bits: ${nBits}`);
-        return BigInt("0x" + "f".repeat(nBits / 4));
-    }
-    /**
-     * Returns the absolute value of a number
-     * @param a The number
-     */
-    static abs(a) {
-        a = BigInt(a);
-        return a >= 0 ? a : -a;
-    }
-    /**
-     * Returns the smallest number given as param
-     * @param x The first number
-     * @param y The second number
-     */
-    static min(...xs) {
-        return xs.map(BigInt).reduce((x, y) => (x <= y ? x : y));
-    }
-    /**
-     * Returns the greatest number given as param
-     * @param x The first number
-     * @param y The second number
-     */
-    static max(...xs) {
-        return xs.map(BigInt).reduce((x, y) => (x <= y ? y : x));
-    }
-    /**
-     * Returns the subtraction of b from a, floored to zero if negative
-     * @param x The first number
-     * @param y The second number
-     */
-    static zeroFloorSub(x, y) {
-        x = BigInt(x);
-        y = BigInt(y);
-        return x <= y ? 0n : x - y;
-    }
-    /**
-     * Perform the WAD-based multiplication of 2 numbers, rounded down
-     * @param x The first number
-     * @param y The second number
-     */
-    static wMulDown(x, 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) {
-        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) {
-        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) {
-        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 = BigInt(x);
-        y = BigInt(y);
-        denominator = BigInt(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 = BigInt(x);
-        y = BigInt(y);
-        denominator = BigInt(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) {
-        const firstTerm = BigInt(x) * BigInt(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 rate to compounded apy
-     *
-     * @param rate The rate to convert (in WAD)
-     * @param period The compounding basis
-     */
-    static rateToApy(rate, period) {
-        const { unit, duration } = morpho_ts_1.Time.toPeriod(period);
-        const factor = morpho_ts_1.Time[unit].from.y(1) / duration;
-        return ((1 + Number(morpho_ts_1.format.number.locale("en").of(BigInt(rate), 18))) ** factor -
-            1);
-    }
-    /**
-     * Converts an apr to compounded apy
-     *
-     * @param apr The apr to convert (in WAD)
-     * @param compounding The compounding basis
-     */
-    static aprToApy(apr, compounding) {
-        const { unit, duration } = morpho_ts_1.Time.toPeriod(compounding);
-        const rate = (BigInt(apr) * BigInt(duration)) / morpho_ts_1.Time[unit].from.y(1n);
-        return this.rateToApy(rate, compounding);
-    }
-}
-exports.MathLib = MathLib;

package/lib/maths/SharesMath.d.ts

@@ -1,12 +0,0 @@
-import { BigIntish } from "../types";
-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: BigIntish, totalAssets: BigIntish, totalShares: BigIntish, rounding: RoundingDirection): bigint;
-    function toShares(assets: BigIntish, totalAssets: BigIntish, totalShares: BigIntish, rounding: RoundingDirection): bigint;
-}

package/lib/maths/SharesMath.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharesMath = void 0;
-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, BigInt(totalAssets) + SharesMath.VIRTUAL_ASSETS, BigInt(totalShares) + SharesMath.VIRTUAL_SHARES, rounding);
-    }
-    SharesMath.toAssets = toAssets;
-    function toShares(assets, totalAssets, totalShares, rounding) {
-        return MathLib_1.MathLib.mulDiv(assets, BigInt(totalShares) + SharesMath.VIRTUAL_SHARES, BigInt(totalAssets) + SharesMath.VIRTUAL_ASSETS, rounding);
-    }
-    SharesMath.toShares = toShares;
-})(SharesMath || (exports.SharesMath = SharesMath = {}));

package/lib/maths/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./MathLib";
-export * from "./SharesMath";
-export * from "./AdaptiveCurveIrmLib";

package/lib/maths/index.js

@@ -1,19 +0,0 @@
-"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("./AdaptiveCurveIrmLib"), exports);

package/lib/position/Position.d.ts

@@ -1,126 +0,0 @@
-import { Market, MaxBorrowOptions, MaxWithdrawCollateralOptions } from "../market";
-import { Address, BigIntish, MarketId } from "../types";
-export interface InputPosition {
-    user: Address;
-    marketId: MarketId;
-    supplyShares: bigint;
-    borrowShares: bigint;
-    collateral: bigint;
-}
-export declare class Position implements InputPosition {
-    /**
-     * 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 {
-    /**
-     * 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;
-    /**
-     * Returns a new position derived from this position, 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 the market's `lastUpdate`.
-     */
-    accrueInterest(timestamp?: BigIntish): AccrualPosition;
-    supply(assets: bigint, shares: bigint, timestamp?: BigIntish): {
-        position: AccrualPosition;
-        assets: bigint;
-        shares: bigint;
-    };
-    withdraw(assets: bigint, shares: bigint, timestamp?: BigIntish): {
-        position: AccrualPosition;
-        assets: bigint;
-        shares: bigint;
-    };
-    supplyCollateral(assets: bigint): AccrualPosition;
-    withdrawCollateral(assets: bigint, timestamp?: BigIntish): AccrualPosition;
-    borrow(assets: bigint, shares: bigint, timestamp?: BigIntish): {
-        position: AccrualPosition;
-        assets: bigint;
-        shares: bigint;
-    };
-    repay(assets: bigint, shares: bigint, timestamp?: BigIntish): {
-        position: AccrualPosition;
-        assets: bigint;
-        shares: bigint;
-    };
-    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market").CapacityLimit;
-    getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint, options?: {
-        borrow?: MaxBorrowOptions;
-        withdrawCollateral?: MaxWithdrawCollateralOptions;
-    }): import("../market").MaxPositionCapacities;
-}