@morpho-org/blue-sdk 5.16.0 → 5.17.0

package/lib/esm/market/index.js

@@ -0,0 +1,3 @@
+export * from "./MarketUtils.js";
+export * from "./MarketParams.js";
+export * from "./Market.js";

package/lib/esm/math/AdaptiveCurveIrmLib.d.ts

@@ -0,0 +1,40 @@
+import type { BigIntish } from "../types.js";
+/**
+ * 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.
+ */
+export declare namespace AdaptiveCurveIrmLib {
+    const CURVE_STEEPNESS = 4000000000000000000n;
+    const TARGET_UTILIZATION = 900000000000000000n;
+    const INITIAL_RATE_AT_TARGET: bigint;
+    const ADJUSTMENT_SPEED: bigint;
+    const MIN_RATE_AT_TARGET: bigint;
+    const MAX_RATE_AT_TARGET: bigint;
+    /**
+     * ln(2), scaled by WAD.
+     */
+    const LN_2_INT = 693147180559945309n;
+    /**
+     * ln(1e-18), scaled by WAD.
+     */
+    const 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).
+     */
+    const WEXP_UPPER_BOUND = 93859467695000404319n;
+    /**
+     * The value of wExp(`WEXP_UPPER_BOUND`).
+     */
+    const WEXP_UPPER_VALUE = 57716089161558943949701069502944508345128422502756744429568n;
+    /**
+     * Returns an approximation of exp(x) used by the Adaptive Curve IRM.
+     * @param x
+     */
+    function wExp(x: BigIntish): bigint;
+    function getBorrowRate(startUtilization: BigIntish, startRateAtTarget: BigIntish, elapsed: BigIntish): {
+        avgBorrowRate: bigint;
+        endBorrowRate: bigint;
+        endRateAtTarget: bigint;
+    };
+    function getUtilizationAtBorrowRate(borrowRate: BigIntish, rateAtTarget: BigIntish): bigint;
+}

package/lib/esm/math/AdaptiveCurveIrmLib.js

