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

package/lib/math/MathLib.d.ts

@@ -0,0 +1,111 @@
+import { Time } from "@morpho-org/morpho-ts";
+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 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 continuous compound interest rate.
+     *
+     * @param x The base of the exponent
+     * @param n The exponent
+     */
+    function 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
+     */
+    function 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
+     */
+    function aprToApy(apr: BigIntish, compounding: Time.PeriodLike): number;
+}

package/lib/math/MathLib.js

@@ -0,0 +1,185 @@
+import { Time, format } from "@morpho-org/morpho-ts";
+/**
+ * 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.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 continuous compound 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 an rate to compounded apy
+     *
+     * @param rate The rate to convert (in WAD)
+     * @param period The compounding basis
+     */
+    function rateToApy(rate, period) {
+        const { unit, duration } = Time.toPeriod(period);
+        const factor = Time[unit].from.y(1) / duration;
+        return ((1 + Number(format.number.locale("en").of(BigInt(rate), 18))) ** factor -
+            1);
+    }
+    MathLib.rateToApy = rateToApy;
+    /**
+     * Converts an apr to compounded apy
+     *
+     * @param apr The apr to convert (in WAD)
+     * @param compounding The compounding basis
+     */
+    function aprToApy(apr, compounding) {
+        const { unit, duration } = Time.toPeriod(compounding);
+        const rate = (BigInt(apr) * BigInt(duration)) / Time[unit].from.y(1n);
+        return rateToApy(rate, compounding);
+    }
+    MathLib.aprToApy = aprToApy;
+})(MathLib || (MathLib = {}));

package/lib/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/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/math/index.d.ts

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

package/lib/math/index.js

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

package/lib/position/Position.d.ts

@@ -0,0 +1,127 @@
+import { Market, type MaxBorrowOptions, type MaxWithdrawCollateralOptions } from "../market/index.js";
+import type { Address, BigIntish, MarketId } from "../types.js";
+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 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%).
+     * Returns null if the position is not a borrow.
+     */
+    get priceVariationToLiquidationPrice(): 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/Market.js").CapacityLimit;
+    get withdrawCapacityLimit(): import("../market/Market.js").CapacityLimit;
+    get withdrawCollateralCapacityLimit(): import("../market/Market.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;
+    };
+    getRepayCapacityLimit(loanTokenBalance: bigint): import("../market/Market.js").CapacityLimit;
+    getMaxCapacities(loanTokenBalance: bigint, collateralTokenBalance: bigint, options?: {
+        borrow?: MaxBorrowOptions;
+        withdrawCollateral?: MaxWithdrawCollateralOptions;
+    }): import("../market/Market.js").MaxPositionCapacities;
+}

package/lib/position/Position.js

@@ -0,0 +1,199 @@
+import { BlueErrors } from "../errors.js";
+import { Market, } from "../market/index.js";
+export class Position {
+    /**
+     * The user holding this position.
+     */
+    user;
+    /**
+     * The id of the market on which this position is held.
+     */
+    marketId;
+    /**
+     * The amount of supply shares held with this position.
+     */
+    supplyShares;
+    /**
+     * The amount of borrow shares held with this position.
+     */
+    borrowShares;
+    /**
+     * The amount of collateral assets held with this position.
+     */
+    collateral;
+    constructor({ user, marketId, supplyShares, borrowShares, collateral, }) {
+        this.user = user;
+        this.marketId = marketId;
+        this.supplyShares = supplyShares;
+        this.borrowShares = borrowShares;
+        this.collateral = collateral;
+    }
+}
+export class AccrualPosition extends Position {
+    /**
+     * The market on which this position is held.
+     */
+    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 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%).
+     * Returns null if the position is not a borrow.
+     */
+    get priceVariationToLiquidationPrice() {
+        return this.market.getPriceVariationToLiquidationPrice(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);
+    }
+    get withdrawCapacityLimit() {
+        return this.market.getWithdrawCapacityLimit(this);
+    }
+    get withdrawCollateralCapacityLimit() {
+        return this.market.getWithdrawCollateralCapacityLimit(this);
+    }
+    /**
+     * 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) {
+        return new AccrualPosition(this, this.market.accrueInterest(timestamp));
+    }
+    supply(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.supply(assets, shares, timestamp));
+        this.supplyShares += shares;
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    withdraw(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.withdraw(assets, shares, timestamp));
+        this.supplyShares -= shares;
+        if (this.supplyShares < 0n)
+            throw new BlueErrors.InsufficientPosition(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    supplyCollateral(assets) {
+        this.collateral += assets;
+        return new AccrualPosition(this, new Market(this.market));
+    }
+    withdrawCollateral(assets, timestamp) {
+        const market = this.market.accrueInterest(timestamp);
+        this.collateral -= assets;
+        if (this.collateral < 0n)
+            throw new BlueErrors.InsufficientPosition(this.user, this.marketId);
+        if (!market.isHealthy(this))
+            throw new BlueErrors.InsufficientCollateral(this.user, this.marketId);
+        return new AccrualPosition(this, market);
+    }
+    borrow(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.borrow(assets, shares, timestamp));
+        this.borrowShares += shares;
+        if (!market.isHealthy(this))
+            throw new BlueErrors.InsufficientCollateral(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    repay(assets, shares, timestamp) {
+        let { market } = this;
+        ({ market, assets, shares } = market.repay(assets, shares, timestamp));
+        this.borrowShares -= shares;
+        if (this.borrowShares < 0n)
+            throw new BlueErrors.InsufficientPosition(this.user, this.marketId);
+        return {
+            position: new AccrualPosition(this, market),
+            assets,
+            shares,
+        };
+    }
+    getRepayCapacityLimit(loanTokenBalance) {
+        return this.market.getRepayCapacityLimit(this.borrowShares, loanTokenBalance);
+    }
+    getMaxCapacities(loanTokenBalance, collateralTokenBalance, options) {
+        return this.market.getMaxCapacities(this, loanTokenBalance, collateralTokenBalance, options);
+    }
+}

package/lib/position/index.d.ts

@@ -0,0 +1 @@
+export * from "./Position.js";

package/lib/position/index.js

@@ -0,0 +1 @@
+export * from "./Position.js";

package/lib/token/ConstantWrappedToken.d.ts

@@ -0,0 +1,17 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { Address, BigIntish } from "../types.js";
+import type { InputToken } from "./Token.js";
+import { WrappedToken } from "./WrappedToken.js";
+export declare class ConstantWrappedToken extends WrappedToken {
+    readonly underlyingDecimals: bigint;
+    constructor(token: InputToken, underlying: Address, underlyingDecimals?: BigIntish);
+    toWrappedExactAmountIn(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+    toWrappedExactAmountOut(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The expected amount when unwrapping `wrappedAmount` */
+    toUnwrappedExactAmountIn(wrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+    toUnwrappedExactAmountOut(unwrappedAmount: bigint, _slippage?: bigint, rounding?: RoundingDirection): bigint;
+    protected _wrap(amount: bigint): bigint;
+    protected _unwrap(amount: bigint): bigint;
+}