@morpho-org/midnight-sdk 1.7.0 → 2.0.0

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

@@ -0,0 +1,57 @@
+import { type Address, type Hash } from "viem";
+import { type IOffer, Offer, type OfferStruct } from "../offers/index.js";
+import type { TreeData } from "./treeTypes.js";
+/** @internal Resolves V1 leaf groups mirroring the router's group_identity content ids. */
+export declare function assignRatifierV1Groups<TLeaf extends {
+    readonly offer: Offer;
+}>(leaves: readonly TLeaf[], groupId: (leaves: readonly TLeaf[]) => Hash): Offer[];
+/** @internal Padded V1 ratifier leaf descriptor shared by the V1 ratifier utils. */
+export type RatifierV1Descriptor<TStruct> = Omit<TreeData<TStruct>, "offers">;
+/**
+ * @internal Pads, hash-checks, and roots a V1 ratifier leaf list.
+ *
+ * All non-padding entries must share one ratifier address and produce distinct
+ * leaf hashes. Non-power-of-two lists are padded with `padding` at the highest
+ * leaf indices, matching `TreeUtils.buildDescriptor` semantics.
+ */
+export declare function buildRatifierV1Descriptor<TStruct>(params: {
+    readonly entries: readonly TStruct[];
+    readonly padding: TStruct;
+    readonly hashLeaf: (entry: TStruct) => Hash;
+    readonly ratifierOf: (entry: TStruct) => Address;
+    readonly label: string;
+}): RatifierV1Descriptor<TStruct>;
+/**
+ * @internal Resolves a V1 ratifier tree input into a materialized descriptor.
+ *
+ * Caller-provided descriptors are fully re-validated: height, lengths, leaf
+ * hashes, visible-offer correspondence, padding placement, and the Merkle
+ * root must all agree, mirroring `Ratifier.normalizeTree`. An optional
+ * `validateEntry` hook runs ratifier-specific checks on each visible
+ * (non-padding) entry before leaf hashes are recomputed, so descriptor input
+ * is held to the same bounds as `buildDescriptor`.
+ */
+export declare function resolveRatifierV1Tree<TStruct extends {
+    readonly offer: OfferStruct;
+}, TLeaf, TDescriptor extends RatifierV1Descriptor<TStruct> & {
+    readonly offers: readonly IOffer[];
+}>(tree: TDescriptor | readonly TLeaf[], helpers: {
+    readonly buildDescriptor: (leaves: readonly TLeaf[]) => TDescriptor;
+    readonly hashLeaf: (entry: TStruct) => Hash;
+    readonly isPadding: (entry: TStruct) => boolean;
+    readonly ratifierOf: (entry: TStruct) => Address;
+    readonly validateEntry?: (entry: TStruct) => void;
+    readonly label: string;
+    readonly type: "priceV1" | "rateV1";
+}): TDescriptor;
+/**
+ * @internal Asserts a V1 ratifier address is deployed (non-zero).
+ */
+export declare function assertRatifierV1Address(ratifier: Address): void;
+/**
+ * @internal Asserts a take-side taker matches the leaf's allowed taker.
+ */
+export declare function assertRatifierV1Taker(params: {
+    readonly taker: Address | undefined;
+    readonly allowedTaker: Address;
+}): void;

package/lib/esm/signatures/ratifierV1Internal.js

