@morpho-org/midnight-sdk 0.1.0

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

@@ -0,0 +1,85 @@
+import type { Address, Client, Hash } from "viem";
+import { AccrualPosition, Position } from "../market/index.js";
+import type { MidnightFetchParams } from "./types.js";
+/**
+ * Fetches a Midnight position by id and user.
+ *
+ * The Solidity storage getter does not return the fixed collateral array, so
+ * this helper reads each collateral slot before returning the position.
+ * The deployless path is used by default. If deployless is disabled or
+ * unavailable, the direct fallback can fan out to 130 RPC calls unless the viem
+ * client has `batch.multicall` enabled.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id. In
+ * deployless mode, reads the deployless `GetPosition.query(midnight, marketId,
+ * user)` helper. If deployless is disabled or falls back, reads
+ * `Midnight.position(marketId, user)` and each
+ * `Midnight.collateral(marketId, user, index)` slot for `index` 0 through 127.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose position to read.
+ * @param params.user - Position owner address.
+ * @param params.deployless - Optional deployless mode; defaults to `true` with fallback, or `"force"` without fallback.
+ * @param params.account - Optional account used as the `from` field for the reads.
+ * @param params.blockNumber - Optional block number used for the reads.
+ * @param params.blockTag - Optional block tag used for the reads.
+ * @param params.stateOverride - Optional state override set used for the reads.
+ * @returns Normalized position object.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchPosition } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const position = await fetchPosition(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   user: "0x0000000000000000000000000000000000009000",
+ * });
+ * console.log(position.debt);
+ * ```
+ */
+export declare function fetchPosition(client: Client, params: MidnightFetchParams & {
+    readonly marketId: Hash;
+    readonly user: Address;
+}): Promise<Position>;
+/**
+ * Fetches a Midnight position paired with its hydrated market.
+ *
+ * Reads the full inventory of `fetchPosition` and `fetchMarket` at the same
+ * call parameters: `eth_chainId` only when needed,
+ * `Midnight.toMarket(marketId)`, `Midnight.marketState(marketId)`, and either
+ * deployless `GetPosition.query(midnight, marketId, user)` or direct
+ * `Midnight.position(marketId, user)` plus all collateral slots.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose position and market state to read.
+ * @param params.user - Position owner address.
+ * @param params.deployless - Optional deployless mode for the position read; defaults to `true` with fallback, or `"force"` without fallback.
+ * @param params.account - Optional account used as the `from` field for the reads.
+ * @param params.blockNumber - Optional block number used for the reads.
+ * @param params.blockTag - Optional block tag used for the reads.
+ * @param params.stateOverride - Optional state override set used for the reads.
+ * @returns Accrual position instance.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchAccrualPosition } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const position = await fetchAccrualPosition(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   user: "0x0000000000000000000000000000000000009000",
+ * });
+ * console.log(position.market.id);
+ * ```
+ */
+export declare function fetchAccrualPosition(client: Client, params: MidnightFetchParams & {
+    readonly marketId: Hash;
+    readonly user: Address;
+}): Promise<AccrualPosition>;

