@morpho-org/midnight-sdk 0.1.0 → 1.1.1

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,54 @@ 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) => GroupUtils.isGroupInput(entry)
+                    ? Group.from(entry).offers
+                    : [
+                        new Offer({
+                            ...Offer.from(entry),
+                            group: OfferUtils.groupHash(entry),
+                        }),
+                    ]);
+            if (!("paddedOffers" in params.tree)) {
+                buildDescriptor(offers, { preserveStandaloneGroups: true });
+            }
+            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 +164,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;
     /**
@@ -208,6 +203,7 @@ export var TreeUtils;
      * make-side code.
      *
      * @param entries - Groups or standalone offers in leaf order.
+     * @param options.preserveStandaloneGroups - Whether standalone offer group ids should be preserved instead of normalized.
      * @returns Tree descriptor.
      * @throws {InvalidTreeError} when the offer count is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the padded tree exceeds supported ratifier typehashes.
@@ -218,12 +214,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",
      *       },
      *     ],
@@ -243,10 +241,17 @@ export var TreeUtils;
      * console.log(tree.root);
      * ```
      */
-    function buildDescriptor(entries) {
-        const structs = entries.flatMap((entry) => "offers" in entry
+    function buildDescriptor(entries, options = {}) {
+        const structs = entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
             ? GroupUtils.toStructs(entry)
-            : [OfferUtils.toStruct({ offer: entry })]);
+            : [
+                OfferUtils.toStruct({
+                    offer: entry,
+                    group: options.preserveStandaloneGroups
+                        ? undefined
+                        : OfferUtils.groupHash(entry),
+                }),
+            ]);
         if (structs.length === 0) {
             throw new InvalidTreeError("Tree must not be empty.");
         }
@@ -290,12 +295,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 +333,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 +344,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 +376,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 +413,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/eip712.d.ts

@@ -0,0 +1,22 @@
+import { type Hash } from "viem";
+/**
+ * Hashes EIP-712 digest parts as `keccak256(0x1901 || domainSeparator || structHash)`.
+ *
+ * Use this when the domain separator and struct hash are already available and
+ * rebuilding full typed-data values would duplicate protocol-specific type maps.
+ *
+ * @param domainSeparator - EIP-712 domain separator hash.
+ * @param structHash - EIP-712 struct hash.
+ * @returns Canonical EIP-712 digest.
+ * @example
+ * ```ts
+ * import { eip712Digest } from "@morpho-org/midnight-sdk";
+ *
+ * const digest = eip712Digest(
+ *   "0x0000000000000000000000000000000000000000000000000000000000000001",
+ *   "0x0000000000000000000000000000000000000000000000000000000000000002",
+ * );
+ * console.log(digest);
+ * ```
+ */
+export declare const eip712Digest: (domainSeparator: Hash, structHash: Hash) => Hash;

package/lib/esm/signatures/eip712.js

@@ -0,0 +1,22 @@
+import { concat, keccak256 } from "viem";
+/**
+ * Hashes EIP-712 digest parts as `keccak256(0x1901 || domainSeparator || structHash)`.
+ *
+ * Use this when the domain separator and struct hash are already available and
+ * rebuilding full typed-data values would duplicate protocol-specific type maps.
+ *
+ * @param domainSeparator - EIP-712 domain separator hash.
+ * @param structHash - EIP-712 struct hash.
+ * @returns Canonical EIP-712 digest.
+ * @example
+ * ```ts
+ * import { eip712Digest } from "@morpho-org/midnight-sdk";
+ *
+ * const digest = eip712Digest(
+ *   "0x0000000000000000000000000000000000000000000000000000000000000001",
+ *   "0x0000000000000000000000000000000000000000000000000000000000000002",
+ * );
+ * console.log(digest);
+ * ```
+ */
+export const eip712Digest = (domainSeparator, structHash) => keccak256(concat(["0x1901", domainSeparator, structHash]));

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

@@ -1,6 +1,8 @@
 export * from "./EcrecoverRatifierUtils.js";
+export * from "./eip712.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,8 @@
 export * from "./EcrecoverRatifierUtils.js";
+export * from "./eip712.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.1.1",
   "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",
@@ -14,16 +17,24 @@
   },
   "license": "MIT",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "./lib/cjs/index.js",
   "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": {
     "*": {
       "api": [
-        "src/api/index.ts"
+        "lib/esm/api/index.d.ts"
       ]
     }
   },
@@ -31,6 +42,18 @@
   "files": [
     "lib"
   ],
+  "peerDependencies": {
+    "@morpho-org/morpho-ts": "^2.8.0",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "fast-check": "^4.8.0",
+    "typescript": "^6.0.3",
+    "viem": "^2.54.2",
+    "vitest": "^4.1.9",
+    "@morpho-org/morpho-ts": "^2.8.0",
+    "@morpho-org/test": "^2.8.2"
+  },
   "scripts": {
     "prepublish": "$npm_execpath build",
     "compile": "node ../../scripts/compile-solidity.js midnight-sdk",
@@ -39,31 +62,5 @@
     "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",
-    "typescript": "^6.0.3",
-    "viem": "2.52.2",
-    "vitest": "^4.1.6"
-  },
-  "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"
-    }
-  }
-}
+  "types": "./lib/esm/index.d.ts"
+}

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>;