@@ -0,0 +1,176 @@
+import { isAddressEqual, zeroAddress } from "viem";
+import { MAX_TREE_HEIGHT } from "../constants.js";
+import { InvalidRatifierV1AddressError, InvalidTreeError, InvalidTreeHeightError, RatifierV1TakerNotAllowedError, } from "../errors.js";
+import { Offer, OfferUtils, } from "../offers/index.js";
+import { GroupUtils } from "./GroupUtils.js";
+import { isZeroAddress } from "./offerStructInternal.js";
+import { TreeUtils } from "./TreeUtils.js";
+import { isPowerOfTwo, nextPowerOfTwo } from "./treeMathInternal.js";
+/** @internal Resolves V1 leaf groups mirroring the router's group_identity content ids. */
+export function assignRatifierV1Groups(leaves, groupId) {
+    const offers = leaves.map((leaf) => leaf.offer.hasExplicitGroup
+        ? leaf.offer
+        : Offer.from({ ...leaf.offer, group: groupId([leaf]) }));
+    const buckets = new Map();
+    for (const [index, leaf] of leaves.entries()) {
+        if (!leaf.offer.hasExplicitGroup)
+            continue;
+        const label = leaf.offer.group.toLowerCase();
+        const bucket = buckets.get(label);
+        if (bucket)
+            bucket.push(index);
+        else
+            buckets.set(label, [index]);
+    }
+    for (const [label, indices] of buckets) {
+        const bucketLeaves = indices.map((index) => leaves[index]);
+        if (GroupUtils.hash(bucketLeaves.map((leaf) => leaf.offer)).toLowerCase() !==
+            label) {
+            continue;
+        }
+        const group = groupId(bucketLeaves);
+        for (const index of indices) {
+            offers[index] = Offer.from({ ...leaves[index].offer, group });
+        }
+    }
+    return offers;
+}
+/**
+ * @internal Pads, hash-checks, and roots a V1 ratifier leaf list.
+ *
+ * All non-padding entries must share one ratifier address and produce distinct
+ * leaf hashes. Non-power-of-two lists are padded with `padding` at the highest
+ * leaf indices, matching `TreeUtils.buildDescriptor` semantics.
+ */
+export function buildRatifierV1Descriptor(params) {
+    const { entries, padding, hashLeaf, ratifierOf, label } = params;
+    const first = entries[0];
+    if (first == null) {
+        throw new InvalidTreeError("Tree must not be empty.");
+    }
+    const ratifier = ratifierOf(first);
+    for (const entry of entries.slice(1)) {
+        const other = ratifierOf(entry);
+        if (!isAddressEqual(other, ratifier)) {
+            throw new InvalidTreeError(`All offers in a ${label} tree must use one ratifier; expected "${ratifier}", got "${other}". Build separate trees per ratifier.`);
+        }
+    }
+    const entryHashes = entries.map(hashLeaf);
+    const seen = new Set();
+    for (const leafHash of entryHashes) {
+        if (seen.has(leafHash)) {
+            throw new InvalidTreeError(`Duplicate leaf hash "${leafHash}" in tree.`);
+        }
+        seen.add(leafHash);
+    }
+    const paddingCount = isPowerOfTwo(entries.length)
+        ? 0
+        : nextPowerOfTwo(entries.length) - entries.length;
+    const paddedEntries = [
+        ...entries,
+        ...Array.from({ length: paddingCount }, () => padding),
+    ];
+    const paddingHash = paddingCount === 0 ? undefined : hashLeaf(padding);
+    const leaves = [
+        ...entryHashes,
+        ...Array.from({ length: paddingCount }, () => paddingHash),
+    ];
+    const { root, height } = TreeUtils.buildRootFromLeaves(leaves);
+    return { entries: paddedEntries, leaves, root, height };
+}
+/**
+ * @internal Resolves a V1 ratifier tree input into a materialized descriptor.
+ *
+ * Caller-provided descriptors are fully re-validated: height, lengths, leaf
+ * hashes, visible-offer correspondence, padding placement, and the Merkle
+ * root must all agree, mirroring `Ratifier.normalizeTree`. An optional
+ * `validateEntry` hook runs ratifier-specific checks on each visible
+ * (non-padding) entry before leaf hashes are recomputed, so descriptor input
+ * is held to the same bounds as `buildDescriptor`.
+ */
+export function resolveRatifierV1Tree(tree, helpers) {
+    const { buildDescriptor, hashLeaf, isPadding, ratifierOf, label } = helpers;
+    if (Array.isArray(tree))
+        return buildDescriptor(tree);
+    const descriptor = tree;
+    if ("type" in descriptor &&
+        descriptor.type != null &&
+        descriptor.type !== helpers.type) {
+        throw new InvalidTreeError("Ratifier route does not match the tree route.");
+    }
+    if (!Number.isInteger(descriptor.height) ||
+        descriptor.height < 0 ||
+        descriptor.height > MAX_TREE_HEIGHT) {
+        throw new InvalidTreeHeightError(descriptor.height);
+    }
+    if (descriptor.offers.length === 0) {
+        throw new InvalidTreeError("Tree must not be empty.");
+    }
+    const expectedLength = 2 ** descriptor.height;
+    if (descriptor.entries.length !== expectedLength ||
+        descriptor.leaves.length !== expectedLength ||
+        expectedLength !== nextPowerOfTwo(descriptor.offers.length)) {
+        throw new InvalidTreeError("Tree entries, leaves, offers, and height describe different trees.");
+    }
+    const visibleEntries = descriptor.entries.slice(0, descriptor.offers.length);
+    const ratifier = ratifierOf(visibleEntries[0]);
+    for (const entry of visibleEntries.slice(1)) {
+        const other = ratifierOf(entry);
+        if (!isAddressEqual(other, ratifier)) {
+            throw new InvalidTreeError(`All offers in a ${label} tree must use one ratifier; expected "${ratifier}", got "${other}". Build separate trees per ratifier.`);
+        }
+    }
+    // Ratifier-specific entry gates run before any leaf hashing.
+    for (const entry of visibleEntries) {
+        if (isPadding(entry)) {
+            throw new InvalidTreeError("Visible offers must not contain tree padding.");
+        }
+        helpers.validateEntry?.(entry);
+    }
+    const computedLeaves = descriptor.entries.map((entry) => hashLeaf(entry));
+    const seen = new Set();
+    for (const [index, offer] of descriptor.offers.entries()) {
+        const entry = descriptor.entries[index];
+        if (OfferUtils.hashStruct(OfferUtils.toStruct({ offer: Offer.from(offer) })).toLowerCase() !== OfferUtils.hashStruct(entry.offer).toLowerCase()) {
+            throw new InvalidTreeError("Visible offers do not match the tree entries.");
+        }
+        const leafHash = computedLeaves[index].toLowerCase();
+        if (seen.has(leafHash)) {
+            throw new InvalidTreeError(`Duplicate leaf hash "${leafHash}" in tree.`);
+        }
+        seen.add(leafHash);
+    }
+    if (descriptor.entries
+        .slice(descriptor.offers.length)
+        .some((entry) => !isPadding(entry))) {
+        throw new InvalidTreeError("Tree padding contains entries hidden from the visible offer list.");
+    }
+    if (computedLeaves.some((leaf, index) => leaf.toLowerCase() !== descriptor.leaves[index].toLowerCase())) {
+        throw new InvalidTreeError("Tree leaves do not match its entries.");
+    }
+    if (TreeUtils.buildRootFromLeaves(descriptor.leaves).root.toLowerCase() !==
+        descriptor.root.toLowerCase()) {
+        throw new InvalidTreeError("Tree root does not match its leaves.");
+    }
+    return descriptor;
+}
+/**
+ * @internal Asserts a V1 ratifier address is deployed (non-zero).
+ */
+export function assertRatifierV1Address(ratifier) {
+    if (isZeroAddress(ratifier)) {
+        throw new InvalidRatifierV1AddressError(ratifier);
+    }
+}
+/**
+ * @internal Asserts a take-side taker matches the leaf's allowed taker.
+ */
+export function assertRatifierV1Taker(params) {
+    const { taker, allowedTaker } = params;
+    if (taker == null ||
+        isAddressEqual(allowedTaker, zeroAddress) ||
+        isAddressEqual(taker, allowedTaker)) {
+        return;
+    }
+    throw new RatifierV1TakerNotAllowedError({ taker, allowedTaker });
+}

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