package/lib/cjs/fetch/Position.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPosition = fetchPosition;
+exports.fetchAccrualPosition = fetchAccrualPosition;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const actions_1 = require("viem/actions");
+const abis_js_1 = require("../abis.js");
+const constants_js_1 = require("../constants.js");
+const index_js_1 = require("../market/index.js");
+const GetPosition_js_1 = require("../queries/GetPosition.js");
+const Market_js_1 = require("./Market.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Fetches a Midnight position by id and user.
+ *
+ * The Solidity storage getter does not return the fixed collateral array, so
+ * this helper reads each collateral slot before returning the position.
+ * The deployless path is used by default. If deployless is disabled or
+ * unavailable, the direct fallback can fan out to 130 RPC calls unless the viem
+ * client has `batch.multicall` enabled.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id. In
+ * deployless mode, reads the deployless `GetPosition.query(midnight, marketId,
+ * user)` helper. If deployless is disabled or falls back, reads
+ * `Midnight.position(marketId, user)` and each
+ * `Midnight.collateral(marketId, user, index)` slot for `index` 0 through 127.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose position to read.
+ * @param params.user - Position owner address.
+ * @param params.deployless - Optional deployless mode; defaults to `true` with fallback, or `"force"` without fallback.
+ * @param params.account - Optional account used as the `from` field for the reads.
+ * @param params.blockNumber - Optional block number used for the reads.
+ * @param params.blockTag - Optional block tag used for the reads.
+ * @param params.stateOverride - Optional state override set used for the reads.
+ * @returns Normalized position object.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchPosition } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const position = await fetchPosition(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   user: "0x0000000000000000000000000000000000009000",
+ * });
+ * console.log(position.debt);
+ * ```
+ */
+async function fetchPosition(client, params) {
+    const chainId = await (0, utils_js_1.resolveChainId)(client);
+    const midnight = (0, morpho_ts_1.getChainAddress)(chainId, "midnight");
+    if ((0, utils_js_1.shouldUseDeployless)(params)) {
+        try {
+            const position = await (0, actions_1.readContract)(client, {
+                ...(0, utils_js_1.callParameters)(params),
+                abi: GetPosition_js_1.abi,
+                code: GetPosition_js_1.code,
+                functionName: "query",
+                args: [midnight, params.marketId, params.user],
+            });
+            const collateral = position.collateral;
+            return new index_js_1.Position({
+                credit: position.credit,
+                pendingFee: position.pendingFee,
+                lastLossFactor: position.lastLossFactor,
+                lastAccrual: position.lastAccrual,
+                debt: position.debt,
+                collateralBitmap: position.collateralBitmap,
+                collateral: collateral.map((assets) => BigInt(assets)),
+            });
+        }
+        catch (error) {
+            if (params.deployless === "force")
+                throw error;
+            // Fallback to direct reads if deployless execution is unavailable.
+        }
+    }
+    const position = await (0, actions_1.readContract)(client, {
+        ...(0, utils_js_1.callParameters)(params),
+        address: midnight,
+        abi: abis_js_1.midnightAbi,
+        functionName: "position",
+        args: [params.marketId, params.user],
+    });
+    const collateral = await Promise.all(Array.from({ length: Number(constants_js_1.MAX_COLLATERALS) }, (_, collateralIndex) => {
+        return (0, actions_1.readContract)(client, {
+            ...(0, utils_js_1.callParameters)(params),
+            address: midnight,
+            abi: abis_js_1.midnightAbi,
+            functionName: "collateral",
+            args: [params.marketId, params.user, BigInt(collateralIndex)],
+        });
+    }));
+    return new index_js_1.Position({
+        credit: position[0],
+        pendingFee: position[1],
+        lastLossFactor: position[2],
+        lastAccrual: position[3],
+        debt: position[4],
+        collateralBitmap: position[5],
+        collateral: [...collateral],
+    });
+}
+/**
+ * Fetches a Midnight position paired with its hydrated market.
+ *
+ * Reads the full inventory of `fetchPosition` and `fetchMarket` at the same
+ * call parameters: `eth_chainId` only when needed,
+ * `Midnight.toMarket(marketId)`, `Midnight.marketState(marketId)`, and either
+ * deployless `GetPosition.query(midnight, marketId, user)` or direct
+ * `Midnight.position(marketId, user)` plus all collateral slots.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose position and market state to read.
+ * @param params.user - Position owner address.
+ * @param params.deployless - Optional deployless mode for the position read; defaults to `true` with fallback, or `"force"` without fallback.
+ * @param params.account - Optional account used as the `from` field for the reads.
+ * @param params.blockNumber - Optional block number used for the reads.
+ * @param params.blockTag - Optional block tag used for the reads.
+ * @param params.stateOverride - Optional state override set used for the reads.
+ * @returns Accrual position instance.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no Midnight address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchAccrualPosition } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const position = await fetchAccrualPosition(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   user: "0x0000000000000000000000000000000000009000",
+ * });
+ * console.log(position.market.id);
+ * ```
+ */
+async function fetchAccrualPosition(client, params) {
+    const [position, market] = await Promise.all([
+        fetchPosition(client, params),
+        (0, Market_js_1.fetchMarket)(client, params),
+    ]);
+    return new index_js_1.AccrualPosition(position, market);
+}

package/lib/cjs/fetch/Ratifier.d.ts

