@morpho-dev/router 0.2.0 → 0.3.0

package/dist/index.browser.d.ts

@@ -1,277 +1,378 @@
-import { z as z$1 } from 'zod/v4';
-import * as z from 'zod';
-import { Hex, Address, AbiEvent, PublicClient, GetLogsReturnType, WalletClient, PublicActions } from 'viem';
-import { Chain as Chain$2 } from 'viem/chains';
-import { OpenAPIDocument } from 'openapi-metadata';
-import { Client as Client$3 } from 'openapi-fetch';
-import { StandardMerkleTree } from '@openzeppelin/merkle-tree';
+import { z } from "zod/v4";
+import { AbiEvent, Address, ChainContract, ChainFormatters, GetLogsReturnType, Hex, MulticallParameters, PublicClient, Transport, WalletClient } from "viem";
+import { Chain } from "viem/chains";
+import * as z$1 from "zod";
+import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
+import { OpenAPIDocument } from "openapi-metadata";
+import { Client } from "openapi-fetch";
 
-declare const CollectorHealth: z$1.ZodObject<{
-    name: z$1.ZodString;
-    chain_id: z$1.ZodNumber;
-    block_number: z$1.ZodNullable<z$1.ZodNumber>;
-    updated_at: z$1.ZodNullable<z$1.ZodString>;
-    lag: z$1.ZodNullable<z$1.ZodNumber>;
-    status: z$1.ZodEnum<{
-        live: "live";
-        lagging: "lagging";
-        unknown: "unknown";
-    }>;
-}, z$1.core.$strip>;
-declare const ChainHealth: z$1.ZodObject<{
-    chain_id: z$1.ZodNumber;
-    block_number: z$1.ZodNumber;
-    updated_at: z$1.ZodString;
-}, z$1.core.$strip>;
-declare const CollectorsHealthResponse: z$1.ZodArray<z$1.ZodObject<{
-    name: z$1.ZodString;
-    chain_id: z$1.ZodNumber;
-    block_number: z$1.ZodNullable<z$1.ZodNumber>;
-    updated_at: z$1.ZodNullable<z$1.ZodString>;
-    lag: z$1.ZodNullable<z$1.ZodNumber>;
-    status: z$1.ZodEnum<{
-        live: "live";
-        lagging: "lagging";
-        unknown: "unknown";
-    }>;
-}, z$1.core.$strip>>;
-type CollectorsHealthResponse = z$1.infer<typeof CollectorsHealthResponse>;
-declare const ChainsHealthResponse: z$1.ZodArray<z$1.ZodObject<{
-    chain_id: z$1.ZodNumber;
-    block_number: z$1.ZodNumber;
-    updated_at: z$1.ZodString;
-}, z$1.core.$strip>>;
-type ChainsHealthResponse = z$1.infer<typeof ChainsHealthResponse>;
-declare const RouterStatusResponse: z$1.ZodObject<{
-    status: z$1.ZodEnum<{
-        live: "live";
-        syncing: "syncing";
-    }>;
-}, z$1.core.$strip>;
-type RouterStatusResponse = z$1.infer<typeof RouterStatusResponse>;
-
-declare const Oracle: readonly [{
-    readonly type: "function";
-    readonly name: "price";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
+//#region rolldown:runtime
+declare namespace BookResponse_d_exports {
+  export { BookLevelResponse, from$13 as from };
+}
+type BookLevelResponse = {
+  rate: string;
+  assets: string;
+  count: number;
+};
+declare function from$13(level: {
+  rate: bigint;
+  assets: bigint;
+  count: number;
+}): BookLevelResponse;
+//#endregion
+//#region src/api/Schema/health.d.ts
+declare const CollectorHealth: z.ZodObject<{
+  name: z.ZodString;
+  chain_id: z.ZodNumber;
+  block_number: z.ZodNullable<z.ZodNumber>;
+  updated_at: z.ZodNullable<z.ZodString>;
+  lag: z.ZodNullable<z.ZodNumber>;
+  status: z.ZodEnum<{
+    live: "live";
+    lagging: "lagging";
+    unknown: "unknown";
+  }>;
+}, z.core.$strip>;
+declare const CollectorsHealthResponse: z.ZodArray<z.ZodObject<{
+  name: z.ZodString;
+  chain_id: z.ZodNumber;
+  block_number: z.ZodNullable<z.ZodNumber>;
+  updated_at: z.ZodNullable<z.ZodString>;
+  lag: z.ZodNullable<z.ZodNumber>;
+  status: z.ZodEnum<{
+    live: "live";
+    lagging: "lagging";
+    unknown: "unknown";
+  }>;
+}, z.core.$strip>>;
+declare const ChainHealth: z.ZodObject<{
+  chain_id: z.ZodNumber;
+  local_block_number: z.ZodNumber;
+  remote_block_number: z.ZodNullable<z.ZodNumber>;
+  updated_at: z.ZodString;
+}, z.core.$strip>;
+declare const ChainsHealthResponse: z.ZodArray<z.ZodObject<{
+  chain_id: z.ZodNumber;
+  local_block_number: z.ZodNumber;
+  remote_block_number: z.ZodNullable<z.ZodNumber>;
+  updated_at: z.ZodString;
+}, z.core.$strip>>;
+declare const RouterStatusResponse: z.ZodObject<{
+  status: z.ZodEnum<{
+    live: "live";
+    syncing: "syncing";
+  }>;
+}, z.core.$strip>;
+type CollectorsHealthResponse = z.infer<typeof CollectorsHealthResponse>;
+type ChainsHealthResponse = z.infer<typeof ChainsHealthResponse>;
+type RouterStatusResponse = z.infer<typeof RouterStatusResponse>;
+//#endregion
+//#region src/core/Abi/MetaMorpho.d.ts
+declare const MetaMorpho: readonly [{
+  readonly name: "balanceOf";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "account";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
+}, {
+  readonly name: "DECIMALS_OFFSET";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint8";
+  }];
+}, {
+  readonly name: "totalAssets";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
+}, {
+  readonly name: "totalSupply";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
+}, {
+  readonly name: "maxWithdraw";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "owner";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+    readonly name: "assets";
+  }];
+}, {
+  readonly name: "asset";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address";
+  }];
+}, {
+  readonly name: "Transfer";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "from";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "to";
+    readonly indexed: true;
+  }, {
+    readonly type: "uint256";
+    readonly name: "value";
+  }];
+}, {
+  readonly name: "withdrawQueue";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "uint256";
+    readonly name: "index";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "bytes32";
+  }];
+}, {
+  readonly name: "withdrawQueueLength";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
 }];
-declare const ERC4626: readonly [{
-    readonly type: "function";
+type MetaMorpho = typeof MetaMorpho;
+//#endregion
+//#region src/core/Abi/MetaMorphoFactory.d.ts
+declare const MetaMorphoFactory: readonly [{
+  readonly name: "CreateMetaMorpho";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "address";
+    readonly name: "metaMorpho";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "caller";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "initialOwner";
+  }, {
+    readonly type: "uint256";
+    readonly name: "initialTimelock";
+  }, {
+    readonly type: "address";
     readonly name: "asset";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
+    readonly indexed: true;
+  }, {
+    readonly type: "string";
+    readonly name: "name";
+  }, {
+    readonly type: "string";
+    readonly name: "symbol";
+  }, {
+    readonly type: "bytes32";
+    readonly name: "salt";
+  }];
+}, {
+  readonly name: "isMetaMorpho";
+  readonly type: "function";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [{
+    readonly type: "address";
+  }];
+  readonly outputs: readonly [{
+    readonly type: "bool";
+  }];
 }];
