@morpho-org/midnight-sdk 0.1.0

package/lib/esm/errors.js

@@ -0,0 +1,291 @@
+/**
+ * Thrown when a Midnight offer group violates protocol-level group mechanics.
+ *
+ * @example
+ * ```ts
+ * import { InvalidOfferGroupError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidOfferGroupError("All offers in a group must use the same maker.");
+ * ```
+ */
+export class InvalidOfferGroupError extends Error {
+    constructor(reason) {
+        super(`Invalid Midnight offer group. ${reason}`);
+        this.name = "InvalidOfferGroupError";
+    }
+}
+/**
+ * Thrown when a tick exceeds the deployed TickLib range.
+ *
+ * @example
+ * ```ts
+ * import { TickOutOfRangeError } from "@morpho-org/midnight-sdk";
+ *
+ * const error = new TickOutOfRangeError(7000n, 6744n);
+ * console.log(error.message);
+ * ```
+ */
+export class TickOutOfRangeError extends Error {
+    constructor(tick, maxTick) {
+        super(`Tick "${tick}" exceeds maximum tick "${maxTick}".`);
+        this.name = "TickOutOfRangeError";
+    }
+}
+/**
+ * Thrown when a price is above the maximum WAD price accepted by TickLib.
+ *
+ * @example
+ * ```ts
+ * import { PriceGreaterThanOneError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new PriceGreaterThanOneError(2n * 10n ** 18n);
+ * ```
+ */
+export class PriceGreaterThanOneError extends Error {
+    constructor(price) {
+        super(`Price "${price}" is greater than WAD.`);
+        this.name = "PriceGreaterThanOneError";
+    }
+}
+/**
+ * Thrown when tick spacing is invalid or a tick is not aligned to it.
+ *
+ * @example
+ * ```ts
+ * import { InvalidTickSpacingError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidTickSpacingError(5n, 4n);
+ * ```
+ */
+export class InvalidTickSpacingError extends Error {
+    constructor(tickOrSpacing, spacing) {
+        super(spacing == null
+            ? `Tick spacing "${tickOrSpacing}" is invalid. Use a positive spacing that divides the maximum tick.`
+            : `Tick "${tickOrSpacing}" is not aligned to spacing "${spacing}". Use a tick aligned to the market spacing.`);
+        this.name = "InvalidTickSpacingError";
+    }
+}
+/**
+ * Thrown when a buy offer's settlement fee exceeds its tick price.
+ *
+ * @example
+ * ```ts
+ * import { SettlementFeeExceedsPriceError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new SettlementFeeExceedsPriceError(10n, 9n);
+ * ```
+ */
+export class SettlementFeeExceedsPriceError extends Error {
+    constructor(settlementFee, price) {
+        super(`Settlement fee "${settlementFee}" exceeds offer price "${price}". Use a lower fee or a higher tick.`);
+        this.name = "SettlementFeeExceedsPriceError";
+    }
+}
+/**
+ * Thrown when a local position accrual is requested for an impossible timestamp.
+ *
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualTimestampError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualTimestampError(1n, 2n);
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { InvalidPositionLossFactorError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionLossFactorError(1n, 2n);
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { InvalidPositionAccrualStateError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidPositionAccrualStateError("Pending fee exceeds credit.");
+ * ```
+ */
+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.
+ *
+ * @example
+ * ```ts
+ * import { InvalidMarketParameterError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidMarketParameterError({
+ *   parameter: "collateralParams",
+ *   value: 0,
+ *   instruction: "Provide at least one collateral.",
+ * });
+ * ```
+ * @param params.parameter - Invalid market parameter name.
+ * @param params.value - Invalid market parameter value.
+ * @param params.instruction - Optional instruction appended to the error message.
+ * @param params.cause - Optional wrapped cause.
+ */
+export class InvalidMarketParameterError extends Error {
+    /** Invalid market parameter name. */
+    parameter;
+    /** Invalid market parameter value. */
+    value;
+    constructor(params) {
+        super(`Invalid market parameter "${params.parameter}" with value "${String(params.value)}".${params.instruction == null ? "" : ` ${params.instruction}`}`, params.cause === undefined ? undefined : { cause: params.cause });
+        this.name = "InvalidMarketParameterError";
+        this.parameter = params.parameter;
+        this.value = params.value;
+    }
+}
+/**
+ * Thrown when an offer builder receives a parameter that cannot satisfy Midnight protocol rules.
+ *
+ * @example
+ * ```ts
+ * import { InvalidOfferParameterError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidOfferParameterError({ parameter: "tick", value: 5821n });
+ * ```
+ * @param params.parameter - Invalid offer parameter name.
+ * @param params.value - Invalid offer parameter value.
+ * @param params.instruction - Optional instruction appended to the error message.
+ * @param params.cause - Optional wrapped cause.
+ */
+export class InvalidOfferParameterError extends Error {
+    /** Invalid offer parameter name. */
+    parameter;
+    /** Invalid offer parameter value. */
+    value;
+    constructor(params) {
+        super(`Invalid offer parameter "${params.parameter}" with value "${String(params.value)}".${params.instruction == null ? "" : ` ${params.instruction}`}`, params.cause === undefined ? undefined : { cause: params.cause });
+        this.name = "InvalidOfferParameterError";
+        this.parameter = params.parameter;
+        this.value = params.value;
+    }
+}
+/**
+ * Thrown when a tree height exceeds the ratifier typehash table.
+ *
+ * @example
+ * ```ts
+ * import { InvalidTreeHeightError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidTreeHeightError(21);
+ * ```
+ */
+export class InvalidTreeHeightError extends Error {
+    constructor(height) {
+        super(`Tree height "${height}" is not supported.`);
+        this.name = "InvalidTreeHeightError";
+    }
+}
+/**
+ * Thrown when a tree cannot be represented by the ratifiers.
+ *
+ * @example
+ * ```ts
+ * import { InvalidTreeError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidTreeError("Tree must not be empty.");
+ * ```
+ */
+export class InvalidTreeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidTreeError";
+    }
+}
+/**
+ * Thrown when a typed-data signature does not recover to the expected signer.
+ *
+ * @example
+ * ```ts
+ * import { InvalidTypedDataSignatureError } from "@morpho-org/midnight-sdk";
+ *
+ * throw new InvalidTypedDataSignatureError(
+ *   "0x0000000000000000000000000000000000000001",
+ * );
+ * ```
+ */
+export class InvalidTypedDataSignatureError extends Error {
+    /** Signer address the signature was expected to recover. */
+    signer;
+    constructor(signer) {
+        super(`Typed-data signature does not recover to signer "${signer}". Check the wallet account or signing transport.`);
+        this.name = "InvalidTypedDataSignatureError";
+        this.signer = signer;
+    }
+}
+/**
+ * Thrown when the Midnight API returns a non-2xx response.
+ *
+ * @example
+ * ```ts
+ * import { MidnightApiError } from "@morpho-org/midnight-sdk/api";
+ *
+ * throw new MidnightApiError({
+ *   status: 400,
+ *   code: "BAD_REQUEST",
+ *   message: "Limit must be greater than 0.",
+ *   details: [{ field: "limit", issue: "Limit must be greater than 0." }],
+ *   requestId: "req-123",
+ * });
+ * ```
+ */
+export class MidnightApiError extends Error {
+    /** HTTP response status from the API. */
+    status;
+    /** API error code, when the response body includes one. */
+    code;
+    /** API error details, when the response body includes them. */
+    details;
+    /** API request id, when the response body includes one. */
+    requestId;
+    constructor(params) {
+        super(params.message ??
+            `Midnight API request failed with HTTP status "${params.status}".`, params.cause === undefined ? undefined : { cause: params.cause });
+        this.name = "MidnightApiError";
+        this.status = params.status;
+        this.code = params.code;
+        this.details = params.details;
+        this.requestId = params.requestId;
+    }
+}
+/**
+ * Thrown when the Midnight API returns a malformed successful response.
+ *
+ * @example
+ * ```ts
+ * import { InvalidMidnightApiResponseError } from "@morpho-org/midnight-sdk/api";
+ *
+ * throw new InvalidMidnightApiResponseError("API response is missing data.");
+ * ```
+ */
+export class InvalidMidnightApiResponseError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "InvalidMidnightApiResponseError";
+    }
+}

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