@@ -0,0 +1,38 @@
+import type { Address, Client } from "viem";
+import { type RatifierInfo } from "../signatures/RatifierUtils.js";
+import type { MidnightCallParameters } from "./types.js";
+/**
+ * Fetches maker bytecode and classifies the ratifier route for new offers.
+ *
+ * The `bytecode` read is the result of `eth_getCode` for `params.maker` at the
+ * requested block. It is not returned to callers; it only tells the SDK whether
+ * the maker is an EOA or EIP-7702 account that can use Ecrecover signatures, or
+ * a deployed-code account that should use Setter root approval. Put the returned
+ * `ratifier` address on `Offer.create`, then use the returned `type` to choose
+ * `EcrecoverRatifierUtils.ratify` or `SetterRatifierUtils.ratify` after the tree
+ * has been built.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `eth_getCode` for `params.maker`.
+ *
+ * @param client - Viem client used for the bytecode read.
+ * @param params.maker - Maker address whose bytecode determines the ratifier route.
+ * @param params.blockNumber - Optional block number used for the bytecode read.
+ * @param params.blockTag - Optional block tag used for the bytecode read.
+ * @returns Ratifier information.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no configured ratifier address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchRatifierInfo } from "@morpho-org/midnight-sdk";
+ *
+ * const maker = "0x7b093658BE7f90B63D7c359e8f408e503c2D9401";
+ * const info = await fetchRatifierInfo(client, { maker });
+ * // Pass info.ratifier to Offer.create(...), then use info.type after
+ * // Tree.create([...]) to choose the Ecrecover or Setter ratifier flow.
+ * console.log(info.type, info.ratifier);
+ * ```
+ */
+export declare function fetchRatifierInfo(client: Client, params: {
+    readonly maker: Address;
+} & MidnightCallParameters): Promise<RatifierInfo>;