@@ -0,0 +1,133 @@
+import { SECONDS_PER_YEAR } from "../constants.js";
+import { MathLib } from "./MathLib.js";
+/**
+ * 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.
+ */
+export var AdaptiveCurveIrmLib;
+(function (AdaptiveCurveIrmLib) {
+    AdaptiveCurveIrmLib.CURVE_STEEPNESS = 4000000000000000000n;
+    AdaptiveCurveIrmLib.TARGET_UTILIZATION = 900000000000000000n;
+    AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET = 40000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.ADJUSTMENT_SPEED = 50000000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET = 1000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET = 2000000000000000000n / 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.WAD + r + (r * r) / 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.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            : AdaptiveCurveIrmLib.TARGET_UTILIZATION;
+        const err = 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.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.min(MathLib.max(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.WAD - MathLib.wDivDown(MathLib.WAD, AdaptiveCurveIrmLib.CURVE_STEEPNESS)
+            : AdaptiveCurveIrmLib.CURVE_STEEPNESS - MathLib.WAD;
+        const _curve = (rateAtTarget) => MathLib.wMulDown(MathLib.wMulDown(coeff, err) + MathLib.WAD, rateAtTarget);
+        // Non negative if avgRateAtTarget >= 0 because if err < 0, coeff <= 1.
+        return {
+            avgBorrowRate: _curve(avgRateAtTarget),
+            endBorrowRate: _curve(endRateAtTarget),
+            endRateAtTarget,
+        };
+    }
+    AdaptiveCurveIrmLib.getBorrowRate = getBorrowRate;
+    function getUtilizationAtBorrowRate(borrowRate, rateAtTarget) {
+        borrowRate = BigInt(borrowRate);
+        rateAtTarget = BigInt(rateAtTarget);
+        if (borrowRate >= rateAtTarget) {
+            const maxBorrowRate = MathLib.wMulDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+            const diffToMaxBorrowRate = maxBorrowRate - rateAtTarget;
+            if (diffToMaxBorrowRate === 0n)
+                return MathLib.WAD;
+            return MathLib.min(MathLib.WAD, AdaptiveCurveIrmLib.TARGET_UTILIZATION +
+                MathLib.mulDivDown(MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - rateAtTarget, diffToMaxBorrowRate));
+        }
+        const minBorrowRate = MathLib.wDivDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+        return MathLib.max(0n, MathLib.mulDivDown(AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - minBorrowRate, rateAtTarget - minBorrowRate));
+    }
+    AdaptiveCurveIrmLib.getUtilizationAtBorrowRate = getUtilizationAtBorrowRate;
+})(AdaptiveCurveIrmLib || (AdaptiveCurveIrmLib = {}));

package/lib/esm/math/MathLib.d.ts

@@ -0,0 +1,102 @@
+import type { BigIntish } from "../types.js";
+export type RoundingDirection = "Up" | "Down";
+/**
+ * Library to manage fixed-point arithmetic.
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
+ */
+export declare namespace MathLib {
+    const WAD = 1000000000000000000n;
+    const RAY = 1000000000000000000000000000n;
+    const MAX_UINT_256: bigint;
+    const MAX_UINT_160: bigint;
+    const MAX_UINT_128: bigint;
+    const MAX_UINT_48: bigint;
+    function maxUint(nBits: number): bigint;
+    /**
+     * Returns the absolute value of a number
+     * @param a The number
+     */
+    function abs(a: BigIntish): bigint;
+    /**
+     * Returns the smallest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function min(...xs: BigIntish[]): bigint;
+    /**
+     * Returns the greatest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function 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
+     */
+    function mulDivUp(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    function 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 continuously compounded interest rate.
+     *
+     * @param x The base of the exponent
+     * @param n The exponent
+     */
+    function wTaylorCompounded(x: BigIntish, n: BigIntish): bigint;
+    /**
+     * Converts a WAD-based quantity to a RAY-based quantity.
+     * @param x The WAD-based quantity.
+     */
+    function wToRay(x: BigIntish): bigint;
+}

package/lib/esm/math/MathLib.js

@@ -0,0 +1,168 @@
+/**
+ * Library to manage fixed-point arithmetic.
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
+ */
+export var MathLib;
+(function (MathLib) {
+    MathLib.WAD = 1000000000000000000n;
+    MathLib.RAY = 1000000000000000000000000000n;
+    MathLib.MAX_UINT_256 = maxUint(256);
+    MathLib.MAX_UINT_160 = maxUint(160);
+    MathLib.MAX_UINT_128 = maxUint(128);
+    MathLib.MAX_UINT_48 = maxUint(48);
+    function maxUint(nBits) {
+        if (nBits % 4 !== 0)
+            throw new Error(`Invalid number of bits: ${nBits}`);
+        return BigInt(`0x${"f".repeat(nBits / 4)}`);
+    }
+    MathLib.maxUint = maxUint;
+    /**
+     * Returns the absolute value of a number
+     * @param a The number
+     */
+    function abs(a) {
+        a = BigInt(a);
+        return a >= 0 ? a : -a;
+    }
+    MathLib.abs = abs;
+    /**
+     * Returns the smallest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function min(...xs) {
+        return xs.map(BigInt).reduce((x, y) => (x <= y ? x : y));
+    }
+    MathLib.min = min;
+    /**
+     * Returns the greatest number given as param
+     * @param x The first number
+     * @param y The second number
+     */
+    function max(...xs) {
+        return xs.map(BigInt).reduce((x, y) => (x <= y ? y : x));
+    }
+    MathLib.max = max;
+    /**
+     * Returns the subtraction of b from a, floored to zero if negative
+     * @param x The first number
+     * @param y The second number
+     */
+    function zeroFloorSub(x, y) {
+        x = BigInt(x);
+        y = BigInt(y);
+        return x <= y ? 0n : x - y;
+    }
+    MathLib.zeroFloorSub = zeroFloorSub;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMulDown(x, y) {
+        return MathLib.wMul(x, y, "Down");
+    }
+    MathLib.wMulDown = wMulDown;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMulUp(x, y) {
+        return MathLib.wMul(x, y, "Up");
+    }
+    MathLib.wMulUp = wMulUp;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    function wMul(x, y, rounding) {
+        return MathLib.mulDiv(x, y, MathLib.WAD, rounding);
+    }
+    MathLib.wMul = wMul;
+    /**
+     * Perform the WAD-based division of 2 numbers, rounded down
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDivDown(x, y) {
+        return MathLib.wDiv(x, y, "Down");
+    }
+    MathLib.wDivDown = wDivDown;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers, rounded up
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDivUp(x, y) {
+        return MathLib.wDiv(x, y, "Up");
+    }
+    MathLib.wDivUp = wDivUp;
+    /**
+     * Perform the WAD-based multiplication of 2 numbers with a provided rounding direction
+     * @param x The first number
+     * @param y The second number
+     */
+    function wDiv(x, y, rounding) {
+        return MathLib.mulDiv(x, MathLib.WAD, y, rounding);
+    }
+    MathLib.wDiv = wDiv;
+    /**
+     * 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
+     */
+    function 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;
+    }
+    MathLib.mulDivDown = mulDivDown;
+    /**
+     * 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
+     */
+    function 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;
+    }
+    MathLib.mulDivUp = mulDivUp;
+    function mulDiv(x, y, denominator, rounding) {
+        return MathLib[`mulDiv${rounding}`](x, y, denominator);
+    }
+    MathLib.mulDiv = mulDiv;
+    /**
+     * The sum of the first three non-zero terms of a Taylor expansion of e^(nx) - 1,
+     * to approximate a continuously compounded interest rate.
+     *
+     * @param x The base of the exponent
+     * @param n The exponent
+     */
+    function 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;
+    }
+    MathLib.wTaylorCompounded = wTaylorCompounded;
+    /**
+     * Converts a WAD-based quantity to a RAY-based quantity.
+     * @param x The WAD-based quantity.
+     */
+    function wToRay(x) {
+        return BigInt(x) * 1000000000n;
+    }
+    MathLib.wToRay = wToRay;
+})(MathLib || (MathLib = {}));

