@morpho-org/midnight-sdk 0.1.0 → 1.0.0

package/lib/esm/signatures/TreeUtils.js

@@ -1,61 +1,14 @@
 import { deepFreeze } from "@morpho-org/morpho-ts";
-import { concat, keccak256 } from "viem";
+import { concat, keccak256, } from "viem";
 import { MidnightApi } from "../api/MidnightApi.js";
-import { InvalidTreeError, InvalidTreeHeightError } from "../errors.js";
+import { InvalidTreeError, InvalidTreeHeightError, MidnightMempoolValidationError, } from "../errors.js";
 import { Offer, OfferUtils, } from "../offers/index.js";
+import { EcrecoverRatifierUtils, } from "./EcrecoverRatifierUtils.js";
 import { Group } from "./Group.js";
 import { GroupUtils } from "./GroupUtils.js";
-import { encode as encodePayload } from "./Payload.js";
-const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-const ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-const EMPTY_OFFER_STRUCT = {
-    market: {
-        loanToken: ZERO_ADDRESS,
-        collateralParams: [],
-        maturity: 0n,
-        rcfThreshold: 0n,
-        enterGate: ZERO_ADDRESS,
-        liquidatorGate: ZERO_ADDRESS,
-    },
-    buy: false,
-    maker: ZERO_ADDRESS,
-    start: 0n,
-    expiry: 0n,
-    tick: 0n,
-    group: ZERO_BYTES32,
-    callback: ZERO_ADDRESS,
-    callbackData: "0x",
-    receiverIfMakerIsSeller: ZERO_ADDRESS,
-    ratifier: ZERO_ADDRESS,
-    reduceOnly: false,
-    maxUnits: 0n,
-    maxAssets: 0n,
-    continuousFeeCap: 0n,
-};
-const EMPTY_OFFER_DEFAULT_GROUP = OfferUtils.hashStruct(EMPTY_OFFER_STRUCT);
-function isEmptyOfferStruct(offer) {
-    return (offer.market.loanToken === ZERO_ADDRESS &&
-        offer.market.collateralParams.length === 0 &&
-        offer.market.maturity === 0n &&
-        offer.market.rcfThreshold === 0n &&
-        offer.market.enterGate === ZERO_ADDRESS &&
-        offer.market.liquidatorGate === ZERO_ADDRESS &&
-        offer.buy === false &&
-        offer.maker === ZERO_ADDRESS &&
-        offer.start === 0n &&
-        offer.expiry === 0n &&
-        offer.tick === 0n &&
-        (offer.group === ZERO_BYTES32 ||
-            offer.group === EMPTY_OFFER_DEFAULT_GROUP) &&
-        offer.callback === ZERO_ADDRESS &&
-        offer.callbackData === "0x" &&
-        offer.receiverIfMakerIsSeller === ZERO_ADDRESS &&
-        offer.ratifier === ZERO_ADDRESS &&
-        offer.reduceOnly === false &&
-        offer.maxUnits === 0n &&
-        offer.maxAssets === 0n &&
-        offer.continuousFeeCap === 0n);
-}
+import { EMPTY_OFFER_STRUCT, isEmptyOfferStruct, } from "./offerStructInternal.js";
+import { Payload } from "./Payload.js";
+import { SetterRatifierUtils } from "./SetterRatifierUtils.js";
 function isPowerOfTwo(value) {
     return value > 0 && (value & (value - 1)) === 0;
 }