@@ -0,0 +1,4 @@
+import { Tree } from "./Tree.js";
+import type { TreeSnapshot } from "./treeTypes.js";
+/** @internal Parses tagged standard-ratifier inputs and rejects legacy or mismatched routes. */
+export declare function parseStandardRatifierTree(tree: TreeSnapshot<"ecrecover"> | TreeSnapshot<"setter">, expected: "ecrecover" | "setter"): Tree<"ecrecover"> | Tree<"setter">;

package/lib/esm/signatures/standardRatifierInternal.js

@@ -0,0 +1,9 @@
+import { InvalidTreeError } from "../errors.js";
+import { Tree } from "./Tree.js";
+/** @internal Parses tagged standard-ratifier inputs and rejects legacy or mismatched routes. */
+export function parseStandardRatifierTree(tree, expected) {
+    if (tree.type !== expected) {
+        throw new InvalidTreeError(`Expected a "${expected}" tree. Create a tree with an explicit matching ratifier type.`);
+    }
+    return Tree.fromDescriptor(tree);
+}

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

@@ -0,0 +1,4 @@
+/** @internal Returns whether `value` is a positive power of two. */
+export declare function isPowerOfTwo(value: number): boolean;
+/** @internal Returns the smallest power of two greater than or equal to `value`. */
+export declare function nextPowerOfTwo(value: number): number;