@@ -0,0 +1,65 @@
+import type { Client, Hash } from "viem";
+import { Market, MarketParams } from "../market/index.js";
+import type { MidnightFetchParams } from "./types.js";
+/**
+ * Fetches immutable market params by id.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.toMarket(marketId)`.
+ *
+ * @param client - Viem client used for the read.
+ * @param params.marketId - Market id whose immutable params to read.
+ * @param params.account - Optional account used as the `from` field for the read.
+ * @param params.blockNumber - Optional block number used for the read.
+ * @param params.blockTag - Optional block tag used for the read.
+ * @param params.stateOverride - Optional state override set used for the read.
+ * @returns Market params 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 { fetchMarketParams } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const params = await fetchMarketParams(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ * });
+ * console.log(params.loanToken);
+ * ```
+ */
+export declare function fetchMarketParams(client: Client, params: MidnightFetchParams & {
+    readonly marketId: Hash;
+}): Promise<MarketParams>;
+/**
+ * Fetches a hydrated market by id.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.toMarket(marketId)` and `Midnight.marketState(marketId)`.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose hydrated market state to read.
+ * @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 Market 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 { fetchMarket } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const market = await fetchMarket(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ * });
+ * console.log(market.params.loanToken);
+ * ```
+ */
+export declare function fetchMarket(client: Client, params: MidnightFetchParams & {
+    readonly marketId: Hash;
+}): Promise<Market>;

