@morpho-org/midnight-sdk 1.0.0 → 1.1.1

package/lib/esm/api/MidnightApi.js

@@ -1,5 +1,8 @@
+import { MathLib } from "@morpho-org/morpho-ts";
+import { InvalidMidnightApiResponseError } from "../errors.js";
+import { TickLib } from "../math/index.js";
 import { Payload } from "../signatures/Payload.js";
-import { buildBookPath, mapBookMarket, mapPriceLevel, mapTakeableOffer, parseValidationResponse, requestMidnightApi, } from "./helpers.js";
+import { buildBookPath, mapBookMarket, mapBoundTakeableOffers, mapPriceLevel, parseValidationResponse, requestMidnightApi, } from "./helpers.js";
 /**
  * Midnight API client and stateless helper surface for books and mempool data.
  *
@@ -217,7 +220,10 @@ export class MidnightApi {
             }),
         });
         return {
-            data: response.data.map(mapTakeableOffer),
+            data: mapBoundTakeableOffers(response.data, {
+                marketId: input.marketId,
+                side: input.side,
+            }),
         };
     }
     /**
@@ -267,7 +273,61 @@ export class MidnightApi {
                 assets: input.assets,
             },
         });
-        const takeableOffers = response.data.takeable_offers.map(mapTakeableOffer);
+        const takeableOffers = mapBoundTakeableOffers(response.data.takeable_offers, {
+            marketId: input.marketId,
+            side: input.side,
+        });
+        const averageWorstPrice = "averageWorstPrice" in input && input.averageWorstPrice != null
+            ? input.averageWorstPrice
+            : "slippage" in input && input.slippage != null
+                ? response.data.average_worst_price
+                : undefined;
+        if (averageWorstPrice != null) {
+            const guard = BigInt(averageWorstPrice);
+            let filledUnits = 0n;
+            let weightedPrice = 0n;
+            if ("units" in input && input.units != null) {
+                let remainingUnits = BigInt(input.units);
+                for (const take of takeableOffers) {
+                    if (remainingUnits === 0n)
+                        break;
+                    const price = TickLib.tickToPrice(take.offer.tick);
+                    const filled = take.units < remainingUnits ? take.units : remainingUnits;
+                    filledUnits += filled;
+                    weightedPrice += filled * price;
+                    remainingUnits -= filled;
+                }
+            }
+            else {
+                let remainingAssets = BigInt(input.assets);
+                for (const take of takeableOffers) {
+                    if (remainingAssets === 0n)
+                        break;
+                    const price = TickLib.tickToPrice(take.offer.tick);
+                    const takeAssets = input.side === "asks"
+                        ? MathLib.mulDivUp(take.units, price, MathLib.WAD)
+                        : MathLib.mulDivDown(take.units, price, MathLib.WAD);
+                    if (takeAssets === 0n)
+                        continue;
+                    const fillsEntireTake = takeAssets <= remainingAssets;
+                    const filled = fillsEntireTake
+                        ? take.units
+                        : MathLib.mulDiv(remainingAssets, MathLib.WAD, price, input.side === "asks" ? "Down" : "Up");
+                    if (filled === 0n)
+                        continue;
+                    filledUnits += filled;
+                    weightedPrice += filled * price;
+                    remainingAssets = fillsEntireTake ? remainingAssets - takeAssets : 0n;
+                }
+            }
+            if (filledUnits > 0n) {
+                const averagePrice = MathLib.mulDivDown(weightedPrice, 1n, filledUnits);
+                const violatesGuard = input.side === "asks" ? averagePrice > guard : averagePrice < guard;
+                if (violatesGuard) {
+                    throw new InvalidMidnightApiResponseError(`Midnight API quote takeable offers imply average price "${averagePrice}" outside average_worst_price guard "${guard}".`);
+                }
+            }
+        }
         return {
             data: {
                 averageBestPrice: response.data.average_best_price,
@@ -320,7 +380,11 @@ export class MidnightApi {
         });
         return {
             cursor: response.cursor,
-            data: response.data.map(mapTakeableOffer),
+            data: mapBoundTakeableOffers(response.data, {
+                maker: input.maker,
+                marketIds: input.marketIds,
+                groups: input.groups,
+            }),
         };
     }
     /**

package/lib/esm/api/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Hash } from "viem";
+import { type Address, type Hash } from "viem";
 import type { ApiBookMarketResponse, ApiCollateralResponse, ApiPriceLevelResponse, ApiRequestParams, ApiTakeableOfferResponse, MempoolPayloadValidationResult, MidnightApiBookMarket, MidnightApiBookSide, MidnightApiCollateral, MidnightApiPriceLevel, MidnightApiTake } from "./types.js";
 /** @internal Sends one Midnight API request and maps non-2xx responses to SDK errors. */
 export declare function requestMidnightApi<Response = unknown>(params: ApiRequestParams): Promise<Response>;
