@morpho-org/midnight-sdk 0.1.0

package/lib/cjs/market/PositionUtils.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionUtils = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const errors_js_1 = require("../errors.js");
+/**
+ * Domain helpers for Midnight positions.
+ *
+ * @example
+ * ```ts
+ * import { PositionUtils } from "@morpho-org/midnight-sdk";
+ *
+ * const accrued = PositionUtils.accrueInterest({
+ *   position: {
+ *     credit: 1_000n,
+ *     pendingFee: 100n,
+ *     lastLossFactor: 0n,
+ *     lastAccrual: 1_000n,
+ *     debt: 0n,
+ *     collateralBitmap: 1n,
+ *     collateral: [50n],
+ *   },
+ *   market: {
+ *     chainId: 8453,
+ *     params: {
+ *       loanToken: "0x0000000000000000000000000000000000006000",
+ *       collateralParams: [
+ *         {
+ *           token: "0x0000000000000000000000000000000000007000",
+ *           lltv: 770000000000000000n,
+ *           maxLif: 1061007957559681697n,
+ *           oracle: "0x0000000000000000000000000000000000008000",
+ *         },
+ *       ],
+ *       maturity: 54_000n,
+ *       rcfThreshold: 0n,
+ *       enterGate: "0x0000000000000000000000000000000000000000",
+ *       liquidatorGate: "0x0000000000000000000000000000000000000000",
+ *     },
+ *     totalUnits: 1_000n,
+ *     lossFactor: 0n,
+ *     withdrawable: 500n,
+ *     continuousFeeCredit: 0n,
+ *     settlementFeeCbps: [1, 2, 3, 4, 5, 6, 7],
+ *     continuousFee: 10,
+ *     tickSpacing: 4,
+ *   },
+ *   timestamp: 1_500n,
+ * });
+ * console.log(accrued.position.credit);
+ * ```
+ */
+var PositionUtils;
+(function (PositionUtils) {
+    /**
+     * Returns plain Midnight position and market objects accrued like Midnight `updatePositionView`.
+     *
+     * @param params.position - Position state to accrue.
+     * @param params.market - Hydrated market state used for loss factor and continuous-fee accrual.
+     * @param params.timestamp - Timestamp at which to accrue.
+     * @returns New plain position and market objects with updated credit, pending fee, last loss factor, last accrual, and market continuous-fee credit.
+     * @throws {InvalidPositionAccrualTimestampError} when timestamp is before `lastAccrual`.
+     * @throws {InvalidPositionLossFactorError} when the market loss factor is older than the position loss factor.
+     * @throws {InvalidPositionAccrualStateError} when raw inputs violate Midnight accounting invariants.
+     * @example
+     * ```ts
+     * import { PositionUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const { position, market } = PositionUtils.accrueInterest({
+     *   position: {
+     *     credit: 1_000n,
+     *     pendingFee: 100n,
+     *     lastLossFactor: 0n,
+     *     lastAccrual: 1_000n,
+     *     debt: 0n,
+     *     collateralBitmap: 1n,
+     *     collateral: [50n],
+     *   },
+     *   market: {
+     *     chainId: 8453,
+     *     params: {
+     *       loanToken: "0x0000000000000000000000000000000000006000",
+     *       collateralParams: [
+     *         {
+     *           token: "0x0000000000000000000000000000000000007000",
+     *           lltv: 770000000000000000n,
+     *           maxLif: 1061007957559681697n,
+     *           oracle: "0x0000000000000000000000000000000000008000",
+     *         },
+     *       ],
+     *       maturity: 54_000n,
+     *       rcfThreshold: 0n,
+     *       enterGate: "0x0000000000000000000000000000000000000000",
+     *       liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *     },
+     *     totalUnits: 1_000n,
+     *     lossFactor: 0n,
+     *     withdrawable: 500n,
+     *     continuousFeeCredit: 0n,
+     *     settlementFeeCbps: [1, 2, 3, 4, 5, 6, 7],
+     *     continuousFee: 10,
+     *     tickSpacing: 4,
+     *   },
+     *   timestamp: 1_500n,
+     * });
+     * console.log(position.lastAccrual, market.continuousFeeCredit);
+     * ```
+     */
+    function accrueInterest(params) {
+        const timestamp = BigInt(params.timestamp);
+        const credit = BigInt(params.position.credit);
+        const pendingFee = BigInt(params.position.pendingFee);
+        const lastLossFactor = BigInt(params.position.lastLossFactor);
+        const lastAccrual = BigInt(params.position.lastAccrual);
+        const marketLossFactor = BigInt(params.market.lossFactor);
+        if (timestamp < lastAccrual) {
+            throw new errors_js_1.InvalidPositionAccrualTimestampError(timestamp, lastAccrual);
+        }
+        if (marketLossFactor < lastLossFactor) {
+            throw new errors_js_1.InvalidPositionLossFactorError(marketLossFactor, lastLossFactor);
+        }
+        if (pendingFee > credit) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Pending fee must be less than or equal to credit.");
+        }
+        const postSlashCredit = lastLossFactor < morpho_ts_1.MathLib.MAX_UINT_128
+            ? morpho_ts_1.MathLib.mulDivDown(credit, morpho_ts_1.MathLib.MAX_UINT_128 - marketLossFactor, morpho_ts_1.MathLib.MAX_UINT_128 - lastLossFactor)
+            : 0n;
+        if (postSlashCredit > credit) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Post-slash credit cannot exceed stored credit.");
+        }
+        const creditDecrease = credit - postSlashCredit;
+        const pendingFeeDecrease = credit > 0n ? morpho_ts_1.MathLib.mulDivUp(pendingFee, creditDecrease, credit) : 0n;
+        if (pendingFeeDecrease > pendingFee) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Pending-fee decrease cannot exceed pending fee.");
+        }
+        const postSlashPendingFee = pendingFee - pendingFeeDecrease;
+        const maturity = BigInt(params.market.params.maturity);
+        const accrualEnd = timestamp < maturity ? timestamp : maturity;
+        const accruedFee = lastAccrual < maturity
+            ? morpho_ts_1.MathLib.mulDivDown(postSlashPendingFee, accrualEnd - lastAccrual, maturity - lastAccrual)
+            : 0n;
+        if (accruedFee > postSlashCredit || accruedFee > postSlashPendingFee) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Accrued fee cannot exceed post-slash credit or pending fee.");
+        }
+        const collateral = params.position.collateral.map((assets) => BigInt(assets));
+        const collateralParams = params.market.params.collateralParams.map((collateralParam) => ({
+            token: collateralParam.token,
+            lltv: BigInt(collateralParam.lltv),
+            maxLif: BigInt(collateralParam.maxLif),
+            oracle: collateralParam.oracle,
+        }));
+        const marketParams = {
+            loanToken: params.market.params.loanToken,
+            collateralParams,
+            maturity,
+            rcfThreshold: BigInt(params.market.params.rcfThreshold),
+            enterGate: params.market.params.enterGate,
+            liquidatorGate: params.market.params.liquidatorGate,
+        };
+        const settlementFeeCbps = [
+            params.market.settlementFeeCbps[0],
+            params.market.settlementFeeCbps[1],
+            params.market.settlementFeeCbps[2],
+            params.market.settlementFeeCbps[3],
+            params.market.settlementFeeCbps[4],
+            params.market.settlementFeeCbps[5],
+            params.market.settlementFeeCbps[6],
+        ];
+        return {
+            position: {
+                credit: postSlashCredit - accruedFee,
+                pendingFee: postSlashPendingFee - accruedFee,
+                lastLossFactor: marketLossFactor,
+                lastAccrual: timestamp,
+                debt: BigInt(params.position.debt),
+                collateralBitmap: BigInt(params.position.collateralBitmap),
+                collateral,
+            },
+            market: {
+                chainId: BigInt(params.market.chainId),
+                params: marketParams,
+                totalUnits: BigInt(params.market.totalUnits),
+                lossFactor: marketLossFactor,
+                withdrawable: BigInt(params.market.withdrawable),
+                continuousFeeCredit: BigInt(params.market.continuousFeeCredit) + accruedFee,
+                settlementFeeCbps,
+                continuousFee: params.market.continuousFee,
+                tickSpacing: params.market.tickSpacing,
+            },
+            accruedFee,
+        };
+    }
+    PositionUtils.accrueInterest = accrueInterest;
+})(PositionUtils || (exports.PositionUtils = PositionUtils = {}));