-declare const MetaMorphoFactory: readonly [{
-    readonly type: "function";
-    readonly name: "isMetaMorpho";
-    readonly inputs: readonly [{
-        readonly name: "target";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
+type MetaMorphoFactory = typeof MetaMorphoFactory;
+declare namespace index_d_exports {
+  export { ERC4626, MetaMorpho, MetaMorphoFactory, Morpho, Oracle$1 as Oracle };
+}
+declare const Oracle$1: readonly [{
+  readonly type: "function";
+  readonly name: "price";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint256";
+  }];
+  readonly stateMutability: "view";
 }];
-declare const MetaMorpho: readonly [{
-    readonly type: "function";
-    readonly name: "withdrawQueue";
-    readonly inputs: readonly [{
-        readonly name: "index";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "withdrawQueueLength";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "maxWithdraw";
-    readonly inputs: readonly [{
-        readonly name: "owner";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
+declare const ERC4626: readonly [{
+  readonly type: "function";
+  readonly name: "asset";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+  }];
+  readonly stateMutability: "view";
 }];
 declare const Morpho: readonly [{
-    readonly type: "function";
-    readonly name: "collateralOf";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }, {
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
+  readonly type: "function";
+  readonly name: "collateralOf";
+  readonly inputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+    readonly internalType: "address";
+  }, {
+    readonly name: "";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "";
+    readonly type: "address";
+    readonly internalType: "address";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint256";
+    readonly internalType: "uint256";
+  }];
+  readonly stateMutability: "view";
 }, {
-    readonly type: "function";
-    readonly name: "debtOf";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
+  readonly type: "function";
+  readonly name: "debtOf";
+  readonly inputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+    readonly internalType: "address";
+  }, {
+    readonly name: "";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint256";
+    readonly internalType: "uint256";
+  }];
+  readonly stateMutability: "view";
 }, {
-    readonly type: "function";
-    readonly name: "market";
-    readonly inputs: readonly [{
-        readonly name: "id";
-        readonly type: "bytes32";
-        readonly internalType: "Id";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "totalSupplyAssets";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "totalSupplyShares";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "totalBorrowAssets";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "totalBorrowShares";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "lastUpdate";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "fee";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }];
-    readonly stateMutability: "view";
+  readonly type: "function";
+  readonly name: "market";
+  readonly inputs: readonly [{
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly internalType: "Id";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "totalSupplyAssets";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "totalSupplyShares";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "totalBorrowAssets";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "totalBorrowShares";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "lastUpdate";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "fee";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }];
+  readonly stateMutability: "view";
 }, {
-    readonly type: "function";
-    readonly name: "position";
-    readonly inputs: readonly [{
-        readonly name: "id";
-        readonly type: "bytes32";
-        readonly internalType: "Id";
-    }, {
-        readonly name: "user";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "supplyShares";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "borrowShares";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }, {
-        readonly name: "collateral";
-        readonly type: "uint128";
-        readonly internalType: "uint128";
-    }];
-    readonly stateMutability: "view";
+  readonly type: "function";
+  readonly name: "position";
+  readonly inputs: readonly [{
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly internalType: "Id";
+  }, {
+    readonly name: "user";
+    readonly type: "address";
+    readonly internalType: "address";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "supplyShares";
+    readonly type: "uint256";
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "borrowShares";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }, {
+    readonly name: "collateral";
+    readonly type: "uint128";
+    readonly internalType: "uint128";
+  }];
+  readonly stateMutability: "view";
 }];
-
-declare const Abi_ERC4626: typeof ERC4626;
-declare const Abi_MetaMorpho: typeof MetaMorpho;
-declare const Abi_MetaMorphoFactory: typeof MetaMorphoFactory;
-declare const Abi_Morpho: typeof Morpho;
-declare const Abi_Oracle: typeof Oracle;
-declare namespace Abi {
-  export { Abi_ERC4626 as ERC4626, Abi_MetaMorpho as MetaMorpho, Abi_MetaMorphoFactory as MetaMorphoFactory, Abi_Morpho as Morpho, Abi_Oracle as Oracle };
+declare namespace Callback_d_exports {
+  export { BuyVaultV1CallbackData, CallbackType, SellERC20CallbackData, decode$3 as decode, decodeBuyVaultV1Callback, decodeSellERC20Callback, encode$3 as encode, encodeBuyVaultV1Callback, encodeSellERC20Callback, isEmptyCallback };
 }
-
 declare enum CallbackType {
-    BuyWithEmptyCallback = "buy_with_empty_callback",
-    BuyVaultV1Callback = "buy_vault_v1_callback",
-    SellERC20Callback = "sell_erc20_callback"
+  BuyWithEmptyCallback = "buy_with_empty_callback",
+  BuyVaultV1Callback = "buy_vault_v1_callback",
+  SellERC20Callback = "sell_erc20_callback",
 }
 declare const isEmptyCallback: (offer: Offer) => boolean;
 declare function decode$3(type: CallbackType, data: Hex): {
-    vault: Address;
-    amount: bigint;
-}[] | {
-    collateral: Address;
-    amount: bigint;
+  contract: Address;
+  amount: bigint;
 }[];
-declare function encode$3(type: CallbackType, data: any): Hex;
+type BuyVaultV1CallbackData = {
+  vaults: Address[];
+  amounts: bigint[];
+};
+type SellERC20CallbackData = {
+  collaterals: Address[];
+  amounts: bigint[];
+};
+declare function encode$3(type: CallbackType.BuyVaultV1Callback, data: BuyVaultV1CallbackData): Hex;
+declare function encode$3(type: CallbackType.SellERC20Callback, data: SellERC20CallbackData): Hex;
 declare function decodeBuyVaultV1Callback(data: Hex): Array<{
-    vault: Address;
-    amount: bigint;
+  contract: Address;
+  amount: bigint;
 }>;
 declare function decodeSellERC20Callback(data: Hex): Array<{
-    collateral: Address;
-    amount: bigint;
+  contract: Address;
+  amount: bigint;
 }>;
 declare function encodeBuyVaultV1Callback(parameters: {
-    vaults: Address[];
-    amounts: bigint[];
+  vaults: Address[];
+  amounts: bigint[];
 }): Hex;
 declare function encodeSellERC20Callback(parameters: {
-    collaterals: Address[];
-    amounts: bigint[];
+  collaterals: Address[];
+  amounts: bigint[];
 }): Hex;
-
-type Callback_CallbackType = CallbackType;
-declare const Callback_CallbackType: typeof CallbackType;
-declare const Callback_decodeBuyVaultV1Callback: typeof decodeBuyVaultV1Callback;
-declare const Callback_decodeSellERC20Callback: typeof decodeSellERC20Callback;
-declare const Callback_encodeBuyVaultV1Callback: typeof encodeBuyVaultV1Callback;
-declare const Callback_encodeSellERC20Callback: typeof encodeSellERC20Callback;
-declare const Callback_isEmptyCallback: typeof isEmptyCallback;
-declare namespace Callback {
-  export { Callback_CallbackType as CallbackType, decode$3 as decode, Callback_decodeBuyVaultV1Callback as decodeBuyVaultV1Callback, Callback_decodeSellERC20Callback as decodeSellERC20Callback, encode$3 as encode, Callback_encodeBuyVaultV1Callback as encodeBuyVaultV1Callback, Callback_encodeSellERC20Callback as encodeSellERC20Callback, Callback_isEmptyCallback as isEmptyCallback };
+declare namespace Errors_d_exports {
+  export { BaseError, GlobalErrorType, ReorgError };
 }
-
 type GlobalErrorType<name extends string = "Error"> = Error & {
-    name: name;
+  name: name;
 };
 /**
  * Base error class inherited by all errors thrown by mempool.
@@ -283,115 +384,94 @@ type GlobalErrorType<name extends string = "Error"> = Error & {
  * ```
  */
 declare class BaseError<cause extends Error | undefined = undefined> extends Error {
-    details: string;
-    shortMessage: string;
-    cause: cause;
-    name: string;
-    constructor(shortMessage: string, options?: {
-        cause?: cause | undefined;
-        details?: string | undefined;
-        metaMessages?: (string | undefined)[] | undefined;
-    });
-    walk(): Error;
-    walk(fn: (err: unknown) => boolean): Error | null;
-}
-
-type Errors_BaseError<cause extends Error | undefined = undefined> = BaseError<cause>;
-declare const Errors_BaseError: typeof BaseError;
-type Errors_GlobalErrorType<name extends string = "Error"> = GlobalErrorType<name>;
-declare namespace Errors {
-  export { Errors_BaseError as BaseError, type Errors_GlobalErrorType as GlobalErrorType };
-}
-
-/** Combines members of an intersection into a readable type. */
-type Compute<type> = {
-    [key in keyof type]: type[key];
-} & unknown;
-declare const BrandTypeId: unique symbol;
-type Brand<in out ID extends string | symbol> = {
-    readonly [BrandTypeId]: {
-        readonly [id in ID]: ID;
+  details: string;
+  shortMessage: string;
+  cause: cause;
+  name: string;
+  constructor(shortMessage: string, options?: {
+    cause?: cause | undefined;
+    details?: string | undefined;
+    metaMessages?: (string | undefined)[] | undefined;
+  });
+  walk(): Error;
+  walk(fn: (err: unknown) => boolean): Error | null;
+}
+declare class ReorgError extends BaseError {
+  name: string;
+  constructor(blockNumber: number);
+}
+declare namespace Chain_d_exports {
+  export { Chain$1 as Chain, ChainId, Id, InvalidBatchSizeError, InvalidBlockRangeError, InvalidBlockWindowError, MissingBlockNumberError, Name, chainIds, chainNames, chains$1 as chains, getChain, getWhitelistedChains, streamLogs };
+}
+type Chain$1 = Compute<Chain<ChainFormatters, {
+  morpho: ChainContract;
+  morphoBlue: ChainContract;
+  mempool: ChainContract;
+  vaults: {
+    factories: {
+      v1_0: ChainContract;
+      v1_1: ChainContract;
     };
-};
-
-declare const chainNames: readonly ["ethereum", "base", "ethereum-virtual-testnet", "anvil"];
-type ChainName = (typeof chainNames)[number];
+  };
+}> & {
+  id: Id;
+  name: Name;
+}>;
 declare const ChainId: {
-    ETHEREUM: bigint;
-    BASE: bigint;
-    "ETHEREUM-VIRTUAL-TESTNET": bigint;
-    ANVIL: bigint;
+  readonly ETHEREUM: 1;
+  readonly BASE: 8453;
+  readonly "ETHEREUM-VIRTUAL-TESTNET": 109111114;
+  readonly ANVIL: 505050505;
 };
-type Id = (typeof ChainId)[keyof typeof ChainId];
-declare const chainIds: Set<bigint>;
-type Chain = Compute<Omit<Chain$2, "id" | "name"> & {
-    id: Id;
-    name: ChainName;
-    morpho: Address;
-    morphoBlue: Address;
-    mempool: {
-        address: Address;
-        deploymentBlock: number;
-        reindexBuffer: number;
-    };
-}>;
-declare function getChain(chainId: Id): Chain | undefined;
-declare const getWhitelistedChains: () => Chain[];
-declare const chains: Record<ChainName, Chain>;
+type Name = Lowercase<keyof typeof ChainId>;
+declare const chainNames: readonly Name[];
+type Id = (typeof ChainId)[Uppercase<Name>];
+declare const chainIds: readonly Id[];
+declare function getChain(chainId: Id): Chain$1 | undefined;
+declare const getWhitelistedChains: () => Chain$1[];
+declare const chains$1: Record<Lowercase<Name>, Chain$1>;
 declare function streamLogs<abiEvent extends AbiEvent | undefined = undefined>(parameters: {
-    client: PublicClient;
-    contractAddress: Address;
-    event?: abiEvent;
-    blockNumberGte?: number;
-    blockNumberLte?: number;
-    order: "asc" | "desc";
-    options: {
-        maxBatchSize?: number;
-        blockWindow?: number;
-    };
+  client: PublicClient;
+  contractAddress?: Address;
+  event?: abiEvent;
+  blockNumberGte?: number;
+  blockNumberLte?: number;
+  order: "asc" | "desc";
+  options: {
+    maxBatchSize?: number;
+    blockWindow?: number;
+  };
 }): AsyncGenerator<{
-    logs: GetLogsReturnType<abiEvent | undefined>;
-    blockNumber: number;
+  logs: GetLogsReturnType<abiEvent | undefined>;
+  blockNumber: number;
 }, void, void>;
 declare class InvalidBlockRangeError extends BaseError {
-    name: string;
-    constructor(fromBlock: bigint, toBlock: bigint);
+  name: string;
+  constructor(fromBlock: bigint, toBlock: bigint);
 }
 declare class InvalidBlockWindowError extends BaseError {
-    name: string;
-    constructor(blockWindow: number);
+  name: string;
+  constructor(blockWindow: number);
 }
 declare class InvalidBatchSizeError extends BaseError {
-    name: string;
-    constructor(maxBatchSize: number);
+  name: string;
+  constructor(maxBatchSize: number);
 }
 declare class MissingBlockNumberError extends BaseError {
-    name: string;
-    constructor();
+  name: string;
+  constructor();
 }
-
-type Chain$1_Chain = Chain;
-declare const Chain$1_ChainId: typeof ChainId;
-type Chain$1_ChainName = ChainName;
-type Chain$1_Id = Id;
-type Chain$1_InvalidBatchSizeError = InvalidBatchSizeError;
-declare const Chain$1_InvalidBatchSizeError: typeof InvalidBatchSizeError;
-type Chain$1_InvalidBlockRangeError = InvalidBlockRangeError;
-declare const Chain$1_InvalidBlockRangeError: typeof InvalidBlockRangeError;
-type Chain$1_InvalidBlockWindowError = InvalidBlockWindowError;
-declare const Chain$1_InvalidBlockWindowError: typeof InvalidBlockWindowError;
-type Chain$1_MissingBlockNumberError = MissingBlockNumberError;
-declare const Chain$1_MissingBlockNumberError: typeof MissingBlockNumberError;
-declare const Chain$1_chainIds: typeof chainIds;
-declare const Chain$1_chainNames: typeof chainNames;
-declare const Chain$1_chains: typeof chains;
-declare const Chain$1_getChain: typeof getChain;
-declare const Chain$1_getWhitelistedChains: typeof getWhitelistedChains;
-declare const Chain$1_streamLogs: typeof streamLogs;
-declare namespace Chain$1 {
-  export { type Chain$1_Chain as Chain, Chain$1_ChainId as ChainId, type Chain$1_ChainName as ChainName, type Chain$1_Id as Id, Chain$1_InvalidBatchSizeError as InvalidBatchSizeError, Chain$1_InvalidBlockRangeError as InvalidBlockRangeError, Chain$1_InvalidBlockWindowError as InvalidBlockWindowError, Chain$1_MissingBlockNumberError as MissingBlockNumberError, Chain$1_chainIds as chainIds, Chain$1_chainNames as chainNames, Chain$1_chains as chains, Chain$1_getChain as getChain, Chain$1_getWhitelistedChains as getWhitelistedChains, Chain$1_streamLogs as streamLogs };
+//#endregion
+//#region src/core/types.d.ts
+/** Combines members of an intersection into a readable type. */
+type Compute<type> = { [key in keyof type]: type[key] } & unknown;
+declare const BrandTypeId: unique symbol;
+type Brand<in out ID extends string | symbol> = {
+  readonly [BrandTypeId]: { readonly [id in ID]: ID };
+};
+declare namespace LLTV_d_exports {
+  export { InvalidLLTVError, InvalidOptionError$1 as InvalidOptionError, LLTV, LLTVSchema, Options, from$12 as from };
 }
-
 type LLTV = bigint & Brand<"LLTV">;
 declare const Options: readonly [0.385, 0.5, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965, 0.98];
 type Options = (typeof Options)[number];
@@ -400,55 +480,48 @@ type Options = (typeof Options)[number];
  * @param lltv - The LLTV option or the scaled LLTV.
  * @returns The LLTV.
  */
-declare function from$9(lltv: Options | bigint): LLTV;
-declare namespace from$9 {
-    type ErrorType = InvalidOptionError$1 | InvalidLLTVError;
+declare function from$12(lltv: Options | bigint): LLTV;
+declare namespace from$12 {
+  type ErrorType = InvalidOptionError$1 | InvalidLLTVError;
 }
 declare class InvalidOptionError$1 extends BaseError {
-    readonly name = "LLTV.InvalidOptionError";
-    constructor(input: number);
+  readonly name = "LLTV.InvalidOptionError";
+  constructor(input: number);
 }
 declare class InvalidLLTVError extends BaseError {
-    readonly name = "LLTV.InvalidLLTVError";
-    constructor(input: bigint);
+  readonly name = "LLTV.InvalidLLTVError";
+  constructor(input: bigint);
 }
-declare const LLTVSchema: z.ZodPipe<z.ZodBigInt, z.ZodTransform<LLTV, bigint>>;
-
-type LLTV$1_InvalidLLTVError = InvalidLLTVError;
-declare const LLTV$1_InvalidLLTVError: typeof InvalidLLTVError;
-type LLTV$1_LLTV = LLTV;
-declare const LLTV$1_LLTVSchema: typeof LLTVSchema;
-type LLTV$1_Options = Options;
-declare namespace LLTV$1 {
-  export { LLTV$1_InvalidLLTVError as InvalidLLTVError, InvalidOptionError$1 as InvalidOptionError, type LLTV$1_LLTV as LLTV, LLTV$1_LLTVSchema as LLTVSchema, type LLTV$1_Options as Options, from$9 as from };
+declare const LLTVSchema: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+declare namespace Collateral_d_exports {
+  export { Collateral, CollateralSchema, CollateralsSchema, from$11 as from, random$3 as random };
 }
-
 type Collateral = {
-    /** Asset being used as collateral. */
+  /** Asset being used as collateral. */
+  asset: Address;
+  /** Liquidation Loan-to-Value of the collateral. */
+  lltv: LLTV;
+  /** Oracle contract used to price the collateral. */
+  oracle: Address;
+};
+declare const CollateralSchema: z$1.ZodObject<{
+  asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+}, z$1.core.$strip>;
+declare const CollateralsSchema: z$1.ZodArray<z$1.ZodObject<{
+  asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+}, z$1.core.$strip>>;
+declare const from$11: (parameters: from$11.Parameters) => from$11.ReturnType;
+declare namespace from$11 {
+  type Parameters = {
     asset: Address;
-    /** Liquidation Loan-to-Value of the collateral. */
-    lltv: LLTV;
-    /** Oracle contract used to price the collateral. */
+    lltv: Options | bigint;
     oracle: Address;
-};
-declare const CollateralSchema: z.ZodObject<{
-    asset: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    oracle: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    lltv: z.ZodPipe<z.ZodBigInt, z.ZodTransform<LLTV, bigint>>;
-}, z.core.$strip>;
-declare const CollateralsSchema: z.ZodArray<z.ZodObject<{
-    asset: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    oracle: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    lltv: z.ZodPipe<z.ZodBigInt, z.ZodTransform<LLTV, bigint>>;
-}, z.core.$strip>>;
-declare const from$8: (parameters: from$8.Parameters) => from$8.ReturnType;
-declare namespace from$8 {
-    type Parameters = {
-        asset: Address;
-        lltv: Options | bigint;
-        oracle: Address;
-    };
-    type ReturnType = Collateral;
+  };
+  type ReturnType = Collateral;
 }
 /**
  * Generates a random collateral.
@@ -461,34 +534,107 @@ declare namespace from$8 {
  */
 declare function random$3(): random$3.ReturnType;
 declare namespace random$3 {
-    type ReturnType = Collateral;
+  type ReturnType = Collateral;
 }
-
-type Collateral$1_Collateral = Collateral;
-declare const Collateral$1_CollateralSchema: typeof CollateralSchema;
-declare const Collateral$1_CollateralsSchema: typeof CollateralsSchema;
-declare namespace Collateral$1 {
-  export { type Collateral$1_Collateral as Collateral, Collateral$1_CollateralSchema as CollateralSchema, Collateral$1_CollateralsSchema as CollateralsSchema, from$8 as from, random$3 as random };
+declare namespace ERC4626_d_exports {
+  export { DenominatorIsZeroError, convertToAssets, convertToShares, decimalsOffset };
+}
+/**
+ * Calculate the decimals offset used by the ERC4626 implementation.
+ * @param parameters - {@link decimalsOffset.Parameters}.
+ * @returns The decimals offset.
+ *
+ * @example
+ * ```ts
+ * const decimalsOffset = decimalsOffset({ underlyingDecimals: 6 });
+ * // decimalsOffset = 12
+ * ```
+ */
+declare function decimalsOffset(parameters: decimalsOffset.Parameters): number;
+declare namespace decimalsOffset {
+  type Parameters = {
+    /** The number of decimals of the underlying asset. */
+    underlyingDecimals: number;
+  };
+  type ReturnType = number;
+}
+/**
+ * Convert shares to assets.
+ * @throws If the denominator is 0. {@link DenominatorIsZeroError}
+ * @param parameters - {@link convertToAssets.Parameters}.
+ * @returns The amount of assets.
+ *
+ * @example
+ * ```ts
+ * const assets = convertToAssets(100n, { totalAssets: 1000n, totalSupply: 1000n, decimalsOffset: 18 });
+ * // assets = 100n
+ * ```
+ */
+declare function convertToAssets(parameters: convertToAssets.Parameters): convertToAssets.ReturnType;
+declare namespace convertToAssets {
+  type Parameters = {
+    /** The amount of shares to convert. */
+    shares: bigint;
+    /** Total amount of assets in the vault. */
+    totalAssets: bigint;
+    /** Total amount of shares in the vault. */
+    totalSupply: bigint;
+    /**
+     * OpenZeppelin decimals offset used by the ERC4626 implementation.
+     * Calculated to be `max(0, 18 - underlyingDecimals)` at construction, so the initial conversion rate maximizes
+     * precision between shares and assets.
+     */
+    decimalsOffset: number;
+  };
+  type ReturnType = bigint;
+  type ErrorType = DenominatorIsZeroError;
+}
+/**
+ * Convert assets to shares.
+ * @throws If the denominator is 0. {@link DenominatorIsZeroError}
+ * @param parameters - {@link convertToShares.Parameters}.
+ * @returns The amount of shares.
+ *
+ * @example
+ * ```ts
+ * const shares = convertToShares(100n, { totalAssets: 1000n, totalSupply: 1000n, decimalsOffset: 12 });
+ * // shares = 100n
+ * ```
+ */
+declare function convertToShares(parameters: convertToShares.Parameters): convertToShares.ReturnType;
+declare namespace convertToShares {
+  type Parameters = {
+    /** The amount of assets to convert. */
+    assets: bigint;
+    /** Total amount of assets in the vault. */
+    totalAssets: bigint;
+    /** Total amount of shares in the vault. */
+    totalSupply: bigint;
+    /**
+     * OpenZeppelin decimals offset used by the ERC4626 implementation.
+     * Calculated to be `max(0, 18 - underlyingDecimals)` at construction, so the initial conversion rate maximizes
+     * precision between shares and assets.
+     */
+    decimalsOffset: number;
+  };
+  type ReturnType = bigint;
+  type ErrorType = DenominatorIsZeroError;
+}
+declare class DenominatorIsZeroError extends BaseError {
+  readonly name = "ERC4626.DenominatorIsZeroError";
+  constructor();
+}
+declare namespace Format_d_exports {
+  export { Snake, fromSnakeCase$3 as fromSnakeCase, stringifyBigint, toSnakeCase$1 as toSnakeCase };
 }
-
 /** The snake case representation of a type with bigint values stringified. */
 type Snake<T> = DeepMutable<SnakeKeys<StringifiedBigint<T>>>;
 /** Make arrays/tuples and object props mutable, deeply. */
-type DeepMutable<T> = T extends (...args: unknown[]) => unknown ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? {
-    -readonly [K in keyof R]: DeepMutable<R[K]>;
-} : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? {
-    -readonly [K in keyof T]: DeepMutable<T[K]>;
-} : T;
+type DeepMutable<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepMutable<R[K]> } : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } : T;
 /** Stringifies bigint values to strings and preserves branded primitives. */
-type StringifiedBigint<T> = [
-    T
-] extends [bigint] ? string : [T] extends [`0x${string}`] ? string : T extends number ? T : T extends string ? T : T extends boolean ? T : T extends symbol ? T : T extends null | undefined ? T : T extends readonly (infer U)[] ? readonly StringifiedBigint<U>[] : T extends object ? {
-    [K in keyof T]: StringifiedBigint<T[K]>;
-} : T;
+type StringifiedBigint<T> = [T] extends [bigint] ? string : [T] extends [`0x${string}`] ? string : T extends number ? T : T extends string ? T : T extends boolean ? T : T extends symbol ? T : T extends null | undefined ? T : T extends readonly (infer U)[] ? readonly StringifiedBigint<U>[] : T extends object ? { [K in keyof T]: StringifiedBigint<T[K]> } : T;
 /** Key remapping that also preserves branded primitives. */
-type SnakeKeys<T> = T extends readonly (infer U)[] ? readonly SnakeKeys<U>[] : T extends number | string | boolean | symbol | null | undefined ? T : T extends object ? {
-    [K in keyof T as ToSnakeCase<Extract<K, string>>]: SnakeKeys<T[K]>;
-} : T;
+type SnakeKeys<T> = T extends readonly (infer U)[] ? readonly SnakeKeys<U>[] : T extends number | string | boolean | symbol | null | undefined ? T : T extends object ? { [K in keyof T as ToSnakeCase<Extract<K, string>>]: SnakeKeys<T[K]> } : T;
 type ToSnakeCase<S extends string> = S extends `${infer Head}${infer Tail}` ? Tail extends Uncapitalize<Tail> ? `${Lowercase<Head>}${ToSnakeCase<Tail>}` : `${Lowercase<Head>}_${ToSnakeCase<Uncapitalize<Tail>>}` : S;
 /**
  * Formats object keys to snake case.
@@ -505,33 +651,29 @@ declare function toSnakeCase$1<T>(obj: T): Snake<T>;
  */
 declare function fromSnakeCase$3<T>(obj: Snake<T>): T;
 declare function stringifyBigint<T>(value: T): StringifiedBigint<T>;
-
-type Format_Snake<T> = Snake<T>;
-declare const Format_stringifyBigint: typeof stringifyBigint;
-declare namespace Format {
-  export { type Format_Snake as Snake, fromSnakeCase$3 as fromSnakeCase, Format_stringifyBigint as stringifyBigint, toSnakeCase$1 as toSnakeCase };
+declare namespace Maturity_d_exports {
+  export { InvalidDateError, InvalidFormatError, InvalidOptionError, Maturity, MaturityOptions, MaturitySchema, MaturityType, from$10 as from };
 }
-
 /**
  * Maturity is a number that represents a date in seconds.
  */
 type Maturity = number & Brand<"Maturity">;
-declare const MaturitySchema: z.ZodPipe<z.ZodNumber, z.ZodTransform<Maturity, number>>;
+declare const MaturitySchema: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
 declare enum MaturityType {
-    EndOfWeek = "end_of_week",
-    EndOfNextWeek = "end_of_next_week",
-    EndOfMonth = "end_of_month",
-    EndOfNextMonth = "end_of_next_month",
-    EndOfQuarter = "end_of_quarter",
-    EndOfNextQuarter = "end_of_next_quarter"
+  EndOfWeek = "end_of_week",
+  EndOfNextWeek = "end_of_next_week",
+  EndOfMonth = "end_of_month",
+  EndOfNextMonth = "end_of_next_month",
+  EndOfQuarter = "end_of_quarter",
+  EndOfNextQuarter = "end_of_next_quarter",
 }
 declare const MaturityOptions: {
-    readonly end_of_week: () => Maturity;
-    readonly end_of_next_week: () => Maturity;
-    readonly end_of_month: () => Maturity;
-    readonly end_of_next_month: () => Maturity;
-    readonly end_of_quarter: () => Maturity;
-    readonly end_of_next_quarter: () => Maturity;
+  readonly end_of_week: () => Maturity;
+  readonly end_of_next_week: () => Maturity;
+  readonly end_of_month: () => Maturity;
+  readonly end_of_next_month: () => Maturity;
+  readonly end_of_quarter: () => Maturity;
+  readonly end_of_next_quarter: () => Maturity;
 };
 type MaturityOptions = keyof typeof MaturityOptions;
 /**
@@ -540,118 +682,117 @@ type MaturityOptions = keyof typeof MaturityOptions;
  * @throws {InvalidDateError} If the maturity is in seconds but not a valid date.
  * @throws {InvalidOptionError} If the maturity is not a valid option.
  */
-declare function from$7(ts: from$7.Parameters): Maturity;
-declare namespace from$7 {
-    type Parameters = number | MaturityOptions;
-    type ErrorType = InvalidFormatError | InvalidDateError | InvalidOptionError;
+declare function from$10(ts: from$10.Parameters): Maturity;
+declare namespace from$10 {
+  type Parameters = number | MaturityOptions;
+  type ErrorType = InvalidFormatError | InvalidDateError | InvalidOptionError;
 }
 declare class InvalidFormatError extends BaseError {
-    readonly name = "Maturity.InvalidFormatError";
-    constructor();
+  readonly name = "Maturity.InvalidFormatError";
+  constructor();
 }
 declare class InvalidDateError extends BaseError {
-    readonly name = "Maturity.InvalidDateError";
-    constructor(input: number);
+  readonly name = "Maturity.InvalidDateError";
+  constructor(input: number);
 }
 declare class InvalidOptionError extends BaseError {
-    readonly name = "Maturity.InvalidOptionError";
-    constructor(input: string);
+  readonly name = "Maturity.InvalidOptionError";
+  constructor(input: string);
 }
-
-type Maturity$1_InvalidDateError = InvalidDateError;
-declare const Maturity$1_InvalidDateError: typeof InvalidDateError;
-type Maturity$1_InvalidFormatError = InvalidFormatError;
-declare const Maturity$1_InvalidFormatError: typeof InvalidFormatError;
-type Maturity$1_InvalidOptionError = InvalidOptionError;
-declare const Maturity$1_InvalidOptionError: typeof InvalidOptionError;
-type Maturity$1_Maturity = Maturity;
-type Maturity$1_MaturityOptions = MaturityOptions;
-declare const Maturity$1_MaturitySchema: typeof MaturitySchema;
-type Maturity$1_MaturityType = MaturityType;
-declare const Maturity$1_MaturityType: typeof MaturityType;
-declare namespace Maturity$1 {
-  export { Maturity$1_InvalidDateError as InvalidDateError, Maturity$1_InvalidFormatError as InvalidFormatError, Maturity$1_InvalidOptionError as InvalidOptionError, type Maturity$1_Maturity as Maturity, type Maturity$1_MaturityOptions as MaturityOptions, Maturity$1_MaturitySchema as MaturitySchema, Maturity$1_MaturityType as MaturityType, from$7 as from };
+declare namespace Offer_d_exports {
+  export { AccountNotSetError, InvalidOfferError, Offer, OfferConsumed, OfferHashSchema, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$2 as decode, domain, encode$2 as encode, from$9 as from, fromSnakeCase$2 as fromSnakeCase, hash, obligationId, random$2 as random, serialize, sign, signatureMsg, toSnakeCase, types };
 }
-
 type Offer = {
-    /** The address that made the offer. */
-    readonly offering: Address;
-    /** The amount of assets offered. */
-    readonly assets: bigint;
-    /** The interest rate (with 18 decimals). */
-    readonly rate: bigint;
-    /** The date at which all interests will be paid. */
-    readonly maturity: Maturity;
-    /** The date at which the offer will expire. */
-    readonly expiry: number;
-    /** The date at which the offer will start. */
-    readonly start: number;
-    /** The nonce. Used for OCO (One-Cancelled-Other) mechanism. */
-    readonly nonce: bigint;
-    /** The side of the offer. `true` for buy, `false` for sell. */
-    readonly buy: boolean;
-    /** The chain id where the liquidity for this offer is located. */
-    readonly chainId: bigint;
-    /** The token that is being borrowed. */
-    readonly loanToken: Address;
-    /** The exact set of collaterals required to borrow the loan token. */
-    readonly collaterals: readonly Collateral[];
-    /** The optional callback data to retrieve the maker funds. */
-    readonly callback: {
-        readonly address: Address;
-        readonly data: Hex;
-        readonly gasLimit: bigint;
-    };
-    /** The amount of assets consumed from the offer. */
-    consumed: bigint;
-    /** The hash of the offer. */
-    readonly hash: Hex;
-    /** The block number at which the offer was created. */
-    readonly blockNumber: number;
-    /** The signature of the offer. */
-    signature?: Hex;
+  /** The address that made the offer. */
+  readonly offering: Address;
+  /** The amount of assets offered. */
+  readonly assets: bigint;
+  /**
+   * The amount of assets that can be taken from the offer. takeable = min(max - consumed, available)
+   * Where available is the total amount of assets retrievable from offering positions.
+   */
+  readonly takeable: bigint;
+  /** The interest rate (with 18 decimals). */
+  readonly rate: bigint;
+  /** The date at which all interests will be paid. */
+  readonly maturity: Maturity;
+  /** The date at which the offer will expire. */
+  readonly expiry: number;
+  /** The date at which the offer will start. */
+  readonly start: number;
+  /** The nonce. Used for OCO (One-Cancelled-Other) mechanism. */
+  readonly nonce: bigint;
+  /** The side of the offer. `true` for buy, `false` for sell. */
+  readonly buy: boolean;
+  /** The chain id where the liquidity for this offer is located. */
+  readonly chainId: Id;
+  /** The token that is being borrowed. */
+  readonly loanToken: Address;
+  /** The exact set of collaterals required to borrow the loan token. */
+  readonly collaterals: readonly Collateral[];
+  /** The optional callback data to retrieve the maker funds. */
+  readonly callback: {
+    readonly address: Address;
+    readonly data: Hex;
+    readonly gasLimit: bigint;
+  };
+  /** The amount of assets consumed from the offer. */
+  consumed: bigint;
+  /** The hash of the offer. */
+  readonly hash: Hex;
+  /** The block number at which the offer was created. */
+  readonly blockNumber: number;
+  /** The signature of the offer. */
+  signature?: Hex;
 };
-declare enum StatusCode {
-    VALID = "VALID",
-    NOT_ENOUGH_LIQUIDITY = "NOT_ENOUGH_LIQUIDITY"
+declare enum Status {
+  VALID = "VALID",
+  SIMULATION_ERROR = "SIMULATION_ERROR",
 }
-declare const OfferHashSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+type Validation = {
+  offerHash: Hex;
+  status: Status;
+};
+declare const OfferHashSchema: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
 declare const OfferSchema: (parameters?: {
-    omitHash?: boolean;
-    omitConsumed?: boolean;
-    omitBlockNumber?: boolean;
-}) => z.ZodObject<{
-    offering: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    assets: z.ZodBigInt;
-    rate: z.ZodBigInt;
-    maturity: z.ZodPipe<z.ZodNumber, z.ZodTransform<Maturity, number>>;
-    expiry: z.ZodNumber;
-    start: z.ZodNumber;
-    nonce: z.ZodBigInt;
-    buy: z.ZodBoolean;
-    chainId: z.ZodBigInt;
-    loanToken: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    collaterals: z.ZodArray<z.ZodObject<{
-        asset: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        oracle: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        lltv: z.ZodPipe<z.ZodBigInt, z.ZodTransform<LLTV, bigint>>;
-    }, z.core.$strip>>;
-    callback: z.ZodObject<{
-        address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        data: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        gasLimit: z.ZodBigInt;
-    }, z.core.$strip>;
-    signature: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
-}, z.core.$strip>;
+  omitHash?: boolean;
+}) => z$1.ZodObject<{
+  offering: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  assets: z$1.ZodBigInt;
+  rate: z$1.ZodBigInt;
+  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
+  expiry: z$1.ZodNumber;
+  start: z$1.ZodNumber;
+  nonce: z$1.ZodBigInt;
+  buy: z$1.ZodBoolean;
+  chainId: z$1.ZodNumber;
+  loanToken: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  collaterals: z$1.ZodArray<z$1.ZodObject<{
+    asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+  }, z$1.core.$strip>>;
+  callback: z$1.ZodObject<{
+    address: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    data: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    gasLimit: z$1.ZodBigInt;
+  }, z$1.core.$strip>;
+  signature: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+  consumed: z$1.ZodOptional<z$1.ZodBigInt>;
+  takeable: z$1.ZodOptional<z$1.ZodBigInt>;
+  blockNumber: z$1.ZodOptional<z$1.ZodNumber>;
+}, z$1.core.$strip>;
 /**
  * Creates an offer from a plain object.
  * @throws {InvalidOfferError} If the offer is invalid.
  * @param input - The offer to create.
  * @returns The created offer with its hash.
  */
-declare function from$6(input: Omit<Offer, "hash">): Offer;
-declare namespace from$6 {
-    type ErrorType = InvalidOfferError;
+declare function from$9(input: Compute<Omit<Offer, "chainId" | "hash"> & {
+  chainId: number;
+}>): Offer;
+declare namespace from$9 {
+  type ErrorType = InvalidOfferError;
 }
 /**
  * Creates an offer from a snake case object.
@@ -659,34 +800,69 @@ declare namespace from$6 {
  * @param input - The offer to create.
  * @returns The created offer with its hash.
  */
-declare function fromSnakeCase$2(input: Snake<Omit<Offer, "hash">>): Offer;
+declare function fromSnakeCase$2(input: Snake<Omit<Offer, "chainId" | "hash"> & {
+  chainId: number;
+}>): Offer;
 /**
  * Converts an offer to a snake case object.
  * @param offer - The offer to convert.
  * @returns The converted offer.
  */
 declare function toSnakeCase(offer: Offer): Snake<Offer>;
+/**
+ * Serializes an offer for merkle tree encoding.
+ * Converts BigInt fields to strings for JSON compatibility.
+ *
+ * @param offer - Offer to serialize
+ * @returns JSON-serializable offer object
+ */
+declare const serialize: (offer: Offer) => {
+  offering: `0x${string}`;
+  assets: string;
+  rate: string;
+  maturity: number;
+  expiry: number;
+  start: number;
+  nonce: string;
+  buy: boolean;
+  chainId: Id;
+  loanToken: `0x${string}`;
+  collaterals: {
+    asset: `0x${string}`;
+    oracle: `0x${string}`;
+    lltv: string;
+  }[];
+  callback: {
+    address: `0x${string}`;
+    data: `0x${string}`;
+    gasLimit: string;
+  };
+  signature: `0x${string}` | undefined;
+  hash: `0x${string}`;
+};
 type RandomConfig = {
-    chains?: Chain[];
-    loanTokens?: Address[];
-    collateralTokens?: Address[];
-    assetsDecimals?: Record<Address, number>;
-    buy?: boolean;
-    assets?: bigint;
-    consumed?: bigint;
-    offering?: Address;
-    maturity?: Maturity;
-    start?: number;
-    expiry?: number;
-    nonce?: bigint;
-    rate?: bigint;
-    callback?: {
-        address: Address;
-        data: Hex;
-        gasLimit: bigint;
-    };
-    collaterals?: readonly Collateral[];
-    signature?: Hex;
+  chains?: Chain$1[];
+  loanTokens?: Address[];
+  collateralTokens?: Address[];
+  assetsDecimals?: Record<Address, number>;
+  buy?: boolean;
+  assets?: bigint;
+  consumed?: bigint;
+  takeable?: bigint;
+  offering?: Address;
+  maturity?: Maturity;
+  start?: number;
+  expiry?: number;
+  nonce?: bigint;
+  rate?: bigint;
+  callback?: {
+    address: Address;
+    data: Hex;
+    gasLimit: bigint;
+  };
+  collaterals?: readonly Collateral[];
+  signature?: Hex;
+  blockNumber?: number;
 };
 /**
  * Generates a random Offer.
@@ -700,9 +876,9 @@ declare function random$2(config?: RandomConfig): Offer;
  * @param chainId - The chain ID.
  * @returns The EIP-712 domain object.
  */
-declare const domain: (chainId: bigint) => {
-    chainId: bigint;
-    verifyingContract: "0x0000000000000000000000000000000000000000";
+declare const domain: (chainId: number) => {
+  chainId: bigint;
+  verifyingContract: "0x0000000000000000000000000000000000000000";
 };
 /**
  * The EIP-712 types for the offer.
@@ -710,64 +886,64 @@ declare const domain: (chainId: bigint) => {
  * @returns The EIP-712 types.
  */
 declare const types: {
-    readonly EIP712Domain: readonly [{
-        readonly name: "chainId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "verifyingContract";
-        readonly type: "address";
-    }];
-    readonly Offer: readonly [{
-        readonly name: "offering";
-        readonly type: "address";
-    }, {
-        readonly name: "assets";
-        readonly type: "uint256";
-    }, {
-        readonly name: "rate";
-        readonly type: "uint256";
-    }, {
-        readonly name: "maturity";
-        readonly type: "uint256";
-    }, {
-        readonly name: "expiry";
-        readonly type: "uint256";
-    }, {
-        readonly name: "nonce";
-        readonly type: "uint256";
-    }, {
-        readonly name: "buy";
-        readonly type: "bool";
-    }, {
-        readonly name: "loanToken";
-        readonly type: "address";
-    }, {
-        readonly name: "collaterals";
-        readonly type: "Collateral[]";
-    }, {
-        readonly name: "callback";
-        readonly type: "Callback";
-    }];
-    readonly Collateral: readonly [{
-        readonly name: "asset";
-        readonly type: "address";
-    }, {
-        readonly name: "oracle";
-        readonly type: "address";
-    }, {
-        readonly name: "lltv";
-        readonly type: "uint256";
-    }];
-    readonly Callback: readonly [{
-        readonly name: "address";
-        readonly type: "address";
-    }, {
-        readonly name: "data";
-        readonly type: "bytes";
-    }, {
-        readonly name: "gasLimit";
-        readonly type: "uint256";
-    }];
+  readonly EIP712Domain: readonly [{
+    readonly name: "chainId";
+    readonly type: "uint256";
+  }, {
+    readonly name: "verifyingContract";
+    readonly type: "address";
+  }];
+  readonly Offer: readonly [{
+    readonly name: "offering";
+    readonly type: "address";
+  }, {
+    readonly name: "assets";
+    readonly type: "uint256";
+  }, {
+    readonly name: "rate";
+    readonly type: "uint256";
+  }, {
+    readonly name: "maturity";
+    readonly type: "uint256";
+  }, {
+    readonly name: "expiry";
+    readonly type: "uint256";
+  }, {
+    readonly name: "nonce";
+    readonly type: "uint256";
+  }, {
+    readonly name: "buy";
+    readonly type: "bool";
+  }, {
+    readonly name: "loanToken";
+    readonly type: "address";
+  }, {
+    readonly name: "collaterals";
+    readonly type: "Collateral[]";
+  }, {
+    readonly name: "callback";
+    readonly type: "Callback";
+  }];
+  readonly Collateral: readonly [{
+    readonly name: "asset";
+    readonly type: "address";
+  }, {
+    readonly name: "oracle";
+    readonly type: "address";
+  }, {
+    readonly name: "lltv";
+    readonly type: "uint256";
+  }];
+  readonly Callback: readonly [{
+    readonly name: "address";
+    readonly type: "address";
+  }, {
+    readonly name: "data";
+    readonly type: "bytes";
+  }, {
+    readonly name: "gasLimit";
+    readonly type: "uint256";
+  }];
 };
 /**
  * Signs an array of offers.
@@ -789,108 +965,88 @@ declare function obligationId(offer: Offer): Hex;
 declare function encode$2(offer: Offer): `0x${string}`;
 declare function decode$2(data: Hex, blockNumber: number | bigint): Offer;
 type OfferConsumed = {
-    id: string;
-    chainId: bigint;
-    offering: Address;
-    nonce: bigint;
-    amount: bigint;
-    blockNumber: number;
+  id: string;
+  chainId: Id;
+  offering: Address;
+  nonce: bigint;
+  amount: bigint;
+  blockNumber: number;
 };
 /**
  * ABI for the Consumed event emitted by the Obligation contract.
  */
 declare const consumedEvent: {
-    readonly type: "event";
-    readonly name: "Consumed";
-    readonly inputs: readonly [{
-        readonly name: "user";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "nonce";
-        readonly type: "uint256";
-        readonly indexed: true;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }];
-    readonly anonymous: false;
+  readonly type: "event";
+  readonly name: "Consumed";
+  readonly inputs: readonly [{
+    readonly name: "user";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "nonce";
+    readonly type: "uint256";
+    readonly indexed: true;
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "amount";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }];
+  readonly anonymous: false;
 };
-declare function fromConsumedLog(parameters: {
-    blockNumber: bigint;
-    logIndex: number;
-    chainId: number;
-    transactionHash: Hex;
-    user: Address;
-    nonce: bigint;
-    amount: bigint;
-}): OfferConsumed;
-declare class InvalidOfferError extends BaseError<z.ZodError | Error> {
-    readonly name = "Offer.InvalidOfferError";
-    constructor(error: z.ZodError | Error);
+declare class InvalidOfferError extends BaseError<z$1.ZodError | Error> {
+  readonly name = "Offer.InvalidOfferError";
+  constructor(error: z$1.ZodError | Error);
+  /**
+   * Formats ZodError issues into a human-readable string with line breaks.
+   * @example
+   * "- 'assets': too small, expected >= 0
+   *  - 'start': must be before expiry"
+   */
+  static formatDetails(error: z$1.ZodError | Error): string;
+  /**
+   * Returns the formatted human-readable message.
+   */
+  get formattedMessage(): string;
 }
 declare class AccountNotSetError extends BaseError {
-    readonly name = "Offer.AccountNotSetError";
-    constructor();
+  readonly name = "Offer.AccountNotSetError";
+  constructor();
 }
-
-type Offer$1_AccountNotSetError = AccountNotSetError;
-declare const Offer$1_AccountNotSetError: typeof AccountNotSetError;
-type Offer$1_InvalidOfferError = InvalidOfferError;
-declare const Offer$1_InvalidOfferError: typeof InvalidOfferError;
-type Offer$1_Offer = Offer;
-type Offer$1_OfferConsumed = OfferConsumed;
-declare const Offer$1_OfferHashSchema: typeof OfferHashSchema;
-declare const Offer$1_OfferSchema: typeof OfferSchema;
-type Offer$1_RandomConfig = RandomConfig;
-type Offer$1_StatusCode = StatusCode;
-declare const Offer$1_StatusCode: typeof StatusCode;
-declare const Offer$1_consumedEvent: typeof consumedEvent;
-declare const Offer$1_domain: typeof domain;
-declare const Offer$1_fromConsumedLog: typeof fromConsumedLog;
-declare const Offer$1_hash: typeof hash;
-declare const Offer$1_obligationId: typeof obligationId;
-declare const Offer$1_sign: typeof sign;
-declare const Offer$1_signatureMsg: typeof signatureMsg;
-declare const Offer$1_toSnakeCase: typeof toSnakeCase;
-declare const Offer$1_types: typeof types;
-declare namespace Offer$1 {
-  export { Offer$1_AccountNotSetError as AccountNotSetError, Offer$1_InvalidOfferError as InvalidOfferError, type Offer$1_Offer as Offer, type Offer$1_OfferConsumed as OfferConsumed, Offer$1_OfferHashSchema as OfferHashSchema, Offer$1_OfferSchema as OfferSchema, type Offer$1_RandomConfig as RandomConfig, Offer$1_StatusCode as StatusCode, Offer$1_consumedEvent as consumedEvent, decode$2 as decode, Offer$1_domain as domain, encode$2 as encode, from$6 as from, Offer$1_fromConsumedLog as fromConsumedLog, fromSnakeCase$2 as fromSnakeCase, Offer$1_hash as hash, Offer$1_obligationId as obligationId, random$2 as random, Offer$1_sign as sign, Offer$1_signatureMsg as signatureMsg, Offer$1_toSnakeCase as toSnakeCase, Offer$1_types as types };
+declare namespace Liquidity_d_exports {
+  export { LiquidityLink, LiquidityPool, OfferLiquidityPool, calculateMaxDebt, generateAllowancePoolId, generateBalancePoolId, generateBuyVaultCallbackPoolId, generateDebtPoolId, generateMarketLiquidityPoolId, generateObligationCollateralPoolId, generateSellERC20CallbackPoolId, generateUserVaultPositionPoolId, generateVaultPositionPoolId };
 }
-
 /**
  * Represents a liquidity pool with a unique ID and amount.
  */
 type LiquidityPool = {
-    id: string;
-    amount: bigint;
+  id: string;
+  amount: bigint;
 };
 /**
  * Represents a hierarchical relationship between two liquidity pools.
  */
 type LiquidityLink = {
-    parentPoolId: string;
-    childPoolId: string;
-    priority: number;
+  parentPoolId: string;
+  childPoolId: string;
+  priority: number;
 };
 /**
  * Represents the connection between an offer and its liquidity pools.
  */
 type OfferLiquidityPool = {
-    offerHash: Offer["hash"];
-    poolId: string;
-    /**
-     * The available capacity/liquidity from this pool for this offer.
-     * Meaning varies by pool type:
-     * - BuyWithEmptyCallback: Matches allowance amount from pool bellow
-     * - SellERC20Callback: Sell Callback/Predeposited -> Maximum debt capacity calculated from collateral (collateralAmount * oraclePrice * lltv)
-     * - SellERC20Callback: Existing debt as negative value (reduces available capacity)
-     */
-    amount: bigint;
+  offerHash: Offer["hash"];
+  poolId: string;
+  /**
+   * The available capacity/liquidity from this pool for this offer.
+   * Meaning varies by pool type:
+   * - BuyWithEmptyCallback: Matches allowance amount from pool bellow
+   * - SellERC20Callback: Sell Callback/Predeposited -> Maximum debt capacity calculated from collateral (collateralAmount * oraclePrice * lltv)
+   * - SellERC20Callback: Existing debt as negative value (reduces available capacity)
+   */
+  amount: bigint;
 };
 /**
  * Calculate maximum debt capacity from collateral amount.
@@ -904,28 +1060,28 @@ declare function calculateMaxDebt(amount: bigint, oraclePrice: bigint, lltv: big
  * Generate pool ID for balance pools.
  */
 declare function generateBalancePoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    token: Address;
+  user: Address;
+  chainId: Id;
+  token: Address;
 }): string;
 /**
  * Generate pool ID for allowance pools.
  */
 declare function generateAllowancePoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    token: Address;
+  user: Address;
+  chainId: Id;
+  token: Address;
 }): string;
 /**
  * Generate pool ID for sell ERC20 callback pools.
  * Each offer has its own callback pool to prevent liquidity conflicts.
  */
 declare function generateSellERC20CallbackPoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    obligationId: Hex;
-    token: Address;
-    offerHash: Hex;
+  user: Address;
+  chainId: Id;
+  obligationId: Hex;
+  token: Address;
+  offerHash: Hex;
 }): string;
 /**
  * Generate pool ID for obligation collateral pools.
@@ -933,89 +1089,74 @@ declare function generateSellERC20CallbackPoolId(parameters: {
  * These pools are shared across all offers with the same obligation.
  */
 declare function generateObligationCollateralPoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    obligationId: Hex;
-    token: Address;
+  user: Address;
+  chainId: Id;
+  obligationId: Hex;
+  token: Address;
 }): string;
 /**
  * Generate pool ID for buy vault callback pools.
  */
 declare function generateBuyVaultCallbackPoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    vault: Address;
-    offerHash: Hex;
+  user: Address;
+  chainId: Id;
+  vault: Address;
+  offerHash: Hex;
 }): string;
 /**
  * Generate pool ID for debt pools.
  */
 declare function generateDebtPoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    obligationId: Hex;
+  user: Address;
+  chainId: Id;
+  obligationId: Hex;
 }): string;
 /**
  * Generate pool ID for user position in a vault.
  */
 declare function generateUserVaultPositionPoolId(parameters: {
-    user: Address;
-    chainId: bigint;
-    vault: Address;
+  user: Address;
+  chainId: Id;
+  vault: Address;
 }): string;
 /**
  * Generate pool ID for vault position in a market.
  */
 declare function generateVaultPositionPoolId(parameters: {
-    vault: Address;
-    chainId: bigint;
-    marketId: string;
+  vault: Address;
+  chainId: Id;
+  marketId: string;
 }): string;
 /**
  * Generate pool ID for market total liquidity.
  */
 declare function generateMarketLiquidityPoolId(parameters: {
-    chainId: bigint;
-    marketId: string;
+  chainId: Id;
+  marketId: string;
 }): string;