@@ -74,7 +27,7 @@ function padOfferStructs(offers) {
 function assertLeafOffers(offers, leafHashes) {
     const seen = new Set();
     for (const [index, offer] of offers.entries()) {
-        if (isEmptyOfferStruct(offer))
+        if (isEmptyOfferStruct(offer, { allowDefaultGroup: true }))
             continue;
         const leafHash = leafHashes[index];
         if (seen.has(leafHash)) {
@@ -106,24 +59,26 @@ export var TreeUtils;
     /**
      * Validates a tree against Midnight mempool API policy.
      *
-     * This is an API-backed convenience: it encodes each tree leaf with empty
-     * `ratifierData`, then sends the temporary payload to the Midnight API
-     * `POST /mempool/validate` endpoint. API policy only inspects offer contents,
-     * so use this after `Tree.create` and before wallet signature or Setter root
-     * approval.
+     * This is an API-backed convenience: by default it encodes each tree leaf
+     * with empty `ratifierData`, then sends the temporary payload to the Midnight
+     * API `POST /mempool/validate` endpoint. Pass `ratification` after signing or
+     * Setter root preparation to validate final payload bytes with real
+     * `ratifierData`.
      *
      * @param params.chainId - Chain id whose API policy should validate the tree.
-     * @param params.tree - Offer tree to validate before ratifier data or payload publication exists.
+     * @param params.tree - Offer tree to validate.
      * @param params.apiUrl - Optional Midnight API URL override used for the validation HTTP request.
      * @param params.timestamp - Optional ISO-8601 timestamp or `Date` selecting the API policy snapshot.
      * @param params.fetch - Optional fetch implementation override used for the API call.
      * @param params.request - Optional fetch options forwarded to the API request.
-     * @returns API issues and `valid` summary.
+     * @param params.ratification - Optional ratification inputs used to validate final payload bytes with real ratifier data.
+     * @returns Successful API validation result with `valid: true`.
      * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the resulting height is unsupported.
-     * @throws {Payload.DecodeError} when validation payload encoding fails.
+     * @throws {PayloadDecodeError} when validation payload encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
+     * @throws {MidnightMempoolValidationError} when the API returns validation issues.
      * @example
      * ```ts
      * import { Offer, TreeUtils } from "@morpho-org/midnight-sdk";
@@ -131,12 +86,14 @@ export var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -152,20 +109,49 @@ export var TreeUtils;
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * const validation = await TreeUtils.mempoolValidate({
+     * await TreeUtils.mempoolValidate({
      *   chainId: 8453,
      *   tree: [offer],
      * });
-     * console.log(validation.valid);
      * ```
      */
     async function mempoolValidate(params) {
-        const offers = "offers" in params.tree
-            ? params.tree.offers
-            : params.tree.flatMap((entry) => "offers" in entry ? Group.from(entry).offers : [Offer.from(entry)]);
-        buildDescriptor(offers);
-        const payload = await encodePayload(offers.map((offer) => ({ offer, ratifierData: "0x" })));
-        return MidnightApi.validateMempoolPayload({
+        let items;
+        if (params.ratification == null) {
+            const offers = "paddedOffers" in params.tree
+                ? params.tree.offers
+                : params.tree.flatMap((entry) => "offers" in entry
+                    ? Group.from(entry).offers
+                    : [Offer.from(entry)]);
+            if (!("paddedOffers" in params.tree)) {
+                buildDescriptor(params.tree);
+            }
+            items = offers.map((offer) => ({
+                offer,
+                ratifierData: "0x",
+            }));
+        }
+        else if (params.ratification.type === "ecrecover") {
+            if (params.ratification.signature != null) {
+                items = await EcrecoverRatifierUtils.ratify({
+                    tree: params.tree,
+                    signature: params.ratification.signature,
+                    account: params.ratification.account,
+                });
+            }
+            else {
+                items = await EcrecoverRatifierUtils.ratify({
+                    tree: params.tree,
+                    client: params.ratification.client,
+                    account: params.ratification.account,
+                });
+            }
+        }
+        else {
+            items = SetterRatifierUtils.ratify({ tree: params.tree });
+        }
+        const payload = await Payload.encode(items);
+        const validation = await MidnightApi.validateMempoolPayload({
             baseUrl: params.apiUrl,
             fetch: params.fetch,
             request: params.request,
@@ -173,6 +159,10 @@ export var TreeUtils;
             timestamp: params.timestamp,
             payload,
         });
+        if (!validation.valid) {
+            throw new MidnightMempoolValidationError(validation.issues);
+        }
+        return { valid: true, issues: validation.issues };
     }
     TreeUtils.mempoolValidate = mempoolValidate;
     /**
@@ -218,12 +208,14 @@ export var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -290,12 +282,14 @@ export var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -326,7 +320,7 @@ export var TreeUtils;
      * built-in Ecrecover and Setter helpers call this while generating
      * `ratifierData`.
      *
-     * @param params.tree - Tree that contains the leaf.
+     * @param params.tree - Tree-like data with the root and leaves that contain the leaf.
      * @param params.leafIndex - Leaf index to prove.
      * @returns Proof descriptor.
      * @throws {InvalidTreeError} when leaf index is out of range.
@@ -337,12 +331,14 @@ export var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -367,8 +363,7 @@ export var TreeUtils;
      */
     function buildProof(params) {
         const leafIndex = BigInt(params.leafIndex);
-        if (leafIndex < 0n ||
-            leafIndex >= BigInt(params.tree.paddedOffers.length)) {
+        if (leafIndex < 0n || leafIndex >= BigInt(params.tree.leaves.length)) {
             throw new InvalidTreeError(`Leaf index "${leafIndex}" is outside the tree.`);
         }
         let index = Number(leafIndex);
@@ -405,12 +400,14 @@ export var TreeUtils;
      *
      * 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/signatures/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./EcrecoverRatifierUtils.js";
 export * from "./Group.js";
 export * from "./GroupUtils.js";
+export { Payload } from "./Payload.js";
 export * from "./RatifierUtils.js";
 export * from "./SetterRatifierUtils.js";
 export * from "./Tree.js";

package/lib/esm/signatures/index.js

@@ -1,6 +1,7 @@
 export * from "./EcrecoverRatifierUtils.js";
 export * from "./Group.js";
 export * from "./GroupUtils.js";
+export { Payload } from "./Payload.js";
 export * from "./RatifierUtils.js";
 export * from "./SetterRatifierUtils.js";
 export * from "./Tree.js";

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

@@ -0,0 +1,14 @@
+import { type OfferStruct } from "../offers/index.js";
+/** @internal Empty protocol offer struct used for Merkle padding. */
+export declare const EMPTY_OFFER_STRUCT: OfferStruct;
+/** @internal Returns whether an address value is the zero address. */
+export declare function isZeroAddress(value: string): boolean;
+/**
+ * @internal Returns whether an offer struct is the protocol empty offer.
+ *
+ * Tree padding may carry the empty offer's derived default group, while payload
+ * decoding only treats the canonical zero-group empty struct as padding.
+ */
+export declare function isEmptyOfferStruct(offer: OfferStruct, options?: {
+    readonly allowDefaultGroup?: boolean;
+}): boolean;

package/lib/esm/signatures/offerStructInternal.js

@@ -0,0 +1,67 @@
+import { zeroAddress, zeroHash } from "viem";
+import { OfferUtils } from "../offers/index.js";
+/** @internal Empty protocol offer struct used for Merkle padding. */
+export const EMPTY_OFFER_STRUCT = {
+    market: {
+        chainId: 0n,
+        midnight: zeroAddress,
+        loanToken: zeroAddress,
+        collateralParams: [],
+        maturity: 0n,
+        rcfThreshold: 0n,
+        enterGate: zeroAddress,
+        liquidatorGate: zeroAddress,
+    },
+    buy: false,
+    maker: zeroAddress,
+    start: 0n,
+    expiry: 0n,
+    tick: 0n,
+    group: zeroHash,
+    callback: zeroAddress,
+    callbackData: "0x",
+    receiverIfMakerIsSeller: zeroAddress,
+    ratifier: zeroAddress,
+    reduceOnly: false,
+    maxUnits: 0n,
+    maxAssets: 0n,
+    continuousFeeCap: 0n,
+};
+const EMPTY_OFFER_DEFAULT_GROUP = OfferUtils.hashStruct(EMPTY_OFFER_STRUCT);
+/** @internal Returns whether an address value is the zero address. */
+export function isZeroAddress(value) {
+    return value.toLowerCase() === zeroAddress;
+}
+/**
+ * @internal Returns whether an offer struct is the protocol empty offer.
+ *
+ * Tree padding may carry the empty offer's derived default group, while payload
+ * decoding only treats the canonical zero-group empty struct as padding.
+ */
+export function isEmptyOfferStruct(offer, options = {}) {
+    const hasEmptyGroup = offer.group === zeroHash ||
+        (options.allowDefaultGroup === true &&
+            offer.group === EMPTY_OFFER_DEFAULT_GROUP);
+    return (offer.market.chainId === 0n &&
+        isZeroAddress(offer.market.midnight) &&
+        isZeroAddress(offer.market.loanToken) &&
+        offer.market.collateralParams.length === 0 &&
+        offer.market.maturity === 0n &&
+        offer.market.rcfThreshold === 0n &&
+        isZeroAddress(offer.market.enterGate) &&
+        isZeroAddress(offer.market.liquidatorGate) &&
+        offer.buy === false &&
+        isZeroAddress(offer.maker) &&
+        offer.start === 0n &&
+        offer.expiry === 0n &&
+        offer.tick === 0n &&
+        hasEmptyGroup &&
+        isZeroAddress(offer.callback) &&
+        offer.callbackData === "0x" &&
+        isZeroAddress(offer.receiverIfMakerIsSeller) &&
+        isZeroAddress(offer.ratifier) &&
+        offer.reduceOnly === false &&
+        offer.maxUnits === 0n &&
+        offer.maxAssets === 0n &&
+        offer.continuousFeeCap === 0n);
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "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": "0.1.0",
+  "version": "1.0.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
   ],
-  "repository": "github:morpho-org/sdks",
+  "repository": {
+    "type": "git",
+    "url": "github:morpho-org/sdks"
+  },
   "homepage": "https://github.com/morpho-org/sdks",
   "bugs": {
     "url": "https://github.com/morpho-org/sdks/issues",
@@ -16,8 +19,16 @@
   "type": "module",
   "main": "src/index.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./api": "./src/api/index.ts",
+    ".": {
+      "types": "./lib/esm/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "./api": {
+      "types": "./lib/esm/api/index.d.ts",
+      "import": "./lib/esm/api/index.js",
+      "require": "./lib/cjs/api/index.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -31,39 +42,24 @@
   "files": [
     "lib"
   ],
-  "scripts": {
-    "prepublish": "$npm_execpath build",
-    "compile": "node ../../scripts/compile-solidity.js midnight-sdk",
-    "build": "tsc --noEmit && $npm_execpath build:cjs && $npm_execpath build:esm",
-    "build:cjs": "tsc --build tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
-    "build:esm": "tsc --build tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > lib/esm/package.json",
-    "test": "vitest --root ../.. --project midnight-sdk"
-  },
   "peerDependencies": {
     "@morpho-org/morpho-ts": "^2.7.0",
     "viem": "^2.0.0"
   },
   "devDependencies": {
-    "@morpho-org/morpho-ts": "workspace:^",
-    "@morpho-org/test": "workspace:^",
-    "fast-check": "^4.4.0",
+    "fast-check": "^4.8.0",
     "typescript": "^6.0.3",
-    "viem": "2.52.2",
-    "vitest": "^4.1.6"
+    "viem": "^2.54.2",
+    "vitest": "^4.1.9",
+    "@morpho-org/morpho-ts": "^2.7.0",
+    "@morpho-org/test": "^2.8.1"
   },
-  "publishConfig": {
-    "exports": {
-      ".": {
-        "types": "./lib/esm/index.d.ts",
-        "import": "./lib/esm/index.js",
-        "require": "./lib/cjs/index.js"
-      },
-      "./api": {
-        "types": "./lib/esm/api/index.d.ts",
-        "import": "./lib/esm/api/index.js",
-        "require": "./lib/cjs/api/index.js"
-      },
-      "./package.json": "./package.json"
-    }
+  "scripts": {
+    "prepublish": "$npm_execpath build",
+    "compile": "node ../../scripts/compile-solidity.js midnight-sdk",
+    "build": "tsc --noEmit && $npm_execpath build:cjs && $npm_execpath build:esm",
+    "build:cjs": "tsc --build tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
+    "build:esm": "tsc --build tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > lib/esm/package.json",
+    "test": "vitest --root ../.. --project midnight-sdk"
   }
-}
+}

package/src/index.ts

@@ -16,4 +16,4 @@ export * from "./signatures/index.js";
  * Encoded payloads are always `Hex` strings ready to be included in onchain
  * mempool submission calldata.
  */
-export * as Payload from "./signatures/Payload.js";
+export { Payload } from "./signatures/Payload.js";

package/lib/cjs/fetch/Offer.d.ts

@@ -1,74 +0,0 @@
-import { type BigIntish } from "@morpho-org/morpho-ts";
-import type { Address, Client, Hash } from "viem";
-import type { MidnightFetchParams } from "./types.js";
-/**
- * Fetches and computes remaining consumable units for an offer.
- *
- * Unit-capped offers skip settlement-fee lookup, matching the Solidity
- * library's early return. For asset-capped offers, pass the time to maturity
- * for the same block context as the quote.
- *
- * Reads `eth_chainId` only when the viem client has no configured chain id,
- * then reads `Midnight.consumed(offer.maker, group)` and
- * `Midnight.continuousFee(marketId)`. If the offer's continuous fee cap is
- * below the market's current continuous fee, returns zero. For asset-capped
- * offers where `offer.maxUnits` is zero, also reads
- * `Midnight.settlementFee(marketId, timeToMaturity)`.
- *
- * @param client - Viem client used for the reads.
- * @param params.marketId - Market id used for settlement-fee lookup on asset-capped offers.
- * @param params.offer.buy - Whether the maker buys loan assets.
- * @param params.offer.maker - Maker address whose consumed group amount is read.
- * @param params.offer.tick - Offer tick used for asset-to-unit conversion.
- * @param params.offer.maxUnits - Unit cap; when non-zero, settlement-fee lookup is skipped.
- * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
- * @param params.offer.continuousFeeCap - Maximum market continuous fee accepted by this offer.
- * @param params.group - Offer group id whose consumed amount is read.
- * @param params.timeToMaturity - Time to maturity used for settlement-fee lookup on asset-capped offers.
- * @param params.account - Optional account used as the `from` field for the reads.
- * @param params.blockNumber - Optional block number used for the reads.
- * @param params.blockTag - Optional block tag used for the reads.
- * @param params.stateOverride - Optional state override set used for the reads.
- * @returns Consumable units.
- * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
- * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
- * @throws {NegativeValueError} when asset-capped `timeToMaturity`, offer caps, or SDK math inputs are negative.
- * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
- * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
- * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
- * @example
- * ```ts
- * import { fetchConsumableUnits } from "@morpho-org/midnight-sdk";
- * import { createPublicClient, http, zeroHash } from "viem";
- * import { base } from "viem/chains";
- *
- * const client = createPublicClient({ chain: base, transport: http() });
- * const units = await fetchConsumableUnits(client, {
- *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
- *   offer: {
- *     buy: true,
- *     maker: "0x0000000000000000000000000000000000009000",
- *     tick: 5_000n,
- *     maxUnits: 100n,
- *     maxAssets: 0n,
- *     continuousFeeCap: 317097919n,
- *   },
- *   group: zeroHash,
- *   timeToMaturity: 3_600n,
- * });
- * console.log(units);
- * ```
- */
-export declare function fetchConsumableUnits(client: Client, params: MidnightFetchParams & {
-    readonly marketId: Hash;
-    readonly offer: {
-        readonly buy: boolean;
-        readonly maker: Address;
-        readonly tick: BigIntish;
-        readonly maxUnits: BigIntish;
-        readonly maxAssets: BigIntish;
-        readonly continuousFeeCap: BigIntish;
-    };
-    readonly group: Hash;
-    readonly timeToMaturity: BigIntish;
-}): Promise<bigint>;

package/lib/cjs/fetch/Offer.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchConsumableUnits = fetchConsumableUnits;
-const morpho_ts_1 = require("@morpho-org/morpho-ts");
-const actions_1 = require("viem/actions");
-const abis_js_1 = require("../abis.js");
-const index_js_1 = require("../math/index.js");
-const index_js_2 = require("../offers/index.js");
-const utils_js_1 = require("./utils.js");
-/**
- * Fetches and computes remaining consumable units for an offer.
- *
- * Unit-capped offers skip settlement-fee lookup, matching the Solidity
- * library's early return. For asset-capped offers, pass the time to maturity
- * for the same block context as the quote.
- *
- * Reads `eth_chainId` only when the viem client has no configured chain id,
- * then reads `Midnight.consumed(offer.maker, group)` and
- * `Midnight.continuousFee(marketId)`. If the offer's continuous fee cap is
- * below the market's current continuous fee, returns zero. For asset-capped
- * offers where `offer.maxUnits` is zero, also reads
- * `Midnight.settlementFee(marketId, timeToMaturity)`.
- *
- * @param client - Viem client used for the reads.
- * @param params.marketId - Market id used for settlement-fee lookup on asset-capped offers.
- * @param params.offer.buy - Whether the maker buys loan assets.
- * @param params.offer.maker - Maker address whose consumed group amount is read.
- * @param params.offer.tick - Offer tick used for asset-to-unit conversion.
- * @param params.offer.maxUnits - Unit cap; when non-zero, settlement-fee lookup is skipped.
- * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
- * @param params.offer.continuousFeeCap - Maximum market continuous fee accepted by this offer.
- * @param params.group - Offer group id whose consumed amount is read.
- * @param params.timeToMaturity - Time to maturity used for settlement-fee lookup on asset-capped offers.
- * @param params.account - Optional account used as the `from` field for the reads.
- * @param params.blockNumber - Optional block number used for the reads.
- * @param params.blockTag - Optional block tag used for the reads.
- * @param params.stateOverride - Optional state override set used for the reads.
- * @returns Consumable units.
- * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
- * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
- * @throws {NegativeValueError} when asset-capped `timeToMaturity`, offer caps, or SDK math inputs are negative.
- * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
- * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
- * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
- * @example
- * ```ts
- * import { fetchConsumableUnits } from "@morpho-org/midnight-sdk";
- * import { createPublicClient, http, zeroHash } from "viem";
- * import { base } from "viem/chains";
- *
- * const client = createPublicClient({ chain: base, transport: http() });
- * const units = await fetchConsumableUnits(client, {
- *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
- *   offer: {
- *     buy: true,
- *     maker: "0x0000000000000000000000000000000000009000",
- *     tick: 5_000n,
- *     maxUnits: 100n,
- *     maxAssets: 0n,
- *     continuousFeeCap: 317097919n,
- *   },
- *   group: zeroHash,
- *   timeToMaturity: 3_600n,
- * });
- * console.log(units);
- * ```
- */
-async function fetchConsumableUnits(client, params) {
-    const maxUnits = BigInt(params.offer.maxUnits);
-    const maxAssets = BigInt(params.offer.maxAssets);
-    const continuousFeeCap = BigInt(params.offer.continuousFeeCap);
-    (0, morpho_ts_1.assertNonNegative)("offer.maxUnits", maxUnits);
-    (0, morpho_ts_1.assertNonNegative)("offer.maxAssets", maxAssets);
-    (0, morpho_ts_1.assertNonNegative)("offer.continuousFeeCap", continuousFeeCap);
-    index_js_2.OfferUtils.validateOfferCaps({ maxUnits, maxAssets });
-    const needsSettlementFee = maxUnits === 0n;
-    const timeToMaturity = needsSettlementFee
-        ? BigInt(params.timeToMaturity)
-        : 0n;
-    if (needsSettlementFee) {
-        (0, morpho_ts_1.assertNonNegative)("timeToMaturity", timeToMaturity);
-    }
-    const chainId = await (0, utils_js_1.resolveChainId)(client);
-    const midnight = (0, morpho_ts_1.getChainAddress)(chainId, "midnight");
-    const consumed = (0, actions_1.readContract)(client, {
-        ...(0, utils_js_1.callParameters)(params),
-        address: midnight,
-        abi: abis_js_1.midnightAbi,
-        functionName: "consumed",
-        args: [params.offer.maker, params.group],
-    });
-    const continuousFee = (0, actions_1.readContract)(client, {
-        ...(0, utils_js_1.callParameters)(params),
-        address: midnight,
-        abi: abis_js_1.midnightAbi,
-        functionName: "continuousFee",
-        args: [params.marketId],
-    });
-    const [consumedValue, marketContinuousFee] = await Promise.all([
-        consumed,
-        continuousFee,
-    ]);
-    if (continuousFeeCap < BigInt(marketContinuousFee))
-        return 0n;
-    const settlementFee = needsSettlementFee
-        ? await (0, actions_1.readContract)(client, {
-            ...(0, utils_js_1.callParameters)(params),
-            address: midnight,
-            abi: abis_js_1.midnightAbi,
-            functionName: "settlementFee",
-            args: [params.marketId, timeToMaturity],
-        })
-        : 0n;
-    return index_js_1.ConsumableUnitsLib.consumableUnits({
-        offer: params.offer,
-        consumed: consumedValue,
-        settlementFee,
-    });
-}