@morpho-org/midnight-sdk 1.1.1 → 1.2.0

package/lib/esm/{market → position}/Position.js

@@ -1,6 +1,6 @@
 import { _try, MathLib } from "@morpho-org/morpho-ts";
 import { UnknownCollateralIndexError } from "../errors.js";
-import { Market } from "./Market.js";
+import { Market } from "../market/Market.js";
 import { PositionUtils } from "./PositionUtils.js";
 /**
  * Midnight user position as stored by the core contract.
@@ -10,6 +10,8 @@ import { PositionUtils } from "./PositionUtils.js";
  * import { Position } from "@morpho-org/midnight-sdk";
  *
  * const position = new Position({
+ *   user: "0x0000000000000000000000000000000000009000",
+ *   marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *   credit: 0n,
  *   pendingFee: 0n,
  *   lastLossFactor: 0n,
@@ -22,6 +24,10 @@ import { PositionUtils } from "./PositionUtils.js";
  * ```
  */
 export class Position {
+    /** User holding this position. */
+    user;
+    /** Id of the market on which this position is held. */
+    marketId;
     /** User credit. */
     credit;
     /** Pending continuous fee. */
@@ -37,6 +43,8 @@ export class Position {
     /** Collateral balances by index. */
     collateral;
     constructor(position) {
+        this.user = position.user;
+        this.marketId = position.marketId;
         this.credit = BigInt(position.credit);
         this.pendingFee = BigInt(position.pendingFee);
         this.lastLossFactor = BigInt(position.lastLossFactor);
@@ -54,6 +62,8 @@ export class Position {
      * import { Position } from "@morpho-org/midnight-sdk";
      *
      * const position = new Position({
+     *   user: "0x0000000000000000000000000000000000009000",
+     *   marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *   credit: 1_000n,
      *   pendingFee: 100n,
      *   lastLossFactor: 0n,
@@ -93,6 +103,7 @@ export class Position {
  *
  * const position = new AccrualPosition(
  *   {
+ *     user: "0x0000000000000000000000000000000000009000",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -132,11 +143,74 @@ export class Position {
  * ```
  */
 export class AccrualPosition extends Position {
-    /** Hydrated market for this position. */
-    market;
+    _market;
     constructor(position, market) {
-        super(position);
-        this.market = Market.from(market);
+        const _market = Market.from(market);
+        super({ ...position, marketId: _market.id });
+        this._market = _market;
+    }
+    /** Hydrated market for this position. */
+    get market() {
+        return this._market;
+    }
+    /**
+     * Returns the maximum credit units currently withdrawable from this position.
+     *
+     * The protocol capacity is limited by both the accrued position credit and
+     * the market's currently withdrawable liquidity. Default redemption flows may
+     * still choose the position face value.
+     *
+     * @returns Maximum credit units currently withdrawable.
+     * @example
+     * ```ts
+     * import { AccrualPosition } from "@morpho-org/midnight-sdk";
+     *
+     * const position = new AccrualPosition(
+     *   {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     credit: 1_000n,
+     *     pendingFee: 100n,
+     *     lastLossFactor: 0n,
+     *     lastAccrual: 1_000n,
+     *     debt: 0n,
+     *     collateralBitmap: 1n,
+     *     collateral: [50n],
+     *   },
+     *   {
+     *     params: {
+     *       chainId: 8453,
+     *       midnight: "0x0000000000000000000000000000000000001000",
+     *       loanToken: "0x0000000000000000000000000000000000006000",
+     *       collateralParams: [
+     *         {
+     *           token: "0x0000000000000000000000000000000000007000",
+     *           lltv: 770000000000000000n,
+     *           liquidationCursor: 250000000000000000n,
+     *           oracle: "0x0000000000000000000000000000000000008000",
+     *         },
+     *       ],
+     *       maturity: 54_000n,
+     *       rcfThreshold: 0n,
+     *       enterGate: "0x0000000000000000000000000000000000000000",
+     *       liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *     },
+     *     totalUnits: 1_000n,
+     *     lossFactor: 0n,
+     *     withdrawable: 950n,
+     *     continuousFeeCredit: 0n,
+     *     settlementFeeCbps: [1, 2, 3, 4, 5, 6, 7],
+     *     continuousFee: 10,
+     *     tickSpacing: 4,
+     *   },
+     * );
+     * console.log(position.withdrawable); // 950n
+     * ```
+     */
+    get withdrawable() {
+        return PositionUtils.getWithdrawable({
+            position: this,
+            market: this.market,
+        });
     }
     /**
      * Returns the position collateral balance at an index configured by the market.
@@ -164,6 +238,7 @@ export class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -236,6 +311,7 @@ export class AccrualPosition extends Position {
      * const collateralToken = "0x0000000000000000000000000000000000007000";
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -305,6 +381,7 @@ export class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -376,6 +453,7 @@ export class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,

package/lib/{cjs/market → esm/position}/PositionUtils.d.ts

@@ -1,5 +1,5 @@
 import { type BigIntish } from "@morpho-org/morpho-ts";
-import type { IMarket } from "./Market.js";
+import type { IMarket } from "../market/Market.js";
 import type { IPosition } from "./Position.js";
 /**
  * Domain helpers for Midnight positions.
@@ -10,6 +10,8 @@ import type { IPosition } from "./Position.js";
  *
  * const accrued = PositionUtils.accrueInterest({
  *   position: {
+ *     user: "0x0000000000000000000000000000000000009000",
+ *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -50,6 +52,27 @@ import type { IPosition } from "./Position.js";
  * ```
  */
 export declare namespace PositionUtils {
+    /**
+     * Returns the maximum credit units currently withdrawable by a position.
+     *
+     * @param params.position - Position whose credit limits the withdrawal.
+     * @param params.market - Market whose available liquidity limits the withdrawal.
+     * @returns The lower of the position credit and market withdrawable liquidity.
+     * @example
+     * ```ts
+     * import { PositionUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const withdrawable = PositionUtils.getWithdrawable({
+     *   position: { credit: 1_000n },
+     *   market: { withdrawable: 500n },
+     * });
+     * console.log(withdrawable); // 500n
+     * ```
+     */
+    function getWithdrawable(params: {
+        readonly position: Pick<IPosition, "credit">;
+        readonly market: Pick<IMarket, "withdrawable">;
+    }): bigint;
     /**
      * Returns plain Midnight position and market objects accrued like Midnight `updatePositionView`.
      *
@@ -66,6 +89,8 @@ export declare namespace PositionUtils {
      *
      * const { position, market } = PositionUtils.accrueInterest({
      *   position: {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,

package/lib/esm/{market → position}/PositionUtils.js

@@ -9,6 +9,8 @@ import { InvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError,
  *
  * const accrued = PositionUtils.accrueInterest({
  *   position: {
+ *     user: "0x0000000000000000000000000000000000009000",
+ *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -50,6 +52,27 @@ import { InvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError,
  */
 export var PositionUtils;
 (function (PositionUtils) {
+    /**
+     * Returns the maximum credit units currently withdrawable by a position.
+     *
+     * @param params.position - Position whose credit limits the withdrawal.
+     * @param params.market - Market whose available liquidity limits the withdrawal.
+     * @returns The lower of the position credit and market withdrawable liquidity.
+     * @example
+     * ```ts
+     * import { PositionUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const withdrawable = PositionUtils.getWithdrawable({
+     *   position: { credit: 1_000n },
+     *   market: { withdrawable: 500n },
+     * });
+     * console.log(withdrawable); // 500n
+     * ```
+     */
+    function getWithdrawable(params) {
+        return MathLib.min(BigInt(params.position.credit), BigInt(params.market.withdrawable));
+    }
+    PositionUtils.getWithdrawable = getWithdrawable;
     /**
      * Returns plain Midnight position and market objects accrued like Midnight `updatePositionView`.
      *
@@ -66,6 +89,8 @@ export var PositionUtils;
      *
      * const { position, market } = PositionUtils.accrueInterest({
      *   position: {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -169,6 +194,8 @@ export var PositionUtils;
         ];
         return {
             position: {
+                user: params.position.user,
+                marketId: params.position.marketId,
                 credit: postSlashCredit - accruedFee,
                 pendingFee: postSlashPendingFee - accruedFee,
                 lastLossFactor: marketLossFactor,

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

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

package/lib/esm/position/index.js

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

package/lib/esm/signatures/RatifierUtils.js

@@ -15,7 +15,8 @@ function normalizeTree(tree) {
     if (isTreeLike(tree)) {
         return tree;
     }
-    const offers = tree.flatMap((entry) => GroupUtils.isGroupInput(entry)
+    const entries = Array.isArray(tree) ? tree : [tree];
+    const offers = entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
         ? Group.from(entry).offers
         : [
             new Offer({

package/lib/esm/signatures/Tree.js

@@ -115,7 +115,9 @@ export class Tree {
      * ```
      */
     static from(tree) {
-        return tree instanceof Tree ? tree : Tree.create(tree);
+        if (tree instanceof Tree)
+            return tree;
+        return Tree.create(Array.isArray(tree) ? tree : [tree]);
     }
     /**
      * Creates a tree from groups or standalone offers.

package/lib/esm/signatures/TreeUtils.d.ts

@@ -188,7 +188,7 @@ export type TreeCreateParams = readonly GroupInput[];
  * console.log(tree);
  * ```
  */
-export type TreeInput = Tree | TreeCreateParams;
+export type TreeInput = Tree | TreeCreateParams | GroupInput;
 /**
  * Tree-shaped data required by ratifier helpers.
  *
@@ -284,7 +284,7 @@ export interface TreeLike {
  * console.log(tree);
  * ```
  */
-export type RatifierTreeInput = TreeLike | TreeCreateParams;
+export type RatifierTreeInput = TreeLike | TreeInput;
 /**
  * Optional ratification inputs for {@link Tree.mempoolValidate}.
  *

package/lib/esm/signatures/TreeUtils.js

@@ -35,6 +35,7 @@ function assertLeafOffers(offers, leafHashes) {
         }
         seen.add(leafHash);
     }
+    /* v8 ignore next: buildDescriptor rejects empty struct lists before padding; this protects direct internal misuse. */
     if (seen.size === 0) {
         throw new InvalidTreeError("Tree must not be empty.");
     }
@@ -118,9 +119,17 @@ export var TreeUtils;
     async function mempoolValidate(params) {
         let items;
         if (params.ratification == null) {
-            const offers = "paddedOffers" in params.tree
-                ? params.tree.offers
-                : params.tree.flatMap((entry) => GroupUtils.isGroupInput(entry)
+            if ("paddedOffers" in params.tree) {
+                items = params.tree.offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
+            }
+            else {
+                const entries = Array.isArray(params.tree)
+                    ? params.tree
+                    : [params.tree];
+                const offers = entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
                     ? Group.from(entry).offers
                     : [
                         new Offer({
@@ -128,13 +137,12 @@ export var TreeUtils;
                             group: OfferUtils.groupHash(entry),
                         }),
                     ]);
-            if (!("paddedOffers" in params.tree)) {
                 buildDescriptor(offers, { preserveStandaloneGroups: true });
+                items = offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
             }
-            items = offers.map((offer) => ({
-                offer,
-                ratifierData: "0x",
-            }));
         }
         else if (params.ratification.type === "ecrecover") {
             if (params.ratification.signature != null) {
@@ -259,6 +267,7 @@ export var TreeUtils;
         const leaves = offerStructs.map(OfferUtils.hashStruct);
         assertLeafOffers(offerStructs, leaves);
         const height = Math.log2(offerStructs.length);
+        /* v8 ignore next: exercising this branch would require allocating more than 2^20 offer structs. */
         if (height > 20)
             throw new InvalidTreeHeightError(height);
         let level = [...leaves];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/midnight-sdk",
   "description": "Viem-based package for Morpho Midnight that exports protocol utilities, fetch helpers, and Midnight API utilities under a dedicated API subpath.",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -52,7 +52,7 @@
     "viem": "^2.54.2",
     "vitest": "^4.1.9",
     "@morpho-org/morpho-ts": "^2.8.0",
-    "@morpho-org/test": "^2.8.2"
+    "@morpho-org/test": "^2.8.3"
   },
   "scripts": {
     "prepublish": "$npm_execpath build",