@morpho-org/midnight-sdk 2.1.0-next.0 → 2.1.0

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.1.0-next.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.1.0-next.0";
+exports.MIDNIGHT_SDK_VERSION = "2.1.0";

package/lib/cjs/errors.d.ts

@@ -1,4 +1,3 @@
-import { InvalidPositionAccrualStateError as SharedInvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError as SharedInvalidPositionAccrualTimestampError, InvalidPositionLossFactorError as SharedInvalidPositionLossFactorError } from "@morpho-org/morpho-ts";
 import type { Address } from "viem";
 import type { MempoolPayloadValidationIssue } from "./api/types.js";
 /**
@@ -71,27 +70,42 @@ export declare class SettlementFeeExceedsPriceError extends Error {
 /**
  * Thrown when a local position accrual is requested for an impossible timestamp.
  *
- * @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualTimestampError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualTimestampError(1n, 2n);
+ * ```
  */
-export declare const InvalidPositionAccrualTimestampError: typeof SharedInvalidPositionAccrualTimestampError;
-/** @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionAccrualTimestampError = SharedInvalidPositionAccrualTimestampError;
+export declare class InvalidPositionAccrualTimestampError extends Error {
+    constructor(timestamp: bigint, lastAccrual: bigint);
+}
 /**
  * Thrown when a local position accrual sees a market loss factor older than the position.
  *
- * @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionLossFactorError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionLossFactorError(1n, 2n);
+ * ```
  */
-export declare const InvalidPositionLossFactorError: typeof SharedInvalidPositionLossFactorError;
-/** @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionLossFactorError = SharedInvalidPositionLossFactorError;
+export declare class InvalidPositionLossFactorError extends Error {
+    constructor(marketLossFactor: bigint, positionLossFactor: bigint);
+}
 /**
  * Thrown when local position accrual inputs violate Midnight accounting invariants.
  *
- * @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualStateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualStateError("Pending fee exceeds credit.");
+ * ```
  */
-export declare const InvalidPositionAccrualStateError: typeof SharedInvalidPositionAccrualStateError;
-/** @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionAccrualStateError = SharedInvalidPositionAccrualStateError;
+export declare class InvalidPositionAccrualStateError extends Error {
+    constructor(reason: string);
+}
 /**
  * Thrown when a market parameter cannot satisfy Midnight protocol rules.
  *

package/lib/cjs/errors.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidMidnightApiQuoteTargetError = exports.InvalidMidnightApiResponseError = exports.MidnightApiError = exports.InvalidEcrecoverSignatureVError = exports.InvalidTypedDataSignatureError = exports.MidnightMempoolValidationError = exports.ChainIdMismatchError = exports.RatifierV1TakerNotAllowedError = exports.InvalidRatifierV1AddressError = exports.InvalidRateRatifierV1TimeError = exports.InvalidRateRatifierV1TickError = exports.RateRatifierV1BoundOverflowError = exports.InvalidRateRatifierV1RateError = exports.InvalidTreeError = exports.InvalidTreeHeightError = exports.PayloadDecodeError = exports.InvalidOfferParameterError = exports.UnknownCollateralIndexError = exports.InvalidMarketParameterError = exports.InvalidPositionAccrualStateError = exports.InvalidPositionLossFactorError = exports.InvalidPositionAccrualTimestampError = exports.SettlementFeeExceedsPriceError = exports.InvalidTickSpacingError = exports.PriceGreaterThanOneError = exports.TickOutOfRangeError = exports.InvalidOfferGroupError = void 0;
-const morpho_ts_1 = require("@morpho-org/morpho-ts");
 /**
  * Thrown when a Midnight offer group violates protocol-level group mechanics.
  *
@@ -90,25 +89,57 @@ class SettlementFeeExceedsPriceError extends Error {
     }
 }
 exports.SettlementFeeExceedsPriceError = SettlementFeeExceedsPriceError;
-// Temporary compatibility exception for these shared morpho-ts errors.
 /**
  * Thrown when a local position accrual is requested for an impossible timestamp.
  *
- * @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualTimestampError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualTimestampError(1n, 2n);
+ * ```
  */
-exports.InvalidPositionAccrualTimestampError = morpho_ts_1.InvalidPositionAccrualTimestampError;
+class InvalidPositionAccrualTimestampError extends Error {
+    constructor(timestamp, lastAccrual) {
+        super(`Position accrual timestamp "${timestamp}" is before last accrual "${lastAccrual}". Use a timestamp greater than or equal to last accrual.`);
+        this.name = "InvalidPositionAccrualTimestampError";
+    }
+}
+exports.InvalidPositionAccrualTimestampError = InvalidPositionAccrualTimestampError;
 /**
  * Thrown when a local position accrual sees a market loss factor older than the position.
  *
- * @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionLossFactorError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionLossFactorError(1n, 2n);
+ * ```
  */
