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

package/lib/{cjs/signatures/RatifierUtils.d.ts → esm/signatures/Ratifier.d.ts}

@@ -1,7 +1,7 @@
 import type { Address, Hex } from "viem";
 import type { RatifierTreeInput, TreeLike } from "./TreeUtils.js";
 /**
- * Parameters for {@link RatifierUtils.getRatifierInfo}.
+ * Parameters for {@link Ratifier.getRatifierInfo}.
  *
  * Pass the maker account bytecode read at the same block context used to build
  * the offer. The bytecode is used only to choose the ratifier address to put on
@@ -60,12 +60,12 @@ export interface RatifierInfo {
  *
  * @example
  * ```ts
- * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+ * import { Ratifier } from "@morpho-org/midnight-sdk";
  *
- * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+ * console.log(Ratifier.isEip7702Designator("0xef0100"));
  * ```
  */
-export declare namespace RatifierUtils {
+export declare namespace Ratifier {
     /**
      * Normalizes a ratifier tree input and asserts it uses one ratifier address.
      *
@@ -80,7 +80,7 @@ export declare namespace RatifierUtils {
      * @throws {InvalidTreeHeightError} when the tree height is unsupported.
      * @example
      * ```ts
-     * import { Offer, RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Offer, Ratifier } from "@morpho-org/midnight-sdk";
      * import { zeroAddress } from "viem";
      *
      * const offer = Offer.create({
@@ -108,7 +108,7 @@ export declare namespace RatifierUtils {
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * const { tree, ratifier } = RatifierUtils.normalizeRatifierTree({
+     * const { tree, ratifier } = Ratifier.normalizeRatifierTree({
      *   tree: [offer],
      *   label: "Ecrecover",
      * });
@@ -132,9 +132,9 @@ export declare namespace RatifierUtils {
      * @returns Whether the bytecode starts with `0xef0100`.
      * @example
      * ```ts
-     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Ratifier } from "@morpho-org/midnight-sdk";
      *
-     * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+     * console.log(Ratifier.isEip7702Designator("0xef0100"));
      * ```
      */
     function isEip7702Designator(bytecode: Hex): boolean;
@@ -143,8 +143,8 @@ export declare namespace RatifierUtils {
      * accounts.
      *
      * Use the returned `ratifier` address in `Offer.create`. Later, use
-     * `EcrecoverRatifierUtils.ratify` when `type` is `ecrecover`, or approve the
-     * root and call `SetterRatifierUtils.ratify` when `type` is `setter`.
+     * `EcrecoverRatifier.ratify` when `type` is `ecrecover`, or approve the
+     * root and call `SetterRatifier.ratify` when `type` is `setter`.
      *
      * @param params.bytecode - Maker bytecode returned by `eth_getCode`.
      * @param params.ecrecoverRatifier - Ratifier address used for EOAs and EIP-7702 accounts.
@@ -152,9 +152,9 @@ export declare namespace RatifierUtils {
      * @returns Ratifier information for the maker.
      * @example
      * ```ts
-     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Ratifier } from "@morpho-org/midnight-sdk";
      *
-     * const info = RatifierUtils.getRatifierInfo({
+     * const info = Ratifier.getRatifierInfo({
      *   bytecode: "0x",
      *   ecrecoverRatifier: "0x0000000000000000000000000000000000000001",
      *   setterRatifier: "0x0000000000000000000000000000000000000002",
@@ -164,3 +164,5 @@ export declare namespace RatifierUtils {
      */
     function getRatifierInfo(params: GetRatifierInfoParams): RatifierInfo;
 }
+/** @deprecated Use {@link Ratifier}. Retained for compatibility. */
+export { Ratifier as RatifierUtils };

package/lib/esm/signatures/{RatifierUtils.js → Ratifier.js}

@@ -1,9 +1,9 @@
+import { MAX_TREE_HEIGHT } from "../constants.js";
 import { InvalidTreeError, InvalidTreeHeightError } from "../errors.js";
-import { Offer, OfferUtils } from "../offers/index.js";
-import { Group } from "./Group.js";
-import { GroupUtils } from "./GroupUtils.js";
+import { OfferUtils } from "../offers/index.js";
 import { isEmptyOfferStruct } from "./offerStructInternal.js";
 import { TreeUtils } from "./TreeUtils.js";
+import { nextPowerOfTwo } from "./treeMathInternal.js";
 function isTreeLike(tree) {
     return (!Array.isArray(tree) &&
         "offers" in tree &&
@@ -14,13 +14,15 @@ function isTreeLike(tree) {
 }
 function normalizeTree(tree) {
     if (isTreeLike(tree)) {
-        if (!Number.isInteger(tree.height) || tree.height < 0 || tree.height > 20) {
+        if (!Number.isInteger(tree.height) ||
+            tree.height < 0 ||
+            tree.height > MAX_TREE_HEIGHT) {
             throw new InvalidTreeHeightError(tree.height);
         }
         const expectedLength = 2 ** tree.height;
         if (tree.paddedOffers.length !== expectedLength ||
             tree.leaves.length !== expectedLength ||
-            tree.offers.length > expectedLength) {
+            expectedLength !== nextPowerOfTwo(tree.offers.length)) {
             throw new InvalidTreeError("Tree offers, leaves, and height describe different trees.");
         }
         const computedLeaves = tree.paddedOffers.map(OfferUtils.hashStruct);
@@ -60,14 +62,7 @@ function normalizeTree(tree) {
         return tree;
     }
     const entries = Array.isArray(tree) ? tree : [tree];
-    const offers = entries.flatMap((entry) => GroupUtils.isGroupInput(entry)
-        ? Group.from(entry).offers
-        : [
-            new Offer({
-                ...Offer.from(entry),
-                group: GroupUtils.hash([entry]),
-            }),
-        ]);
+    const offers = TreeUtils.normalizeEntries(entries);
     const descriptor = TreeUtils.buildDescriptor(entries);
     return {
         offers,
@@ -101,13 +96,13 @@ function assertRatifierTree(params) {
  *
  * @example
  * ```ts
- * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+ * import { Ratifier } from "@morpho-org/midnight-sdk";
  *
- * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+ * console.log(Ratifier.isEip7702Designator("0xef0100"));
  * ```
  */
-export var RatifierUtils;
-(function (RatifierUtils) {
+export var Ratifier;
+(function (Ratifier) {
     /**
      * Normalizes a ratifier tree input and asserts it uses one ratifier address.
      *
@@ -122,7 +117,7 @@ export var RatifierUtils;
      * @throws {InvalidTreeHeightError} when the tree height is unsupported.
      * @example
      * ```ts
-     * import { Offer, RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Offer, Ratifier } from "@morpho-org/midnight-sdk";
      * import { zeroAddress } from "viem";
      *
      * const offer = Offer.create({
@@ -150,7 +145,7 @@ export var RatifierUtils;
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * const { tree, ratifier } = RatifierUtils.normalizeRatifierTree({
+     * const { tree, ratifier } = Ratifier.normalizeRatifierTree({
      *   tree: [offer],
      *   label: "Ecrecover",
      * });
@@ -158,11 +153,16 @@ export var RatifierUtils;
      * ```
      */
     function normalizeRatifierTree(params) {
+        if ("type" in params.tree &&
+            params.tree.type != null &&
+            params.tree.type !== params.label.toLowerCase()) {
+            throw new InvalidTreeError("Ratifier route does not match the tree route.");
+        }
         const tree = normalizeTree(params.tree);
         const ratifier = assertRatifierTree({ tree, label: params.label });
         return { tree, ratifier };
     }
-    RatifierUtils.normalizeRatifierTree = normalizeRatifierTree;
+    Ratifier.normalizeRatifierTree = normalizeRatifierTree;
     /**
      * Checks whether bytecode is an EIP-7702 designator.
      *
@@ -173,22 +173,22 @@ export var RatifierUtils;
      * @returns Whether the bytecode starts with `0xef0100`.
      * @example
      * ```ts
-     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Ratifier } from "@morpho-org/midnight-sdk";
      *
-     * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+     * console.log(Ratifier.isEip7702Designator("0xef0100"));
      * ```
      */
     function isEip7702Designator(bytecode) {
         return bytecode.toLowerCase().startsWith("0xef0100");
     }
-    RatifierUtils.isEip7702Designator = isEip7702Designator;
+    Ratifier.isEip7702Designator = isEip7702Designator;
     /**
      * Selects Ecrecover for EOAs/EIP-7702 accounts and Setter for deployed-code
      * accounts.
      *
      * Use the returned `ratifier` address in `Offer.create`. Later, use
-     * `EcrecoverRatifierUtils.ratify` when `type` is `ecrecover`, or approve the
-     * root and call `SetterRatifierUtils.ratify` when `type` is `setter`.
+     * `EcrecoverRatifier.ratify` when `type` is `ecrecover`, or approve the
+     * root and call `SetterRatifier.ratify` when `type` is `setter`.
      *
      * @param params.bytecode - Maker bytecode returned by `eth_getCode`.
      * @param params.ecrecoverRatifier - Ratifier address used for EOAs and EIP-7702 accounts.
@@ -196,9 +196,9 @@ export var RatifierUtils;
      * @returns Ratifier information for the maker.
      * @example
      * ```ts
-     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { Ratifier } from "@morpho-org/midnight-sdk";
      *
-     * const info = RatifierUtils.getRatifierInfo({
+     * const info = Ratifier.getRatifierInfo({
      *   bytecode: "0x",
      *   ecrecoverRatifier: "0x0000000000000000000000000000000000000001",
      *   setterRatifier: "0x0000000000000000000000000000000000000002",
@@ -217,5 +217,7 @@ export var RatifierUtils;
         }
         return { type: "setter", ratifier: setterRatifier };
     }
-    RatifierUtils.getRatifierInfo = getRatifierInfo;
-})(RatifierUtils || (RatifierUtils = {}));
+    Ratifier.getRatifierInfo = getRatifierInfo;
+})(Ratifier || (Ratifier = {}));
+/** @deprecated Use {@link Ratifier}. Retained for compatibility. */
+export { Ratifier as RatifierUtils };

package/lib/esm/signatures/{SetterRatifierUtils.d.ts → SetterRatifier.d.ts}

@@ -2,7 +2,9 @@ import { type BigIntish } from "@morpho-org/morpho-ts";
 import { type Hash, type Hex } from "viem";
 import { type IOffer } from "../offers/index.js";
 import type { Payload } from "./Payload.js";
-import { type RatifierTreeInput, type TreeProof } from "./TreeUtils.js";
+import type { SetterRatifierDataRequest, SetterRatifierRatifyRequest } from "./ratifierRequests.js";
+import type { RatifierTreeInput } from "./TreeUtils.js";
+import { type TreeProof } from "./TreeUtils.js";
 /**
  * Decoded SetterRatifier ratifier data.
  *
@@ -68,6 +70,7 @@ export type DecodedSetterRatifierData = TreeProof;
  * };
  * console.log(params.leafIndex);
  * ```
+ * @deprecated Use {@link SetterRatifierDataRequest} with {@link SetterRatifier}.
  */
 export interface SetterRatifierDataParams {
     /** Tree-like input that produced the proof. Existing `Tree` instances reuse cached hashes and proofs. */
@@ -99,6 +102,7 @@ export interface SetterRatifierDataVerificationParams {
  *
  * console.log(typeof SetterRatifierUtils.encodeRatifierData);
  * ```
+ * @deprecated Use {@link SetterRatifier} with a tagged tree.
  */
 export declare namespace SetterRatifierUtils {
     /**
@@ -155,7 +159,7 @@ export declare namespace SetterRatifierUtils {
     /**
      * Verifies that Setter ratifier data proves one payload offer belongs to its root.
      *
-     * This helper intentionally does not check `SetterRatifier.isRootRatified` or
+     * This helper intentionally does not check `SetterRatifierUtils.isRootRatified` or
      * `Midnight.isAuthorized` state. Consumers can query those values at their
      * own block context after local proof verification.
      *
@@ -189,7 +193,7 @@ export declare namespace SetterRatifierUtils {
      * @throws {InvalidTreeError} when the leaf index is outside the tree or the tree contains multiple ratifiers.
      * @example
      * ```ts
-     * import { Offer, SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { Offer, SetterRatifier, Tree } from "@morpho-org/midnight-sdk";
      * import { zeroAddress } from "viem";
      *
      * const offer = Offer.create({
@@ -280,3 +284,46 @@ export declare namespace SetterRatifierUtils {
         readonly tree: RatifierTreeInput;
     }): readonly Payload.Item[];
 }
+/**
+ * Tagged-tree API for SetterRatifier with validated portable leaf commitments.
+ * Legacy untagged inputs remain available through {@link SetterRatifierUtils}.
+ */
+export declare namespace SetterRatifier {
+    /**
+     * Encodes the proof for one tagged Setter leaf.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @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.
+     * @example
+     * ```ts
+     * import { SetterRatifier, type SetterRatifierDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: SetterRatifierDataRequest) {
+     *   return SetterRatifier.ratifierData(request);
+     * }
+     * ```
+     */
+    function ratifierData(request: SetterRatifierDataRequest): Hex;
+    /**
+     * Builds payload items for a tagged Setter tree after onchain root approval.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @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.
+     * @example
+     * ```ts
+     * import { SetterRatifier, type SetterRatifierRatifyRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: SetterRatifierRatifyRequest) {
+     *   return SetterRatifier.ratify(request);
+     * }
+     * ```
+     */
+    function ratify(request: SetterRatifierRatifyRequest): readonly Payload.Item[];
+    /** {@inheritDoc SetterRatifierUtils.encodeRatifierData} */
+    const encodeRatifierData: typeof SetterRatifierUtils.encodeRatifierData;
+    /** {@inheritDoc SetterRatifierUtils.decodeRatifierData} */
+    const decodeRatifierData: typeof SetterRatifierUtils.decodeRatifierData;
+    /** {@inheritDoc SetterRatifierUtils.verifyRatifierData} */
+    const verifyRatifierData: typeof SetterRatifierUtils.verifyRatifierData;
+}

package/lib/esm/signatures/{SetterRatifierUtils.js → SetterRatifier.js}

@@ -2,8 +2,9 @@ import { deepFreeze } from "@morpho-org/morpho-ts";
 import { decodeAbiParameters, encodeAbiParameters, } from "viem";
 import { InvalidTreeError } from "../errors.js";
 import { Offer } from "../offers/index.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 setterRatifierDataAbi = [
     { name: "root", type: "bytes32" },
     { name: "leafIndex", type: "uint256" },
@@ -26,6 +27,7 @@ const setterRatifierDataAbi = [
  *
  * console.log(typeof SetterRatifierUtils.encodeRatifierData);
  * ```
+ * @deprecated Use {@link SetterRatifier} with a tagged tree.
  */
 export var SetterRatifierUtils;
 (function (SetterRatifierUtils) {
@@ -90,7 +92,7 @@ export var SetterRatifierUtils;
     /**
      * Verifies that Setter ratifier data proves one payload offer belongs to its root.
      *
-     * This helper intentionally does not check `SetterRatifier.isRootRatified` or
+     * This helper intentionally does not check `SetterRatifierUtils.isRootRatified` or
      * `Midnight.isAuthorized` state. Consumers can query those values at their
      * own block context after local proof verification.
      *
@@ -137,7 +139,7 @@ export var SetterRatifierUtils;
      * @throws {InvalidTreeError} when the leaf index is outside the tree or the tree contains multiple ratifiers.
      * @example
      * ```ts
-     * import { Offer, SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { Offer, SetterRatifier, Tree } from "@morpho-org/midnight-sdk";
      * import { zeroAddress } from "viem";
      *
      * const offer = Offer.create({
@@ -173,7 +175,7 @@ export var SetterRatifierUtils;
      * ```
      */
     function ratifierData(params) {
-        const { tree } = RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Setter",
         });
@@ -237,14 +239,70 @@ export var SetterRatifierUtils;
      * ```
      */
     function ratify(params) {
-        const { tree } = RatifierUtils.normalizeRatifierTree({
+        const { tree } = Ratifier.normalizeRatifierTree({
             tree: params.tree,
             label: "Setter",
         });
+        const proofs = TreeUtils.buildProofs({
+            tree,
+            count: tree.offers.length,
+        });
         return tree.offers.map((offer, leafIndex) => ({
             offer,
-            ratifierData: encodeRatifierData(TreeUtils.buildProof({ tree, leafIndex })),
+            ratifierData: encodeRatifierData(proofs[leafIndex]),
         }));
     }
     SetterRatifierUtils.ratify = ratify;
 })(SetterRatifierUtils || (SetterRatifierUtils = {}));
+/**
+ * Tagged-tree API for SetterRatifier with validated portable leaf commitments.
+ * Legacy untagged inputs remain available through {@link SetterRatifierUtils}.
+ */
+export var SetterRatifier;
+(function (SetterRatifier) {
+    /**
+     * Encodes the proof for one tagged Setter leaf.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @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.
+     * @example
+     * ```ts
+     * import { SetterRatifier, type SetterRatifierDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: SetterRatifierDataRequest) {
+     *   return SetterRatifier.ratifierData(request);
+     * }
+     * ```
+     */
+    function ratifierData(request) {
+        const tree = parseStandardRatifierTree(request.tree, "setter");
+        return SetterRatifierUtils.ratifierData({ ...request, tree });
+    }
+    SetterRatifier.ratifierData = ratifierData;
+    /**
+     * Builds payload items for a tagged Setter tree after onchain root approval.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @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.
+     * @example
+     * ```ts
+     * import { SetterRatifier, type SetterRatifierRatifyRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: SetterRatifierRatifyRequest) {
+     *   return SetterRatifier.ratify(request);
+     * }
+     * ```
+     */
+    function ratify(request) {
+        const tree = parseStandardRatifierTree(request.tree, "setter");
+        return SetterRatifierUtils.ratify({ ...request, tree });
+    }
+    SetterRatifier.ratify = ratify;
+    /** {@inheritDoc SetterRatifierUtils.encodeRatifierData} */
+    SetterRatifier.encodeRatifierData = SetterRatifierUtils.encodeRatifierData;
+    /** {@inheritDoc SetterRatifierUtils.decodeRatifierData} */
+    SetterRatifier.decodeRatifierData = SetterRatifierUtils.decodeRatifierData;
+    /** {@inheritDoc SetterRatifierUtils.verifyRatifierData} */
+    SetterRatifier.verifyRatifierData = SetterRatifierUtils.verifyRatifierData;
+})(SetterRatifier || (SetterRatifier = {}));

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

@@ -1,15 +1,17 @@
-import type { BigIntish } from "@morpho-org/morpho-ts";
+import { type BigIntish } from "@morpho-org/morpho-ts";
 import type { Hash } from "viem";
 import type { MempoolPayloadValidationSuccess } from "../api/types.js";
 import { Offer, type OfferStruct } from "../offers/index.js";
-import { type TreeCreateParams, type TreeInput, type TreeMempoolValidateParams, type TreeProof } from "./TreeUtils.js";
+import { type TreeCreateParams, type TreeInput, type TreeProof } from "./TreeUtils.js";
+import type { AnyTree, AnyTreeSnapshot, RatifierKind, TreeCreateRequest, TreeEntry, TreeSnapshot, TypedTreeMempoolValidateParams } from "./treeTypes.js";
 export type { RatifierTreeInput, TreeCreateParams, TreeDescriptor, TreeInput, TreeLike, TreeMempoolValidateParams, TreeMempoolValidateRatification, TreeProof, } from "./TreeUtils.js";
 /**
  * Maker-side Merkle tree used by Midnight ratifiers.
  *
  * Build a tree after offers have been created and related offers have been
  * grouped. The tree root is what Ecrecover makers sign, Setter makers approve,
- * and payload items later prove with per-leaf ratifier data.
+ * and payload items later prove with per-leaf ratifier data. Price/Rate V1
+ * trees carry their additional leaf commitments and use onchain root approval.
  *
  * @example
  * ```ts
@@ -41,16 +43,20 @@ export type { RatifierTreeInput, TreeCreateParams, TreeDescriptor, TreeInput, Tr
  *   ratifier: "0x0000000000000000000000000000000000004000",
  *   maxUnits: 100n,
  * });
- * const tree = Tree.create([offer]);
+ * const tree = Tree.create({ type: "ecrecover", entries: [offer] });
  * console.log(tree.root);
  * ```
  */
-export declare class Tree {
+export declare class Tree<K extends RatifierKind | undefined = undefined> {
+    /** Explicit route, or undefined for a legacy standard tree. */
+    readonly type: K;
+    /** Complete padded leaf commitments for this route. */
+    readonly entries: readonly TreeEntry<K>[];
     /** Non-padding offers in leaf order. */
     readonly offers: readonly Offer[];
     /** ABI-compatible offers in leaf order, including protocol-zero padding. */
     readonly paddedOffers: readonly OfferStruct[];
-    /** Leaf hashes for `paddedOffers`. */
+    /** Leaf hashes for the complete padded `entries`. */
     readonly leaves: readonly Hash[];
     /** Merkle root. */
     readonly root: Hash;
@@ -68,6 +74,8 @@ export declare class Tree {
      * @returns Tree instance.
      * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the resulting height is unsupported.
+     * @throws {InvalidRateRatifierV1RateError} when a Rate leaf has a negative rate.
+     * @throws {InvalidRateRatifierV1TickError} when a Rate leaf offer tick is below `RateRatifierV1.MIN_TICK`.
      * @example
      * ```ts
      * import { Offer, Tree } from "@morpho-org/midnight-sdk";
@@ -98,24 +106,43 @@ export declare class Tree {
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * const tree = Tree.from([offer]);
+     * const tree = Tree.from({ type: "ecrecover", entries: [offer] });
      * console.log(tree.root);
      * ```
      */
+    static from<T extends AnyTree | AnyTreeSnapshot | TreeCreateRequest>(tree: T): Extract<AnyTree, {
+        readonly type: T["type"];
+    }>;
+    /**
+     * Resolves an untagged standard tree or legacy creation input.
+     * @deprecated Pass a tagged TreeCreateRequest or a route-typed Tree instead.
+     * @param tree - Legacy tree, offer, group, or array of entries.
+     * @returns Untagged standard tree.
+     * @throws {InvalidTreeError} When entries are empty, all padding, or duplicated.
+     * @throws {InvalidTreeHeightError} When the tree height is unsupported.
+     * @example
+     * ```ts
+     * import { Tree, type TreeInput } from "@morpho-org/midnight-sdk";
+     * function legacyTree(input: TreeInput) { return Tree.from(input); }
+     * ```
+     */
     static from(tree: TreeInput): Tree;
     /**
-     * Creates a tree from groups or standalone offers.
+     * Creates a route-typed tree from standard offer/groups or Price/Rate leaf inputs.
      *
      * Use after `Offer.create` and optional `Group.create`, before
-     * `Tree.mempoolValidate`, `EcrecoverRatifierUtils.ratify`, or
-     * `SetterRatifierUtils.ratify`. Groups are flattened, and every standalone
+     * `Tree.mempoolValidate`, `EcrecoverRatifier.ratify`, or
+     * `SetterRatifier.ratify`. Groups are flattened, and every standalone
      * offer is normalized as a singleton group using the router-compatible group
      * id algorithm.
      *
-     * @param params - Groups or standalone offers in leaf order.
-     * @returns Tree instance.
+     * @param params.type - Ratifier route selecting the leaf commitment format.
+     * @param params.entries - Standard offer/groups or route-specific leaves in leaf order.
+     * @returns A tree whose entries and validation options are inferred from the route.
      * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the resulting height is unsupported.
+     * @throws {InvalidRateRatifierV1RateError} when a Rate leaf has a negative rate.
+     * @throws {InvalidRateRatifierV1TickError} when a Rate leaf offer tick is below `RateRatifierV1.MIN_TICK`.
      * @example
      * ```ts
      * import { Offer, Tree } from "@morpho-org/midnight-sdk";
@@ -146,11 +173,58 @@ export declare class Tree {
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * const tree = Tree.create([offer]);
+     * const tree = Tree.create({ type: "ecrecover", entries: [offer] });
      * console.log(tree.height);
      * ```
      */
+    static create<R extends TreeCreateRequest>(params: R): Extract<AnyTree, {
+        readonly type: R["type"];
+    }>;
+    /**
+     * Creates a legacy tree compatible with Ecrecover and Setter.
+     * @deprecated Pass `{ type, entries }` to select a ratifier explicitly.
+     * @param params - Standard offer/group inputs.
+     * @returns Untagged standard tree.
+     * @throws {InvalidTreeError} when the tree is empty, all padding, or duplicated.
+     * @throws {InvalidTreeHeightError} when the resulting height is unsupported.
+     * @example
+     * ```ts
+     * import { Tree, type IOffer } from "@morpho-org/midnight-sdk";
+     * function legacyTree(offers: readonly IOffer[]) { return Tree.create(offers); }
+     * ```
+     */
     static create(params: TreeCreateParams): Tree;
+    /**
+     * Exports plain normalized data for transport; does not claim root authorization.
+     * @returns Descriptor with the same route and padded commitments.
+     * @example
+     * ```ts
+     * import { Tree, type IOffer } from "@morpho-org/midnight-sdk";
+     * function prepare(offers: readonly IOffer[]) {
+     *   return Tree.create({ type: "setter", entries: offers }).toDescriptor();
+     * }
+     * ```
+     */
+    toDescriptor(): TreeSnapshot<K>;
+    /**
+     * Validates portable data before constructing a tree. Hashes and padding are checked again.
+     * @param descriptor - Tagged descriptor, or legacy untagged snapshot.
+     * @returns A new tree with the descriptor's route.
+     * @throws {InvalidTreeError} When entries, offers, padding, hashes or root disagree.
+     * @throws {InvalidTreeHeightError} When height is unsupported.
+     * @throws {InvalidRateRatifierV1TickError} when a rateV1 snapshot entry's offer tick is below `RateRatifierV1.MIN_TICK`.
+     * @example
+     * ```ts
+     * import { Tree, type TreeSnapshot } from "@morpho-org/midnight-sdk";
+     * function resume(snapshot: TreeSnapshot<"rateV1">) {
+     *   return Tree.fromDescriptor(snapshot); // Tree<"rateV1">
+     * }
+     * ```
+     */
+    static fromDescriptor<D extends AnyTreeSnapshot>(descriptor: D): Extract<AnyTree, {
+        readonly type: D["type"];
+    }>;
+    static fromDescriptor(descriptor: TreeSnapshot<undefined>): Tree;
     /**
      * Validates this tree against Midnight mempool API policy.
      *
@@ -158,15 +232,18 @@ export declare class Tree {
      * 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 routes always post their real ratifier data
+     * because the router decodes it to identify each offer; their
+     * `ratification` only asserts the route.
      *
      * @param params.chainId - Chain id whose API policy should validate this tree.
      * @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 authorization inputs; Price/Rate routes require their root to have been approved onchain.
      * @returns Successful API validation result with `valid: true`.
+     * @throws {InvalidTreeError} when the ratification route differs from the tree route.
      * @throws {PayloadDecodeError} when validation payload encoding fails.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
      * @throws {InvalidMidnightApiResponseError} when the API returns malformed success JSON.
@@ -201,12 +278,12 @@ export declare class Tree {
      *   ratifier: "0x0000000000000000000000000000000000004000",
      *   maxUnits: 100n,
      * });
-     * await Tree.create([offer]).mempoolValidate({
+     * await Tree.create({ type: "ecrecover", entries: [offer] }).mempoolValidate({
      *   chainId: 8453,
      * });
      * ```
      */
-    mempoolValidate(params: TreeMempoolValidateParams): Promise<MempoolPayloadValidationSuccess>;
+    mempoolValidate(params: TypedTreeMempoolValidateParams<K>): Promise<MempoolPayloadValidationSuccess>;
     /**
      * Builds a Merkle proof for one leaf.
      *