@morpho-org/midnight-sdk 0.1.0

package/lib/esm/signatures/Group.d.ts

@@ -0,0 +1,178 @@
+import type { Hash } from "viem";
+import { type IOffer, Offer } from "../offers/index.js";
+import { type GroupInput, type IGroup } from "./GroupUtils.js";
+/**
+ * Protocol offer group with one shared consumption group id.
+ *
+ * Create a group after building related offers and before building the tree to
+ * publish. Offers inside one group must share maker, side, and loan token. The
+ * constructor hashes every offer to derive the group id, then copies each offer
+ * with that id. Offers inside one group must also share cap mode and value
+ * because Midnight tracks one consumed scalar per maker and group; group
+ * creation is resource-intensive compared to offer construction.
+ *
+ * @example
+ * ```ts
+ * import { Group, Offer } from "@morpho-org/midnight-sdk";
+ * import { zeroAddress } from "viem";
+ *
+ * const offer = Offer.create({
+ *   market: {
+ *     loanToken: "0x0000000000000000000000000000000000006000",
+ *     collateralParams: [
+ *       {
+ *         token: "0x0000000000000000000000000000000000007000",
+ *         lltv: 770000000000000000n,
+ *         maxLif: 1061007957559681697n,
+ *         oracle: "0x0000000000000000000000000000000000008000",
+ *       },
+ *     ],
+ *     maturity: 54_000n,
+ *     rcfThreshold: 0n,
+ *     enterGate: zeroAddress,
+ *     liquidatorGate: zeroAddress,
+ *   },
+ *   buy: true,
+ *   maker: "0x0000000000000000000000000000000000009000",
+ *   tick: 5_000n,
+ *   expiry: 3_600n,
+ *   ratifier: "0x0000000000000000000000000000000000004000",
+ *   maxUnits: 100n,
+ * });
+ * const group = Group.create([offer]);
+ * console.log(group.offers.length);
+ * ```
+ */
+export declare class Group implements IGroup {
+    private readonly _offers;
+    /** Content-addressed group id. */
+    readonly id: Hash;
+    private constructor();
+    /**
+     * Offers in this protocol group.
+     *
+     * Returns a fresh array so callers cannot mutate the group's offer list.
+     *
+     * @returns Offers in caller order.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.create([offer]);
+     * console.log(group.offers.length);
+     * ```
+     */
+    get offers(): readonly Offer[];
+    /**
+     * Returns a group instance from group or standalone offer input.
+     *
+     * Use at boundaries that accept either a prebuilt `Group`, a plain `IGroup`,
+     * or a standalone offer that should form its own group. Existing `Group`
+     * instances are returned as-is.
+     *
+     * @param entry - Group object or standalone offer.
+     * @returns Group instance.
+     * @throws {InvalidOfferGroupError} when group mechanics are invalid.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.from(offer);
+     * console.log(group.offers.length);
+     * ```
+     */
+    static from(entry: GroupInput): Group;
+    /**
+     * Creates a protocol-valid offer group.
+     *
+     * Use after `Offer.create` for laddered offers with the same cap mode and
+     * value that should consume from one group id. Pass the returned group into
+     * `Tree.create` alongside other groups or standalone offers. This hashes every
+     * offer and copies the validated offers into group-owned instances, so it is
+     * resource-intensive and should be done once per group definition.
+     *
+     * @param offers - Iterable of offers to group.
+     * @returns Group instance.
+     * @throws {InvalidOfferGroupError} when group mechanics are invalid.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.create([offer]);
+     * console.log(group.offers.length);
+     * ```
+     */
+    static create(offers: Iterable<IOffer>): Group;
+}

package/lib/esm/signatures/Group.js

