@morpho-org/midnight-sdk 2.0.0 → 2.1.0

package/lib/cjs/api/MidnightApi.d.ts

@@ -142,7 +142,7 @@ export declare class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -170,11 +170,12 @@ export declare class MidnightApi {
      * @param params.baseUrl - Optional Midnight API base URL override.
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -205,7 +206,7 @@ export declare class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -390,7 +391,7 @@ export declare class MidnightApi {
      * @param params.side - Book side to query.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -416,11 +417,12 @@ export declare class MidnightApi {
      * @param params.averageWorstPrice - Optional WAD-scaled average worst price guard. Mutually exclusive with `params.slippage`.
      * @param params.slippage - Optional slippage percentage used to derive the guard. Mutually exclusive with `params.averageWorstPrice`.
      * @param params.settlementFee - Optional current WAD-scaled settlement fee used for local guard validation. Defaults to zero.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -448,7 +450,7 @@ export declare class MidnightApi {
      * @param params.cursor - Optional opaque pagination cursor from a previous response.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";

package/lib/cjs/api/MidnightApi.js

@@ -207,7 +207,7 @@ class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -252,11 +252,12 @@ class MidnightApi {
      * @param params.baseUrl - Optional Midnight API base URL override.
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -301,8 +302,8 @@ class MidnightApi {
             : "slippage" in input && input.slippage != null
                 ? response.data.average_worst_price
                 : undefined;
-        if (averageWorstPrice != null) {
-            const guard = BigInt(averageWorstPrice);
+        const guard = averageWorstPrice == null ? undefined : BigInt(averageWorstPrice);
+        if (guard != null) {
             let filledUnits = 0n;
             let filledAssets = 0n;
             if ("units" in input && input.units != null) {
@@ -359,7 +360,7 @@ class MidnightApi {
         return {
             data: {
                 averageBestPrice: response.data.average_best_price,
-                averageWorstPrice: response.data.average_worst_price,
+                averageWorstPrice: guard?.toString() ?? response.data.average_worst_price,
                 availableAssets: response.data.available_assets,
                 availableUnits: response.data.available_units,
                 takeableOffers,
@@ -381,7 +382,7 @@ class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -629,7 +630,7 @@ class MidnightApi {
      * @param params.side - Book side to query.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -660,11 +661,12 @@ class MidnightApi {
      * @param params.averageWorstPrice - Optional WAD-scaled average worst price guard. Mutually exclusive with `params.slippage`.
      * @param params.slippage - Optional slippage percentage used to derive the guard. Mutually exclusive with `params.averageWorstPrice`.
      * @param params.settlementFee - Optional current WAD-scaled settlement fee used for local guard validation. Defaults to zero.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -697,7 +699,7 @@ class MidnightApi {
      * @param params.cursor - Optional opaque pagination cursor from a previous response.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";

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

@@ -30,7 +30,7 @@ export interface TakeableOfferContext {
     readonly marketIds?: readonly Hash[];
     readonly groups?: readonly Hash[];
 }
-/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+/** @internal Maps, validates offer caps and units, 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/cjs/api/helpers.js

@@ -250,7 +250,7 @@ function mapTakeableOffer(takeableOffer) {
         ratifierData: takeableOffer.ratifier_data,
     };
 }
-/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+/** @internal Maps, validates offer caps and units, and best-price-sorts API takeable offers. */
 function mapBoundTakeableOffers(takeableOffers, context) {
     const mapped = takeableOffers.map((takeableOffer) => {
         let take;
@@ -285,6 +285,9 @@ function mapBoundTakeableOffers(takeableOffers, context) {
                 throw cause;
             throw new errors_js_1.InvalidMidnightApiResponseError(`Midnight API takeable offer for market_id "${take.marketId}" is not executable: ${cause.message}`, { cause });
         }
+        if (maxUnits > 0n && take.units > maxUnits) {
+            throw new errors_js_1.InvalidMidnightApiResponseError(`Midnight API takeable offer for market_id "${take.marketId}" reports units "${take.units}" above offer maxUnits "${maxUnits}".`);
+        }
         if (context.marketId != null &&
             !(0, morpho_ts_1.isHexEqual)(take.marketId, context.marketId)) {
             throw new errors_js_1.InvalidMidnightApiResponseError(`Midnight API takeable offer market_id "${take.marketId}" does not match requested market "${context.marketId}".`);

package/lib/cjs/api/types.d.ts

@@ -409,7 +409,7 @@ export interface MidnightApiBookPriceLevelsResult {
 export interface MidnightApiQuote {
     /** Weighted average price for the requested size before any guard. */
     readonly averageBestPrice: string;
-    /** Effective weighted average-price guard for the returned instructions. */
+    /** Equals the caller's `averageWorstPrice` when provided, otherwise the API's guard. */
     readonly averageWorstPrice: string;
     /** Maximum assets available from the returned take caps. */
     readonly availableAssets: string;

package/lib/cjs/api/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** @internal Installed Midnight SDK package version. */
-export declare const MIDNIGHT_SDK_VERSION = "2.0.0";
+export declare const MIDNIGHT_SDK_VERSION = "2.1.0";

package/lib/cjs/api/version.generated.js

@@ -3,4 +3,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIDNIGHT_SDK_VERSION = void 0;
 /** @internal Installed Midnight SDK package version. */
-exports.MIDNIGHT_SDK_VERSION = "2.0.0";
+exports.MIDNIGHT_SDK_VERSION = "2.1.0";

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

@@ -150,6 +150,7 @@ export declare class Offer {
     readonly tick: bigint;
     private cachedGroup;
     private cachedHash;
+    private cachedOnchainHash;
     /**
      * Whether the group id was supplied at construction rather than derived.
      *
@@ -329,6 +330,55 @@ export declare class Offer {
      * ```
      */
     get hash(): Hash;
+    /**
+     * Returns the on-chain offer identifier emitted by Midnight's `Take` event.
+     *
+     * This `keccak256(abi.encode(offer))` hash identifies offers on-chain and is
+     * distinct from `hash`, the typehash-prefixed ratifier hash.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @returns The cached on-chain offer hash.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = offer.onchainHash;
+     * console.log(offerHash);
+     * ```
+     */
+    get onchainHash(): Hash;
     /**
      * WAD zero-coupon price at this offer's tick.
      *

package/lib/cjs/offers/Offer.js

@@ -71,6 +71,7 @@ class Offer {
     tick;
     cachedGroup;
     cachedHash;
+    cachedOnchainHash;
     /**
      * Whether the group id was supplied at construction rather than derived.
      *
@@ -281,6 +282,58 @@ class Offer {
         this.cachedHash ??= OfferUtils_js_1.OfferUtils.hash(this);
         return this.cachedHash;
     }
+    /**
+     * Returns the on-chain offer identifier emitted by Midnight's `Take` event.
+     *
+     * This `keccak256(abi.encode(offer))` hash identifies offers on-chain and is
+     * distinct from `hash`, the typehash-prefixed ratifier hash.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @returns The cached on-chain offer hash.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = offer.onchainHash;
+     * console.log(offerHash);
+     * ```
+     */
+    get onchainHash() {
+        this.cachedOnchainHash ??= OfferUtils_js_1.OfferUtils.onchainHash(this);
+        return this.cachedOnchainHash;
+    }
     /**
      * WAD zero-coupon price at this offer's tick.
      *

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

@@ -160,6 +160,114 @@ export declare namespace OfferUtils {
      * ```
      */
     function hash(offer: IOffer & Required<Pick<IOffer, "group">>): Hash;
+    /**
+     * Computes the on-chain offer identifier from the supplied offer struct.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hashStruct` and `hash`, which produce the typehash-prefixed ratifier hash.
+     * Collaterals are hashed in the supplied order; Midnight rejects unsorted
+     * collateral params with `CollateralParamsNotSorted`, so pass a sorted struct,
+     * for example one returned by `toStruct`.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offerStruct - ABI-compatible offer to hash without normalization.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHashStruct(
+     *   OfferUtils.toStruct({ offer }),
+     * );
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHashStruct(offerStruct: OfferStruct): Hash;
+    /**
+     * Computes the on-chain offer identifier from an offer with a group id.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hash`, which returns the typehash-prefixed ratifier hash. `toStruct`
+     * normalizes the offer and sorts collateral params as required by Midnight.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offer - Offer with the protocol group id encoded in its struct.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHash(offer);
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHash(offer: IOffer & Required<Pick<IOffer, "group">>): Hash;
     /**
      * Computes the offer hash used to derive a content-addressed group id.
      *

package/lib/cjs/offers/OfferUtils.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OfferUtils = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const viem_1 = require("viem");
+const abis_js_1 = require("../abis.js");
 const constants_js_1 = require("../constants.js");
 const errors_js_1 = require("../errors.js");
 const index_js_1 = require("../market/index.js");
 const index_js_2 = require("../math/index.js");
 const Offer_js_1 = require("./Offer.js");
+const takeOfferParam = (0, viem_1.getAbiItem)({ abi: abis_js_1.midnightAbi, name: "take" }).inputs[0];
 const offerHashParams = [
     { name: "typehash", type: "bytes32" },
     { name: "marketHash", type: "bytes32" },
@@ -226,6 +228,120 @@ var OfferUtils;
         return hashStruct(toStruct({ offer }));
     }
     OfferUtils.hash = hash;
+    /**
+     * Computes the on-chain offer identifier from the supplied offer struct.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hashStruct` and `hash`, which produce the typehash-prefixed ratifier hash.
+     * Collaterals are hashed in the supplied order; Midnight rejects unsorted
+     * collateral params with `CollateralParamsNotSorted`, so pass a sorted struct,
+     * for example one returned by `toStruct`.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offerStruct - ABI-compatible offer to hash without normalization.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHashStruct(
+     *   OfferUtils.toStruct({ offer }),
+     * );
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHashStruct(offerStruct) {
+        return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([takeOfferParam], [offerStruct]));
+    }
+    OfferUtils.onchainHashStruct = onchainHashStruct;
+    /**
+     * Computes the on-chain offer identifier from an offer with a group id.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hash`, which returns the typehash-prefixed ratifier hash. `toStruct`
+     * normalizes the offer and sorts collateral params as required by Midnight.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offer - Offer with the protocol group id encoded in its struct.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHash(offer);
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHash(offer) {
+        return onchainHashStruct(toStruct({ offer }));
+    }
+    OfferUtils.onchainHash = onchainHash;
     /**
      * Computes the offer hash used to derive a content-addressed group id.
      *

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

@@ -142,7 +142,7 @@ export declare class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -170,11 +170,12 @@ export declare class MidnightApi {
      * @param params.baseUrl - Optional Midnight API base URL override.
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -205,7 +206,7 @@ export declare class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -390,7 +391,7 @@ export declare class MidnightApi {
      * @param params.side - Book side to query.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -416,11 +417,12 @@ export declare class MidnightApi {
      * @param params.averageWorstPrice - Optional WAD-scaled average worst price guard. Mutually exclusive with `params.slippage`.
      * @param params.slippage - Optional slippage percentage used to derive the guard. Mutually exclusive with `params.averageWorstPrice`.
      * @param params.settlementFee - Optional current WAD-scaled settlement fee used for local guard validation. Defaults to zero.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -448,7 +450,7 @@ export declare class MidnightApi {
      * @param params.cursor - Optional opaque pagination cursor from a previous response.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";

package/lib/esm/api/MidnightApi.js

@@ -203,7 +203,7 @@ export class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -248,11 +248,12 @@ export class MidnightApi {
      * @param params.baseUrl - Optional Midnight API base URL override.
      * @param params.fetch - Optional fetch implementation override.
      * @param params.request - Optional fetch options forwarded to this request.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -297,8 +298,8 @@ export class MidnightApi {
             : "slippage" in input && input.slippage != null
                 ? response.data.average_worst_price
                 : undefined;
-        if (averageWorstPrice != null) {
-            const guard = BigInt(averageWorstPrice);
+        const guard = averageWorstPrice == null ? undefined : BigInt(averageWorstPrice);
+        if (guard != null) {
             let filledUnits = 0n;
             let filledAssets = 0n;
             if ("units" in input && input.units != null) {
@@ -355,7 +356,7 @@ export class MidnightApi {
         return {
             data: {
                 averageBestPrice: response.data.average_best_price,
-                averageWorstPrice: response.data.average_worst_price,
+                averageWorstPrice: guard?.toString() ?? response.data.average_worst_price,
                 availableAssets: response.data.available_assets,
                 availableUnits: response.data.available_units,
                 takeableOffers,
@@ -377,7 +378,7 @@ export class MidnightApi {
      * @param params.request - Optional fetch options forwarded to this request.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -625,7 +626,7 @@ export class MidnightApi {
      * @param params.side - Book side to query.
      * @returns ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";
@@ -656,11 +657,12 @@ export class MidnightApi {
      * @param params.averageWorstPrice - Optional WAD-scaled average worst price guard. Mutually exclusive with `params.slippage`.
      * @param params.slippage - Optional slippage percentage used to derive the guard. Mutually exclusive with `params.averageWorstPrice`.
      * @param params.settlementFee - Optional current WAD-scaled settlement fee used for local guard validation. Defaults to zero.
-     * @returns Quote and signed ABI-ready take caps mapped from the API response.
+     * @returns Quote and ABI-ready take caps. `averageWorstPrice` equals the caller's guard when provided,
+     *   otherwise the API's guard.
      * @throws {InvalidMidnightApiQuoteTargetError} when the runtime input does not set exactly one of `units` or `assets`.
      * @throws {NegativeValueError} when `settlementFee` is negative.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, when its units exceed its offer `maxUnits`, or when the returned offers imply a rounded aggregate settlement price outside the effective average-worst-price guard.
      * @throws {SettlementFeeExceedsPriceError} when a bid's settlement fee exceeds its offer price.
      * @example
      * ```ts
@@ -693,7 +695,7 @@ export class MidnightApi {
      * @param params.cursor - Optional opaque pagination cursor from a previous response.
      * @returns Paginated ABI-ready take objects mapped from the API response.
      * @throws {MidnightApiError} when the API returns a non-2xx response.
-     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, or when its caps or buy-side receiver are not executable.
+     * @throws {InvalidMidnightApiResponseError} when the API success response is not JSON, when a returned offer cannot be mapped (malformed numeric or hex fields), when its `market_id` does not match, or cannot be derived from, its embedded market, when it falls outside the requested filters, when its `receiverIfMakerIsSeller` is not a well-formed address, when its caps or buy-side receiver are not executable, or when its units exceed its offer `maxUnits`.
      * @example
      * ```ts
      * import { MidnightApi } from "@morpho-org/midnight-sdk/api";

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

@@ -30,7 +30,7 @@ export interface TakeableOfferContext {
     readonly marketIds?: readonly Hash[];
     readonly groups?: readonly Hash[];
 }
-/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+/** @internal Maps, validates offer caps and units, 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

@@ -241,7 +241,7 @@ function mapTakeableOffer(takeableOffer) {
         ratifierData: takeableOffer.ratifier_data,
     };
 }
-/** @internal Maps, validates, and best-price-sorts API takeable offers. */
+/** @internal Maps, validates offer caps and units, and best-price-sorts API takeable offers. */
 export function mapBoundTakeableOffers(takeableOffers, context) {
     const mapped = takeableOffers.map((takeableOffer) => {
         let take;
@@ -276,6 +276,9 @@ export function mapBoundTakeableOffers(takeableOffers, context) {
                 throw cause;
             throw new InvalidMidnightApiResponseError(`Midnight API takeable offer for market_id "${take.marketId}" is not executable: ${cause.message}`, { cause });
         }
+        if (maxUnits > 0n && take.units > maxUnits) {
+            throw new InvalidMidnightApiResponseError(`Midnight API takeable offer for market_id "${take.marketId}" reports units "${take.units}" above offer maxUnits "${maxUnits}".`);
+        }
         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}".`);

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

@@ -409,7 +409,7 @@ export interface MidnightApiBookPriceLevelsResult {
 export interface MidnightApiQuote {
     /** Weighted average price for the requested size before any guard. */
     readonly averageBestPrice: string;
-    /** Effective weighted average-price guard for the returned instructions. */
+    /** Equals the caller's `averageWorstPrice` when provided, otherwise the API's guard. */
     readonly averageWorstPrice: string;
     /** Maximum assets available from the returned take caps. */
     readonly availableAssets: string;

package/lib/esm/api/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** @internal Installed Midnight SDK package version. */
-export declare const MIDNIGHT_SDK_VERSION = "2.0.0";
+export declare const MIDNIGHT_SDK_VERSION = "2.1.0";

package/lib/esm/api/version.generated.js

@@ -1,3 +1,3 @@
 // Generated by scripts/generate-midnight-package-version.ts. Do not edit.
 /** @internal Installed Midnight SDK package version. */
-export const MIDNIGHT_SDK_VERSION = "2.0.0";
+export const MIDNIGHT_SDK_VERSION = "2.1.0";

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

@@ -150,6 +150,7 @@ export declare class Offer {
     readonly tick: bigint;
     private cachedGroup;
     private cachedHash;
+    private cachedOnchainHash;
     /**
      * Whether the group id was supplied at construction rather than derived.
      *
@@ -329,6 +330,55 @@ export declare class Offer {
      * ```
      */
     get hash(): Hash;
+    /**
+     * Returns the on-chain offer identifier emitted by Midnight's `Take` event.
+     *
+     * This `keccak256(abi.encode(offer))` hash identifies offers on-chain and is
+     * distinct from `hash`, the typehash-prefixed ratifier hash.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @returns The cached on-chain offer hash.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = offer.onchainHash;
+     * console.log(offerHash);
+     * ```
+     */
+    get onchainHash(): Hash;
     /**
      * WAD zero-coupon price at this offer's tick.
      *

package/lib/esm/offers/Offer.js

@@ -68,6 +68,7 @@ export class Offer {
     tick;
     cachedGroup;
     cachedHash;
+    cachedOnchainHash;
     /**
      * Whether the group id was supplied at construction rather than derived.
      *
@@ -278,6 +279,58 @@ export class Offer {
         this.cachedHash ??= OfferUtils.hash(this);
         return this.cachedHash;
     }
+    /**
+     * Returns the on-chain offer identifier emitted by Midnight's `Take` event.
+     *
+     * This `keccak256(abi.encode(offer))` hash identifies offers on-chain and is
+     * distinct from `hash`, the typehash-prefixed ratifier hash.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @returns The cached on-chain offer hash.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = offer.onchainHash;
+     * console.log(offerHash);
+     * ```
+     */
+    get onchainHash() {
+        this.cachedOnchainHash ??= OfferUtils.onchainHash(this);
+        return this.cachedOnchainHash;
+    }
     /**
      * WAD zero-coupon price at this offer's tick.
      *

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

@@ -160,6 +160,114 @@ export declare namespace OfferUtils {
      * ```
      */
     function hash(offer: IOffer & Required<Pick<IOffer, "group">>): Hash;
+    /**
+     * Computes the on-chain offer identifier from the supplied offer struct.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hashStruct` and `hash`, which produce the typehash-prefixed ratifier hash.
+     * Collaterals are hashed in the supplied order; Midnight rejects unsorted
+     * collateral params with `CollateralParamsNotSorted`, so pass a sorted struct,
+     * for example one returned by `toStruct`.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offerStruct - ABI-compatible offer to hash without normalization.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHashStruct(
+     *   OfferUtils.toStruct({ offer }),
+     * );
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHashStruct(offerStruct: OfferStruct): Hash;
+    /**
+     * Computes the on-chain offer identifier from an offer with a group id.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hash`, which returns the typehash-prefixed ratifier hash. `toStruct`
+     * normalizes the offer and sorts collateral params as required by Midnight.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offer - Offer with the protocol group id encoded in its struct.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHash(offer);
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHash(offer: IOffer & Required<Pick<IOffer, "group">>): Hash;
     /**
      * Computes the offer hash used to derive a content-addressed group id.
      *

package/lib/esm/offers/OfferUtils.js

@@ -1,10 +1,12 @@
 import { assertNonNegative, DivisionByZeroError, MathLib, } from "@morpho-org/morpho-ts";
-import { encodeAbiParameters, isAddressEqual, keccak256, zeroAddress, zeroHash, } from "viem";
+import { encodeAbiParameters, getAbiItem, isAddressEqual, keccak256, zeroAddress, zeroHash, } from "viem";
+import { midnightAbi } from "../abis.js";
 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 takeOfferParam = getAbiItem({ abi: midnightAbi, name: "take" }).inputs[0];
 const offerHashParams = [
     { name: "typehash", type: "bytes32" },
     { name: "marketHash", type: "bytes32" },
@@ -223,6 +225,120 @@ export var OfferUtils;
         return hashStruct(toStruct({ offer }));
     }
     OfferUtils.hash = hash;
+    /**
+     * Computes the on-chain offer identifier from the supplied offer struct.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hashStruct` and `hash`, which produce the typehash-prefixed ratifier hash.
+     * Collaterals are hashed in the supplied order; Midnight rejects unsorted
+     * collateral params with `CollateralParamsNotSorted`, so pass a sorted struct,
+     * for example one returned by `toStruct`.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offerStruct - ABI-compatible offer to hash without normalization.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHashStruct(
+     *   OfferUtils.toStruct({ offer }),
+     * );
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHashStruct(offerStruct) {
+        return keccak256(encodeAbiParameters([takeOfferParam], [offerStruct]));
+    }
+    OfferUtils.onchainHashStruct = onchainHashStruct;
+    /**
+     * Computes the on-chain offer identifier from an offer with a group id.
+     *
+     * This is `keccak256(abi.encode(offer))`, the hash emitted by Midnight's
+     * `Take` event and used to identify offers on-chain. It is distinct from
+     * `hash`, which returns the typehash-prefixed ratifier hash. `toStruct`
+     * normalizes the offer and sorts collateral params as required by Midnight.
+     * It matches a `Take` event only for the offer exactly as published. For
+     * RateRatifierV1 and PriceRatifierV1, hash the offers in the descriptor's
+     * `offers`: `buildDescriptor` replaces both the default group and a
+     * `Group.create` group.
+     *
+     * @param offer - Offer with the protocol group id encoded in its struct.
+     * @returns The offer hash emitted by Midnight's `Take` event.
+     * @throws {viem.InvalidAddressError} when an address has an invalid mixed-case checksum.
+     * @throws {viem.IntegerOutOfRangeError} when a uint field overflows its ABI size.
+     * @example
+     * ```ts
+     * import { Offer, OfferUtils } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     chainId: 8453,
+     *     midnight: "0x0000000000000000000000000000000000001000",
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         liquidationCursor: 250000000000000000n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   group: "0x1111111111111111111111111111111111111111111111111111111111111111",
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const offerHash = OfferUtils.onchainHash(offer);
+     * console.log(offerHash);
+     * ```
+     */
+    function onchainHash(offer) {
+        return onchainHashStruct(toStruct({ offer }));
+    }
+    OfferUtils.onchainHash = onchainHash;
     /**
      * Computes the offer hash used to derive a content-addressed group id.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/midnight-sdk",
   "description": "Viem-based package for Morpho Midnight that exports protocol utilities, fetch helpers, and Midnight API utilities under a dedicated API subpath.",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "author": "Morpho Association <contact@morpho.org>",
   "repository": {
     "type": "git",
@@ -45,8 +45,8 @@
     "viem": "^2.0.0"
   },
   "devDependencies": {
-    "@morpho-org/morpho-ts": "^4.0.0",
-    "@morpho-org/test": "^2.10.1",
+    "@morpho-org/morpho-ts": "^4.0.1",
+    "@morpho-org/test": "^2.11.0",
     "fast-check": "^4.9.0",
     "typescript": "7.0.2",
     "viem": "^2.55.10",