@morpho-org/midnight-sdk 0.1.0 → 1.1.1

package/lib/esm/signatures/EcrecoverRatifierUtils.js

@@ -1,30 +1,35 @@
 import { deepFreeze } from "@morpho-org/morpho-ts";
-import { concat, decodeAbiParameters, encodeAbiParameters, keccak256, parseSignature, verifyTypedData, } from "viem";
+import { decodeAbiParameters, encodeAbiParameters, keccak256, parseSignature, recoverAddress, serializeSignature, verifyHash, } from "viem";
 import { signTypedData } from "viem/actions";
 import { EIP712_DOMAIN_TYPEHASH } from "../constants.js";
-import { InvalidTreeError, InvalidTreeHeightError, InvalidTypedDataSignatureError, } from "../errors.js";
+import { ChainIdMismatchError, InvalidEcrecoverSignatureVError, InvalidTreeError, InvalidTreeHeightError, InvalidTypedDataSignatureError, } from "../errors.js";
+import { MarketParams } from "../market/index.js";
+import { Offer } from "../offers/index.js";
+import { eip712Digest } from "./eip712.js";
+import { RatifierUtils } from "./RatifierUtils.js";
+import { TreeUtils, } from "./TreeUtils.js";
 const treeTypeHashes = [
-    "0xc27c38e446b48c820ab9c4373dc63a4a750a08165cb4bb488206ebabe045d650",
-    "0x4e15d8736f4406e07bf9844b1653474472a827130c61e899bf1f574a88b8d987",
-    "0x46d107447b480c38ef5b7f54603dba0cb23b887f302b01a998b9d8a80320dd53",
-    "0xd1f3607a8e81454bb3baf5f898274ab47541fffc690278a74f13e174e116be72",
-    "0xb2d98adca9d116c9bc02ce59ec599ac3c2d33db1c0d1217c7e411d9198d427be",
-    "0x5931e0597fcf986027f3118b2495a9ac22139d133f9ad2c2198e6738dc3886c5",
-    "0x3967d37928614a085b47e8758fbc3869a8aed63bdf60ccee8536ff2b5064da06",
-    "0xd6b9f5f45915a260f6e521d9b40f86c385730b6bc330590fcde212e2fea64263",
-    "0x080caa519dbd5328c119d9907e0fa3d9a50dc2ae4bf6dd42c93c100dbc89b51a",
-    "0x45da471048924165ea2ad1855ba940e454b486e71dcf1666c71a928c8844c419",
-    "0xa49a9434fc1836bd08097368325b31039b6a0fd44919f53e4d8f4bf814084cb0",
-    "0xd3e93e4525132f0187a6964dc01fef33fde414538ffd212e9f2f478c3263e0a0",
-    "0x25990db2d26547f92c711988300df317af57bad5cd5d9d8e787a82f95c929474",
-    "0x8e0c648afa977572ead40a1d10a6db2c425b8099545006d834a7b849c6166643",
-    "0x4b635250efa6243e277fdd0cf6df993c2943b64f10f3a0756ceb1f47ef8f9b18",
-    "0xbde1c927f6222c07c8df264e68b42b8382c7c2b85f4729e0df94297cfeebfa91",
-    "0x4d58aea1a67f94be21ab1415bf3b602592430eb9112268fd0fc4e141b1a35e76",
-    "0x14c03281bce13010b158e5a4a3378be394ac9e16118aedb17d82ced51e66836c",
-    "0x99fd3e76f43b2cc221cb9860bc6c96cda95af3fa07ef5f04e071b54aa9386d06",
-    "0x1b1c2f1a04968094d8d0453d49838f7a809d1202ae04a1c2e0964e442ff7988b",
-    "0xc8ccd3cb3267dd76f563584920ac60f2283b719917481b85fe5e10b754932455",
+    "0x270da1ebafc0f24637af3612fb8c3a1d828fcb56d3637c24e86dd006b12ca7f9",
+    "0x828b9cdf8326a1cf234328e4d5229546a98fb72ef73624f5b6b31538e555b96c",
+    "0xfcb7a3ca4094246b8185620c4cf025c93032b6f0384805aa3f22afe04290e982",
+    "0xcc97cb1955496a5269b5a7afca62ba694edcab26ba838a1adbd257931249de92",
+    "0xda3feb08db360ad9e09540132ff04d2b6a596fdaa4747892217aaa4c7c9bcc31",
+    "0x15bd6e2aa1a7a61614187ac16d2cbf8610c8f2f3c3d9eaa380ae7a501ee3cf06",
+    "0xb726cb7fab1a24c28213cbd482fa5a301f127fb25feb01da341919983a72711a",
+    "0xcea9cd557c6f821868ea287304199d0e0554af630bfa8fe36c64eb3bbacca418",
+    "0xf7dbde8234e8e345cec8fc0a8ac5909ee336b214882751ecd51e7b37df4f6cdd",
+    "0x5400a5d43d39e6bfe910af8cb84ac77bf501d310413769dffd62ccecda8b00c6",
+    "0x0754209b60d99d0822b3ecd5a970f9db09df9c8998a8441e24b81f06d6c76fee",
+    "0xf5d561d88647c3b38ed6636709d3166819fc66f8ed52a0daf4ae186387b4646c",
+    "0x5801c07a6c7df039ce00a7a2b8bd92aa1cf333c30b0bc3d78768590b6063d09e",
+    "0xc9da7190eaf4b14c7cb1c14f9898256c0adb6b1dc303afe79594dea64fe199c0",
+    "0xa47534c85ac57c583568465d40fd46683d2d558d8129fe1aca01e93023afca92",
+    "0xb1e841691fb54f4ef85e2ed9de45d610e57f49e1e6eb2510ceead16e447dd519",
+    "0x4fa4f16f09f0c36c7670449a4032073380d28a60071e12ee8874bb3e5a8318fc",
+    "0x817bbaac8bb863670f488b454cdd5d0990d9d81871a68e9df381c3c13d3f2ba2",
+    "0xc447f06079bddf4b011523c4bce119e9e90fdf937de4ee88f48010406560e9c1",
+    "0x1608d5eb56943c667c34b413f9f8a1c24a84ddfe1301a9c25487e638de1f5822",
+    "0x3a677100d2e855c24a62d1e9c365bff90d02287f066a07064843ca1ee70ea113",
 ];
 const signatureAbi = [
     {
@@ -56,10 +61,12 @@ const typedDataTypes = {
     CollateralParams: [
         { name: "token", type: "address" },
         { name: "lltv", type: "uint256" },
-        { name: "maxLif", type: "uint256" },
+        { name: "liquidationCursor", type: "uint256" },
         { name: "oracle", type: "address" },
     ],
     Market: [
+        { name: "chainId", type: "uint256" },
+        { name: "midnight", type: "address" },
         { name: "loanToken", type: "address" },
         { name: "collateralParams", type: "CollateralParams[]" },
         { name: "maturity", type: "uint256" },
@@ -80,8 +87,8 @@ const typedDataTypes = {
         { name: "receiverIfMakerIsSeller", type: "address" },
         { name: "ratifier", type: "address" },
         { name: "reduceOnly", type: "bool" },
-        { name: "maxUnits", type: "uint256" },
-        { name: "maxAssets", type: "uint256" },
+        { name: "maxUnits", type: "uint128" },
+        { name: "maxAssets", type: "uint128" },
         { name: "continuousFeeCap", type: "uint256" },
     ],
 };
@@ -94,21 +101,13 @@ const buildTreeValue = (offers) => {
         buildTreeValue(offers.slice(mid)),
     ];
 };
-const getTreeRatifier = (tree) => {
-    const offers = tree.offers;
-    const firstOffer = offers[0];
-    if (firstOffer == null) {
-        throw new InvalidTreeError("Tree must contain at least one offer.");
-    }
-    const ratifier = firstOffer.ratifier;
-    const comparableRatifier = ratifier.toLowerCase();
-    for (const offer of offers.slice(1)) {
-        if (offer.ratifier.toLowerCase() !== comparableRatifier) {
-            throw new InvalidTreeError(`All offers in an Ecrecover tree must use one ratifier; expected "${ratifier}", got "${offer.ratifier}". Build separate trees per ratifier.`);
-        }
-    }
-    return ratifier;
-};
+function toCanonicalYParity(v) {
+    if (v === 27)
+        return 0;
+    if (v === 28)
+        return 1;
+    throw new InvalidEcrecoverSignatureVError(v);
+}
 /**
  * EcrecoverRatifier-specific pure utilities.
  *
@@ -117,7 +116,10 @@ const getTreeRatifier = (tree) => {
  * validate the tree, sign the typed data, call `ratify`, then pass the returned
  * items to `Payload.encode`. Ecrecover trees must contain one ratifier; split
  * trees by ratifier before signing. The signer may be the maker or an address
- * authorized by every maker in the tree.
+ * authorized by every maker in the tree. Ratifier helpers accept tree-like
+ * inputs rather than requiring the `Tree` class. Passing an existing `Tree`
+ * remains the optimal path because its cached offers, leaves, root, and height
+ * are reused for typed data and per-leaf proofs.
  *
  * @example
  * ```ts
@@ -149,14 +151,14 @@ export var EcrecoverRatifierUtils;
     }
     EcrecoverRatifierUtils.treeTypeHash = treeTypeHash;
     /**
-     * Builds EcrecoverRatifier typed data for a tree.
+     * Builds EcrecoverRatifier typed data for a tree-like input.
      *
      * Use after the tree is built and validated, before requesting the signer
      * signature. The EIP-712 verifier is derived from the shared ratifier address
      * on the tree offers. `ratify` calls this for you when given a client and
      * account.
      *
-     * @param params.tree - Ecrecover-ratified offer tree to sign.
+     * @param params.tree - Ecrecover-ratified offer tree-like input to sign.
      * @param params.chainId - EIP-155 chain id included in the EIP-712 domain.
      * @returns EIP-712 typed-data descriptor.
      * @throws {InvalidTreeError} when the tree is invalid or contains multiple ratifiers.
@@ -169,12 +171,14 @@ export var EcrecoverRatifierUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -199,10 +203,11 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function typedData(params) {
-        const verifyingContract = getTreeRatifier(params.tree);
-        const treeType = params.tree.height === 0
-            ? "Offer"
-            : `Offer${"[2]".repeat(params.tree.height)}`;
+        const { tree, ratifier: verifyingContract } = RatifierUtils.normalizeRatifierTree({
+            tree: params.tree,
+            label: "Ecrecover",
+        });
+        const treeType = tree.height === 0 ? "Offer" : `Offer${"[2]".repeat(tree.height)}`;
         return deepFreeze({
             domain: {
                 chainId: BigInt(params.chainId),
@@ -214,7 +219,7 @@ export var EcrecoverRatifierUtils;
             },
             primaryType: "OfferTree",
             message: {
-                offerTree: buildTreeValue(params.tree.paddedOffers),
+                offerTree: buildTreeValue(tree.paddedOffers),
             },
         });
     }
@@ -222,7 +227,7 @@ export var EcrecoverRatifierUtils;
     /**
      * Builds the EcrecoverRatifier digest used by the Solidity ratifier.
      *
-     * @param params.tree - Ecrecover-ratified offer tree to hash.
+     * @param params.tree - Ecrecover-ratified offer tree-like input to hash.
      * @param params.chainId - EIP-155 chain id included in the EIP-712 domain.
      * @returns EIP-712 digest.
      * @throws {InvalidTreeError} when the tree contains multiple ratifiers.
@@ -235,12 +240,14 @@ export var EcrecoverRatifierUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -265,19 +272,161 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function digest(params) {
-        const verifyingContract = getTreeRatifier(params.tree);
+        const { tree, ratifier: verifyingContract } = RatifierUtils.normalizeRatifierTree({
+            tree: params.tree,
+            label: "Ecrecover",
+        });
         const domainSeparator = keccak256(encodeAbiParameters(domainSeparatorAbi, [
             EIP712_DOMAIN_TYPEHASH,
             BigInt(params.chainId),
             verifyingContract,
         ]));
         const structHash = keccak256(encodeAbiParameters(treeStructHashAbi, [
-            treeTypeHash(params.tree.height),
-            params.tree.root,
+            treeTypeHash(tree.height),
+            tree.root,
         ]));
-        return keccak256(concat(["0x1901", domainSeparator, structHash]));
+        return 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 = Offer.from(params.offer);
+        const market = MarketParams.from(offer.market);
+        const chainId = BigInt(params.chainId);
+        if (chainId !== market.chainId) {
+            throw new ChainIdMismatchError(Number(chainId), market.chainId);
+        }
+        const domainSeparator = keccak256(encodeAbiParameters(domainSeparatorAbi, [
+            EIP712_DOMAIN_TYPEHASH,
+            chainId,
+            offer.ratifier,
+        ]));
+        const structHash = keccak256(encodeAbiParameters(treeStructHashAbi, [
+            treeTypeHash(params.proofLength),
+            params.root,
+        ]));
+        return 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 = Offer.from(params.offer);
+        const decoded = decodeRatifierData(params.ratifierData);
+        if (!TreeUtils.verifyProof({
+            offer,
+            root: decoded.root,
+            leafIndex: decoded.leafIndex,
+            proof: decoded.proof,
+        })) {
+            throw new InvalidTreeError("Ratifier data proof does not include offer.");
+        }
+        const signer = await recoverAddress({
+            hash: digestForRoot({
+                chainId: params.chainId,
+                offer,
+                root: decoded.root,
+                proofLength: decoded.proof.length,
+            }),
+            signature: serializeSignature({
+                r: decoded.signature.r,
+                s: decoded.signature.s,
+                yParity: toCanonicalYParity(decoded.signature.v),
+            }),
+        });
+        return deepFreeze({
+            ...decoded,
+            signer,
+        });
+    }
+    EcrecoverRatifierUtils.verifyRatifierData = verifyRatifierData;
     /**
      * Signs EcrecoverRatifier typed data through a viem client.
      *
@@ -286,12 +435,13 @@ export var EcrecoverRatifierUtils;
      * client and account. The account may be the maker or an address authorized
      * by every maker in the tree; the protocol checks that authorization onchain.
      *
-     * @param params.tree - Ecrecover-ratified offer tree to sign.
+     * @param params.tree - Ecrecover-ratified offer tree-like input to sign.
      * @param params.client - Viem client whose transport signs the tree typed data.
      * @param params.account - Account used to sign the tree typed data.
      * @returns Signature returned by the client.
-     * @throws {InvalidTreeError} when the tree is invalid or contains multiple ratifiers.
+     * @throws {InvalidTreeError} when the tree is invalid, contains multiple ratifiers, or spans multiple chain ids.
      * @throws {InvalidTreeHeightError} when the tree height is unsupported.
+     * @throws {ChainIdMismatchError} when `params.client.chain?.id` does not match the tree offer chain id.
      * @throws {InvalidTypedDataSignatureError} when the returned signature does not recover to `params.account`.
      * @example
      * ```ts
@@ -302,12 +452,14 @@ export var EcrecoverRatifierUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -337,24 +489,46 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     async function sign(params) {
+        const { tree } = RatifierUtils.normalizeRatifierTree({
+            tree: params.tree,
+            label: "Ecrecover",
+        });
+        const expectedChainId = MarketParams.from(tree.offers[0].market).chainId;
+        for (const offer of tree.offers.slice(1)) {
+            const offerChainId = MarketParams.from(offer.market).chainId;
+            if (offerChainId !== expectedChainId) {
+                throw new InvalidTreeError(`All offers in an Ecrecover tree must use one chain id; expected "${expectedChainId}", got "${offerChainId}". Build separate trees per chain.`);
+            }
+        }
+        const clientChainId = params.client.chain?.id;
+        if (clientChainId == null || BigInt(clientChainId) !== expectedChainId) {
+            throw new ChainIdMismatchError(clientChainId, expectedChainId);
+        }
         const signer = typeof params.account === "string"
             ? params.account
             : params.account.address;
         const data = typedData({
-            tree: params.tree,
-            chainId: params.client.chain.id,
+            tree,
+            chainId: expectedChainId,
         });
         const signature = await signTypedData(params.client, {
             account: params.account,
             ...data,
         });
-        const isValidSignature = await verifyTypedData({
-            ...data,
-            address: signer,
-            signature,
-        });
-        if (!isValidSignature)
+        let isValidSignature = false;
+        try {
+            isValidSignature = await verifyHash({
+                address: signer,
+                hash: digest({ tree, chainId: expectedChainId }),
+                signature,
+            });
+        }
+        catch (cause) {
+            throw new InvalidTypedDataSignatureError(signer, cause);
+        }
+        if (!isValidSignature) {
             throw new InvalidTypedDataSignatureError(signer);
+        }
         return signature;
     }
     EcrecoverRatifierUtils.sign = sign;
@@ -378,17 +552,17 @@ export var EcrecoverRatifierUtils;
      */
     function toSignature(signature) {
         if (typeof signature !== "string") {
+            const v = signature.v != null ? Number(signature.v) : Number(signature.yParity);
             return {
-                v: signature.v != null
-                    ? Number(signature.v)
-                    : Number(signature.yParity) + 27,
+                v: v < 27 ? v + 27 : v,
                 r: signature.r,
                 s: signature.s,
             };
         }
         const parsed = parseSignature(signature);
+        const v = Number(parsed.v ?? BigInt(parsed.yParity));
         return {
-            v: Number(parsed.v ?? BigInt(parsed.yParity + 27)),
+            v: v < 27 ? v + 27 : v,
             r: parsed.r,
             s: parsed.s,
         };
@@ -479,7 +653,7 @@ export var EcrecoverRatifierUtils;
      * Use after a tree has been signed when a caller needs data for one offer
      * leaf. Use `ratify` to produce payload-ready items for the whole tree.
      *
-     * @param params.tree - Ecrecover-ratified offer tree that produced the proof.
+     * @param params.tree - Ecrecover-ratified offer tree-like input that produced the proof.
      * @param params.leafIndex - Leaf index to prove.
      * @param params.signature - Ecrecover signature for the tree root.
      * @returns ABI-encoded EcrecoverRatifier data.
@@ -491,12 +665,14 @@ export var EcrecoverRatifierUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -521,8 +697,11 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function ratifierData(params) {
-        getTreeRatifier(params.tree);
-        const proof = params.tree.proof(params.leafIndex);
+        const { tree } = RatifierUtils.normalizeRatifierTree({
+            tree: params.tree,
+            label: "Ecrecover",
+        });
+        const proof = TreeUtils.buildProof({ tree, leafIndex: params.leafIndex });
         return encodeRatifierData({
             signature: toSignature(params.signature),
             root: proof.root,
@@ -538,14 +717,14 @@ export var EcrecoverRatifierUtils;
      * The returned items preserve tree leaf order and include ratifier data
      * required by takers. The group id is stored on each inline offer.
      *
-     * @param params.tree - Ecrecover-ratified offer tree to ratify.
+     * @param params.tree - Ecrecover-ratified offer tree-like input to ratify.
      * @param params.client - Optional viem client whose transport signs typed data built from `params.tree`.
      * @param params.account - Optional account used to sign typed data built from `params.tree`.
      * @param params.signature - Optional precomputed signature for `params.tree`.
      * @returns Items containing each offer and its ratifier data.
      * @throws {InvalidTreeError} when the tree is invalid or contains multiple ratifiers.
      * @throws {InvalidTreeHeightError} when the tree height is unsupported.
-     * @throws {InvalidTypedDataSignatureError} when client signing returns a signature that does not recover to `params.account`.
+     * @throws {InvalidTypedDataSignatureError} when client signing or a precomputed signature does not recover to `params.account`.
      * @example
      * ```ts
      * import { EcrecoverRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
@@ -555,12 +734,14 @@ export var EcrecoverRatifierUtils;
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -590,20 +771,55 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     async function ratify(params) {
+        const { tree } = RatifierUtils.normalizeRatifierTree({
+            tree: params.tree,
+            label: "Ecrecover",
+        });
         let signature;
         if (params.signature != null) {
-            getTreeRatifier(params.tree);
             signature = toSignature(params.signature);
+            const expectedChainId = MarketParams.from(tree.offers[0].market).chainId;
+            for (const offer of tree.offers.slice(1)) {
+                const offerChainId = MarketParams.from(offer.market).chainId;
+                if (offerChainId !== expectedChainId) {
+                    throw new InvalidTreeError(`All offers in an Ecrecover tree must use one chain id; expected "${expectedChainId}", got "${offerChainId}". Build separate trees per chain.`);
+                }
+            }
+            const signer = typeof params.account === "string"
+                ? params.account
+                : params.account.address;
+            let isValidSignature = false;
+            try {
+                isValidSignature = await verifyHash({
+                    address: signer,
+                    hash: digest({ tree, chainId: expectedChainId }),
+                    signature: serializeSignature({
+                        r: signature.r,
+                        s: signature.s,
+                        yParity: signature.v - 27,
+                    }),
+                });
+            }
+            catch (cause) {
+                throw new InvalidTypedDataSignatureError(signer, cause);
+            }
+            if (!isValidSignature) {
+                throw new InvalidTypedDataSignatureError(signer);
+            }
         }
         else {
-            signature = toSignature(await sign(params));
+            signature = toSignature(await sign({
+                tree,
+                client: params.client,
+                account: params.account,
+            }));
         }
         const items = [];
-        for (const offer of params.tree.offers) {
+        for (const offer of tree.offers) {
             items.push({
                 offer,
                 ratifierData: ratifierData({
-                    tree: params.tree,
+                    tree,
                     leafIndex: items.length,
                     signature,
                 }),

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

@@ -18,12 +18,14 @@ import { type GroupInput, type IGroup } from "./GroupUtils.js";
  *
  * const offer = Offer.create({
  *   market: {
+ *     chainId: 8453,
+ *     midnight: "0x0000000000000000000000000000000000001000",
  *     loanToken: "0x0000000000000000000000000000000000006000",
  *     collateralParams: [
  *       {
  *         token: "0x0000000000000000000000000000000000007000",
  *         lltv: 770000000000000000n,
- *         maxLif: 1061007957559681697n,
+ *         liquidationCursor: 250000000000000000n,
  *         oracle: "0x0000000000000000000000000000000000008000",
  *       },
  *     ],
@@ -61,12 +63,14 @@ export declare class Group implements IGroup {
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -104,12 +108,14 @@ export declare class Group implements IGroup {
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],
@@ -149,12 +155,14 @@ export declare class Group implements IGroup {
      *
      * const offer = Offer.create({
      *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
      *     loanToken: "0x0000000000000000000000000000000000006000",
      *     collateralParams: [
      *       {
      *         token: "0x0000000000000000000000000000000000007000",
      *         lltv: 770000000000000000n,
-     *         maxLif: 1061007957559681697n,
+     *         liquidationCursor: 250000000000000000n,
      *         oracle: "0x0000000000000000000000000000000000008000",
      *       },
      *     ],