@@ -0,0 +1,189 @@
+import { Offer, OfferUtils } from "../offers/index.js";
+import { GroupUtils } from "./GroupUtils.js";
+/**
+ * Protocol offer group with one shared consumption group id.
+ *
+ * Create a group after building related offers and before building the tree to
+ * publish. Offers inside one group must share maker, side, and loan token. The
+ * constructor hashes every offer to derive the group id, then copies each offer
+ * with that id. Offers inside one group must also share cap mode and value
+ * because Midnight tracks one consumed scalar per maker and group; group
+ * creation is resource-intensive compared to offer construction.
+ *
+ * @example
+ * ```ts
+ * import { Group, Offer } from "@morpho-org/midnight-sdk";
+ * import { zeroAddress } from "viem";
+ *
+ * const offer = Offer.create({
+ *   market: {
+ *     loanToken: "0x0000000000000000000000000000000000006000",
+ *     collateralParams: [
+ *       {
+ *         token: "0x0000000000000000000000000000000000007000",
+ *         lltv: 770000000000000000n,
+ *         maxLif: 1061007957559681697n,
+ *         oracle: "0x0000000000000000000000000000000000008000",
+ *       },
+ *     ],
+ *     maturity: 54_000n,
+ *     rcfThreshold: 0n,
+ *     enterGate: zeroAddress,
+ *     liquidatorGate: zeroAddress,
+ *   },
+ *   buy: true,
+ *   maker: "0x0000000000000000000000000000000000009000",
+ *   tick: 5_000n,
+ *   expiry: 3_600n,
+ *   ratifier: "0x0000000000000000000000000000000000004000",
+ *   maxUnits: 100n,
+ * });
+ * const group = Group.create([offer]);
+ * console.log(group.offers.length);
+ * ```
+ */
+export class Group {
+    _offers;
+    /** Content-addressed group id. */
+    id;
+    constructor(offers) {
+        const validatedOffers = OfferUtils.validateOfferGroup({ offers });
+        this.id = GroupUtils.hash(validatedOffers);
+        this._offers = validatedOffers.map((offer) => new Offer({ ...offer, group: this.id }));
+    }
+    /**
+     * Offers in this protocol group.
+     *
+     * Returns a fresh array so callers cannot mutate the group's offer list.
+     *
+     * @returns Offers in caller order.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.create([offer]);
+     * console.log(group.offers.length);
+     * ```
+     */
+    get offers() {
+        return [...this._offers];
+    }
+    /**
+     * Returns a group instance from group or standalone offer input.
+     *
+     * Use at boundaries that accept either a prebuilt `Group`, a plain `IGroup`,
+     * or a standalone offer that should form its own group. Existing `Group`
+     * instances are returned as-is.
+     *
+     * @param entry - Group object or standalone offer.
+     * @returns Group instance.
+     * @throws {InvalidOfferGroupError} when group mechanics are invalid.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.from(offer);
+     * console.log(group.offers.length);
+     * ```
+     */
+    static from(entry) {
+        return entry instanceof Group
+            ? entry
+            : new Group("offers" in entry ? entry.offers : [entry]);
+    }
+    /**
+     * Creates a protocol-valid offer group.
+     *
+     * Use after `Offer.create` for laddered offers with the same cap mode and
+     * value that should consume from one group id. Pass the returned group into
+     * `Tree.create` alongside other groups or standalone offers. This hashes every
+     * offer and copies the validated offers into group-owned instances, so it is
+     * resource-intensive and should be done once per group definition.
+     *
+     * @param offers - Iterable of offers to group.
+     * @returns Group instance.
+     * @throws {InvalidOfferGroupError} when group mechanics are invalid.
+     * @example
+     * ```ts
+     * import { Group, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const group = Group.create([offer]);
+     * console.log(group.offers.length);
+     * ```
+     */
+    static create(offers) {
+        return new Group(offers);
+    }
+}

package/lib/esm/signatures/GroupUtils.d.ts

