@morpho-org/midnight-sdk 0.1.0

package/lib/esm/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/esm/fetch/Position.js

@@ -0,0 +1,144 @@
+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 { abi as getPositionAbi, code as getPositionCode, } from "../queries/GetPosition.js";
+import { fetchMarket } from "./Market.js";
+import { callParameters, resolveChainId, shouldUseDeployless, } from "./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);
+ * ```
+ */
+export async function fetchPosition(client, params) {
+    const chainId = await resolveChainId(client);
+    const midnight = getChainAddress(chainId, "midnight");
+    if (shouldUseDeployless(params)) {
+        try {
+            const position = await readContract(client, {
+                ...callParameters(params),
+                abi: getPositionAbi,
+                code: getPositionCode,
+                functionName: "query",
+                args: [midnight, params.marketId, params.user],
+            });
+            const collateral = position.collateral;
+            return new 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 readContract(client, {
+        ...callParameters(params),
+        address: midnight,
+        abi: midnightAbi,
+        functionName: "position",
+        args: [params.marketId, params.user],
+    });
+    const collateral = await Promise.all(Array.from({ length: Number(MAX_COLLATERALS) }, (_, collateralIndex) => {
+        return readContract(client, {
+            ...callParameters(params),
+            address: midnight,
+            abi: midnightAbi,
+            functionName: "collateral",
+            args: [params.marketId, params.user, BigInt(collateralIndex)],
+        });
+    }));
+    return new 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);
+ * ```
+ */
+export async function fetchAccrualPosition(client, params) {
+    const [position, market] = await Promise.all([
+        fetchPosition(client, params),
+        fetchMarket(client, params),
+    ]);
+    return new AccrualPosition(position, market);
+}

package/lib/esm/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/esm/fetch/Ratifier.js

@@ -0,0 +1,54 @@
+import { getChainAddress } from "@morpho-org/morpho-ts";
+import { getBytecode } from "viem/actions";
+import { RatifierUtils, } from "../signatures/RatifierUtils.js";
+import { resolveChainId } from "./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);
+ * ```
+ */
+export async function fetchRatifierInfo(client, params) {
+    const chainId = await resolveChainId(client);
+    const ecrecoverRatifier = getChainAddress(chainId, "ecrecoverRatifier");
+    const setterRatifier = getChainAddress(chainId, "setterRatifier");
+    const bytecode = await getBytecode(client, {
+        ...(params.blockNumber != null
+            ? { blockNumber: params.blockNumber }
+            : params.blockTag != null
+                ? { blockTag: params.blockTag }
+                : {}),
+        address: params.maker,
+    });
+    return RatifierUtils.getRatifierInfo({
+        bytecode,
+        ecrecoverRatifier,
+        setterRatifier,
+    });
+}

package/lib/esm/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/esm/fetch/index.js

@@ -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/esm/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/esm/fetch/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/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/esm/fetch/utils.js

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

package/lib/esm/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/esm/index.js

@@ -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";