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

package/lib/esm/errors.d.ts

@@ -228,6 +228,113 @@ export declare class InvalidTreeHeightError extends Error {
 export declare class InvalidTreeError extends Error {
     constructor(message: string);
 }
+/**
+ * Thrown when a RateRatifierV1 leaf receives a negative rate.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1RateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1RateError(-1n);
+ * ```
+ */
+export declare class InvalidRateRatifierV1RateError extends Error {
+    /** Negative rate that was rejected. */
+    readonly rate: bigint;
+    constructor(rate: bigint);
+}
+/**
+ * Thrown when RateRatifierV1 price-bound arithmetic overflows uint256.
+ *
+ * @example
+ * ```ts
+ * import { RateRatifierV1BoundOverflowError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new RateRatifierV1BoundOverflowError(2n ** 255n, 10n);
+ * ```
+ */
+export declare class RateRatifierV1BoundOverflowError extends Error {
+    /** Rate whose bound arithmetic overflowed. */
+    readonly rate: bigint;
+    /** Time to maturity used in the overflowing bound. */
+    readonly timeToMaturity: bigint;
+    constructor(rate: bigint, timeToMaturity: bigint);
+}
+/**
+ * Thrown when a RateRatifierV1 leaf offer commits a nominal tick below the
+ * router's minimum takeable tick.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1TickError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1TickError(0n, 3372n);
+ * ```
+ */
+export declare class InvalidRateRatifierV1TickError extends Error {
+    /** Nominal tick that was rejected. */
+    readonly tick: bigint;
+    /** Minimum accepted tick. */
+    readonly minTick: bigint;
+    constructor(tick: bigint, minTick: bigint);
+}
+/**
+ * Thrown when a RateRatifierV1 time parameter is negative.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1TimeError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1TimeError(-1n, "timestamp");
+ * ```
+ */
+export declare class InvalidRateRatifierV1TimeError extends Error {
+    /** Negative time value that was rejected. */
+    readonly value: bigint;
+    /** Parameter that carried the negative value. */
+    readonly field: "timeToMaturity" | "timestamp";
+    constructor(value: bigint, field: "timeToMaturity" | "timestamp");
+}
+/**
+ * Thrown when a V1 ratifier address is the zero address.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRatifierV1AddressError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRatifierV1AddressError(
+ *   "0x0000000000000000000000000000000000000000",
+ * );
+ * ```
+ */
+export declare class InvalidRatifierV1AddressError extends Error {
+    /** Zero ratifier address that was rejected. */
+    readonly ratifier: Address;
+    constructor(ratifier: Address);
+}
+/**
+ * Thrown when a taker is not the allowed taker of a V1 ratifier leaf.
+ *
+ * @example
+ * ```ts
+ * import { RatifierV1TakerNotAllowedError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new RatifierV1TakerNotAllowedError({
+ *   taker: "0x0000000000000000000000000000000000000001",
+ *   allowedTaker: "0x0000000000000000000000000000000000000002",
+ * });
+ * ```
+ */
+export declare class RatifierV1TakerNotAllowedError extends Error {
+    /** Taker that attempted to take the offer. */
+    readonly taker: Address;
+    /** Taker allowed by the ratified leaf. */
+    readonly allowedTaker: Address;
+    constructor(params: {
+        readonly taker: Address;
+        readonly allowedTaker: Address;
+    });
+}
 /**
  * Thrown when a viem client's chain id does not match the chain id required by a signing flow.
  *

package/lib/esm/errors.js

@@ -263,6 +263,138 @@ export class InvalidTreeError extends Error {
         this.name = "InvalidTreeError";
     }
 }
+/**
+ * Thrown when a RateRatifierV1 leaf receives a negative rate.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1RateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1RateError(-1n);
+ * ```
+ */
+export class InvalidRateRatifierV1RateError extends Error {
+    /** Negative rate that was rejected. */
+    rate;
+    constructor(rate) {
+        super(`Rate "${rate}" is negative. Use a non-negative WAD-scaled rate.`);
+        this.name = "InvalidRateRatifierV1RateError";
+        this.rate = rate;
+    }
+}
+/**
+ * Thrown when RateRatifierV1 price-bound arithmetic overflows uint256.
+ *
+ * @example
+ * ```ts
+ * import { RateRatifierV1BoundOverflowError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new RateRatifierV1BoundOverflowError(2n ** 255n, 10n);
+ * ```
+ */
+export class RateRatifierV1BoundOverflowError extends Error {
+    /** Rate whose bound arithmetic overflowed. */
+    rate;
+    /** Time to maturity used in the overflowing bound. */
+    timeToMaturity;
+    constructor(rate, timeToMaturity) {
+        super(`Rate bound arithmetic overflows uint256 for rate "${rate}" and timeToMaturity "${timeToMaturity}". Lower the rate or time to maturity.`);
+        this.name = "RateRatifierV1BoundOverflowError";
+        this.rate = rate;
+        this.timeToMaturity = timeToMaturity;
+    }
+}
+/**
+ * Thrown when a RateRatifierV1 leaf offer commits a nominal tick below the
+ * router's minimum takeable tick.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1TickError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1TickError(0n, 3372n);
+ * ```
+ */
+export class InvalidRateRatifierV1TickError extends Error {
+    /** Nominal tick that was rejected. */
+    tick;
+    /** Minimum accepted tick. */
+    minTick;
+    constructor(tick, minTick) {
+        super(`Offer tick "${tick}" is below the minimum "${minTick}" (price >= 0.5 WAD). RateRatifierV1 prices from \`rate\`, but the router still validates the committed tick; set a nominal tick of at least "${minTick}".`);
+        this.name = "InvalidRateRatifierV1TickError";
+        this.tick = tick;
+        this.minTick = minTick;
+    }
+}
+/**
+ * Thrown when a RateRatifierV1 time parameter is negative.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRateRatifierV1TimeError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRateRatifierV1TimeError(-1n, "timestamp");
+ * ```
+ */
+export class InvalidRateRatifierV1TimeError extends Error {
+    /** Negative time value that was rejected. */
+    value;
+    /** Parameter that carried the negative value. */
+    field;
+    constructor(value, field) {
+        super(`${field} "${value}" is negative. Use a non-negative number of seconds.`);
+        this.name = "InvalidRateRatifierV1TimeError";
+        this.value = value;
+        this.field = field;
+    }
+}
+/**
+ * Thrown when a V1 ratifier address is the zero address.
+ *
+ * @example
+ * ```ts
+ * import { InvalidRatifierV1AddressError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidRatifierV1AddressError(
+ *   "0x0000000000000000000000000000000000000000",
+ * );
+ * ```
+ */
+export class InvalidRatifierV1AddressError extends Error {
+    /** Zero ratifier address that was rejected. */
+    ratifier;
+    constructor(ratifier) {
+        super(`Ratifier address "${ratifier}" is the zero address. Use a deployed PriceRatifierV1 or RateRatifierV1 address.`);
+        this.name = "InvalidRatifierV1AddressError";
+        this.ratifier = ratifier;
+    }
+}
+/**
+ * Thrown when a taker is not the allowed taker of a V1 ratifier leaf.
+ *
+ * @example
+ * ```ts
+ * import { RatifierV1TakerNotAllowedError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new RatifierV1TakerNotAllowedError({
+ *   taker: "0x0000000000000000000000000000000000000001",
+ *   allowedTaker: "0x0000000000000000000000000000000000000002",
+ * });
+ * ```
+ */
+export class RatifierV1TakerNotAllowedError extends Error {
+    /** Taker that attempted to take the offer. */
+    taker;
+    /** Taker allowed by the ratified leaf. */
+    allowedTaker;
+    constructor(params) {
+        super(`Taker "${params.taker}" is not the allowed taker "${params.allowedTaker}". Use the allowed taker or an offer without a taker restriction.`);
+        this.name = "RatifierV1TakerNotAllowedError";
+        this.taker = params.taker;
+        this.allowedTaker = params.allowedTaker;
+    }
+}
 /**
  * Thrown when a viem client's chain id does not match the chain id required by a signing flow.
  *

package/lib/esm/fetch/Ratifier.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Client } from "viem";
-import { type RatifierInfo } from "../signatures/RatifierUtils.js";
+import { type RatifierInfo } from "../signatures/Ratifier.js";
 import type { MidnightCallParameters } from "./types.js";
 /**
  * Fetches maker bytecode and classifies the ratifier route for new offers.
@@ -9,7 +9,7 @@ import type { MidnightCallParameters } from "./types.js";
  * the maker is an EOA or EIP-7702 account that can use Ecrecover signatures, or
  * a deployed-code account that should use Setter root approval. Put the returned
  * `ratifier` address on `Offer.create`, then use the returned `type` to choose
- * `EcrecoverRatifierUtils.ratify` or `SetterRatifierUtils.ratify` after the tree
+ * `EcrecoverRatifier.ratify` or `SetterRatifier.ratify` after the tree
  * has been built.
  *
  * Reads `eth_chainId` only when the viem client has no configured chain id,
@@ -29,7 +29,8 @@ import type { MidnightCallParameters } from "./types.js";
  * const maker = "0x7b093658BE7f90B63D7c359e8f408e503c2D9401";
  * const info = await fetchRatifierInfo(client, { maker });
  * // Pass info.ratifier to Offer.create(...), then use info.type after
- * // Tree.create([...]) to choose the Ecrecover or Setter ratifier flow.
+ * // Tree.create({ type: info.type, entries: [...] }) to choose the Ecrecover
+ * // or Setter ratifier flow.
  * console.log(info.type, info.ratifier);
  * ```
  */

package/lib/esm/fetch/Ratifier.js

@@ -1,6 +1,6 @@
 import { getChainAddress } from "@morpho-org/morpho-ts";
 import { getBytecode } from "viem/actions";
-import { RatifierUtils, } from "../signatures/RatifierUtils.js";
+import { Ratifier } from "../signatures/Ratifier.js";
 import { resolveChainId } from "./utils.js";
 /**
  * Fetches maker bytecode and classifies the ratifier route for new offers.
@@ -10,7 +10,7 @@ import { resolveChainId } from "./utils.js";
  * the maker is an EOA or EIP-7702 account that can use Ecrecover signatures, or
  * a deployed-code account that should use Setter root approval. Put the returned
  * `ratifier` address on `Offer.create`, then use the returned `type` to choose
- * `EcrecoverRatifierUtils.ratify` or `SetterRatifierUtils.ratify` after the tree
+ * `EcrecoverRatifier.ratify` or `SetterRatifier.ratify` after the tree
  * has been built.
  *
  * Reads `eth_chainId` only when the viem client has no configured chain id,
@@ -30,7 +30,8 @@ import { resolveChainId } from "./utils.js";
  * const maker = "0x7b093658BE7f90B63D7c359e8f408e503c2D9401";
  * const info = await fetchRatifierInfo(client, { maker });
  * // Pass info.ratifier to Offer.create(...), then use info.type after
- * // Tree.create([...]) to choose the Ecrecover or Setter ratifier flow.
+ * // Tree.create({ type: info.type, entries: [...] }) to choose the Ecrecover
+ * // or Setter ratifier flow.
  * console.log(info.type, info.ratifier);
  * ```
  */
@@ -46,7 +47,7 @@ export async function fetchRatifierInfo(client, params) {
                 : {}),
         address: params.maker,
     });