-
-type Liquidity_LiquidityLink = LiquidityLink;
-type Liquidity_LiquidityPool = LiquidityPool;
-type Liquidity_OfferLiquidityPool = OfferLiquidityPool;
-declare const Liquidity_calculateMaxDebt: typeof calculateMaxDebt;
-declare const Liquidity_generateAllowancePoolId: typeof generateAllowancePoolId;
-declare const Liquidity_generateBalancePoolId: typeof generateBalancePoolId;
-declare const Liquidity_generateBuyVaultCallbackPoolId: typeof generateBuyVaultCallbackPoolId;
-declare const Liquidity_generateDebtPoolId: typeof generateDebtPoolId;
-declare const Liquidity_generateMarketLiquidityPoolId: typeof generateMarketLiquidityPoolId;
-declare const Liquidity_generateObligationCollateralPoolId: typeof generateObligationCollateralPoolId;
-declare const Liquidity_generateSellERC20CallbackPoolId: typeof generateSellERC20CallbackPoolId;
-declare const Liquidity_generateUserVaultPositionPoolId: typeof generateUserVaultPositionPoolId;
-declare const Liquidity_generateVaultPositionPoolId: typeof generateVaultPositionPoolId;
-declare namespace Liquidity {
-  export { type Liquidity_LiquidityLink as LiquidityLink, type Liquidity_LiquidityPool as LiquidityPool, type Liquidity_OfferLiquidityPool as OfferLiquidityPool, Liquidity_calculateMaxDebt as calculateMaxDebt, Liquidity_generateAllowancePoolId as generateAllowancePoolId, Liquidity_generateBalancePoolId as generateBalancePoolId, Liquidity_generateBuyVaultCallbackPoolId as generateBuyVaultCallbackPoolId, Liquidity_generateDebtPoolId as generateDebtPoolId, Liquidity_generateMarketLiquidityPoolId as generateMarketLiquidityPoolId, Liquidity_generateObligationCollateralPoolId as generateObligationCollateralPoolId, Liquidity_generateSellERC20CallbackPoolId as generateSellERC20CallbackPoolId, Liquidity_generateUserVaultPositionPoolId as generateUserVaultPositionPoolId, Liquidity_generateVaultPositionPoolId as generateVaultPositionPoolId };
+declare namespace Obligation_d_exports {
+  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation, ObligationSchema, from$8 as from, fromSnakeCase$1 as fromSnakeCase, id, random$1 as random };
 }