-exports.InvalidPositionLossFactorError = morpho_ts_1.InvalidPositionLossFactorError;
+class InvalidPositionLossFactorError extends Error {
+    constructor(marketLossFactor, positionLossFactor) {
+        super(`Market loss factor "${marketLossFactor}" is below position loss factor "${positionLossFactor}". Fetch a consistent market and position at the same block.`);
+        this.name = "InvalidPositionLossFactorError";
+    }
+}
+exports.InvalidPositionLossFactorError = InvalidPositionLossFactorError;
 /**
  * Thrown when local position accrual inputs violate Midnight accounting invariants.
  *
- * @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualStateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualStateError("Pending fee exceeds credit.");
+ * ```
  */
-exports.InvalidPositionAccrualStateError = morpho_ts_1.InvalidPositionAccrualStateError;
+class InvalidPositionAccrualStateError extends Error {
+    constructor(reason) {
+        super(`Invalid Midnight position accrual state. ${reason}`);
+        this.name = "InvalidPositionAccrualStateError";
+    }
+}
+exports.InvalidPositionAccrualStateError = InvalidPositionAccrualStateError;
 /**
  * Thrown when a market parameter cannot satisfy Midnight protocol rules.
  *

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/cjs/position/PositionUtils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PositionUtils = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const errors_js_1 = require("../errors.js");
 /**
  * Domain helpers for Midnight positions.
  *
@@ -134,17 +135,40 @@ var PositionUtils;
      */
     function accrueInterest(params) {
         const timestamp = BigInt(params.timestamp);
+        const credit = BigInt(params.position.credit);
+        const pendingFee = BigInt(params.position.pendingFee);
+        const lastLossFactor = BigInt(params.position.lastLossFactor);
+        const lastAccrual = BigInt(params.position.lastAccrual);
         const marketLossFactor = BigInt(params.market.lossFactor);
+        if (timestamp < lastAccrual) {
+            throw new errors_js_1.InvalidPositionAccrualTimestampError(timestamp, lastAccrual);
+        }
+        if (marketLossFactor < lastLossFactor) {
+            throw new errors_js_1.InvalidPositionLossFactorError(marketLossFactor, lastLossFactor);
+        }
+        if (pendingFee > credit) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Pending fee must be less than or equal to credit.");
+        }
+        const postSlashCredit = lastLossFactor < morpho_ts_1.MathLib.MAX_UINT_128
+            ? morpho_ts_1.MathLib.mulDivDown(credit, morpho_ts_1.MathLib.MAX_UINT_128 - marketLossFactor, morpho_ts_1.MathLib.MAX_UINT_128 - lastLossFactor)
+            : 0n;
+        if (postSlashCredit > credit) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Post-slash credit cannot exceed stored credit.");
+        }
+        const creditDecrease = credit - postSlashCredit;
+        const pendingFeeDecrease = credit > 0n ? morpho_ts_1.MathLib.mulDivUp(pendingFee, creditDecrease, credit) : 0n;
+        if (pendingFeeDecrease > pendingFee) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Pending-fee decrease cannot exceed pending fee.");
+        }
+        const postSlashPendingFee = pendingFee - pendingFeeDecrease;
         const maturity = BigInt(params.market.params.maturity);