-    return RatifierUtils.getRatifierInfo({
+    return Ratifier.getRatifierInfo({
         bytecode,
         ecrecoverRatifier,
         setterRatifier,

package/lib/esm/index.d.ts

@@ -6,6 +6,7 @@ export * from "./market/index.js";
 export * from "./math/index.js";
 export * from "./offers/index.js";
 export * from "./position/index.js";
+export { EcrecoverRatifier, EcrecoverRatifierUtils, } from "./signatures/EcrecoverRatifier.js";
 export * from "./signatures/index.js";
 /**
  * Namespace for Midnight mempool payload utilities.
@@ -17,3 +18,9 @@ export * from "./signatures/index.js";
  * mempool submission calldata.
  */
 export { Payload } from "./signatures/Payload.js";
+export { PriceRatifierV1, PriceRatifierV1Utils, } from "./signatures/PriceRatifierV1.js";
+export { RateRatifierV1, RateRatifierV1Utils, } from "./signatures/RateRatifierV1.js";
+export { Ratifier, RatifierUtils } from "./signatures/Ratifier.js";
+export type { EcrecoverRatifierDataRequest, EcrecoverRatifierRatifyRequest, EcrecoverRatifierSignRequest, EcrecoverRatifierTypedDataRequest, SetterRatifierDataRequest, SetterRatifierRatifyRequest, } from "./signatures/ratifierRequests.js";
+export { SetterRatifier, SetterRatifierUtils, } from "./signatures/SetterRatifier.js";
+export type { AnyTree, AnyTreeSnapshot, EcrecoverTreeCreateRequest, PriceRatifierV1TreeCreateRequest, RateRatifierV1TreeCreateRequest, RatifierKind, RatifierTypes, SetterTreeCreateRequest, TreeCreateRequest, TreeData, TreeEntry, TreeSnapshot, TypedRatifierTreeInput, TypedTreeMempoolValidateParams, } from "./signatures/treeTypes.js";

package/lib/esm/index.js

@@ -6,6 +6,7 @@ export * from "./market/index.js";
 export * from "./math/index.js";
 export * from "./offers/index.js";
 export * from "./position/index.js";
+export { EcrecoverRatifier, EcrecoverRatifierUtils, } from "./signatures/EcrecoverRatifier.js";
 export * from "./signatures/index.js";
 /**
  * Namespace for Midnight mempool payload utilities.
@@ -17,3 +18,7 @@ export * from "./signatures/index.js";
  * mempool submission calldata.
  */
 export { Payload } from "./signatures/Payload.js";
+export { PriceRatifierV1, PriceRatifierV1Utils, } from "./signatures/PriceRatifierV1.js";
+export { RateRatifierV1, RateRatifierV1Utils, } from "./signatures/RateRatifierV1.js";
+export { Ratifier, RatifierUtils } from "./signatures/Ratifier.js";
+export { SetterRatifier, SetterRatifierUtils, } from "./signatures/SetterRatifier.js";

package/lib/esm/offers/Offer.d.ts

@@ -150,6 +150,16 @@ export declare class Offer {
     readonly tick: bigint;
     private cachedGroup;
     private cachedHash;
+    /**
+     * Whether the group id was supplied at construction rather than derived.
+     *
+     * Ratifier-specific tree builders only substitute their scheme's
+     * content-addressed singleton group when this is `false`; an explicit
+     * group is always committed as-is.
+     *
+     * @internal
+     */
+    readonly hasExplicitGroup: boolean;
     /** Optional maker callback. */
     readonly callback: Address;
     /** Callback payload. */

package/lib/esm/offers/Offer.js

@@ -68,6 +68,16 @@ export class Offer {
     tick;
     cachedGroup;
     cachedHash;
+    /**
+     * Whether the group id was supplied at construction rather than derived.
+     *
+     * Ratifier-specific tree builders only substitute their scheme's
+     * content-addressed singleton group when this is `false`; an explicit
+     * group is always committed as-is.
+     *
+     * @internal
+     */
+    hasExplicitGroup;
     /** Optional maker callback. */
     callback;
     /** Callback payload. */
@@ -94,7 +104,11 @@ export class Offer {
         this.start = BigInt(offer.start);
         this.expiry = BigInt(offer.expiry);
         this.tick = BigInt(offer.tick);
-        this.cachedGroup = offer.group;
+        this.hasExplicitGroup =
+            offer instanceof Offer
+                ? offer.hasExplicitGroup
+                : offer.group !== undefined;
+        this.cachedGroup = this.hasExplicitGroup ? offer.group : undefined;
         this.callback = offer.callback;
         this.callbackData = offer.callbackData;
         this.receiverIfMakerIsSeller = offer.receiverIfMakerIsSeller;

package/lib/esm/offers/OfferUtils.d.ts

@@ -24,6 +24,9 @@ export declare namespace OfferUtils {
      * This is the bridge from SDK/domain objects
      * into Merkle leaf hashing, payload items, and take calldata encoding.
      *
+     * The struct carries a materialized group (the generic default when omitted);
+     * V1 tree builders re-derive that generic default under their scheme.
+     *
      * @param params.offer - Offer class or plain offer input to encode.
      * @param params.group - Optional protocol group id override encoded into the ABI offer.
      * @returns ABI-compatible offer.

package/lib/esm/offers/OfferUtils.js

@@ -47,6 +47,9 @@ export var OfferUtils;
      * This is the bridge from SDK/domain objects
      * into Merkle leaf hashing, payload items, and take calldata encoding.
      *
+     * The struct carries a materialized group (the generic default when omitted);
+     * V1 tree builders re-derive that generic default under their scheme.
+     *
      * @param params.offer - Offer class or plain offer input to encode.
      * @param params.group - Optional protocol group id override encoded into the ABI offer.
      * @returns ABI-compatible offer.

package/lib/esm/signatures/{EcrecoverRatifierUtils.d.ts → EcrecoverRatifier.d.ts}

@@ -2,7 +2,9 @@ import { type BigIntish } from "@morpho-org/morpho-ts";
 import { type Account, type Address, type Chain, type Client, type Hash, type Hex, type Signature, type Transport } 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 { EcrecoverRatifierDataRequest, EcrecoverRatifierRatifyRequest, EcrecoverRatifierSignRequest, EcrecoverRatifierTypedDataRequest } from "./ratifierRequests.js";
+import type { RatifierTreeInput } from "./TreeUtils.js";
+import { type TreeProof } from "./TreeUtils.js";
 declare const typedDataTypes: {
     readonly EIP712Domain: readonly [{
         readonly name: "chainId";
@@ -245,6 +247,7 @@ export type EcrecoverSignatureInput = Hex | Signature | Signature<number, number
  * };
  * console.log(params.chainId);
  * ```
+ * @deprecated Use {@link EcrecoverRatifierTypedDataRequest} with {@link EcrecoverRatifier}.
  */
 export interface EcrecoverRatifierTypedDataParams {
     /** Tree-like input being ratified. Existing `Tree` instances reuse cached hashes and proofs. */
@@ -295,6 +298,7 @@ export interface EcrecoverRatifierTypedDataParams {
  * };
  * console.log(params.tree);
  * ```
+ * @deprecated Use {@link EcrecoverRatifierRatifyRequest} with {@link EcrecoverRatifier}.
  */
 export type EcrecoverRatifierRatifyParams = {
     /** Tree-like input being ratified. */
@@ -357,6 +361,7 @@ export type EcrecoverRatifierRatifyParams = {
  * };
  * console.log(params.leafIndex);
  * ```
+ * @deprecated Use {@link EcrecoverRatifierDataRequest} with {@link EcrecoverRatifier}.
  */
 export interface EcrecoverRatifierDataParams {
     /** Tree-like input that produced the proof. Existing `Tree` instances reuse cached hashes and proofs. */
@@ -419,6 +424,7 @@ export interface VerifiedEcrecoverRatifierData extends DecodedEcrecoverRatifierD
  *
  * console.log(EcrecoverRatifierUtils.treeTypeHash(0));
  * ```
+ * @deprecated Use {@link EcrecoverRatifier} with a tagged tree.
  */
 export declare namespace EcrecoverRatifierUtils {
     /**
@@ -593,7 +599,7 @@ export declare namespace EcrecoverRatifierUtils {
      * Verifies an Ecrecover ratifier-data proof and recovers its signer.
      *
      * This helper intentionally does not check `Midnight.isAuthorized` or
-     * `EcrecoverRatifier.isRootCanceled` state. Consumers must query both at the
+     * `EcrecoverRatifierUtils.isRootCanceled` state. Consumers must query both at the
      * observed block before treating a recovered item as executable: the returned
      * signer must be the maker or authorized by the maker, the offer ratifier must
      * be authorized by the maker, and `isRootCanceled(maker, root)` must be false.
@@ -876,4 +882,114 @@ export declare namespace EcrecoverRatifierUtils {
      */
     function ratify(params: EcrecoverRatifierRatifyParams): Promise<readonly Payload.Item[]>;
 }
+/**
+ * Tagged-tree API for EcrecoverRatifier with validated portable leaf commitments.
+ * Legacy untagged inputs remain available through {@link EcrecoverRatifierUtils}.
+ */
+export declare namespace EcrecoverRatifier {
+    /**
+     * Builds Ecrecover signing data from a tagged tree.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.chainId - Chain defining the EIP-712 domain.
+     * @returns EIP-712 domain, type definitions, and offer-tree message.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierTypedDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierTypedDataRequest) {
+     *   return EcrecoverRatifier.typedData(request);
+     * }
+     * ```
+     */
+    function typedData(request: EcrecoverRatifierTypedDataRequest): EcrecoverRatificationTypedData;
+    /**
+     * Computes the signing digest of a tagged Ecrecover tree.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.chainId - Chain defining the EIP-712 domain.
+     * @returns The EIP-712 signing digest.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierTypedDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierTypedDataRequest) {
+     *   return EcrecoverRatifier.digest(request);
+     * }
+     * ```
+     */
+    function digest(request: EcrecoverRatifierTypedDataRequest): Hash;
+    /**
+     * Signs a tagged Ecrecover tree using the supplied client and account.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.account - Maker or authorized signer.
+     * @param request.client - Signing client; omit when ratify receives a precomputed signature.
+     * @returns A verified hex signature over the tree.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {ChainIdMismatchError} When the signing client's chain differs from the offers.
+     * @throws {InvalidTypedDataSignatureError} When the signature does not recover to the supplied account.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierSignRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierSignRequest) {
+     *   return EcrecoverRatifier.sign(request);
+     * }
+     * ```
+     */
+    function sign(request: EcrecoverRatifierSignRequest): Promise<Hex>;
+    /**
+     * Encodes the signature and proof for one tagged Ecrecover leaf.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.signature - Tree signature; ratify may instead request one through the supplied client.
+     * @param request.leafIndex - Leaf to prove.
+     * @returns ABI-encoded ratifier data for the requested leaf.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {InvalidEcrecoverSignatureVError} When a supplied signature has an unsupported recovery value.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierDataRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierDataRequest) {
+     *   return EcrecoverRatifier.ratifierData(request);
+     * }
+     * ```
+     */
+    function ratifierData(request: EcrecoverRatifierDataRequest): Hex;
+    /**
+     * Builds payload items from a tagged tree and a verified signature.
+     * @param request.tree - Matching tagged tree or portable snapshot; commitments are validated before use.
+     * @param request.account - Maker or authorized signer.
+     * @param request.client - Signing client; omit when ratify receives a precomputed signature.
+     * @param request.signature - Tree signature; ratify may instead request one through the supplied client.
+     * @returns One payload item per non-padding offer, including its ratifier data.
+     * @throws {InvalidTreeError} When the tag, commitments, or root are invalid.
+     * @throws {InvalidTreeHeightError} When the descriptor height is unsupported.
+     * @throws {ChainIdMismatchError} When the signing client's chain differs from the offers.
+     * @throws {InvalidTypedDataSignatureError} When the signature does not recover to the supplied account.
+     * @throws {InvalidEcrecoverSignatureVError} When a supplied signature has an unsupported recovery value.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifier, type EcrecoverRatifierRatifyRequest } from "@morpho-org/midnight-sdk";
+     * function execute(request: EcrecoverRatifierRatifyRequest) {
+     *   return EcrecoverRatifier.ratify(request);
+     * }
+     * ```
+     */
+    function ratify(request: EcrecoverRatifierRatifyRequest): Promise<readonly Payload.Item[]>;
+    /** {@inheritDoc EcrecoverRatifierUtils.treeTypeHash} */
+    const treeTypeHash: typeof EcrecoverRatifierUtils.treeTypeHash;
+    /** {@inheritDoc EcrecoverRatifierUtils.digestForRoot} */
+    const digestForRoot: typeof EcrecoverRatifierUtils.digestForRoot;
+    /** {@inheritDoc EcrecoverRatifierUtils.digestRatifierData} */
+    const digestRatifierData: typeof EcrecoverRatifierUtils.digestRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.verifyRatifierData} */
+    const verifyRatifierData: typeof EcrecoverRatifierUtils.verifyRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.toSignature} */
+    const toSignature: typeof EcrecoverRatifierUtils.toSignature;
+    /** {@inheritDoc EcrecoverRatifierUtils.encodeRatifierData} */
+    const encodeRatifierData: typeof EcrecoverRatifierUtils.encodeRatifierData;
+    /** {@inheritDoc EcrecoverRatifierUtils.decodeRatifierData} */
+    const decodeRatifierData: typeof EcrecoverRatifierUtils.decodeRatifierData;
+}
 export {};