@morpho-org/midnight-sdk 1.7.0-next.0 → 1.8.0

package/lib/esm/signatures/{EcrecoverRatifierUtils.js → EcrecoverRatifier.js}

@@ -6,8 +6,9 @@ import { ChainIdMismatchError, InvalidEcrecoverSignatureVError, InvalidTreeError
 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";
+import { Ratifier } from "./Ratifier.js";
+import { parseStandardRatifierTree } from "./standardRatifierInternal.js";
+import { TreeUtils } from "./TreeUtils.js";
 const treeTypeHashes = [
     "0x270da1ebafc0f24637af3612fb8c3a1d828fcb56d3637c24e86dd006b12ca7f9",
     "0x828b9cdf8326a1cf234328e4d5229546a98fb72ef73624f5b6b31538e555b96c",
@@ -127,6 +128,7 @@ function toCanonicalYParity(v) {
  *
  * console.log(EcrecoverRatifierUtils.treeTypeHash(0));
  * ```
+ * @deprecated Use {@link EcrecoverRatifier} with a tagged tree.
  */
 export var EcrecoverRatifierUtils;
 (function (EcrecoverRatifierUtils) {
@@ -203,7 +205,7 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function typedData(params) {
-        const { tree, ratifier: verifyingContract } = RatifierUtils.normalizeRatifierTree({
+        const { tree, ratifier: verifyingContract } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -272,7 +274,7 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function digest(params) {
-        const { tree, ratifier: verifyingContract } = RatifierUtils.normalizeRatifierTree({
+        const { tree, ratifier: verifyingContract } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -372,7 +374,7 @@ export var EcrecoverRatifierUtils;
      * 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
+     * `EcrecoverRatifierUtils.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.
@@ -489,7 +491,7 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     async function sign(params) {
-        const { tree } = RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -697,7 +699,7 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     function ratifierData(params) {
-        const { tree } = RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -771,7 +773,7 @@ export var EcrecoverRatifierUtils;
      * ```
      */
     async function ratify(params) {
-        const { tree } = RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -814,13 +816,148 @@ export var EcrecoverRatifierUtils;
                 account: params.account,
             }));
         }
+        const proofs = TreeUtils.buildProofs({
+            tree,
+            count: tree.offers.length,
+        });
         return tree.offers.map((offer, leafIndex) => ({
             offer,
             ratifierData: encodeRatifierData({
                 signature,
-                ...TreeUtils.buildProof({ tree, leafIndex }),
+                ...proofs[leafIndex],
             }),
         }));
     }
     EcrecoverRatifierUtils.ratify = ratify;
 })(EcrecoverRatifierUtils || (EcrecoverRatifierUtils = {}));
+/**
+ * Tagged-tree API for EcrecoverRatifier with validated portable leaf commitments.
+ * Legacy untagged inputs remain available through {@link EcrecoverRatifierUtils}.
+ */
+export var EcrecoverRatifier;
+(function (EcrecoverRatifier) {
+    /**
+     * Builds Ecrecover signing data from a tagged tree.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.chainId - Chain defining the EIP-712 domain.
+     * @returns EIP-712 domain, type definitions, and offer-tree message.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierTypedDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierTypedDataRequest) {
+     *   return EcrecoverRatifier.typedData(request);
+     * }
+     * ```
+     */
+    function typedData(request) {
+        const tree = parseStandardRatifierTree(request.tree, "ecrecover");
+        return EcrecoverRatifierUtils.typedData({ ...request, tree });
+    }
+    EcrecoverRatifier.typedData = typedData;
+    /**
+     * Computes the signing digest of a tagged Ecrecover tree.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.chainId - Chain defining the EIP-712 domain.
+     * @returns The EIP-712 signing digest.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierTypedDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierTypedDataRequest) {
+     *   return EcrecoverRatifier.digest(request);
+     * }
+     * ```
+     */
+    function digest(request) {
+        const tree = parseStandardRatifierTree(request.tree, "ecrecover");
+        return EcrecoverRatifierUtils.digest({ ...request, tree });
+    }
+    EcrecoverRatifier.digest = digest;
+    /**
+     * Signs a tagged Ecrecover tree using the supplied client and account.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.account - Maker or authorized signer.
+     * @param request.client - Signing client; omit when ratify receives a precomputed signature.
+     * @returns A verified hex signature over the tree.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {ChainIdMismatchError} When the signing client's chain differs from the offers.
+     * @throws {InvalidTypedDataSignatureError} When the signature does not recover to the supplied account.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierSignRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierSignRequest) {
+     *   return EcrecoverRatifier.sign(request);
+     * }
+     * ```
+     */
+    async function sign(request) {
+        const tree = parseStandardRatifierTree(request.tree, "ecrecover");
+        return EcrecoverRatifierUtils.sign({ ...request, tree });
+    }
+    EcrecoverRatifier.sign = sign;
+    /**
+     * Encodes the signature and proof for one tagged Ecrecover leaf.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.signature - Tree signature; ratify may instead request one through the supplied client.
+     * @param request.leafIndex - Leaf to prove.
+     * @returns ABI-encoded ratifier data for the requested leaf.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {InvalidEcrecoverSignatureVError} When a supplied signature has an unsupported recovery value.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierDataRequest) {
+     *   return EcrecoverRatifier.ratifierData(request);
+     * }
+     * ```
+     */
+    function ratifierData(request) {
+        const tree = parseStandardRatifierTree(request.tree, "ecrecover");
+        return EcrecoverRatifierUtils.ratifierData({ ...request, tree });
+    }
+    EcrecoverRatifier.ratifierData = ratifierData;
+    /**
+     * Builds payload items from a tagged tree and a verified signature.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.account - Maker or authorized signer.
+     * @param request.client - Signing client; omit when ratify receives a precomputed signature.
+     * @param request.signature - Tree signature; ratify may instead request one through the supplied client.
+     * @returns One payload item per non-padding offer, including its ratifier data.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {ChainIdMismatchError} When the signing client's chain differs from the offers.
+     * @throws {InvalidTypedDataSignatureError} When the signature does not recover to the supplied account.
+     * @throws {InvalidEcrecoverSignatureVError} When a supplied signature has an unsupported recovery value.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierRatifyRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierRatifyRequest) {
+     *   return EcrecoverRatifier.ratify(request);
+     * }
+     * ```
+     */
+    async function ratify(request) {
+        const tree = parseStandardRatifierTree(request.tree, "ecrecover");
+        return EcrecoverRatifierUtils.ratify({ ...request, tree });
+    }
+    EcrecoverRatifier.ratify = ratify;
+    /** {@inheritDoc EcrecoverRatifierUtils.treeTypeHash} */
+    EcrecoverRatifier.treeTypeHash = EcrecoverRatifierUtils.treeTypeHash;
+    /** {@inheritDoc EcrecoverRatifierUtils.digestForRoot} */
+    EcrecoverRatifier.digestForRoot = EcrecoverRatifierUtils.digestForRoot;
+    /** {@inheritDoc EcrecoverRatifierUtils.digestRatifierData} */
+    EcrecoverRatifier.digestRatifierData = EcrecoverRatifierUtils.digestRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.verifyRatifierData} */
+    EcrecoverRatifier.verifyRatifierData = EcrecoverRatifierUtils.verifyRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.toSignature} */
+    EcrecoverRatifier.toSignature = EcrecoverRatifierUtils.toSignature;
+    /** {@inheritDoc EcrecoverRatifierUtils.encodeRatifierData} */
+    EcrecoverRatifier.encodeRatifierData = EcrecoverRatifierUtils.encodeRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.decodeRatifierData} */
+    EcrecoverRatifier.decodeRatifierData = EcrecoverRatifierUtils.decodeRatifierData;
+})(EcrecoverRatifier || (EcrecoverRatifier = {}));

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

