@morpho-org/midnight-sdk 1.0.0 → 1.2.0

package/lib/cjs/signatures/EcrecoverRatifierUtils.js

@@ -7,6 +7,8 @@ const actions_1 = require("viem/actions");
 const constants_js_1 = require("../constants.js");
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../market/index.js");
+const index_js_2 = require("../offers/index.js");
+const eip712_js_1 = require("./eip712.js");
 const RatifierUtils_js_1 = require("./RatifierUtils.js");
 const TreeUtils_js_1 = require("./TreeUtils.js");
 const treeTypeHashes = [
@@ -102,6 +104,13 @@ const buildTreeValue = (offers) => {
         buildTreeValue(offers.slice(mid)),
     ];
 };
+function toCanonicalYParity(v) {
+    if (v === 27)
+        return 0;
+    if (v === 28)
+        return 1;
+    throw new errors_js_1.InvalidEcrecoverSignatureVError(v);
+}
 /**
  * EcrecoverRatifier-specific pure utilities.
  *
@@ -279,9 +288,148 @@ var EcrecoverRatifierUtils;
             treeTypeHash(tree.height),
             tree.root,
         ]));
-        return (0, viem_1.keccak256)((0, viem_1.concat)(["0x1901", domainSeparator, structHash]));
+        return (0, eip712_js_1.eip712Digest)(domainSeparator, structHash);
     }
     EcrecoverRatifierUtils.digest = digest;
+    /**
+     * Builds the EcrecoverRatifier digest from a payload offer, root, and proof height.
+     *
+     * Use this on the take-side or in indexers after decoding ratifier data, when
+     * the original full tree is not available but the payload item includes the
+     * offer and proof metadata needed to reconstruct the signed digest. Pass the
+     * observed log or execution chain id so cross-chain-spoofed payloads are
+     * rejected before signature recovery.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.root - Merkle root embedded in the ratifier data.
+     * @param params.proofLength - Number of sibling hashes in the Merkle proof.
+     * @returns EIP-712 digest signed by the maker or authorized signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidTreeHeightError} when `proofLength` exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const digest = EcrecoverRatifierUtils.digestForRoot({
+     *   chainId: 8453n,
+     *   offer,
+     *   root: zeroHash,
+     *   proofLength: 0,
+     * });
+     * console.log(digest);
+     * ```
+     */
+    function digestForRoot(params) {
+        const offer = index_js_2.Offer.from(params.offer);
+        const market = index_js_1.MarketParams.from(offer.market);
+        const chainId = BigInt(params.chainId);
+        if (chainId !== market.chainId) {
+            throw new errors_js_1.ChainIdMismatchError(Number(chainId), market.chainId);
+        }
+        const domainSeparator = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)(domainSeparatorAbi, [
+            constants_js_1.EIP712_DOMAIN_TYPEHASH,
+            chainId,
+            offer.ratifier,
+        ]));
+        const structHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)(treeStructHashAbi, [
+            treeTypeHash(params.proofLength),
+            params.root,
+        ]));
+        return (0, eip712_js_1.eip712Digest)(domainSeparator, structHash);
+    }
+    EcrecoverRatifierUtils.digestForRoot = digestForRoot;
+    /**
+     * Builds the EcrecoverRatifier digest from one payload item's encoded ratifier data.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Ecrecover ratifier data.
+     * @returns EIP-712 digest signed by the maker or authorized signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidTreeHeightError} when the proof height exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const digest = EcrecoverRatifierUtils.digestRatifierData({
+     *   chainId: 8453n,
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(digest);
+     * ```
+     */
+    function digestRatifierData(params) {
+        const decoded = decodeRatifierData(params.ratifierData);
+        return digestForRoot({
+            chainId: params.chainId,
+            offer: params.offer,
+            root: decoded.root,
+            proofLength: decoded.proof.length,
+        });
+    }
+    EcrecoverRatifierUtils.digestRatifierData = digestRatifierData;
+    /**
+     * Verifies an Ecrecover ratifier-data proof and recovers its signer.
+     *
+     * This helper intentionally does not check `Midnight.isAuthorized` or
+     * `EcrecoverRatifier.isRootCanceled` state. Consumers must query both at the
+     * observed block before treating a recovered item as executable: the returned
+     * signer must be the maker or authorized by the maker, the offer ratifier must
+     * be authorized by the maker, and `isRootCanceled(maker, root)` must be false.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Ecrecover ratifier data.
+     * @returns Decoded ratifier data plus recovered signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidEcrecoverSignatureVError} when the decoded signature `v` is not 27 or 28.
+     * @throws {InvalidTreeError} when the proof does not include `offer` in `root`.
+     * @throws {InvalidTreeHeightError} when the proof height exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const verified = await EcrecoverRatifierUtils.verifyRatifierData({
+     *   chainId: 8453n,
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(verified.signer);
+     * ```
+     */
+    async function verifyRatifierData(params) {
+        const offer = index_js_2.Offer.from(params.offer);
+        const decoded = decodeRatifierData(params.ratifierData);
+        if (!TreeUtils_js_1.TreeUtils.verifyProof({
+            offer,
+            root: decoded.root,
+            leafIndex: decoded.leafIndex,
+            proof: decoded.proof,
+        })) {
+            throw new errors_js_1.InvalidTreeError("Ratifier data proof does not include offer.");
+        }
+        const signer = await (0, viem_1.recoverAddress)({
+            hash: digestForRoot({
+                chainId: params.chainId,
+                offer,
+                root: decoded.root,
+                proofLength: decoded.proof.length,
+            }),
+            signature: (0, viem_1.serializeSignature)({
+                r: decoded.signature.r,
+                s: decoded.signature.s,
+                yParity: toCanonicalYParity(decoded.signature.v),
+            }),
+        });
+        return (0, morpho_ts_1.deepFreeze)({
+            ...decoded,
+            signer,
+        });
+    }
+    EcrecoverRatifierUtils.verifyRatifierData = verifyRatifierData;
     /**
      * Signs EcrecoverRatifier typed data through a viem client.
      *

package/lib/cjs/signatures/Group.js

@@ -144,9 +144,11 @@ class Group {
      * ```
      */
     static from(entry) {
-        return entry instanceof Group
-            ? entry
-            : new Group("offers" in entry ? entry.offers : [entry]);
+        if (entry instanceof Group)
+            return entry;
+        if (GroupUtils_js_1.GroupUtils.isGroupInput(entry))
+            return new Group(entry.offers);
+        return new Group([entry]);
     }
     /**
      * Creates a protocol-valid offer group.

package/lib/cjs/signatures/GroupUtils.d.ts

@@ -103,6 +103,54 @@ export type GroupInput = IGroup | IOffer;
  * ```
  */
 export declare namespace GroupUtils {
+    /**
+     * Returns whether an entry is an explicit group rather than a standalone offer.
+     *
+     * Plain offer objects can also contain incidental `offers` properties, so the
+     * discriminant must reject values that still carry the offer `market` field.
+     *
+     * @param entry - Group or offer input to inspect.
+     * @returns Whether `entry` is an explicit group input.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = Offer.from({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: "0x0000000000000000000000000000000000000000",
+     *     liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   start: 0n,
+     *   expiry: 3_600n,
+     *   tick: 5_000n,
+     *   callback: "0x0000000000000000000000000000000000000000",
+     *   callbackData: "0x",
+     *   receiverIfMakerIsSeller: "0x0000000000000000000000000000000000000000",
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   reduceOnly: false,
+     *   maxUnits: 100n,
+     *   maxAssets: 0n,
+     *   continuousFeeCap: 0n,
+     * });
+     * console.log(GroupUtils.isGroupInput(offer));
+     * ```
+     */
+    function isGroupInput(entry: GroupInput): entry is IGroup;
     /**
      * Derives the deterministic content-addressed id for a group of offers.
      *

package/lib/cjs/signatures/GroupUtils.js

@@ -22,6 +22,57 @@ const index_js_1 = require("../offers/index.js");
  */
 var GroupUtils;
 (function (GroupUtils) {
+    /**
+     * Returns whether an entry is an explicit group rather than a standalone offer.
+     *
+     * Plain offer objects can also contain incidental `offers` properties, so the
+     * discriminant must reject values that still carry the offer `market` field.
+     *
+     * @param entry - Group or offer input to inspect.
+     * @returns Whether `entry` is an explicit group input.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     *
+     * const offer = Offer.from({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: "0x0000000000000000000000000000000000000000",
+     *     liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   start: 0n,
+     *   expiry: 3_600n,
+     *   tick: 5_000n,
+     *   callback: "0x0000000000000000000000000000000000000000",
+     *   callbackData: "0x",
+     *   receiverIfMakerIsSeller: "0x0000000000000000000000000000000000000000",
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   reduceOnly: false,
+     *   maxUnits: 100n,
+     *   maxAssets: 0n,
+     *   continuousFeeCap: 0n,
+     * });
+     * console.log(GroupUtils.isGroupInput(offer));
+     * ```
+     */
+    function isGroupInput(entry) {
+        return "offers" in entry && !("market" in entry);
+    }
+    GroupUtils.isGroupInput = isGroupInput;
     /**
      * Derives the deterministic content-addressed id for a group of offers.
      *

package/lib/cjs/signatures/RatifierUtils.js

@@ -4,6 +4,7 @@ exports.RatifierUtils = void 0;
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../offers/index.js");
 const Group_js_1 = require("./Group.js");
+const GroupUtils_js_1 = require("./GroupUtils.js");
 const TreeUtils_js_1 = require("./TreeUtils.js");
 function isTreeLike(tree) {
     return (!Array.isArray(tree) &&
@@ -14,10 +15,21 @@ function isTreeLike(tree) {
         "height" in tree);
 }
 function normalizeTree(tree) {
-    if (isTreeLike(tree))
+    if (isTreeLike(tree)) {
         return tree;
-    const offers = tree.flatMap((entry) => "offers" in entry ? Group_js_1.Group.from(entry).offers : [index_js_1.Offer.from(entry)]);
-    const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(offers);
+    }
+    const entries = Array.isArray(tree) ? tree : [tree];
+    const offers = entries.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),
+            }),
+        ]);
+    const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(offers, {
+        preserveStandaloneGroups: true,
+    });
     return {
         offers,
         paddedOffers: descriptor.offers,

package/lib/cjs/signatures/SetterRatifierUtils.d.ts

@@ -1,5 +1,6 @@
 import { type BigIntish } from "@morpho-org/morpho-ts";
 import { type Hash, type Hex } from "viem";
+import { type IOffer } from "../offers/index.js";
 import type { Payload } from "./Payload.js";
 import { type RatifierTreeInput, type TreeProof } from "./TreeUtils.js";
 /**
@@ -74,6 +75,13 @@ export interface SetterRatifierDataParams {
     /** Leaf index to prove. */
     readonly leafIndex: BigIntish;
 }
+/** Parameters for locally verifying Setter ratifier data attached to one payload item. */
+export interface SetterRatifierDataVerificationParams {
+    /** Offer carried by the payload item. */
+    readonly offer: IOffer;
+    /** ABI-encoded Setter ratifier data carried by the payload item. */
+    readonly ratifierData: Hex;
+}
 /**
  * SetterRatifier-specific pure utilities.
  *
@@ -144,6 +152,29 @@ export declare namespace SetterRatifierUtils {
      * ```
      */
     function decodeRatifierData(data: Hex): DecodedSetterRatifierData;
+    /**
+     * Verifies that Setter ratifier data proves one payload offer belongs to its root.
+     *
+     * This helper intentionally does not check `SetterRatifier.isRootRatified` or
+     * `Midnight.isAuthorized` state. Consumers can query those values at their
+     * own block context after local proof verification.
+     *
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Setter ratifier data.
+     * @returns Decoded Setter ratifier data after proof verification.
+     * @throws {InvalidTreeError} when the proof does not include `offer` in `root`.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const decoded = SetterRatifierUtils.verifyRatifierData({
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(decoded.root);
+     * ```
+     */
+    function verifyRatifierData(params: SetterRatifierDataVerificationParams): DecodedSetterRatifierData;
     /**
      * Builds one ratifier-data value for a tree leaf.
      *

package/lib/cjs/signatures/SetterRatifierUtils.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetterRatifierUtils = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const viem_1 = require("viem");
+const errors_js_1 = require("../errors.js");
+const index_js_1 = require("../offers/index.js");
 const RatifierUtils_js_1 = require("./RatifierUtils.js");
 const TreeUtils_js_1 = require("./TreeUtils.js");
 const setterRatifierDataAbi = [
@@ -88,6 +90,42 @@ var SetterRatifierUtils;
         return (0, morpho_ts_1.deepFreeze)({ root, leafIndex, proof: [...proof] });
     }
     SetterRatifierUtils.decodeRatifierData = decodeRatifierData;
+    /**
+     * Verifies that Setter ratifier data proves one payload offer belongs to its root.
+     *
+     * This helper intentionally does not check `SetterRatifier.isRootRatified` or
+     * `Midnight.isAuthorized` state. Consumers can query those values at their
+     * own block context after local proof verification.
+     *
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Setter ratifier data.
+     * @returns Decoded Setter ratifier data after proof verification.
+     * @throws {InvalidTreeError} when the proof does not include `offer` in `root`.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const decoded = SetterRatifierUtils.verifyRatifierData({
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(decoded.root);
+     * ```
+     */
+    function verifyRatifierData(params) {
+        const offer = index_js_1.Offer.from(params.offer);
+        const decoded = decodeRatifierData(params.ratifierData);
+        if (!TreeUtils_js_1.TreeUtils.verifyProof({
+            offer,
+            root: decoded.root,
+            leafIndex: decoded.leafIndex,
+            proof: decoded.proof,
+        })) {
+            throw new errors_js_1.InvalidTreeError("Ratifier data proof does not include offer.");
+        }
+        return decoded;
+    }
+    SetterRatifierUtils.verifyRatifierData = verifyRatifierData;
     /**
      * Builds one ratifier-data value for a tree leaf.
      *

package/lib/cjs/signatures/Tree.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tree = void 0;
 const index_js_1 = require("../offers/index.js");
 const Group_js_1 = require("./Group.js");
+const GroupUtils_js_1 = require("./GroupUtils.js");
 const TreeUtils_js_1 = require("./TreeUtils.js");
 /**
  * Maker-side Merkle tree used by Midnight ratifiers.
@@ -57,8 +58,15 @@ class Tree {
     /** Tree height. */
     height;
     constructor(params) {
-        this.offers = params.flatMap((entry) => "offers" in entry ? Group_js_1.Group.from(entry).offers : [index_js_1.Offer.from(entry)]);
-        const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(this.offers);
+        this.offers = params.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),
+                }),
+            ]);
+        const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(params);
         this.paddedOffers = descriptor.offers;
         this.leaves = descriptor.leaves;
         this.root = descriptor.root;
