@morpho-org/midnight-sdk 1.0.0 → 1.2.0

package/lib/esm/offers/OfferChainUtils.js

@@ -0,0 +1,443 @@
+import { MathLib, Time } from "@morpho-org/morpho-ts";
+import { formatUnits, parseUnits } from "viem";
+import { DEFAULT_TICK_SPACING, MAX_TICK } from "../constants.js";
+import { InvalidOfferParameterError } from "../errors.js";
+import { TickLib } from "../math/index.js";
+const FAVORABLE_RATE_DRIFT = 0.1;
+const MAX_EXPIRY_TTM_NUMERATOR = 75n;
+const MAX_EXPIRY_TTM_DENOMINATOR = 100n;
+const MAX_CHAIN_LEGS = Number(MAX_TICK) + 1;
+const SECONDS_PER_YEAR = Number(Time.s.from.y(1n));
+/**
+ * Utilities for building time-bounded Midnight offer chains.
+ *
+ * A Midnight offer has one fixed price, so its displayed yearly rate changes
+ * as maturity approaches. The markets app uses these helpers when a maker wants
+ * to post, for example, a 5% order for several months: the app builds several
+ * adjacent offers sharing the same reserve, each with a different tick and time
+ * window, so the order reviews and renders as a stable 5% order across the
+ * selected window instead of drifting upward as time passes.
+ *
+ * @example
+ * ```ts
+ * import { OfferChainUtils } from "@morpho-org/midnight-sdk";
+ *
+ * const legs = OfferChainUtils.buildLendFixedRateOfferChain({
+ *   targetRate: 0.05,
+ *   tickSpacing: 4n,
+ *   maturityTimestamp: 1_798_761_600n,
+ *   chainStartTimestamp: 1_767_225_600n,
+ *   chainEndTimestamp: 1_791_153_600n,
+ * });
+ * console.log(legs[0]?.tick);
+ * ```
+ */
+export var OfferChainUtils;
+(function (OfferChainUtils) {
+    /**
+     * Maximum fraction of the initial time-to-maturity covered by a fixed-rate offer chain.
+     *
+     * Use this cap before displaying an expiry picker for a fixed-rate maker
+     * order. The last part of the maturity window is intentionally excluded
+     * because tiny time changes cause large displayed-rate drift.
+     *
+     * @example
+     * ```ts
+     * import { OfferChainUtils } from "@morpho-org/midnight-sdk";
+     *
+     * console.log(OfferChainUtils.MAX_EXPIRY_TTM_FRACTION);
+     * ```
+     */
+    OfferChainUtils.MAX_EXPIRY_TTM_FRACTION = 0.75;
+    /**
+     * Builds borrow-side sell-offer legs that approximate one fixed maker rate over time.
+     *
+     * Use before a make-borrow or supply-collateral-and-make-borrow flow when a
+     * borrower wants one displayed fixed borrow rate across a longer window. Map
+     * the returned legs to `Offer.create({ buy: false, ... })`, then group and
+     * submit them through the maker flow.
+     *
+     * Borrow chains read their target rate at each leg's expiry edge. If a leg
+     * would need to extend past `chainEndTimestamp`, it is dropped rather than
+     * clamped so the expiry edge remains the recoverable target-rate edge.
+     *
+     * @param params - Fixed-rate offer-chain parameters without a side field.
+     * @param params.targetRate - Target yearly fixed rate expressed as a decimal number.
+     * @param params.tickSpacing - Tick spacing enforced by the market.
+     * @param params.maturityTimestamp - Market maturity timestamp in seconds.
+     * @param params.chainStartTimestamp - First timestamp the chain should cover.
+     * @param params.chainEndTimestamp - Latest timestamp the chain may cover.
+     * @returns Borrow-side offer legs that can be mapped to `Offer.create({ buy: false, ... })`.
+     * @throws {InvalidOfferParameterError} when an input is invalid or the end timestamp exceeds the supported horizon.
+     * @example
+     * ```ts
+     * import { Offer, OfferChainUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const legs = OfferChainUtils.buildBorrowFixedRateOfferChain({
+     *   targetRate: 0.08,
+     *   tickSpacing: market.tickSpacing,
+     *   maturityTimestamp: market.params.maturity,
+     *   chainStartTimestamp: now,
+     *   chainEndTimestamp: expiry,
+     * });
+     * const offers = legs.map((leg) =>
+     *   Offer.create({
+     *     ...baseOffer,
+     *     buy: false,
+     *     tick: leg.tick,
+     *     start: leg.startTimestamp,
+     *     expiry: leg.expiryTimestamp,
+     *   }),
+     * );
+     * ```
+     */
+    function buildBorrowFixedRateOfferChain(params) {
+        if (!Number.isFinite(params.targetRate)) {
+            throw new InvalidOfferParameterError({
+                parameter: "targetRate",
+                value: params.targetRate,
+                instruction: "Use a finite positive yearly rate.",
+            });
+        }
+        if (params.targetRate <= 0) {
+            throw new InvalidOfferParameterError({
+                parameter: "targetRate",
+                value: params.targetRate,
+                instruction: "Use a positive yearly rate.",
+            });
+        }
+        const tickSpacing = normalizeSafeInteger("tickSpacing", params.tickSpacing);
+        if (tickSpacing <= 0n || DEFAULT_TICK_SPACING % tickSpacing !== 0n) {
+            throw new InvalidOfferParameterError({
+                parameter: "tickSpacing",
+                value: tickSpacing,
+                instruction: `Use a positive tick spacing that divides "${DEFAULT_TICK_SPACING}".`,
+            });
+        }
+        const maturityTimestamp = normalizeTimestamp("maturityTimestamp", params.maturityTimestamp);
+        const chainStartTimestamp = normalizeTimestamp("chainStartTimestamp", params.chainStartTimestamp);
+        const chainEndTimestamp = normalizeTimestamp("chainEndTimestamp", params.chainEndTimestamp);
+        if (maturityTimestamp <= chainStartTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "maturityTimestamp",
+                value: maturityTimestamp,
+                instruction: "Use a timestamp greater than chainStartTimestamp.",
+            });
+        }
+        if (chainEndTimestamp <= chainStartTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "chainEndTimestamp",
+                value: chainEndTimestamp,
+                instruction: "Use a timestamp greater than chainStartTimestamp.",
+            });
+        }
+        const maxChainEndTimestamp = getMaxFixedRateOfferChainEndTimestamp({
+            maturityTimestamp,
+            chainStartTimestamp,
+        });
+        if (chainEndTimestamp > maxChainEndTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "chainEndTimestamp",
+                value: chainEndTimestamp,
+                instruction: `Use a timestamp no greater than "${maxChainEndTimestamp}".`,
+            });
+        }
+        const tauInitial = Number(maturityTimestamp - chainStartTimestamp) / SECONDS_PER_YEAR;
+        const tauStop = Number(maturityTimestamp - chainEndTimestamp) / SECONDS_PER_YEAR;
+        const lowerRate = params.targetRate * (1 - FAVORABLE_RATE_DRIFT);
+        /* v8 ignore next: positive finite targetRate validation keeps lowerRate positive for practical JS numbers. */
+        if (lowerRate <= 0)
+            return [];
+        const legs = [];
+        let tauTop = tauInitial;
+        let iteration = 0;
+        for (; iteration < MAX_CHAIN_LEGS; iteration++) {
+            const price = 1 / (1 + lowerRate * tauTop);
+            let priceInput;
+            if (!Number.isFinite(price) || price <= 0) {
+                priceInput = 0n;
+            }
+            else if (price >= 1) {
+                priceInput = MathLib.WAD;
+            }
+            else {
+                priceInput = parseUnits(price.toFixed(18), 18);
+            }
+            const rawTick = TickLib.priceToTick(priceInput, 1n) - 1n;
+            if (rawTick < 0n || rawTick > MAX_TICK)
+                break;
+            const tick = floorTickToSpacing(rawTick, tickSpacing);
+            if (legs.at(-1)?.tick === tick)
+                break;
+            const tauMax = rateTau(tick, lowerRate);
+            const tauMin = rateTau(tick, params.targetRate);
+            if (tauMin >= tauTop)
+                break;
+            if (tauMin < tauStop)
+                break;
+            const startTimestamp = maturityTimestamp -
+                BigInt(Math.round(Math.min(tauMax, tauTop) * SECONDS_PER_YEAR));
+            const expiryTimestamp = maturityTimestamp - BigInt(Math.round(tauMin * SECONDS_PER_YEAR));
+            /* v8 ignore next: tests cover positive legs; zero-width legs are skipped only on rounding ties. */
+            if (expiryTimestamp > startTimestamp) {
+                legs.push({ tick, startTimestamp, expiryTimestamp });
+            }
+            tauTop = tauMin;
+        }
+        /* v8 ignore next: the monotonic tick walk exits before exhausting the finite tick range. */
+        if (iteration >= MAX_CHAIN_LEGS) {
+            throw new InvalidOfferParameterError({
+                parameter: "tickSpacing",
+                value: tickSpacing,
+                instruction: `Borrow chain exceeded "${MAX_CHAIN_LEGS}" legs.`,
+            });
+        }
+        return legs;
+    }
+    OfferChainUtils.buildBorrowFixedRateOfferChain = buildBorrowFixedRateOfferChain;
+    /**
+     * Builds lend-side buy-offer legs that approximate one fixed maker rate over time.
+     *
+     * Use before a make-lend flow when a lender wants one displayed fixed lend
+     * rate across a longer window. Map the returned legs to
+     * `Offer.create({ buy: true, ... })`, then group and submit them through the
+     * maker flow.
+     *
+     * Lend chains read their target rate at each leg's start edge. The first leg
+     * may start before `chainStartTimestamp`; clamping that edge would move the
+     * recoverable display rate below the maker's target.
+     *
+     * @param params - Fixed-rate offer-chain parameters without a side field.
+     * @param params.targetRate - Target yearly fixed rate expressed as a decimal number.
+     * @param params.tickSpacing - Tick spacing enforced by the market.
+     * @param params.maturityTimestamp - Market maturity timestamp in seconds.
+     * @param params.chainStartTimestamp - First timestamp the chain should cover.
+     * @param params.chainEndTimestamp - Latest timestamp the chain may cover.
+     * @returns Lend-side offer legs that can be mapped to `Offer.create({ buy: true, ... })`.
+     * @throws {InvalidOfferParameterError} when an input is invalid or the end timestamp exceeds the supported horizon.
+     * @example
+     * ```ts
+     * import { Offer, OfferChainUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const legs = OfferChainUtils.buildLendFixedRateOfferChain({
+     *   targetRate: 0.05,
+     *   tickSpacing: market.tickSpacing,
+     *   maturityTimestamp: market.params.maturity,
+     *   chainStartTimestamp: now,
+     *   chainEndTimestamp: expiry,
+     * });
+     * const offers = legs.map((leg) =>
+     *   Offer.create({
+     *     ...baseOffer,
+     *     buy: true,
+     *     tick: leg.tick,
+     *     start: leg.startTimestamp,
+     *     expiry: leg.expiryTimestamp,
+     *   }),
+     * );
+     * ```
+     */
+    function buildLendFixedRateOfferChain(params) {
+        if (!Number.isFinite(params.targetRate)) {
+            throw new InvalidOfferParameterError({
+                parameter: "targetRate",
+                value: params.targetRate,
+                instruction: "Use a finite positive yearly rate.",
+            });
+        }
+        if (params.targetRate <= 0) {
+            throw new InvalidOfferParameterError({
+                parameter: "targetRate",
+                value: params.targetRate,
+                instruction: "Use a positive yearly rate.",
+            });
+        }
+        const tickSpacing = normalizeSafeInteger("tickSpacing", params.tickSpacing);
+        if (tickSpacing <= 0n || DEFAULT_TICK_SPACING % tickSpacing !== 0n) {
+            throw new InvalidOfferParameterError({
+                parameter: "tickSpacing",
+                value: tickSpacing,
+                instruction: `Use a positive tick spacing that divides "${DEFAULT_TICK_SPACING}".`,
+            });
+        }
+        const maturityTimestamp = normalizeTimestamp("maturityTimestamp", params.maturityTimestamp);
+        const chainStartTimestamp = normalizeTimestamp("chainStartTimestamp", params.chainStartTimestamp);
+        const chainEndTimestamp = normalizeTimestamp("chainEndTimestamp", params.chainEndTimestamp);
+        if (maturityTimestamp <= chainStartTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "maturityTimestamp",
+                value: maturityTimestamp,
+                instruction: "Use a timestamp greater than chainStartTimestamp.",
+            });
+        }
+        if (chainEndTimestamp <= chainStartTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "chainEndTimestamp",
+                value: chainEndTimestamp,
+                instruction: "Use a timestamp greater than chainStartTimestamp.",
+            });
+        }
+        const maxChainEndTimestamp = getMaxFixedRateOfferChainEndTimestamp({
+            maturityTimestamp,
+            chainStartTimestamp,
+        });
+        if (chainEndTimestamp > maxChainEndTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "chainEndTimestamp",
+                value: chainEndTimestamp,
+                instruction: `Use a timestamp no greater than "${maxChainEndTimestamp}".`,
+            });
+        }
+        const tauInitial = Number(maturityTimestamp - chainStartTimestamp) / SECONDS_PER_YEAR;
+        const tauStop = Number(maturityTimestamp - chainEndTimestamp) / SECONDS_PER_YEAR;
+        const upperRate = params.targetRate * (1 + FAVORABLE_RATE_DRIFT);
+        const maxAlignedTick = floorTickToSpacing(MAX_TICK, tickSpacing);
+        const highestDiscountTick = floorTickToSpacing(TickLib.priceToTick(MathLib.WAD, 1n) - 1n, tickSpacing);
+        const ceilingTick = highestDiscountTick < maxAlignedTick
+            ? highestDiscountTick
+            : maxAlignedTick;
+        const tauCeiling = rateTau(ceilingTick, upperRate);
+        let tauBottom = Math.max(tauStop, tauCeiling);
+        if (tauBottom >= tauInitial)
+            return [];
+        const tauLegs = [];
+        let iteration = 0;
+        for (; iteration < MAX_CHAIN_LEGS; iteration++) {
+            const price = 1 / (1 + upperRate * tauBottom);
+            let priceInput;
+            if (!Number.isFinite(price) || price <= 0) {
+                priceInput = 0n;
+            }
+            else {
+                /* v8 ignore next: positive rates that survive the grid-floor check keep lend-chain prices below one. */
+                if (price >= 1) {
+                    priceInput = MathLib.WAD;
+                }
+                else {
+                    priceInput = parseUnits(price.toFixed(18), 18);
+                }
+            }
+            const rawTick = TickLib.priceToTick(priceInput, 1n);
+            /* v8 ignore next: priceToTick returns in-range ticks; maxAlignedTick only tightens non-dividing spacing. */
+            if (rawTick < 0n || rawTick > MAX_TICK || rawTick > maxAlignedTick)
+                break;
+            const alignedTick = ((rawTick + tickSpacing - 1n) / tickSpacing) * tickSpacing;
+            /* v8 ignore next: non-dividing spacing boundary clamp is defensive; normal alignment is covered. */
+            const tick = alignedTick < maxAlignedTick ? alignedTick : maxAlignedTick;
+            if (tauLegs.at(-1)?.tick === tick)
+                break;
+            const tauMax = rateTau(tick, params.targetRate);
+            const tauMin = rateTau(tick, upperRate);
+            if (tauMax <= tauBottom)
+                break;
+            tauLegs.push({ tick, tauMax, tauMin: Math.max(tauMin, tauBottom) });
+            if (tauMax >= tauInitial)
+                break;
+            tauBottom = tauMax;
+        }
+        /* v8 ignore next: the monotonic tick walk exits before exhausting the finite tick range. */
+        if (iteration >= MAX_CHAIN_LEGS) {
+            throw new InvalidOfferParameterError({
+                parameter: "tickSpacing",
+                value: tickSpacing,
+                instruction: `Lend chain exceeded "${MAX_CHAIN_LEGS}" legs.`,
+            });
+        }
+        const leftmostLeg = tauLegs.at(-1);
+        if (leftmostLeg && leftmostLeg.tauMax < tauInitial)
+            return [];
+        return tauLegs
+            .reverse()
+            .map((leg) => ({
+            tick: leg.tick,
+            startTimestamp: maturityTimestamp - BigInt(Math.round(leg.tauMax * SECONDS_PER_YEAR)),
+            expiryTimestamp: maturityTimestamp - BigInt(Math.round(leg.tauMin * SECONDS_PER_YEAR)),
+        }))
+            .filter((leg) => leg.expiryTimestamp > leg.startTimestamp);
+    }
+    OfferChainUtils.buildLendFixedRateOfferChain = buildLendFixedRateOfferChain;
+    /**
+     * Returns the latest supported end timestamp for a fixed-rate offer chain.
+     *
+     * Chains intentionally stop before the final part of the maturity window
+     * because rate sensitivity accelerates near maturity and would require too
+     * many short-lived offers for a stable maker quote.
+     * Call this when constraining a make-offer expiry selector, then pass the
+     * selected timestamp to the lend-only or borrow-only chain builder.
+     *
+     * @param params - Maturity and chain-start timestamps.
+     * @param params.maturityTimestamp - Market maturity timestamp in seconds.
+     * @param params.chainStartTimestamp - First timestamp the chain should cover.
+     * @returns Latest accepted chain end timestamp.
+     * @throws {InvalidOfferParameterError} when a timestamp is invalid.
+     * @example
+     * ```ts
+     * import { OfferChainUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const maxExpiry = OfferChainUtils.getMaxFixedRateOfferChainEndTimestamp({
+     *   maturityTimestamp: market.params.maturity,
+     *   chainStartTimestamp: now,
+     * });
+     * console.log(maxExpiry);
+     * ```
+     */
+    function getMaxFixedRateOfferChainEndTimestamp(params) {
+        const maturityTimestamp = normalizeTimestamp("maturityTimestamp", params.maturityTimestamp);
+        const chainStartTimestamp = normalizeTimestamp("chainStartTimestamp", params.chainStartTimestamp);
+        if (maturityTimestamp <= chainStartTimestamp) {
+            throw new InvalidOfferParameterError({
+                parameter: "maturityTimestamp",
+                value: maturityTimestamp,
+                instruction: "Use a maturity timestamp greater than chainStartTimestamp.",
+            });
+        }
+        return (chainStartTimestamp +
+            ((maturityTimestamp - chainStartTimestamp) * MAX_EXPIRY_TTM_NUMERATOR) /
+                MAX_EXPIRY_TTM_DENOMINATOR);
+    }
+    OfferChainUtils.getMaxFixedRateOfferChainEndTimestamp = getMaxFixedRateOfferChainEndTimestamp;
+})(OfferChainUtils || (OfferChainUtils = {}));
+function normalizeSafeInteger(parameter, value) {
+    let normalized;
+    try {
+        normalized = BigInt(value);
+    }
+    catch (cause) {
+        throw new InvalidOfferParameterError({
+            parameter,
+            value,
+            instruction: "Use a safe integer value.",
+            cause,
+        });
+    }
+    const numberValue = Number(normalized);
+    if (!Number.isSafeInteger(numberValue)) {
+        throw new InvalidOfferParameterError({
+            parameter,
+            value,
+            instruction: "Use a JavaScript-safe integer value.",
+        });
+    }
+    return normalized;
+}
+function normalizeTimestamp(parameter, value) {
+    const normalized = normalizeSafeInteger(parameter, value);
+    if (normalized < 0n) {
+        throw new InvalidOfferParameterError({
+            parameter,
+            value,
+            instruction: "Use a non-negative timestamp.",
+        });
+    }
+    return normalized;
+}
+function rateTau(tick, rate) {
+    const price = Number(formatUnits(TickLib.tickToPrice(tick), 18));
+    /* v8 ignore next: builders pass positive rates and discount ticks; this guards direct internal misuse. */
+    if (price <= 0 || price >= 1 || rate <= 0)
+        return 0;
+    return (1 / price - 1) / rate;
+}
+function floorTickToSpacing(tick, spacing) {
+    return tick - (tick % spacing);
+}

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/offers/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./Offer.js";
+export * from "./OfferChainUtils.js";
 export * from "./OfferUtils.js";

package/lib/esm/offers/index.js

@@ -1,2 +1,3 @@
 export * from "./Offer.js";
+export * from "./OfferChainUtils.js";
 export * from "./OfferUtils.js";