@morpho-org/blue-sdk 2.0.0-test.1 → 2.0.0

package/lib/{maths → math}/AdaptiveCurveIrmLib.d.ts

@@ -1,4 +1,4 @@
-import { BigIntish } from "../types";
+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.
  */

package/lib/{maths → math}/AdaptiveCurveIrmLib.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdaptiveCurveIrmLib = void 0;
-const constants_1 = require("../constants");
-const MathLib_1 = require("./MathLib");
+const constants_js_1 = require("../constants.js");
+const MathLib_js_1 = require("./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.
  */
@@ -10,10 +10,10 @@ 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;
+    AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET = 40000000000000000n / constants_js_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.ADJUSTMENT_SPEED = 50000000000000000000n / constants_js_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET = 1000000000000000n / constants_js_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET = 2000000000000000000n / constants_js_1.SECONDS_PER_YEAR;
     /**
      * ln(2), scaled by WAD.
      */
@@ -49,7 +49,7 @@ var AdaptiveCurveIrmLib;
         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;
+        const expR = MathLib_js_1.MathLib.WAD + r + (r * r) / MathLib_js_1.MathLib.WAD / 2n;
         // Return e^x = 2^q * e^r.
         if (q === 0n)
             return expR << q;
@@ -61,9 +61,9 @@ var AdaptiveCurveIrmLib;
         startRateAtTarget = BigInt(startRateAtTarget);
         elapsed = BigInt(elapsed);
         const errNormFactor = startUtilization > AdaptiveCurveIrmLib.TARGET_UTILIZATION
-            ? MathLib_1.MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            ? MathLib_js_1.MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
             : AdaptiveCurveIrmLib.TARGET_UTILIZATION;
-        const err = MathLib_1.MathLib.wDivDown(startUtilization - AdaptiveCurveIrmLib.TARGET_UTILIZATION, errNormFactor);
+        const err = MathLib_js_1.MathLib.wDivDown(startUtilization - AdaptiveCurveIrmLib.TARGET_UTILIZATION, errNormFactor);
         let avgRateAtTarget;
         let endRateAtTarget;
         if (startRateAtTarget === 0n) {
@@ -74,7 +74,7 @@ var AdaptiveCurveIrmLib;
         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 speed = MathLib_js_1.MathLib.wMulDown(AdaptiveCurveIrmLib.ADJUSTMENT_SPEED, err);
             const linearAdaptation = speed * elapsed;
             if (linearAdaptation === 0n) {
                 // If linearAdaptation == 0, avgRateAtTarget = endRateAtTarget = startRateAtTarget;
@@ -83,7 +83,7 @@ var AdaptiveCurveIrmLib;
             }
             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);
+                const _newRateAtTarget = (linearAdaptation) => MathLib_js_1.MathLib.min(MathLib_js_1.MathLib.max(MathLib_js_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:
@@ -107,11 +107,11 @@ var AdaptiveCurveIrmLib;
         }
         // 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;
+            ? MathLib_js_1.MathLib.WAD - MathLib_js_1.MathLib.wDivDown(MathLib_js_1.MathLib.WAD, AdaptiveCurveIrmLib.CURVE_STEEPNESS)
+            : AdaptiveCurveIrmLib.CURVE_STEEPNESS - MathLib_js_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),
+            avgBorrowRate: MathLib_js_1.MathLib.wMulDown(MathLib_js_1.MathLib.wMulDown(coeff, err) + MathLib_js_1.MathLib.WAD, avgRateAtTarget),
             endRateAtTarget,
         };
     }
@@ -120,15 +120,15 @@ var AdaptiveCurveIrmLib;
         borrowRate = BigInt(borrowRate);
         rateAtTarget = BigInt(rateAtTarget);
         if (borrowRate >= rateAtTarget) {
-            const maxBorrowRate = MathLib_1.MathLib.wMulDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+            const maxBorrowRate = MathLib_js_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));
+                return MathLib_js_1.MathLib.WAD;
+            return MathLib_js_1.MathLib.min(MathLib_js_1.MathLib.WAD, AdaptiveCurveIrmLib.TARGET_UTILIZATION +
+                MathLib_js_1.MathLib.mulDivDown(MathLib_js_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));
+        const minBorrowRate = MathLib_js_1.MathLib.wDivDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+        return MathLib_js_1.MathLib.max(0n, MathLib_js_1.MathLib.mulDivDown(AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - minBorrowRate, rateAtTarget - minBorrowRate));
     }
     AdaptiveCurveIrmLib.getUtilizationAtBorrowRate = getUtilizationAtBorrowRate;
 })(AdaptiveCurveIrmLib || (exports.AdaptiveCurveIrmLib = AdaptiveCurveIrmLib = {}));

