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

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EcrecoverRatifierUtils = void 0;
+exports.EcrecoverRatifier = exports.EcrecoverRatifierUtils = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const viem_1 = require("viem");
 const actions_1 = require("viem/actions");
@@ -9,7 +9,8 @@ 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 Ratifier_js_1 = require("./Ratifier.js");
+const standardRatifierInternal_js_1 = require("./standardRatifierInternal.js");
 const TreeUtils_js_1 = require("./TreeUtils.js");
 const treeTypeHashes = [
     "0x270da1ebafc0f24637af3612fb8c3a1d828fcb56d3637c24e86dd006b12ca7f9",
@@ -130,6 +131,7 @@ function toCanonicalYParity(v) {
  *
  * console.log(EcrecoverRatifierUtils.treeTypeHash(0));
  * ```
+ * @deprecated Use {@link EcrecoverRatifier} with a tagged tree.
  */
 var EcrecoverRatifierUtils;
 (function (EcrecoverRatifierUtils) {
@@ -206,7 +208,7 @@ var EcrecoverRatifierUtils;
      * ```
      */
     function typedData(params) {
-        const { tree, ratifier: verifyingContract } = RatifierUtils_js_1.RatifierUtils.normalizeRatifierTree({
+        const { tree, ratifier: verifyingContract } = Ratifier_js_1.Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -275,7 +277,7 @@ var EcrecoverRatifierUtils;
      * ```
      */
     function digest(params) {
-        const { tree, ratifier: verifyingContract } = RatifierUtils_js_1.RatifierUtils.normalizeRatifierTree({
+        const { tree, ratifier: verifyingContract } = Ratifier_js_1.Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -375,7 +377,7 @@ 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.
@@ -492,7 +494,7 @@ var EcrecoverRatifierUtils;
      * ```
      */
     async function sign(params) {
-        const { tree } = RatifierUtils_js_1.RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier_js_1.Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -700,7 +702,7 @@ var EcrecoverRatifierUtils;
      * ```
      */
     function ratifierData(params) {
-        const { tree } = RatifierUtils_js_1.RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier_js_1.Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -774,7 +776,7 @@ var EcrecoverRatifierUtils;
      * ```
      */
     async function ratify(params) {
-        const { tree } = RatifierUtils_js_1.RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier_js_1.Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Ecrecover",
         });
@@ -817,13 +819,148 @@ var EcrecoverRatifierUtils;
                 account: params.account,
             }));
         }
+        const proofs = TreeUtils_js_1.TreeUtils.buildProofs({
+            tree,
+            count: tree.offers.length,
+        });
         return tree.offers.map((offer, leafIndex) => ({
             offer,
             ratifierData: encodeRatifierData({
                 signature,
-                ...TreeUtils_js_1.TreeUtils.buildProof({ tree, leafIndex }),
+                ...proofs[leafIndex],
             }),
         }));
     }
     EcrecoverRatifierUtils.ratify = ratify;
 })(EcrecoverRatifierUtils || (exports.EcrecoverRatifierUtils = EcrecoverRatifierUtils = {}));
+/**
+ * Tagged-tree API for EcrecoverRatifier with validated portable leaf commitments.
+ * Legacy untagged inputs remain available through {@link EcrecoverRatifierUtils}.
+ */
+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 = (0, standardRatifierInternal_js_1.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 = (0, standardRatifierInternal_js_1.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 = (0, standardRatifierInternal_js_1.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 = (0, standardRatifierInternal_js_1.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 = (0, standardRatifierInternal_js_1.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 || (exports.EcrecoverRatifier = EcrecoverRatifier = {}));

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

@@ -76,8 +76,11 @@ 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.
@@ -121,11 +124,67 @@ var GroupUtils;
         if (offerInputs.length === 0) {
             throw new errors_js_1.InvalidOfferGroupError("Provide at least one offer in the group.");
         }
-        const offerHashes = offerInputs.map((offer) => index_js_1.OfferUtils.groupHash(offer));
-        const sorted = offerHashes.length > 1 ? [...offerHashes].sort() : offerHashes;
-        return (0, viem_1.keccak256)((0, viem_1.concat)(sorted));
+        return hashMembers(offerInputs.map((offer) => index_js_1.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 errors_js_1.InvalidOfferGroupError("Provide at least one member hash in the group.");
+        }
+        const sorted = hashes.length > 1 ? [...hashes].sort() : hashes;
+        return (0, viem_1.keccak256)((0, viem_1.concat)(sorted));
+    }
+    GroupUtils.hashMembers = hashMembers;
     /**
      * Converts a group into ABI-compatible offers carrying the derived group id.
      *

package/lib/cjs/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