@@ -0,0 +1,191 @@
+import { type Hash } from "viem";
+import { type IOffer, type OfferStruct } from "../offers/index.js";
+/**
+ * Plain offer group shape accepted by group and tree utilities.
+ *
+ * @example
+ * ```ts
+ * import { Offer, type IGroup } from "@morpho-org/midnight-sdk";
+ * import { zeroAddress } from "viem";
+ *
+ * const group: IGroup = {
+ *   offers: [
+ *     Offer.create({
+ *       market: {
+ *         loanToken: "0x0000000000000000000000000000000000006000",
+ *         collateralParams: [
+ *           {
+ *             token: "0x0000000000000000000000000000000000007000",
+ *             lltv: 770000000000000000n,
+ *             maxLif: 1061007957559681697n,
+ *             oracle: "0x0000000000000000000000000000000000008000",
+ *           },
+ *         ],
+ *         maturity: 54_000n,
+ *         rcfThreshold: 0n,
+ *         enterGate: zeroAddress,
+ *         liquidatorGate: zeroAddress,
+ *       },
+ *       buy: true,
+ *       maker: "0x0000000000000000000000000000000000009000",
+ *       tick: 5_000n,
+ *       group: zeroHash,
+ *       expiry: 3_600n,
+ *       ratifier: "0x0000000000000000000000000000000000004000",
+ *       maxUnits: 100n,
+ *     }),
+ *   ],
+ * };
+ * console.log(group.offers.length);
+ * ```
+ */
+export interface IGroup {
+    /** Offers in this protocol group. The group id is derived from this list. */
+    readonly offers: readonly IOffer[];
+}
+/**
+ * Group object or standalone offer accepted by tree helpers.
+ *
+ * Use standalone offers for independent consumption groups. Use `Group.create`
+ * first when multiple offers from the same maker, side, loan token, cap mode,
+ * and cap value should share one consumption group.
+ *
+ * @example
+ * ```ts
+ * import { Offer, type GroupInput } from "@morpho-org/midnight-sdk";
+ * import { zeroAddress } from "viem";
+ *
+ * const input: GroupInput = Offer.create({
+ *   market: {
+ *     loanToken: "0x0000000000000000000000000000000000006000",
+ *     collateralParams: [
+ *       {
+ *         token: "0x0000000000000000000000000000000000007000",
+ *         lltv: 770000000000000000n,
+ *         maxLif: 1061007957559681697n,
+ *         oracle: "0x0000000000000000000000000000000000008000",
+ *       },
+ *     ],
+ *     maturity: 54_000n,
+ *     rcfThreshold: 0n,
+ *     enterGate: zeroAddress,
+ *     liquidatorGate: zeroAddress,
+ *   },
+ *   buy: true,
+ *   maker: "0x0000000000000000000000000000000000009000",
+ *   tick: 5_000n,
+ *   expiry: 3_600n,
+ *   ratifier: "0x0000000000000000000000000000000000004000",
+ *   maxUnits: 100n,
+ * });
+ * console.log(input);
+ * ```
+ */
+export type GroupInput = IGroup | IOffer;
+/**
+ * Make-side helpers for Midnight offer groups.
+ *
+ * Groups sit between `Offer.create` and `Tree.create`: they assign a
+ * content-addressed group id to offers that share one consumption bucket. One
+ * group must use one cap mode and value because Midnight tracks a single
+ * consumed scalar per maker and group. Tree helpers derive that id for explicit
+ * groups and preserve it on grouped offer copies.
+ *
+ * @example
+ * ```ts
+ * import { GroupUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof GroupUtils.hash);
+ * ```
+ */
+export declare namespace GroupUtils {
+    /**
+     * Derives the deterministic content-addressed id for a group of offers.
+     *
+     * This mirrors the router implementation: hash each offer with `group = 0`,
+     * sort those hashes, concatenate them, then keccak the result.
+     *
+     * @param offers - Offers to hash as one group.
+     * @returns Content-addressed group id.
+     * @throws {InvalidOfferGroupError} when `offers` is empty.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const id = GroupUtils.hash([offer]);
+     * console.log(id);
+     * ```
+     */
+    function hash(offers: Iterable<IOffer>): Hash;
+    /**
+     * Converts a group into ABI-compatible offers carrying the derived group id.
+     *
+     * Use after `Group.create` for custom encoders that need offer structs with
+     * their final group id. The id is derived from the full offer list and
+     * applied while encoding, so plain groups cannot drift from offer fields.
+     *
+     * This helper is encode-only and does not validate protocol group mechanics.
+     * Validate with `Group.create` or {@link OfferUtils.validateOfferGroup}
+     * before relying on the output for signing, tree roots, or calldata.
+     *
+     * @param group - Group to encode.
+     * @returns ABI-compatible offers in caller order.
+     * @throws {InvalidOfferGroupError} when the group has no offers.
+     * @example
+     * ```ts
+     * import { Group, GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const structs = GroupUtils.toStructs(Group.create([offer]));
+     * console.log(structs.length);
+     * ```
+     */
+    function toStructs(group: IGroup): readonly OfferStruct[];
+}