package/lib/{maths → math}/MathLib.d.ts

@@ -1,114 +1,96 @@
-import { Time } from "@morpho-org/morpho-ts";
-import { BigIntish } from "../types";
+import type { BigIntish } from "../types.js";
 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
- *
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
  */
-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;
+export declare namespace MathLib {
+    const WAD = 1000000000000000000n;
+    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
      */
-    static abs(a: BigIntish): bigint;
+    function 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;
+    function 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;
+    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
      */
-    static zeroFloorSub(x: BigIntish, y: BigIntish): bigint;
+    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
      */
-    static wMulDown(x: BigIntish, y: BigIntish): bigint;
+    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
      */
-    static wMulUp(x: BigIntish, y: BigIntish): bigint;
+    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
      */
-    static wMul(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    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
      */
-    static wDivDown(x: BigIntish, y: BigIntish): bigint;
+    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
      */
-    static wDivUp(x: BigIntish, y: BigIntish): bigint;
+    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
      */
-    static wDiv(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    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
      */
-    static mulDivDown(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    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
      */
-    static mulDivUp(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
-    static mulDiv(x: BigIntish, y: BigIntish, denominator: BigIntish, rounding: RoundingDirection): bigint;
+    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 continuous compound interest rate.
+     * to approximate a continuously compounded 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;
+    function wTaylorCompounded(x: BigIntish, n: BigIntish): bigint;
 }

package/lib/{maths → math}/MathLib.js

@@ -1,115 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathLib = void 0;
-const morpho_ts_1 = require("@morpho-org/morpho-ts");
-const helpers_1 = require("../helpers");
 /**
  * Library to manage fixed-point arithmetic.
- * This library reproduces the behaviour of the solidity library MathLib
- * TODO: add library link
- * @category Maths
- *
+ * https://github.com/morpho-org/morpho-blue/blob/main/src/libraries/MathLib.sol
  */
-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) {
+var MathLib;
+(function (MathLib) {
+    MathLib.WAD = 1000000000000000000n;
+    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));
+        return BigInt(`0x${"f".repeat(nBits / 4)}`);
     }
+    MathLib.maxUint = maxUint;
     /**
      * Returns the absolute value of a number
      * @param a The number
      */
-    static abs(a) {
+    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
      */
-    static min(...xs) {
+    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
      */
-    static max(...xs) {
+    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
      */
-    static zeroFloorSub(x, y) {
+    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
      */
-    static wMulDown(x, y) {
+    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
      */
-    static wMulUp(x, y) {
+    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
      */
-    static wMul(x, y, rounding) {
+    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
      */
-    static wDivDown(x, y) {
+    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
      */
-    static wDivUp(x, y) {
+    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
      */
-    static wDiv(x, y, rounding) {
+    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
      */
-    static mulDivDown(x, y, denominator) {
+    function mulDivDown(x, y, denominator) {
         x = BigInt(x);
         y = BigInt(y);
         denominator = BigInt(denominator);
@@ -117,13 +124,14 @@ class MathLib {
             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
      */
-    static mulDivUp(x, y, denominator) {
+    function mulDivUp(x, y, denominator) {
         x = BigInt(x);
         y = BigInt(y);
         denominator = BigInt(denominator);
@@ -132,44 +140,23 @@ class MathLib {
         const roundup = (x * y) % denominator > 0 ? 1n : 0n;
         return (x * y) / denominator + roundup;
     }
-    static mulDiv(x, y, denominator, rounding) {
+    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 continuous compound interest rate.
+     * to approximate a continuously compounded interest rate.
      *
      * @param x The base of the exponent
      * @param n The exponent
      */
-    static wTaylorCompounded(x, n) {
+    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;
     }
-    /**
-     * 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(helpers_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;
+    MathLib.wTaylorCompounded = wTaylorCompounded;
+})(MathLib || (exports.MathLib = MathLib = {}));

package/lib/{maths → math}/SharesMath.d.ts

@@ -1,5 +1,5 @@
-import { BigIntish } from "../types";
-import { RoundingDirection } from "./MathLib";
+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}).

package/lib/{maths → math}/SharesMath.js

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

package/lib/math/index.d.ts

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

package/lib/{helpers/format → math}/index.js

@@ -14,4 +14,6 @@ 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("./format"), exports);
+__exportStar(require("./MathLib.js"), exports);
+__exportStar(require("./SharesMath.js"), exports);
+__exportStar(require("./AdaptiveCurveIrmLib.js"), exports);

package/lib/position/Position.d.ts

@@ -1,13 +1,13 @@
-import { Market, MaxBorrowOptions, MaxWithdrawCollateralOptions } from "../market";
-import { Address, BigIntish, MarketId } from "../types";
-export interface InputPosition {
+import { Market, type MaxBorrowOptions, 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 InputPosition {
+export declare class Position implements IPosition {
     /**
      * The user holding this position.
      */
@@ -28,69 +28,79 @@ export declare class Position implements InputPosition {
      * The amount of collateral assets held with this position.
      */
     collateral: bigint;
-    constructor({ user, marketId, supplyShares, borrowShares, collateral, }: InputPosition);
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }: IPosition);
 }
-export interface InputAccrualPosition extends Omit<InputPosition, "marketId"> {
+export interface IAccrualPosition extends Omit<IPosition, "marketId"> {
 }
-export declare class AccrualPosition extends Position implements InputAccrualPosition {
+export declare class AccrualPosition extends Position implements IAccrualPosition {
     /**
      * The market on which this position is held.
      */
     readonly market: Market;
-    constructor(position: InputAccrualPosition, market: Market);
+    constructor(position: IAccrualPosition, market: Market);
     get supplyAssets(): bigint;
     get borrowAssets(): bigint;
     /**
      * The value of this position's collateral quoted in loan assets.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get collateralValue(): bigint;
+    get collateralValue(): bigint | undefined;
     /**
      * The maximum amount of loan assets that can be borrowed against this position's collateral.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get maxBorrowAssets(): bigint;
+    get maxBorrowAssets(): bigint | undefined;
     /**
      * The maximum additional amount of assets that can be borrowed against this position's collateral.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get maxBorrowableAssets(): bigint;
+    get maxBorrowableAssets(): bigint | undefined;
     /**
      * The maximum amount of collateral that can be seized in exchange for the outstanding debt.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get seizableCollateral(): bigint;
+    get seizableCollateral(): bigint | undefined;
     /**
      * The maximum amount of collateral that can be withdrawn.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get withdrawableCollateral(): bigint;
+    get withdrawableCollateral(): bigint | undefined;
     /**
      * Whether this position is healthy.
+     * `undefined` iff the market's oracle is undefined or reverts.
      */
-    get isHealthy(): boolean;
+    get isHealthy(): boolean | undefined;
     /**
      * 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).
+     * 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` iff the market's oracle is undefined or reverts.
+     * Null if the position is not a borrow.
      */
-    get priceVariationToLiquidation(): bigint | null;
+    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` iff the market's oracle is undefined or reverts.
      */
-    get ltv(): bigint | null;
+    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` iff the market's oracle is undefined or reverts.
      */
-    get healthFactor(): bigint | null;
+    get healthFactor(): bigint | null | 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 | null;
-    get borrowCapacityLimit(): import("../market").CapacityLimit;
-    get withdrawCapacityLimit(): import("../market").CapacityLimit;
-    get withdrawCollateralCapacityLimit(): import("../market").CapacityLimit;
+    get borrowCapacityUsage(): bigint | undefined;
+    get borrowCapacityLimit(): import("../market/Market.js").CapacityLimit | undefined;
+    get withdrawCapacityLimit(): import("../market/Market.js").CapacityLimit;
+    get withdrawCollateralCapacityLimit(): import("../market/Market.js").CapacityLimit | undefined;
     /**
      * 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`.
@@ -118,9 +128,9 @@ export declare class AccrualPosition extends Position implements InputAccrualPos
         assets: bigint;
         shares: bigint;
     };
-    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market").CapacityLimit;
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market/Market.js").CapacityLimit;
     getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint, options?: {
         borrow?: MaxBorrowOptions;
         withdrawCollateral?: MaxWithdrawCollateralOptions;
-    }): import("../market").MaxPositionCapacities;
+    }): import("../market/Market.js").MaxPositionCapacities;
 }