package/lib/esm/fetch/Market.js

@@ -0,0 +1,113 @@
+import { getChainAddress } from "@morpho-org/morpho-ts";
+import { readContract } from "viem/actions";
+import { midnightAbi } from "../abis.js";
+import { Market, MarketParams } from "../market/index.js";
+import { callParameters, resolveChainId } from "./utils.js";
+/**
+ * Fetches immutable market params by id.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.toMarket(marketId)`.
+ *
+ * @param client - Viem client used for the read.
+ * @param params.marketId - Market id whose immutable params to read.
+ * @param params.account - Optional account used as the `from` field for the read.
+ * @param params.blockNumber - Optional block number used for the read.
+ * @param params.blockTag - Optional block tag used for the read.
+ * @param params.stateOverride - Optional state override set used for the read.
+ * @returns Market params 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 { fetchMarketParams } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const params = await fetchMarketParams(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ * });
+ * console.log(params.loanToken);
+ * ```
+ */
+export async function fetchMarketParams(client, params) {
+    const chainId = await resolveChainId(client);
+    const midnight = getChainAddress(chainId, "midnight");
+    const market = await readContract(client, {
+        ...callParameters(params),
+        address: midnight,
+        abi: midnightAbi,
+        functionName: "toMarket",
+        args: [params.marketId],
+    });
+    return new MarketParams(market);
+}
+/**
+ * Fetches a hydrated market by id.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.toMarket(marketId)` and `Midnight.marketState(marketId)`.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id whose hydrated market state to read.
+ * @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 Market 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 { fetchMarket } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const market = await fetchMarket(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ * });
+ * console.log(market.params.loanToken);
+ * ```
+ */
+export async function fetchMarket(client, params) {
+    const chainId = await resolveChainId(client);
+    const midnight = getChainAddress(chainId, "midnight");
+    const [market, state] = await Promise.all([
+        readContract(client, {
+            ...callParameters(params),
+            address: midnight,
+            abi: midnightAbi,
+            functionName: "toMarket",
+            args: [params.marketId],
+        }),
+        readContract(client, {
+            ...callParameters(params),
+            address: midnight,
+            abi: midnightAbi,
+            functionName: "marketState",
+            args: [params.marketId],
+        }),
+    ]);
+    const [totalUnits, lossFactor, withdrawable, continuousFeeCredit, settlementFeeCbps0, settlementFeeCbps1, settlementFeeCbps2, settlementFeeCbps3, settlementFeeCbps4, settlementFeeCbps5, settlementFeeCbps6, continuousFee, tickSpacing,] = state;
+    return new Market({
+        chainId,
+        params: new MarketParams(market),
+        totalUnits,
+        lossFactor,
+        withdrawable,
+        continuousFeeCredit,
+        settlementFeeCbps: [
+            settlementFeeCbps0,
+            settlementFeeCbps1,
+            settlementFeeCbps2,
+            settlementFeeCbps3,
+            settlementFeeCbps4,
+            settlementFeeCbps5,
+            settlementFeeCbps6,
+        ],
+        continuousFee,
+        tickSpacing,
+    });
+}

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