@@ -110,7 +118,9 @@ class Tree {
      * ```
      */
     static from(tree) {
-        return tree instanceof Tree ? tree : Tree.create(tree);
+        if (tree instanceof Tree)
+            return tree;
+        return Tree.create(Array.isArray(tree) ? tree : [tree]);
     }
     /**
      * Creates a tree from groups or standalone offers.

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

@@ -188,7 +188,7 @@ export type TreeCreateParams = readonly GroupInput[];
  * console.log(tree);
  * ```
  */
-export type TreeInput = Tree | TreeCreateParams;
+export type TreeInput = Tree | TreeCreateParams | GroupInput;
 /**
  * Tree-shaped data required by ratifier helpers.
  *
@@ -284,7 +284,7 @@ export interface TreeLike {
  * console.log(tree);
  * ```
  */
-export type RatifierTreeInput = TreeLike | TreeCreateParams;
+export type RatifierTreeInput = TreeLike | TreeInput;
 /**
  * Optional ratification inputs for {@link Tree.mempoolValidate}.
  *
@@ -494,6 +494,7 @@ export declare namespace 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.
@@ -531,7 +532,9 @@ export declare namespace TreeUtils {
      * console.log(tree.root);
      * ```
      */
-    function buildDescriptor(entries: TreeCreateParams): TreeDescriptor;
+    function buildDescriptor(entries: TreeCreateParams, options?: {
+        readonly preserveStandaloneGroups?: boolean;
+    }): TreeDescriptor;
     /**
      * Builds only the tree root.
      *

package/lib/cjs/signatures/TreeUtils.js

@@ -38,6 +38,7 @@ function assertLeafOffers(offers, leafHashes) {
         }
         seen.add(leafHash);
     }
+    /* v8 ignore next: buildDescriptor rejects empty struct lists before padding; this protects direct internal misuse. */
     if (seen.size === 0) {
         throw new errors_js_1.InvalidTreeError("Tree must not be empty.");
     }
@@ -121,18 +122,30 @@ var TreeUtils;
     async function mempoolValidate(params) {
         let items;
         if (params.ratification == null) {
-            const offers = "paddedOffers" in params.tree
-                ? params.tree.offers
-                : params.tree.flatMap((entry) => "offers" in entry
+            if ("paddedOffers" in params.tree) {
+                items = params.tree.offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
+            }
+            else {
+                const entries = Array.isArray(params.tree)
+                    ? params.tree
+                    : [params.tree];
+                const offers = entries.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
                     ? Group_js_1.Group.from(entry).offers
-                    : [index_js_1.Offer.from(entry)]);
-            if (!("paddedOffers" in params.tree)) {
-                buildDescriptor(params.tree);
+                    : [
+                        new index_js_1.Offer({
+                            ...index_js_1.Offer.from(entry),
+                            group: index_js_1.OfferUtils.groupHash(entry),
+                        }),
+                    ]);
+                buildDescriptor(offers, { preserveStandaloneGroups: true });
+                items = offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
             }
-            items = offers.map((offer) => ({
-                offer,
-                ratifierData: "0x",
-            }));
         }
         else if (params.ratification.type === "ecrecover") {
             if (params.ratification.signature != null) {
@@ -201,6 +214,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.
@@ -238,10 +252,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.");
         }
@@ -249,6 +270,7 @@ var TreeUtils;
         const leaves = offerStructs.map(index_js_1.OfferUtils.hashStruct);
         assertLeafOffers(offerStructs, leaves);
         const height = Math.log2(offerStructs.length);
+        /* v8 ignore next: exercising this branch would require allocating more than 2^20 offer structs. */
         if (height > 20)
             throw new errors_js_1.InvalidTreeHeightError(height);
         let level = [...leaves];

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,4 +1,5 @@
 export * from "./EcrecoverRatifierUtils.js";
+export * from "./eip712.js";
 export * from "./Group.js";
 export * from "./GroupUtils.js";
 export { Payload } from "./Payload.js";

package/lib/cjs/signatures/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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");