@morpho-org/midnight-sdk 1.1.1 → 1.2.1

package/lib/cjs/{market → position}/Position.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccrualPosition = exports.Position = void 0;
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
 const errors_js_1 = require("../errors.js");
-const Market_js_1 = require("./Market.js");
+const Market_js_1 = require("../market/Market.js");
 const PositionUtils_js_1 = require("./PositionUtils.js");
 /**
  * Midnight user position as stored by the core contract.
@@ -13,6 +13,8 @@ const PositionUtils_js_1 = require("./PositionUtils.js");
  * import { Position } from "@morpho-org/midnight-sdk";
  *
  * const position = new Position({
+ *   user: "0x0000000000000000000000000000000000009000",
+ *   marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *   credit: 0n,
  *   pendingFee: 0n,
  *   lastLossFactor: 0n,
@@ -25,6 +27,10 @@ const PositionUtils_js_1 = require("./PositionUtils.js");
  * ```
  */
 class Position {
+    /** User holding this position. */
+    user;
+    /** Id of the market on which this position is held. */
+    marketId;
     /** User credit. */
     credit;
     /** Pending continuous fee. */
@@ -40,6 +46,8 @@ class Position {
     /** Collateral balances by index. */
     collateral;
     constructor(position) {
+        this.user = position.user;
+        this.marketId = position.marketId;
         this.credit = BigInt(position.credit);
         this.pendingFee = BigInt(position.pendingFee);
         this.lastLossFactor = BigInt(position.lastLossFactor);
@@ -57,6 +65,8 @@ class Position {
      * import { Position } from "@morpho-org/midnight-sdk";
      *
      * const position = new Position({
+     *   user: "0x0000000000000000000000000000000000009000",
+     *   marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *   credit: 1_000n,
      *   pendingFee: 100n,
      *   lastLossFactor: 0n,
@@ -97,6 +107,7 @@ exports.Position = Position;
  *
  * const position = new AccrualPosition(
  *   {
+ *     user: "0x0000000000000000000000000000000000009000",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -136,11 +147,74 @@ exports.Position = Position;
  * ```
  */
 class AccrualPosition extends Position {
-    /** Hydrated market for this position. */
-    market;
+    _market;
     constructor(position, market) {
-        super(position);
-        this.market = Market_js_1.Market.from(market);
+        const _market = Market_js_1.Market.from(market);
+        super({ ...position, marketId: _market.id });
+        this._market = _market;
+    }
+    /** Hydrated market for this position. */
+    get market() {
+        return this._market;
+    }
+    /**
+     * Returns the maximum credit units currently withdrawable from this position.
+     *
+     * The protocol capacity is limited by both the accrued position credit and
+     * the market's currently withdrawable liquidity. Default redemption flows may
+     * still choose the position face value.
+     *
+     * @returns Maximum credit units currently withdrawable.
+     * @example
+     * ```ts
+     * import { AccrualPosition } from "@morpho-org/midnight-sdk";
+     *
+     * const position = new AccrualPosition(
+     *   {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     credit: 1_000n,
+     *     pendingFee: 100n,
+     *     lastLossFactor: 0n,
+     *     lastAccrual: 1_000n,
+     *     debt: 0n,
+     *     collateralBitmap: 1n,
+     *     collateral: [50n],
+     *   },
+     *   {
+     *     params: {
+     *       chainId: 8453,
+     *       midnight: "0x0000000000000000000000000000000000001000",
+     *       loanToken: "0x0000000000000000000000000000000000006000",
+     *       collateralParams: [
+     *         {
+     *           token: "0x0000000000000000000000000000000000007000",
+     *           lltv: 770000000000000000n,
+     *           liquidationCursor: 250000000000000000n,
+     *           oracle: "0x0000000000000000000000000000000000008000",
+     *         },
+     *       ],
+     *       maturity: 54_000n,
+     *       rcfThreshold: 0n,
+     *       enterGate: "0x0000000000000000000000000000000000000000",
+     *       liquidatorGate: "0x0000000000000000000000000000000000000000",
+     *     },
+     *     totalUnits: 1_000n,
+     *     lossFactor: 0n,
+     *     withdrawable: 950n,
+     *     continuousFeeCredit: 0n,
+     *     settlementFeeCbps: [1, 2, 3, 4, 5, 6, 7],
+     *     continuousFee: 10,
+     *     tickSpacing: 4,
+     *   },
+     * );
+     * console.log(position.withdrawable); // 950n
+     * ```
+     */
+    get withdrawable() {
+        return PositionUtils_js_1.PositionUtils.getWithdrawable({
+            position: this,
+            market: this.market,
+        });
     }
     /**
      * Returns the position collateral balance at an index configured by the market.
@@ -168,6 +242,7 @@ class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -240,6 +315,7 @@ class AccrualPosition extends Position {
      * const collateralToken = "0x0000000000000000000000000000000000007000";
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -309,6 +385,7 @@ class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -380,6 +457,7 @@ class AccrualPosition extends Position {
      *
      * const position = new AccrualPosition(
      *   {
+     *     user: "0x0000000000000000000000000000000000009000",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,

package/lib/{esm/market → cjs/position}/PositionUtils.d.ts

@@ -1,5 +1,5 @@
 import { type BigIntish } from "@morpho-org/morpho-ts";
-import type { IMarket } from "./Market.js";
+import type { IMarket } from "../market/Market.js";
 import type { IPosition } from "./Position.js";
 /**
  * Domain helpers for Midnight positions.
@@ -10,6 +10,8 @@ import type { IPosition } from "./Position.js";
  *
  * const accrued = PositionUtils.accrueInterest({
  *   position: {
+ *     user: "0x0000000000000000000000000000000000009000",
+ *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -50,6 +52,27 @@ import type { IPosition } from "./Position.js";
  * ```
  */
 export declare namespace PositionUtils {
+    /**
+     * Returns the maximum credit units currently withdrawable by a position.
+     *
+     * @param params.position - Position whose credit limits the withdrawal.
+     * @param params.market - Market whose available liquidity limits the withdrawal.
+     * @returns The lower of the position credit and market withdrawable liquidity.
+     * @example
+     * ```ts
+     * import { PositionUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const withdrawable = PositionUtils.getWithdrawable({
+     *   position: { credit: 1_000n },
+     *   market: { withdrawable: 500n },
+     * });
+     * console.log(withdrawable); // 500n
+     * ```
+     */
+    function getWithdrawable(params: {
+        readonly position: Pick<IPosition, "credit">;
+        readonly market: Pick<IMarket, "withdrawable">;
+    }): bigint;
     /**
      * Returns plain Midnight position and market objects accrued like Midnight `updatePositionView`.
      *
@@ -66,6 +89,8 @@ export declare namespace PositionUtils {
      *
      * const { position, market } = PositionUtils.accrueInterest({
      *   position: {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,

package/lib/cjs/{market → position}/PositionUtils.js

@@ -12,6 +12,8 @@ const errors_js_1 = require("../errors.js");
  *
  * const accrued = PositionUtils.accrueInterest({
  *   position: {
+ *     user: "0x0000000000000000000000000000000000009000",
+ *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
  *     credit: 1_000n,
  *     pendingFee: 100n,
  *     lastLossFactor: 0n,
@@ -53,6 +55,27 @@ const errors_js_1 = require("../errors.js");
  */
 var PositionUtils;
 (function (PositionUtils) {
+    /**
+     * Returns the maximum credit units currently withdrawable by a position.
+     *
+     * @param params.position - Position whose credit limits the withdrawal.
+     * @param params.market - Market whose available liquidity limits the withdrawal.
+     * @returns The lower of the position credit and market withdrawable liquidity.
+     * @example
+     * ```ts
+     * import { PositionUtils } from "@morpho-org/midnight-sdk";
+     *
+     * const withdrawable = PositionUtils.getWithdrawable({
+     *   position: { credit: 1_000n },
+     *   market: { withdrawable: 500n },
+     * });
+     * console.log(withdrawable); // 500n
+     * ```
+     */
+    function getWithdrawable(params) {
+        return morpho_ts_1.MathLib.min(BigInt(params.position.credit), BigInt(params.market.withdrawable));
+    }
+    PositionUtils.getWithdrawable = getWithdrawable;
     /**
      * Returns plain Midnight position and market objects accrued like Midnight `updatePositionView`.
      *
@@ -69,6 +92,8 @@ var PositionUtils;
      *
      * const { position, market } = PositionUtils.accrueInterest({
      *   position: {
+     *     user: "0x0000000000000000000000000000000000009000",
+     *     marketId: "0x0000000000000000000000000000000000000000000000000000000000000001",
      *     credit: 1_000n,
      *     pendingFee: 100n,
      *     lastLossFactor: 0n,
@@ -172,6 +197,8 @@ var PositionUtils;
         ];
         return {
             position: {
+                user: params.position.user,
+                marketId: params.position.marketId,
                 credit: postSlashCredit - accruedFee,
                 pendingFee: postSlashPendingFee - accruedFee,
                 lastLossFactor: marketLossFactor,

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

@@ -0,0 +1,2 @@
+export * from "./Position.js";
+export * from "./PositionUtils.js";

package/lib/cjs/position/index.js

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

package/lib/cjs/signatures/RatifierUtils.js

@@ -18,17 +18,16 @@ function normalizeTree(tree) {
     if (isTreeLike(tree)) {
         return tree;
     }
-    const offers = tree.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
+    const entries = Array.isArray(tree) ? tree : [tree];
+    const offers = entries.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
         ? Group_js_1.Group.from(entry).offers
         : [
             new index_js_1.Offer({
                 ...index_js_1.Offer.from(entry),
-                group: index_js_1.OfferUtils.groupHash(entry),
+                group: GroupUtils_js_1.GroupUtils.hash([entry]),
             }),
         ]);
-    const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(offers, {
-        preserveStandaloneGroups: true,
-    });
+    const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(entries);
     return {
         offers,
         paddedOffers: descriptor.offers,

package/lib/cjs/signatures/Tree.d.ts

@@ -108,8 +108,9 @@ export declare class Tree {
      *
      * Use after `Offer.create` and optional `Group.create`, before
      * `Tree.mempoolValidate`, `EcrecoverRatifierUtils.ratify`, or
-     * `SetterRatifierUtils.ratify`. Groups are flattened; the tree hashes each
-     * offer with the group id already stored on the offer.
+     * `SetterRatifierUtils.ratify`. Groups are flattened, and every standalone
+     * offer is normalized as a singleton group using the router-compatible group
+     * id algorithm.
      *
      * @param params - Groups or standalone offers in leaf order.
      * @returns Tree instance.

package/lib/cjs/signatures/Tree.js

@@ -63,7 +63,7 @@ class Tree {
             : [
                 new index_js_1.Offer({
                     ...index_js_1.Offer.from(entry),
-                    group: index_js_1.OfferUtils.groupHash(entry),
+                    group: GroupUtils_js_1.GroupUtils.hash([entry]),
                 }),
             ]);
         const descriptor = TreeUtils_js_1.TreeUtils.buildDescriptor(params);
@@ -118,15 +118,18 @@ class Tree {
      * ```
      */
     static from(tree) {
-        return tree instanceof Tree ? tree : Tree.create(tree);
+        if (tree instanceof Tree)
+            return tree;
+        return Tree.create(Array.isArray(tree) ? tree : [tree]);
     }
     /**
      * Creates a tree from groups or standalone offers.
      *
      * Use after `Offer.create` and optional `Group.create`, before
      * `Tree.mempoolValidate`, `EcrecoverRatifierUtils.ratify`, or
-     * `SetterRatifierUtils.ratify`. Groups are flattened; the tree hashes each
-     * offer with the group id already stored on the offer.
+     * `SetterRatifierUtils.ratify`. Groups are flattened, and every standalone
+     * offer is normalized as a singleton group using the router-compatible group
+     * id algorithm.
      *
      * @param params - Groups or standalone offers in leaf order.
      * @returns Tree instance.

package/lib/cjs/signatures/TreeUtils.d.ts

@@ -188,7 +188,7 @@ export type TreeCreateParams = readonly GroupInput[];
  * console.log(tree);
  * ```
  */
-export type TreeInput = Tree | TreeCreateParams;
+export type TreeInput = Tree | TreeCreateParams | GroupInput;
 /**
  * Tree-shaped data required by ratifier helpers.
  *
@@ -284,7 +284,7 @@ export interface TreeLike {
  * console.log(tree);
  * ```
  */
-export type RatifierTreeInput = TreeLike | TreeCreateParams;
+export type RatifierTreeInput = TreeLike | TreeInput;
 /**
  * Optional ratification inputs for {@link Tree.mempoolValidate}.
  *
@@ -489,12 +489,11 @@ export declare namespace TreeUtils {
      * Use after `Group.create` or standalone `Offer.create` when you need the
      * padded leaves for custom signing, root approval, or proof construction.
      * Groups are encoded with their derived shared group id, and standalone
-     * offers are encoded with their own group id.
+     * offers are encoded as singleton groups with the same algorithm.
      * `Tree.create` calls this internally and is the simpler API for most
      * make-side code.
      *
      * @param entries - Groups or standalone offers in leaf order.
-     * @param options.preserveStandaloneGroups - Whether standalone offer group ids should be preserved instead of normalized.
      * @returns Tree descriptor.
      * @throws {InvalidTreeError} when the offer count is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the padded tree exceeds supported ratifier typehashes.
@@ -532,9 +531,7 @@ export declare namespace TreeUtils {
      * console.log(tree.root);
      * ```
      */
-    function buildDescriptor(entries: TreeCreateParams, options?: {
-        readonly preserveStandaloneGroups?: boolean;
-    }): TreeDescriptor;
+    function buildDescriptor(entries: TreeCreateParams): TreeDescriptor;
     /**
      * Builds only the tree root.
      *

package/lib/cjs/signatures/TreeUtils.js

@@ -38,6 +38,7 @@ function assertLeafOffers(offers, leafHashes) {
         }
         seen.add(leafHash);
     }
+    /* v8 ignore next: buildDescriptor rejects empty struct lists before padding; this protects direct internal misuse. */
     if (seen.size === 0) {
         throw new errors_js_1.InvalidTreeError("Tree must not be empty.");
     }
@@ -121,23 +122,30 @@ var TreeUtils;
     async function mempoolValidate(params) {
         let items;
         if (params.ratification == null) {
-            const offers = "paddedOffers" in params.tree
-                ? params.tree.offers
-                : params.tree.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
+            if ("paddedOffers" in params.tree) {
+                items = params.tree.offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
+            }
+            else {
+                const entries = Array.isArray(params.tree)
+                    ? params.tree
+                    : [params.tree];
+                const offers = entries.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
                     ? Group_js_1.Group.from(entry).offers
                     : [
                         new index_js_1.Offer({
                             ...index_js_1.Offer.from(entry),
-                            group: index_js_1.OfferUtils.groupHash(entry),
+                            group: GroupUtils_js_1.GroupUtils.hash([entry]),
                         }),
                     ]);
-            if (!("paddedOffers" in params.tree)) {
-                buildDescriptor(offers, { preserveStandaloneGroups: true });
+                buildDescriptor(entries);
+                items = offers.map((offer) => ({
+                    offer,
+                    ratifierData: "0x",
+                }));
             }
-            items = offers.map((offer) => ({
-                offer,
-                ratifierData: "0x",
-            }));
         }
         else if (params.ratification.type === "ecrecover") {
             if (params.ratification.signature != null) {
@@ -201,12 +209,11 @@ var TreeUtils;
      * Use after `Group.create` or standalone `Offer.create` when you need the
      * padded leaves for custom signing, root approval, or proof construction.
      * Groups are encoded with their derived shared group id, and standalone
-     * offers are encoded with their own group id.
+     * offers are encoded as singleton groups with the same algorithm.
      * `Tree.create` calls this internally and is the simpler API for most
      * make-side code.
      *
      * @param entries - Groups or standalone offers in leaf order.
-     * @param options.preserveStandaloneGroups - Whether standalone offer group ids should be preserved instead of normalized.
      * @returns Tree descriptor.
      * @throws {InvalidTreeError} when the offer count is empty, all padding, or duplicated.
      * @throws {InvalidTreeHeightError} when the padded tree exceeds supported ratifier typehashes.
@@ -244,15 +251,13 @@ var TreeUtils;
      * console.log(tree.root);
      * ```
      */
-    function buildDescriptor(entries, options = {}) {
+    function buildDescriptor(entries) {
         const structs = entries.flatMap((entry) => GroupUtils_js_1.GroupUtils.isGroupInput(entry)
             ? GroupUtils_js_1.GroupUtils.toStructs(entry)
             : [
                 index_js_1.OfferUtils.toStruct({
                     offer: entry,
-                    group: options.preserveStandaloneGroups
-                        ? undefined
-                        : index_js_1.OfferUtils.groupHash(entry),
+                    group: GroupUtils_js_1.GroupUtils.hash([entry]),
                 }),
             ]);
         if (structs.length === 0) {
@@ -262,6 +267,7 @@ var TreeUtils;
         const leaves = offerStructs.map(index_js_1.OfferUtils.hashStruct);
         assertLeafOffers(offerStructs, leaves);
         const height = Math.log2(offerStructs.length);
+        /* v8 ignore next: exercising this branch would require allocating more than 2^20 offer structs. */
         if (height > 20)
             throw new errors_js_1.InvalidTreeHeightError(height);
         let level = [...leaves];

package/lib/esm/api/helpers.js

@@ -2,10 +2,8 @@ import { BLUE_API_BASE_URL, isHexEqual } from "@morpho-org/morpho-ts";
 import { isAddressEqual } from "viem";
 import { InvalidMidnightApiResponseError, MidnightApiError, } from "../errors.js";
 import { MarketUtils } from "../market/index.js";
+import { MIDNIGHT_SDK_VERSION } from "./version.generated.js";
 const DEFAULT_MIDNIGHT_API_URL = new URL("/v0/midnight", BLUE_API_BASE_URL);
-// Keep this literal in source so the browser ESM build does not import package.json
-// through Node-only createRequire/module shims.
-const MIDNIGHT_SDK_VERSION = "1.0.1";
 /** @internal Sends one Midnight API request and maps non-2xx responses to SDK errors. */
 export async function requestMidnightApi(params) {
     const baseUrl = new URL(params.baseUrl ?? DEFAULT_MIDNIGHT_API_URL);

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

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

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

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

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

@@ -1,5 +1,5 @@
 import type { Address, Client, Hash } from "viem";
-import { AccrualPosition, Position } from "../market/index.js";
+import { AccrualPosition, Position } from "../position/index.js";
 import type { MidnightFetchParams } from "./types.js";
 /**
  * Fetches a Midnight position by id and user.

package/lib/esm/fetch/Position.js

@@ -2,7 +2,7 @@ import { getChainAddress } from "@morpho-org/morpho-ts";
 import { readContract } from "viem/actions";
 import { midnightAbi } from "../abis.js";
 import { MAX_COLLATERALS } from "../constants.js";
-import { AccrualPosition, Position } from "../market/index.js";
+import { AccrualPosition, Position } from "../position/index.js";
 import { abi as getPositionAbi, code as getPositionCode, } from "../queries/GetPosition.js";
 import { fetchMarket } from "./Market.js";
 import { callParameters, resolveChainId, shouldUseDeployless, } from "./utils.js";
@@ -60,6 +60,8 @@ export async function fetchPosition(client, params) {
             });
             const collateral = position.collateral;
             return new Position({
+                user: params.user,
+                marketId: params.marketId,
                 credit: position.credit,
                 pendingFee: position.pendingFee,
                 lastLossFactor: position.lastLossFactor,
@@ -92,6 +94,8 @@ export async function fetchPosition(client, params) {
         });
     }));
     return new Position({
+        user: params.user,
+        marketId: params.marketId,
         credit: position[0],
         pendingFee: position[1],
         lastLossFactor: position[2],

package/lib/esm/index.d.ts

@@ -5,6 +5,7 @@ export * from "./fetch/index.js";
 export * from "./market/index.js";
 export * from "./math/index.js";
 export * from "./offers/index.js";
+export * from "./position/index.js";
 export * from "./signatures/index.js";
 /**
  * Namespace for Midnight mempool payload utilities.

package/lib/esm/index.js

@@ -5,6 +5,7 @@ export * from "./fetch/index.js";
 export * from "./market/index.js";
 export * from "./math/index.js";
 export * from "./offers/index.js";
+export * from "./position/index.js";
 export * from "./signatures/index.js";
 /**
  * Namespace for Midnight mempool payload utilities.

package/lib/esm/market/index.d.ts

@@ -1,4 +1,2 @@
 export * from "./Market.js";
 export * from "./MarketUtils.js";
-export * from "./Position.js";
-export * from "./PositionUtils.js";

package/lib/esm/market/index.js

@@ -1,4 +1,2 @@
 export * from "./Market.js";
 export * from "./MarketUtils.js";
-export * from "./Position.js";
-export * from "./PositionUtils.js";

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

@@ -9,9 +9,9 @@ import { type IMarket, type IMarketParams, Market, MarketParams } from "../marke
  * take-side conversion helpers. Use {@link Offer.create} instead for new maker
  * offers so deterministic fields are validated before grouping or signing.
  * The `group` field is optional. When omitted, {@link Offer.group} lazily
- * derives the standalone group id from this offer hashed with the protocol
- * zero group id. `Group.create` copies offers into a shared group and overrides
- * this field on the copies it owns.
+ * derives the content-addressed singleton group id from this offer's
+ * zero-group hash. `Group.create` copies offers into a shared group and
+ * overrides this field on the copies it owns.
  *
  * @example
  * ```ts
@@ -64,7 +64,7 @@ export interface IOffer {
     readonly expiry: BigIntish;
     /** Midnight tick. */
     readonly tick: BigIntish;
-    /** Consumption group id; defaults to the offer hash with the zero group id. */
+    /** Consumption group id; defaults to the content-addressed singleton group id. */
     readonly group?: Hash;
     /** Optional maker callback. */
     readonly callback: Address;
@@ -90,10 +90,11 @@ export interface IOffer {
  * `Group.create` for shared-consumption ladders or directly to `Tree.create`
  * for standalone offers. API/take-side code can convert a plain `IOffer`
  * into this class before ABI encoding. The class resolves the onchain `group`
- * field lazily. Standalone offers derive their group id from the offer hash
- * with the zero group id; `Group.create` copies offers and overrides the group
- * on those copies when several offers share one consumption bucket. Offers
- * hydrated from API or decoded data may also carry a known group id.
+ * field lazily. Standalone offers derive their content-addressed singleton
+ * group id from the offer's zero-group hash; `Group.create` copies offers and
+ * overrides the group on those copies when several offers share one
+ * consumption bucket. Offers hydrated from API or decoded data may also carry
+ * a known group id.
  *
  * @example
  * ```ts
@@ -220,8 +221,11 @@ export declare class Offer {
      * Consumption group id encoded into this offer.
      *
      * When no group id was provided, the value is computed on first access by
-     * hashing this offer with the protocol zero group id. The computed value is
-     * cached because offer hashing is resource-intensive.
+     * hashing this offer with the protocol zero group id, then hashing that
+     * result as a singleton group. The computed value is cached because offer
+     * hashing is resource-intensive. This is equivalent to
+     * `GroupUtils.hash([offer])`, but is computed directly to keep the offers
+     * layer from importing signature helpers and creating a circular dependency.
      *
      * @returns Consumption group id.
      * @example