package/lib/cjs/fetch/Ratifier.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRatifierInfo = fetchRatifierInfo;
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const actions_1 = require("viem/actions");
+const RatifierUtils_js_1 = require("../signatures/RatifierUtils.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Fetches maker bytecode and classifies the ratifier route for new offers.
+ *
+ * The `bytecode` read is the result of `eth_getCode` for `params.maker` at the
+ * requested block. It is not returned to callers; it only tells the SDK whether
+ * the maker is an EOA or EIP-7702 account that can use Ecrecover signatures, or
+ * a deployed-code account that should use Setter root approval. Put the returned
+ * `ratifier` address on `Offer.create`, then use the returned `type` to choose
+ * `EcrecoverRatifierUtils.ratify` or `SetterRatifierUtils.ratify` after the tree
+ * has been built.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `eth_getCode` for `params.maker`.
+ *
+ * @param client - Viem client used for the bytecode read.
+ * @param params.maker - Maker address whose bytecode determines the ratifier route.
+ * @param params.blockNumber - Optional block number used for the bytecode read.
+ * @param params.blockTag - Optional block tag used for the bytecode read.
+ * @returns Ratifier information.
+ * @throws {UnsupportedChainIdError} when no address registry exists for the client chain id.
+ * @throws {UnknownAddressError} when the registry has no configured ratifier address for the client chain id.
+ * @example
+ * ```ts
+ * import { fetchRatifierInfo } from "@morpho-org/midnight-sdk";
+ *
+ * const maker = "0x7b093658BE7f90B63D7c359e8f408e503c2D9401";
+ * const info = await fetchRatifierInfo(client, { maker });
+ * // Pass info.ratifier to Offer.create(...), then use info.type after
+ * // Tree.create([...]) to choose the Ecrecover or Setter ratifier flow.
+ * console.log(info.type, info.ratifier);
+ * ```
+ */
+async function fetchRatifierInfo(client, params) {
+    const chainId = await (0, utils_js_1.resolveChainId)(client);
+    const ecrecoverRatifier = (0, morpho_ts_1.getChainAddress)(chainId, "ecrecoverRatifier");
+    const setterRatifier = (0, morpho_ts_1.getChainAddress)(chainId, "setterRatifier");
+    const bytecode = await (0, actions_1.getBytecode)(client, {
+        ...(params.blockNumber != null
+            ? { blockNumber: params.blockNumber }
+            : params.blockTag != null
+                ? { blockTag: params.blockTag }
+                : {}),
+        address: params.maker,
+    });
+    return RatifierUtils_js_1.RatifierUtils.getRatifierInfo({
+        bytecode,
+        ecrecoverRatifier,
+        setterRatifier,
+    });
+}

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

@@ -0,0 +1,5 @@
+export * from "./Market.js";
+export * from "./Offer.js";
+export * from "./Position.js";
+export * from "./Ratifier.js";
+export * from "./types.js";

package/lib/cjs/fetch/index.js

@@ -0,0 +1,21 @@
+"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("./Market.js"), exports);
+__exportStar(require("./Offer.js"), exports);
+__exportStar(require("./Position.js"), exports);
+__exportStar(require("./Ratifier.js"), exports);
+__exportStar(require("./types.js"), exports);

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

@@ -0,0 +1,57 @@
+import type { Account, Address, BlockTag, StateOverride } from "viem";
+/**
+ * Shared viem call parameters accepted by Midnight fetch helpers.
+ *
+ * @example
+ * ```ts
+ * import type { MidnightCallParameters } from "@morpho-org/midnight-sdk";
+ *
+ * const params: MidnightCallParameters = { blockTag: "latest" };
+ * console.log(params.blockTag);
+ * ```
+ */
+export interface MidnightCallParameters {
+    /** Account used as the `from` field for the read. */
+    readonly account?: Account | Address;
+    /** Block number used for the read. */
+    readonly blockNumber?: bigint;
+    /** Block tag used for the read. */
+    readonly blockTag?: BlockTag;
+    /** State override set used for the read. */
+    readonly stateOverride?: StateOverride;
+}
+/**
+ * Deployless read mode accepted by deployless-capable Midnight fetch helpers.
+ *
+ * @example
+ * ```ts
+ * import type { DeploylessFetchParameters } from "@morpho-org/midnight-sdk";
+ *
+ * const params: DeploylessFetchParameters = { deployless: "force" };
+ * console.log(params.deployless);
+ * ```
+ */
+export interface DeploylessFetchParameters extends MidnightCallParameters {
+    /**
+     * If `true`, deployless-capable fetchers use deployless reads and fall back to direct reads if they fail.
+     *
+     * If `"force"`, deployless-capable fetchers use deployless reads without fallback.
+     *
+     * If `false`, deployless-capable fetchers use direct reads.
+     *
+     * Default is `true` for fetchers that implement deployless reads.
+     */
+    readonly deployless?: boolean | "force";
+}
+/**
+ * Shared viem fetch parameters for Midnight helpers.
+ *
+ * @example
+ * ```ts
+ * import type { MidnightFetchParams } from "@morpho-org/midnight-sdk";
+ *
+ * const params: MidnightFetchParams = { blockTag: "latest" };
+ * console.log(params.blockTag);
+ * ```
+ */
+export type MidnightFetchParams = DeploylessFetchParameters;

package/lib/cjs/fetch/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/fetch/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from "viem";
+import type { DeploylessFetchParameters, MidnightCallParameters } from "./types.js";
+/** @internal Extracts viem call parameters from Midnight fetch inputs. */
+export declare const callParameters: (params: MidnightCallParameters) => MidnightCallParameters;
+/** @internal Returns the configured deployless mode, defaulting to enabled. */
+export declare const shouldUseDeployless: (params: DeploylessFetchParameters) => boolean | "force";
+/** @internal Returns the configured viem client chain id or fetches it from RPC. */
+export declare const resolveChainId: (client: Client) => Promise<number>;

package/lib/cjs/fetch/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveChainId = exports.shouldUseDeployless = exports.callParameters = void 0;
+const actions_1 = require("viem/actions");
+/** @internal Extracts viem call parameters from Midnight fetch inputs. */
+const callParameters = (params) => ({
+    account: params.account,
+    blockNumber: params.blockNumber,
+    blockTag: params.blockTag,
+    stateOverride: params.stateOverride,
+});
+exports.callParameters = callParameters;
+/** @internal Returns the configured deployless mode, defaulting to enabled. */
+const shouldUseDeployless = (params) => params.deployless ?? true;
+exports.shouldUseDeployless = shouldUseDeployless;
+/** @internal Returns the configured viem client chain id or fetches it from RPC. */
+const resolveChainId = async (client) => client.chain?.id ?? (await (0, actions_1.getChainId)(client));
+exports.resolveChainId = resolveChainId;

package/lib/cjs/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./abis.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./fetch/index.js";
+export * from "./market/index.js";
+export * from "./math/index.js";
+export * from "./offers/index.js";
+export * from "./signatures/index.js";
+/**
+ * Namespace for Midnight mempool payload utilities.
+ *
+ * Use `Payload.encode` to turn ratified offer items into wire bytes for mempool
+ * publication or raw payload API validation, and `Payload.decode` to inspect
+ * published maker offers, ratifier data, or attribution-tagged payloads.
+ * Encoded payloads are always `Hex` strings ready to be included in onchain
+ * mempool submission calldata.
+ */
+export * as Payload from "./signatures/Payload.js";

package/lib/cjs/index.js

@@ -0,0 +1,57 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payload = void 0;
+__exportStar(require("./abis.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./fetch/index.js"), exports);
+__exportStar(require("./market/index.js"), exports);
+__exportStar(require("./math/index.js"), exports);
+__exportStar(require("./offers/index.js"), exports);
+__exportStar(require("./signatures/index.js"), exports);
+/**
+ * Namespace for Midnight mempool payload utilities.
+ *
+ * Use `Payload.encode` to turn ratified offer items into wire bytes for mempool
+ * publication or raw payload API validation, and `Payload.decode` to inspect
+ * published maker offers, ratifier data, or attribution-tagged payloads.
+ * Encoded payloads are always `Hex` strings ready to be included in onchain
+ * mempool submission calldata.
+ */
+exports.Payload = __importStar(require("./signatures/Payload.js"));