@morpho-org/midnight-sdk 1.7.0 → 2.0.0

package/lib/esm/signatures/TreeUtils.js

@@ -1,20 +1,20 @@
 import { deepFreeze } from "@morpho-org/morpho-ts";
 import { concat, keccak256, } from "viem";
 import { MidnightApi } from "../api/MidnightApi.js";
+import { MAX_TREE_HEIGHT } from "../constants.js";
 import { InvalidTreeError, InvalidTreeHeightError, MidnightMempoolValidationError, } from "../errors.js";
 import { Offer, OfferUtils, } from "../offers/index.js";
-import { EcrecoverRatifierUtils, } from "./EcrecoverRatifierUtils.js";
+import { EcrecoverRatifierUtils, } from "./EcrecoverRatifier.js";
 import { Group } from "./Group.js";
 import { GroupUtils } from "./GroupUtils.js";
 import { EMPTY_OFFER_STRUCT, isEmptyOfferStruct, } from "./offerStructInternal.js";
 import { Payload } from "./Payload.js";
-import { SetterRatifierUtils } from "./SetterRatifierUtils.js";
-function isPowerOfTwo(value) {
-    return value > 0 && (value & (value - 1)) === 0;
-}
-function nextPowerOfTwo(value) {
-    return 2 ** Math.ceil(Math.log2(value));
-}
+import { PriceRatifierV1 } from "./PriceRatifierV1.js";
+import { RateRatifierV1 } from "./RateRatifierV1.js";
+import { Ratifier } from "./Ratifier.js";
+import { SetterRatifierUtils } from "./SetterRatifier.js";
+import { Tree } from "./Tree.js";
+import { isPowerOfTwo, nextPowerOfTwo } from "./treeMathInternal.js";
 function padOfferStructs(offers) {
     if (isPowerOfTwo(offers.length))
         return [...offers];
@@ -40,6 +40,33 @@ function assertLeafOffers(offers, leafHashes) {
         throw new InvalidTreeError("Tree must not be empty.");
     }
 }