-        const { credit, pendingFee, accruedFee } = morpho_ts_1.MidnightPositionLib.accrue({
-            credit: params.position.credit,
-            pendingFee: params.position.pendingFee,
-            lastLossFactor: params.position.lastLossFactor,
-            lastAccrual: params.position.lastAccrual,
-            marketLossFactor,
-            maturity,
-            timestamp,
-        });
+        const accrualEnd = timestamp < maturity ? timestamp : maturity;
+        const accruedFee = lastAccrual < maturity
+            ? morpho_ts_1.MathLib.mulDivDown(postSlashPendingFee, accrualEnd - lastAccrual, maturity - lastAccrual)
+            : 0n;
+        if (accruedFee > postSlashCredit || accruedFee > postSlashPendingFee) {
+            throw new errors_js_1.InvalidPositionAccrualStateError("Accrued fee cannot exceed post-slash credit or pending fee.");
+        }
         const collateral = params.position.collateral.map((assets) => BigInt(assets));
         const collateralParams = params.market.params.collateralParams.map((collateralParam) => ({
             token: collateralParam.token,
@@ -175,8 +199,8 @@ var PositionUtils;
             position: {
                 user: params.position.user,
                 marketId: params.position.marketId,
-                credit,
-                pendingFee,
+                credit: postSlashCredit - accruedFee,
+                pendingFee: postSlashPendingFee - accruedFee,
                 lastLossFactor: marketLossFactor,
                 lastAccrual: timestamp,
                 debt: BigInt(params.position.debt),

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.1.0-next.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.1.0-next.0";
+export const MIDNIGHT_SDK_VERSION = "2.1.0";

package/lib/esm/errors.d.ts

@@ -1,4 +1,3 @@
-import { InvalidPositionAccrualStateError as SharedInvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError as SharedInvalidPositionAccrualTimestampError, InvalidPositionLossFactorError as SharedInvalidPositionLossFactorError } from "@morpho-org/morpho-ts";
 import type { Address } from "viem";
 import type { MempoolPayloadValidationIssue } from "./api/types.js";
 /**
@@ -71,27 +70,42 @@ export declare class SettlementFeeExceedsPriceError extends Error {
 /**
  * Thrown when a local position accrual is requested for an impossible timestamp.
  *
- * @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualTimestampError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualTimestampError(1n, 2n);
+ * ```
  */
-export declare const InvalidPositionAccrualTimestampError: typeof SharedInvalidPositionAccrualTimestampError;
-/** @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionAccrualTimestampError = SharedInvalidPositionAccrualTimestampError;
+export declare class InvalidPositionAccrualTimestampError extends Error {
+    constructor(timestamp: bigint, lastAccrual: bigint);
+}
 /**
  * Thrown when a local position accrual sees a market loss factor older than the position.
  *
- * @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionLossFactorError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionLossFactorError(1n, 2n);
+ * ```
  */
-export declare const InvalidPositionLossFactorError: typeof SharedInvalidPositionLossFactorError;
-/** @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionLossFactorError = SharedInvalidPositionLossFactorError;
+export declare class InvalidPositionLossFactorError extends Error {
+    constructor(marketLossFactor: bigint, positionLossFactor: bigint);
+}
 /**
  * Thrown when local position accrual inputs violate Midnight accounting invariants.
  *
- * @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualStateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualStateError("Pending fee exceeds credit.");
+ * ```
  */
-export declare const InvalidPositionAccrualStateError: typeof SharedInvalidPositionAccrualStateError;
-/** @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major. */
-export type InvalidPositionAccrualStateError = SharedInvalidPositionAccrualStateError;
+export declare class InvalidPositionAccrualStateError extends Error {
+    constructor(reason: string);
+}
 /**
  * Thrown when a market parameter cannot satisfy Midnight protocol rules.
  *

package/lib/esm/errors.js

@@ -1,4 +1,3 @@
-import { InvalidPositionAccrualStateError as SharedInvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError as SharedInvalidPositionAccrualTimestampError, InvalidPositionLossFactorError as SharedInvalidPositionLossFactorError, } from "@morpho-org/morpho-ts";
 /**
  * Thrown when a Midnight offer group violates protocol-level group mechanics.
  *
@@ -82,25 +81,54 @@ export class SettlementFeeExceedsPriceError extends Error {
         this.name = "SettlementFeeExceedsPriceError";
     }
 }
-// Temporary compatibility exception for these shared morpho-ts errors.
 /**
  * Thrown when a local position accrual is requested for an impossible timestamp.
  *
- * @deprecated Import `InvalidPositionAccrualTimestampError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualTimestampError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualTimestampError(1n, 2n);
+ * ```
  */
-export const InvalidPositionAccrualTimestampError = SharedInvalidPositionAccrualTimestampError;
+export class InvalidPositionAccrualTimestampError extends Error {
+    constructor(timestamp, lastAccrual) {
+        super(`Position accrual timestamp "${timestamp}" is before last accrual "${lastAccrual}". Use a timestamp greater than or equal to last accrual.`);
+        this.name = "InvalidPositionAccrualTimestampError";
+    }
+}
 /**
  * Thrown when a local position accrual sees a market loss factor older than the position.
  *
- * @deprecated Import `InvalidPositionLossFactorError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionLossFactorError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionLossFactorError(1n, 2n);
+ * ```
  */
-export const InvalidPositionLossFactorError = SharedInvalidPositionLossFactorError;
+export class InvalidPositionLossFactorError extends Error {
+    constructor(marketLossFactor, positionLossFactor) {
+        super(`Market loss factor "${marketLossFactor}" is below position loss factor "${positionLossFactor}". Fetch a consistent market and position at the same block.`);
+        this.name = "InvalidPositionLossFactorError";
+    }
+}
 /**
  * Thrown when local position accrual inputs violate Midnight accounting invariants.
  *
- * @deprecated Import `InvalidPositionAccrualStateError` from `@morpho-org/morpho-ts`. Removed in the next major.
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualStateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualStateError("Pending fee exceeds credit.");
+ * ```
  */
-export const InvalidPositionAccrualStateError = SharedInvalidPositionAccrualStateError;
+export class InvalidPositionAccrualStateError extends Error {
+    constructor(reason) {
+        super(`Invalid Midnight position accrual state. ${reason}`);
+        this.name = "InvalidPositionAccrualStateError";
+    }
+}
 /**
  * Thrown when a market parameter cannot satisfy Midnight protocol rules.
  *

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/lib/esm/position/PositionUtils.js

@@ -1,4 +1,5 @@
-import { MathLib, MidnightPositionLib, } from "@morpho-org/morpho-ts";
+import { MathLib } from "@morpho-org/morpho-ts";
+import { InvalidPositionAccrualStateError, InvalidPositionAccrualTimestampError, InvalidPositionLossFactorError, } from "../errors.js";
 /**
  * Domain helpers for Midnight positions.
  *
@@ -131,17 +132,40 @@ export var PositionUtils;
      */
     function accrueInterest(params) {
         const timestamp = BigInt(params.timestamp);
+        const credit = BigInt(params.position.credit);
+        const pendingFee = BigInt(params.position.pendingFee);
+        const lastLossFactor = BigInt(params.position.lastLossFactor);
+        const lastAccrual = BigInt(params.position.lastAccrual);
         const marketLossFactor = BigInt(params.market.lossFactor);
+        if (timestamp < lastAccrual) {
+            throw new InvalidPositionAccrualTimestampError(timestamp, lastAccrual);
+        }
+        if (marketLossFactor < lastLossFactor) {
+            throw new InvalidPositionLossFactorError(marketLossFactor, lastLossFactor);
+        }
+        if (pendingFee > credit) {
+            throw new InvalidPositionAccrualStateError("Pending fee must be less than or equal to credit.");
+        }
+        const postSlashCredit = lastLossFactor < MathLib.MAX_UINT_128
+            ? MathLib.mulDivDown(credit, MathLib.MAX_UINT_128 - marketLossFactor, MathLib.MAX_UINT_128 - lastLossFactor)
+            : 0n;
+        if (postSlashCredit > credit) {
+            throw new InvalidPositionAccrualStateError("Post-slash credit cannot exceed stored credit.");
+        }
+        const creditDecrease = credit - postSlashCredit;
+        const pendingFeeDecrease = credit > 0n ? MathLib.mulDivUp(pendingFee, creditDecrease, credit) : 0n;
+        if (pendingFeeDecrease > pendingFee) {
+            throw new InvalidPositionAccrualStateError("Pending-fee decrease cannot exceed pending fee.");
+        }
+        const postSlashPendingFee = pendingFee - pendingFeeDecrease;
         const maturity = BigInt(params.market.params.maturity);
-        const { credit, pendingFee, accruedFee } = MidnightPositionLib.accrue({
-            credit: params.position.credit,
-            pendingFee: params.position.pendingFee,
-            lastLossFactor: params.position.lastLossFactor,
-            lastAccrual: params.position.lastAccrual,
-            marketLossFactor,
-            maturity,
-            timestamp,
-        });
+        const accrualEnd = timestamp < maturity ? timestamp : maturity;
+        const accruedFee = lastAccrual < maturity
+            ? MathLib.mulDivDown(postSlashPendingFee, accrualEnd - lastAccrual, maturity - lastAccrual)
+            : 0n;
+        if (accruedFee > postSlashCredit || accruedFee > postSlashPendingFee) {
+            throw new InvalidPositionAccrualStateError("Accrued fee cannot exceed post-slash credit or pending fee.");
+        }
         const collateral = params.position.collateral.map((assets) => BigInt(assets));
         const collateralParams = params.market.params.collateralParams.map((collateralParam) => ({
             token: collateralParam.token,
@@ -172,8 +196,8 @@ export var PositionUtils;
             position: {
                 user: params.position.user,
                 marketId: params.position.marketId,
-                credit,
-                pendingFee,
+                credit: postSlashCredit - accruedFee,
+                pendingFee: postSlashPendingFee - accruedFee,
                 lastLossFactor: marketLossFactor,
                 lastAccrual: timestamp,
                 debt: BigInt(params.position.debt),

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.1.0-next.0",
+  "version": "2.1.0",
   "author": "Morpho Association <contact@morpho.org>",
   "repository": {
     "type": "git",
@@ -41,12 +41,12 @@
     "MIGRATION-v1-to-v2.md"
   ],
   "peerDependencies": {
-    "@morpho-org/morpho-ts": "^4.1.0-0",
+    "@morpho-org/morpho-ts": "^2.8.0 || ^3.0.0 || ^4.0.0",
     "viem": "^2.0.0"
   },
   "devDependencies": {
-    "@morpho-org/morpho-ts": "^4.1.0-next.0",
-    "@morpho-org/test": "^2.11.0-next.0",
+    "@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",