@@ -16,5 +16,15 @@ export declare function mapCollateral(collateral: ApiCollateralResponse): Midnig
 export declare function mapPriceLevel(level: ApiPriceLevelResponse): MidnightApiPriceLevel;
 /** @internal Maps a takeable-offer API payload to the SDK response shape. */
 export declare function mapTakeableOffer(takeableOffer: ApiTakeableOfferResponse): MidnightApiTake;
+/** @internal API response context required for a takeable offer to be executable for the caller's request. */
+export interface TakeableOfferContext {
+    readonly marketId?: Hash;
+    readonly side?: MidnightApiBookSide;
+    readonly maker?: Address;
+    readonly marketIds?: readonly Hash[];
+    readonly groups?: readonly Hash[];
+}
+/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+export declare function mapBoundTakeableOffers(takeableOffers: readonly ApiTakeableOfferResponse[], context: TakeableOfferContext): MidnightApiTake[];
 /** @internal Parses the mempool validation response envelope. */
 export declare function parseValidationResponse(response: unknown): MempoolPayloadValidationResult;

package/lib/esm/api/helpers.js

@@ -1,9 +1,11 @@
-import { BLUE_API_BASE_URL } from "@morpho-org/morpho-ts";
+import { BLUE_API_BASE_URL, isHexEqual } from "@morpho-org/morpho-ts";
+import { isAddressEqual } from "viem";
 import { InvalidMidnightApiResponseError, MidnightApiError, } from "../errors.js";
+import { MarketUtils } from "../market/index.js";
 const DEFAULT_MIDNIGHT_API_URL = new URL("/v0/midnight", BLUE_API_BASE_URL);
 // Keep this literal in source so the browser ESM build does not import package.json
 // through Node-only createRequire/module shims.
-const MIDNIGHT_SDK_VERSION = "0.1.0";
+const MIDNIGHT_SDK_VERSION = "1.0.1";
 /** @internal Sends one Midnight API request and maps non-2xx responses to SDK errors. */
 export async function requestMidnightApi(params) {
     const baseUrl = new URL(params.baseUrl ?? DEFAULT_MIDNIGHT_API_URL);
@@ -153,6 +155,50 @@ export function mapTakeableOffer(takeableOffer) {
         ratifierData: takeableOffer.ratifier_data,
     };
 }