@@ -0,0 +1,74 @@
+import { type BigIntish } from "@morpho-org/morpho-ts";
+import type { Address, Client, Hash } from "viem";
+import type { MidnightFetchParams } from "./types.js";
+/**
+ * Fetches and computes remaining consumable units for an offer.
+ *
+ * Unit-capped offers skip settlement-fee lookup, matching the Solidity
+ * library's early return. For asset-capped offers, pass the time to maturity
+ * for the same block context as the quote.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.consumed(offer.maker, group)` and
+ * `Midnight.continuousFee(marketId)`. If the offer's continuous fee cap is
+ * below the market's current continuous fee, returns zero. For asset-capped
+ * offers where `offer.maxUnits` is zero, also reads
+ * `Midnight.settlementFee(marketId, timeToMaturity)`.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id used for settlement-fee lookup on asset-capped offers.
+ * @param params.offer.buy - Whether the maker buys loan assets.
+ * @param params.offer.maker - Maker address whose consumed group amount is read.
+ * @param params.offer.tick - Offer tick used for asset-to-unit conversion.
+ * @param params.offer.maxUnits - Unit cap; when non-zero, settlement-fee lookup is skipped.
+ * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
+ * @param params.offer.continuousFeeCap - Maximum market continuous fee accepted by this offer.
+ * @param params.group - Offer group id whose consumed amount is read.
+ * @param params.timeToMaturity - Time to maturity used for settlement-fee lookup on asset-capped offers.
+ * @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 Consumable units.
+ * @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.
+ * @throws {NegativeValueError} when asset-capped `timeToMaturity`, offer caps, or SDK math inputs are negative.
+ * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
+ * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
+ * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+ * @example
+ * ```ts
+ * import { fetchConsumableUnits } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http, zeroHash } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const units = await fetchConsumableUnits(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   offer: {
+ *     buy: true,
+ *     maker: "0x0000000000000000000000000000000000009000",
+ *     tick: 5_000n,
+ *     maxUnits: 100n,
+ *     maxAssets: 0n,
+ *     continuousFeeCap: 317097919n,
+ *   },
+ *   group: zeroHash,
+ *   timeToMaturity: 3_600n,
+ * });
+ * console.log(units);
+ * ```
+ */
+export declare function fetchConsumableUnits(client: Client, params: MidnightFetchParams & {
+    readonly marketId: Hash;
+    readonly offer: {
+        readonly buy: boolean;
+        readonly maker: Address;
+        readonly tick: BigIntish;
+        readonly maxUnits: BigIntish;
+        readonly maxAssets: BigIntish;
+        readonly continuousFeeCap: BigIntish;
+    };
+    readonly group: Hash;
+    readonly timeToMaturity: BigIntish;
+}): Promise<bigint>;

package/lib/esm/fetch/Offer.js