-
 type Obligation = {
-    /** The chain id where the liquidity for this obligation is located. */
-    chainId: Id;
-    /** The token that is being borrowed for this obligation. */
-    loanToken: Address;
-    /** The exact set of collaterals required to borrow the loan token. */
-    collaterals: Collateral[];
-    /** The maturity of the obligation. */
-    maturity: Maturity;
+  /** The chain id where the liquidity for this obligation is located. */
+  chainId: Id;
+  /** The token that is being borrowed for this obligation. */
+  loanToken: Address;
+  /** The exact set of collaterals required to borrow the loan token. */
+  collaterals: Collateral[];
+  /** The maturity of the obligation. */
+  maturity: Maturity;
 };
-declare const ObligationSchema: z.ZodObject<{
-    chainId: z.ZodBigInt;
-    loanToken: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    collaterals: z.ZodArray<z.ZodObject<{
-        asset: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        oracle: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        lltv: z.ZodPipe<z.ZodBigInt, z.ZodTransform<LLTV, bigint>>;
-    }, z.core.$strip>>;
-    maturity: z.ZodPipe<z.ZodNumber, z.ZodTransform<Maturity, number>>;
-}, z.core.$strip>;
+declare const ObligationSchema: z$1.ZodObject<{
+  chainId: z$1.ZodNumber;
+  loanToken: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  collaterals: z$1.ZodArray<z$1.ZodObject<{
+    asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+  }, z$1.core.$strip>>;
+  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
+}, z$1.core.$strip>;
 /**
  * Creates an obligation from the given parameters.
  * @constructor
@@ -1026,7 +1167,7 @@ declare const ObligationSchema: z.ZodObject<{
  * @example
  * ```ts
  * const obligation = Obligation.from({
- *   chainId: 1n,
+ *   chainId: 1,
  *   loanToken: privateKeyToAccount(generatePrivateKey()).address,
  *   collaterals: [
  *     Collateral.from({
@@ -1039,20 +1180,20 @@ declare const ObligationSchema: z.ZodObject<{
  * });
  * ```
  */
