@morpho-org/midnight-sdk 0.1.0 → 1.1.1

package/lib/esm/api/MidnightApi.d.ts

@@ -1,9 +1,9 @@
 import type { FetchBookParams, FetchBookPriceLevelsParams, FetchBookQuoteParams, FetchBooksParams, FetchBookTakeableOffersParams, FetchTakeableOffersParams, MempoolPayloadValidationResult, MidnightApiBookPriceLevelsResult, MidnightApiBookResult, MidnightApiBooksResult, MidnightApiBookTakeableOffersResult, MidnightApiClientParams, MidnightApiConstructorConfig, MidnightApiQuoteResult, MidnightApiTakeableOffersResult, ValidateMempoolItemsParams, ValidateMempoolPayloadParams } from "./types.js";
-export type { FetchBookParams, FetchBookPriceLevelsParams, FetchBookQuoteParams, FetchBooksParams, FetchBookTakeableOffersParams, FetchTakeableOffersParams, MempoolPayloadValidationIssue, MempoolPayloadValidationResult, MidnightApiBookMarket, MidnightApiBookPriceLevelsResult, MidnightApiBookResult, MidnightApiBookSide, MidnightApiBookSort, MidnightApiBookSortField, MidnightApiBookSortTerm, MidnightApiBooksResult, MidnightApiBookTakeableOffersResult, MidnightApiClientParams, MidnightApiCollateral, MidnightApiConfig, MidnightApiConstructorConfig, MidnightApiFetch, MidnightApiPriceLevel, MidnightApiQuote, MidnightApiQuoteAssetsTarget, MidnightApiQuoteAverageWorstPriceGuard, MidnightApiQuoteResult, MidnightApiQuoteSlippageGuard, MidnightApiQuoteUnitsTarget, MidnightApiQuoteWithoutGuard, MidnightApiRequestOptions, MidnightApiSlippage, MidnightApiTake, MidnightApiTakeableOffersResult, ValidateMempoolItemsParams, ValidateMempoolPayloadParams, } from "./types.js";
+export type { FetchBookParams, FetchBookPriceLevelsParams, FetchBookQuoteParams, FetchBooksParams, FetchBookTakeableOffersParams, FetchTakeableOffersParams, MempoolPayloadValidationIssue, MempoolPayloadValidationResult, MempoolPayloadValidationSuccess, MidnightApiBookMarket, MidnightApiBookPriceLevelsResult, MidnightApiBookResult, MidnightApiBookSide, MidnightApiBookSort, MidnightApiBookSortField, MidnightApiBookSortTerm, MidnightApiBooksResult, MidnightApiBookTakeableOffersResult, MidnightApiClientParams, MidnightApiCollateral, MidnightApiConfig, MidnightApiConstructorConfig, MidnightApiFetch, MidnightApiPriceLevel, MidnightApiQuote, MidnightApiQuoteAssetsTarget, MidnightApiQuoteAverageWorstPriceGuard, MidnightApiQuoteResult, MidnightApiQuoteSlippageGuard, MidnightApiQuoteUnitsTarget, MidnightApiQuoteWithoutGuard, MidnightApiRequestOptions, MidnightApiSlippage, MidnightApiTake, MidnightApiTakeableOffersResult, ValidateMempoolItemsParams, ValidateMempoolPayloadParams, } from "./types.js";
 /**
  * Midnight API client and stateless helper surface for books and mempool data.
  *
- * Static methods use `https://api.morpho.org/v1/midnight` by default and accept
+ * Static methods use `https://api.morpho.org/v0/midnight` by default and accept
  * per-call configuration. Instances keep shared `baseUrl`, `fetch`, and request
  * options for integrations that make repeated calls.
  * Caller input and successful JSON output shapes are trusted at runtime;
@@ -18,7 +18,7 @@ export type { FetchBookParams, FetchBookPriceLevelsParams, FetchBookQuoteParams,
  *   payload: "0x0100000000",
  * });
  *
- * const api = new MidnightApi("https://api.morpho.org/v1/midnight");
+ * const api = new MidnightApi("https://api.morpho.org/v0/midnight");
  * const configured = await api.validateMempoolPayload({
  *   chainId: 8453,
  *   payload: "0x0100000000",
@@ -42,7 +42,7 @@ export declare class MidnightApi {
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
      *
      * const api = new MidnightApi({
-     *   baseUrl: "https://api.morpho.org/v1/midnight",
+     *   baseUrl: "https://api.morpho.org/v0/midnight",
      * });
      * console.log(api);
      * ```
@@ -216,9 +216,9 @@ export declare class MidnightApi {
      * Validates an encoded Midnight mempool payload against API policy.
      *
      * Use when an integration already has encoded payload bytes and wants API
-     * feedback before publishing those bytes onchain. Normal SDK maker flows
-     * should call `Tree.mempoolValidate` before ratification instead of
-     * validating again after `Payload.encode`.
+     * feedback before publishing those bytes onchain. Normal SDK maker flows can
+     * call `Tree.mempoolValidate` before ratification, or pass ratification
+     * inputs to that helper when validating final payload bytes.
      *
      * Sends `POST /mempool/validate` to the Midnight API. Does not read onchain RPC state.
      *
@@ -247,9 +247,10 @@ export declare class MidnightApi {
      * Encodes SDK-native payload items and validates them against API policy.
      *
      * Use when an integration already has payload-ready items but not encoded
-     * payload bytes. Normal SDK maker flows should call `Tree.mempoolValidate`
-     * before ratification. This helper owns the temporary payload encoding for
-     * validation only.
+     * payload bytes. Normal SDK maker flows can call `Tree.mempoolValidate`
+     * before ratification, or pass ratification inputs to that helper when
+     * validating final payload bytes. This helper owns the temporary payload
+     * encoding for validation only.
      *
      * Encodes `params.items`, then sends `POST /mempool/validate` to the Midnight API. Does not read onchain RPC state.
      *
@@ -260,7 +261,7 @@ export declare class MidnightApi {
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns API issues and `valid` summary.
-     * @throws {Payload.DecodeError} when item encoding fails.
+     * @throws {PayloadDecodeError} when item encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
      * @example
@@ -271,12 +272,14 @@ export declare class MidnightApi {
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -479,8 +482,9 @@ export declare class MidnightApi {
      * Validates payload-ready items with this client's configuration.
      *
      * Use when an integration already has payload-ready items but not encoded
-     * payload bytes. Normal SDK maker flows should call `Tree.mempoolValidate`
-     * before ratification.
+     * payload bytes. Normal SDK maker flows can call `Tree.mempoolValidate`
+     * before ratification, or pass ratification inputs to that helper when
+     * validating final payload bytes.
      *
      * Encodes `params.items`, then sends `POST /mempool/validate` to the Midnight API using this client's configuration. Does not read onchain RPC state.
      *
@@ -488,7 +492,7 @@ export declare class MidnightApi {
      * @param params.items - SDK-native payload items to encode before API validation.
      * @param params.timestamp - Optional ISO-8601 timestamp or `Date` selecting the API policy snapshot.
      * @returns API validation result.
-     * @throws {Payload.DecodeError} when item encoding fails.
+     * @throws {PayloadDecodeError} when item encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
      * @example
@@ -500,12 +504,14 @@ export declare class MidnightApi {
      * const api = new MidnightApi();
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],

package/lib/esm/api/MidnightApi.js

@@ -1,9 +1,12 @@
-import { encode as encodePayload } from "../signatures/Payload.js";
-import { buildBookPath, mapBookMarket, mapPriceLevel, mapTakeableOffer, parseValidationResponse, requestMidnightApi, } from "./helpers.js";
+import { MathLib } from "@morpho-org/morpho-ts";
+import { InvalidMidnightApiResponseError } from "../errors.js";
+import { TickLib } from "../math/index.js";
+import { Payload } from "../signatures/Payload.js";
+import { buildBookPath, mapBookMarket, mapBoundTakeableOffers, mapPriceLevel, parseValidationResponse, requestMidnightApi, } from "./helpers.js";
 /**
  * Midnight API client and stateless helper surface for books and mempool data.
  *
- * Static methods use `https://api.morpho.org/v1/midnight` by default and accept
+ * Static methods use `https://api.morpho.org/v0/midnight` by default and accept
  * per-call configuration. Instances keep shared `baseUrl`, `fetch`, and request
  * options for integrations that make repeated calls.
  * Caller input and successful JSON output shapes are trusted at runtime;
@@ -18,7 +21,7 @@ import { buildBookPath, mapBookMarket, mapPriceLevel, mapTakeableOffer, parseVal
  *   payload: "0x0100000000",
  * });
  *
- * const api = new MidnightApi("https://api.morpho.org/v1/midnight");
+ * const api = new MidnightApi("https://api.morpho.org/v0/midnight");
  * const configured = await api.validateMempoolPayload({
  *   chainId: 8453,
  *   payload: "0x0100000000",
@@ -42,7 +45,7 @@ export class MidnightApi {
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
      *
      * const api = new MidnightApi({
-     *   baseUrl: "https://api.morpho.org/v1/midnight",
+     *   baseUrl: "https://api.morpho.org/v0/midnight",
      * });
      * console.log(api);
      * ```
@@ -217,7 +220,10 @@ export class MidnightApi {
             }),
         });
         return {
-            data: response.data.map(mapTakeableOffer),
+            data: mapBoundTakeableOffers(response.data, {
+                marketId: input.marketId,
+                side: input.side,
+            }),
         };
     }
     /**
@@ -267,7 +273,61 @@ export class MidnightApi {
                 assets: input.assets,
             },
         });
-        const takeableOffers = response.data.takeable_offers.map(mapTakeableOffer);
+        const takeableOffers = mapBoundTakeableOffers(response.data.takeable_offers, {
+            marketId: input.marketId,
+            side: input.side,
+        });
+        const averageWorstPrice = "averageWorstPrice" in input && input.averageWorstPrice != null
+            ? input.averageWorstPrice
+            : "slippage" in input && input.slippage != null
+                ? response.data.average_worst_price
+                : undefined;
+        if (averageWorstPrice != null) {
+            const guard = BigInt(averageWorstPrice);
+            let filledUnits = 0n;
+            let weightedPrice = 0n;
+            if ("units" in input && input.units != null) {
+                let remainingUnits = BigInt(input.units);
+                for (const take of takeableOffers) {
+                    if (remainingUnits === 0n)
+                        break;
+                    const price = TickLib.tickToPrice(take.offer.tick);
+                    const filled = take.units < remainingUnits ? take.units : remainingUnits;
+                    filledUnits += filled;
+                    weightedPrice += filled * price;
+                    remainingUnits -= filled;
+                }
+            }
+            else {
+                let remainingAssets = BigInt(input.assets);
+                for (const take of takeableOffers) {
+                    if (remainingAssets === 0n)
+                        break;
+                    const price = TickLib.tickToPrice(take.offer.tick);
+                    const takeAssets = input.side === "asks"
+                        ? MathLib.mulDivUp(take.units, price, MathLib.WAD)
+                        : MathLib.mulDivDown(take.units, price, MathLib.WAD);
+                    if (takeAssets === 0n)
+                        continue;
+                    const fillsEntireTake = takeAssets <= remainingAssets;
+                    const filled = fillsEntireTake
+                        ? take.units
+                        : MathLib.mulDiv(remainingAssets, MathLib.WAD, price, input.side === "asks" ? "Down" : "Up");
+                    if (filled === 0n)
+                        continue;
+                    filledUnits += filled;
+                    weightedPrice += filled * price;
+                    remainingAssets = fillsEntireTake ? remainingAssets - takeAssets : 0n;
+                }
+            }
+            if (filledUnits > 0n) {
+                const averagePrice = MathLib.mulDivDown(weightedPrice, 1n, filledUnits);
+                const violatesGuard = input.side === "asks" ? averagePrice > guard : averagePrice < guard;
+                if (violatesGuard) {
+                    throw new InvalidMidnightApiResponseError(`Midnight API quote takeable offers imply average price "${averagePrice}" outside average_worst_price guard "${guard}".`);
+                }
+            }
+        }
         return {
             data: {
                 averageBestPrice: response.data.average_best_price,
@@ -320,16 +380,20 @@ export class MidnightApi {
         });
         return {
             cursor: response.cursor,
-            data: response.data.map(mapTakeableOffer),
+            data: mapBoundTakeableOffers(response.data, {
+                maker: input.maker,
+                marketIds: input.marketIds,
+                groups: input.groups,
+            }),
         };
     }
     /**
      * Validates an encoded Midnight mempool payload against API policy.
      *
      * Use when an integration already has encoded payload bytes and wants API
-     * feedback before publishing those bytes onchain. Normal SDK maker flows
-     * should call `Tree.mempoolValidate` before ratification instead of
-     * validating again after `Payload.encode`.
+     * feedback before publishing those bytes onchain. Normal SDK maker flows can
+     * call `Tree.mempoolValidate` before ratification, or pass ratification
+     * inputs to that helper when validating final payload bytes.
      *
      * Sends `POST /mempool/validate` to the Midnight API. Does not read onchain RPC state.
      *
@@ -373,9 +437,10 @@ export class MidnightApi {
      * Encodes SDK-native payload items and validates them against API policy.
      *
      * Use when an integration already has payload-ready items but not encoded
-     * payload bytes. Normal SDK maker flows should call `Tree.mempoolValidate`
-     * before ratification. This helper owns the temporary payload encoding for
-     * validation only.
+     * payload bytes. Normal SDK maker flows can call `Tree.mempoolValidate`
+     * before ratification, or pass ratification inputs to that helper when
+     * validating final payload bytes. This helper owns the temporary payload
+     * encoding for validation only.
      *
      * Encodes `params.items`, then sends `POST /mempool/validate` to the Midnight API. Does not read onchain RPC state.
      *
@@ -386,7 +451,7 @@ export class MidnightApi {
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns API issues and `valid` summary.
-     * @throws {Payload.DecodeError} when item encoding fails.
+     * @throws {PayloadDecodeError} when item encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
      * @example
@@ -397,12 +462,14 @@ export class MidnightApi {
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -428,7 +495,7 @@ export class MidnightApi {
      */
     static async validateMempoolItems(params) {
         const input = params;
-        const payload = await encodePayload(input.items);
+        const payload = await Payload.encode(input.items);
         return MidnightApi.validateMempoolPayload({
             baseUrl: input.baseUrl,
             fetch: input.fetch,
@@ -651,8 +718,9 @@ export class MidnightApi {
      * Validates payload-ready items with this client's configuration.
      *
      * Use when an integration already has payload-ready items but not encoded
-     * payload bytes. Normal SDK maker flows should call `Tree.mempoolValidate`
-     * before ratification.
+     * payload bytes. Normal SDK maker flows can call `Tree.mempoolValidate`
+     * before ratification, or pass ratification inputs to that helper when
+     * validating final payload bytes.
      *
      * Encodes `params.items`, then sends `POST /mempool/validate` to the Midnight API using this client's configuration. Does not read onchain RPC state.
      *
@@ -660,7 +728,7 @@ export class MidnightApi {
      * @param params.items - SDK-native payload items to encode before API validation.
      * @param params.timestamp - Optional ISO-8601 timestamp or `Date` selecting the API policy snapshot.
      * @returns API validation result.
-     * @throws {Payload.DecodeError} when item encoding fails.
+     * @throws {PayloadDecodeError} when item encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
      * @example
@@ -672,12 +740,14 @@ export class MidnightApi {
      * const api = new MidnightApi();
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],

package/lib/esm/api/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Hash } from "viem";
+import { type Address, type Hash } from "viem";
 import type { ApiBookMarketResponse, ApiCollateralResponse, ApiPriceLevelResponse, ApiRequestParams, ApiTakeableOfferResponse, MempoolPayloadValidationResult, MidnightApiBookMarket, MidnightApiBookSide, MidnightApiCollateral, MidnightApiPriceLevel, MidnightApiTake } from "./types.js";
 /** @internal Sends one Midnight API request and maps non-2xx responses to SDK errors. */
 export declare function requestMidnightApi<Response = unknown>(params: ApiRequestParams): Promise<Response>;
@@ -16,5 +16,15 @@ export declare function mapCollateral(collateral: ApiCollateralResponse): Midnig
 export declare function mapPriceLevel(level: ApiPriceLevelResponse): MidnightApiPriceLevel;
 /** @internal Maps a takeable-offer API payload to the SDK response shape. */
 export declare function mapTakeableOffer(takeableOffer: ApiTakeableOfferResponse): MidnightApiTake;
+/** @internal API response context required for a takeable offer to be executable for the caller's request. */
+export interface TakeableOfferContext {
+    readonly marketId?: Hash;
+    readonly side?: MidnightApiBookSide;
+    readonly maker?: Address;
+    readonly marketIds?: readonly Hash[];
+    readonly groups?: readonly Hash[];
+}
+/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+export declare function mapBoundTakeableOffers(takeableOffers: readonly ApiTakeableOfferResponse[], context: TakeableOfferContext): MidnightApiTake[];
 /** @internal Parses the mempool validation response envelope. */
 export declare function parseValidationResponse(response: unknown): MempoolPayloadValidationResult;

package/lib/esm/api/helpers.js

@@ -1,9 +1,11 @@
-import { BLUE_API_BASE_URL } from "@morpho-org/morpho-ts";
+import { BLUE_API_BASE_URL, isHexEqual } from "@morpho-org/morpho-ts";
+import { isAddressEqual } from "viem";
 import { InvalidMidnightApiResponseError, MidnightApiError, } from "../errors.js";
-const DEFAULT_MIDNIGHT_API_URL = new URL("/v1/midnight", BLUE_API_BASE_URL);
+import { MarketUtils } from "../market/index.js";
+const DEFAULT_MIDNIGHT_API_URL = new URL("/v0/midnight", BLUE_API_BASE_URL);
 // Keep this literal in source so the browser ESM build does not import package.json
 // through Node-only createRequire/module shims.
-const MIDNIGHT_SDK_VERSION = "0.1.0";
+const MIDNIGHT_SDK_VERSION = "1.0.1";
 /** @internal Sends one Midnight API request and maps non-2xx responses to SDK errors. */
 export async function requestMidnightApi(params) {
     const baseUrl = new URL(params.baseUrl ?? DEFAULT_MIDNIGHT_API_URL);
@@ -83,6 +85,7 @@ export function mapBookMarket(book) {
     return {
         marketId: book.market_id,
         chainId: book.chain_id,
+        midnight: book.midnight,
         loanToken: book.loan_token,
         collaterals: book.collaterals.map(mapCollateral),
         maturity: book.maturity,
@@ -98,7 +101,7 @@ export function mapCollateral(collateral) {
     return {
         token: collateral.token,
         lltv: collateral.lltv,
-        maxLif: collateral.max_lif,
+        liquidationCursor: collateral.liquidation_cursor,
         oracle: collateral.oracle,
     };
 }
@@ -120,11 +123,13 @@ export function mapTakeableOffer(takeableOffer) {
         units: BigInt(takeableOffer.units),
         offer: {
             market: {
+                chainId: BigInt(offer.market.chain_id),
+                midnight: offer.market.midnight,
                 loanToken: offer.market.loan_token,
                 collateralParams: offer.market.collaterals.map((collateral) => ({
                     token: collateral.token,
                     lltv: BigInt(collateral.lltv),
-                    maxLif: BigInt(collateral.max_lif),
+                    liquidationCursor: BigInt(collateral.liquidation_cursor),
                     oracle: collateral.oracle,
                 })),
                 maturity: BigInt(offer.market.maturity),
@@ -150,6 +155,50 @@ export function mapTakeableOffer(takeableOffer) {
         ratifierData: takeableOffer.ratifier_data,
     };
 }
+/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+export function mapBoundTakeableOffers(takeableOffers, context) {
+    const mapped = takeableOffers.map((takeableOffer) => {
+        const take = mapTakeableOffer(takeableOffer);
+        const embeddedMarketId = MarketUtils.toId(take.offer.market);
+        if (!isHexEqual(embeddedMarketId, take.marketId)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" does not match embedded offer market "${embeddedMarketId}".`);
+        }
+        if (context.marketId != null &&
+            !isHexEqual(take.marketId, context.marketId)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" does not match requested market "${context.marketId}".`);
+        }
+        if (context.marketIds != null &&
+            context.marketIds.length > 0 &&
+            !context.marketIds.some((marketId) => isHexEqual(marketId, take.marketId))) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" is outside the requested market_ids filter.`);
+        }
+        if (context.side != null) {
+            const expectedBuy = context.side === "bids";
+            if (take.offer.buy !== expectedBuy) {
+                throw new InvalidMidnightApiResponseError(`Midnight API ${context.side} takeable offer returned offer.buy "${take.offer.buy}".`);
+            }
+        }
+        if (context.maker != null &&
+            !isAddressEqual(take.offer.maker, context.maker)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer maker "${take.offer.maker}" does not match requested maker "${context.maker}".`);
+        }
+        if (context.groups != null &&
+            context.groups.length > 0 &&
+            !context.groups.some((group) => isHexEqual(group, take.offer.group))) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer group "${take.offer.group}" is outside the requested groups filter.`);
+        }
+        return take;
+    });
+    if (context.side == null)
+        return mapped;
+    return [...mapped].sort((a, b) => {
+        if (a.offer.tick === b.offer.tick)
+            return 0;
+        if (context.side === "asks")
+            return a.offer.tick < b.offer.tick ? -1 : 1;
+        return a.offer.tick > b.offer.tick ? -1 : 1;
+    });
+}
 /** @internal Parses the mempool validation response envelope. */
 export function parseValidationResponse(response) {
     const parsedResponse = requireRecord(response, "validation response");

package/lib/esm/api/types.d.ts

@@ -1,7 +1,7 @@
 import type { BigIntish } from "@morpho-org/morpho-ts";
 import type { Address, Hash, Hex } from "viem";
 import type { OfferStruct } from "../offers/Offer.js";
-import type { Item as MidnightPayloadItem } from "../signatures/Payload.js";
+import type { Payload } from "../signatures/Payload.js";
 /**
  * Fetch implementation used by Midnight API helpers.
  */
@@ -17,7 +17,7 @@ export type MidnightApiRequestOptions = Omit<RequestInit, "method" | "body">;
  * Shared configuration for Midnight API calls.
  */
 export interface MidnightApiConfig {
-    /** Midnight API base URL. Defaults to `https://api.morpho.org/v1/midnight`. */
+    /** Midnight API base URL. Defaults to `https://api.morpho.org/v0/midnight`. */
     readonly baseUrl?: string | URL;
     /** Fetch implementation. Defaults to the global `fetch`. */
     readonly fetch?: MidnightApiFetch;
@@ -70,7 +70,7 @@ export interface ValidateMempoolItemsParams extends MidnightApiConfig {
     /** Chain id whose API policy should validate the payload. */
     readonly chainId: number;
     /** SDK-native payload items to encode before API validation. */
-    readonly items: readonly MidnightPayloadItem[];
+    readonly items: readonly Payload.Item[];
     /** Optional ISO-8601 timestamp or `Date` selecting the API policy snapshot. */
     readonly timestamp?: string | Date;
 }
@@ -209,6 +209,28 @@ export interface MempoolPayloadValidationResult {
     /** Payload-level API issues. */
     readonly issues: readonly MempoolPayloadValidationIssue[];
 }
+/**
+ * Successful Midnight mempool validation result.
+ *
+ * Returned by `Tree.mempoolValidate` and `TreeUtils.mempoolValidate`, which
+ * throw `MidnightMempoolValidationError` instead of returning unsuccessful API
+ * validation results.
+ *
+ * @example
+ * ```ts
+ * import type { MempoolPayloadValidationSuccess } from "@morpho-org/midnight-sdk/api";
+ *
+ * const result: MempoolPayloadValidationSuccess = {
+ *   valid: true,
+ *   issues: [],
+ * };
+ * console.log(result.valid);
+ * ```
+ */
+export type MempoolPayloadValidationSuccess = MempoolPayloadValidationResult & {
+    /** Successful tree validation always has `valid: true`. */
+    readonly valid: true;
+};
 /**
  * Collateral metadata returned by Midnight API book routes.
  */
@@ -217,8 +239,8 @@ export interface MidnightApiCollateral {
     readonly token: Address;
     /** WAD-scaled liquidation loan-to-value. */
     readonly lltv: string;
-    /** WAD-scaled maximum liquidation incentive factor. */
-    readonly maxLif: string;
+    /** WAD-scaled liquidation cursor used to compute the maximum liquidation incentive factor. */
+    readonly liquidationCursor: string;
     /** Oracle address used to price this collateral. */
     readonly oracle: Address;
 }
@@ -245,6 +267,8 @@ export interface MidnightApiBookMarket {
     readonly marketId: Hash;
     /** Chain id the market lives on. */
     readonly chainId: number;
+    /** Core Midnight contract address for the market chain. */
+    readonly midnight: Address;
     /** Loan token address. */
     readonly loanToken: Address;
     /** Collateral definitions for the market. */
@@ -282,9 +306,8 @@ export interface MidnightApiBookResult {
  * ABI-ready take returned by Midnight API book and quote routes.
  *
  * This shape matches the Midnight periphery `Take` tuple. Pass `offer`,
- * `ratifierData`, and `units` directly to `IMidnight.take`, or pass the object
- * in the `takes` array of a target-aware `MidnightBundles` call. `marketId` is
- * API metadata and is ignored by ABI encoders.
+ * `ratifierData`, and `units` directly to `IMidnight.take`. `marketId` is API
+ * metadata and is ignored by ABI encoders.
  */
 export interface MidnightApiTake {
     /** Market id the offer belongs to. */
@@ -361,7 +384,7 @@ export type ApiRequestParams = MidnightApiConfig & {
 export type ApiCollateralResponse = {
     readonly token: Address;
     readonly lltv: string;
-    readonly max_lif: string;
+    readonly liquidation_cursor: string;
     readonly oracle: Address;
 };
 /** @internal Price-level response shape returned by the API. */
@@ -376,6 +399,7 @@ export type ApiPriceLevelResponse = {
 export type ApiBookMarketResponse = {
     readonly market_id: Hash;
     readonly chain_id: number;
+    readonly midnight: Address;
     readonly loan_token: Address;
     readonly collaterals: readonly ApiCollateralResponse[];
     readonly maturity: number;
@@ -400,6 +424,8 @@ export type ApiPriceLevelsResponse = {
 };
 /** @internal Offer market response shape returned by the API. */
 export type ApiOfferMarketResponse = {
+    readonly chain_id: number;
+    readonly midnight: Address;
     readonly loan_token: Address;
     readonly collaterals: readonly ApiCollateralResponse[];
     readonly maturity: number;

package/lib/esm/constants.d.ts

@@ -101,27 +101,28 @@ export declare const MAX_SETTLEMENT_FEES: readonly [14000000000000n, 14000000000
  */
 export declare const MAX_CONTINUOUS_FEE = 317097919n;
 /**
- * Low liquidation cursor used by liquidation incentive factor helpers.
+ * Maximum value accepted by the uint128 offer cap fields.
  *
  * @example
  * ```ts
- * import { LIQUIDATION_CURSOR_LOW } from "@morpho-org/midnight-sdk";
+ * import { MAX_OFFER_CAP } from "@morpho-org/midnight-sdk";
  *
- * console.log(LIQUIDATION_CURSOR_LOW);
+ * console.log(MAX_OFFER_CAP);
  * ```
  */
-export declare const LIQUIDATION_CURSOR_LOW = 250000000000000000n;
+export declare const MAX_OFFER_CAP: bigint;
 /**
- * High liquidation cursor from Midnight ConstantsLib.
+ * Seconds after maturity over which post-maturity LIF reaches the computed
+ * maximum liquidation incentive factor.
  *
  * @example
  * ```ts
- * import { LIQUIDATION_CURSOR_HIGH } from "@morpho-org/midnight-sdk";
+ * import { TIME_TO_MAX_LIF } from "@morpho-org/midnight-sdk";
  *
- * console.log(LIQUIDATION_CURSOR_HIGH);
+ * console.log(TIME_TO_MAX_LIF);
  * ```
  */
-export declare const LIQUIDATION_CURSOR_HIGH = 500000000000000000n;
+export declare const TIME_TO_MAX_LIF: bigint;
 /**
  * HashLib collateral params typehash.
  *
@@ -132,7 +133,7 @@ export declare const LIQUIDATION_CURSOR_HIGH = 500000000000000000n;
  * console.log(COLLATERAL_PARAMS_TYPEHASH);
  * ```
  */
-export declare const COLLATERAL_PARAMS_TYPEHASH = "0xaf44a88eb50ebdbbebd980e5a23045c44f61ece5f80ab708a1bbe8718102e6af";
+export declare const COLLATERAL_PARAMS_TYPEHASH = "0x39ed3f928d24fd00574b1a02aba9c2483abcf5d9a3a366118c9a5aa29885b841";
 /**
  * HashLib market typehash.
  *
@@ -143,7 +144,7 @@ export declare const COLLATERAL_PARAMS_TYPEHASH = "0xaf44a88eb50ebdbbebd980e5a23
  * console.log(MARKET_TYPEHASH);
  * ```
  */
-export declare const MARKET_TYPEHASH = "0x358117e98511cc3df97175dca58053b06675b43ad090b0553f8a1eff008b6e2e";
+export declare const MARKET_TYPEHASH = "0x510b3862f3816a109c9340b76972e8a30984246be06e034ae12ed2934220391a";
 /**
  * HashLib offer typehash.
  *
@@ -154,7 +155,7 @@ export declare const MARKET_TYPEHASH = "0x358117e98511cc3df97175dca58053b06675b4
  * console.log(OFFER_TYPEHASH);
  * ```
  */
-export declare const OFFER_TYPEHASH = "0x6bd2a06ec6952feb97c3e3b4f7de6c342f12b1ac769d5c91368271af636c85b7";
+export declare const OFFER_TYPEHASH = "0x9905214264a9fb7b6cc1b0e33db7a04687c6e4185a84755d29914314aa9d8906";
 /**
  * EcrecoverRatifier EIP-712 domain typehash.
  *