@@ -0,0 +1,116 @@
+import { assertNonNegative, getChainAddress, } from "@morpho-org/morpho-ts";
+import { readContract } from "viem/actions";
+import { midnightAbi } from "../abis.js";
+import { ConsumableUnitsLib } from "../math/index.js";
+import { OfferUtils } from "../offers/index.js";
+import { callParameters, resolveChainId } from "./utils.js";
+/**
+ * Fetches and computes remaining consumable units for an offer.
+ *
+ * Unit-capped offers skip settlement-fee lookup, matching the Solidity
+ * library's early return. For asset-capped offers, pass the time to maturity
+ * for the same block context as the quote.
+ *
+ * Reads `eth_chainId` only when the viem client has no configured chain id,
+ * then reads `Midnight.consumed(offer.maker, group)` and
+ * `Midnight.continuousFee(marketId)`. If the offer's continuous fee cap is
+ * below the market's current continuous fee, returns zero. For asset-capped
+ * offers where `offer.maxUnits` is zero, also reads
+ * `Midnight.settlementFee(marketId, timeToMaturity)`.
+ *
+ * @param client - Viem client used for the reads.
+ * @param params.marketId - Market id used for settlement-fee lookup on asset-capped offers.
+ * @param params.offer.buy - Whether the maker buys loan assets.
+ * @param params.offer.maker - Maker address whose consumed group amount is read.
+ * @param params.offer.tick - Offer tick used for asset-to-unit conversion.
+ * @param params.offer.maxUnits - Unit cap; when non-zero, settlement-fee lookup is skipped.
+ * @param params.offer.maxAssets - Asset cap used when `params.offer.maxUnits` is zero.
+ * @param params.offer.continuousFeeCap - Maximum market continuous fee accepted by this offer.
+ * @param params.group - Offer group id whose consumed amount is read.
+ * @param params.timeToMaturity - Time to maturity used for settlement-fee lookup on asset-capped offers.
+ * @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 Consumable units.
+ * @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.
+ * @throws {NegativeValueError} when asset-capped `timeToMaturity`, offer caps, or SDK math inputs are negative.
+ * @throws {InvalidOfferParameterError} when offer caps are both zero or both non-zero.
+ * @throws {DivisionByZeroError} when the delegated units conversion divides by zero.
+ * @throws {SettlementFeeExceedsPriceError} when settlement fee exceeds a buy offer price.
+ * @example
+ * ```ts
+ * import { fetchConsumableUnits } from "@morpho-org/midnight-sdk";
+ * import { createPublicClient, http, zeroHash } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const client = createPublicClient({ chain: base, transport: http() });
+ * const units = await fetchConsumableUnits(client, {
+ *   marketId: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+ *   offer: {
+ *     buy: true,
+ *     maker: "0x0000000000000000000000000000000000009000",
+ *     tick: 5_000n,
+ *     maxUnits: 100n,
+ *     maxAssets: 0n,
+ *     continuousFeeCap: 317097919n,
+ *   },
+ *   group: zeroHash,
+ *   timeToMaturity: 3_600n,
+ * });
+ * console.log(units);
+ * ```
+ */
+export async function fetchConsumableUnits(client, params) {
+    const maxUnits = BigInt(params.offer.maxUnits);
+    const maxAssets = BigInt(params.offer.maxAssets);
+    const continuousFeeCap = BigInt(params.offer.continuousFeeCap);
+    assertNonNegative("offer.maxUnits", maxUnits);
+    assertNonNegative("offer.maxAssets", maxAssets);
+    assertNonNegative("offer.continuousFeeCap", continuousFeeCap);
+    OfferUtils.validateOfferCaps({ maxUnits, maxAssets });
+    const needsSettlementFee = maxUnits === 0n;
+    const timeToMaturity = needsSettlementFee
+        ? BigInt(params.timeToMaturity)
+        : 0n;
+    if (needsSettlementFee) {
+        assertNonNegative("timeToMaturity", timeToMaturity);
+    }
+    const chainId = await resolveChainId(client);
+    const midnight = getChainAddress(chainId, "midnight");
+    const consumed = readContract(client, {
+        ...callParameters(params),
+        address: midnight,
+        abi: midnightAbi,
+        functionName: "consumed",
+        args: [params.offer.maker, params.group],
+    });
+    const continuousFee = readContract(client, {
+        ...callParameters(params),
+        address: midnight,
+        abi: midnightAbi,
+        functionName: "continuousFee",
+        args: [params.marketId],
+    });
+    const [consumedValue, marketContinuousFee] = await Promise.all([
+        consumed,
+        continuousFee,
+    ]);
+    if (continuousFeeCap < BigInt(marketContinuousFee))
+        return 0n;
+    const settlementFee = needsSettlementFee
+        ? await readContract(client, {
+            ...callParameters(params),
+            address: midnight,
+            abi: midnightAbi,
+            functionName: "settlementFee",
+            args: [params.marketId, timeToMaturity],
+        })
+        : 0n;
+    return ConsumableUnitsLib.consumableUnits({
+        offer: params.offer,
+        consumed: consumedValue,
+        settlementFee,
+    });
+}