@@ -154,8 +154,11 @@ export declare namespace GroupUtils {
     /**
      * Derives the deterministic content-addressed id for a group of offers.
      *
-     * This mirrors the router implementation: hash each offer with `group = 0`,
-     * sort those hashes, concatenate them, then keccak the result.
+     * Hashes each offer with `group = 0` using the protocol offer hash, sorts
+     * those hashes, concatenates them, then keccaks the result. This matches the
+     * router for Ecrecover and Setter offers only; RateRatifierV1 and
+     * PriceRatifierV1 commit to scheme leaf hashes, so use
+     * `RateRatifierV1.groupId` / `PriceRatifierV1.groupId` for those.
      *
      * @param offers - Offers to hash as one group.
      * @returns Content-addressed group id.
@@ -195,6 +198,56 @@ export declare namespace GroupUtils {
      * ```
      */
     function hash(offers: Iterable<IOffer>): Hash;
+    /**
+     * Derives a content-addressed group id from ratifier-specific member hashes.
+     *
+     * This is the ratifier-agnostic core of {@link hash}: each member hash must
+     * commit the offer with `group = 0` under the scheme the offer is ratified
+     * with (the protocol offer hash for Ecrecover/Setter, the zero-group leaf
+     * hash for `RateRatifierV1`/`PriceRatifierV1`). Hashes are lowercased,
+     * sorted, concatenated, then keccak'd, so neither member order nor hex
+     * casing affects the id.
+     *
+     * @param memberHashes - Zero-group member hashes of one consumption group.
+     * @returns Content-addressed group id.
+     * @throws {InvalidOfferGroupError} when `memberHashes` is empty.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer, RateRatifierV1 } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x000000000000000000000000000000000000a111",
+     *   maxUnits: 100n,
+     * });
+     * const id = GroupUtils.hashMembers([
+     *   RateRatifierV1.memberHash({ offer, rate: 50_000_000_000_000_000n }),
+     * ]);
+     * console.log(id);
+     * ```
+     */
+    function hashMembers(memberHashes: Iterable<Hash>): Hash;
     /**
      * Converts a group into ABI-compatible offers carrying the derived group id.
      *

package/lib/esm/signatures/GroupUtils.js

@@ -73,8 +73,11 @@ export var GroupUtils;
     /**
      * Derives the deterministic content-addressed id for a group of offers.
      *
-     * This mirrors the router implementation: hash each offer with `group = 0`,
-     * sort those hashes, concatenate them, then keccak the result.
+     * Hashes each offer with `group = 0` using the protocol offer hash, sorts
+     * those hashes, concatenates them, then keccaks the result. This matches the
+     * router for Ecrecover and Setter offers only; RateRatifierV1 and
+     * PriceRatifierV1 commit to scheme leaf hashes, so use
+     * `RateRatifierV1.groupId` / `PriceRatifierV1.groupId` for those.
      *
      * @param offers - Offers to hash as one group.
      * @returns Content-addressed group id.
@@ -118,11 +121,67 @@ export var GroupUtils;
         if (offerInputs.length === 0) {
             throw new InvalidOfferGroupError("Provide at least one offer in the group.");
         }
-        const offerHashes = offerInputs.map((offer) => OfferUtils.groupHash(offer));
-        const sorted = offerHashes.length > 1 ? [...offerHashes].sort() : offerHashes;
-        return keccak256(concat(sorted));
+        return hashMembers(offerInputs.map((offer) => OfferUtils.groupHash(offer)));
     }
     GroupUtils.hash = hash;
+    /**
+     * Derives a content-addressed group id from ratifier-specific member hashes.
+     *
+     * This is the ratifier-agnostic core of {@link hash}: each member hash must
+     * commit the offer with `group = 0` under the scheme the offer is ratified
+     * with (the protocol offer hash for Ecrecover/Setter, the zero-group leaf
+     * hash for `RateRatifierV1`/`PriceRatifierV1`). Hashes are lowercased,
+     * sorted, concatenated, then keccak'd, so neither member order nor hex
+     * casing affects the id.
+     *
+     * @param memberHashes - Zero-group member hashes of one consumption group.
+     * @returns Content-addressed group id.
+     * @throws {InvalidOfferGroupError} when `memberHashes` is empty.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer, RateRatifierV1 } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x000000000000000000000000000000000000a111",
+     *   maxUnits: 100n,
+     * });
+     * const id = GroupUtils.hashMembers([
+     *   RateRatifierV1.memberHash({ offer, rate: 50_000_000_000_000_000n }),
+     * ]);
+     * console.log(id);
+     * ```
+     */
+    function hashMembers(memberHashes) {
+        const hashes = Array.from(memberHashes, (h) => h.toLowerCase());
+        if (hashes.length === 0) {
+            throw new InvalidOfferGroupError("Provide at least one member hash in the group.");
+        }
+        const sorted = hashes.length > 1 ? [...hashes].sort() : hashes;
+        return keccak256(concat(sorted));
+    }
+    GroupUtils.hashMembers = hashMembers;
     /**
      * Converts a group into ABI-compatible offers carrying the derived group id.
      *

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

@@ -13,12 +13,12 @@ export declare namespace Payload {
      * `ratifierData` blob a taker hands to `Midnight.take(..., ratifierData)`.
      *
      * `ratifierData` is owned by the ratifier scheme the maker used (e.g.
-     * `EcrecoverRatifierUtils.ratifierData`). The payload codec treats it as
+     * `EcrecoverRatifier.ratifierData`). The payload codec treats it as
      * opaque bytes — simulators that only need to forward `ratifierData` can
      * stay completely ratifier-agnostic.
      *
-     * Build items with `EcrecoverRatifierUtils.ratify` or
-     * `SetterRatifierUtils.ratify` after the tree is signed or approved, then pass
+     * Build items with `EcrecoverRatifier.ratify` or
+     * `SetterRatifier.ratify` after the tree is signed or approved, then pass
      * the items to `Payload.encode` for publication.
      *
      * @example