package/lib/cjs/market/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Market.js";
+export * from "./MarketUtils.js";
+export * from "./Position.js";
+export * from "./PositionUtils.js";

package/lib/cjs/market/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Market.js"), exports);
+__exportStar(require("./MarketUtils.js"), exports);
+__exportStar(require("./Position.js"), exports);
+__exportStar(require("./PositionUtils.js"), exports);

package/lib/cjs/math/ConsumableUnitsLib.d.ts

@@ -0,0 +1,57 @@
+import { type BigIntish } from "@morpho-org/morpho-ts";
+/**
+ * TypeScript port of Midnight `ConsumableUnitsLib`.
+ *
+ * @example
+ * ```ts
+ * import { ConsumableUnitsLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof ConsumableUnitsLib.consumableUnits);
+ * ```
+ */
+export declare namespace ConsumableUnitsLib {
+    /**
+     * Returns units that would fully consume an offer.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used for asset-capped conversion.
+     * @param params.offer.maxUnits - Unit cap; when non-zero, units are capped directly.
+     * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
+     * @param params.consumed - Amount already consumed from the offer group.
+     * @param params.settlementFee - WAD-scaled settlement fee used for asset-capped conversion.
+     * @returns Remaining consumable units.
+     * @throws {NegativeValueError} when `consumed`, offer limits, delegated asset inputs, or the offer tick is negative.
+     * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
+     * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { ConsumableUnitsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     *   maxUnits: 0n,
+     *   maxAssets: 1_000n,
+     * };
+     *
+     * const units = ConsumableUnitsLib.consumableUnits({
+     *   offer,
+     *   consumed: 0n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function consumableUnits(params: {
+        readonly offer: {
+            readonly buy: boolean;
+            readonly tick: BigIntish;
+            readonly maxUnits: BigIntish;
+            readonly maxAssets: BigIntish;
+        };
+        readonly consumed: BigIntish;
+        readonly settlementFee: BigIntish;
+    }): bigint;
+}

package/lib/cjs/math/ConsumableUnitsLib.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumableUnitsLib = void 0;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const index_js_1 = require("../offers/index.js");
+const TakeAmountsLib_js_1 = require("./TakeAmountsLib.js");
+/**
+ * TypeScript port of Midnight `ConsumableUnitsLib`.
+ *
+ * @example
+ * ```ts
+ * import { ConsumableUnitsLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof ConsumableUnitsLib.consumableUnits);
+ * ```
+ */
+var ConsumableUnitsLib;
+(function (ConsumableUnitsLib) {
+    /**
+     * Returns units that would fully consume an offer.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used for asset-capped conversion.
+     * @param params.offer.maxUnits - Unit cap; when non-zero, units are capped directly.
+     * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
+     * @param params.consumed - Amount already consumed from the offer group.
+     * @param params.settlementFee - WAD-scaled settlement fee used for asset-capped conversion.
+     * @returns Remaining consumable units.
+     * @throws {NegativeValueError} when `consumed`, offer limits, delegated asset inputs, or the offer tick is negative.
+     * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
+     * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { ConsumableUnitsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     *   maxUnits: 0n,
+     *   maxAssets: 1_000n,
+     * };
+     *
+     * const units = ConsumableUnitsLib.consumableUnits({
+     *   offer,
+     *   consumed: 0n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function consumableUnits(params) {
+        const consumed = BigInt(params.consumed);
+        const maxUnits = BigInt(params.offer.maxUnits);
+        const maxAssets = BigInt(params.offer.maxAssets);
+        (0, morpho_ts_1.assertNonNegative)("consumed", consumed);
+        (0, morpho_ts_1.assertNonNegative)("offer.maxUnits", maxUnits);
+        (0, morpho_ts_1.assertNonNegative)("offer.maxAssets", maxAssets);
+        index_js_1.OfferUtils.validateOfferCaps({ maxUnits, maxAssets });
+        if (maxUnits > 0n)
+            return morpho_ts_1.MathLib.zeroFloorSub(maxUnits, consumed);
+        const remainingAssets = morpho_ts_1.MathLib.zeroFloorSub(maxAssets, consumed);
+        return params.offer.buy
+            ? TakeAmountsLib_js_1.TakeAmountsLib.buyerAssetsToUnits({
+                offer: params.offer,
+                targetBuyerAssets: remainingAssets,
+                settlementFee: params.settlementFee,
+            })
+            : TakeAmountsLib_js_1.TakeAmountsLib.sellerAssetsToUnits({
+                offer: params.offer,
+                targetSellerAssets: remainingAssets,
+                settlementFee: params.settlementFee,
+            });
+    }
+    ConsumableUnitsLib.consumableUnits = consumableUnits;
+})(ConsumableUnitsLib || (exports.ConsumableUnitsLib = ConsumableUnitsLib = {}));

package/lib/cjs/math/TakeAmountsLib.d.ts

@@ -0,0 +1,175 @@
+import { type BigIntish, type RoundingDirection } from "@morpho-org/morpho-ts";
+/**
+ * TypeScript port of Midnight `TakeAmountsLib`.
+ *
+ * @example
+ * ```ts
+ * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof TakeAmountsLib.toUnits);
+ * ```
+ */
+export declare namespace TakeAmountsLib {
+    /**
+     * Computes buyer and seller prices for an offer and settlement fee.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the base price.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Buyer and seller prices.
+     * @throws {NegativeValueError} when `settlementFee` or the offer tick is negative.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     * };
+     *
+     * const prices = TakeAmountsLib.prices({ offer, settlementFee: 1_000000000000n });
+     * console.log(prices.buyerPrice);
+     * ```
+     */
+    function prices(params: {
+        readonly offer: {
+            readonly buy: boolean;
+            readonly tick: BigIntish;
+        };
+        readonly settlementFee: BigIntish;
+    }): {
+        readonly buyerPrice: bigint;
+        readonly sellerPrice: bigint;
+    };
+    /**
+     * Converts a target buyer-asset amount into units for an offer.
+     *
+     * `settlementFee` must be the fee for the offer market's current time to maturity.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the buyer price.
+     * @param params.targetBuyerAssets - Target buyer-side asset amount.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Units that round-trip to the target buyer assets where reachable.
+     * @throws {NegativeValueError} when `targetBuyerAssets`, `settlementFee`, or the offer tick is negative.
+     * @throws {DivisionByZeroError} when the computed buyer price is zero.
+     * @throws {PriceGreaterThanOneError} when buyer price is above WAD.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: true,
+     *   tick: 5_820n,
+     * };
+     *
+     * const units = TakeAmountsLib.buyerAssetsToUnits({
+     *   offer,
+     *   targetBuyerAssets: 100n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function buyerAssetsToUnits(params: {
+        readonly offer: {
+            readonly buy: boolean;
+            readonly tick: BigIntish;
+        };
+        readonly targetBuyerAssets: BigIntish;
+        readonly settlementFee: BigIntish;
+    }): bigint;
+    /**
+     * Converts a target seller-asset amount into units for an offer.
+     *
+     * `settlementFee` must be the fee for the offer market's current time to maturity.
+     *
+     * @param params.offer.buy - Whether the maker buys loan assets.
+     * @param params.offer.tick - Offer tick used to compute the seller price.
+     * @param params.targetSellerAssets - Target seller-side asset amount.
+     * @param params.settlementFee - WAD-scaled settlement fee for the market and time to maturity.
+     * @returns Units that round-trip to the target seller assets where reachable.
+     * @throws {NegativeValueError} when `targetSellerAssets`, `settlementFee`, or the offer tick is negative.
+     * @throws {DivisionByZeroError} when the computed seller price is zero.
+     * @throws {TickOutOfRangeError} when the offer tick exceeds `MAX_TICK`.
+     * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = {
+     *   buy: false,
+     *   tick: 5_820n,
+     * };
+     *
+     * const units = TakeAmountsLib.sellerAssetsToUnits({
+     *   offer,
+     *   targetSellerAssets: 100n,
+     *   settlementFee: 0n,
+     * });
+     * console.log(units);
+     * ```
+     */
+    function sellerAssetsToUnits(params: {
+        readonly offer: {
+            readonly buy: boolean;
+            readonly tick: BigIntish;
+        };
+        readonly targetSellerAssets: BigIntish;
+        readonly settlementFee: BigIntish;
+    }): bigint;
+    /**
+     * Converts assets to units at a WAD price.
+     *
+     * This is an SDK-only generic conversion convenience.
+     *
+     * @param params.assets - Asset amount to convert.
+     * @param params.price - WAD-scaled price used for the conversion.
+     * @param params.rounding - Rounding direction applied by the fixed-point conversion.
+     * @returns Units.
+     * @throws {NegativeValueError} when `assets` or `price` is negative.
+     * @throws {DivisionByZeroError} when price is zero.
+     * @example
+     * ```ts
+     * import { MathLib } from "@morpho-org/morpho-ts";
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const units = TakeAmountsLib.toUnits({ assets: 100n, price: MathLib.WAD, rounding: "Down" });
+     * console.log(units);
+     * ```
+     */
+    function toUnits(params: {
+        readonly assets: BigIntish;
+        readonly price: BigIntish;
+        readonly rounding: RoundingDirection;
+    }): bigint;
+    /**
+     * Converts assets to units at a tick price.
+     *
+     * This is an SDK-only tick-priced conversion convenience.
+     *
+     * @param params.assets - Asset amount to convert.
+     * @param params.tick - Offer tick whose price is used for the conversion.
+     * @param params.rounding - Rounding direction applied by the fixed-point conversion.
+     * @returns Units.
+     * @throws {NegativeValueError} when `assets` or `tick` is negative.
+     * @throws {DivisionByZeroError} when the tick price is zero.
+     * @throws {TickOutOfRangeError} when `tick` exceeds `MAX_TICK`.
+     * @example
+     * ```ts
+     * import { TakeAmountsLib } from "@morpho-org/midnight-sdk";
+     *
+     * const units = TakeAmountsLib.toUnitsAtTick({ assets: 100n, tick: 6744n, rounding: "Down" });
+     * console.log(units);
+     * ```
+     */
+    function toUnitsAtTick(params: {
+        readonly assets: BigIntish;
+        readonly tick: BigIntish;
+        readonly rounding: RoundingDirection;
+    }): bigint;
+}