-declare function from$5(parameters: from$5.Parameters): from$5.ReturnType;
-declare namespace from$5 {
-    type Parameters = {
-        /** The chain id where the liquidity for this obligation is located. */
-        chainId: Id;
-        /** The token that is being borrowed for this obligation. */
-        loanToken: Address;
-        /** The exact set of collaterals required to borrow the loan token. Must be sorted alphabetically by address. */
-        collaterals: from$8.Parameters[] | readonly from$8.Parameters[];
-        /** The maturity of the obligation. */
-        maturity: from$7.Parameters;
-    };
-    type ReturnType = Obligation;
-    type ErrorType = InvalidObligationError;
+declare function from$8(parameters: from$8.Parameters): from$8.ReturnType;
+declare namespace from$8 {
+  type Parameters = {
+    /** The chain id where the liquidity for this obligation is located. */
+    chainId: number;
+    /** The token that is being borrowed for this obligation. */
+    loanToken: Address;
+    /** The exact set of collaterals required to borrow the loan token. Must be sorted alphabetically by address. */
+    collaterals: from$11.Parameters[] | readonly from$11.Parameters[];
+    /** The maturity of the obligation. */
+    maturity: from$10.Parameters;
+  };
+  type ReturnType = Obligation;
+  type ErrorType = InvalidObligationError;
 }
 /**
  * Creates an obligation from a snake case object.
@@ -1062,9 +1203,11 @@ declare namespace from$5 {
  */
 declare function fromSnakeCase$1(input: fromSnakeCase$1.Parameters): fromSnakeCase$1.ReturnType;
 declare namespace fromSnakeCase$1 {
-    type Parameters = Snake<Obligation>;
-    type ReturnType = Obligation;
-    type ErrorType = InvalidObligationError;
+  type Parameters = Snake<Omit<Obligation, "chainId"> & {
+    chainId: number;
+  }>;
+  type ReturnType = Obligation;
+  type ErrorType = InvalidObligationError;
 }
 /**
  * Calculates the obligation id based on the smart contract's Obligation struct.
@@ -1082,9 +1225,9 @@ declare namespace fromSnakeCase$1 {
  */
 declare function id(obligation: id.Parameters): id.ReturnType;
 declare namespace id {
-    type Parameters = Obligation;
-    type ReturnType = Hex;
-    type ErrorType = CollateralsAreNotSortedError;
+  type Parameters = Obligation;
+  type ReturnType = Hex;
+  type ErrorType = CollateralsAreNotSortedError;
 }
 /**
  * Generates a random obligation.
@@ -1097,49 +1240,150 @@ declare namespace id {
  */
 declare function random$1(): random$1.ReturnType;
 declare namespace random$1 {
-    type ReturnType = Obligation;
+  type ReturnType = Obligation;
 }
-declare class InvalidObligationError extends BaseError<z.ZodError | Error> {
-    readonly name = "Obligation.InvalidObligationError";
-    constructor(error: z.ZodError | Error);
+declare class InvalidObligationError extends BaseError<z$1.ZodError | Error> {
+  readonly name = "Obligation.InvalidObligationError";
+  constructor(error: z$1.ZodError | Error);
 }
 declare class CollateralsAreNotSortedError extends BaseError {
-    readonly name = "Obligation.CollateralsAreNotSortedError";
-    constructor();
+  readonly name = "Obligation.CollateralsAreNotSortedError";
+  constructor();
 }
-
-type Obligation$1_CollateralsAreNotSortedError = CollateralsAreNotSortedError;
-declare const Obligation$1_CollateralsAreNotSortedError: typeof CollateralsAreNotSortedError;
-type Obligation$1_InvalidObligationError = InvalidObligationError;
-declare const Obligation$1_InvalidObligationError: typeof InvalidObligationError;
-type Obligation$1_Obligation = Obligation;
-declare const Obligation$1_ObligationSchema: typeof ObligationSchema;
-declare const Obligation$1_id: typeof id;
-declare namespace Obligation$1 {
-  export { Obligation$1_CollateralsAreNotSortedError as CollateralsAreNotSortedError, Obligation$1_InvalidObligationError as InvalidObligationError, type Obligation$1_Obligation as Obligation, Obligation$1_ObligationSchema as ObligationSchema, from$5 as from, fromSnakeCase$1 as fromSnakeCase, Obligation$1_id as id, random$1 as random };
+declare namespace Oracle_d_exports {
+  export { Conversion, Oracle, from$7 as from };
+}
+/**
+ * An oracle contract that provides price information for assets.
+ */
+type Oracle = {
+  /** The chain id where the oracle is deployed. */
+  readonly chainId: Id;
+  /** The address of the oracle contract. */
+  readonly address: Address;
+  /** The price returned by the oracle (in the oracle's native units), null if no price available. */
+  readonly price: bigint | null;
+  /** The block number at which the price was fetched. */
+  readonly blockNumber: number;
+};
+/**
+ * Create an Oracle from a plain object.
+ * @param data - The data to create the oracle from.
+ * @returns The created oracle.
+ */
+declare function from$7(data: from$7.Parameters): from$7.ReturnType;
+declare namespace from$7 {
+  type Parameters = {
+    chainId: Id;
+    address: Address;
+    price: string | null;
+    blockNumber: number;
+  };
+  type ReturnType = Oracle;
+}
+/**
+ * Conversion utilities for converting between collateral and loan token amounts
+ * using oracle prices and LLTV
+ */
+declare namespace Conversion {
+  /**
+   * Converts a collateral amount to loan token
+   * Uses the formula: (amount * price / 10^36) * lltv / 10^18
+   *
+   * @param amount - The collateral amount to convert
+   * @param params - Conversion parameters containing price (36 decimals) and lltv (18 decimals)
+   * @returns The equivalent loan token amount
+   */
+  function collateralToLoan(amount: bigint, params: {
+    price: bigint;
+    lltv: bigint;
+  }): bigint;
+  /**
+   * Converts a loan token amount to collateral
+   * Uses the inverse formula: (amount * 10^36 / price) * 10^18 / lltv
+   * Returns 0n if price or lltv is zero (invalid conversion).
+   *
+   * @param amount - The loan token amount to convert
+   * @param params - Conversion parameters containing price (36 decimals) and lltv (18 decimals)
+   * @returns The equivalent collateral amount, or 0n if conversion is invalid
+   */
+  function loanToCollateral(amount: bigint, params: {
+    price: bigint;
+    lltv: bigint;
+  }): bigint;
+}
+declare namespace Position_d_exports {
+  export { Position, Type, from$6 as from };
+}
+type Position = {
+  /** The chain id. */
+  chainId: Id;
+  /** The contract address from which the position is called.
+   * While balances are obviously tracked on ERC20 contracts, we prefer to track which contract is called to know the balance.
+   * For example, when depositing into a vault, we would specify the vault contract address as the contract not the underlying vault's ERC20 token address.
+   */
+  contract: Address;
+  /** The user address. */
+  user: Address;
+  /** The type of position. */
+  type: Type;
+  /** The balance of the position. */
+  balance?: bigint;
+  /** The underlying asset of the position.
+   * For ERC20 positions, this equals the contract address.
+   * For vault positions, this is the vault's underlying asset.
+   */
+  asset?: Address;
+  /** The block number at which the position was last updated. */
+  blockNumber: number;
+};
+declare enum Type {
+  ERC20 = "erc20",
+  VAULT_V1 = "vault_v1",
+}
+/**
+ * @constructor
+ * Creates a Position.
+ * @param parameters - {@link from.Parameters}
+ * @returns The created Position. {@link from.ReturnType}
+ */
+declare function from$6(parameters: from$6.Parameters): from$6.ReturnType;
+declare namespace from$6 {
+  type Parameters = {
+    chainId: Id;
+    contract: Address;
+    user: Address;
+    type: Type;
+    balance?: bigint;
+    asset?: Address;
+    blockNumber: number;
+  };
+  type ReturnType = Position;
+}
+declare namespace Quote_d_exports {
+  export { InvalidQuoteError, Quote, QuoteSchema, from$5 as from, fromSnakeCase, random };
 }
-
 type Quote = {
-    /** The obligation id. */
-    obligationId: Hex;
-    ask: {
-        /** The highest interest rate the seller will accept to pay for the obligation. (18 decimals). */
-        rate: bigint;
-    };
-    bid: {
-        /** The lowest interest rate a buyer is willing to be paid for the obligation. (18 decimals). */
-        rate: bigint;
-    };
+  /** The obligation id. */
+  obligationId: Hex;
+  ask: {
+    /** The highest interest rate the seller will accept to pay for the obligation. (18 decimals). */
+    rate: bigint;
+  };
+  bid: {
+    /** The lowest interest rate a buyer is willing to be paid for the obligation. (18 decimals). */
+    rate: bigint;
+  };
 };
-declare const QuoteSchema: z.ZodObject<{
-    obligationId: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    ask: z.ZodObject<{
-        rate: z.ZodBigInt;
-    }, z.core.$strip>;
-    bid: z.ZodObject<{
-        rate: z.ZodBigInt;
-    }, z.core.$strip>;
-}, z.core.$strip>;
+declare const QuoteSchema: z$1.ZodObject<{
+  obligationId: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  ask: z$1.ZodObject<{
+    rate: z$1.ZodBigInt;
+  }, z$1.core.$strip>;
+  bid: z$1.ZodObject<{
+    rate: z$1.ZodBigInt;
+  }, z$1.core.$strip>;
+}, z$1.core.$strip>;
 /**
  * Creates a quote for a given obligation.
  * @constructor
@@ -1152,11 +1396,11 @@ declare const QuoteSchema: z.ZodObject<{
  * const quote = Quote.from({ obligationId: "0x123", ask: { assets: 100n, rate: 100n }, bid: { assets: 100n, rate: 100n } });
  * ```
  */
-declare function from$4(parameters: from$4.Parameters): from$4.ReturnType;
-declare namespace from$4 {
-    type Parameters = Quote;
-    type ReturnType = Quote;
-    type ErrorType = InvalidQuoteError;
+declare function from$5(parameters: from$5.Parameters): from$5.ReturnType;
+declare namespace from$5 {
+  type Parameters = Quote;
+  type ReturnType = Quote;
+  type ErrorType = InvalidQuoteError;
 }
 /**
  * Creates a quote from a snake case object.
@@ -1166,9 +1410,9 @@ declare namespace from$4 {
  */
 declare function fromSnakeCase(snake: fromSnakeCase.Parameters): fromSnakeCase.ReturnType;
 declare namespace fromSnakeCase {
-    type Parameters = Snake<Quote>;
-    type ReturnType = Quote;
-    type ErrorType = from$4.ErrorType;
+  type Parameters = Snake<Quote>;
+  type ReturnType = Quote;
+  type ErrorType = from$5.ErrorType;
 }
 /**
  * Generates a random quote.
@@ -1181,622 +1425,961 @@ declare namespace fromSnakeCase {
  */
 declare function random(): random.ReturnType;
 declare namespace random {
-    type Parameters = never;
-    type ReturnType = Quote;
-    type ErrorType = from$4.ErrorType;
-}
-declare class InvalidQuoteError extends BaseError<z.ZodError | Error> {
-    readonly name = "Quote.InvalidQuoteError";
-    constructor(error: z.ZodError | Error);
+  type Parameters = never;
+  type ReturnType = Quote;
+  type ErrorType = from$5.ErrorType;
+}
+declare class InvalidQuoteError extends BaseError<z$1.ZodError | Error> {
+  readonly name = "Quote.InvalidQuoteError";
+  constructor(error: z$1.ZodError | Error);
+}
+declare namespace Transfer_d_exports {
+  export { Transfer, from$4 as from };
+}
+type Transfer = {
+  id: string;
+  chainId: Id;
+  contract: Address;
+  from: Address;
+  to: Address;
+  value: bigint;
+  blockNumber: number;
+};
+/**
+ * @constructor
+ *
+ * Creates a {@link Transfer}.
+ * @param parameters - {@link from.Parameters}
+ * @returns The created Transfer. {@link from.ReturnType}
+ *
+ * @example
+ * ```ts
+ * const transfer = Transfer.from({ id: "1", chainId: 1, contract: "0x123", from: "0x456", to: "0x789", value: 100n, blockNumber: 100n });
+ * ```
+ */
+declare function from$4(parameters: from$4.Parameters): from$4.ReturnType;
+declare namespace from$4 {
+  type Parameters = {
+    id: string;
+    chainId: Id;
+    contract: Address;
+    from: Address;
+    to: Address;
+    value: bigint;
+    blockNumber: number;
+  };
+  type ReturnType = Transfer;
 }
-
-type Quote$1_InvalidQuoteError = InvalidQuoteError;
-declare const Quote$1_InvalidQuoteError: typeof InvalidQuoteError;
-type Quote$1_Quote = Quote;
-declare const Quote$1_QuoteSchema: typeof QuoteSchema;
-declare const Quote$1_fromSnakeCase: typeof fromSnakeCase;
-declare const Quote$1_random: typeof random;
-declare namespace Quote$1 {
-  export { Quote$1_InvalidQuoteError as InvalidQuoteError, type Quote$1_Quote as Quote, Quote$1_QuoteSchema as QuoteSchema, from$4 as from, Quote$1_fromSnakeCase as fromSnakeCase, Quote$1_random as random };
+declare namespace Tree_d_exports {
+  export { DecodeError, EncodeError, Proof, Tree, TreeError, VERSION, decode$1 as decode, encode$1 as encode, encodeUnsigned, from$3 as from, proofs };
 }
-
+/**
+ * A merkle tree of offers built from offer hashes.
+ * Constructed via {@link from}. The tree root can be signed for onchain broadcast.
+ */
 type Tree = Compute<StandardMerkleTree<[Hex]> & {
-    offers: Offer[];
-    root: Hex;
+  /** The offers in the tree. */
+  offers: Offer[];
+  /** The root of the tree. */
+  root: Hex;
 }>;
+type Proof = {
+  /** The offer that the proof is for. */
+  offer: Offer;
+  /** The merkle proof path for the offer. */
+  path: Hex[];
+};
 declare const VERSION = 1;
 /**
  * Builds a Merkle tree from a list of offers.
  *
  * Leaves are the offer `hash` values as `bytes32` and are deterministically
- * ordered in ascending lexicographic order so that the resulting root is stable
- * regardless of the input order.
+ * ordered following the StandardMerkleTree leaf ordering so that the resulting
+ * root is stable regardless of the input order.
  *
  * @param offers - Offers to include in the tree.
  * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+ * @throws {TreeError} If tree building fails due to offer inconsistencies.
  */
 declare const from$3: (offers: Offer[]) => Tree;
 /**
- * Encodes an `Tree` into a Hex string with a version byte prefix and gzipped payload.
+ * Generates merkle proofs for all offers in a tree.
+ *
+ * Each proof allows independent verification that an offer is included in the tree
+ * without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+ *
+ * @param tree - The {@link Tree} to generate proofs for.
+ * @returns Array of proofs - {@link Proof}
+ */
+declare const proofs: (tree: Tree) => Proof[];
+/**
+ * Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
+ * - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+ *
+ * Validates signature authenticity and root integrity before encoding.
+ *
+ * @example
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = await Tree.encode(tree, signature);
+ * await broadcast(calldata);
+ * ```
  *
- * - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
- * - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+ * @example
+ * Manual construction (for advanced users):
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+ * const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = `${partial}${signature.slice(2)}`;
+ * ```
  *
- * @param tree - The offer Merkle tree to encode.
- * @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
- * @throws Error if the given `root` does not match the offers.
+ * @param tree - Merkle tree of offers
+ * @param signature - EIP-191 signature over raw root bytes
+ * @returns Hex-encoded calldata ready for onchain broadcast
+ * @throws {EncodeError} If signature verification fails or root mismatch
  */
-declare const encode$1: (tree: Tree) => Hex;
+declare const encode$1: (tree: Tree, signature: Hex) => Promise<Hex>;
 /**
- * Decodes a Hex string produced by {@link encode} back into an `Tree`.
+ * Encodes a merkle tree without a signature into hex payload for client-side signing.
  *
- * - Ensures the first byte version matches {@link VERSION}.
- * - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+ * Layout: `0x{vv}{gzip([...offers])}{root}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
  *
- * @param encoded - Hex string in the form `0x{vv}{zip...}`.
- * @returns A validated `Tree` rebuilt from the offers.
- * @throws Error if the version is invalid or the root does not match the offers.
+ * Validates root integrity before encoding.
+ *
+ * @param tree - Merkle tree of offers
+ * @returns Hex-encoded unsigned payload
+ * @throws {EncodeError} If root mismatch
  */
-declare const decode$1: (encoded: Hex) => Tree;
-
-type Tree$1_Tree = Tree;
-declare const Tree$1_VERSION: typeof VERSION;
-declare namespace Tree$1 {
-  export { type Tree$1_Tree as Tree, Tree$1_VERSION as VERSION, decode$1 as decode, encode$1 as encode, from$3 as from };
+declare const encodeUnsigned: (tree: Tree) => Hex;
+/**
+ * Decodes hex calldata into a validated merkle tree.
+ *
+ * Validates signature before decompression for fail-fast rejection of invalid payloads.
+ * Returns the tree with separately validated signature and recovered signer address.
+ *
+ * Validation order:
+ * 1. Version check
+ * 2. Signature verification (fail-fast, before decompression)
+ * 3. Decompression (only if signature valid)
+ * 4. Root verification (computed from offers vs embedded root)
+ *
+ * @example
+ * ```typescript
+ * const { tree, signature, signer } = await Tree.decode(calldata);
+ * console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+ * ```
+ *
+ * @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+ * @returns Validated tree, signature, and recovered signer address
+ * @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+ */
+declare const decode$1: (encoded: Hex) => Promise<{
+  tree: Tree;
+  signature: Hex;
+  signer: Address;
+}>;
+/**
+ * Error thrown during tree building operations.
+ * Indicates structural issues with the tree (missing offers, inconsistent state).
+ */
+declare class TreeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+/**
+ * Error thrown during tree encoding.
+ * Indicates validation failures (signature, root mismatch, mixed makers).
+ */
+declare class EncodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
 }
-
+/**
+ * Error thrown during tree decoding.
+ * Indicates payload corruption, version mismatch, or validation failures.
+ */
+declare class DecodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+//#endregion
+//#region src/api/Schema/generated/swagger.d.ts
 /**
  * This file was auto-generated by openapi-typescript.
  * Do not make direct changes to the file.
  */
 
 interface paths {
-    "/v1/offers": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * List all offers
-         * @description Returns a list of offers for a given obligation and side. Offers are sorted by the best rate (depending on the side), their block number (older offers first) and their assets (bigger offers first).
-         */
-        get: {
-            parameters: {
-                query: {
-                    /**
-                     * @description Maximum number of offers to return.
-                     * @example 10
-                     */
-                    limit?: number;
-                    /**
-                     * @description Pagination cursor in base64url-encoded format.
-                     * @example eyJvZmZzZXQiOjEwMH0
-                     */
-                    cursor?: string;
-                    /**
-                     * @description Obligation id used to filter offers.
-                     * @example 0x1234567890123456789012345678901234567890123456789012345678901234
-                     */
-                    obligation_id: string;
-                    /** @example buy */
-                    side: "buy" | "sell";
-                };
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["OfferListResponse"];
-                    };
-                };
-                /** @description Bad Request */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["BadRequestResponse"];
-                    };
-                };
-            };
-        };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
+  "/v1/books/{obligationId}/{side}": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
     };
-    "/v1/obligations": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * List all obligations
-         * @description Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default.
-         */
-        get: {
-            parameters: {
-                query?: {
-                    /** @example 10 */
-                    limit?: number;
-                    /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
-                    cursor?: string;
-                };
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ObligationListResponse"];
-                    };
-                };
-                /** @description Bad Request */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["BadRequestResponse"];
-                    };
-                };
-            };
+    /**
+     * Get aggregated book
+     * @description Returns aggregated book data for a given obligation and side. Offers are grouped by rate with summed takeable amounts. Book levels are sorted by rate (ascending for buy side, descending for sell side).
+     */
+    get: {
+      parameters: {
+        query?: {
+          /**
+           * @description Maximum number of rate levels to return.
+           * @example 10
+           */
+          limit?: number;
+          /**
+           * @description Pagination cursor in base64url-encoded format.
+           * @example eyJvZmZzZXQiOjEwMH0
+           */
+          cursor?: string;
         };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/obligations/{obligationId}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BookListResponse"];
+          };
         };
-        /**
-         * Get an obligation
-         * @description Returns an obligation by its id.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ObligationSingleSuccessResponse"];
-                    };
-                };
-                /** @description Bad Request */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["BadRequestResponse"];
-                    };
-                };
-            };
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
         };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
+      };
     };
-    "/v1/health": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Retrieve global health
-         * @description Returns the aggregated status of the router.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["RouterStatusSuccessResponse"];
-                    };
-                };
-            };
-        };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/offers": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
     };
-    "/v1/health/collectors": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Retrieve collectors health
-         * @description Returns the latest block numbers processed by collectors and their sync status.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["CollectorsHealthSuccessResponse"];
-                    };
-                };
-            };
+    /**
+     * List all offers
+     * @description Returns offers. Provide either `obligation_id` + `side` (order book) or `offering` (by maker).
+     */
+    get: {
+      parameters: {
+        query?: {
+          /**
+           * @description Maximum number of offers to return.
+           * @example 10
+           */
+          limit?: number;
+          /**
+           * @description Pagination cursor in base64url-encoded format.
+           * @example eyJvZmZzZXQiOjEwMH0
+           */
+          cursor?: string;
+          /**
+           * @description Maker address to filter offers by. Alternative to obligation_id + side.
+           * @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401
+           */
+          offering?: string;
+          /**
+           * @description Obligation id used to filter offers. Required when not using offering.
+           * @example 0x1234567890123456789012345678901234567890123456789012345678901234
+           */
+          obligation_id?: string;
+          /**
+           * @description Side of the offer. Required when using obligation_id.
+           * @example buy
+           */
+          side?: "buy" | "sell";
         };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/v1/health/chains": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["OfferListResponse"];
+          };
         };
-        /**
-         * Retrieve chains health
-         * @description Returns the latest block that can be processed by collectors for each chain.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Success */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ChainsHealthSuccessResponse"];
-                    };
-                };
-            };
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
         };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
+      };
     };
-}
-interface components {
-    schemas: {
-        OfferListResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /** @example eyJvZmZzZXQiOjEwMH0 */
-            cursor: string | null;
-            /**
-             * @description Offers matching the provided filters.
-             * @example [
-             *       {
-             *         "hash": "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
-             *         "offering": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-             *         "assets": "369216000000000000000000",
-             *         "rate": "2750000000000000000",
-             *         "maturity": 1761922799,
-             *         "expiry": 1761922799,
-             *         "start": 1761922790,
-             *         "nonce": "571380",
-             *         "buy": false,
-             *         "chain_id": "1",
-             *         "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
-             *         "collaterals": [
-             *           {
-             *             "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
-             *             "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
-             *             "lltv": "860000000000000000"
-             *           }
-             *         ],
-             *         "callback": {
-             *           "address": "0x1111111111111111111111111111111111111111",
-             *           "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
-             *           "gas_limit": "500000"
-             *         },
-             *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
-             *         "consumed": "0",
-             *         "block_number": 2942933377146801
-             *       }
-             *     ]
-             */
-            data: components["schemas"]["OfferListItemResponse"][];
-        };
-        Meta: {
-            /** @example 2024-01-01T12:00:00.000Z */
-            timestamp: string;
-        };
-        OfferListItemResponse: {
-            /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
-            hash: string;
-            /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
-            offering: string;
-            /** @example 369216000000000000000000 */
-            assets: string;
-            /** @example 2750000000000000000 */
-            rate: string;
-            /** @example 1761922799 */
-            maturity: number;
-            /** @example 1761922799 */
-            expiry: number;
-            /** @example 1761922790 */
-            start: number;
-            /** @example 571380 */
-            nonce: string;
-            /** @example false */
-            buy: boolean;
-            /** @example 1 */
-            chain_id: string;
-            /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
-            loan_token: string;
-            /**
-             * @example [
-             *       {
-             *         "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
-             *         "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
-             *         "lltv": "860000000000000000"
-             *       }
-             *     ]
-             */
-            collaterals: components["schemas"]["CollateralResponse"][];
-            /**
-             * @example {
-             *       "address": "0x1111111111111111111111111111111111111111",
-             *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
-             *       "gas_limit": "500000"
-             *     }
-             */
-            callback: components["schemas"]["OfferCallbackResponse"];
-            /** @example 0 */
-            consumed: string;
-            /** @example 2942933377146801 */
-            block_number: number;
-            /** @example 0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400 */
-            signature: string | null;
-        };
-        CollateralResponse: {
-            /** @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751 */
-            asset: string;
-            /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
-            oracle: string;
-            /** @example 860000000000000000 */
-            lltv: string;
-        };
-        OfferCallbackResponse: {
-            /** @example 0x1111111111111111111111111111111111111111 */
-            address: string;
-            /** @example 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000 */
-            data: string;
-            /** @example 500000 */
-            gas_limit: string;
-        };
-        BadRequestResponse: {
-            /** @enum {string} */
-            status: "error";
-            error: components["schemas"]["ErrorResponse"];
-            meta: components["schemas"]["Meta"];
-        };
-        ErrorResponse: {
-            /**
-             * @example VALIDATION_ERROR
-             * @enum {string}
-             */
-            code: "VALIDATION_ERROR" | "NOT_FOUND" | "INTERNAL_SERVER_ERROR" | "BAD_REQUEST";
-            /** @example Limit must be greater than 0. */
-            message: string;
-            /**
-             * @example [
-             *       {
-             *         "field": "limit",
-             *         "issue": "Limit must be greater than 0."
-             *       }
-             *     ]
-             */
-            details: Record<string, never>;
-        };
-        ObligationListResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
-            cursor: string | null;
-            /** @description List of obligations with takable offers. */
-            data: components["schemas"]["ObligationResponse"][];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/obligations": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List all obligations
+     * @description Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default.
+     */
+    get: {
+      parameters: {
+        query?: {
+          /** @example 10 */
+          limit?: number;
+          /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
+          cursor?: string;
         };
-        ObligationResponse: {
-            /** @example 0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67 */
-            id: string;
-            /** @example 1 */
-            chain_id: string;
-            /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
-            loan_token: string;
-            collaterals: components["schemas"]["CollateralResponse"][];
-            /** @example 1761922800 */
-            maturity: number;
-            ask: components["schemas"]["AskResponse"];
-            bid: components["schemas"]["BidResponse"];
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ObligationListResponse"];
+          };
         };
-        AskResponse: {
-            /** @example 1000000000000000000 */
-            rate: string;
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
         };
-        BidResponse: {
-            /** @example 1000000000000000000 */
-            rate: string;
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/obligations/{obligationId}": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get an obligation
+     * @description Returns an obligation by its id.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ObligationSingleSuccessResponse"];
+          };
         };
-        ObligationSingleSuccessResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /** @example null */
-            cursor: string | null;
-            /** @description Obligation details. */
-            data: components["schemas"]["ObligationResponse"];
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
         };
-        RouterStatusSuccessResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /**
-             * @description Aggregated router status.
-             * @example {
-             *       "status": "live"
-             *     }
-             */
-            data: components["schemas"]["RouterStatusDataResponse"];
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/health": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Retrieve global health
+     * @description Returns the aggregated status of the router.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["RouterStatusSuccessResponse"];
+          };
         };