package/lib/esm/signatures/treeMathInternal.js

@@ -0,0 +1,8 @@
+/** @internal Returns whether `value` is a positive power of two. */
+export function isPowerOfTwo(value) {
+    return value > 0 && (value & (value - 1)) === 0;
+}
+/** @internal Returns the smallest power of two greater than or equal to `value`. */
+export function nextPowerOfTwo(value) {
+    return 2 ** Math.ceil(Math.log2(value));
+}

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

@@ -0,0 +1,109 @@
+import type { Hash } from "viem";
+import type { IOffer, OfferStruct } from "../offers/index.js";
+import type { GroupInput } from "./GroupUtils.js";
+import type { PriceRatifierV1Leaf, PriceRatifierV1LeafStruct } from "./PriceRatifierV1.js";
+import type { RateRatifierV1Leaf, RateRatifierV1LeafStruct } from "./RateRatifierV1.js";
+import type { Tree } from "./Tree.js";
+import type { RatifierTreeInput, TreeLike, TreeMempoolValidateParams, TreeMempoolValidateRatification } from "./TreeUtils.js";
+/** Creation request for an Ecrecover tree; its root is authorized by signature. */
+export interface EcrecoverTreeCreateRequest {
+    /** Selects standard offer hashing and Ecrecover authorization. */
+    readonly type: "ecrecover";
+    /** Groups or standalone offers in leaf order. */
+    readonly entries: readonly GroupInput[];
+}
+/** Creation request for a Setter tree; its root is approved onchain. */
+export interface SetterTreeCreateRequest {
+    /** Selects standard offer hashing and Setter authorization. */
+    readonly type: "setter";
+    /** Groups or standalone offers in leaf order. */
+    readonly entries: readonly GroupInput[];
+}
+/** Creation request for a Price V1 tree with per-leaf taker restrictions. */
+export interface PriceRatifierV1TreeCreateRequest {
+    /** Selects Price V1 leaf commitments. */
+    readonly type: "priceV1";
+    /** Price-bounded offer leaves in leaf order. */
+    readonly entries: readonly PriceRatifierV1Leaf[];
+}
+/** Creation request for a Rate V1 tree with per-leaf rate and taker restrictions. */
+export interface RateRatifierV1TreeCreateRequest {
+    /** Selects Rate V1 leaf commitments. */
+    readonly type: "rateV1";
+    /** Rate-bounded offer leaves in leaf order. */
+    readonly entries: readonly RateRatifierV1Leaf[];
+}
+/** Tagged construction API; each variant keeps its route and entries together. */
+export type TreeCreateRequest = EcrecoverTreeCreateRequest | SetterTreeCreateRequest | PriceRatifierV1TreeCreateRequest | RateRatifierV1TreeCreateRequest;
+/** Associates each ratifier route with its construction input and committed leaf. */
+export type RatifierTypes = {
+    /** Ecrecover signs standard offer trees. */
+    readonly ecrecover: {
+        readonly input: EcrecoverTreeCreateRequest["entries"];
+        readonly entry: OfferStruct;
+    };
+    /** Setter approves standard offer trees onchain. */
+    readonly setter: {
+        readonly input: SetterTreeCreateRequest["entries"];
+        readonly entry: OfferStruct;
+    };
+    /** Price V1 commits to price and taker restrictions. */
+    readonly priceV1: {
+        readonly input: PriceRatifierV1TreeCreateRequest["entries"];
+        readonly entry: PriceRatifierV1LeafStruct;
+    };
+    /** Rate V1 commits to rate and taker restrictions. */
+    readonly rateV1: {
+        readonly input: RateRatifierV1TreeCreateRequest["entries"];
+        readonly entry: RateRatifierV1LeafStruct;
+    };
+};
+/** Explicit ratifier routes supported by a typed tree. */
+export type RatifierKind = keyof RatifierTypes;
+/** Normalized entry for a route; undefined retains the legacy standard format. */
+export type TreeEntry<K extends RatifierKind | undefined> = K extends RatifierKind ? RatifierTypes[K]["entry"] : OfferStruct;
+/** Shared materialized leaf data, independent of ratifier authorization. */
+export interface TreeData<E> {
+    /** Padded normalized entries in leaf order. */
+    readonly entries: readonly E[];
+    /** Non-padding offers in leaf order. */
+    readonly offers: readonly IOffer[];
+    /** Hashes of all padded entries. */
+    readonly leaves: readonly Hash[];
+    /** Merkle root. */
+    readonly root: Hash;
+    /** Merkle height. */
+    readonly height: number;
+}
+/** Portable descriptor; callers must validate it before trusting its hashes. */
+export interface TreeSnapshot<K extends RatifierKind | undefined> extends TreeData<TreeEntry<K>> {
+    /** Route selecting normalization, hashing and authorization. */
+    readonly type: K;
+}
+/** Union preserving the relationship between a descriptor's route and entries. */
+export type AnyTreeSnapshot = {
+    [K in RatifierKind]: TreeSnapshot<K>;
+}[RatifierKind];
+/** Union that narrows entries when its route tag is narrowed. */
+export type AnyTree = {
+    [K in RatifierKind]: Tree<K>;
+}[RatifierKind];
+/** API validation options restricted to a tree's authorization route. */
+export type TypedTreeMempoolValidateParams<K extends RatifierKind | undefined> = Omit<TreeMempoolValidateParams, "ratification"> & {
+    readonly ratification?: K extends "priceV1" | "rateV1" ? {
+        readonly type: K;
+    } : K extends "ecrecover" | "setter" ? Extract<TreeMempoolValidateRatification, {
+        readonly type: K;
+    }> : TreeMempoolValidateRatification;
+};
+/**
+ * Compatibility input accepting the original untagged contract or a matching tagged tree.
+ * @deprecated Use TreeSnapshot with the required route for the new ratifier APIs.
+ * Deliberately widening a tagged tree to a legacy type erases static route information;
+ * ratifier utilities still validate any runtime tag before use.
+ */
+export type TypedRatifierTreeInput<K extends "ecrecover" | "setter"> = (RatifierTreeInput & {
+    readonly type?: undefined;
+}) | (TreeLike & {
+    readonly type: K;
+});