+/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+export function mapBoundTakeableOffers(takeableOffers, context) {
+    const mapped = takeableOffers.map((takeableOffer) => {
+        const take = mapTakeableOffer(takeableOffer);
+        const embeddedMarketId = MarketUtils.toId(take.offer.market);
+        if (!isHexEqual(embeddedMarketId, take.marketId)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" does not match embedded offer market "${embeddedMarketId}".`);
+        }
+        if (context.marketId != null &&
+            !isHexEqual(take.marketId, context.marketId)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" does not match requested market "${context.marketId}".`);
+        }
+        if (context.marketIds != null &&
+            context.marketIds.length > 0 &&
+            !context.marketIds.some((marketId) => isHexEqual(marketId, take.marketId))) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" is outside the requested market_ids filter.`);
+        }
+        if (context.side != null) {
+            const expectedBuy = context.side === "bids";
+            if (take.offer.buy !== expectedBuy) {
+                throw new InvalidMidnightApiResponseError(`Midnight API ${context.side} takeable offer returned offer.buy "${take.offer.buy}".`);
+            }
+        }
+        if (context.maker != null &&
+            !isAddressEqual(take.offer.maker, context.maker)) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer maker "${take.offer.maker}" does not match requested maker "${context.maker}".`);
+        }
+        if (context.groups != null &&
+            context.groups.length > 0 &&
+            !context.groups.some((group) => isHexEqual(group, take.offer.group))) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer group "${take.offer.group}" is outside the requested groups filter.`);
+        }
+        return take;
+    });
+    if (context.side == null)
+        return mapped;
+    return [...mapped].sort((a, b) => {
+        if (a.offer.tick === b.offer.tick)
+            return 0;
+        if (context.side === "asks")
+            return a.offer.tick < b.offer.tick ? -1 : 1;
+        return a.offer.tick > b.offer.tick ? -1 : 1;
+    });
+}
 /** @internal Parses the mempool validation response envelope. */
 export function parseValidationResponse(response) {
     const parsedResponse = requireRecord(response, "validation response");

package/lib/esm/errors.d.ts

@@ -277,6 +277,21 @@ export declare class InvalidTypedDataSignatureError extends Error {
     readonly signer: Address;
     constructor(signer: Address, cause?: unknown);
 }
+/**
+ * Thrown when decoded Ecrecover ratifier data contains a non-canonical signature `v` value.
+ *
+ * @example
+ * ```ts
+ * import { InvalidEcrecoverSignatureVError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidEcrecoverSignatureVError(29);
+ * ```
+ */
+export declare class InvalidEcrecoverSignatureVError extends Error {
+    /** Invalid ECDSA recovery id. */
+    readonly v: number;
+    constructor(v: number);
+}
 /**
  * Thrown when the Midnight API returns a non-2xx response.
  *

package/lib/esm/errors.js

@@ -325,6 +325,25 @@ export class InvalidTypedDataSignatureError extends Error {
         this.signer = signer;
     }
 }
+/**
+ * Thrown when decoded Ecrecover ratifier data contains a non-canonical signature `v` value.
+ *
+ * @example
+ * ```ts
+ * import { InvalidEcrecoverSignatureVError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidEcrecoverSignatureVError(29);
+ * ```
+ */
+export class InvalidEcrecoverSignatureVError extends Error {
+    /** Invalid ECDSA recovery id. */
+    v;
+    constructor(v) {
+        super(`Ecrecover signature v "${v}" is invalid. Use canonical Ethereum v 27 or 28.`);
+        this.name = "InvalidEcrecoverSignatureVError";
+        this.v = v;
+    }
+}
 /**
  * Thrown when the Midnight API returns a non-2xx response.
  *

package/lib/esm/fetch/Market.js

@@ -1,7 +1,8 @@
 import { getChainAddress } from "@morpho-org/morpho-ts";
 import { readContract } from "viem/actions";
 import { midnightAbi } from "../abis.js";
-import { Market, MarketParams } from "../market/index.js";
+import { InvalidMarketParameterError } from "../errors.js";
+import { Market, MarketParams, MarketUtils } from "../market/index.js";
 import { callParameters, resolveChainId } from "./utils.js";
 /**
  * Fetches immutable market params by id.
@@ -41,7 +42,11 @@ export async function fetchMarketParams(client, params) {
         functionName: "toMarket",
         args: [params.marketId],
     });
-    return new MarketParams(market);
+    return normalizeFetchedMarketParams(market, {
+        marketId: params.marketId,
+        chainId,
+        midnight,
+    });
 }
 /**
  * Fetches a hydrated market by id.
@@ -92,7 +97,11 @@ export async function fetchMarket(client, params) {
     ]);
     const [totalUnits, lossFactor, withdrawable, continuousFeeCredit, settlementFeeCbps0, settlementFeeCbps1, settlementFeeCbps2, settlementFeeCbps3, settlementFeeCbps4, settlementFeeCbps5, settlementFeeCbps6, continuousFee, tickSpacing,] = state;
     return new Market({
-        params: new MarketParams(market),
+        params: normalizeFetchedMarketParams(market, {
+            marketId: params.marketId,
+            chainId,
+            midnight,
+        }),
         totalUnits,
         lossFactor,
         withdrawable,
@@ -110,3 +119,29 @@ export async function fetchMarket(client, params) {
         tickSpacing,
     });
 }
+function normalizeFetchedMarketParams(market, expected) {
+    const marketParams = new MarketParams(market);
+    if (marketParams.chainId !== BigInt(expected.chainId)) {
+        throw new InvalidMarketParameterError({
+            parameter: "chainId",
+            value: marketParams.chainId,
+            instruction: `Fetched market must use client chain id "${expected.chainId}".`,
+        });
+    }
+    if (marketParams.midnight.toLowerCase() !== expected.midnight.toLowerCase()) {
+        throw new InvalidMarketParameterError({
+            parameter: "midnight",
+            value: marketParams.midnight,
+            instruction: `Fetched market must use Midnight contract "${expected.midnight}".`,
+        });
+    }
+    const actualMarketId = MarketUtils.toId(marketParams);
+    if (actualMarketId.toLowerCase() !== expected.marketId.toLowerCase()) {
+        throw new InvalidMarketParameterError({
+            parameter: "marketId",
+            value: actualMarketId,
+            instruction: `Fetched market must match requested market id "${expected.marketId}".`,
+        });
+    }
+    return marketParams;
+}

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

@@ -4,5 +4,5 @@ import type { DeploylessFetchParameters, MidnightCallParameters } from "./types.
 export declare const callParameters: (params: MidnightCallParameters) => MidnightCallParameters;
 /** @internal Returns the configured deployless mode, defaulting to enabled. */
 export declare const shouldUseDeployless: (params: DeploylessFetchParameters) => boolean | "force";
-/** @internal Returns the configured viem client chain id or fetches it from RPC. */
+/** @internal Returns the RPC chain id and rejects configured-chain drift. */
 export declare const resolveChainId: (client: Client) => Promise<number>;

package/lib/esm/fetch/utils.js

@@ -1,4 +1,5 @@
 import { getChainId } from "viem/actions";
+import { ChainIdMismatchError } from "../errors.js";
 /** @internal Extracts viem call parameters from Midnight fetch inputs. */
 export const callParameters = (params) => ({
     account: params.account,
@@ -8,5 +9,11 @@ export const callParameters = (params) => ({
 });
 /** @internal Returns the configured deployless mode, defaulting to enabled. */
 export const shouldUseDeployless = (params) => params.deployless ?? true;
-/** @internal Returns the configured viem client chain id or fetches it from RPC. */
-export const resolveChainId = async (client) => client.chain?.id ?? (await getChainId(client));
+/** @internal Returns the RPC chain id and rejects configured-chain drift. */
+export const resolveChainId = async (client) => {
+    const rpcChainId = await getChainId(client);
+    if (client.chain?.id != null && client.chain.id !== rpcChainId) {
+        throw new ChainIdMismatchError(client.chain.id, BigInt(rpcChainId));
+    }
+    return rpcChainId;
+};

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

@@ -721,7 +721,7 @@ export interface BuildOfferParams {
     readonly maxUnits?: BigIntish;
     /** Maximum buyer or seller assets; defaults to zero. Exactly one of `maxUnits` and `maxAssets` must be non-zero. */
     readonly maxAssets?: BigIntish;
-    /** Maximum market continuous fee accepted by this offer; defaults to the protocol maximum. */
+    /** Maximum market continuous fee accepted by this offer; defaults to zero. */
     readonly continuousFeeCap?: BigIntish;
     /** Offer start timestamp; defaults to zero. */
     readonly start?: BigIntish;

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

@@ -1,5 +1,5 @@
 import { type BigIntish } from "@morpho-org/morpho-ts";
-import type { Address, Hash } from "viem";
+import { type Address, type Hash } from "viem";
 import { type BuildOfferParams, type IOffer, Offer, type OfferStruct } from "./Offer.js";
 /**
  * Object-compatible helpers for Midnight offer construction, grouping, and
@@ -280,8 +280,8 @@ export declare namespace OfferUtils {
      * Validates and normalizes the maximum continuous fee an offer accepts.
      *
      * Use this before `Offer.create` when a maker UI exposes fee tolerance.
-     * `Offer.create` calls it internally and defaults omitted values to
-     * {@link MAX_CONTINUOUS_FEE}.
+     * `Offer.create` calls it internally and defaults omitted values to zero so
+     * fresh offers fail closed unless the maker explicitly accepts a fee cap.
      *
      * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer.
      * @returns Normalized continuous fee cap.
@@ -339,7 +339,7 @@ export declare namespace OfferUtils {
      * @param params.tickSpacing - Optional market tick spacing; defaults to `DEFAULT_TICK_SPACING`.
      * @param params.maxUnits - Optional unit cap; defaults to zero.
      * @param params.maxAssets - Optional buyer or seller asset cap; defaults to zero.
-     * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer; defaults to `MAX_CONTINUOUS_FEE`.
+     * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer; defaults to zero.
      * @param params.start - Optional offer start timestamp; defaults to zero.
      * @param params.expiry - Offer expiry timestamp.
      * @param params.receiverIfMakerIsSeller - Optional receiver used when maker is seller.
@@ -620,7 +620,7 @@ export declare namespace OfferUtils {
      * ```
      */
     function getConsumableUnits(params: {
-        readonly offer: Pick<IOffer, "market" | "buy" | "tick" | "maxUnits" | "maxAssets" | "continuousFeeCap">;
+        readonly offer: Pick<IOffer, "market" | "buy" | "start" | "expiry" | "tick" | "maxUnits" | "maxAssets" | "continuousFeeCap">;
         readonly consumed: BigIntish;
         readonly timestamp: BigIntish;
     }): bigint;

package/lib/esm/offers/OfferUtils.js

@@ -1,11 +1,10 @@
 import { assertNonNegative, DivisionByZeroError, MathLib, } from "@morpho-org/morpho-ts";
-import { encodeAbiParameters, keccak256, zeroAddress, zeroHash } from "viem";
-import { DEFAULT_TICK_SPACING, MAX_CONTINUOUS_FEE, MAX_OFFER_CAP, MAX_TICK, OFFER_TYPEHASH, } from "../constants.js";
+import { encodeAbiParameters, isAddressEqual, keccak256, zeroAddress, zeroHash, } from "viem";
+import { DEFAULT_TICK_SPACING, MAX_OFFER_CAP, MAX_TICK, OFFER_TYPEHASH, } from "../constants.js";
 import { InvalidOfferGroupError, InvalidOfferParameterError, } from "../errors.js";
 import { Market, MarketParams, MarketUtils } from "../market/index.js";
 import { TakeAmountsLib, TickLib } from "../math/index.js";
 import { Offer, } from "./Offer.js";
-const comparableHex = (value) => value.toLowerCase();
 const offerHashParams = [
     { name: "typehash", type: "bytes32" },
     { name: "marketHash", type: "bytes32" },
@@ -414,8 +413,8 @@ export var OfferUtils;
      * Validates and normalizes the maximum continuous fee an offer accepts.
      *
      * Use this before `Offer.create` when a maker UI exposes fee tolerance.
-     * `Offer.create` calls it internally and defaults omitted values to
-     * {@link MAX_CONTINUOUS_FEE}.
+     * `Offer.create` calls it internally and defaults omitted values to zero so
+     * fresh offers fail closed unless the maker explicitly accepts a fee cap.
      *
      * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer.
      * @returns Normalized continuous fee cap.
@@ -429,7 +428,7 @@ export var OfferUtils;
      * ```
      */
     function validateContinuousFeeCap(params) {
-        const continuousFeeCap = BigInt(params.continuousFeeCap ?? MAX_CONTINUOUS_FEE);
+        const continuousFeeCap = BigInt(params.continuousFeeCap ?? 0n);
         if (continuousFeeCap < 0n) {
             throw new InvalidOfferParameterError({
                 parameter: "continuousFeeCap",
@@ -488,7 +487,7 @@ export var OfferUtils;
      * @param params.tickSpacing - Optional market tick spacing; defaults to `DEFAULT_TICK_SPACING`.
      * @param params.maxUnits - Optional unit cap; defaults to zero.
      * @param params.maxAssets - Optional buyer or seller asset cap; defaults to zero.
-     * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer; defaults to `MAX_CONTINUOUS_FEE`.
+     * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer; defaults to zero.
      * @param params.start - Optional offer start timestamp; defaults to zero.
      * @param params.expiry - Offer expiry timestamp.
      * @param params.receiverIfMakerIsSeller - Optional receiver used when maker is seller.
@@ -579,13 +578,15 @@ export var OfferUtils;
         }
         const offers = offerInputs.map((offer) => Offer.from(offer));
         const first = offers[0];
-        const expectedMaker = comparableHex(first.maker);
+        const expectedMaker = first.maker;
         const expectedBuy = first.buy;
-        const expectedLoanToken = comparableHex(MarketParams.from(first.market).loanToken);
+        const expectedLoanToken = MarketParams.from(first.market).loanToken;
+        const expectedChainId = MarketParams.from(first.market).chainId;
+        const expectedMidnight = MarketParams.from(first.market).midnight;
         const expectedMaxUnits = first.maxUnits;
         const expectedMaxAssets = first.maxAssets;
         for (const offer of offers) {
-            if (comparableHex(offer.maker) !== expectedMaker) {
+            if (!isAddressEqual(offer.maker, expectedMaker)) {
                 throw new InvalidOfferGroupError("All offers in a group must use the same maker.");
             }
             if (offer.buy !== expectedBuy) {
@@ -598,17 +599,21 @@ export var OfferUtils;
                 (offer.maxAssets === 0n) === (offer.maxUnits === 0n)) {
                 throw new InvalidOfferGroupError("Every offer must set exactly one non-zero uint128 cap.");
             }
-            if (comparableHex(MarketParams.from(offer.market).loanToken) !==
-                expectedLoanToken) {
+            if (!isAddressEqual(MarketParams.from(offer.market).loanToken, expectedLoanToken)) {
                 throw new InvalidOfferGroupError("All offers in a group must use the same loan token.");
             }
+            if (MarketParams.from(offer.market).chainId !== expectedChainId) {
+                throw new InvalidOfferGroupError("All offers in a group must use the same chain id.");
+            }
+            if (!isAddressEqual(MarketParams.from(offer.market).midnight, expectedMidnight)) {
+                throw new InvalidOfferGroupError("All offers in a group must use the same Midnight contract.");
+            }
             if (offer.maxUnits !== expectedMaxUnits ||
                 offer.maxAssets !== expectedMaxAssets) {
                 throw new InvalidOfferGroupError("All offers in a group must use the same cap mode and value.");
             }
             if (offer.buy &&
-                comparableHex(offer.receiverIfMakerIsSeller) !==
-                    comparableHex(zeroAddress)) {
+                !isAddressEqual(offer.receiverIfMakerIsSeller, zeroAddress)) {
                 throw new InvalidOfferGroupError("Buy offers must use the zero address as receiverIfMakerIsSeller.");
             }
         }
@@ -834,10 +839,16 @@ export var OfferUtils;
     function getConsumableUnits(params) {
         const offer = params.offer;
         const consumed = BigInt(params.consumed);
+        const timestamp = BigInt(params.timestamp);
+        const start = BigInt(offer.start);
+        const expiry = BigInt(offer.expiry);
         const maxUnits = BigInt(offer.maxUnits);
         const maxAssets = BigInt(offer.maxAssets);
         const continuousFeeCap = BigInt(offer.continuousFeeCap);
         assertNonNegative("consumed", consumed);
+        assertNonNegative("timestamp", timestamp);
+        assertNonNegative("offer.start", start);
+        assertNonNegative("offer.expiry", expiry);
         assertNonNegative("offer.maxUnits", maxUnits);
         assertNonNegative("offer.maxAssets", maxAssets);
         assertNonNegative("offer.continuousFeeCap", continuousFeeCap);
@@ -850,12 +861,14 @@ export var OfferUtils;
             });
         }
         const market = Market.from(offer.market);
+        if (timestamp < start || timestamp > expiry)
+            return 0n;
         if (continuousFeeCap < BigInt(market.continuousFee))
             return 0n;
         if (maxUnits > 0n)
             return MathLib.zeroFloorSub(maxUnits, consumed);
         const remainingAssets = MathLib.zeroFloorSub(maxAssets, consumed);
-        const settlementFee = market.getSettlementFee(market.timeToMaturity(params.timestamp));
+        const settlementFee = market.getSettlementFee(market.timeToMaturity(timestamp));
         if (!offer.buy) {
             const { sellerPrice } = TakeAmountsLib.prices({
                 offer,

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

@@ -1,5 +1,6 @@
 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";
 declare const typedDataTypes: {
@@ -365,6 +366,40 @@ export interface EcrecoverRatifierDataParams {
     /** Ecrecover signature for the tree root. */
     readonly signature: EcrecoverSignatureInput;
 }
+/** Parameters for reconstructing an EcrecoverRatifier digest from decoded ratifier data fields. */
+export interface EcrecoverRatifierRootDigestParams {
+    /** Observed EIP-155 chain id from the log or execution context. Must match `offer.market.chainId`. */
+    readonly chainId: BigIntish;
+    /** Offer whose ratifier address and market chain id define the EIP-712 domain. */
+    readonly offer: IOffer;
+    /** Merkle root embedded in the ratifier data. */
+    readonly root: Hash;
+    /** Number of sibling hashes in the Merkle proof. */
+    readonly proofLength: number;
+}
+/** Parameters for reconstructing an EcrecoverRatifier digest from encoded ratifier data. */
+export interface EcrecoverRatifierDataDigestParams {
+    /** Observed EIP-155 chain id from the log or execution context. Must match `offer.market.chainId`. */
+    readonly chainId: BigIntish;
+    /** Offer carried by the payload item. */
+    readonly offer: IOffer;
+    /** ABI-encoded Ecrecover ratifier data carried by the payload item. */
+    readonly ratifierData: Hex;
+}
+/** Parameters for locally verifying Ecrecover ratifier data attached to one payload item. */
+export interface EcrecoverRatifierDataVerificationParams {
+    /** Observed EIP-155 chain id from the log or execution context. Must match `offer.market.chainId`. */
+    readonly chainId: BigIntish;
+    /** Offer carried by the payload item. */
+    readonly offer: IOffer;
+    /** ABI-encoded Ecrecover ratifier data carried by the payload item. */
+    readonly ratifierData: Hex;
+}
+/** Decoded Ecrecover ratifier data after local proof verification and signature recovery. */
+export interface VerifiedEcrecoverRatifierData extends DecodedEcrecoverRatifierData {
+    /** Signer recovered from the Ecrecover typed-data digest. */
+    readonly signer: Address;
+}
 /**
  * EcrecoverRatifier-specific pure utilities.
  *
@@ -501,6 +536,89 @@ export declare namespace EcrecoverRatifierUtils {
      * ```
      */
     function digest(params: EcrecoverRatifierTypedDataParams): `0x${string}`;
+    /**
+     * Builds the EcrecoverRatifier digest from a payload offer, root, and proof height.
+     *
+     * Use this on the take-side or in indexers after decoding ratifier data, when
+     * the original full tree is not available but the payload item includes the
+     * offer and proof metadata needed to reconstruct the signed digest. Pass the
+     * observed log or execution chain id so cross-chain-spoofed payloads are
+     * rejected before signature recovery.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.root - Merkle root embedded in the ratifier data.
+     * @param params.proofLength - Number of sibling hashes in the Merkle proof.
+     * @returns EIP-712 digest signed by the maker or authorized signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidTreeHeightError} when `proofLength` exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroHash } from "viem";
+     *
+     * const digest = EcrecoverRatifierUtils.digestForRoot({
+     *   chainId: 8453n,
+     *   offer,
+     *   root: zeroHash,
+     *   proofLength: 0,
+     * });
+     * console.log(digest);
+     * ```
+     */
+    function digestForRoot(params: EcrecoverRatifierRootDigestParams): Hash;
+    /**
+     * Builds the EcrecoverRatifier digest from one payload item's encoded ratifier data.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Ecrecover ratifier data.
+     * @returns EIP-712 digest signed by the maker or authorized signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidTreeHeightError} when the proof height exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const digest = EcrecoverRatifierUtils.digestRatifierData({
+     *   chainId: 8453n,
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(digest);
+     * ```
+     */
+    function digestRatifierData(params: EcrecoverRatifierDataDigestParams): Hash;
+    /**
+     * 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
+     * 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.
+     *
+     * @param params.chainId - Observed EIP-155 chain id from the log or execution context.
+     * @param params.offer - Offer carried by the payload item.
+     * @param params.ratifierData - ABI-encoded Ecrecover ratifier data.
+     * @returns Decoded ratifier data plus recovered signer.
+     * @throws {ChainIdMismatchError} when `params.chainId` does not match `offer.market.chainId`.
+     * @throws {InvalidEcrecoverSignatureVError} when the decoded signature `v` is not 27 or 28.
+     * @throws {InvalidTreeError} when the proof does not include `offer` in `root`.
+     * @throws {InvalidTreeHeightError} when the proof height exceeds 20.
+     * @example
+     * ```ts
+     * import { EcrecoverRatifierUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const verified = await EcrecoverRatifierUtils.verifyRatifierData({
+     *   chainId: 8453n,
+     *   offer,
+     *   ratifierData,
+     * });
+     * console.log(verified.signer);
+     * ```
+     */
+    function verifyRatifierData(params: EcrecoverRatifierDataVerificationParams): Promise<VerifiedEcrecoverRatifierData>;
     /**
      * Signs EcrecoverRatifier typed data through a viem client.
      *