-        RouterStatusDataResponse: {
-            /**
-             * @example live
-             * @enum {string}
-             */
-            status: "live" | "syncing";
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/health/collectors": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Retrieve collectors health
+     * @description Returns the latest block numbers processed by collectors and their sync status.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CollectorsHealthSuccessResponse"];
+          };
         };
-        CollectorsHealthSuccessResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /**
-             * @description Collectors health details and sync status.
-             * @example [
-             *       {
-             *         "name": "mempool_offers",
-             *         "chain_id": "1",
-             *         "block_number": 21345678,
-             *         "updated_at": "2024-01-01T12:00:00.000Z",
-             *         "lag": 0,
-             *         "status": "live"
-             *       }
-             *     ]
-             */
-            data: components["schemas"]["CollectorHealthResponse"][];
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/health/chains": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Retrieve chains health
+     * @description Returns the latest block that can be processed by collectors for each chain.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ChainsHealthSuccessResponse"];
+          };
         };
-        CollectorHealthResponse: {
-            /** @example mempool_offers */
-            name: string;
-            /** @example 1 */
-            chain_id: string;
-            /** @example 21345678 */
-            block_number: number | null;
-            /** @example 2024-01-01T12:00:00.000Z */
-            updated_at: string | null;
-            /** @example 0 */
-            lag: number | null;
-            /**
-             * @example live
-             * @enum {string}
-             */
-            status: "live" | "lagging" | "unknown";
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/validate": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Validate offers
+     * @description Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.
+     *
+     *     **Available validation rules:**
+     *     - **parse_error**: Returns when an offer fails to parse due to invalid format or missing required fields
+     *     - **mixed_maker**: Validates that all offers in a batch have the same maker (offering address)
+     *     - **chain_ids**: Validates that offer chain is one of: [109111114]
+     *     - **maturity**: Validates that offer maturity is one of: [end_of_month, end_of_next_month]
+     *     - **callback**: Validates callbacks: buy empty callback is allowed; sell offers must use a non-empty callback; non-empty callbacks must target one of [0x3333333333333333333333333333333333333333, 0x4444444444444444444444444444444444444444, 0x1111111111111111111111111111111111111111, 0x2222222222222222222222222222222222222222]
+     *     - **token**: Validates that offer loan token and collateral tokens are in the allowed assets list
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          "application/json": components["schemas"]["ValidateOffersRequest"];
         };
-        ChainsHealthSuccessResponse: {
-            /** @enum {string} */
-            status: "success";
-            meta: components["schemas"]["Meta"];
-            /**
-             * @description Latest processed block per chain.
-             * @example [
-             *       {
-             *         "chain_id": "1",
-             *         "block_number": 21345678,
-             *         "updated_at": "2024-01-01T12:00:00.000Z"
-             *       }
-             *     ]
-             */
-            data: components["schemas"]["ChainHealthResponse"][];
+      };
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ValidationSuccessResponse"];
+          };
         };
-        ChainHealthResponse: {
-            /** @example 1 */
-            chain_id: string;
-            /** @example 21345678 */
-            block_number: number;
-            /** @example 2024-01-01T12:00:00.000Z */
-            updated_at: string;
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
         };
+      };
     };