package/lib/esm/math/SharesMath.d.ts

@@ -0,0 +1,12 @@
+import type { BigIntish } from "../types.js";
+import { type RoundingDirection } from "./MathLib.js";
+/**
+ * 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/esm/math/SharesMath.js

@@ -0,0 +1,18 @@
+import { MathLib } from "./MathLib.js";
+/**
+ * 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 var SharesMath;
+(function (SharesMath) {
+    SharesMath.VIRTUAL_SHARES = 1000000n;
+    SharesMath.VIRTUAL_ASSETS = 1n;
+    function toAssets(shares, totalAssets, totalShares, rounding) {
+        return 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.mulDiv(assets, BigInt(totalShares) + SharesMath.VIRTUAL_SHARES, BigInt(totalAssets) + SharesMath.VIRTUAL_ASSETS, rounding);
+    }
+    SharesMath.toShares = toShares;
+})(SharesMath || (SharesMath = {}));

package/lib/esm/math/index.d.ts

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

package/lib/esm/math/index.js

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

package/lib/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/esm/position/Position.d.ts

@@ -0,0 +1,147 @@
+import { type IMarket, Market, type MaxBorrowOptions, type MaxPositionCapacities, type MaxWithdrawCollateralOptions } from "../market/index.js";
+import type { Address, BigIntish, MarketId } from "../types.js";
+export interface IPosition {
+    user: Address;
+    marketId: MarketId;
+    supplyShares: bigint;
+    borrowShares: bigint;
+    collateral: bigint;
+}
+export declare class Position implements IPosition {
+    /**
+     * 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, }: IPosition);
+}
+export interface IAccrualPosition extends Omit<IPosition, "marketId"> {
+}
+export declare class AccrualPosition extends Position implements IAccrualPosition {
+    protected readonly _market: Market;
+    constructor(position: IAccrualPosition, market: IMarket);
+    /**
+     * The market on which this position is held.
+     */
+    get market(): Market;
+    get supplyAssets(): bigint;
+    get borrowAssets(): bigint;
+    /**
+     * The value of this position's collateral quoted in loan assets.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get collateralValue(): bigint | undefined;
+    /**
+     * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get maxBorrowAssets(): bigint | undefined;
+    /**
+     * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get maxBorrowableAssets(): bigint | undefined;
+    /**
+     * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get seizableCollateral(): bigint | undefined;
+    /**
+     * The maximum amount of collateral that can be withdrawn.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get withdrawableCollateral(): bigint | undefined;
+    /**
+     * Whether this position is healthy.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get isHealthy(): boolean | undefined;
+    /**
+     * Whether this position can be liquidated.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get isLiquidatable(): boolean | undefined;
+    /**
+     * The price of the collateral quoted in loan assets that would allow this position to be liquidated.
+     * `null` if the position has no borrow.
+     */
+    get liquidationPrice(): bigint | null;
+    /**
+     * The price variation required for the position to reach its liquidation threshold (scaled by WAD).
+     * Negative when healthy (the price needs to drop x%), positive when unhealthy (the price needs to soar x%).
+     * `undefined` if the market's oracle is undefined or reverts.
+     * `null` if the position is not a borrow.
+     */
+    get priceVariationToLiquidationPrice(): bigint | null | undefined;
+    /**
+     * This position's Loan-To-Value (debt over collateral power, scaled by WAD).
+     * If the collateral price is 0, LTV is `MaxUint256`.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get ltv(): bigint | null | undefined;
+    /**
+     * This position's health factor (collateral power over debt, scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     * `undefined` if the market's oracle is undefined or reverts.
+     */
+    get healthFactor(): bigint | undefined;
+    /**
+     * 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 | undefined;
+    /**
+     * 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.
+     */
+    get withdrawCapacityLimit(): import("../utils.js").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;
+    };
+    getBorrowCapacityLimit(options?: MaxBorrowOptions): import("../utils.js").CapacityLimit | undefined;
+    getWithdrawCollateralCapacityLimit(options?: MaxWithdrawCollateralOptions): import("../utils.js").CapacityLimit | undefined;
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../utils.js").CapacityLimit;
+    getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint, options?: {
+        borrow?: MaxBorrowOptions;
+        withdrawCollateral?: MaxWithdrawCollateralOptions;
+    }): MaxPositionCapacities;
+}