@morpho-org/midnight-sdk 0.1.0

package/lib/cjs/offers/OfferUtils.js

@@ -0,0 +1,659 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfferUtils = void 0;
+const viem_1 = require("viem");
+const constants_js_1 = require("../constants.js");
+const errors_js_1 = require("../errors.js");
+const index_js_1 = require("../market/index.js");
+const Offer_js_1 = require("./Offer.js");
+const comparableHex = (value) => value.toLowerCase();
+const offerHashParams = [
+    { name: "typehash", type: "bytes32" },
+    { name: "marketHash", type: "bytes32" },
+    { name: "buy", type: "bool" },
+    { name: "maker", type: "address" },
+    { name: "start", type: "uint256" },
+    { name: "expiry", type: "uint256" },
+    { name: "tick", type: "uint256" },
+    { name: "group", type: "bytes32" },
+    { name: "callback", type: "address" },
+    { name: "callbackDataHash", type: "bytes32" },
+    { name: "receiverIfMakerIsSeller", type: "address" },
+    { name: "ratifier", type: "address" },
+    { name: "reduceOnly", type: "bool" },
+    { name: "maxUnits", type: "uint256" },
+    { name: "maxAssets", type: "uint256" },
+    { name: "continuousFeeCap", type: "uint256" },
+];
+/**
+ * Object-compatible helpers for Midnight offer construction, grouping, and
+ * take-side encoding.
+ *
+ * Make-side apps usually call {@link Offer.create}, then `Group.create` or
+ * `Tree.create`. Use these helpers when you need the same validation or ABI
+ * conversion without depending on class instances, or when converting API data
+ * into the structs consumed by payload and take encoders.
+ *
+ * @example
+ * ```ts
+ * import { OfferUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof OfferUtils.getOfferExpiry);
+ * ```
+ */
+var OfferUtils;
+(function (OfferUtils) {
+    /**
+     * Converts an offer into the tuple object expected by viem ABI encoders.
+     *
+     * This is the bridge from SDK/domain objects
+     * into Merkle leaf hashing, payload items, and take calldata encoding.
+     *
+     * @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.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const struct = OfferUtils.toStruct({ offer });
+     * console.log(struct.tick);
+     * ```
+     */
+    function toStruct(params) {
+        const offer = Offer_js_1.Offer.from(params.offer);
+        return {
+            market: index_js_1.MarketUtils.toStruct(offer.market),
+            buy: offer.buy,
+            maker: offer.maker,
+            start: offer.start,
+            expiry: offer.expiry,
+            tick: offer.tick,
+            group: params.group ?? offer.group,
+            callback: offer.callback,
+            callbackData: offer.callbackData,
+            receiverIfMakerIsSeller: offer.receiverIfMakerIsSeller,
+            ratifier: offer.ratifier,
+            reduceOnly: offer.reduceOnly,
+            maxUnits: offer.maxUnits,
+            maxAssets: offer.maxAssets,
+            continuousFeeCap: offer.continuousFeeCap,
+        };
+    }
+    OfferUtils.toStruct = toStruct;
+    /**
+     * Computes the canonical protocol offer hash for an ABI-compatible offer.
+     *
+     * Use when you already have an `OfferStruct`, for example from
+     * `GroupUtils.toStructs`, `TreeUtils.buildDescriptor`, or decoded payload
+     * bytes. Use `hash` when you still have a grouped `Offer` or grouped plain
+     * offer input, and `groupHash` when deriving a group id from the zero-group
+     * hash.
+     *
+     * @param offerStruct - ABI-compatible offer to hash.
+     * @returns Offer hash.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress, zeroHash } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const hash = OfferUtils.hashStruct(
+     *   OfferUtils.toStruct({ offer, group: zeroHash }),
+     * );
+     * console.log(hash);
+     * ```
+     */
+    function hashStruct(offerStruct) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)(offerHashParams, [
+            constants_js_1.OFFER_TYPEHASH,
+            index_js_1.MarketUtils.hash(offerStruct.market),
+            offerStruct.buy,
+            offerStruct.maker,
+            offerStruct.start,
+            offerStruct.expiry,
+            offerStruct.tick,
+            offerStruct.group,
+            offerStruct.callback,
+            (0, viem_1.keccak256)(offerStruct.callbackData),
+            offerStruct.receiverIfMakerIsSeller,
+            offerStruct.ratifier,
+            offerStruct.reduceOnly,
+            offerStruct.maxUnits,
+            offerStruct.maxAssets,
+            offerStruct.continuousFeeCap,
+        ]));
+    }
+    OfferUtils.hashStruct = hashStruct;
+    /**
+     * Computes the canonical protocol offer hash from the offer's group id.
+     *
+     * Use this for final tree leaves and payload offers after a group has been
+     * assigned. Use `groupHash` for the zero-group hash that derives a group id.
+     *
+     * @param offer - Offer with the protocol group id encoded into the hash.
+     * @returns Offer hash.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress, zeroHash } 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,
+     *   group: zeroHash,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const hash = OfferUtils.hash(offer);
+     * console.log(hash);
+     * ```
+     */
+    function hash(offer) {
+        return hashStruct(toStruct({ offer }));
+    }
+    OfferUtils.hash = hash;
+    /**
+     * Computes the offer hash used to derive a content-addressed group id.
+     *
+     * The encoded group is always the protocol zero hash. Use this only for
+     * standalone or grouped-offer id derivation, not for final tree leaves or
+     * payload offers.
+     *
+     * @param offer - Offer to hash without a group id.
+     * @returns Offer hash encoded with the protocol zero group id.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const hash = OfferUtils.groupHash(offer);
+     * console.log(hash);
+     * ```
+     */
+    function groupHash(offer) {
+        return hashStruct(toStruct({ offer, group: viem_1.zeroHash }));
+    }
+    OfferUtils.groupHash = groupHash;
+    /**
+     * Validates and normalizes a Midnight offer tick and spacing.
+     *
+     * Use this for form-level validation before `Offer.create` when you want to
+     * surface a tick-specific issue. `Offer.create` calls it internally.
+     *
+     * @param params.tick - Offer tick to validate.
+     * @param params.tickSpacing - Optional market tick spacing; defaults to `DEFAULT_TICK_SPACING`.
+     * @returns Normalized tick and tick spacing.
+     * @throws {InvalidOfferParameterError} when the tick or spacing cannot be accepted by Midnight.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const { tick } = OfferUtils.validateOfferTick({ tick: 4n });
+     * console.log(tick);
+     * ```
+     */
+    function validateOfferTick(params) {
+        const tick = BigInt(params.tick);
+        const tickSpacing = BigInt(params.tickSpacing ?? constants_js_1.DEFAULT_TICK_SPACING);
+        if (tick < 0n || tick > constants_js_1.MAX_TICK) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "tick",
+                value: tick,
+                instruction: `Use a tick between "0" and "${constants_js_1.MAX_TICK}".`,
+            });
+        }
+        if (tickSpacing <= 0n || constants_js_1.DEFAULT_TICK_SPACING % tickSpacing !== 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "tickSpacing",
+                value: tickSpacing,
+                instruction: `Use a positive tick spacing that divides "${constants_js_1.DEFAULT_TICK_SPACING}".`,
+            });
+        }
+        if (tick % tickSpacing !== 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "tick",
+                value: tick,
+                instruction: `Use a tick aligned to spacing "${tickSpacing}".`,
+            });
+        }
+        return { tick, tickSpacing };
+    }
+    OfferUtils.validateOfferTick = validateOfferTick;
+    /**
+     * Validates and normalizes an offer start/expiry range.
+     *
+     * Use this before `Offer.create` when a UI edits dates separately from other
+     * offer fields. `Offer.create` calls it internally.
+     *
+     * @param params.start - Optional offer start timestamp; defaults to zero.
+     * @param params.expiry - Offer expiry timestamp.
+     * @returns Normalized start and expiry timestamps.
+     * @throws {InvalidOfferParameterError} when the range is negative or not strictly increasing.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const range = OfferUtils.validateOfferTimeRange({ start: 0n, expiry: 1n });
+     * console.log(range.expiry);
+     * ```
+     */
+    function validateOfferTimeRange(params) {
+        const start = BigInt(params.start ?? 0n);
+        const expiry = BigInt(params.expiry);
+        if (start < 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "start",
+                value: start,
+                instruction: "Use a non-negative timestamp.",
+            });
+        }
+        if (expiry < 0n || expiry <= start) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "expiry",
+                value: expiry,
+                instruction: `Use an expiry greater than start "${start}".`,
+            });
+        }
+        return { start, expiry };
+    }
+    OfferUtils.validateOfferTimeRange = validateOfferTimeRange;
+    /**
+     * Validates and normalizes mutually exclusive offer caps.
+     *
+     * Use this before `Offer.create` when a UI lets makers choose between a unit
+     * cap and an asset cap. `Offer.create` calls it internally.
+     *
+     * @param params.maxUnits - Optional unit cap; defaults to zero.
+     * @param params.maxAssets - Optional buyer or seller asset cap; defaults to zero.
+     * @returns Normalized unit and asset caps.
+     * @throws {InvalidOfferParameterError} when caps are negative, both zero, or both non-zero.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const caps = OfferUtils.validateOfferCaps({ maxAssets: 100n });
+     * console.log(caps.maxAssets);
+     * ```
+     */
+    function validateOfferCaps(params) {
+        const maxUnits = BigInt(params.maxUnits ?? 0n);
+        const maxAssets = BigInt(params.maxAssets ?? 0n);
+        if (maxUnits < 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "maxUnits",
+                value: maxUnits,
+                instruction: "Use a non-negative cap.",
+            });
+        }
+        if (maxAssets < 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "maxAssets",
+                value: maxAssets,
+                instruction: "Use a non-negative cap.",
+            });
+        }
+        if ((maxAssets === 0n) === (maxUnits === 0n)) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "maxUnits/maxAssets",
+                value: `maxUnits=${maxUnits}, maxAssets=${maxAssets}`,
+                instruction: "Set exactly one offer cap to a non-zero value.",
+            });
+        }
+        return { maxUnits, maxAssets };
+    }
+    OfferUtils.validateOfferCaps = validateOfferCaps;
+    /**
+     * 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}.
+     *
+     * @param params.continuousFeeCap - Optional maximum market continuous fee accepted by this offer.
+     * @returns Normalized continuous fee cap.
+     * @throws {InvalidOfferParameterError} when the cap is negative.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const cap = OfferUtils.validateContinuousFeeCap({});
+     * console.log(cap.continuousFeeCap);
+     * ```
+     */
+    function validateContinuousFeeCap(params) {
+        const continuousFeeCap = BigInt(params.continuousFeeCap ?? constants_js_1.MAX_CONTINUOUS_FEE);
+        if (continuousFeeCap < 0n) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "continuousFeeCap",
+                value: continuousFeeCap,
+                instruction: "Use a non-negative continuous fee cap.",
+            });
+        }
+        return { continuousFeeCap };
+    }
+    OfferUtils.validateContinuousFeeCap = validateContinuousFeeCap;
+    /**
+     * Resolves and validates the maker-seller receiver field for an offer side.
+     *
+     * Use this before `Offer.create` when side-specific receiver defaults must be
+     * displayed to a maker. `Offer.create` calls it internally.
+     *
+     * @param params.buy - Whether the maker buys loan assets.
+     * @param params.maker - Maker address used as the default sell-side receiver.
+     * @param params.receiverIfMakerIsSeller - Optional receiver used when maker is seller.
+     * @returns Receiver address to put on the offer.
+     * @throws {InvalidOfferParameterError} when a buy offer sets a non-zero maker-seller receiver.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const receiver = OfferUtils.resolveReceiverIfMakerIsSeller({
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000000001",
+     * });
+     * console.log(receiver);
+     * ```
+     */
+    function resolveReceiverIfMakerIsSeller(params) {
+        const maker = params.maker;
+        const receiverIfMakerIsSeller = params.receiverIfMakerIsSeller ?? (params.buy ? viem_1.zeroAddress : maker);
+        if (params.buy && receiverIfMakerIsSeller !== viem_1.zeroAddress) {
+            throw new errors_js_1.InvalidOfferParameterError({
+                parameter: "receiverIfMakerIsSeller",
+                value: receiverIfMakerIsSeller,
+                instruction: "Use the zero address for buy offers.",
+            });
+        }
+        return receiverIfMakerIsSeller;
+    }
+    OfferUtils.resolveReceiverIfMakerIsSeller = resolveReceiverIfMakerIsSeller;
+    /**
+     * Validates deterministic make-offer parameters without constructing an offer.
+     *
+     * Use when an app needs normalized maker input or field-level errors before
+     * instantiating an `Offer`. `Offer.create` uses the same validation and then
+     * constructs the class instance for grouping and trees.
+     *
+     * @param params.market - Market params or hydrated market this offer trades.
+     * @param params.buy - Whether the maker buys loan assets.
+     * @param params.maker - Maker address.
+     * @param params.tick - Offer tick.
+     * @param params.group - Optional consumption group id for already-grouped offers.
+     * @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.start - Optional offer start timestamp; defaults to zero.
+     * @param params.expiry - Offer expiry timestamp.
+     * @param params.callback - Optional callback address; defaults to the zero address.
+     * @param params.callbackData - Optional callback payload; defaults to `0x`.
+     * @param params.receiverIfMakerIsSeller - Optional receiver used when maker is seller.
+     * @param params.ratifier - Ratifier contract address.
+     * @param params.reduceOnly - Optional flag restricting the offer to exposure-reducing execution.
+     * @returns Normalized deterministic offer parameters.
+     * @throws {InvalidOfferParameterError} when a deterministic offer parameter cannot satisfy protocol rules.
+     * @example
+     * ```ts
+     * import { OfferUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const params = OfferUtils.validateOfferParams({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: "0x0000000000000000000000000000000000000000",
+     *     liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * console.log(params.maxAssets);
+     * ```
+     */
+    function validateOfferParams(params) {
+        const { tick, tickSpacing } = validateOfferTick(params);
+        const { start, expiry } = validateOfferTimeRange(params);
+        const { maxUnits, maxAssets } = validateOfferCaps(params);
+        const { continuousFeeCap } = validateContinuousFeeCap(params);
+        const receiverIfMakerIsSeller = resolveReceiverIfMakerIsSeller(params);
+        return {
+            tick,
+            tickSpacing,
+            start,
+            expiry,
+            maxUnits,
+            maxAssets,
+            continuousFeeCap,
+            receiverIfMakerIsSeller,
+        };
+    }
+    OfferUtils.validateOfferParams = validateOfferParams;
+    /**
+     * Validates protocol-level mechanics for one Midnight offer consumption group.
+     *
+     * Use before deriving a content-addressed group id. Grouped offers must share
+     * maker, side, loan token, cap mode, and cap value because Midnight tracks one
+     * consumed scalar per maker and group. `Group.create` calls this automatically;
+     * call it directly only when you need the normalized offers without
+     * constructing a `Group`.
+     *
+     * @param params.offers - Offers to validate as one protocol consumption group.
+     * @returns Normalized offers in the same order as the input entries.
+     * @throws {InvalidOfferGroupError} when the group violates protocol mechanics.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offers = OfferUtils.validateOfferGroup({ offers: [offer] });
+     * console.log(offers.length);
+     * ```
+     */
+    function validateOfferGroup(params) {
+        const offerInputs = Array.from(params.offers);
+        if (offerInputs.length === 0) {
+            throw new errors_js_1.InvalidOfferGroupError("Provide at least one offer in the group.");
+        }
+        const offers = offerInputs.map((offer) => Offer_js_1.Offer.from(offer));
+        const first = offers[0];
+        const expectedMaker = comparableHex(first.maker);
+        const expectedBuy = first.buy;
+        const expectedLoanToken = comparableHex(first.market.loanToken);
+        const expectedMaxUnits = first.maxUnits;
+        const expectedMaxAssets = first.maxAssets;
+        for (const offer of offers) {
+            if (comparableHex(offer.maker) !== expectedMaker) {
+                throw new errors_js_1.InvalidOfferGroupError("All offers in a group must use the same maker.");
+            }
+            if (offer.buy !== expectedBuy) {
+                throw new errors_js_1.InvalidOfferGroupError("All offers in a group must use the same maker side.");
+            }
+            if (offer.maxUnits < 0n ||
+                offer.maxAssets < 0n ||
+                (offer.maxAssets === 0n) === (offer.maxUnits === 0n)) {
+                throw new errors_js_1.InvalidOfferGroupError("Every offer must set exactly one non-zero non-negative cap.");
+            }
+            if (comparableHex(offer.market.loanToken) !== expectedLoanToken) {
+                throw new errors_js_1.InvalidOfferGroupError("All offers in a group must use the same loan token.");
+            }
+            if (offer.maxUnits !== expectedMaxUnits ||
+                offer.maxAssets !== expectedMaxAssets) {
+                throw new errors_js_1.InvalidOfferGroupError("All offers in a group must use the same cap mode and value.");
+            }
+            if (offer.buy &&
+                comparableHex(offer.receiverIfMakerIsSeller) !==
+                    comparableHex(viem_1.zeroAddress)) {
+                throw new errors_js_1.InvalidOfferGroupError("Buy offers must use the zero address as receiverIfMakerIsSeller.");
+            }
+        }
+        return [...offers];
+    }
+    OfferUtils.validateOfferGroup = validateOfferGroup;
+    /**
+     * Returns an offer expiry timestamp.
+     *
+     * Use in maker UIs, API response mappers, or quote filters when accepting
+     * any plain object matching `IOffer` or an `Offer` instance. This does not validate
+     * whether the offer is still live at the current block time.
+     *
+     * @param offer - Offer to inspect.
+     * @returns Offer expiry.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } 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: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const expiry = OfferUtils.getOfferExpiry(offer);
+     * console.log(expiry);
+     * ```
+     */
+    function getOfferExpiry(offer) {
+        return BigInt(offer.expiry);
+    }
+    OfferUtils.getOfferExpiry = getOfferExpiry;
+})(OfferUtils || (exports.OfferUtils = OfferUtils = {}));

package/lib/cjs/offers/index.d.ts

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

package/lib/cjs/offers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Offer.js"), exports);
+__exportStar(require("./OfferUtils.js"), exports);

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}