-    responses: never;
-    parameters: never;
-    requestBodies: never;
-    headers: never;
-    pathItems: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+}
+interface components {
+  schemas: {
+    BookListResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example eyJvZmZzZXQiOjEwMH0 */
+      cursor: string | null;
+      /** @description Aggregated book levels grouped by rate. */
+      data: components["schemas"]["BookLevelResponse"][];
+    };
+    Meta: {
+      /** @example 2024-01-01T12:00:00.000Z */
+      timestamp: string;
+    };
+    BookLevelResponse: {
+      /** @example 2750000000000000000 */
+      rate: string;
+      /** @example 369216000000000000000000 */
+      assets: string;
+      /** @example 5 */
+      count: number;
+    };
+    BadRequestResponse: {
+      error: components["schemas"]["ErrorResponse"];
+      meta: components["schemas"]["Meta"];
+    };
+    ErrorResponse: {
+      /**
+       * @example VALIDATION_ERROR
+       * @enum {string}
+       */
+      code: "VALIDATION_ERROR" | "NOT_FOUND" | "INTERNAL_SERVER_ERROR" | "BAD_REQUEST";
+      /** @example Limit must be greater than 0. */
+      message: string;
+      /**
+       * @example [
+       *       {
+       *         "field": "limit",
+       *         "issue": "Limit must be greater than 0."
+       *       }
+       *     ]
+       */
+      details: Record<string, never>;
+    };
+    OfferListResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example eyJvZmZzZXQiOjEwMH0 */
+      cursor: string | null;
+      /**
+       * @description Offers matching the provided filters.
+       * @example [
+       *       {
+       *         "hash": "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
+       *         "offering": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+       *         "assets": "369216000000000000000000",
+       *         "rate": "2750000000000000000",
+       *         "maturity": 1761922799,
+       *         "expiry": 1761922799,
+       *         "start": 1761922790,
+       *         "nonce": "571380",
+       *         "buy": false,
+       *         "chain_id": 1,
+       *         "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+       *         "collaterals": [
+       *           {
+       *             "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *             "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
+       *             "lltv": "860000000000000000"
+       *           }
+       *         ],
+       *         "callback": {
+       *           "address": "0x1111111111111111111111111111111111111111",
+       *           "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
+       *           "gas_limit": "500000"
+       *         },
+       *         "consumed": "0",
+       *         "takeable": "369216000000000000000000",
+       *         "block_number": 2942933377146801,
+       *         "root": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+       *         "proof": [
+       *           "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *           "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *         ],
+       *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400"
+       *       }
+       *     ]
+       */
+      data: components["schemas"]["OfferListItemResponse"][];
+    };
+    OfferListItemResponse: {
+      /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
+      hash: string;
+      /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
+      offering: string;
+      /** @example 369216000000000000000000 */
+      assets: string;
+      /** @example 2750000000000000000 */
+      rate: string;
+      /** @example 1761922799 */
+      maturity: number;
+      /** @example 1761922799 */
+      expiry: number;
+      /** @example 1761922790 */
+      start: number;
+      /** @example 571380 */
+      nonce: string;
+      /** @example false */
+      buy: boolean;
+      /** @example 1 */
+      chain_id: number;
+      /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
+      loan_token: string;
+      /**
+       * @example [
+       *       {
+       *         "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *         "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
+       *         "lltv": "860000000000000000"
+       *       }
+       *     ]
+       */
+      collaterals: components["schemas"]["CollateralResponse"][];
+      /**
+       * @example {
+       *       "address": "0x1111111111111111111111111111111111111111",
+       *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
+       *       "gas_limit": "500000"
+       *     }
+       */
+      callback: components["schemas"]["OfferCallbackResponse"];
+      /** @example 369216000000000000000000 */
+      takeable: string;
+      /** @example 0 */
+      consumed: string;
+      /** @example 2942933377146801 */
+      block_number: number;
+      /** @example 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef */
+      root: string | null;
+      /**
+       * @example [
+       *       "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *       "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *     ]
+       */
+      proof: string[] | null;
+      /** @example 0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400 */
+      signature: string | null;
+    };
+    CollateralResponse: {
+      /** @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751 */
+      asset: string;
+      /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
+      oracle: string;
+      /** @example 860000000000000000 */
+      lltv: string;
+    };
+    OfferCallbackResponse: {
+      /** @example 0x1111111111111111111111111111111111111111 */
+      address: string;
+      /** @example 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000 */
+      data: string;
+      /** @example 500000 */
+      gas_limit: string;
+    };
+    ObligationListResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
+      cursor: string | null;
+      /** @description List of obligations with takable offers. */
+      data: components["schemas"]["ObligationResponse"][];
+    };
+    ObligationResponse: {
+      /** @example 0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67 */
+      id: string;
+      /** @example 1 */
+      chain_id: number;
+      /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
+      loan_token: string;
+      collaterals: components["schemas"]["CollateralResponse"][];
+      /** @example 1761922800 */
+      maturity: number;
+      ask: components["schemas"]["AskResponse"];
+      bid: components["schemas"]["BidResponse"];
+    };
+    AskResponse: {
+      /** @example 1000000000000000000 */
+      rate: string;
+    };
+    BidResponse: {
+      /** @example 1000000000000000000 */
+      rate: string;
+    };
+    ObligationSingleSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example null */
+      cursor: string | null;
+      /** @description Obligation details. */
+      data: components["schemas"]["ObligationResponse"];
+    };
+    RouterStatusSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /**
+       * @description Aggregated router status.
+       * @example {
+       *       "status": "live"
+       *     }
+       */
+      data: components["schemas"]["RouterStatusDataResponse"];
+    };
+    RouterStatusDataResponse: {
+      /**
+       * @example live
+       * @enum {string}
+       */
+      status: "live" | "syncing";
+    };
+    CollectorsHealthSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /**
+       * @description Collectors health details and sync status.
+       * @example [
+       *       {
+       *         "name": "offers",
+       *         "chain_id": 1,
+       *         "block_number": 21345678,
+       *         "updated_at": "2024-01-01T12:00:00.000Z",
+       *         "lag": 0,
+       *         "status": "live"
+       *       }
+       *     ]
+       */
+      data: components["schemas"]["CollectorHealthResponse"][];
+    };
+    CollectorHealthResponse: {
+      /** @example offers */
+      name: string;
+      /** @example 1 */
+      chain_id: number;
+      /** @example 21345678 */
+      block_number: number | null;
+      /** @example 2024-01-01T12:00:00.000Z */
+      updated_at: string | null;
+      /** @example 0 */
+      lag: number | null;
+      /**
+       * @example live
+       * @enum {string}
+       */
+      status: "live" | "lagging" | "unknown";
+    };
+    ChainsHealthSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /**
+       * @description Latest processed block per chain.
+       * @example [
+       *       {
+       *         "chain_id": 1,
+       *         "local_block_number": 21345678,
+       *         "remote_block_number": 21345690,
+       *         "updated_at": "2024-01-01T12:00:00.000Z"
+       *       }
+       *     ]
+       */
+      data: components["schemas"]["ChainHealthResponse"][];
+    };
+    ChainHealthResponse: {
+      /** @example 1 */
+      chain_id: number;
+      /** @example 21345678 */
+      local_block_number: number;
+      /** @example 21345690 */
+      remote_block_number: number | null;
+      /** @example 2024-01-01T12:00:00.000Z */
+      updated_at: string;
+    };
+    ValidateOffersRequest: {
+      /** @description Array of offers in snake_case format. Required, non-empty. */
+      offers: components["schemas"]["ValidateOfferRequest"][];
+    };
+    ValidateOfferRequest: {
+      /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
+      offering: string;
+      /** @example 369216000000000000000000 */
+      assets: string;
+      /** @example 2750000000000000000 */
+      rate: string;
+      /** @example 1761922799 */
+      maturity: number;
+      /** @example 1761922799 */
+      expiry: number;
+      /** @example 1761922790 */
+      start: number;
+      /** @example 571380 */
+      nonce: string;
+      /** @example false */
+      buy: boolean;
+      /** @example 1 */
+      chain_id: number;
+      /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
+      loan_token: string;
+      /**
+       * @example [
+       *       {
+       *         "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *         "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
+       *         "lltv": "860000000000000000"
+       *       }
+       *     ]
+       */
+      collaterals: components["schemas"]["CollateralResponse"][];
+      /**
+       * @example {
+       *       "address": "0x1111111111111111111111111111111111111111",
+       *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
+       *       "gas_limit": "500000"
+       *     }
+       */
+      callback: components["schemas"]["OfferCallbackResponse"];
+    };
+    ValidationSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example null */
+      cursor: string | null;
+      /** @description Payload and root for client-side signing. */
+      data: components["schemas"]["ValidationSuccessDataResponse"];
+    };
+    ValidationSuccessDataResponse: {
+      /**
+       * @description Unsigned payload: version (1B) + gzip(offers) + root (32B).
+       * @example 0x01789c...
+       */
+      payload: string;
+      /**
+       * @description Merkle tree root to sign with EIP-191.
+       * @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427
+       */
+      root: string;
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+declare namespace ObligationResponse_d_exports {
+  export { ObligationResponse, from$2 as from };
 }
-
 type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["content"]["application/json"]["data"][number];
 /**
  * Creates an `ObligationResponse` from a `Obligation`.
@@ -1805,258 +2388,26 @@ type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["c
  * @returns The created `ObligationResponse`. {@link ObligationResponse}
  */
 declare function from$2(obligation: Obligation, quote: Quote): ObligationResponse;
-
-type ObligationResponse$1_ObligationResponse = ObligationResponse;
-declare namespace ObligationResponse$1 {
-  export { type ObligationResponse$1_ObligationResponse as ObligationResponse, from$2 as from };
-}
-
-type OfferResponse = paths["/v1/offers"]["get"]["responses"]["200"]["content"]["application/json"]["data"][number];
-/**
- * Creates an `OfferResponse` from an `Offer`.
- * @constructor
- * @param offer - {@link Offer}
- * @returns The created `OfferResponse`. {@link OfferResponse}
- */
-declare function from$1(offer: Offer): OfferResponse;
-
-type OfferResponse$1_OfferResponse = OfferResponse;
-declare namespace OfferResponse$1 {
-  export { type OfferResponse$1_OfferResponse as OfferResponse, from$1 as from };
-}
-
-declare class OffersController {
-    getOffers(): Promise<void>;
-}
-declare class HealthController {
-    getRouterStatus(): Promise<void>;
-    getCollectorsHealth(): Promise<void>;
-    getChainsHealth(): Promise<void>;
-}
-declare class ObligationsController {
-    getObligations(): Promise<void>;
-    getObligation(): Promise<void>;
+declare namespace Gate_d_exports {
+  export { Batch, Issue, Result, Rule, RuleNames, Single, batch$1 as batch, run, single };
 }
-declare const OpenApi: () => Promise<OpenAPIDocument>;
-
-declare const schemas: {
-    readonly get_offers: z.ZodObject<{
-        side: z.ZodEnum<{
-            buy: "buy";
-            sell: "sell";
-        }>;
-        obligation_id: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-        cursor: z.ZodOptional<z.ZodString>;
-        limit: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>>;
-    }, z.core.$strip>;
-    readonly get_obligations: z.ZodObject<{
-        cursor: z.ZodOptional<z.ZodString>;
-        limit: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>>;
-    }, z.core.$strip>;
-    readonly get_obligation: z.ZodObject<{
-        obligation_id: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
-    }, z.core.$strip>;
-};
-type Action = keyof typeof schemas;
-declare function parse<A extends Action>(action: A, query: unknown): z.infer<(typeof schemas)[A]>;
-declare function safeParse<A extends Action>(action: A, query: unknown, error?: z.core.$ZodErrorMap<z.core.$ZodIssue>): z.ZodSafeParseResult<z.infer<(typeof schemas)[A]>>;
-
-declare const index$1_ChainHealth: typeof ChainHealth;
-type index$1_ChainsHealthResponse = ChainsHealthResponse;
-declare const index$1_CollectorHealth: typeof CollectorHealth;
-type index$1_CollectorsHealthResponse = CollectorsHealthResponse;
-type index$1_HealthController = HealthController;
-declare const index$1_HealthController: typeof HealthController;
-type index$1_ObligationsController = ObligationsController;
-declare const index$1_ObligationsController: typeof ObligationsController;
-type index$1_OffersController = OffersController;
-declare const index$1_OffersController: typeof OffersController;
-declare const index$1_OpenApi: typeof OpenApi;
-type index$1_RouterStatusResponse = RouterStatusResponse;
-declare const index$1_parse: typeof parse;
-declare const index$1_safeParse: typeof safeParse;
-declare namespace index$1 {
-  export { index$1_ChainHealth as ChainHealth, type index$1_ChainsHealthResponse as ChainsHealthResponse, index$1_CollectorHealth as CollectorHealth, type index$1_CollectorsHealthResponse as CollectorsHealthResponse, index$1_HealthController as HealthController, ObligationResponse$1 as ObligationResponse, index$1_ObligationsController as ObligationsController, OfferResponse$1 as OfferResponse, index$1_OffersController as OffersController, index$1_OpenApi as OpenApi, type index$1_RouterStatusResponse as RouterStatusResponse, index$1_parse as parse, index$1_safeParse as safeParse };
-}
-
-type RouterClientConfig = {
-    /** The URL of the router. */
-    readonly url: URL;
-    /** The default headers to use for each request. */
-    readonly headers: Headers;
-};
-type Client$1 = Compute<RouterClientConfig & {
-    /**
-     * Get offers from the router.
-     * @param parameters - {@link getOffers.Parameters}
-     * @returns The offers with pagination cursor. {@link getOffers.ReturnType}
-     * @throws If the request fails - {@link getOffers.ErrorType}
-     *
-     * @example
-     * ```ts
-     * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
-     * const { offers, cursor } = await router.getOffers({ side: "buy", obligationId: "0xa1c...d2f" });
-     * console.log(offers);
-     * ```
-     */
-    getOffers: (parameters: getOffers.Parameters) => Promise<getOffers.ReturnType>;
-    /**
-     * Get obligations from the router.
-     * @param parameters - {@link getObligations.Parameters}
-     * @returns The obligations with pagination cursor. {@link getObligations.ReturnType}
-     * @throws If the request fails - {@link getObligations.ErrorType}
-     *
-     * @example
-     * ```ts
-     * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
-     * const { obligations, cursor } = await router.getObligations();
-     * console.log(obligations[0].id()); // 0x123...456
-     * ```
-     */
-    getObligations: (parameters?: getObligations.Parameters) => Promise<getObligations.ReturnType>;
-}>;
-type ConnectOptions = {
-    /** The URL of the router to interact with.
-     * @default "https://router.morpho.dev"
-     */
-    url?: string;
-    /** The API key to use for the router API. */
-    apiKey?: string;
-    /** The default headers to use for each request. */
-    headers?: Headers;
-};
-/**
- * Creates an instance of a router client.
- * @constructor
- * @param parameters - {@link connect.Parameters}
- * @returns A Router Client. {@link connect.ReturnType}
- *
- * @example
- * ```typescript
- * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
- * ```
- */
-declare function connect$1(parameters?: connect$1.Parameters): connect$1.ReturnType;
-declare namespace connect$1 {
-    type Parameters = ConnectOptions;
-    type ReturnType = Client$1;
-    type ErrorType = InvalidUrlError;
-}
-declare function getOffers(apiClient: Client$3<paths>, parameters: getOffers.Parameters): Promise<getOffers.ReturnType>;
-declare namespace getOffers {
-    type Parameters = {
-        /** The desired side of the match: 'buy' if you want to buy, 'sell' if you want to sell */
-        side: "buy" | "sell";
-        /** The offers obligation id */
-        obligationId: Hex;
-        /** Pagination cursor in base64url-encoded format */
-        cursor?: string;
-        /** Maximum number of offers to return. @default 20 */
-        limit?: number;
-    };
-    type ReturnType = {
-        offers: Offer[];
-        /** The pagination cursor. */
-        cursor: string | null;
-    };
-    type ErrorType = GetApiErrorType;
-}
-declare function getObligations(apiClient: Client$3<paths>, parameters?: getObligations.Parameters): Promise<getObligations.ReturnType>;
-declare namespace getObligations {
-    type Parameters = {
-        /** Pagination cursor is a 32-byte hex string. */
-        cursor?: Hex;
-        /** Maximum number of obligations to return. @default 20 */
-        limit?: number;
-    };
-    type ReturnType = {
-        obligations: Compute<{
-            /** The obligation id. Uses {@link Obligation.id} to calculate the id.*/
-            id: () => Hex;
-        } & Obligation & Omit<Quote, "obligationId">>[];
-        /** The pagination cursor. */
-        cursor: string | null;
-    };
-    type ErrorType = GetApiErrorType;
-}
-type GetApiErrorType = HttpGetApiFailedError | HttpUnauthorizedError | HttpForbiddenError | HttpRateLimitError;
-declare class InvalidUrlError extends BaseError {
-    name: string;
-    constructor(url: string);
-}
-declare class HttpUnauthorizedError extends BaseError {
-    name: string;
-    constructor();
-}
-declare class HttpForbiddenError extends BaseError {
-    name: string;
-    constructor();
-}
-declare class HttpRateLimitError extends BaseError {
-    name: string;
-    constructor();
-}
-declare class HttpGetApiFailedError extends BaseError {
-    name: string;
-    constructor(message: string, { details }?: {
-        details?: string;
-    });
-}
-
-type Client$2_ConnectOptions = ConnectOptions;
-type Client$2_HttpForbiddenError = HttpForbiddenError;
-declare const Client$2_HttpForbiddenError: typeof HttpForbiddenError;
-type Client$2_HttpGetApiFailedError = HttpGetApiFailedError;
-declare const Client$2_HttpGetApiFailedError: typeof HttpGetApiFailedError;
-type Client$2_HttpRateLimitError = HttpRateLimitError;
-declare const Client$2_HttpRateLimitError: typeof HttpRateLimitError;
-type Client$2_HttpUnauthorizedError = HttpUnauthorizedError;
-declare const Client$2_HttpUnauthorizedError: typeof HttpUnauthorizedError;
-type Client$2_InvalidUrlError = InvalidUrlError;
-declare const Client$2_InvalidUrlError: typeof InvalidUrlError;
-declare const Client$2_getObligations: typeof getObligations;
-declare const Client$2_getOffers: typeof getOffers;
-declare namespace Client$2 {
-  export { type Client$1 as Client, type Client$2_ConnectOptions as ConnectOptions, Client$2_HttpForbiddenError as HttpForbiddenError, Client$2_HttpGetApiFailedError as HttpGetApiFailedError, Client$2_HttpRateLimitError as HttpRateLimitError, Client$2_HttpUnauthorizedError as HttpUnauthorizedError, Client$2_InvalidUrlError as InvalidUrlError, connect$1 as connect, Client$2_getObligations as getObligations, Client$2_getOffers as getOffers };
-}
-
-type Cursor = {
-    sort: "rate" | "maturity" | "expiry" | "amount";
-    dir: "asc" | "desc";
-    rate?: string;
-    maturity?: number;
-    expiry?: number;
-    assets?: string;
-    hash: string;
-    page?: number;
-};
-declare function validate(cursor: unknown): cursor is Cursor;
-declare function encode(c: Cursor): string;
-declare function decode(token?: string): Cursor | null;
-
-type Cursor$1_Cursor = Cursor;
-declare const Cursor$1_decode: typeof decode;
-declare const Cursor$1_encode: typeof encode;
-declare const Cursor$1_validate: typeof validate;
-declare namespace Cursor$1 {
-  export { type Cursor$1_Cursor as Cursor, Cursor$1_decode as decode, Cursor$1_encode as encode, Cursor$1_validate as validate };
-}
-
 /**
  * A validation rule.
  */
-type Rule<T, Name extends string = string> = {
-    kind: "single";
-    name: Name;
-    run: Single<T, Name>;
+type Rule<T, Name$1 extends string = string> = {
+  kind: "single";
+  name: Name$1;
+  description: string;
+  run: Single<T, Name$1>;
 } | {
-    kind: "batch";
-    name: Name;
-    run: Batch<T, Name>;
+  kind: "batch";
+  name: Name$1;
+  description: string;
+  run: Batch<T, Name$1>;
 };
-type RuleNames<Rules extends readonly {
-    name: string;
-}[]> = Rules[number]["name"];
+type RuleNames<Rules$1 extends readonly {
+  name: string;
+}[]> = Rules$1[number]["name"];
 /**
  * A single item validation rule.
  * @param item - The item to validate.
@@ -2072,81 +2423,83 @@ type Batch<T, RuleName extends string> = (items: T[]) => Map<number, Omit<Issue<
 /**
  * Create a validation rule iterating over a single item at a time.
  * @param name - The name of the rule.
+ * @param description - A human-readable description of the rule.
  * @param run - The function that validates the rule.
  * @returns The created rule.
  */
-declare function single<Name extends string, T>(name: Name, run: Single<T, Name>): Rule<T, Name>;
+declare function single<Name$1 extends string, T>(name: Name$1, description: string, run: Single<T, Name$1>): Rule<T, Name$1>;
 /**
  * Create a validation rule iterating over a batch of items at a time.
  * @param name - The name of the rule.
+ * @param description - A human-readable description of the rule.
  * @param run - The function that validates the rule.
  * @returns The created rule.
  */
-declare function batch$1<Name extends string, T>(name: Name, run: Batch<T, Name>): Rule<T, Name>;
+declare function batch$1<Name$1 extends string, T>(name: Name$1, description: string, run: Batch<T, Name$1>): Rule<T, Name$1>;
 /**
  * A validation issue.
  */
 type Issue<T, RuleName extends string = string> = {
-    /** The name of the rule that caused the issue. */
-    ruleName: RuleName;
-    /** The message of the issue. */
-    message: string;
-    /** The item that was not valid. */
-    item: T;
+  /** The name of the rule that caused the issue. */
+  ruleName: RuleName;
+  /** The message of the issue. */
+  message: string;
+  /** The item that was not valid. */
+  item: T;
 };
 /**
  * The result of a validation.
  */
 type Result<T, RuleName extends string = string> = {
-    /** The items that were valid. */
-    valid: T[];
-    /** The reports of the failed validations. */
-    issues: Issue<T, RuleName>[];
+  /** The items that were valid. */
+  valid: T[];
+  /** The reports of the failed validations. */
+  issues: Issue<T, RuleName>[];
 };
-declare function run<T, Name extends string, Rules extends readonly Rule<T, Name>[]>(parameters: {
-    items: T[];
-    rules: Rules;
-    chunkSize?: number;
-}): Promise<Result<T, RuleNames<Rules>>>;
-
-type Gate_Batch<T, RuleName extends string> = Batch<T, RuleName>;
-type Gate_Issue<T, RuleName extends string = string> = Issue<T, RuleName>;
-type Gate_Result<T, RuleName extends string = string> = Result<T, RuleName>;
-type Gate_Rule<T, Name extends string = string> = Rule<T, Name>;
-type Gate_RuleNames<Rules extends readonly {
-    name: string;
-}[]> = RuleNames<Rules>;
-type Gate_Single<T, RuleName extends string> = Single<T, RuleName>;
-declare const Gate_run: typeof run;
-declare const Gate_single: typeof single;
-declare namespace Gate {
-  export { type Gate_Batch as Batch, type Gate_Issue as Issue, type Gate_Result as Result, type Gate_Rule as Rule, type Gate_RuleNames as RuleNames, type Gate_Single as Single, batch$1 as batch, Gate_run as run, Gate_single as single };
+declare function run<T, Name$1 extends string, Rules$1 extends readonly Rule<T, Name$1>[]>(parameters: {
+  items: T[];
+  rules: Rules$1;
+  chunkSize?: number;
+}): Promise<Result<T, RuleNames<Rules$1>>>;
+declare namespace Gatekeeper_d_exports {
+  export { Gatekeeper, Rules, create };
+}
+type Rules = readonly Rule<Offer, string>[];
+type Gatekeeper = {
+  rules: Rules;
+  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
+};
+type GatekeeperParameters = {
+  rules: Rules;
+};
+declare function create(parameters: GatekeeperParameters): Gatekeeper;
+declare namespace GateConfig_d_exports {
+  export { CallbackConfig, GateConfig, assets$1 as assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
 }
-
 type GateConfig = {
-    callbacks?: CallbackConfig[];
-    maturities?: MaturityType[];
+  callbacks?: CallbackConfig[];
+  maturities?: MaturityType[];
 };
 type CallbackConfig = {
-    type: CallbackType.BuyVaultV1Callback;
-    addresses: Address[];
-    vaultFactories: Address[];
+  type: CallbackType.BuyVaultV1Callback;
+  addresses: Address[];
+  vaultFactories: Address[];
 } | {
-    type: CallbackType.SellERC20Callback;
-    addresses: Address[];
+  type: CallbackType.SellERC20Callback;
+  addresses: Address[];
 } | {
-    type: CallbackType.BuyWithEmptyCallback;
+  type: CallbackType.BuyWithEmptyCallback;
 };
-declare function getCallback(chain: ChainName, type: CallbackType.BuyVaultV1Callback): Extract<CallbackConfig, {
-    type: CallbackType.BuyVaultV1Callback;
+declare function getCallback(chain: Name, type: CallbackType.BuyVaultV1Callback): Extract<CallbackConfig, {
+  type: CallbackType.BuyVaultV1Callback;
 }> | undefined;
-declare function getCallback(chain: ChainName, type: CallbackType.SellERC20Callback): Extract<CallbackConfig, {
-    type: CallbackType.SellERC20Callback;
+declare function getCallback(chain: Name, type: CallbackType.SellERC20Callback): Extract<CallbackConfig, {
+  type: CallbackType.SellERC20Callback;
 }> | undefined;
-declare function getCallback(chain: ChainName, type: CallbackType.BuyWithEmptyCallback): Extract<CallbackConfig, {
-    type: CallbackType.BuyWithEmptyCallback;
+declare function getCallback(chain: Name, type: CallbackType.BuyWithEmptyCallback): Extract<CallbackConfig, {
+  type: CallbackType.BuyWithEmptyCallback;
 }> | undefined;
-declare function getCallback(chain: ChainName, type: CallbackType): CallbackConfig | undefined;
+declare function getCallback(chain: Name, type: CallbackType): CallbackConfig | undefined;
 /**
  * Attempts to infer the configured callback type from a callback address on a chain.
  * Skips the empty callback type as it does not carry addresses.
@@ -2155,54 +2508,31 @@ declare function getCallback(chain: ChainName, type: CallbackType): CallbackConf
  * @param address - Callback contract address
  * @returns The callback type when found, otherwise undefined
  */
-declare function getCallbackType(chain: ChainName, address: Address): CallbackType | undefined;
+declare function getCallbackType(chain: Name, address: Address): CallbackType | undefined;
 /**
  * Returns the callback addresses for a given chain and callback type, if it exists.
  * @param chain - Chain name for which to read the validation configuration
  * @param type - Callback type to retrieve
  * @returns The matching callback addresses or an empty array if not configured
  */
-declare function getCallbackTypeAddresses(chain: ChainName, type: CallbackType): Address[];
+declare function getCallbackTypeAddresses(chain: Name, type: CallbackType): Address[];
 /**
  * Returns the list of allowed non-empty callback addresses for a chain.
  *
  * @param chain - Chain name
  * @returns Array of allowed callback addresses (lowercased). Empty when none configured
  */
-declare const getCallbackAddresses: (chain: ChainName) => Address[];
-declare const assets: Record<string, Address[]>;
-declare const configs: Record<ChainName, GateConfig>;
-
-type GateConfig$1_CallbackConfig = CallbackConfig;
-type GateConfig$1_GateConfig = GateConfig;
-declare const GateConfig$1_assets: typeof assets;
-declare const GateConfig$1_configs: typeof configs;
-declare const GateConfig$1_getCallback: typeof getCallback;
-declare const GateConfig$1_getCallbackAddresses: typeof getCallbackAddresses;
-declare const GateConfig$1_getCallbackType: typeof getCallbackType;
-declare const GateConfig$1_getCallbackTypeAddresses: typeof getCallbackTypeAddresses;
-declare namespace GateConfig$1 {
-  export { type GateConfig$1_CallbackConfig as CallbackConfig, type GateConfig$1_GateConfig as GateConfig, GateConfig$1_assets as assets, GateConfig$1_configs as configs, GateConfig$1_getCallback as getCallback, GateConfig$1_getCallbackAddresses as getCallbackAddresses, GateConfig$1_getCallbackType as getCallbackType, GateConfig$1_getCallbackTypeAddresses as getCallbackTypeAddresses };
+declare const getCallbackAddresses: (chain: Name) => Address[];
+declare const assets$1: Record<string, Address[]>;
+declare const configs: Record<Name, GateConfig>;
+//#endregion
+//#region src/gatekeeper/morphoRules.d.ts
+declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "mixed_maker"> | Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token">)[];
+declare namespace Rules_d_exports {
+  export { ValidityParameters, callback, chains, maturity, sameMaker, token, validity };
 }
-
-type Rules$1 = readonly Rule<Offer, string>[];
-type Gatekeeper = {
-    isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
-};
-type GatekeeperParameters = {
-    rules: Rules$1;
-};
-declare function create(parameters: GatekeeperParameters): Gatekeeper;
-
-type Gatekeeper$1_Gatekeeper = Gatekeeper;
-declare const Gatekeeper$1_create: typeof create;
-declare namespace Gatekeeper$1 {
-  export { type Gatekeeper$1_Gatekeeper as Gatekeeper, type Rules$1 as Rules, Gatekeeper$1_create as create };
-}
-
 type ValidityParameters = {
-    chain: Chain;
-    client: PublicClient;
+  client: PublicClient<Transport, Chain$1>;
 };
 /**
  * set of rules to validate offers.
@@ -2210,113 +2540,353 @@ type ValidityParameters = {
  * @param parameters - Validity parameters with chain and client
  * @returns Array of validation rules to evaluate against offers
  */
-declare function validity(parameters: ValidityParameters): (Rule<Offer, "sell_erc20_callback_invalid"> | Rule<Offer, "buy_offers_callback_vault_invalid"> | Rule<Offer, "expiry">)[];
-declare const chain: ({ chain }: {
-    chain: Chain;
-}) => Rule<Offer, "chain_id">;
-declare const maturity: ({ maturities }: {
-    maturities: MaturityType[];
+declare function validity(parameters: ValidityParameters): (Rule<Offer, "expiry"> | Rule<Offer, "sell_erc20_callback_invalid"> | Rule<Offer, "buy_offers_callback_vault_invalid">)[];
+declare const chains: ({
+  chains
+}: {
+  chains: Chain$1[];
+}) => Rule<Offer, "chain_ids">;
+declare const maturity: ({
+  maturities
+}: {
+  maturities: MaturityType[];
 }) => Rule<Offer, "maturity">;
-declare const callback: ({ callbacks, allowedAddresses, }: {
-    callbacks: CallbackType[];
-    allowedAddresses: Address[];
+declare const callback: ({
+  callbacks,
+  allowedAddresses
+}: {
+  callbacks: CallbackType[];
+  allowedAddresses: Address[];
 }) => Rule<Offer, "callback">;
 /**
  * A validation rule that checks if the offer's token is allowed.
  * @param offer - The offer to validate.
  * @returns The issue that was found. If the offer is valid, this will be undefined.
  */
-declare const token: ({ assets }: {
-    assets: Address[];
+declare const token: ({
+  assets
+}: {
+  assets: Address[];
 }) => Rule<Offer, "token">;
-
-type Rules_ValidityParameters = ValidityParameters;
-declare const Rules_callback: typeof callback;
-declare const Rules_chain: typeof chain;
-declare const Rules_maturity: typeof maturity;
-declare const Rules_token: typeof token;
-declare const Rules_validity: typeof validity;
-declare namespace Rules {
-  export { type Rules_ValidityParameters as ValidityParameters, Rules_callback as callback, Rules_chain as chain, Rules_maturity as maturity, Rules_token as token, Rules_validity as validity };
+/**
+ * A batch validation rule that ensures all offers in a tree have the same maker (offering address).
+ * Returns an issue only for the first non-conforming offer.
+ * This rule is signing-agnostic; signer verification is handled at the collector level.
+ */
+declare const sameMaker: () => Rule<Offer, "mixed_maker">;
+//#endregion
+//#region src/database/domains/Trees.d.ts
+/**
+ * Attestation data for a single offer, containing the merkle root, signature, and proof.
+ */
+type Attestation = {
+  root: Hex;
+  signature: Hex;
+  proof: Hex[];
+};
+declare namespace OfferResponse_d_exports {
+  export { OfferResponse, from$1 as from };
 }
-
+type OfferResponse = paths["/v1/offers"]["get"]["responses"]["200"]["content"]["application/json"]["data"][number];
+/**
+ * Creates an `OfferResponse` from an `Offer`.
+ * @constructor
+ * @param offer - {@link Offer}
+ * @param attestation - {@link Attestation}
+ * @returns The created `OfferResponse`. {@link OfferResponse}
+ */
+declare function from$1(offer: Offer, attestation?: Attestation): OfferResponse;
+//#endregion
+//#region src/api/Schema/openapi.d.ts
+declare class BooksController {
+  getBook(): Promise<void>;
+}
+declare class ValidateController {
+  validateOffers(): Promise<void>;
+}
+declare class OffersController {
+  getOffers(): Promise<void>;
+}
+declare class HealthController {
+  getRouterStatus(): Promise<void>;
+  getCollectorsHealth(): Promise<void>;
+  getChainsHealth(): Promise<void>;
+}
+declare class ObligationsController {
+  getObligations(): Promise<void>;
+  getObligation(): Promise<void>;
+}
+type RuleInfo = {
+  name: string;
+  description: string;
+};
+type OpenApiOptions = {
+  rules?: RuleInfo[];
+};
+declare const OpenApi: (options?: OpenApiOptions) => Promise<OpenAPIDocument>;
+//#endregion
+//#region src/api/Schema/requests.d.ts
+declare const schemas: {
+  readonly get_offers: z$1.ZodObject<{
+    side: z$1.ZodOptional<z$1.ZodEnum<{
+      buy: "buy";
+      sell: "sell";
+    }>>;
+    obligation_id: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    offering: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
+  }, z$1.core.$strip>;
+  readonly get_obligations: z$1.ZodObject<{
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
+  }, z$1.core.$strip>;
+  readonly get_obligation: z$1.ZodObject<{
+    obligation_id: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  }, z$1.core.$strip>;
+  readonly get_book: z$1.ZodObject<{
+    obligation_id: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    side: z$1.ZodEnum<{
+      buy: "buy";
+      sell: "sell";
+    }>;
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
+  }, z$1.core.$strip>;
+  readonly validate_offers: z$1.ZodObject<{
+    offers: z$1.ZodArray<z$1.ZodUnknown>;
+  }, z$1.core.$strict>;
+};
+type Action = keyof typeof schemas;
+declare function parse<A extends Action>(action: A, query: unknown): z$1.infer<(typeof schemas)[A]>;
+declare function safeParse<A extends Action>(action: A, query: unknown, error?: z$1.core.$ZodErrorMap<z$1.core.$ZodIssue>): z$1.ZodSafeParseResult<z$1.infer<(typeof schemas)[A]>>;
+declare namespace index_d_exports$1 {
+  export { BookResponse_d_exports as BookResponse, BooksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, OpenApiOptions, RouterStatusResponse, RuleInfo, ValidateController, parse, safeParse };
+}
+declare namespace Client_d_exports {
+  export { Client$2 as Client, ConnectOptions, HttpForbiddenError, HttpGetApiFailedError, HttpRateLimitError, HttpUnauthorizedError, InvalidUrlError, connect$1 as connect, getObligations, getOffers };
+}
+type RouterClientConfig = {
+  /** The URL of the router. */
+  readonly url: URL;
+  /** The default headers to use for each request. */
+  readonly headers: Headers;
+};
+type Client$2 = Compute<RouterClientConfig & {
+  /**
+   * Get offers from the router.
+   * @param parameters - {@link getOffers.Parameters}
+   * @returns The offers with pagination cursor. {@link getOffers.ReturnType}
+   * @throws If the request fails - {@link getOffers.ErrorType}
+   *
+   * @example
+   * ```ts
+   * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
+   * const { offers, cursor } = await router.getOffers({ side: "buy", obligationId: "0xa1c...d2f" });
+   * console.log(offers);
+   * ```
+   */
+  getOffers: (parameters: getOffers.Parameters) => Promise<getOffers.ReturnType>;
+  /**
+   * Get obligations from the router.
+   * @param parameters - {@link getObligations.Parameters}
+   * @returns The obligations with pagination cursor. {@link getObligations.ReturnType}
+   * @throws If the request fails - {@link getObligations.ErrorType}
+   *
+   * @example
+   * ```ts
+   * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
+   * const { obligations, cursor } = await router.getObligations();
+   * console.log(obligations[0].id()); // 0x123...456
+   * ```
+   */
+  getObligations: (parameters?: getObligations.Parameters) => Promise<getObligations.ReturnType>;
+}>;
+type ConnectOptions = {
+  /** The URL of the router to interact with.
+   * @default "https://router.morpho.dev"
+   */
+  url?: string;
+  /** The API key to use for the router API. */
+  apiKey?: string;
+  /** The default headers to use for each request. */
+  headers?: Headers;
+};
+/**
+ * Creates an instance of a router client.
+ * @constructor
+ * @param parameters - {@link connect.Parameters}
+ * @returns A Router Client. {@link connect.ReturnType}
+ *
+ * @example
+ * ```typescript
+ * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
+ * ```
+ */
+declare function connect$1(parameters?: connect$1.Parameters): connect$1.ReturnType;
+declare namespace connect$1 {
+  type Parameters = ConnectOptions;
+  type ReturnType = Client$2;
+  type ErrorType = InvalidUrlError;
+}
+declare function getOffers(apiClient: Client<paths>, parameters: getOffers.Parameters): Promise<getOffers.ReturnType>;
+declare namespace getOffers {
+  type Parameters = {
+    /** The desired side of the match: 'buy' if you want to buy, 'sell' if you want to sell */
+    side: "buy" | "sell";
+    /** The offers obligation id */
+    obligationId: Hex;
+    /** Pagination cursor in base64url-encoded format */
+    cursor?: string;
+    /** Maximum number of offers to return. @default 20 */
+    limit?: number;
+  };
+  type ReturnType = {
+    offers: Compute<Offer & {
+      /** 32-byte merkle root. */
+      root?: Hex;
+      /** Sibling hashes for the merkle proof. */
+      proof?: Hex[];
+    }>[];
+    /** The pagination cursor. */
+    cursor: string | null;
+  };
+  type ErrorType = GetApiErrorType;
+}
+declare function getObligations(apiClient: Client<paths>, parameters?: getObligations.Parameters): Promise<getObligations.ReturnType>;
+declare namespace getObligations {
+  type Parameters = {
+    /** Pagination cursor is a 32-byte hex string. */
+    cursor?: Hex;
+    /** Maximum number of obligations to return. @default 20 */
+    limit?: number;
+  };
+  type ReturnType = {
+    obligations: Compute<{
+      /** The obligation id. Uses {@link Obligation.id} to calculate the id.*/
+      id: () => Hex;
+    } & Obligation & Omit<Quote, "obligationId">>[];
+    /** The pagination cursor. */
+    cursor: string | null;
+  };
+  type ErrorType = GetApiErrorType;
+}
+type GetApiErrorType = HttpGetApiFailedError | HttpUnauthorizedError | HttpForbiddenError | HttpRateLimitError;
+declare class InvalidUrlError extends BaseError {
+  name: string;
+  constructor(url: string);
+}
+declare class HttpUnauthorizedError extends BaseError {
+  name: string;
+  constructor();
+}
+declare class HttpForbiddenError extends BaseError {
+  name: string;
+  constructor();
+}
+declare class HttpRateLimitError extends BaseError {
+  name: string;
+  constructor();
+}
+declare class HttpGetApiFailedError extends BaseError {
+  name: string;
+  constructor(message: string, {
+    details
+  }?: {
+    details?: string;
+  });
+}
+declare namespace Cursor_d_exports {
+  export { Cursor, decode, encode, validate };
+}
+type Cursor = {
+  sort: "rate" | "maturity" | "expiry" | "amount";
+  dir: "asc" | "desc";
+  rate?: string;
+  maturity?: number;
+  expiry?: number;
+  assets?: string;
+  hash: string;
+  page?: number;
+};
+declare function validate(cursor: unknown): cursor is Cursor;
+declare function encode(c: Cursor): string;
+declare function decode(token?: string): Cursor | null;
+//#endregion
+//#region src/mempool/MempoolEVMClient.d.ts
 declare function from(parameters: from.Parameters): from.ReturnType;
 declare namespace from {
-    type Parameters = {
-        /** The viem client to use. */
-        client: WalletClient;
-        /** The mempool address. */
-        mempoolAddress: Address;
-        /** The block window to use for the mempool. Defaults to 100. */
-        blockWindow?: number;
-    };
-    type ReturnType = Client;
-    type ErrorType = null;
+  type Parameters = {
+    /** The viem client to use. */
+    client: WalletClient;
+    /** The mempool address. */
+    mempoolAddress: Address;
+    /** The block window to use for the mempool. Defaults to 100. */
+    blockWindow?: number;
+  };
+  type ReturnType = Client$1;
+  type ErrorType = null;
+}
+declare namespace MempoolClient_d_exports {
+  export { AddParameters, Client$1 as Client, GetParameters, connect };
 }
-
 type AddParameters = Compute<Omit<Offer, "hash" | "createdAt">[]>;
 type GetParameters = {
-    /** The block number to get offers from. */
-    blockNumberGte?: number;
-    /** The block number to get offers to. */
-    blockNumberLte?: number;
-    /** The loan asset to get offers from. */
-    loanToken?: string;
-    /** The order to get offers. Defaults to "desc". */
-    order?: "asc" | "desc";
-    /** The options to get offers from. */
-    options?: {
-        /** The maximum number of offers to return. Defaults to 100. Maximum is 1000. */
-        maxBatchSize?: number;
-    };
+  /** The block number to get offers from. */
+  blockNumberGte?: number;
+  /** The block number to get offers to. */
+  blockNumberLte?: number;
+  /** The loan asset to get offers from. */
+  loanToken?: string;
+  /** The order to get offers. Defaults to "desc". */
+  order?: "asc" | "desc";
+  /** The options to get offers from. */
+  options?: {
+    /** The maximum number of offers to return. Defaults to 100. Maximum is 1000. */
+    maxBatchSize?: number;
+  };
 };
 /**
  * Mempool client interface.
  */
-type Client = {
-    /**
-     * Add an offer to the mempool.
-     * @returns The created offer with its hash.
-     */
-    add: (parameters: AddParameters) => Promise<Hex>;
-    /** Get offers from the mempool. */
-    get: (parameters?: GetParameters) => AsyncGenerator<{
-        offers: Offer[];
-        /** The block number of the last processed offer. Depends on the `order` parameter, block numbers will ascend or descend. */
-        blockNumber: number;
-    }>;
-    /**
-     * Stream offers from the mempool.
-     * @returns A generator of offers alongside the last block number processed.
-     */
-    stream: (parameters: Compute<Omit<GetParameters, "options"> & {
-        options: GetParameters["options"] & {
-            blockWindow?: number;
-        };
-    }>) => AsyncGenerator<{
-        offers: Offer[];
-        blockNumber: number;
-    }>;
+type Client$1 = {
+  /**
+   * Add an offer to the mempool.
+   * @returns The created offer with its hash.
+   */
+  add: (parameters: AddParameters) => Promise<Hex>;
+  /** Get offers from the mempool. */
+  get: (parameters?: GetParameters) => AsyncGenerator<{
+    offers: Offer[];
+    /** The block number of the last processed offer. Depends on the `order` parameter, block numbers will ascend or descend. */
+    blockNumber: number;
+  }>;
+  /**
+   * Stream offers from the mempool.
+   * @returns A generator of offers alongside the last block number processed.
+   */
+  stream: (parameters: Compute<Omit<GetParameters, "options"> & {
+    options: GetParameters["options"] & {
+      blockWindow?: number;
+    };
+  }>) => AsyncGenerator<{
+    offers: Offer[];
+    blockNumber: number;
+  }>;
 };
 /**
  * Client to interact with the Mempool contract on a specific chain.
  */
-declare function connect(parameters: from.Parameters): Client;
+declare function connect(parameters: from.Parameters): Client$1;
 declare namespace connect {
-    type ErrorType = from.ErrorType;
+  type ErrorType = from.ErrorType;
 }
-
-type MempoolClient_AddParameters = AddParameters;
-type MempoolClient_Client = Client;
-type MempoolClient_GetParameters = GetParameters;
-declare const MempoolClient_connect: typeof connect;
-declare namespace MempoolClient {
-  export { type MempoolClient_AddParameters as AddParameters, type MempoolClient_Client as Client, type MempoolClient_GetParameters as GetParameters, MempoolClient_connect as connect };
-}
-
+//#endregion
+//#region src/utils/BigMath.d.ts
 declare function max$1(a: bigint, b: bigint): bigint;
 declare function min(a: bigint, b: bigint): bigint;
-
+//#endregion
+//#region src/utils/batch.d.ts
 /**
  * Splits an array into batches of a specified size.
  * @param array The array to split.
@@ -2334,8 +2904,9 @@ declare function min(a: bigint, b: bigint): bigint;
  * // [5]
  * ```
  */
-declare function batch<T>(array: Array<T>, batchSize: number): Generator<T[], void, unknown>;
-
+declare function batch<T>(array: T[] | readonly T[], batchSize: number): Generator<T[], void, unknown>;
+//#endregion
+//#region src/utils/batchMulticall.d.ts
 /**
  * Helper function to execute multicall in batches with retry logic.
  * Abstracts the common pattern of batching calls, retrying, and collecting results.
@@ -2344,60 +2915,89 @@ declare function batch<T>(array: Array<T>, batchSize: number): Generator<T[], vo
  * @returns Promise resolving to flattened array of results
  */
 declare function batchMulticall<TResult>(parameters: {
-    client: Pick<PublicActions, "multicall">;
-    calls: unknown[];
-    batchSize: number;
-    retryAttempts: number;
-    retryDelayMs: number;
-    blockNumber?: bigint;
+  client: PublicClient<Transport, Chain$1>;
+  calls: MulticallParameters["contracts"];
+  batchSize: number;
+  retryAttempts: number;
+  retryDelayMs: number;
+  blockNumber?: bigint;
 }): Promise<TResult[]>;
-
+//#endregion
+//#region src/utils/lazy.d.ts
 /**
  * Transform a polling function into an async generator.
  * @param fn - The polling function to transform.
  * @returns An async generator.
  */
-declare function lazy<T>(pollFn: (emit: (value: T) => void, { stop }: {
-    stop: () => void;
+declare function lazy<T>(pollFn: (emit: (value: T) => void, {
+  stop
+}: {
+  stop: () => void;
 }) => () => boolean): () => AsyncGenerator<Awaited<NonNullable<T>>, void, unknown>;
-
+//#endregion
+//#region src/utils/poll.d.ts
 /**
  * Polls a function at a specified interval.
  * Inspired by https://github.com/wevm/viem/blob/845994d20275d08ff892018e237a4b599eeefb6a/src/utils/poll.ts
  */
-declare function poll<data>(fn: ({ unpoll }: {
-    unpoll: () => void;
-}) => Promise<data | undefined>, { interval }: {
-    interval: number;
+declare function poll<data>(fn: ({
+  unpoll
+}: {
+  unpoll: () => void;
+}) => Promise<data | undefined>, {
+  interval
+}: {
+  interval: () => Promise<number>;
 }): () => boolean;
-
+declare namespace Random_d_exports {
+  export { address, bool, bytes, float, hex, int, seed, withSeed };
+}
+/**
+ * Runs a function with a deterministic RNG derived from the given seed.
+ */
+declare function withSeed<T>(seed: string, fn: () => T): T;
+/**
+ * Seeds the global RNG for deterministic test runs.
+ */
+declare function seed(seed: string): void;
+/**
+ * Returns a deterministic random float in [0, 1).
+ */
+declare function float(): number;
+/**
+ * Returns a deterministic random integer in [min, maxExclusive).
+ */
+declare function int(maxExclusive: number, min?: number): number;
+/**
+ * Returns a deterministic random boolean.
+ */
+declare function bool(probability?: number): boolean;
+/**
+ * Returns deterministic random bytes.
+ */
+declare function bytes(length: number): Uint8Array;
+/**
+ * Returns a deterministic random hex string for the given byte length.
+ */
+declare function hex(byteLength: number): Hex;
+/**
+ * Returns a deterministic random address.
+ */
+declare function address(): Address;
+//#endregion
+//#region src/utils/retry.d.ts
 declare const retry: <T>(fn: () => Promise<T>, attempts?: number, delayMs?: number) => Promise<T>;
-
+declare namespace time_d_exports {
+  export { max, now };
+}
 declare function now(): number;
 declare function max(): number;
-
-declare const time_max: typeof max;
-declare const time_now: typeof now;
-declare namespace time {
-  export { time_max as max, time_now as now };
-}
-
+//#endregion
+//#region src/utils/wait.d.ts
 declare function wait(time: number): Promise<unknown>;
-
-type index_BaseError<cause extends Error | undefined = undefined> = BaseError<cause>;
-declare const index_BaseError: typeof BaseError;
-type index_GlobalErrorType<name extends string = "Error"> = GlobalErrorType<name>;
-type index_Snake<T> = Snake<T>;
-declare const index_batch: typeof batch;
-declare const index_batchMulticall: typeof batchMulticall;
-declare const index_lazy: typeof lazy;
-declare const index_min: typeof min;
-declare const index_poll: typeof poll;
-declare const index_retry: typeof retry;
-declare const index_stringifyBigint: typeof stringifyBigint;
-declare const index_wait: typeof wait;
-declare namespace index {
-  export { index_BaseError as BaseError, type index_GlobalErrorType as GlobalErrorType, type index_Snake as Snake, time as Time, index_batch as batch, index_batchMulticall as batchMulticall, fromSnakeCase$3 as fromSnakeCase, index_lazy as lazy, max$1 as max, index_min as min, index_poll as poll, index_retry as retry, index_stringifyBigint as stringifyBigint, toSnakeCase$1 as toSnakeCase, index_wait as wait };
+declare namespace index_d_exports$2 {
+  export { BaseError, GlobalErrorType, Random_d_exports as Random, ReorgError, Snake, time_d_exports as Time, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
 }
-
-export { Abi, type Brand, BrandTypeId, Callback, Chain$1 as Chain, Collateral$1 as Collateral, type Compute, Cursor$1 as Cursor, Errors, Format, GateConfig$1 as GateConfig, Gatekeeper$1 as Gatekeeper, LLTV$1 as LLTV, Liquidity, Maturity$1 as Maturity, MempoolClient as Mempool, Obligation$1 as Obligation, Offer$1 as Offer, Quote$1 as Quote, index$1 as RouterApi, Client$2 as RouterClient, Rules, time as Time, Tree$1 as Tree, index as Utils, Gate as Validation };
+//#endregion
+export { index_d_exports as Abi, Brand, BrandTypeId, Callback_d_exports as Callback, Chain_d_exports as Chain, Collateral_d_exports as Collateral, Compute, Cursor_d_exports as Cursor, ERC4626_d_exports as ERC4626, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Maturity_d_exports as Maturity, MempoolClient_d_exports as Mempool, Obligation_d_exports as Obligation, Offer_d_exports as Offer, Oracle_d_exports as Oracle, Position_d_exports as Position, Quote_d_exports as Quote, index_d_exports$1 as RouterApi, Client_d_exports as RouterClient, Rules_d_exports as Rules, time_d_exports as Time, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, Gate_d_exports as Validation, morphoRules };
+//# sourceMappingURL=index.browser.d.ts.map