@morpho-org/midnight-sdk 0.1.0

package/lib/esm/signatures/RatifierUtils.js

@@ -0,0 +1,73 @@
+/**
+ * Utilities for selecting Midnight ratifier routes.
+ *
+ * Call these during make-side preparation, before `Offer.create`, when an app
+ * must decide whether a maker can sign an Ecrecover root or must approve a
+ * Setter root onchain. Fetch helpers read bytecode for you; this namespace is
+ * the pure classification logic.
+ *
+ * @example
+ * ```ts
+ * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+ * ```
+ */
+export var RatifierUtils;
+(function (RatifierUtils) {
+    /**
+     * Checks whether bytecode is an EIP-7702 designator.
+     *
+     * EIP-7702 accounts have code-like bytecode but still sign as the owning EOA,
+     * so they use the Ecrecover ratifier route instead of the Setter route.
+     *
+     * @param bytecode - Account bytecode.
+     * @returns Whether the bytecode starts with `0xef0100`.
+     * @example
+     * ```ts
+     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(RatifierUtils.isEip7702Designator("0xef0100"));
+     * ```
+     */
+    function isEip7702Designator(bytecode) {
+        return bytecode.toLowerCase().startsWith("0xef0100");
+    }
+    RatifierUtils.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`.
+     *
+     * @param params.bytecode - Maker bytecode returned by `eth_getCode`.
+     * @param params.ecrecoverRatifier - Ratifier address used for EOAs and EIP-7702 accounts.
+     * @param params.setterRatifier - Ratifier address used for deployed-code accounts.
+     * @returns Ratifier information for the maker.
+     * @example
+     * ```ts
+     * import { RatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const info = RatifierUtils.getRatifierInfo({
+     *   bytecode: "0x",
+     *   ecrecoverRatifier: "0x0000000000000000000000000000000000000001",
+     *   setterRatifier: "0x0000000000000000000000000000000000000002",
+     * });
+     * console.log(info.type);
+     * ```
+     */
+    function getRatifierInfo(params) {
+        const ecrecoverRatifier = params.ecrecoverRatifier;
+        const setterRatifier = params.setterRatifier;
+        const bytecode = params.bytecode;
+        if (bytecode == null ||
+            bytecode === "0x" ||
+            isEip7702Designator(bytecode)) {
+            return { type: "ecrecover", ratifier: ecrecoverRatifier };
+        }
+        return { type: "setter", ratifier: setterRatifier };
+    }
+    RatifierUtils.getRatifierInfo = getRatifierInfo;
+})(RatifierUtils || (RatifierUtils = {}));

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

@@ -0,0 +1,243 @@
+import { type BigIntish } from "@morpho-org/morpho-ts";
+import { type Hash, type Hex } from "viem";
+import type { Item as PayloadItem } from "./Payload.js";
+import type { Tree } from "./Tree.js";
+import type { TreeProof } from "./TreeUtils.js";
+/**
+ * Decoded SetterRatifier ratifier data.
+ *
+ * Use this on the take-side or in diagnostics after `Payload.decode` when you
+ * need to inspect the proof attached to a Setter-ratified offer.
+ *
+ * @example
+ * ```ts
+ * import { SetterRatifierUtils, type DecodedSetterRatifierData } from "@morpho-org/midnight-sdk";
+ * import { zeroHash } from "viem";
+ *
+ * const data = SetterRatifierUtils.encodeRatifierData({
+ *   root: zeroHash,
+ *   leafIndex: 0n,
+ *   proof: [],
+ * });
+ * const decoded: DecodedSetterRatifierData =
+ *   SetterRatifierUtils.decodeRatifierData(data);
+ * console.log(decoded.root);
+ * ```
+ */
+export type DecodedSetterRatifierData = TreeProof;
+/**
+ * Parameters for one SetterRatifier ratifier-data value.
+ *
+ * Use after the offer maker or delegate has approved the tree root onchain.
+ * Setter approvals are keyed by maker and root, so a mixed-maker tree needs one
+ * approval per maker for the same root.
+ *
+ * @example
+ * ```ts
+ * import { Offer, Tree, type SetterRatifierDataParams } from "@morpho-org/midnight-sdk";
+ * import { zeroAddress } from "viem";
+ *
+ * const offer = Offer.create({
+ *   market: {
+ *     loanToken: "0x0000000000000000000000000000000000006000",
+ *     collateralParams: [
+ *       {
+ *         token: "0x0000000000000000000000000000000000007000",
+ *         lltv: 770000000000000000n,
+ *         maxLif: 1061007957559681697n,
+ *         oracle: "0x0000000000000000000000000000000000008000",
+ *       },
+ *     ],
+ *     maturity: 54_000n,
+ *     rcfThreshold: 0n,
+ *     enterGate: zeroAddress,
+ *     liquidatorGate: zeroAddress,
+ *   },
+ *   buy: true,
+ *   maker: "0x0000000000000000000000000000000000009000",
+ *   tick: 5_000n,
+ *   expiry: 3_600n,
+ *   ratifier: "0x0000000000000000000000000000000000005000",
+ *   maxUnits: 100n,
+ * });
+ * const params: SetterRatifierDataParams = {
+ *   tree: Tree.create([offer]),
+ *   leafIndex: 0n,
+ * };
+ * console.log(params.leafIndex);
+ * ```
+ */
+export interface SetterRatifierDataParams {
+    /** Tree that produced the proof. */
+    readonly tree: Tree;
+    /** Leaf index to prove. */
+    readonly leafIndex: BigIntish;
+}
+/**
+ * SetterRatifier-specific pure utilities.
+ *
+ * Use this route for deployed-code makers. The make-side sequence is: create
+ * offers with the Setter ratifier address, build the group/tree, validate the
+ * tree, approve the root onchain for every maker in the tree, call `ratify`,
+ * then pass the returned items to `Payload.encode`.
+ *
+ * @example
+ * ```ts
+ * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof SetterRatifierUtils.encodeRatifierData);
+ * ```
+ */
+export declare namespace SetterRatifierUtils {
+    /**
+     * Encodes SetterRatifier ratifier data.
+     *
+     * Use only when you already have a root and proof. Most maker flows call
+     * `ratifierData` for one leaf or `ratify` for every leaf in the approved
+     * tree.
+     *
+     * @param params.root - Merkle root approved by the maker's Setter ratifier.
+     * @param params.leafIndex - Leaf index proven by `params.proof`.
+     * @param params.proof - Merkle proof siblings for the leaf.
+     * @returns ABI-encoded ratifier data.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const data = SetterRatifierUtils.encodeRatifierData({
+     *   root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+     *   leafIndex: 0n,
+     *   proof: [],
+     * });
+     * console.log(data);
+     * ```
+     */
+    function encodeRatifierData(params: {
+        readonly root: Hash;
+        readonly leafIndex: BigIntish;
+        readonly proof: readonly Hash[];
+    }): `0x${string}`;
+    /**
+     * Decodes SetterRatifier ratifier data.
+     *
+     * Use on the take-side or in tests after `Payload.decode` to inspect the
+     * proof attached to a published Setter offer.
+     *
+     * @param data - ABI-encoded ratifier data.
+     * @returns Decoded Setter ratifier data.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const data = SetterRatifierUtils.encodeRatifierData({
+     *   root: zeroHash,
+     *   leafIndex: 0n,
+     *   proof: [],
+     * });
+     * const decoded = SetterRatifierUtils.decodeRatifierData(data);
+     * console.log(decoded.proof);
+     * ```
+     */
+    function decodeRatifierData(data: Hex): DecodedSetterRatifierData;
+    /**
+     * Builds one ratifier-data value for a tree leaf.
+     *
+     * Use after root approval when a caller needs data for one offer leaf. Use
+     * `ratify` to produce payload-ready items for the whole tree. Setter
+     * approvals are keyed by maker and root, so the maker for this leaf must have
+     * approved the tree root onchain.
+     *
+     * @param params.tree - Setter-ratified offer tree that produced the proof.
+     * @param params.leafIndex - Leaf index to prove.
+     * @returns ABI-encoded SetterRatifier data.
+     * @throws {InvalidTreeError} when the leaf index is outside the tree.
+     * @example
+     * ```ts
+     * import { Offer, SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000005000",
+     *   maxUnits: 100n,
+     * });
+     * const data = SetterRatifierUtils.ratifierData({
+     *   tree: Tree.create([offer]),
+     *   leafIndex: 0n,
+     * });
+     * console.log(data);
+     * ```
+     */
+    function ratifierData(params: SetterRatifierDataParams): Hex;
+    /**
+     * Returns payload-ready items after a Setter root has been approved.
+     *
+     * Use after `Tree.mempoolValidate` and the root approval
+     * transaction has been submitted for every maker in the tree. Setter
+     * approvals are keyed by maker and root, so mixed-maker trees need one
+     * approval per maker for the same root. The returned items can be passed
+     * directly to `Payload.encode`. All offers in the tree must use one ratifier
+     * address; build separate trees per ratifier.
+     *
+     * @param params.tree - Setter-ratified offer tree whose root has already been approved onchain.
+     * @returns Items containing each offer and its ratifier data.
+     * @throws {InvalidTreeError} when the tree is invalid or contains multiple ratifiers.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000005000",
+     *   maxUnits: 100n,
+     * });
+     *
+     * const items = SetterRatifierUtils.ratify({
+     *   tree: Tree.create([offer]),
+     * });
+     * console.log(items.length);
+     * ```
+     */
+    function ratify(params: {
+        readonly tree: Tree;
+    }): readonly PayloadItem[];
+}

package/lib/esm/signatures/SetterRatifierUtils.js

@@ -0,0 +1,214 @@
+import { deepFreeze } from "@morpho-org/morpho-ts";
+import { decodeAbiParameters, encodeAbiParameters, } from "viem";
+import { InvalidTreeError } from "../errors.js";
+const setterRatifierDataAbi = [
+    { name: "root", type: "bytes32" },
+    { name: "leafIndex", type: "uint256" },
+    { name: "proof", type: "bytes32[]" },
+];
+/**
+ * SetterRatifier-specific pure utilities.
+ *
+ * Use this route for deployed-code makers. The make-side sequence is: create
+ * offers with the Setter ratifier address, build the group/tree, validate the
+ * tree, approve the root onchain for every maker in the tree, call `ratify`,
+ * then pass the returned items to `Payload.encode`.
+ *
+ * @example
+ * ```ts
+ * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof SetterRatifierUtils.encodeRatifierData);
+ * ```
+ */
+export var SetterRatifierUtils;
+(function (SetterRatifierUtils) {
+    /**
+     * Encodes SetterRatifier ratifier data.
+     *
+     * Use only when you already have a root and proof. Most maker flows call
+     * `ratifierData` for one leaf or `ratify` for every leaf in the approved
+     * tree.
+     *
+     * @param params.root - Merkle root approved by the maker's Setter ratifier.
+     * @param params.leafIndex - Leaf index proven by `params.proof`.
+     * @param params.proof - Merkle proof siblings for the leaf.
+     * @returns ABI-encoded ratifier data.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const data = SetterRatifierUtils.encodeRatifierData({
+     *   root: "0x0000000000000000000000000000000000000000000000000000000000000000",
+     *   leafIndex: 0n,
+     *   proof: [],
+     * });
+     * console.log(data);
+     * ```
+     */
+    function encodeRatifierData(params) {
+        return encodeAbiParameters(setterRatifierDataAbi, [
+            params.root,
+            BigInt(params.leafIndex),
+            params.proof,
+        ]);
+    }
+    SetterRatifierUtils.encodeRatifierData = encodeRatifierData;
+    /**
+     * Decodes SetterRatifier ratifier data.
+     *
+     * Use on the take-side or in tests after `Payload.decode` to inspect the
+     * proof attached to a published Setter offer.
+     *
+     * @param data - ABI-encoded ratifier data.
+     * @returns Decoded Setter ratifier data.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const data = SetterRatifierUtils.encodeRatifierData({
+     *   root: zeroHash,
+     *   leafIndex: 0n,
+     *   proof: [],
+     * });
+     * const decoded = SetterRatifierUtils.decodeRatifierData(data);
+     * console.log(decoded.proof);
+     * ```
+     */
+    function decodeRatifierData(data) {
+        const [root, leafIndex, proof] = decodeAbiParameters(setterRatifierDataAbi, data);
+        return deepFreeze({ root, leafIndex, proof: [...proof] });
+    }
+    SetterRatifierUtils.decodeRatifierData = decodeRatifierData;
+    /**
+     * Builds one ratifier-data value for a tree leaf.
+     *
+     * Use after root approval when a caller needs data for one offer leaf. Use
+     * `ratify` to produce payload-ready items for the whole tree. Setter
+     * approvals are keyed by maker and root, so the maker for this leaf must have
+     * approved the tree root onchain.
+     *
+     * @param params.tree - Setter-ratified offer tree that produced the proof.
+     * @param params.leafIndex - Leaf index to prove.
+     * @returns ABI-encoded SetterRatifier data.
+     * @throws {InvalidTreeError} when the leaf index is outside the tree.
+     * @example
+     * ```ts
+     * import { Offer, SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000005000",
+     *   maxUnits: 100n,
+     * });
+     * const data = SetterRatifierUtils.ratifierData({
+     *   tree: Tree.create([offer]),
+     *   leafIndex: 0n,
+     * });
+     * console.log(data);
+     * ```
+     */
+    function ratifierData(params) {
+        const proof = params.tree.proof(params.leafIndex);
+        return encodeRatifierData({
+            root: proof.root,
+            leafIndex: proof.leafIndex,
+            proof: proof.proof,
+        });
+    }
+    SetterRatifierUtils.ratifierData = ratifierData;
+    /**
+     * Returns payload-ready items after a Setter root has been approved.
+     *
+     * Use after `Tree.mempoolValidate` and the root approval
+     * transaction has been submitted for every maker in the tree. Setter
+     * approvals are keyed by maker and root, so mixed-maker trees need one
+     * approval per maker for the same root. The returned items can be passed
+     * directly to `Payload.encode`. All offers in the tree must use one ratifier
+     * address; build separate trees per ratifier.
+     *
+     * @param params.tree - Setter-ratified offer tree whose root has already been approved onchain.
+     * @returns Items containing each offer and its ratifier data.
+     * @throws {InvalidTreeError} when the tree is invalid or contains multiple ratifiers.
+     * @example
+     * ```ts
+     * import { SetterRatifierUtils, Tree } from "@morpho-org/midnight-sdk";
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000005000",
+     *   maxUnits: 100n,
+     * });
+     *
+     * const items = SetterRatifierUtils.ratify({
+     *   tree: Tree.create([offer]),
+     * });
+     * console.log(items.length);
+     * ```
+     */
+    function ratify(params) {
+        const firstOffer = params.tree.offers[0];
+        if (firstOffer == null) {
+            throw new InvalidTreeError("Tree must contain at least one offer.");
+        }
+        const ratifier = firstOffer.ratifier;
+        const comparableRatifier = ratifier.toLowerCase();
+        for (const offer of params.tree.offers.slice(1)) {
+            if (offer.ratifier.toLowerCase() !== comparableRatifier) {
+                throw new InvalidTreeError(`All offers in a Setter tree must use one ratifier; expected "${ratifier}", got "${offer.ratifier}". Build separate trees per ratifier.`);
+            }
+        }
+        const items = [];
+        for (const offer of params.tree.offers) {
+            items.push({
+                offer,
+                ratifierData: ratifierData({
+                    tree: params.tree,
+                    leafIndex: items.length,
+                }),
+            });
+        }
+        return items;
+    }
+    SetterRatifierUtils.ratify = ratify;
+})(SetterRatifierUtils || (SetterRatifierUtils = {}));