+function buildLayers(leaves) {
+    const layers = [[...leaves]];
+    let level = layers[0];
+    while (level.length > 1) {
+        const next = [];
+        for (let i = 0; i < level.length; i += 2) {
+            next.push(TreeUtils.hashNode(level[i], level[i + 1]));
+        }
+        layers.push(next);
+        level = next;
+    }
+    return layers;
+}
+function assertProvableLeaves(leaves) {
+    if (!isPowerOfTwo(leaves.length)) {
+        throw new InvalidTreeError(`Tree leaf count "${leaves.length}" is not a power of two.`);
+    }
+    const height = Math.log2(leaves.length);
+    if (height > MAX_TREE_HEIGHT)
+        throw new InvalidTreeHeightError(height);
+    return height;
+}
+function computeRootFromLeaves(leaves) {
+    const height = assertProvableLeaves(leaves);
+    const layers = buildLayers(leaves);
+    return { root: layers[height][0], height };
+}
 /**
  * Object-compatible tree hashing, root, proof, and verification helpers.
  *
@@ -57,6 +84,37 @@ function assertLeafOffers(offers, leafHashes) {
  */
 export var TreeUtils;
 (function (TreeUtils) {
+    /**
+     * Normalizes legacy standard tree entries into grouped offers.
+     *
+     * Explicit groups are flattened into their member offers, and every
+     * standalone offer is normalized as a singleton group using the
+     * router-compatible `GroupUtils.hash` group id. Use this when you need the
+     * exact offer list a standard Ecrecover/Setter tree commits to.
+     *
+     * @param entries - Groups or standalone offers in leaf order.
+     * @returns Offers in leaf order with their committed group ids.
+     * @throws {InvalidOfferGroupError} when an explicit group entry violates group mechanics.
+     * @example
+     * ```ts
+     * import { TreeUtils, type TreeCreateParams } from "@morpho-org/midnight-sdk";
+     *
+     * function normalize(entries: TreeCreateParams) {
+     *   return TreeUtils.normalizeEntries(entries);
+     * }
+     * ```
+     */
+    function normalizeEntries(entries) {
+        return entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
+            ? Group.from(entry).offers
+            : [
+                new Offer({
+                    ...Offer.from(entry),
+                    group: GroupUtils.hash([entry]),
+                }),
+            ]);
+    }
+    TreeUtils.normalizeEntries = normalizeEntries;
     /**
      * Validates a tree against Midnight mempool API policy.
      *
@@ -64,17 +122,20 @@ export var TreeUtils;
      * with empty `ratifierData`, then sends the temporary payload to the Midnight
      * API `POST /mempool/validate` endpoint. Pass `ratification` after signing or
      * Setter root preparation to validate final payload bytes with real
-     * `ratifierData`.
+     * `ratifierData`. Price/Rate V1 tree snapshots are supported directly and
+     * always post the corresponding V1 `ratify` output — there is no empty
+     * ratifier-data shape because the router decodes the leaf fields to identify
+     * each offer. A V1 `ratification` only asserts the matching route.
      *
      * @param params.chainId - Chain id whose API policy should validate the tree.
-     * @param params.tree - Offer tree to validate.
+     * @param params.tree - Offer tree or route-typed tree snapshot to validate. Serialized standard snapshots resume without rewriting committed groups.
      * @param params.apiUrl - Optional Midnight API URL override used for the validation HTTP request.
      * @param params.timestamp - Optional ISO-8601 timestamp or `Date` selecting the API policy snapshot.
      * @param params.fetch - Optional fetch implementation override used for the API call.
      * @param params.request - Optional fetch options forwarded to the API request.
-     * @param params.ratification - Optional ratification inputs used to validate final payload bytes with real ratifier data.
+     * @param params.ratification - Optional route-matching ratification inputs used to validate final payload bytes with real ratifier data.
      * @returns Successful API validation result with `valid: true`.
-     * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated.
+     * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated, or when `ratification` does not match the tree route.
      * @throws {InvalidTreeHeightError} when the resulting height is unsupported.
      * @throws {PayloadDecodeError} when validation payload encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
@@ -118,51 +179,72 @@ export var TreeUtils;
      */
     async function mempoolValidate(params) {
         let items;
-        if (params.ratification == null) {
-            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.isGroupInput(entry)
-                    ? Group.from(entry).offers
-                    : [
-                        new Offer({
-                            ...Offer.from(entry),
-                            group: GroupUtils.hash([entry]),
-                        }),
-                    ]);
-                buildDescriptor(entries);
-                items = offers.map((offer) => ({
-                    offer,
-                    ratifierData: "0x",
-                }));
+        if (!Array.isArray(params.tree) &&
+            "type" in params.tree &&
+            (params.tree.type === "priceV1" || params.tree.type === "rateV1")) {
+            const tree = params.tree;
+            if (params.ratification != null &&
+                params.ratification.type !== tree.type) {
+                throw new InvalidTreeError("Ratification route does not match the tree route.");
             }
+            items =
+                tree.type === "priceV1"
+                    ? PriceRatifierV1.ratify({ tree })
+                    : RateRatifierV1.ratify({ tree });
         }
-        else if (params.ratification.type === "ecrecover") {
-            if (params.ratification.signature != null) {
-                items = await EcrecoverRatifierUtils.ratify({
-                    tree: params.tree,
-                    signature: params.ratification.signature,
-                    account: params.ratification.account,
-                });
+        else {
+            // Only standard Ecrecover/Setter inputs remain beyond this point.
+            // Serialized standard snapshots resume through descriptor validation so committed groups are kept.
+            const rawTree = params.tree;
+            const tree = !(rawTree instanceof Tree) &&
+                !Array.isArray(rawTree) &&
+                "entries" in rawTree &&
+                "offers" in rawTree &&
+                "leaves" in rawTree &&
+                "root" in rawTree &&
+                "height" in rawTree
+                ? Tree.fromDescriptor(rawTree)
+                : rawTree;
+            if (params.ratification == null) {
+                if (Array.isArray(tree) || !("paddedOffers" in tree)) {
+                    const entries = Array.isArray(tree) ? tree : [tree];
+                    const offers = normalizeEntries(entries);
+                    buildDescriptor(entries);
+                    items = offers.map((offer) => ({
+                        offer,
+                        ratifierData: "0x",
+                    }));
+                }
+                else {
+                    items = tree.offers.map((offer) => ({
+                        offer,
+                        ratifierData: "0x",
+                    }));
+                }
+            }
+            else if (params.ratification.type === "ecrecover") {
+                if (params.ratification.signature != null) {
+                    items = await EcrecoverRatifierUtils.ratify({
+                        tree,
+                        signature: params.ratification.signature,
+                        account: params.ratification.account,
+                    });
+                }
+                else {
+                    items = await EcrecoverRatifierUtils.ratify({
+                        tree,
+                        client: params.ratification.client,
+                        account: params.ratification.account,
+                    });
+                }
+            }
+            else if (params.ratification.type === "setter") {
+                items = SetterRatifierUtils.ratify({ tree });
             }
             else {
-                items = await EcrecoverRatifierUtils.ratify({
-                    tree: params.tree,
-                    client: params.ratification.client,
-                    account: params.ratification.account,
-                });
+                throw new InvalidTreeError("Ratification route does not match the tree route.");
             }
         }
-        else {
-            items = SetterRatifierUtils.ratify({ tree: params.tree });
-        }
         const payload = await Payload.encode(items);
         const validation = await MidnightApi.validateMempoolPayload({
             baseUrl: params.apiUrl,
@@ -199,56 +281,48 @@ export var TreeUtils;
         return keccak256(concat([left, right]));
     }
     TreeUtils.hashNode = hashNode;
-    /**
-     * Builds a tree descriptor and Merkle root. Non-power-of-two batches are
-     * padded with protocol-zero offers at the highest leaf indices.
-     *
-     * Use after `Group.create` or standalone `Offer.create` when you need the
-     * padded leaves for custom signing, root approval, or proof construction.
-     * Groups are encoded with their derived shared group id, and standalone
-     * offers are encoded as singleton groups with the same algorithm.
-     * `Tree.create` calls this internally and is the simpler API for most
-     * make-side code.
-     *
-     * @param entries - Groups or standalone offers in leaf order.
-     * @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.
-     * @example
-     * ```ts
-     * import { Offer, TreeUtils } 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: "0x0000000000000000000000000000000000004000",
-     *   maxUnits: 100n,
-     * });
-     * const tree = TreeUtils.buildDescriptor([offer]);
-     * console.log(tree.root);
-     * ```
-     */
     function buildDescriptor(entries) {
+        if ("type" in entries) {
+            switch (entries.type) {
+                case "priceV1": {
+                    const descriptor = PriceRatifierV1.buildDescriptor(entries.entries);
+                    return deepFreeze({
+                        ...descriptor,
+                        type: "priceV1",
+                        offers: descriptor.entries
+                            .slice(0, descriptor.offers.length)
+                            .map((entry) => entry.offer),
+                    });
+                }
+                case "rateV1": {
+                    const descriptor = RateRatifierV1.buildDescriptor(entries.entries);
+                    return deepFreeze({
+                        ...descriptor,
+                        type: "rateV1",
+                        offers: descriptor.entries
+                            .slice(0, descriptor.offers.length)
+                            .map((entry) => entry.offer),
+                    });
+                }
+                case "ecrecover":
+                case "setter": {
+                    const { tree } = Ratifier.normalizeRatifierTree({
+                        tree: entries.entries,
+                        label: entries.type === "ecrecover" ? "Ecrecover" : "Setter",
+                    });
+                    return deepFreeze({
+                        type: entries.type,
+                        entries: tree.paddedOffers,
+                        offers: tree.paddedOffers.slice(0, tree.offers.length),
+                        leaves: tree.leaves,
+                        root: tree.root,
+                        height: tree.height,
+                    });
+                }
+                default:
+                    throw new InvalidTreeError("Unsupported tree ratifier route.");
+            }
+        }
         const structs = entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
             ? GroupUtils.toStructs(entry)
             : [
@@ -263,22 +337,11 @@ export var TreeUtils;
         const offerStructs = padOfferStructs(structs);
         const leaves = offerStructs.map(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 InvalidTreeHeightError(height);
-        let level = [...leaves];
-        while (level.length > 1) {
-            const next = [];
-            for (let i = 0; i < level.length; i += 2) {
-                next.push(hashNode(level[i], level[i + 1]));
-            }
-            level = next;
-        }
+        const { root, height } = computeRootFromLeaves(leaves);
         return deepFreeze({
             offers: offerStructs,
             leaves,
-            root: level[0],
+            root,
             height,
         });
     }
@@ -332,17 +395,42 @@ export var TreeUtils;
         return buildDescriptor(entries).root;
     }
     TreeUtils.buildRoot = buildRoot;
+    /**
+     * Builds a Merkle root from already-hashed leaves.
+     *
+     * Use this leaf-hash-agnostic form when a ratifier's leaves are not plain
+     * offer hashes, for example `RateRatifierV1.hashLeaf` outputs. The leaf
+     * count must be a power of two; pad non-power-of-two lists beforehand.
+     *
+     * @param leaves - Leaf hashes in leaf order; length must be a power of two.
+     * @returns Merkle root and tree height.
+     * @throws {InvalidTreeError} when the leaf count is not a power of two.
+     * @throws {InvalidTreeHeightError} when the tree exceeds supported ratifier typehashes.
+     * @example
+     * ```ts
+     * import { TreeUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const { root, height } = TreeUtils.buildRootFromLeaves([zeroHash]);
+     * console.log(height);
+     * ```
+     */
+    function buildRootFromLeaves(leaves) {
+        return computeRootFromLeaves(leaves);
+    }
+    TreeUtils.buildRootFromLeaves = buildRootFromLeaves;
     /**
      * Builds a Merkle proof for one offer.
      *
-     * Use after tree construction when a custom ratifier needs one proof. The
-     * built-in Ecrecover and Setter helpers call this while generating
-     * `ratifierData`.
+     * Use after tree construction when a custom ratifier needs one proof; the
+     * built-in ratify helpers use {@link TreeUtils.buildProofs} to generate
+     * `ratifierData` in bulk.
      *
      * @param params.tree - Tree-like data with the root and leaves that contain the leaf.
      * @param params.leafIndex - Leaf index to prove.
      * @returns Proof descriptor.
-     * @throws {InvalidTreeError} when leaf index is out of range.
+     * @throws {InvalidTreeError} when leaf index is out of range or when the leaf count is not a power of two.
+     * @throws {InvalidTreeHeightError} when the tree height (log2 of the leaf count) exceeds 20.
      * @example
      * ```ts
      * import { Offer, Tree, TreeUtils } from "@morpho-org/midnight-sdk";
@@ -385,21 +473,84 @@ export var TreeUtils;
         if (leafIndex < 0n || leafIndex >= BigInt(params.tree.leaves.length)) {
             throw new InvalidTreeError(`Leaf index "${leafIndex}" is outside the tree.`);
         }
-        let index = Number(leafIndex);
-        let level = [...params.tree.leaves];
-        const proof = [];
-        while (level.length > 1) {
-            proof.push(level[index ^ 1]);
-            const next = [];
-            for (let i = 0; i < level.length; i += 2) {
-                next.push(hashNode(level[i], level[i + 1]));
-            }
-            index = Math.floor(index / 2);
-            level = next;
-        }
+        // Height is unused; the call only validates the leaf set is provable.
+        assertProvableLeaves(params.tree.leaves);
+        const index = Number(leafIndex);
+        const layers = buildLayers(params.tree.leaves);
+        const proof = layers
+            .slice(0, -1)
+            .map((level, layerIndex) => level[(index >> layerIndex) ^ 1]);
         return deepFreeze({ root: params.tree.root, leafIndex, proof });
     }
     TreeUtils.buildProof = buildProof;
+    /**
+     * Builds Merkle proofs for a range of leaves from one tree-layer pass.
+     *
+     * Use instead of calling {@link TreeUtils.buildProof} per leaf when many
+     * proofs are needed at once, for example inside `ratify` helpers: the
+     * parent layers are computed once instead of once per leaf. Each returned
+     * proof is byte-identical to `buildProof` on the same tree and leaf index.
+     *
+     * @param params.tree - Tree leaves and root to prove against.
+     * @param params.count - Number of leading leaf indices to prove; defaults to `tree.leaves.length`.
+     * @returns Frozen proofs for leaf indices `0` through `count - 1`.
+     * @throws {InvalidTreeError} when `count` is negative, non-integer, or exceeds the leaf count, or when the leaf count is not a power of two.
+     * @throws {InvalidTreeHeightError} when the tree height (log2 of the leaf count) exceeds 20.
+     * @example
+     * ```ts
+     * import { Offer, Tree, TreeUtils } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const proofs = TreeUtils.buildProofs({
+     *   tree: Tree.create([offer]),
+     *   count: 1,
+     * });
+     * console.log(proofs[0]!.proof.length);
+     * ```
+     */
+    function buildProofs(params) {
+        const count = params.count ?? params.tree.leaves.length;
+        if (!Number.isInteger(count) ||
+            count < 0 ||
+            count > params.tree.leaves.length) {
+            throw new InvalidTreeError(`Proof count "${count}" is outside the tree.`);
+        }
+        // Height is unused; the call only validates the leaf set is provable.
+        assertProvableLeaves(params.tree.leaves);
+        const layers = buildLayers(params.tree.leaves);
+        const siblingLayers = layers.slice(0, -1);
+        return deepFreeze(Array.from({ length: count }, (_, index) => ({
+            root: params.tree.root,
+            leafIndex: BigInt(index),
+            proof: siblingLayers.map((level, layerIndex) => level[(index >> layerIndex) ^ 1]),
+        })));
+    }
+    TreeUtils.buildProofs = buildProofs;
     /**
      * Verifies a local Merkle proof against a root.
      *
@@ -454,8 +605,43 @@ export var TreeUtils;
      * ```
      */
     function verifyProof(params) {
-        const offer = Offer.from(params.offer);
-        let node = OfferUtils.hash(offer);
+        return verifyLeafProof({
+            leaf: OfferUtils.hash(Offer.from(params.offer)),
+            root: params.root,
+            leafIndex: params.leafIndex,
+            proof: params.proof,
+        });
+    }
+    TreeUtils.verifyProof = verifyProof;
+    /**
+     * Verifies a local Merkle proof for an already-hashed leaf against a root.
+     *
+     * Use this leaf-hash-agnostic form when a ratifier's leaves are not plain
+     * offer hashes, for example `RateRatifierV1.hashLeaf` outputs. The leaf
+     * index determines each sibling's left/right position, matching
+     * `HashLib.isLeaf` onchain.
+     *
+     * @param params.leaf - Leaf hash that starts proof reconstruction.
+     * @param params.root - Expected Merkle root.
+     * @param params.leafIndex - Leaf index proven by `params.proof`.
+     * @param params.proof - Merkle proof siblings for the leaf.
+     * @returns Whether the proof reconstructs the supplied root.
+     * @example
+     * ```ts
+     * import { TreeUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const valid = TreeUtils.verifyLeafProof({
+     *   leaf: zeroHash,
+     *   root: zeroHash,
+     *   leafIndex: 0n,
+     *   proof: [],
+     * });
+     * console.log(valid);
+     * ```
+     */
+    function verifyLeafProof(params) {
+        let node = params.leaf;
         const leafIndex = BigInt(params.leafIndex);
         if (leafIndex < 0n || leafIndex >> BigInt(params.proof.length) !== 0n) {
             return false;
@@ -470,5 +656,5 @@ export var TreeUtils;
         }
         return node === params.root;
     }
-    TreeUtils.verifyProof = verifyProof;
+    TreeUtils.verifyLeafProof = verifyLeafProof;
 })(TreeUtils || (TreeUtils = {}));

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

@@ -1,9 +1,13 @@
-export * from "./EcrecoverRatifierUtils.js";
+export * from "./EcrecoverRatifier.js";
 export * from "./eip712.js";
 export * from "./Group.js";
 export * from "./GroupUtils.js";
 export { Payload } from "./Payload.js";
-export * from "./RatifierUtils.js";
-export * from "./SetterRatifierUtils.js";
+export * from "./PriceRatifierV1.js";
+export * from "./RateRatifierV1.js";
+export * from "./Ratifier.js";
+export type { EcrecoverRatifierDataRequest, EcrecoverRatifierRatifyRequest, EcrecoverRatifierSignRequest, EcrecoverRatifierTypedDataRequest, SetterRatifierDataRequest, SetterRatifierRatifyRequest, } from "./ratifierRequests.js";
+export * from "./SetterRatifier.js";
 export * from "./Tree.js";
 export * from "./TreeUtils.js";
+export type { AnyTree, AnyTreeSnapshot, EcrecoverTreeCreateRequest, PriceRatifierV1TreeCreateRequest, RateRatifierV1TreeCreateRequest, RatifierKind, RatifierTypes, SetterTreeCreateRequest, TreeCreateRequest, TreeData, TreeEntry, TreeSnapshot, TypedRatifierTreeInput, TypedTreeMempoolValidateParams, } from "./treeTypes.js";

package/lib/esm/signatures/index.js

@@ -1,9 +1,11 @@
-export * from "./EcrecoverRatifierUtils.js";
+export * from "./EcrecoverRatifier.js";
 export * from "./eip712.js";
 export * from "./Group.js";
 export * from "./GroupUtils.js";
 export { Payload } from "./Payload.js";
-export * from "./RatifierUtils.js";
-export * from "./SetterRatifierUtils.js";
+export * from "./PriceRatifierV1.js";
+export * from "./RateRatifierV1.js";
+export * from "./Ratifier.js";
+export * from "./SetterRatifier.js";
 export * from "./Tree.js";
 export * from "./TreeUtils.js";

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

@@ -0,0 +1,55 @@
+import type { BigIntish } from "@morpho-org/morpho-ts";
+import type { Account, Address, Chain, Client, Transport } from "viem";
+import type { EcrecoverSignatureInput } from "./EcrecoverRatifier.js";
+import type { TreeSnapshot } from "./treeTypes.js";
+/** Tagged Ecrecover tree and chain used to construct signing data or a digest. */
+export interface EcrecoverRatifierTypedDataRequest {
+    /** Complete Ecrecover leaf commitments, from a tree instance or portable snapshot. */
+    readonly tree: TreeSnapshot<"ecrecover">;
+    /** Chain defining the signing domain. */
+    readonly chainId: BigIntish;
+}
+/** Tagged Ecrecover tree and signer used to request a signature. */
+export interface EcrecoverRatifierSignRequest {
+    /** Complete Ecrecover leaf commitments. */
+    readonly tree: TreeSnapshot<"ecrecover">;
+    /** Client used at the signing boundary. */
+    readonly client: Client<Transport, Chain, Account | undefined>;
+    /** Maker or authorized signer. */
+    readonly account: Account | Address;
+}
+/** Tagged Ecrecover tree with either a signing client or a precomputed signature. */
+export type EcrecoverRatifierRatifyRequest = (EcrecoverRatifierSignRequest & {
+    /** Omit when requesting a signature through the client. */
+    readonly signature?: undefined;
+}) | {
+    /** Complete Ecrecover leaf commitments. */
+    readonly tree: TreeSnapshot<"ecrecover">;
+    /** Maker or authorized signer that produced the signature. */
+    readonly account: Account | Address;
+    /** Signature over this tree's signing digest. */
+    readonly signature: EcrecoverSignatureInput;
+    /** Omit when supplying a precomputed signature. */
+    readonly client?: undefined;
+    /** The chain is derived from the offers when supplying a signature. */
+    readonly chainId?: undefined;
+};
+/** Tagged Ecrecover tree, signature and leaf index used to encode one proof. */
+export interface EcrecoverRatifierDataRequest {
+    /** Complete Ecrecover leaf commitments. */
+    readonly tree: TreeSnapshot<"ecrecover">;
+    /** Leaf to prove. */
+    readonly leafIndex: BigIntish;
+    /** Signature over the tree's signing digest. */
+    readonly signature: EcrecoverSignatureInput;
+}
+/** Tagged Setter tree whose root has been approved onchain. */
+export interface SetterRatifierRatifyRequest {
+    /** Complete Setter leaf commitments; the tag does not prove onchain approval. */
+    readonly tree: TreeSnapshot<"setter">;
+}
+/** Tagged Setter tree and leaf index used to encode one proof. */
+export interface SetterRatifierDataRequest extends SetterRatifierRatifyRequest {
+    /** Leaf to prove. */
+    readonly leafIndex: BigIntish;
+}

package/lib/esm/signatures/ratifierRequests.js

@@ -0,0 +1 @@
+export {};