@morpho-org/midnight-sdk 0.1.0 → 1.1.1

package/lib/cjs/signatures/TreeUtils.js

@@ -6,59 +6,12 @@ const viem_1 = require("viem");
 const MidnightApi_js_1 = require("../api/MidnightApi.js");
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../offers/index.js");
+const EcrecoverRatifierUtils_js_1 = require("./EcrecoverRatifierUtils.js");
 const Group_js_1 = require("./Group.js");
 const GroupUtils_js_1 = require("./GroupUtils.js");
+const offerStructInternal_js_1 = require("./offerStructInternal.js");
 const Payload_js_1 = require("./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 = index_js_1.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);
-}
+const SetterRatifierUtils_js_1 = require("./SetterRatifierUtils.js");
 function isPowerOfTwo(value) {
     return value > 0 && (value & (value - 1)) === 0;
 }
@@ -71,13 +24,13 @@ function padOfferStructs(offers) {
     const paddedLength = nextPowerOfTwo(offers.length);
     return [
         ...offers,
-        ...Array.from({ length: paddedLength - offers.length }, () => EMPTY_OFFER_STRUCT),
+        ...Array.from({ length: paddedLength - offers.length }, () => offerStructInternal_js_1.EMPTY_OFFER_STRUCT),
     ];
 }
 function assertLeafOffers(offers, leafHashes) {
     const seen = new Set();
     for (const [index, offer] of offers.entries()) {
-        if (isEmptyOfferStruct(offer))
+        if ((0, offerStructInternal_js_1.isEmptyOfferStruct)(offer, { allowDefaultGroup: true }))
             continue;
         const leafHash = leafHashes[index];
         if (seen.has(leafHash)) {
@@ -109,24 +62,26 @@ 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";
@@ -134,12 +89,14 @@ var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -155,20 +112,54 @@ 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_js_1.Group.from(entry).offers : [index_js_1.Offer.from(entry)]);
-        buildDescriptor(offers);
-        const payload = await (0, Payload_js_1.encode)(offers.map((offer) => ({ offer, ratifierData: "0x" })));
-        return MidnightApi_js_1.MidnightApi.validateMempoolPayload({
+        let items;
+        if (params.ratification == null) {
+            const offers = "paddedOffers" in params.tree
+                ? params.tree.offers
+                : params.tree.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
+                    ? Group_js_1.Group.from(entry).offers
+                    : [
+                        new index_js_1.Offer({
+                            ...index_js_1.Offer.from(entry),
+                            group: index_js_1.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_js_1.EcrecoverRatifierUtils.ratify({
+                    tree: params.tree,
+                    signature: params.ratification.signature,
+                    account: params.ratification.account,
+                });
+            }
+            else {
+                items = await EcrecoverRatifierUtils_js_1.EcrecoverRatifierUtils.ratify({
+                    tree: params.tree,
+                    client: params.ratification.client,
+                    account: params.ratification.account,
+                });
+            }
+        }
+        else {
+            items = SetterRatifierUtils_js_1.SetterRatifierUtils.ratify({ tree: params.tree });
+        }
+        const payload = await Payload_js_1.Payload.encode(items);
+        const validation = await MidnightApi_js_1.MidnightApi.validateMempoolPayload({
             baseUrl: params.apiUrl,
             fetch: params.fetch,
             request: params.request,
@@ -176,6 +167,10 @@ var TreeUtils;
             timestamp: params.timestamp,
             payload,
         });
+        if (!validation.valid) {
+            throw new errors_js_1.MidnightMempoolValidationError(validation.issues);
+        }
+        return { valid: true, issues: validation.issues };
     }
     TreeUtils.mempoolValidate = mempoolValidate;
     /**
@@ -211,6 +206,7 @@ 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.
@@ -221,12 +217,14 @@ var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -246,10 +244,17 @@ 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_js_1.GroupUtils.isGroupInput(entry)
             ? GroupUtils_js_1.GroupUtils.toStructs(entry)
-            : [index_js_1.OfferUtils.toStruct({ offer: entry })]);
+            : [
+                index_js_1.OfferUtils.toStruct({
+                    offer: entry,
+                    group: options.preserveStandaloneGroups
+                        ? undefined
+                        : index_js_1.OfferUtils.groupHash(entry),
+                }),
+            ]);
         if (structs.length === 0) {
             throw new errors_js_1.InvalidTreeError("Tree must not be empty.");
         }
@@ -293,12 +298,14 @@ var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -329,7 +336,7 @@ 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.
@@ -340,12 +347,14 @@ var TreeUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -370,8 +379,7 @@ 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 errors_js_1.InvalidTreeError(`Leaf index "${leafIndex}" is outside the tree.`);
         }
         let index = Number(leafIndex);
@@ -408,12 +416,14 @@ 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/cjs/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/cjs/signatures/eip712.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eip712Digest = void 0;
+const viem_1 = require("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);
+ * ```
+ */
+const eip712Digest = (domainSeparator, structHash) => (0, viem_1.keccak256)((0, viem_1.concat)(["0x1901", domainSeparator, structHash]));
+exports.eip712Digest = eip712Digest;

package/lib/cjs/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/cjs/signatures/index.js

@@ -14,9 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payload = void 0;
 __exportStar(require("./EcrecoverRatifierUtils.js"), exports);
+__exportStar(require("./eip712.js"), exports);
 __exportStar(require("./Group.js"), exports);
 __exportStar(require("./GroupUtils.js"), exports);
+var Payload_js_1 = require("./Payload.js");
+Object.defineProperty(exports, "Payload", { enumerable: true, get: function () { return Payload_js_1.Payload; } });
 __exportStar(require("./RatifierUtils.js"), exports);
 __exportStar(require("./SetterRatifierUtils.js"), exports);
 __exportStar(require("./Tree.js"), exports);

package/lib/cjs/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/cjs/signatures/offerStructInternal.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_OFFER_STRUCT = void 0;
+exports.isZeroAddress = isZeroAddress;
+exports.isEmptyOfferStruct = isEmptyOfferStruct;
+const viem_1 = require("viem");
+const index_js_1 = require("../offers/index.js");
+/** @internal Empty protocol offer struct used for Merkle padding. */
+exports.EMPTY_OFFER_STRUCT = {
+    market: {
+        chainId: 0n,
+        midnight: viem_1.zeroAddress,
+        loanToken: viem_1.zeroAddress,
+        collateralParams: [],
+        maturity: 0n,
+        rcfThreshold: 0n,
+        enterGate: viem_1.zeroAddress,
+        liquidatorGate: viem_1.zeroAddress,
+    },
+    buy: false,
+    maker: viem_1.zeroAddress,
+    start: 0n,
+    expiry: 0n,
+    tick: 0n,
+    group: viem_1.zeroHash,
+    callback: viem_1.zeroAddress,
+    callbackData: "0x",
+    receiverIfMakerIsSeller: viem_1.zeroAddress,
+    ratifier: viem_1.zeroAddress,
+    reduceOnly: false,
+    maxUnits: 0n,
+    maxAssets: 0n,
+    continuousFeeCap: 0n,
+};
+const EMPTY_OFFER_DEFAULT_GROUP = index_js_1.OfferUtils.hashStruct(exports.EMPTY_OFFER_STRUCT);
+/** @internal Returns whether an address value is the zero address. */
+function isZeroAddress(value) {
+    return value.toLowerCase() === viem_1.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.
+ */
+function isEmptyOfferStruct(offer, options = {}) {
+    const hasEmptyGroup = offer.group === viem_1.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);
+}