package/lib/esm/signatures/GroupUtils.js

@@ -0,0 +1,124 @@
+import { concat, keccak256 } from "viem";
+import { InvalidOfferGroupError } from "../errors.js";
+import { OfferUtils } from "../offers/index.js";
+/**
+ * Make-side helpers for Midnight offer groups.
+ *
+ * Groups sit between `Offer.create` and `Tree.create`: they assign a
+ * content-addressed group id to offers that share one consumption bucket. One
+ * group must use one cap mode and value because Midnight tracks a single
+ * consumed scalar per maker and group. Tree helpers derive that id for explicit
+ * groups and preserve it on grouped offer copies.
+ *
+ * @example
+ * ```ts
+ * import { GroupUtils } from "@morpho-org/midnight-sdk";
+ *
+ * console.log(typeof GroupUtils.hash);
+ * ```
+ */
+export var GroupUtils;
+(function (GroupUtils) {
+    /**
+     * Derives the deterministic content-addressed id for a group of offers.
+     *
+     * This mirrors the router implementation: hash each offer with `group = 0`,
+     * sort those hashes, concatenate them, then keccak the result.
+     *
+     * @param offers - Offers to hash as one group.
+     * @returns Content-addressed group id.
+     * @throws {InvalidOfferGroupError} when `offers` is empty.
+     * @example
+     * ```ts
+     * import { GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const id = GroupUtils.hash([offer]);
+     * console.log(id);
+     * ```
+     */
+    function hash(offers) {
+        const offerInputs = Array.from(offers);
+        if (offerInputs.length === 0) {
+            throw new InvalidOfferGroupError("Provide at least one offer in the group.");
+        }
+        const offerHashes = offerInputs.map((offer) => OfferUtils.groupHash(offer));
+        const sorted = offerHashes.length > 1 ? [...offerHashes].sort() : offerHashes;
+        return keccak256(concat(sorted));
+    }
+    GroupUtils.hash = hash;
+    /**
+     * Converts a group into ABI-compatible offers carrying the derived group id.
+     *
+     * Use after `Group.create` for custom encoders that need offer structs with
+     * their final group id. The id is derived from the full offer list and
+     * applied while encoding, so plain groups cannot drift from offer fields.
+     *
+     * This helper is encode-only and does not validate protocol group mechanics.
+     * Validate with `Group.create` or {@link OfferUtils.validateOfferGroup}
+     * before relying on the output for signing, tree roots, or calldata.
+     *
+     * @param group - Group to encode.
+     * @returns ABI-compatible offers in caller order.
+     * @throws {InvalidOfferGroupError} when the group has no offers.
+     * @example
+     * ```ts
+     * import { Group, GroupUtils, Offer } from "@morpho-org/midnight-sdk";
+     * import { zeroAddress } from "viem";
+     *
+     * const offer = Offer.create({
+     *   market: {
+     *     loanToken: "0x0000000000000000000000000000000000006000",
+     *     collateralParams: [
+     *       {
+     *         token: "0x0000000000000000000000000000000000007000",
+     *         lltv: 770000000000000000n,
+     *         maxLif: 1061007957559681697n,
+     *         oracle: "0x0000000000000000000000000000000000008000",
+     *       },
+     *     ],
+     *     maturity: 54_000n,
+     *     rcfThreshold: 0n,
+     *     enterGate: zeroAddress,
+     *     liquidatorGate: zeroAddress,
+     *   },
+     *   buy: true,
+     *   maker: "0x0000000000000000000000000000000000009000",
+     *   tick: 5_000n,
+     *   expiry: 3_600n,
+     *   ratifier: "0x0000000000000000000000000000000000004000",
+     *   maxUnits: 100n,
+     * });
+     * const structs = GroupUtils.toStructs(Group.create([offer]));
+     * console.log(structs.length);
+     * ```
+     */
+    function toStructs(group) {
+        const groupId = hash(group.offers);
+        return group.offers.map((offer) => OfferUtils.toStruct({ offer, group: groupId }));
+    }
+    GroupUtils.toStructs = toStructs;
+})(GroupUtils || (GroupUtils = {}));