package/lib/esm/signatures/treeTypes.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/midnight-sdk",
   "description": "Viem-based package for Morpho Midnight that exports protocol utilities, fetch helpers, and Midnight API utilities under a dedicated API subpath.",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "author": "Morpho Association <contact@morpho.org>",
   "repository": {
     "type": "git",
@@ -37,27 +37,28 @@
   },
   "sideEffects": false,
   "files": [
-    "lib"
+    "lib",
+    "MIGRATION-v1-to-v2.md"
   ],
   "peerDependencies": {
-    "@morpho-org/morpho-ts": "^2.8.0 || ^3.0.0",
+    "@morpho-org/morpho-ts": "^2.8.0 || ^3.0.0 || ^4.0.0",
     "viem": "^2.0.0"
   },
   "devDependencies": {
+    "@morpho-org/morpho-ts": "^4.0.0",
+    "@morpho-org/test": "^2.10.1",
     "fast-check": "^4.9.0",
     "typescript": "7.0.2",
     "viem": "^2.55.10",
-    "vitest": "^4.1.11",
-    "@morpho-org/morpho-ts": "^3.0.0",
-    "@morpho-org/test": "^2.10.0"
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "prepublish": "pnpm build",
-    "compile": "node ../../scripts/compile-solidity.js midnight-sdk",
+    "compile": "node ../../scripts/compile-solidity.ts midnight-sdk",
     "build": "pnpm generate:version && tsc --noEmit && pnpm build:cjs && pnpm build:esm",
     "build:cjs": "tsc --build tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
     "build:esm": "tsc --build tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > lib/esm/package.json",
-    "generate:version": "node ../../scripts/release/generate-midnight-package-version.mjs",
+    "generate:version": "node ../../scripts/generate-midnight-package-version.ts",
     "test": "vitest --root ../.. --project midnight-sdk --project midnight-sdk-fork"
   },
   "types": "./lib/esm/index.d.ts"