@morpho-dev/router 0.1.12 → 0.1.15

package/dist/index.node.d.ts

@@ -1,44 +1,565 @@
-import * as _morpho_dev_mempool from '@morpho-dev/mempool';
-import { Offer, Errors, Format, Maturity, LLTV, Compute, Chain, Mempool } from '@morpho-dev/mempool';
-export * from '@morpho-dev/mempool';
-import * as viem from 'viem';
-import { Address, Hex, PublicClient, PublicActions } from 'viem';
-import { z, ZodError } from 'zod/v4';
-import * as node_modules_zod_openapi_dist_components_DkyUTLcs_js from 'node_modules/zod-openapi/dist/components-DkyUTLcs.js';
-import * as hono_utils_types from 'hono/utils/types';
-import * as hono from 'hono';
-import { Context } from 'hono';
-import * as hono_utils_http_status from 'hono/utils/http-status';
+import { Hex, Address, AbiEvent, PublicClient, GetLogsReturnType, WalletClient, PublicActions, Account } from 'viem';
+import { Chain as Chain$2 } from 'viem/chains';
 import { PGlite } from '@electric-sql/pglite';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { drizzle as drizzle$1 } from 'drizzle-orm/pglite';
 import { Pool } from 'pg';
+import * as z from 'zod';
+import { z as z$1 } from 'zod/v4';
+import * as node_modules_zod_openapi_dist_components_DkyUTLcs_js from 'node_modules/zod-openapi/dist/components-DkyUTLcs.js';
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
 
-declare const OfferStatusValues: readonly ["valid", "callback_not_supported", "callback_error", "unverified"];
-type OfferStatus = (typeof OfferStatusValues)[number];
-type OfferMetadata = {
-    issue: string;
+declare const Oracle: readonly [{
+    readonly type: "function";
+    readonly name: "price";
+    readonly inputs: readonly [];
+    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 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";
+}];
+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 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: "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: "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 enum CallbackType {
+    BuyWithEmptyCallback = "buy_with_empty_callback",
+    BuyVaultV1Callback = "buy_vault_v1_callback",
+    SellERC20Callback = "sell_erc20_callback"
+}
+declare const WhitelistedCallbackAddresses: Record<CallbackType, readonly string[]>;
+declare function decodeBuyVaultV1Callback(data: Hex): Array<{
+    vault: Address;
+    amount: bigint;
+}>;
+declare function decodeSellERC20Callback(data: Hex): Array<{
+    collateral: Address;
+    amount: bigint;
+}>;
+declare function encodeBuyVaultV1Callback(parameters: {
+    vaults: Address[];
+    amounts: bigint[];
+}): Hex;
+declare function encodeSellERC20Callback(parameters: {
+    collaterals: Address[];
+    amounts: bigint[];
+}): Hex;
+
+type Callback_CallbackType = CallbackType;
+declare const Callback_CallbackType: typeof CallbackType;
+declare const Callback_WhitelistedCallbackAddresses: typeof WhitelistedCallbackAddresses;
+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 namespace Callback {
+  export { Callback_CallbackType as CallbackType, Callback_WhitelistedCallbackAddresses as WhitelistedCallbackAddresses, Callback_decodeBuyVaultV1Callback as decodeBuyVaultV1Callback, Callback_decodeSellERC20Callback as decodeSellERC20Callback, Callback_encodeBuyVaultV1Callback as encodeBuyVaultV1Callback, Callback_encodeSellERC20Callback as encodeSellERC20Callback };
+}
+
+type GlobalErrorType<name extends string = "Error"> = Error & {
+    name: name;
 };
-type RouterOffer = Offer.Offer & {
-    consumed: bigint;
-    status: OfferStatus;
-    metadata?: OfferMetadata;
+/**
+ * Base error class inherited by all errors thrown by mempool.
+ *
+ * @example
+ * ```ts
+ * import { Errors } from 'mempool'
+ * throw new Errors.BaseError('An error occurred')
+ * ```
+ */
+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;
+    };
 };
-type OfferConsumed = {
-    id: string;
-    chainId: bigint;
-    offering: Address;
-    nonce: bigint;
-    amount: bigint;
+
+declare const chainNames: readonly ["ethereum", "base", "ethereum-virtual-testnet", "anvil"];
+type ChainName = (typeof chainNames)[number];
+declare const ChainId: {
+    ETHEREUM: bigint;
+    BASE: bigint;
+    "ETHEREUM-VIRTUAL-TESTNET": bigint;
+    ANVIL: bigint;
+};
+type Id = (typeof ChainId)[keyof typeof ChainId];
+declare const chainIds: Set<bigint>;
+type Chain = Compute<Omit<Chain$2, "id" | "name"> & {
+    id: Id;
+    name: ChainName;
+    whitelistedAssets: Set<Address>;
+    morpho: Address;
+    morphoBlue: Address;
+    mempool: {
+        address: Address;
+        deploymentBlock: number;
+        reindexBuffer: number;
+    };
+    vaultV1Factory: Record<string, Address>;
+}>;
+declare function getChain(chainId: Id): Chain | undefined;
+declare const getWhitelistedChains: () => Chain[];
+declare const chains$1: Record<ChainName, Chain>;
+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;
+    };
+}): AsyncGenerator<{
+    logs: GetLogsReturnType<abiEvent | undefined>;
+    blockNumber: number;
+}, void, void>;
+declare class InvalidBlockRangeError extends BaseError {
+    name: string;
+    constructor(fromBlock: bigint, toBlock: bigint);
+}
+declare class InvalidBlockWindowError extends BaseError {
+    name: string;
+    constructor(blockWindow: number);
+}
+declare class InvalidBatchSizeError extends BaseError {
+    name: string;
+    constructor(maxBatchSize: number);
+}
+declare class MissingBlockNumberError extends BaseError {
+    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_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, chains$1 as chains, Chain$1_getChain as getChain, Chain$1_getWhitelistedChains as getWhitelistedChains, Chain$1_streamLogs as streamLogs };
+}
+
+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];
+/**
+ * Convert a LLTV option or a scaled LLTV to a LLTV.
+ * @param lltv - The LLTV option or the scaled LLTV.
+ * @returns The LLTV.
+ */
+declare function from$8(lltv: Options | bigint): LLTV;
+declare namespace from$8 {
+    type ErrorType = InvalidOptionError$1 | InvalidLLTVError;
+}
+declare class InvalidOptionError$1 extends BaseError {
+    readonly name = "LLTV.InvalidOptionError";
+    constructor(input: number);
+}
+declare class InvalidLLTVError extends BaseError {
+    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$8 as from };
+}
+
+type 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.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$7: (parameters: from$7.Parameters) => from$7.ReturnType;
+declare namespace from$7 {
+    type Parameters = {
+        asset: Address;
+        lltv: Options | bigint;
+        oracle: Address;
+    };
+    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$7 as from };
+}
+
+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$1(c: Cursor): string;
+declare function decode$1(token?: string): Cursor | null;
+
+type Cursor$1_Cursor = Cursor;
+declare const Cursor$1_validate: typeof validate;
+declare namespace Cursor$1 {
+  export { type Cursor$1_Cursor as Cursor, decode$1 as decode, encode$1 as encode, Cursor$1_validate as validate };
+}
+
+/** The snake case representation of a type with bigint values stringified. */
+type Snake<T> = SnakeKeys<StringifiedBigint<T>>;
+/** Stringifies bigint values to strings and preserves branded primitives. */
+type StringifiedBigint<T> = [
+    T
+] extends [bigint] ? 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 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.
+ * Preserves ethereum addresses as is.
+ * Converts ethereum addresses to checksummed if used as values.
+ * Stringifies bigint values to strings.
+ */
+declare function toSnakeCase$1<T>(obj: T): Snake<T>;
+/**
+ * Formats a snake case object to its camel case type.
+ * Preserves ethereum addresses as is.
+ * Converts checksummed ethereum addresses to lowercase if used as values.
+ * @warning Does not unstringify bigint values.
+ */
+declare function fromSnakeCase$2<T>(obj: Snake<T>): T;
+
+type Format_Snake<T> = Snake<T>;
+declare namespace Format {
+  export { type Format_Snake as Snake, fromSnakeCase$2 as fromSnakeCase, toSnakeCase$1 as toSnakeCase };
+}
+
+/**
+ * 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 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;
+};
+type MaturityOptions = keyof typeof MaturityOptions;
+/**
+ * Creates a maturity from a timestamp in seconds or a maturity option.
+ * @throws {InvalidFormatError} If the maturity is in milliseconds.
+ * @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$6(ts: from$6.Parameters): Maturity;
+declare namespace from$6 {
+    type Parameters = number | MaturityOptions;
+    type ErrorType = InvalidFormatError | InvalidDateError | InvalidOptionError;
+}
+declare class InvalidFormatError extends BaseError {
+    readonly name = "Maturity.InvalidFormatError";
+    constructor();
+}
+declare class InvalidDateError extends BaseError {
+    readonly name = "Maturity.InvalidDateError";
+    constructor(input: number);
+}
+declare class InvalidOptionError extends BaseError {
+    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;
+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, from$6 as from };
+}
+
+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;
 };
-declare const RouterOfferSchema: (parameters?: {
+declare const OfferHashSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+declare const OfferSchema: (parameters?: {
     omitHash?: 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<number & _morpho_dev_mempool.Brand<"Maturity">, number>>;
+    maturity: z.ZodPipe<z.ZodNumber, z.ZodTransform<Maturity, number>>;
     expiry: z.ZodNumber;
     start: z.ZodNumber;
     nonce: z.ZodBigInt;
@@ -48,28 +569,150 @@ declare const RouterOfferSchema: (parameters?: {
     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<bigint & _morpho_dev_mempool.Brand<"LLTV">, bigint>>;
+        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>>>;
-    createdAt: z.ZodOptional<z.ZodNumber>;
     consumed: z.ZodBigInt;
-    status: z.ZodEnum<{
-        valid: "valid";
-        callback_not_supported: "callback_not_supported";
-        callback_error: "callback_error";
-        unverified: "unverified";
-    }>;
-    metadata: z.ZodOptional<z.ZodObject<{
-        issue: z.ZodString;
-    }, z.core.$strip>>;
+    blockNumber: z.ZodNumber;
+    signature: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
 }, z.core.$strip>;
 /**
- * ABI for the Consumed event emitted by the terms contract.
+ * 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$5(input: Omit<Offer, "hash">): Offer;
+declare namespace from$5 {
+    type ErrorType = InvalidOfferError;
+}
+/**
+ * Creates an offer from a snake case object.
+ * @throws {InvalidOfferError} If the offer is invalid.
+ * @param input - The offer to create.
+ * @returns The created offer with its hash.
+ */
+declare function fromSnakeCase$1(input: Snake<Omit<Offer, "hash">>): 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>;
+/**
+ * Generates a random Offer.
+ * The returned Offer contains randomly generated values for most fields, such as assets, rate, nonce, and buy flag.
+ * Some fields use fixed or deterministic values (e.g., chainId, collaterals, callback).
+ * @warning The generated Offer should not be used for production usage.
+ * @returns {Offer} A randomly generated Offer object.
+ */
+declare function random$1(): Offer;
+/**
+ * Creates an EIP-712 domain object.
+ * @param chainId - The chain ID.
+ * @returns The EIP-712 domain object.
+ */
+declare const domain: (chainId: bigint) => {
+    chainId: bigint;
+    verifyingContract: "0x0000000000000000000000000000000000000000";
+};
+/**
+ * The EIP-712 types for the offer.
+ * @warning The ordering of the types should NEVER be changed. The offer hash is computed based on the order of the types.
+ * @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";
+    }];
+};
+/**
+ * Signs an offer.
+ * @throws {Error} If the wallet account is not set.
+ * @param offer - The offer to sign.
+ * @param wallet - The wallet to sign the offer with.
+ * @returns The signed offer.
+ */
+declare function sign(offer: Offer, wallet: WalletClient): Promise<Hex>;
+declare function hash(offer: Omit<Offer, "hash">): Hex;
+/**
+ * Calculates the obligation id for an offer based on the smart contract's Obligation struct.
+ * The id is computed as keccak256(abi.encode(chainId, loanToken, collaterals (sorted by token address), maturity)).
+ * @param offer - The offer to calculate the obligation id for.
+ * @returns The obligation id as a 32-byte hex string.
+ */
+declare function obligationId(offer: Offer): Hex;
+declare function encode(offer: Offer): `0x${string}`;
+declare function decode(data: Hex, blockNumber: number | bigint): Offer;
+type OfferConsumed = {
+    id: string;
+    chainId: bigint;
+    offering: Address;
+    nonce: bigint;
+    amount: bigint;
+    blockNumber: number;
+};
+/**
+ * ABI for the Consumed event emitted by the Obligation contract.
  */
 declare const consumedEvent: {
     readonly type: "event";
@@ -92,33 +735,6 @@ declare const consumedEvent: {
     }];
     readonly anonymous: false;
 };
-/**
- * Creates a router offer from a plain object.
- * @throws {InvalidRouterOfferError} If the router offer is invalid.
- * @param input - The router offer to create.
- * @returns The created router offer with its hash.
- */
-declare function from$1(input: Omit<RouterOffer, "hash">): RouterOffer;
-declare namespace from$1 {
-    type ErrorType = InvalidRouterOfferError;
-}
-/**
- * Creates a router offer from a snake case object.
- * @throws {InvalidRouterOfferError} If the router offer is invalid.
- * @param input - The router offer to create.
- * @returns The created router offer with its hash.
- */
-declare function fromSnakeCase(input: Format.Snake<Omit<RouterOffer, "hash">>): RouterOffer;
-declare namespace fromSnakeCase {
-    type ErrorType = InvalidRouterOfferError;
-}
-/**
- * Converts a router offer to a snake case object.
- * @param offer - The router offer to convert.
- * @returns The converted router offer.
- */
-declare function toSnakeCase(offer: RouterOffer): Format.Snake<RouterOffer>;
-declare function random(): RouterOffer;
 declare function fromConsumedLog(parameters: {
     blockNumber: bigint;
     logIndex: number;
@@ -128,354 +744,306 @@ declare function fromConsumedLog(parameters: {
     nonce: bigint;
     amount: bigint;
 }): OfferConsumed;
-declare class InvalidRouterOfferError extends Errors.BaseError<ZodError | Error> {
-    readonly name = "RouterOffer.InvalidRouterOfferError";
-    constructor(error: ZodError | Error);
-}
-
-type RouterOffer$1_InvalidRouterOfferError = InvalidRouterOfferError;
-declare const RouterOffer$1_InvalidRouterOfferError: typeof InvalidRouterOfferError;
-type RouterOffer$1_OfferConsumed = OfferConsumed;
-type RouterOffer$1_OfferMetadata = OfferMetadata;
-type RouterOffer$1_OfferStatus = OfferStatus;
-declare const RouterOffer$1_OfferStatusValues: typeof OfferStatusValues;
-type RouterOffer$1_RouterOffer = RouterOffer;
-declare const RouterOffer$1_RouterOfferSchema: typeof RouterOfferSchema;
-declare const RouterOffer$1_consumedEvent: typeof consumedEvent;
-declare const RouterOffer$1_fromConsumedLog: typeof fromConsumedLog;
-declare const RouterOffer$1_fromSnakeCase: typeof fromSnakeCase;
-declare const RouterOffer$1_random: typeof random;
-declare const RouterOffer$1_toSnakeCase: typeof toSnakeCase;
-declare namespace RouterOffer$1 {
-  export { RouterOffer$1_InvalidRouterOfferError as InvalidRouterOfferError, type RouterOffer$1_OfferConsumed as OfferConsumed, type RouterOffer$1_OfferMetadata as OfferMetadata, type RouterOffer$1_OfferStatus as OfferStatus, RouterOffer$1_OfferStatusValues as OfferStatusValues, type RouterOffer$1_RouterOffer as RouterOffer, RouterOffer$1_RouterOfferSchema as RouterOfferSchema, RouterOffer$1_consumedEvent as consumedEvent, from$1 as from, RouterOffer$1_fromConsumedLog as fromConsumedLog, RouterOffer$1_fromSnakeCase as fromSnakeCase, RouterOffer$1_random as random, RouterOffer$1_toSnakeCase as toSnakeCase };
+declare class InvalidOfferError extends BaseError<z.ZodError | Error> {
+    readonly name = "Offer.InvalidOfferError";
+    constructor(error: z.ZodError | Error);
+}
+declare class AccountNotSetError extends BaseError {
+    readonly name = "Offer.AccountNotSetError";
+    constructor();
 }
 
-declare const OpenApi: node_modules_zod_openapi_dist_components_DkyUTLcs_js.OpenAPIObject;
+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;
+declare const Offer$1_consumedEvent: typeof consumedEvent;
+declare const Offer$1_decode: typeof decode;
+declare const Offer$1_domain: typeof domain;
+declare const Offer$1_encode: typeof encode;
+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_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, Offer$1_consumedEvent as consumedEvent, Offer$1_decode as decode, Offer$1_domain as domain, Offer$1_encode as encode, from$5 as from, Offer$1_fromConsumedLog as fromConsumedLog, fromSnakeCase$1 as fromSnakeCase, Offer$1_hash as hash, Offer$1_obligationId as obligationId, random$1 as random, Offer$1_sign as sign, Offer$1_toSnakeCase as toSnakeCase, Offer$1_types as types };
+}
 
-declare const schemas: {
-    readonly get_offers: z.ZodObject<{
-        creators: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
-        side: z.ZodOptional<z.ZodEnum<{
-            buy: "buy";
-            sell: "sell";
-        }>>;
-        chains: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<number[], string>>>;
-        loan_tokens: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
-        status: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<("valid" | "callback_not_supported" | "callback_error" | "unverified")[], string>>>;
-        callback_addresses: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
-        min_amount: z.ZodOptional<z.ZodBigInt>;
-        max_amount: z.ZodOptional<z.ZodBigInt>;
-        min_rate: z.ZodOptional<z.ZodBigInt>;
-        max_rate: z.ZodOptional<z.ZodBigInt>;
-        min_maturity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        max_maturity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        min_expiry: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        max_expiry: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        collateral_assets: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
-        collateral_oracles: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>>;
-        collateral_tuple: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<{
-            asset: string;
-            oracle: string | undefined;
-            lltv: (bigint & _morpho_dev_mempool.Brand<"LLTV">) | undefined;
-        }[], string>>>;
-        min_lltv: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        max_lltv: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        sort_by: z.ZodOptional<z.ZodEnum<{
-            amount: "amount";
-            rate: "rate";
-            maturity: "maturity";
-            expiry: "expiry";
-        }>>;
-        sort_order: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            asc: "asc";
-            desc: "desc";
-        }>>>;
-        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 match_offers: z.ZodObject<{
-        side: z.ZodEnum<{
-            buy: "buy";
-            sell: "sell";
-        }>;
-        chain_id: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;
-        rate: z.ZodOptional<z.ZodBigInt>;
-        collaterals: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<{
-            asset: string;
-            oracle: string;
-            lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-        }[], string>>>;
-        maturity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        min_maturity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        max_maturity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        loan_token: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-        creator: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<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>;
+/**
+ * Represents a liquidity pool with a unique ID and amount.
+ */
+type LiquidityPool = {
+    id: string;
+    amount: bigint;
 };
-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]>>;
-
-type OfferResponse = {
-    offer: Offer.Offer;
-    consumed: bigint;
-    status: OfferStatus;
-    metadata?: OfferMetadata;
+/**
+ * Represents a hierarchical relationship between two liquidity pools.
+ */
+type LiquidityLink = {
+    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;
 };
 /**
- * Transforms a RouterOffer to OfferResponse format.
- * @param routerOffer - The router offer to transform.
- * @returns The router offer response with offer as a nested property.
+ * Calculate maximum debt capacity from collateral amount.
+ * @param amount - Collateral amount
+ * @param oraclePrice - Oracle price (scaled to 36 decimals)
+ * @param lltv - Loan-to-value ratio (scaled to 18 decimals)
+ * @returns Maximum debt capacity
+ */
+declare function calculateMaxDebt(amount: bigint, oraclePrice: bigint, lltv: bigint): bigint;
+/**
+ * Generate pool ID for balance pools.
+ */
+declare function generateBalancePoolId(parameters: {
+    user: Address;
+    chainId: bigint;
+    token: Address;
+}): string;
+/**
+ * Generate pool ID for allowance pools.
+ */
+declare function generateAllowancePoolId(parameters: {
+    user: Address;
+    chainId: bigint;
+    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;
+}): string;
+/**
+ * Generate pool ID for obligation collateral pools.
+ * Obligation collateral pools represent collateral already deposited in the obligation.
+ * These pools are shared across all offers with the same obligation.
+ */
+declare function generateObligationCollateralPoolId(parameters: {
+    user: Address;
+    chainId: bigint;
+    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;
+}): string;
+/**
+ * Generate pool ID for debt pools.
+ */
+declare function generateDebtPoolId(parameters: {
+    user: Address;
+    chainId: bigint;
+    obligationId: Hex;
+}): string;
+/**
+ * Generate pool ID for user position in a vault.
+ */
+declare function generateUserVaultPositionPoolId(parameters: {
+    user: Address;
+    chainId: bigint;
+    vault: Address;
+}): string;
+/**
+ * Generate pool ID for vault position in a market.
  */
-declare function toResponse(routerOffer: RouterOffer): OfferResponse;
+declare function generateVaultPositionPoolId(parameters: {
+    vault: Address;
+    chainId: bigint;
+    marketId: string;
+}): string;
 /**
- * Transforms a OfferResponse to RouterOffer format.
- * @param offerResponse - The router offer response to transform.
- * @returns The router offer with all properties at the top level.
+ * Generate pool ID for market total liquidity.
  */
-declare function fromResponse(offerResponse: OfferResponse): RouterOffer;
+declare function generateMarketLiquidityPoolId(parameters: {
+    chainId: bigint;
+    marketId: string;
+}): string;
 
-type GetParameters = {
-    /** Filter by multiple creator addresses (comma-separated) */
-    creators?: string[];
-    /** Filter by offer type: buy offers or sell offers */
-    side?: "buy" | "sell";
-    /** Filter by multiple blockchain networks (comma-separated chain IDs) */
-    chains?: number[];
-    /** Filter by multiple loan assets (comma-separated) */
-    loanTokens?: string[];
-    /** Filter by multiple statuses (comma-separated) */
-    status?: OfferStatus[];
-    /** Filter by multiple callback addresses (comma-separated) */
-    callbackAddresses?: string[];
-    /** Minimum amount of assets in the offer */
-    minAmount?: bigint;
-    /** Maximum amount of assets in the offer */
-    maxAmount?: bigint;
-    /** Minimum rate per asset (in wei) */
-    minRate?: bigint;
-    /** Maximum rate per asset (in wei) */
-    maxRate?: bigint;
-    /** Minimum maturity timestamp (Unix timestamp in seconds) */
-    minMaturity?: Maturity.Maturity;
-    /** Maximum maturity timestamp (Unix timestamp in seconds) */
-    maxMaturity?: Maturity.Maturity;
-    /** Minimum expiry timestamp (Unix timestamp in seconds) */
-    minExpiry?: number;
-    /** Maximum expiry timestamp (Unix timestamp in seconds) */
-    maxExpiry?: number;
-    /** Filter by multiple collateral assets (comma-separated) */
-    collateralAssets?: string[];
-    /** Filter by multiple rate oracles (comma-separated) */
-    collateralOracles?: string[];
-    /** Filter by collateral combinations */
-    collateralTuple?: Array<{
-        asset: string;
-        oracle?: string;
-        lltv?: LLTV.LLTV;
-    }>;
-    /** Minimum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal) */
-    minLltv?: LLTV.LLTV;
-    /** Maximum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal) */
-    maxLltv?: LLTV.LLTV;
-    /** Field to sort results by */
-    sortBy?: "rate" | "maturity" | "expiry" | "amount";
-    /** Sort direction: asc (ascending) or desc (descending, default) */
-    sortOrder?: "asc" | "desc";
-    /** Pagination cursor in base64url-encoded format */
-    cursor?: string;
-    /** Maximum number of offers to return. Defaults to 20. Maximum is 100. */
-    limit?: number;
-};
-type MatchParameters = {
-    /** The desired side of the match: 'buy' if you want to buy, 'sell' if you want to sell */
-    side: "buy" | "sell";
-    /** The blockchain network chain ID */
-    chainId: number;
-    /** Rate per asset (in wei) for matching offers */
-    rate?: bigint;
-    /** Collateral requirements */
-    collaterals?: Array<{
-        asset: string;
-        oracle: string;
-        lltv: LLTV.LLTV;
-    }>;
-    /** Exact maturity timestamp (Unix timestamp in seconds) */
-    maturity?: Maturity.Maturity;
-    /** Minimum maturity timestamp (Unix timestamp in seconds, inclusive) */
-    minMaturity?: Maturity.Maturity;
-    /** Maximum maturity timestamp (Unix timestamp in seconds, inclusive) */
-    maxMaturity?: Maturity.Maturity;
-    /** The loan asset address to match against */
-    loanToken?: string;
-    /** Filter by a specific offer creator address */
-    creator?: string;
-    /** Filter by multiple statuses (comma-separated) */
-    status?: OfferStatus[];
-    /** Pagination cursor in base64url-encoded format */
-    cursor?: string;
-    /** Maximum number of offers to return. Defaults to 20. Maximum is 100. */
-    limit?: number;
-};
-type RouterApiClientConfig = {
-    readonly url: URL;
-    readonly headers: Headers;
-};
-type Client = Compute<RouterApiClientConfig & {
-    get: (parameters: GetParameters) => Promise<{
-        cursor: string | null;
-        offers: OfferResponse[];
-    }>;
-    match: (parameters: MatchParameters) => Promise<{
-        cursor: string | null;
-        offers: OfferResponse[];
-    }>;
-}>;
-declare function connect$1(opts?: {
-    url?: string;
-    apiKey?: string;
-    headers?: Headers;
-}): Client;
-declare namespace connect$1 {
-    type ErrorType = InvalidUrlError;
+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 };
 }
+
+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;
+};
+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>;
 /**
- * Get offers from the router.
- * @returns The offers with pagination cursor.
+ * Creates an obligation from the given parameters.
+ * @constructor
+ * @param parameters - {@link from.Parameters}
+ * @returns The created obligation. {@link Obligation}
+ * @throws If the collaterals are not sorted alphabetically by address. {@link CollateralsAreNotSortedError}
+ *
+ * @example
+ * ```ts
+ * const obligation = Obligation.from({
+ *   chainId: 1n,
+ *   loanToken: privateKeyToAccount(generatePrivateKey()).address,
+ *   collaterals: [
+ *     Collateral.from({
+ *       asset: privateKeyToAccount(generatePrivateKey()).address,
+ *       oracle: privateKeyToAccount(generatePrivateKey()).address,
+ *       lltv: 0.965
+ *     }),
+ *   ],
+ *   maturity: Maturity.from("end_of_next_quarter"),
+ * });
+ * ```
  */
-declare function get(config: RouterApiClientConfig, parameters: GetParameters): Promise<{
-    cursor: string | null;
-    offers: OfferResponse[];
-}>;
-declare namespace get {
-    type ErrorType = GetApiErrorType;
+declare function from$4(parameters: from$4.Parameters): from$4.ReturnType;
+declare namespace from$4 {
+    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$7.Parameters[] | readonly from$7.Parameters[];
+        /** The maturity of the obligation. */
+        maturity: from$6.Parameters;
+    };
+    type ReturnType = Obligation;
+    type ErrorType = InvalidObligationError;
 }
 /**
- * Match offers from the router.
- * @returns The matched offers with pagination cursor.
+ * Creates an obligation from a snake case object.
+ * @throws If the obligation is invalid. {@link fromSnakeCase.ErrorType}
+ * @param input - {@link fromSnakeCase.Parameters}
+ * @returns The created obligation. {@link fromSnakeCase.ReturnType}
  */
-declare function match(config: RouterApiClientConfig, parameters: MatchParameters): Promise<{
-    cursor: string | null;
-    offers: OfferResponse[];
-}>;
-declare namespace match {
-    type ErrorType = GetApiErrorType;
+declare function fromSnakeCase(input: fromSnakeCase.Parameters): fromSnakeCase.ReturnType;
+declare namespace fromSnakeCase {
+    type Parameters = Snake<Obligation>;
+    type ReturnType = Obligation;
+    type ErrorType = InvalidObligationError;
 }
-type GetApiErrorType = HttpGetOffersFailedError | HttpUnauthorizedError | HttpForbiddenError | HttpRateLimitError;
-declare class InvalidUrlError extends Errors.BaseError {
-    name: string;
-    constructor(url: string);
+/**
+ * Calculates the obligation id based on the smart contract's Obligation struct.
+ * The id is computed as keccak256(abi.encode(chainId, loanToken, collaterals, maturity)).
+ * @throws If the collaterals are not sorted alphabetically by address. {@link CollateralsAreNotSortedError}
+ * @param obligation - {@link id.Parameters}
+ * @returns The obligation id as a 32-byte hex string. {@link id.ReturnType}
+ *
+ * @example
+ * ```ts
+ * const obligation = Obligation.random();
+ * const id = Obligation.id(obligation);
+ * console.log(id); // 0x1234567890123456789012345678901234567890123456789012345678901234
+ * ```
+ */
+declare function id(obligation: id.Parameters): id.ReturnType;
+declare namespace id {
+    type Parameters = Obligation;
+    type ReturnType = Hex;
+    type ErrorType = CollateralsAreNotSortedError;
 }
-declare class HttpUnauthorizedError extends Errors.BaseError {
-    name: string;
-    constructor();
+/**
+ * Generates a random obligation.
+ * @returns A randomly generated obligation. {@link random.ReturnType}
+ *
+ * @example
+ * ```ts
+ * const obligation = Obligation.random();
+ * ```
+ */
+declare function random(): random.ReturnType;
+declare namespace random {
+    type ReturnType = Obligation;
 }
-declare class HttpForbiddenError extends Errors.BaseError {
-    name: string;
-    constructor();
+declare class InvalidObligationError extends BaseError<z.ZodError | Error> {
+    readonly name = "Obligation.InvalidObligationError";
+    constructor(error: z.ZodError | Error);
 }
-declare class HttpRateLimitError extends Errors.BaseError {
-    name: string;
+declare class CollateralsAreNotSortedError extends BaseError {
+    readonly name = "Obligation.CollateralsAreNotSortedError";
     constructor();
 }
-declare class HttpGetOffersFailedError extends Errors.BaseError {
-    name: string;
-    constructor(message: string, { details }?: {
-        details?: string;
-    });
+
+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_fromSnakeCase: typeof fromSnakeCase;
+declare const Obligation$1_id: typeof id;
+declare const Obligation$1_random: typeof random;
+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$4 as from, Obligation$1_fromSnakeCase as fromSnakeCase, Obligation$1_id as id, Obligation$1_random as random };
 }
 
-type Name = "mempool_offers" | "consumed_events" | "buy_with_empty_callback_liquidity" | "sell_erc20_callback_liquidity" | "chain_reorgs";
-/** A general collector interface. */
-type Collector<name extends Name = Name> = {
-    /** The name of the collector. */
-    name: name;
-    /** Start collecting data from external sources.
-     * @yields The last block number processed by the collector.
-     */
-    collect: () => AsyncGenerator<number, void, void>;
-    /** The last block number processed by the collector. */
-    lastSyncedBlock: () => Promise<number>;
-    /** The callback to call when a reorg is detected. */
-    onReorg(lastFinalizedBlockNumber: number): void;
+type Indexer = {
+    start: () => () => void;
 };
-/** Start a collector.
- * @param collector - The collector to start.
- * @returns A function to stop the collector.
- */
-declare function start(collector: Collector): () => void;
-
-declare function createBuyWithEmptyCallbackLiquidityCollector(params: {
-    client: PublicClient;
-    offerStore: OfferStore;
-    collectorBlockStore: CollectorBlockStore;
-    liquidityStore: LiquidityStore;
-    chain: Chain.Chain;
-    options?: {
-        maxBatchSize?: number;
-        interval?: number;
-    };
-}): Collector<"buy_with_empty_callback_liquidity">;
-
-declare function createChainReorgsCollector(parameters: {
-    client: PublicClient;
-    subscribers: Collector[];
-    collectorStore: CollectorBlockStore;
-    chain: Chain.Chain;
-    options?: {
-        maxBatchSize?: number;
-        interval?: number;
-        maxBlockNumber?: number;
-    };
-}): Collector<"chain_reorgs">;
-
-declare function createConsumedEventsCollector(parameters: {
-    client: PublicClient;
-    contractAddress: Address;
-    offerStore: OfferStore;
-    collectorBlockStore: CollectorBlockStore;
-    chainId: Chain.Id;
-    options?: {
-        maxBatchSize?: number;
-        interval?: number;
-    };
-}): Collector<"consumed_events">;
-
-declare function createMempoolCollector(parameters: {
-    mempool: Mempool.Client;
-    offerStore: OfferStore;
-    collectorBlockStore: CollectorBlockStore;
-    chain: Chain.Chain;
-    options?: {
-        maxBatchSize?: number;
-        interval?: number;
-    };
-}): Collector<"mempool_offers">;
+declare function create$7(params: {
+    collectors: Collector[];
+}): Indexer;
 
-declare function createSellERC20CallbackLiquidityCollector(params: {
-    client: PublicClient;
-    offerStore: OfferStore;
-    collectorBlockStore: CollectorBlockStore;
-    liquidityStore: LiquidityStore;
-    chain: Chain.Chain;
-    options?: {
-        maxBatchSize?: number;
-        interval?: number;
-    };
-}): Collector<"sell_erc20_callback_liquidity">;
-
-type index$1_Collector<name extends Name = Name> = Collector<name>;
-type index$1_Name = Name;
-declare const index$1_createBuyWithEmptyCallbackLiquidityCollector: typeof createBuyWithEmptyCallbackLiquidityCollector;
-declare const index$1_createChainReorgsCollector: typeof createChainReorgsCollector;
-declare const index$1_createConsumedEventsCollector: typeof createConsumedEventsCollector;
-declare const index$1_createMempoolCollector: typeof createMempoolCollector;
-declare const index$1_createSellERC20CallbackLiquidityCollector: typeof createSellERC20CallbackLiquidityCollector;
-declare const index$1_start: typeof start;
-declare namespace index$1 {
-  export { type index$1_Collector as Collector, type index$1_Name as Name, index$1_createBuyWithEmptyCallbackLiquidityCollector as createBuyWithEmptyCallbackLiquidityCollector, index$1_createChainReorgsCollector as createChainReorgsCollector, index$1_createConsumedEventsCollector as createConsumedEventsCollector, index$1_createMempoolCollector as createMempoolCollector, index$1_createSellERC20CallbackLiquidityCollector as createSellERC20CallbackLiquidityCollector, index$1_start as start };
+type RouterIndexer_Indexer = Indexer;
+declare namespace RouterIndexer {
+  export { type RouterIndexer_Indexer as Indexer, create$7 as create };
 }
 
 type PgDB = ReturnType<typeof drizzle> & {
@@ -487,7 +1055,7 @@ type PGLiteDB = ReturnType<typeof drizzle$1> & {
     pool: PGlite;
 };
 type PG = PgDB | PGLiteDB;
-declare function connect(parameters: {
+declare function connect$2(parameters: {
     type: "pg";
     endpoint: string;
 } | {
@@ -501,241 +1069,181 @@ type PG$1_PGLiteDB = PGLiteDB;
 type PG$1_PgDB = PgDB;
 declare const PG$1_applyMigrations: typeof applyMigrations;
 declare const PG$1_clean: typeof clean;
-declare const PG$1_connect: typeof connect;
 declare namespace PG$1 {
-  export { type PG$1_PG as PG, type PG$1_PGLiteDB as PGLiteDB, type PG$1_PgDB as PgDB, PG$1_applyMigrations as applyMigrations, PG$1_clean as clean, PG$1_connect as connect };
+  export { type PG$1_PG as PG, type PG$1_PGLiteDB as PGLiteDB, type PG$1_PgDB as PgDB, PG$1_applyMigrations as applyMigrations, PG$1_clean as clean, connect$2 as connect };
 }
 
-type CollectorBlockStore = {
-    /** Get the latest block number processed by a collector for a given chain. */
-    getBlockNumber: (parameters: {
-        collectorName: Name;
-        chainId: Chain.Id;
-    }) => Promise<number>;
-    /** Save the latest block number processed by a collector for a given chain. */
+type ChainStore = {
+    /** Get the latest block number processed by a given chain alongside its epoch. */
+    getBlockNumber: (chainId: Id) => Promise<{
+        blockNumber: number;
+        epoch: bigint;
+    }>;
+    /** Get the latest block number processed for all chains, optionally filtered by chain id. */
+    getBlockNumbers: (parameters?: {
+        chainId?: Id;
+    }) => Promise<Array<{
+        chainId: Id;
+        blockNumber: number;
+        epoch: bigint;
+        updatedAt: Date;
+    }>>;
+    /** Save the latest block number processed for a given chain alongside its epoch.*/
     saveBlockNumber: (parameters: {
-        collectorName: Name;
-        chainId: Chain.Id;
+        chainId: Id;
         blockNumber: number;
+        epoch: bigint;
     }) => Promise<void>;
 };
 /** Postgres implementation. */
-declare const create$3: (config: {
+declare const create$6: (config: {
     db: PG;
-}) => CollectorBlockStore;
-declare function memory$1(): CollectorBlockStore;
+}) => ChainStore;
 
-type CollectorBlockStore$1_CollectorBlockStore = CollectorBlockStore;
-declare namespace CollectorBlockStore$1 {
-  export { type CollectorBlockStore$1_CollectorBlockStore as CollectorBlockStore, create$3 as create, memory$1 as memory };
+type ChainStore$1_ChainStore = ChainStore;
+declare namespace ChainStore$1 {
+  export { type ChainStore$1_ChainStore as ChainStore, create$6 as create };
 }
 
-type LiquidityUserPosition = {
-    id: string;
-    availableLiquidityQueueId: string;
-    user: string;
-    chainId: bigint;
-    amount: string;
-    updatedAt: Date;
-};
-type LiquidityQueue = {
-    queueId: string;
-    availableLiquidityPoolId: string;
-    index: number;
-    callbackAmount: string;
-    updatedAt: Date;
-};
-type LiquidityPool = {
-    id: string;
-    amount: string;
-    updatedAt: Date;
-};
-type LiquidityQueueWithPool = {
-    queue: LiquidityQueue;
-    pool: LiquidityPool;
-};
-type Liquidity = {
-    userPosition: LiquidityUserPosition;
-    queues: LiquidityQueueWithPool[];
-};
-type FetchOptions = {
-    batchSize?: number;
-    retryAttempts?: number;
-    retryDelayMs?: number;
-    blockNumber?: number;
-};
-type LiquidityClient = {
-    /** Fetch liquidity for buy offers based on wallet token balances and allowances. */
-    fetchBuyLiquidity: (parameters: {
-        chainId: bigint;
-        spender: Address;
-        pairs: Array<{
-            user: Address;
-            loanToken: Address;
-        }>;
-        options?: FetchOptions;
-    }) => Promise<Liquidity[]>;
-    /** Fetch liquidity for sell offers based on collateral capacity and existing positions. */
-    fetchSellLiquidity: (parameters: {
-        chainId: bigint;
-        spender: Address;
-        morphoAddress: Address;
-        offers: Array<Offer.Offer>;
-        options?: FetchOptions;
-    }) => Promise<Liquidity[]>;
+type CollectorStore = {
+    /** Get the latest block number processed by a collector for a given chain alongside the epoch. */
+    getBlockNumber: (parameters: {
+        collectorName: Name;
+        chainId: Id;
+    }) => Promise<{
+        blockNumber: number;
+        epoch: bigint;
+    }>;
+    /**
+     * Get the latest block number processed by all collectors.
+     * When a chainId is provided the result is filtered, otherwise all records are returned.
+     */
+    getBlockNumbers: (parameters?: {
+        chainId?: Id;
+    }) => Promise<Array<{
+        collectorName: Name;
+        chainId: Id;
+        blockNumber: number;
+        epoch: bigint;
+        updatedAt: Date;
+    }>>;
+    /** Save the latest block number processed by a collector for a given chain.*/
+    saveBlockNumber: (parameters: {
+        collectorName: Name;
+        chainId: Id;
+        blockNumber: number;
+        epoch: bigint;
+    }) => Promise<void>;
 };
-/**
- * Create a liquidity client with the specified blockchain client.
- *
- * @param config - Configuration containing the blockchain client
- * @returns LiquidityClient
- */
-declare const create$2: (config: {
-    client: Pick<PublicActions, "multicall">;
-}) => LiquidityClient;
-declare function serialize(liquidity: Liquidity): string;
+/** Postgres implementation. */
+declare const create$5: (config: {
+    db: PG;
+}) => CollectorStore;
 
-type Liquidity$1_Liquidity = Liquidity;
-type Liquidity$1_LiquidityClient = LiquidityClient;
-type Liquidity$1_LiquidityPool = LiquidityPool;
-type Liquidity$1_LiquidityQueue = LiquidityQueue;
-type Liquidity$1_LiquidityQueueWithPool = LiquidityQueueWithPool;
-type Liquidity$1_LiquidityUserPosition = LiquidityUserPosition;
-declare const Liquidity$1_serialize: typeof serialize;
-declare namespace Liquidity$1 {
-  export { type Liquidity$1_Liquidity as Liquidity, type Liquidity$1_LiquidityClient as LiquidityClient, type Liquidity$1_LiquidityPool as LiquidityPool, type Liquidity$1_LiquidityQueue as LiquidityQueue, type Liquidity$1_LiquidityQueueWithPool as LiquidityQueueWithPool, type Liquidity$1_LiquidityUserPosition as LiquidityUserPosition, create$2 as create, Liquidity$1_serialize as serialize };
-}
-
-declare enum CallbackType {
-    BuyWithEmptyCallback = "buy_with_empty_callback",
-    SellERC20Callback = "sell_erc20_callback"
-}
-declare const WhitelistedCallbackAddresses: Record<CallbackType, readonly string[]>;
-type BuildLiquidityParameters = {
-    type: CallbackType.BuyWithEmptyCallback;
-    user: Address;
-    loanToken: Address;
-    chainId: Chain.Id;
-    amount: bigint;
-    index?: number;
-    updatedAt?: Date;
-} | {
-    type: CallbackType.SellERC20Callback;
-    user: Address;
-    termId: string;
-    offerHash: string;
-    chainId: Chain.Id;
-    amount: bigint;
-    collaterals: Array<{
-        collateralAddress: Address;
-        balance: bigint;
-        callbackAmount: bigint;
-    }>;
-    index?: number;
-    updatedAt?: Date;
-};
-declare function buildLiquidity(parameters: BuildLiquidityParameters): Liquidity;
-declare function getCallbackIdForOffer(offer: Offer.Offer): string | null;
-declare function decode$1(parameters: {
-    type: CallbackType;
-    data: Hex;
-}): Array<{
-    collateral: Address;
-    amount: bigint;
-}>;
-declare function encode$1(parameters: {
-    type: CallbackType;
-    data: {
-        collaterals: Address[];
-        amounts: bigint[];
-    };
-}): Hex;
-
-type Callback_CallbackType = CallbackType;
-declare const Callback_CallbackType: typeof CallbackType;
-declare const Callback_WhitelistedCallbackAddresses: typeof WhitelistedCallbackAddresses;
-declare const Callback_buildLiquidity: typeof buildLiquidity;
-declare const Callback_getCallbackIdForOffer: typeof getCallbackIdForOffer;
-declare namespace Callback {
-  export { Callback_CallbackType as CallbackType, Callback_WhitelistedCallbackAddresses as WhitelistedCallbackAddresses, Callback_buildLiquidity as buildLiquidity, decode$1 as decode, encode$1 as encode, Callback_getCallbackIdForOffer as getCallbackIdForOffer };
+type CollectorStore$1_CollectorStore = CollectorStore;
+declare namespace CollectorStore$1 {
+  export { type CollectorStore$1_CollectorStore as CollectorStore, create$5 as create };
 }
 
 type LiquidityStore = {
-    /** Get a liquidity entry by user position id, including queues and pools. */
-    getByUserPositionId: (parameters: {
-        userPositionId: string;
-    }) => Promise<Liquidity | null>;
-    /** Get all liquidity entries, grouped by user position, including queues and pools. */
-    getAll: (parameters?: {
-        callbackType?: CallbackType;
-    }) => Promise<Liquidity[]>;
-    /** Save or update a liquidity entry (transactional upsert across all three tables). */
+    /**
+     * Get all liquidity pools.
+     * @returns Array of all liquidity pools
+     */
+    getAllPools: () => Promise<LiquidityPool[]>;
+    /**
+     * Get all liquidity links.
+     * @returns Array of all liquidity links
+     */
+    getAllLinks: () => Promise<LiquidityLink[]>;
+    /**
+     * Get all offer-pool mappings.
+     * @returns Array of all offer liquidity pools
+     */
+    getAllOfferPools: () => Promise<OfferLiquidityPool[]>;
+    /**
+     * Save or update liquidity data.
+     * Accepts flat arrays of pools, links, and offer-pool mappings.
+     *
+     * Automatically cleans up stale links: for each parent pool being updated,
+     * deletes any existing links with priority greater than the maximum priority
+     * in the new links. This ensures that when priority-ordered relationships
+     * shrink, old links are removed.
+     *
+     * @param parameters - Object containing arrays of pools, links, and offerPools
+     */
     save: (parameters: {
-        liquidity: Liquidity;
+        pools: LiquidityPool[];
+        links: LiquidityLink[];
+        offerPools: OfferLiquidityPool[];
     }) => Promise<void>;
 };
 /** Postgres implementation. */
-declare const create$1: (config: {
+declare const create$4: (config: {
     db: PG;
 }) => LiquidityStore;
-declare function memory(): LiquidityStore;
 
 type LiquidityStore$1_LiquidityStore = LiquidityStore;
-declare const LiquidityStore$1_memory: typeof memory;
 declare namespace LiquidityStore$1 {
-  export { type LiquidityStore$1_LiquidityStore as LiquidityStore, create$1 as create, LiquidityStore$1_memory as memory };
+  export { type LiquidityStore$1_LiquidityStore as LiquidityStore, create$4 as create };
 }
 
 /**
- * The `OfferStore` is responsible for managing offer data in the database.
+ * The `OfferStore` is responsible for managing offer-related data.
  */
 type OfferStore = {
-    /** Create a single offer in the database. */
+    /** Create a single offer. */
     create: (parameters: {
-        offer: Offer.Offer;
-        status: OfferStatus;
-        metadata?: OfferMetadata;
+        offer: Offer;
     }) => Promise<string>;
-    /** Create multiple offers in the database. */
+    /** Create multiple offers. */
     createMany: (parameters: {
-        offer: Offer.Offer;
-        status: OfferStatus;
-        metadata?: OfferMetadata;
+        offer: Offer;
     }[]) => Promise<string[]>;
-    /** Get all offers from the database with optional filtering, sorting, and pagination. */
+    /** Get all offers with optional filtering, sorting, and pagination. */
     getAll: (params?: GetAllParams) => Promise<{
-        offers: RouterOffer[];
+        offers: Offer[];
         nextCursor: string | null;
     }>;
     /** Find offers that match the specified parameters, with cursor pagination. */
-    findMatchingOffers: (params: FindMatchingOffersParams) => Promise<{
-        offers: RouterOffer[];
+    findMatchingOffers: (params: FindMatchingOffersParams & {
+        implementation?: "nodejs" | "sql";
+    }) => Promise<{
+        offers: Offer[];
         nextCursor: string | null;
+        implementation?: "nodejs" | "sql";
     }>;
-    /** Delete an offer and its associated collaterals by hash. */
-    delete: (hash: Offer.Offer["hash"]) => Promise<boolean>;
-    /** Delete multiple offers and their associated collaterals by hashes. */
-    deleteMany: (hashes: Offer.Offer["hash"][]) => Promise<number>;
-    /** Update the status of an offer. */
-    updateStatus: (parameters: {
-        offerHash: Offer.Offer["hash"];
-        status: OfferStatus;
-        metadata?: OfferMetadata;
-    }) => Promise<void>;
+    /** Delete an offer by hash. */
+    delete: (hash: Offer["hash"]) => Promise<boolean>;
+    /** Delete multiple offers by hashes. */
+    deleteMany: (hashes: Offer["hash"][]) => Promise<number>;
+    /** Delete multiple offers by block number greater than or equal to the given value. */
+    deleteManyByBlockNumberGte: (blockNumberGte: number) => Promise<number>;
+    /** Update the consumed amount for a set of offers with the same chainId, offering, and nonce. */
     updateConsumedAmount: (parameters: {
         id: string;
-        chainId: Offer.Offer["chainId"];
-        offering: Offer.Offer["offering"];
-        nonce: Offer.Offer["nonce"];
+        chainId: Offer["chainId"];
+        offering: Offer["offering"];
+        nonce: Offer["nonce"];
         consumed: bigint;
+        blockNumber: number;
     }) => Promise<void>;
+    /** Delete multiple consumed amounts by block number greater than or equal to the given value. */
+    deleteManyConsumedAmountsByBlockNumberGte: (blockNumberGte: number) => Promise<number>;
+    /** Get all obligations */
+    getAllObligations: (parameters?: {
+        cursor?: string;
+        limit?: number;
+    }) => Promise<{
+        obligations: Obligation[];
+        nextCursor: string | null;
+    }>;
 };
 type GetOffersFilters = {
     creators?: string[];
     side?: "buy" | "sell";
     chains?: number[];
     loanTokens?: string[];
-    status?: OfferStatus[];
     callbackAddresses?: string[];
     minAmount?: bigint;
     maxAmount?: bigint;
@@ -750,7 +1258,7 @@ type GetOffersFilters = {
     collateralTuple?: Array<{
         asset: string;
         oracle?: string;
-        lltv?: LLTV.LLTV;
+        lltv?: LLTV;
     }>;
     minLltv?: number;
     maxLltv?: number;
@@ -760,19 +1268,10 @@ type GetOffersFilters = {
     limit?: number;
 };
 type FindMatchingOffersParams = {
+    /** The side of the offer. */
     side: "buy" | "sell";
-    chainId: number;
-    rate?: bigint;
-    collaterals?: Array<{
-        asset: string;
-        oracle: string;
-        lltv: LLTV.LLTV;
-    }>;
-    maturity?: number;
-    minMaturity?: number;
-    maxMaturity?: number;
-    loanToken?: string;
-    creator?: string;
+    /** The obligationId of the offer. */
+    obligationId: Hex;
     /** Cursor string returned by a previous call, for pagination */
     cursor?: string;
     /** Page size; defaults to 20 */
@@ -785,233 +1284,245 @@ type PgConfig = {
     /** The database instance to use for operations. */
     db: PG;
 };
-declare function create(config: PgConfig): OfferStore;
+declare function create$3(config: PgConfig): OfferStore;
 
 type OfferStore$1_FindMatchingOffersParams = FindMatchingOffersParams;
 type OfferStore$1_GetAllParams = GetAllParams;
 type OfferStore$1_GetOffersFilters = GetOffersFilters;
 type OfferStore$1_OfferStore = OfferStore;
 type OfferStore$1_PgConfig = PgConfig;
-declare const OfferStore$1_create: typeof create;
 declare namespace OfferStore$1 {
-  export { type OfferStore$1_FindMatchingOffersParams as FindMatchingOffersParams, type OfferStore$1_GetAllParams as GetAllParams, type OfferStore$1_GetOffersFilters as GetOffersFilters, type OfferStore$1_OfferStore as OfferStore, type OfferStore$1_PgConfig as PgConfig, OfferStore$1_create as create };
-}
-
-/**
- * Start a local router server.
- * @example
- * ```ts
- * import { Router } from "@morpho-dev/router";
- * await Router.serve(); // local router server running on http://localhost:8081
- * ```
- */
-declare function serve(parameters: {
-    port: number;
-    store: OfferStore;
-}): Promise<void>;
-declare function error(error: unknown, c: Context): Response & hono.TypedResponse<{
-    statusCode: number;
-    body: string;
-}, hono_utils_http_status.ContentfulStatusCode, "json">;
-declare function success<T>(c: Context, { data, cursor, }: {
-    data: T | T[];
-    cursor?: string | null;
-}): Response & hono.TypedResponse<{
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-} extends hono_utils_types.JSONValue ? { [K in keyof {
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-} as ({
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K] extends infer T_1 ? T_1 extends {
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K]: boolean extends ({
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K] extends infer T_2 ? T_2 extends {
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K] ? T_2 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K]> | undefined : hono_utils_types.JSONParsed<{
-    status: string;
-    cursor: string | null | undefined;
-    data: T | T[];
-    meta: {
-        timestamp: string;
-    };
-}[K]>; } : never, hono_utils_http_status.ContentfulStatusCode, "json">;
-declare class APIError extends Error {
-    statusCode: number;
-    code: string;
-    details?: unknown | undefined;
-    constructor(statusCode: number, message: string, code: string, details?: unknown | undefined);
-}
-declare class ValidationError extends APIError {
-    constructor(message: string, details?: unknown);
-}
-declare class NotFoundError extends APIError {
-    constructor(message: string);
-}
-declare class InternalServerError extends APIError {
-    constructor(message?: string);
-}
-declare class BadRequestError extends APIError {
-    constructor(message?: string, details?: unknown);
-}
-declare function handleZodError(error: z.ZodError): ValidationError;
-
-type index_APIError = APIError;
-declare const index_APIError: typeof APIError;
-type index_BadRequestError = BadRequestError;
-declare const index_BadRequestError: typeof BadRequestError;
-type index_Client = Client;
-type index_GetParameters = GetParameters;
-type index_HttpForbiddenError = HttpForbiddenError;
-declare const index_HttpForbiddenError: typeof HttpForbiddenError;
-type index_HttpGetOffersFailedError = HttpGetOffersFailedError;
-declare const index_HttpGetOffersFailedError: typeof HttpGetOffersFailedError;
-type index_HttpRateLimitError = HttpRateLimitError;
-declare const index_HttpRateLimitError: typeof HttpRateLimitError;
-type index_HttpUnauthorizedError = HttpUnauthorizedError;
-declare const index_HttpUnauthorizedError: typeof HttpUnauthorizedError;
-type index_InternalServerError = InternalServerError;
-declare const index_InternalServerError: typeof InternalServerError;
-type index_InvalidUrlError = InvalidUrlError;
-declare const index_InvalidUrlError: typeof InvalidUrlError;
-type index_MatchParameters = MatchParameters;
-type index_NotFoundError = NotFoundError;
-declare const index_NotFoundError: typeof NotFoundError;
-type index_OfferResponse = OfferResponse;
-declare const index_OpenApi: typeof OpenApi;
-type index_RouterApiClientConfig = RouterApiClientConfig;
-type index_ValidationError = ValidationError;
-declare const index_ValidationError: typeof ValidationError;
-declare const index_error: typeof error;
-declare const index_fromResponse: typeof fromResponse;
-declare const index_get: typeof get;
-declare const index_handleZodError: typeof handleZodError;
-declare const index_match: typeof match;
-declare const index_parse: typeof parse;
-declare const index_safeParse: typeof safeParse;
-declare const index_serve: typeof serve;
-declare const index_success: typeof success;
-declare const index_toResponse: typeof toResponse;
-declare namespace index {
-  export { index_APIError as APIError, index_BadRequestError as BadRequestError, type index_Client as Client, type index_GetParameters as GetParameters, index_HttpForbiddenError as HttpForbiddenError, index_HttpGetOffersFailedError as HttpGetOffersFailedError, index_HttpRateLimitError as HttpRateLimitError, index_HttpUnauthorizedError as HttpUnauthorizedError, index_InternalServerError as InternalServerError, index_InvalidUrlError as InvalidUrlError, type index_MatchParameters as MatchParameters, index_NotFoundError as NotFoundError, type index_OfferResponse as OfferResponse, index_OpenApi as OpenApi, type index_RouterApiClientConfig as RouterApiClientConfig, index_ValidationError as ValidationError, connect$1 as connect, index_error as error, index_fromResponse as fromResponse, index_get as get, index_handleZodError as handleZodError, index_match as match, index_parse as parse, index_safeParse as safeParse, index_serve as serve, index_success as success, index_toResponse as toResponse };
-}
-
-type Cursor = {
-    sort: "rate" | "maturity" | "expiry" | "amount";
-    dir: "asc" | "desc";
-    rate?: string;
-    maturity?: number;
-    expiry?: number;
-    assets?: string;
-    hash: string;
-};
-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 };
-}
-
-declare const LogLevelValues: readonly ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
-type LogLevel = (typeof LogLevelValues)[number];
-type LogEntry = Compute<{
-    msg: string;
-} & Record<string, unknown>>;
-type LogFn = (entry: LogEntry) => void;
-type Logger = {
-    trace: LogFn;
-    debug: LogFn;
-    info: LogFn;
-    warn: LogFn;
-    error: LogFn;
-    fatal: LogFn;
-};
-declare function defaultLogger(minLevel?: LogLevel): Logger;
-declare function silentLogger(): Logger;
-declare function runWithLogger<T>(logger: Logger, fn: () => Promise<T>): Promise<T>;
-declare function getLogger(): Logger;
-
-type Logger$1_LogEntry = LogEntry;
-type Logger$1_LogFn = LogFn;
-type Logger$1_LogLevel = LogLevel;
-declare const Logger$1_LogLevelValues: typeof LogLevelValues;
-type Logger$1_Logger = Logger;
-declare const Logger$1_defaultLogger: typeof defaultLogger;
-declare const Logger$1_getLogger: typeof getLogger;
-declare const Logger$1_runWithLogger: typeof runWithLogger;
-declare const Logger$1_silentLogger: typeof silentLogger;
-declare namespace Logger$1 {
-  export { type Logger$1_LogEntry as LogEntry, type Logger$1_LogFn as LogFn, type Logger$1_LogLevel as LogLevel, Logger$1_LogLevelValues as LogLevelValues, type Logger$1_Logger as Logger, Logger$1_defaultLogger as defaultLogger, Logger$1_getLogger as getLogger, Logger$1_runWithLogger as runWithLogger, Logger$1_silentLogger as silentLogger };
+  export { type OfferStore$1_FindMatchingOffersParams as FindMatchingOffersParams, type OfferStore$1_GetAllParams as GetAllParams, type OfferStore$1_GetOffersFilters as GetOffersFilters, type OfferStore$1_OfferStore as OfferStore, type OfferStore$1_PgConfig as PgConfig, create$3 as create };
 }
 
-type config = {
-    chain: Chain.Chain;
+type ServicesConfig = {
+    chain: Chain;
     rpcUrl: string;
     dbConfig: {
         type: "pg" | "pglite";
         endpoint?: string;
     };
+    collectorConfig?: {
+        interval?: number;
+        maxBatchSize?: number;
+        maxBlockNumber?: number;
+    };
 };
 type Services = {
+    indexer: Indexer;
     offerStore: OfferStore;
-    collectorBlockStore: CollectorBlockStore;
+    collectorStore: CollectorStore;
     liquidityStore: LiquidityStore;
+    chainStore: ChainStore;
+    healthService: HealthService;
     mempoolOffersCollector: Collector<"mempool_offers">;
     consumedEventsCollector: Collector<"consumed_events">;
     buyWithEmptyCallbackLiquidityCollector: Collector<"buy_with_empty_callback_liquidity">;
+    buyVaultV1CallbackLiquidityCollector: Collector<"buy_vault_v1_callback_liquidity">;
+    sellERC20CallbackLiquidityCollector: Collector<"sell_erc20_callback_liquidity">;
     DB: PG;
+    routerApi: RouterApi;
 };
-declare function from(config: config): Services;
+declare function from$3(config: ServicesConfig): Services;
+type Stores = ReturnType<typeof createStores>;
+declare function createStores(db: PG): {
+    collectorStore: CollectorStore;
+    offerStore: OfferStore;
+    liquidityStore: LiquidityStore;
+    chainStore: ChainStore;
+};
+declare function createWithTransaction<T>(db: PG): (fn: (s: ReturnType<typeof createStores>) => Promise<T>) => Promise<T>;
 
 type Services$1_Services = Services;
-type Services$1_config = config;
-declare const Services$1_from: typeof from;
+type Services$1_ServicesConfig = ServicesConfig;
+type Services$1_Stores = Stores;
+declare const Services$1_createStores: typeof createStores;
+declare const Services$1_createWithTransaction: typeof createWithTransaction;
 declare namespace Services$1 {
-  export { type Services$1_Services as Services, type Services$1_config as config, Services$1_from as from };
+  export { type Services$1_Services as Services, type Services$1_ServicesConfig as ServicesConfig, type Services$1_Stores as Stores, Services$1_createStores as createStores, Services$1_createWithTransaction as createWithTransaction, from$3 as from };
 }
 
+declare const names: readonly ["mempool_offers", "consumed_events", "buy_with_empty_callback_liquidity", "buy_vault_v1_callback_liquidity", "sell_erc20_callback_liquidity"];
+type Name = (typeof names)[number];
+/** A general collector interface. */
+type Collector<name extends Name = Name, chain extends Chain = Chain> = {
+    /** The name of the collector. */
+    readonly name: name;
+    /** The chain the collector is running on. */
+    readonly chain: chain;
+    /** Start collecting data from external sources.
+     * @yields The last block number processed by the collector.
+     */
+    collect: () => AsyncGenerator<number, void, void>;
+};
+/** A collector’s collect function signature */
+type CollectFn<chain extends Chain, collector extends Name> = (parameters: CollectParameters<chain, collector>) => Promise<number>;
+/** Core parameters every collector gets at runtime */
+type CollectParameters<chain extends Chain, collector extends Name> = {
+    /** The chain the collector is running on. */
+    chain: chain;
+    /** A public viem client. */
+    client: PublicClient;
+    /** The collector name. */
+    collector: collector;
+    /** The epoch the collector is running on. */
+    epoch: bigint;
+    /** The last block number processed by the collector. */
+    lastBlockNumber: number;
+    /** A function to execute database operations in a transaction. */
+    withTransaction: <T>(fn: (s: Stores) => Promise<T>) => Promise<T>;
+};
+declare function create$2<name extends Name, chain extends Chain>({ name, collect, client, chain, withTransaction, collectorStore, options, }: {
+    name: name;
+    collect: CollectFn<chain, name>;
+    chain: chain;
+    client: PublicClient;
+    withTransaction: <T>(fn: (s: Stores) => Promise<T>) => Promise<T>;
+    collectorStore: CollectorStore;
+    options: {
+        interval: number;
+        maxBlockNumber?: number;
+    };
+}): Collector<name, chain>;
+/** Start a collector.
+ * @param collector - The collector to start.
+ * @returns A function to stop the collector.
+ */
+declare function start(collector: Collector): () => void;
+
+type Builder<chain extends Chain = Chain> = {
+    buildMempoolCollector: (parameters: {
+        options?: {
+            maxBatchSize?: number;
+        };
+    }) => Collector<"mempool_offers", chain>;
+    buildConsumedEventsCollector: (parameters?: {
+        options?: {
+            maxBatchSize?: number;
+        };
+    }) => Collector<"consumed_events", chain>;
+    buildBuyWithEmptyCallbackLiquidityCollector: (parameters?: {
+        options?: {
+            maxBatchSize?: number;
+        };
+    }) => Collector<"buy_with_empty_callback_liquidity", chain>;
+    buildSellERC20CallbackLiquidityCollector: (parameters?: {
+        options?: {
+            maxBatchSize?: number;
+        };
+    }) => Collector<"sell_erc20_callback_liquidity", chain>;
+    buildBuyVaultV1CallbackLiquidityCollector: (parameters?: {
+        options?: {
+            maxBatchSize?: number;
+        };
+    }) => Collector<"buy_vault_v1_callback_liquidity", chain>;
+};
+declare function createBuilder<chain extends Chain = Chain>(parameters: {
+    client: PublicClient;
+    chain: chain;
+    db: PG;
+    options: {
+        interval: number;
+        maxBlockNumber?: number;
+    };
+}): Builder<chain>;
+
+/**
+ * Fetches ERC20 token balances and allowances using multicall.
+ * Returns liquidity pools and links.
+ *
+ * @param parameters - Configuration for the fetch operation including user-token pairs
+ * @returns Promise resolving to pools and links arrays
+ */
+declare function fetchBalancesAndAllowances(parameters: {
+    client: Pick<PublicActions, "multicall">;
+    chainId: bigint;
+    spender: Address;
+    pairs: Array<{
+        user: Address;
+        token: Address;
+    }>;
+    options?: {
+        batchSize?: number;
+        retryAttempts?: number;
+        retryDelayMs?: number;
+        blockNumber?: number;
+    };
+}): Promise<{
+    pools: LiquidityPool[];
+    links: LiquidityLink[];
+}>;
+
+/**
+ * Fetches existing collateral and debt data from Morpho protocol for user-term-collateral combinations.
+ * Returns liquidity pools for obligation collateral and debt.
+ *
+ * @param parameters - Configuration for the fetch operation
+ * @returns Promise resolving to pools array (no links for obligation collateral/debt pools)
+ */
+declare function fetchCollateralAndDebt(parameters: {
+    client: Pick<PublicActions, "multicall">;
+    chainId: bigint;
+    morphoAddress: Address;
+    queries: Array<{
+        user: Address;
+        obligationId: Hex;
+        collateralAssets: Address[];
+    }>;
+    options?: {
+        batchSize?: number;
+        retryAttempts?: number;
+        retryDelayMs?: number;
+        blockNumber?: number;
+    };
+}): Promise<{
+    pools: LiquidityPool[];
+}>;
+
+/**
+ * Fetches prices from multiple oracle contracts using multicall.
+ *
+ * @param parameters - Configuration for the fetch operation
+ * @returns Promise resolving to a Map: oracle address -> price
+ */
+declare function fetchOraclePrices(parameters: {
+    client: Pick<PublicActions, "multicall">;
+    oracles: Address[];
+    options?: {
+        batchSize?: number;
+        retryAttempts?: number;
+        retryDelayMs?: number;
+        blockNumber?: number;
+    };
+}): Promise<Map<Address, bigint>>;
+
+/**
+ * Fetches user positions in MetaMorpho vaults, vault positions in Morpho Blue markets, and total market liquidity.
+ * Returns liquidity pools for user vault positions, vault positions, and market liquidity, along with hierarchical links.
+ *
+ * @param parameters - Configuration for the fetch operation
+ * @param parameters.chain - The chain configuration containing chainId and Morpho Blue address
+ * @param parameters.userVaults - Array of user-vault pairs to query (markets are determined from vault's withdrawQueue)
+ * @returns Promise resolving to pools and links arrays
+ */
+declare function fetchUserVaultMarketLiquidity(parameters: {
+    client: Pick<PublicActions, "multicall">;
+    chain: Chain;
+    userVaults: Array<{
+        user: Address;
+        vault: Address;
+    }>;
+    options?: {
+        batchSize?: number;
+        retryAttempts?: number;
+        retryDelayMs?: number;
+        blockNumber?: number;
+    };
+}): Promise<{
+    pools: LiquidityPool[];
+    links: LiquidityLink[];
+}>;
+
 /**
  * A validation rule.
  */
@@ -1054,285 +1565,955 @@ declare function single<Name extends string, T, Ctx = void>(name: Name, run: Sin
  * @param run - The function that validates the rule.
  * @returns The created rule.
  */
-declare function batch<Name extends string, T, Ctx = void>(name: Name, run: Batch<T, Name, Ctx>): Rule<T, Name, Ctx>;
+declare function batch$1<Name extends string, T, Ctx = void>(name: Name, run: Batch<T, Name, Ctx>): Rule<T, Name, Ctx>;
 type MorphoContext = {
-    chain: Chain.Chain;
+    chain: Chain;
+    client: PublicClient;
 };
-declare function morpho(): (Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "chain_id", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "loan_token", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "expiry", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "sell_offers_empty_callback", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "buy_offers_non_empty_callback", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "sell_offers_non_whitelisted_callback", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "sell_offers_callback_data_invalid", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "sell_offers_callback_collateral_invalid", MorphoContext> | Rule<{
-    readonly offering: Address;
-    readonly assets: bigint;
-    readonly rate: bigint;
-    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
-    readonly expiry: number;
-    readonly nonce: bigint;
-    readonly buy: boolean;
-    readonly chainId: bigint;
-    readonly loanToken: Address;
-    readonly start: number;
-    readonly collaterals: readonly {
-        asset: Address;
-        oracle: Address;
-        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
-    }[];
-    readonly callback: {
-        readonly address: Address;
-        readonly data: viem.Hex;
-        readonly gasLimit: bigint;
-    };
-    readonly hash: viem.Hex;
-    signature?: viem.Hex;
-    createdAt?: number;
-}, "maturity", MorphoContext>)[];
+declare function morpho(): (Rule<Offer, "chain_id", MorphoContext> | Rule<Offer, "loan_token", MorphoContext> | Rule<Offer, "expiry", MorphoContext> | Rule<Offer, "sell_offers_empty_callback", MorphoContext> | Rule<Offer, "buy_offers_non_empty_callback", MorphoContext> | Rule<Offer, "sell_offers_non_whitelisted_callback", MorphoContext> | Rule<Offer, "sell_offers_callback_data_invalid", MorphoContext> | Rule<Offer, "sell_offers_callback_collateral_invalid", MorphoContext> | Rule<Offer, "buy_offers_callback_data_invalid", MorphoContext> | Rule<Offer, "buy_offers_callback_vault_invalid", MorphoContext> | Rule<Offer, "maturity", MorphoContext>)[];
 
 type ValidationRule_Batch<T, RuleName extends string, Ctx = void> = Batch<T, RuleName, Ctx>;
 type ValidationRule_MorphoContext = MorphoContext;
 type ValidationRule_Rule<T, Name extends string = string, Ctx = void> = Rule<T, Name, Ctx>;
 type ValidationRule_RuleNames<Rules extends readonly {
     name: string;
-}[]> = RuleNames<Rules>;
-type ValidationRule_Single<T, RuleName extends string, Ctx = void> = Single<T, RuleName, Ctx>;
-declare const ValidationRule_batch: typeof batch;
-declare const ValidationRule_morpho: typeof morpho;
-declare const ValidationRule_single: typeof single;
-declare namespace ValidationRule {
-  export { type ValidationRule_Batch as Batch, type ValidationRule_MorphoContext as MorphoContext, type ValidationRule_Rule as Rule, type ValidationRule_RuleNames as RuleNames, type ValidationRule_Single as Single, ValidationRule_batch as batch, ValidationRule_morpho as morpho, ValidationRule_single as single };
+}[]> = RuleNames<Rules>;
+type ValidationRule_Single<T, RuleName extends string, Ctx = void> = Single<T, RuleName, Ctx>;
+declare const ValidationRule_morpho: typeof morpho;
+declare const ValidationRule_single: typeof single;
+declare namespace ValidationRule {
+  export { type ValidationRule_Batch as Batch, type ValidationRule_MorphoContext as MorphoContext, type ValidationRule_Rule as Rule, type ValidationRule_RuleNames as RuleNames, type ValidationRule_Single as Single, batch$1 as batch, ValidationRule_morpho as morpho, ValidationRule_single as single };
+}
+
+/**
+ * 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 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>[];
+};
+declare function run<T, Name extends string, Rules extends readonly Rule<T, Name, void>[]>(parameters: {
+    items: T[];
+    rules: Rules;
+    chunkSize?: number;
+}): Promise<Result<T, RuleNames<Rules>>>;
+declare function run<T, Ctx, Name extends string, Rules extends readonly Rule<T, Name, Ctx>[]>(parameters: {
+    items: T[];
+    rules: Rules;
+    ctx: Ctx;
+    chunkSize?: number;
+}): Promise<Result<T, RuleNames<Rules>>>;
+
+type Validation_Issue<T, RuleName extends string = string> = Issue<T, RuleName>;
+type Validation_Result<T, RuleName extends string = string> = Result<T, RuleName>;
+declare const Validation_run: typeof run;
+declare namespace Validation {
+  export { type Validation_Issue as Issue, type Validation_Result as Result, Validation_run as run };
+}
+
+type index$4_Batch<T, RuleName extends string, Ctx = void> = Batch<T, RuleName, Ctx>;
+type index$4_Builder<chain extends Chain = Chain> = Builder<chain>;
+type index$4_CollectFn<chain extends Chain, collector extends Name> = CollectFn<chain, collector>;
+type index$4_CollectParameters<chain extends Chain, collector extends Name> = CollectParameters<chain, collector>;
+type index$4_Collector<name extends Name = Name, chain extends Chain = Chain> = Collector<name, chain>;
+type index$4_Issue<T, RuleName extends string = string> = Issue<T, RuleName>;
+type index$4_MorphoContext = MorphoContext;
+type index$4_Name = Name;
+type index$4_Result<T, RuleName extends string = string> = Result<T, RuleName>;
+type index$4_Rule<T, Name extends string = string, Ctx = void> = Rule<T, Name, Ctx>;
+type index$4_RuleNames<Rules extends readonly {
+    name: string;
+}[]> = RuleNames<Rules>;
+type index$4_Single<T, RuleName extends string, Ctx = void> = Single<T, RuleName, Ctx>;
+declare const index$4_createBuilder: typeof createBuilder;
+declare const index$4_fetchBalancesAndAllowances: typeof fetchBalancesAndAllowances;
+declare const index$4_fetchCollateralAndDebt: typeof fetchCollateralAndDebt;
+declare const index$4_fetchOraclePrices: typeof fetchOraclePrices;
+declare const index$4_fetchUserVaultMarketLiquidity: typeof fetchUserVaultMarketLiquidity;
+declare const index$4_morpho: typeof morpho;
+declare const index$4_names: typeof names;
+declare const index$4_run: typeof run;
+declare const index$4_single: typeof single;
+declare const index$4_start: typeof start;
+declare namespace index$4 {
+  export { type index$4_Batch as Batch, type index$4_Builder as Builder, type index$4_CollectFn as CollectFn, type index$4_CollectParameters as CollectParameters, type index$4_Collector as Collector, type index$4_Issue as Issue, type index$4_MorphoContext as MorphoContext, type index$4_Name as Name, type index$4_Result as Result, type index$4_Rule as Rule, type index$4_RuleNames as RuleNames, type index$4_Single as Single, batch$1 as batch, create$2 as create, index$4_createBuilder as createBuilder, index$4_fetchBalancesAndAllowances as fetchBalancesAndAllowances, index$4_fetchCollateralAndDebt as fetchCollateralAndDebt, index$4_fetchOraclePrices as fetchOraclePrices, index$4_fetchUserVaultMarketLiquidity as fetchUserVaultMarketLiquidity, index$4_morpho as morpho, index$4_names as names, index$4_run as run, index$4_single as single, index$4_start as start };
+}
+
+type CollectorHealthStatus = "live" | "lagging" | "unknown";
+type RouterStatus = "live" | "syncing";
+type CollectorHealth$1 = {
+    name: Name;
+    chainId: Id;
+    blockNumber: number | null;
+    updatedAt: string | null;
+    lag: number | null;
+    status: CollectorHealthStatus;
+};
+type ChainHealth$1 = {
+    chainId: Id;
+    blockNumber: number;
+    epoch: string;
+    updatedAt: string;
+};
+type HealthService = {
+    getStatus: () => Promise<RouterStatus>;
+    getCollectors: () => Promise<CollectorHealth$1[]>;
+    getChains: () => Promise<ChainHealth$1[]>;
+};
+type HealthServiceParameters = {
+    collectorStore: CollectorStore;
+    chainStore: ChainStore;
+    /** Maximum number of blocks a collector can lag behind its chain before being considered lagging. */
+    maxAllowedLag?: number;
+};
+/**
+ * Create a health service that exposes collector and chain block numbers.
+ */
+declare function create$1(parameters: HealthServiceParameters): HealthService;
+
+type Health_CollectorHealthStatus = CollectorHealthStatus;
+type Health_HealthService = HealthService;
+type Health_HealthServiceParameters = HealthServiceParameters;
+type Health_RouterStatus = RouterStatus;
+declare namespace Health {
+  export { type ChainHealth$1 as ChainHealth, type CollectorHealth$1 as CollectorHealth, type Health_CollectorHealthStatus as CollectorHealthStatus, type Health_HealthService as HealthService, type Health_HealthServiceParameters as HealthServiceParameters, type Health_RouterStatus as RouterStatus, create$1 as create };
+}
+
+type RouterApiConfig = {
+    store: OfferStore;
+    healthService: HealthService;
+};
+type RouterApi = {
+    serve: (parameters: {
+        port: number;
+    }) => void;
+};
+declare function create(config: RouterApiConfig): RouterApi;
+
+declare const LogLevelValues: readonly ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+type LogLevel = (typeof LogLevelValues)[number];
+type LogEntry = Compute<{
+    msg: string;
+} & Record<string, unknown>>;
+type LogFn = (entry: LogEntry) => void;
+type Logger = {
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    fatal: LogFn;
+};
+declare function defaultLogger(minLevel?: LogLevel, pretty?: boolean): Logger;
+declare function silentLogger(): Logger;
+declare function runWithLogger<T>(logger: Logger, fn: () => Promise<T>): Promise<T>;
+declare function getLogger(): Logger;
+
+type Logger$1_LogEntry = LogEntry;
+type Logger$1_LogFn = LogFn;
+type Logger$1_LogLevel = LogLevel;
+declare const Logger$1_LogLevelValues: typeof LogLevelValues;
+type Logger$1_Logger = Logger;
+declare const Logger$1_defaultLogger: typeof defaultLogger;
+declare const Logger$1_getLogger: typeof getLogger;
+declare const Logger$1_runWithLogger: typeof runWithLogger;
+declare const Logger$1_silentLogger: typeof silentLogger;
+declare namespace Logger$1 {
+  export { type Logger$1_LogEntry as LogEntry, type Logger$1_LogFn as LogFn, type Logger$1_LogLevel as LogLevel, Logger$1_LogLevelValues as LogLevelValues, type Logger$1_Logger as Logger, Logger$1_defaultLogger as defaultLogger, Logger$1_getLogger as getLogger, Logger$1_runWithLogger as runWithLogger, Logger$1_silentLogger as silentLogger };
+}
+
+declare enum STATUS_CODE {
+    SUCCESS = 200,
+    BAD_REQUEST = 400,
+    NOT_FOUND = 404,
+    INTERNAL_SERVER_ERROR = 500
+}
+
+declare function getHealth(healthService: HealthService): Promise<{
+    statusCode: STATUS_CODE;
+    body: {
+        status: "success" | "error";
+        meta: {
+            timestamp: string;
+        };
+    } & ({
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        cursor?: string | null;
+        data: unknown;
+    });
+}>;
+declare function getHealthChains(healthService: HealthService): Promise<{
+    statusCode: STATUS_CODE;
+    body: {
+        status: "success" | "error";
+        meta: {
+            timestamp: string;
+        };
+    } & ({
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        cursor?: string | null;
+        data: unknown;
+    });
+}>;
+declare function getHealthCollectors(healthService: HealthService): Promise<{
+    statusCode: STATUS_CODE;
+    body: {
+        status: "success" | "error";
+        meta: {
+            timestamp: string;
+        };
+    } & ({
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        cursor?: string | null;
+        data: unknown;
+    });
+}>;
+
+declare function getObligations$1(queryParameters: object, store: OfferStore): Promise<{
+    statusCode: STATUS_CODE;
+    body: {
+        status: "success" | "error";
+        meta: {
+            timestamp: string;
+        };
+    } & ({
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        cursor?: string | null;
+        data: unknown;
+    });
+}>;
+
+declare function getOffers$1(queryParameters: object, store: OfferStore): Promise<{
+    statusCode: STATUS_CODE;
+    body: {
+        status: "success" | "error";
+        meta: {
+            timestamp: string;
+        };
+    } & ({
+        error: {
+            code: string;
+            message: string;
+            details?: unknown;
+        };
+    } | {
+        cursor?: string | null;
+        data: unknown;
+    });
+}>;
+
+declare const index$3_getHealth: typeof getHealth;
+declare const index$3_getHealthChains: typeof getHealthChains;
+declare const index$3_getHealthCollectors: typeof getHealthCollectors;
+declare namespace index$3 {
+  export { index$3_getHealth as getHealth, index$3_getHealthChains as getHealthChains, index$3_getHealthCollectors as getHealthCollectors, getObligations$1 as getObligations, getOffers$1 as getOffers };
+}
+
+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<{
+        unknown: "unknown";
+        live: "live";
+        lagging: "lagging";
+    }>;
+}, 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.ZodObject<{
+    collectors: 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<{
+            unknown: "unknown";
+            live: "live";
+            lagging: "lagging";
+        }>;
+    }, z$1.core.$strip>>;
+}, z$1.core.$strip>;
+type CollectorsHealthResponse = z$1.infer<typeof CollectorsHealthResponse>;
+declare const ChainsHealthResponse: z$1.ZodObject<{
+    chains: 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>>;
+}, 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>;
+
+type ObligationResponse = Snake<Compute<{
+    /** The obligation id. */
+    id: Hex;
+} & Obligation>>;
+/**
+ * Creates an `ObligationResponse` from a `Obligation`.
+ * @constructor
+ * @param obligation - {@link Obligation}
+ * @returns The created `ObligationResponse`. {@link ObligationResponse}
+ */
+declare function from$2(obligation: Obligation): ObligationResponse;
+
+type ObligationResponse$1_ObligationResponse = ObligationResponse;
+declare namespace ObligationResponse$1 {
+  export { type ObligationResponse$1_ObligationResponse as ObligationResponse, from$2 as from };
+}
+
+type OfferResponse = Snake<Offer>;
+/**
+ * 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 const OpenApi: node_modules_zod_openapi_dist_components_DkyUTLcs_js.OpenAPIObject;
+
+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>;
+};
+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$2_ChainHealth: typeof ChainHealth;
+type index$2_ChainsHealthResponse = ChainsHealthResponse;
+declare const index$2_CollectorHealth: typeof CollectorHealth;
+type index$2_CollectorsHealthResponse = CollectorsHealthResponse;
+declare const index$2_OpenApi: typeof OpenApi;
+type index$2_RouterApi = RouterApi;
+type index$2_RouterApiConfig = RouterApiConfig;
+type index$2_RouterStatusResponse = RouterStatusResponse;
+declare const index$2_create: typeof create;
+declare const index$2_parse: typeof parse;
+declare const index$2_safeParse: typeof safeParse;
+declare namespace index$2 {
+  export { index$2_ChainHealth as ChainHealth, type index$2_ChainsHealthResponse as ChainsHealthResponse, index$2_CollectorHealth as CollectorHealth, type index$2_CollectorsHealthResponse as CollectorsHealthResponse, index$3 as Controllers, ObligationResponse$1 as ObligationResponse, OfferResponse$1 as OfferResponse, index$2_OpenApi as OpenApi, type index$2_RouterApi as RouterApi, type index$2_RouterApiConfig as RouterApiConfig, type index$2_RouterStatusResponse as RouterStatusResponse, index$2_create as create, index$2_parse as parse, index$2_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}
+     *
+     * @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}
+     *
+     * @example
+     * ```ts
+     * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
+     * const { obligations, cursor } = await router.getObligations();
+     * console.log(obligations);
+     * ```
+     */
+    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 options - {@link ConnectOptions}
+ * @returns A Router Client. {@link Client}
+ *
+ * @example
+ * ```typescript
+ * const router = RouterClient.connect({ url: "https://router.morpho.dev" });
+ * ```
+ */
+declare function connect$1(options?: ConnectOptions): connect$1.ReturnType;
+declare namespace connect$1 {
+    type ReturnType = Client$1;
+    type ErrorType = InvalidUrlError;
+}
+declare function getOffers(config: RouterClientConfig, 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(config: RouterClientConfig, 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: Obligation[];
+        /** 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 };
+}
+
+declare const users: Account[];
+declare const assetList: readonly ["USDC", "DAI"];
+declare const mockAddress: (asset: (typeof assetList)[number]) => `0x${string}`;
+declare const mockOracleAddress: `0x${string}`;
+declare const mockMorphoAddress: `0x${string}`;
+declare const mockFactoryAddress: `0x${string}`;
+declare const encodeConsumedEvent: (parameters: {
+    user: Address;
+    nonce: bigint;
+    amount: bigint;
+}) => `0x${string}`;
+declare const assetMethods: readonly ["balanceOf", "allowance"];
+declare const oracleMethods: readonly ["price"];
+declare const morphoMethods: readonly ["debtOf", "collateralOf", "market", "position"];
+declare const vaultMethods: readonly ["asset", "balanceOf", "totalSupply", "totalAssets", "withdrawQueue"];
+declare const factoryMethods: readonly ["isMetaMorpho", "morpho"];
+type AssetMethod = (typeof assetMethods)[number];
+type OracleMethod = (typeof oracleMethods)[number];
+type MorphoMethod = (typeof morphoMethods)[number];
+type VaultMethod = (typeof vaultMethods)[number];
+type FactoryMethod = (typeof factoryMethods)[number];
+type MethodParameters = {
+    balanceOf: {
+        address: Address;
+        value: bigint;
+    };
+    allowance: {
+        owner: Address;
+        spender: Address;
+        value: bigint;
+    };
+};
+type OracleMethodParameters = {
+    price: {
+        value: bigint;
+    };
+};
+type MorphoMethodParameters = {
+    debtOf: {
+        user: Address;
+        obligationId: Hex;
+        value: bigint;
+    };
+    collateralOf: {
+        user: Address;
+        obligationId: Hex;
+        collateralAsset: Address;
+        value: bigint;
+    };
+    market: {
+        marketId: Hex;
+        totalSupplyAssets: bigint;
+        totalSupplyShares: bigint;
+        totalBorrowAssets: bigint;
+        totalBorrowShares: bigint;
+        lastUpdate: bigint;
+        fee: bigint;
+    };
+    position: {
+        marketId: Hex;
+        user: Address;
+        supplyShares: bigint;
+        borrowShares: bigint;
+        collateral: bigint;
+    };
+};
+type VaultMethodParameters = {
+    asset: {
+        value: Address;
+    };
+    balanceOf: {
+        user: Address;
+        value: bigint;
+    };
+    totalSupply: {
+        value: bigint;
+    };
+    totalAssets: {
+        value: bigint;
+    };
+    withdrawQueue: {
+        value: Hex[];
+    };
+};
+type FactoryMethodParameters = {
+    isMetaMorpho: {
+        vault: Address;
+        value: boolean;
+    };
+    morpho: {
+        value: Address;
+    };
+};
+type MockedAsset = {
+    address: Address;
+    set: (slot: Hex | AssetMethod, parameters: Hex | bigint | MethodParameters[AssetMethod]) => Promise<void>;
+};
+type MockedOracle = {
+    address: Address;
+    set: (method: OracleMethod, parameters: OracleMethodParameters[OracleMethod]) => Promise<void>;
+};
+type MockedMorpho = {
+    address: Address;
+    set: (method: MorphoMethod, parameters: MorphoMethodParameters[MorphoMethod]) => Promise<void>;
+};
+type MockedVault = {
+    address: Address;
+    set: (method: VaultMethod, parameters: VaultMethodParameters[VaultMethod]) => Promise<void>;
+};
+type MockedFactory = {
+    address: Address;
+    set: (method: FactoryMethod, parameters: FactoryMethodParameters[FactoryMethod]) => Promise<void>;
+};
+type Mocked = {
+    name: string;
+    client: WalletClient;
+    mempoolAddress: Address;
+    termsAddress: Address;
+    mine: () => Promise<void>;
+    reset: () => Promise<void>;
+    deployVault: () => Promise<MockedVault>;
+    oracle: MockedOracle;
+    morpho: MockedMorpho;
+    factory: MockedFactory;
+} & Record<(typeof assetList)[number], MockedAsset>;
+declare function mock(name: string): Promise<Mocked>;
+/**
+ * Start a local anvil chain.
+ * @example
+ * ```ts
+ * import { EVM } from "@morpho-dev/router";
+ * EVM.serve(); // local chain rpc url running on http://localhost:8545
+ * ```
+ */
+declare function serve(parameters: {
+    port: number;
+    forkUrl: string;
+    blockNumber?: number;
+}): Promise<{
+    rpcUrl: `http://localhost:${number}`;
+    stop: () => boolean;
+}>;
+
+type EVM_AssetMethod = AssetMethod;
+type EVM_FactoryMethod = FactoryMethod;
+type EVM_FactoryMethodParameters = FactoryMethodParameters;
+type EVM_MethodParameters = MethodParameters;
+type EVM_Mocked = Mocked;
+type EVM_MockedAsset = MockedAsset;
+type EVM_MockedFactory = MockedFactory;
+type EVM_MockedMorpho = MockedMorpho;
+type EVM_MockedOracle = MockedOracle;
+type EVM_MockedVault = MockedVault;
+type EVM_MorphoMethod = MorphoMethod;
+type EVM_MorphoMethodParameters = MorphoMethodParameters;
+type EVM_OracleMethod = OracleMethod;
+type EVM_OracleMethodParameters = OracleMethodParameters;
+type EVM_VaultMethod = VaultMethod;
+type EVM_VaultMethodParameters = VaultMethodParameters;
+declare const EVM_assetList: typeof assetList;
+declare const EVM_assetMethods: typeof assetMethods;
+declare const EVM_encodeConsumedEvent: typeof encodeConsumedEvent;
+declare const EVM_factoryMethods: typeof factoryMethods;
+declare const EVM_mock: typeof mock;
+declare const EVM_mockAddress: typeof mockAddress;
+declare const EVM_mockFactoryAddress: typeof mockFactoryAddress;
+declare const EVM_mockMorphoAddress: typeof mockMorphoAddress;
+declare const EVM_mockOracleAddress: typeof mockOracleAddress;
+declare const EVM_morphoMethods: typeof morphoMethods;
+declare const EVM_oracleMethods: typeof oracleMethods;
+declare const EVM_serve: typeof serve;
+declare const EVM_users: typeof users;
+declare const EVM_vaultMethods: typeof vaultMethods;
+declare namespace EVM {
+  export { type EVM_AssetMethod as AssetMethod, type EVM_FactoryMethod as FactoryMethod, type EVM_FactoryMethodParameters as FactoryMethodParameters, type EVM_MethodParameters as MethodParameters, type EVM_Mocked as Mocked, type EVM_MockedAsset as MockedAsset, type EVM_MockedFactory as MockedFactory, type EVM_MockedMorpho as MockedMorpho, type EVM_MockedOracle as MockedOracle, type EVM_MockedVault as MockedVault, type EVM_MorphoMethod as MorphoMethod, type EVM_MorphoMethodParameters as MorphoMethodParameters, type EVM_OracleMethod as OracleMethod, type EVM_OracleMethodParameters as OracleMethodParameters, type EVM_VaultMethod as VaultMethod, type EVM_VaultMethodParameters as VaultMethodParameters, EVM_assetList as assetList, EVM_assetMethods as assetMethods, EVM_encodeConsumedEvent as encodeConsumedEvent, EVM_factoryMethods as factoryMethods, EVM_mock as mock, EVM_mockAddress as mockAddress, EVM_mockFactoryAddress as mockFactoryAddress, EVM_mockMorphoAddress as mockMorphoAddress, EVM_mockOracleAddress as mockOracleAddress, EVM_morphoMethods as morphoMethods, EVM_oracleMethods as oracleMethods, EVM_serve as serve, EVM_users as users, EVM_vaultMethods as vaultMethods };
+}
+
+type MempoolEVMClientConfig = {
+    readonly client: WalletClient;
+    readonly mempoolAddress: Address;
+    readonly blockWindow: number;
+};
+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;
+}
+/**
+ * Add an offer to the mempool.
+ * @returns The created offer with its hash.
+ * @throws WalletAccountNotSetError if the wallet account is not set.
+ * @throws ViemClientError if the viem client throws an error.
+ * @throws Offer.InvalidOfferError if the offer is invalid.
+ */
+declare function add(config: MempoolEVMClientConfig, parameters: AddParameters): Promise<{
+    offer: Offer;
+    txHash: Hex;
+}>;
+declare namespace add {
+    type ErrorType = WalletAccountNotSetError | ViemClientError | InvalidOfferError | ChainIdMismatchError;
+}
+declare function get(config: MempoolEVMClientConfig, parameters?: GetParameters): AsyncGenerator<{
+    offers: Offer[];
+    blockNumber: number;
+}, void, void>;
+declare namespace get {
+    type ErrorType = streamOffersReturnType;
+}
+/**
+ * Watch for new offers on a specific chain.
+ * @returns A function to stop watching for new offers.
+ */
+declare function watch(config: MempoolEVMClientConfig, parameters: WatchParameters): () => boolean;
+declare namespace watch {
+    type ErrorType = streamOffersReturnType;
+}
+type streamOffersReturnType = WalletAccountNotSetError | ChainIdMismatchError;
+declare class WalletAccountNotSetError extends BaseError {
+    name: string;
+    constructor();
+}
+declare class ViemClientError extends BaseError {
+    name: string;
+}
+declare class ChainIdMismatchError extends BaseError {
+    name: string;
+    constructor(expected: bigint, actual: bigint);
 }
 
+type AddParameters = {
+    offer: 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;
+    };
+};
+type WatchParameters = {
+    /** The async function to get the last synced block number from which to start watching.
+     *  This function will be called periodically on each poll. It should be updated by the caller (e.g. using `onOffers` callback) to track the last synced block number.
+     */
+    lastSyncedBlock: () => Promise<number>;
+    /** The loan asset to watch. */
+    loanToken?: string;
+    /** The callback to call when a new batch of offers is found in the mempool.
+     * @param offers The offers found in the mempool.
+     * @param blockNumber The block number of the last processed offer. Block numbers will always ascend.
+     */
+    onOffers: (offers: Offer[], blockNumber: number) => Promise<void>;
+    /** The polling configuration. */
+    polling?: {
+        /** The interval in milliseconds to poll for new offers. Defaults to 30000. */
+        interval?: number;
+        /** The maximum number of offers that can be returned in a single batch.
+         * Defaults to 100. Maximum is 1000. */
+        maxBatchSize?: number;
+    };
+};
 /**
- * A validation issue.
+ * Mempool client interface.
  */
-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;
+type Client = {
+    /**
+     * Add an offer to the mempool.
+     * @returns The created offer with its hash.
+     */
+    add: (parameters: AddParameters) => Promise<{
+        offer: Offer;
+        txHash: 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;
+    }>;
+    /**
+     * Watch for new offers on a specific chain.
+     * @returns A function to stop watching for new offers.
+     */
+    watch: (parameters: WatchParameters) => () => boolean;
+    /**
+     * 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;
+    }>;
 };
 /**
- * The result of a validation.
+ * Client to interact with the Mempool contract on a specific chain.
  */
-type Result<T, RuleName extends string = string> = {
-    /** 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, void>[]>(parameters: {
-    items: T[];
-    rules: Rules;
-    chunkSize?: number;
-}): Promise<Result<T, RuleNames<Rules>>>;
-declare function run<T, Ctx, Name extends string, Rules extends readonly Rule<T, Name, Ctx>[]>(parameters: {
-    items: T[];
-    rules: Rules;
-    ctx: Ctx;
-    chunkSize?: number;
-}): Promise<Result<T, RuleNames<Rules>>>;
+declare function connect(parameters: from.Parameters): Client;
+declare namespace connect {
+    type ErrorType = from.ErrorType;
+}
 
-type Validation_Issue<T, RuleName extends string = string> = Issue<T, RuleName>;
-type Validation_Result<T, RuleName extends string = string> = Result<T, RuleName>;
-declare const Validation_run: typeof run;
-declare namespace Validation {
-  export { type Validation_Issue as Issue, type Validation_Result as Result, Validation_run as run };
+type index$1_AddParameters = AddParameters;
+type index$1_ChainIdMismatchError = ChainIdMismatchError;
+declare const index$1_ChainIdMismatchError: typeof ChainIdMismatchError;
+type index$1_Client = Client;
+type index$1_GetParameters = GetParameters;
+type index$1_ViemClientError = ViemClientError;
+declare const index$1_ViemClientError: typeof ViemClientError;
+type index$1_WalletAccountNotSetError = WalletAccountNotSetError;
+declare const index$1_WalletAccountNotSetError: typeof WalletAccountNotSetError;
+type index$1_WatchParameters = WatchParameters;
+declare const index$1_add: typeof add;
+declare const index$1_connect: typeof connect;
+declare const index$1_from: typeof from;
+declare const index$1_get: typeof get;
+declare const index$1_watch: typeof watch;
+declare namespace index$1 {
+  export { type index$1_AddParameters as AddParameters, index$1_ChainIdMismatchError as ChainIdMismatchError, type index$1_Client as Client, type index$1_GetParameters as GetParameters, index$1_ViemClientError as ViemClientError, index$1_WalletAccountNotSetError as WalletAccountNotSetError, type index$1_WatchParameters as WatchParameters, index$1_add as add, index$1_connect as connect, index$1_from as from, index$1_get as get, index$1_watch as watch };
 }
 
-declare const VERSION = "router_v1.1";
+declare const VERSION = "router_v1.4";
+declare const obligations: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "obligations";
+    schema: "router_v1.4";
+    columns: {
+        obligationId: drizzle_orm_pg_core.PgColumn<{
+            name: "obligation_id";
+            tableName: "obligations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 66;
+        }>;
+        chainId: drizzle_orm_pg_core.PgColumn<{
+            name: "chain_id";
+            tableName: "obligations";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        loanToken: drizzle_orm_pg_core.PgColumn<{
+            name: "loan_token";
+            tableName: "obligations";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 42;
+        }>;
+        maturity: drizzle_orm_pg_core.PgColumn<{
+            name: "maturity";
+            tableName: "obligations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 declare const offers: drizzle_orm_pg_core.PgTableWithColumns<{
     name: "offers";
-    schema: "router_v1.1";
+    schema: "router_v1.4";
     columns: {
         hash: drizzle_orm_pg_core.PgColumn<{
             name: "hash";
@@ -1353,6 +2534,25 @@ declare const offers: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {
             length: 66;
         }>;
+        obligationId: drizzle_orm_pg_core.PgColumn<{
+            name: "obligation_id";
+            tableName: "offers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 66;
+        }>;
         offering: drizzle_orm_pg_core.PgColumn<{
             name: "offering";
             tableName: "offers";
@@ -1568,143 +2768,26 @@ declare const offers: drizzle_orm_pg_core.PgTableWithColumns<{
             tableName: "offers";
             dataType: "bigint";
             columnType: "PgBigInt64";
-            data: bigint;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        signature: drizzle_orm_pg_core.PgColumn<{
-            name: "signature";
-            tableName: "offers";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 132;
-        }>;
-        callbackId: drizzle_orm_pg_core.PgColumn<{
-            name: "callback_id";
-            tableName: "offers";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 256;
-        }>;
-        createdAt: drizzle_orm_pg_core.PgColumn<{
-            name: "created_at";
-            tableName: "offers";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-    };
-    dialect: "pg";
-}>;
-declare const offerCollaterals: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "offer_collaterals";
-    schema: "router_v1.1";
-    columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
-            name: "id";
-            tableName: "offer_collaterals";
-            dataType: "number";
-            columnType: "PgSerial";
-            data: number;
-            driverParam: number;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: true;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        offerHash: drizzle_orm_pg_core.PgColumn<{
-            name: "offer_hash";
-            tableName: "offer_collaterals";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 66;
-        }>;
-        asset: drizzle_orm_pg_core.PgColumn<{
-            name: "asset";
-            tableName: "offer_collaterals";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
+            data: bigint;
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {
-            length: 42;
-        }>;
-        oracle: drizzle_orm_pg_core.PgColumn<{
-            name: "oracle";
-            tableName: "offer_collaterals";
+        }, {}, {}>;
+        signature: drizzle_orm_pg_core.PgColumn<{
+            name: "signature";
+            tableName: "offers";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -1714,17 +2797,17 @@ declare const offerCollaterals: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {
-            length: 42;
+            length: 132;
         }>;
-        lltv: drizzle_orm_pg_core.PgColumn<{
-            name: "lltv";
-            tableName: "offer_collaterals";
-            dataType: "bigint";
-            columnType: "PgBigInt64";
-            data: bigint;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "offers";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
             driverParam: string;
             notNull: true;
-            hasDefault: false;
+            hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
@@ -1733,23 +2816,16 @@ declare const offerCollaterals: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-    };
-    dialect: "pg";
-}>;
-declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "offer_status";
-    schema: "router_v1.1";
-    columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
-            name: "id";
-            tableName: "offer_status";
+        blockNumber: drizzle_orm_pg_core.PgColumn<{
+            name: "block_number";
+            tableName: "offers";
             dataType: "number";
-            columnType: "PgSerial";
+            columnType: "PgBigInt53";
             data: number;
-            driverParam: number;
+            driverParam: string | number;
             notNull: true;
-            hasDefault: true;
-            isPrimaryKey: true;
+            hasDefault: false;
+            isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
             enumValues: undefined;
@@ -1757,9 +2833,16 @@ declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        offerHash: drizzle_orm_pg_core.PgColumn<{
-            name: "offer_hash";
-            tableName: "offer_status";
+    };
+    dialect: "pg";
+}>;
+declare const obligationCollaterals: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "obligation_collaterals";
+    schema: "router_v1.4";
+    columns: {
+        obligationId: drizzle_orm_pg_core.PgColumn<{
+            name: "obligation_id";
+            tableName: "obligation_collaterals";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
@@ -1776,12 +2859,12 @@ declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {
             length: 66;
         }>;
-        status: drizzle_orm_pg_core.PgColumn<{
-            name: "status";
-            tableName: "offer_status";
+        asset: drizzle_orm_pg_core.PgColumn<{
+            name: "asset";
+            tableName: "obligation_collaterals";
             dataType: "string";
-            columnType: "PgText";
-            data: "valid" | "callback_not_supported" | "callback_error" | "unverified";
+            columnType: "PgVarchar";
+            data: string;
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -1793,34 +2876,36 @@ declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {
-            $type: "valid" | "callback_not_supported" | "callback_error" | "unverified";
+            length: 42;
         }>;
-        metadata: drizzle_orm_pg_core.PgColumn<{
-            name: "metadata";
-            tableName: "offer_status";
-            dataType: "json";
-            columnType: "PgJsonb";
-            data: unknown;
-            driverParam: unknown;
-            notNull: false;
+        oracle: drizzle_orm_pg_core.PgColumn<{
+            name: "oracle";
+            tableName: "obligation_collaterals";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: undefined;
+            enumValues: [string, ...string[]];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {}>;
-        createdAt: drizzle_orm_pg_core.PgColumn<{
-            name: "created_at";
-            tableName: "offer_status";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
+        }, {}, {
+            length: 42;
+        }>;
+        lltv: drizzle_orm_pg_core.PgColumn<{
+            name: "lltv";
+            tableName: "obligation_collaterals";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
             driverParam: string;
             notNull: true;
-            hasDefault: true;
+            hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
@@ -1834,7 +2919,7 @@ declare const offerStatus: drizzle_orm_pg_core.PgTableWithColumns<{
 }>;
 declare const consumed: drizzle_orm_pg_core.PgTableWithColumns<{
     name: "consumed_per_user_and_nonce";
-    schema: "router_v1.1";
+    schema: "router_v1.4";
     columns: {
         id: drizzle_orm_pg_core.PgColumn<{
             name: "id";
@@ -1925,6 +3010,23 @@ declare const consumed: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        blockNumber: drizzle_orm_pg_core.PgColumn<{
+            name: "block_number";
+            tableName: "consumed_per_user_and_nonce";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: drizzle_orm_pg_core.PgColumn<{
             name: "created_at";
             tableName: "consumed_per_user_and_nonce";
@@ -1945,13 +3047,13 @@ declare const consumed: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-declare const collectorBlockNumbers: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "collector_block_numbers";
-    schema: "router_v1.1";
+declare const collectors: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "collectors";
+    schema: "router_v1.4";
     columns: {
         chainId: drizzle_orm_pg_core.PgColumn<{
             name: "chain_id";
-            tableName: "collector_block_numbers";
+            tableName: "collectors";
             dataType: "bigint";
             columnType: "PgBigInt64";
             data: bigint;
@@ -1968,10 +3070,10 @@ declare const collectorBlockNumbers: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {}>;
         name: drizzle_orm_pg_core.PgColumn<{
             name: "name";
-            tableName: "collector_block_numbers";
+            tableName: "collectors";
             dataType: "string";
             columnType: "PgText";
-            data: string;
+            data: "mempool_offers" | "consumed_events" | "buy_with_empty_callback_liquidity" | "buy_vault_v1_callback_liquidity" | "sell_erc20_callback_liquidity";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -1982,10 +3084,12 @@ declare const collectorBlockNumbers: drizzle_orm_pg_core.PgTableWithColumns<{
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {}>;
+        }, {}, {
+            $type: "mempool_offers" | "consumed_events" | "buy_with_empty_callback_liquidity" | "buy_vault_v1_callback_liquidity" | "sell_erc20_callback_liquidity";
+        }>;
         blockNumber: drizzle_orm_pg_core.PgColumn<{
             name: "block_number";
-            tableName: "collector_block_numbers";
+            tableName: "collectors";
             dataType: "number";
             columnType: "PgBigInt53";
             data: number;
@@ -2000,9 +3104,26 @@ declare const collectorBlockNumbers: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        epoch: drizzle_orm_pg_core.PgColumn<{
+            name: "epoch";
+            tableName: "collectors";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         updatedAt: drizzle_orm_pg_core.PgColumn<{
             name: "updated_at";
-            tableName: "collector_block_numbers";
+            tableName: "collectors";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -2020,38 +3141,53 @@ declare const collectorBlockNumbers: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-declare const availableLiquidityPools: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "available_liquidity_pools";
-    schema: "router_v1.1";
+declare const chains: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "chains";
+    schema: "router_v1.4";
     columns: {
-        id: drizzle_orm_pg_core.PgColumn<{
-            name: "id";
-            tableName: "available_liquidity_pools";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
+        chainId: drizzle_orm_pg_core.PgColumn<{
+            name: "chain_id";
+            tableName: "chains";
+            dataType: "bigint";
+            columnType: "PgBigInt64";
+            data: bigint;
             driverParam: string;
             notNull: true;
             hasDefault: false;
-            isPrimaryKey: true;
+            isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {
-            length: 255;
-        }>;
-        amount: drizzle_orm_pg_core.PgColumn<{
-            name: "amount";
-            tableName: "available_liquidity_pools";
+        }, {}, {}>;
+        blockNumber: drizzle_orm_pg_core.PgColumn<{
+            name: "block_number";
+            tableName: "chains";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        epoch: drizzle_orm_pg_core.PgColumn<{
+            name: "epoch";
+            tableName: "chains";
             dataType: "string";
             columnType: "PgNumeric";
             data: string;
             driverParam: string;
             notNull: true;
-            hasDefault: false;
+            hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
@@ -2062,7 +3198,7 @@ declare const availableLiquidityPools: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {}>;
         updatedAt: drizzle_orm_pg_core.PgColumn<{
             name: "updated_at";
-            tableName: "available_liquidity_pools";
+            tableName: "chains";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -2080,13 +3216,13 @@ declare const availableLiquidityPools: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-declare const availableLiquidityQueues: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "available_liquidity_queues";
-    schema: "router_v1.1";
+declare const offerLiquidityPools: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "offer_liquidity_pools";
+    schema: "router_v1.4";
     columns: {
-        queueId: drizzle_orm_pg_core.PgColumn<{
-            name: "queue_id";
-            tableName: "available_liquidity_queues";
+        offerHash: drizzle_orm_pg_core.PgColumn<{
+            name: "offer_hash";
+            tableName: "offer_liquidity_pools";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
@@ -2101,11 +3237,11 @@ declare const availableLiquidityQueues: drizzle_orm_pg_core.PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {
-            length: 255;
+            length: 66;
         }>;
-        availableLiquidityPoolId: drizzle_orm_pg_core.PgColumn<{
-            name: "available_liquidity_pool_id";
-            tableName: "available_liquidity_queues";
+        poolId: drizzle_orm_pg_core.PgColumn<{
+            name: "pool_id";
+            tableName: "offer_liquidity_pools";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
@@ -2122,32 +3258,15 @@ declare const availableLiquidityQueues: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {
             length: 255;
         }>;
-        index: drizzle_orm_pg_core.PgColumn<{
-            name: "index";
-            tableName: "available_liquidity_queues";
-            dataType: "number";
-            columnType: "PgInteger";
-            data: number;
-            driverParam: string | number;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        callbackAmount: drizzle_orm_pg_core.PgColumn<{
-            name: "callback_amount";
-            tableName: "available_liquidity_queues";
+        amount: drizzle_orm_pg_core.PgColumn<{
+            name: "amount";
+            tableName: "offer_liquidity_pools";
             dataType: "string";
             columnType: "PgNumeric";
             data: string;
             driverParam: string;
             notNull: true;
-            hasDefault: true;
+            hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
@@ -2158,7 +3277,7 @@ declare const availableLiquidityQueues: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {}>;
         updatedAt: drizzle_orm_pg_core.PgColumn<{
             name: "updated_at";
-            tableName: "available_liquidity_queues";
+            tableName: "offer_liquidity_pools";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -2176,13 +3295,13 @@ declare const availableLiquidityQueues: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
-declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
-    name: "user_positions";
-    schema: "router_v1.1";
+declare const liquidityPools: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "liquidity_pools";
+    schema: "router_v1.4";
     columns: {
         id: drizzle_orm_pg_core.PgColumn<{
             name: "id";
-            tableName: "user_positions";
+            tableName: "liquidity_pools";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
@@ -2199,11 +3318,11 @@ declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {
             length: 255;
         }>;
-        availableLiquidityQueueId: drizzle_orm_pg_core.PgColumn<{
-            name: "available_liquidity_queue_id";
-            tableName: "user_positions";
+        amount: drizzle_orm_pg_core.PgColumn<{
+            name: "amount";
+            tableName: "liquidity_pools";
             dataType: "string";
-            columnType: "PgVarchar";
+            columnType: "PgNumeric";
             data: string;
             driverParam: string;
             notNull: true;
@@ -2211,16 +3330,38 @@ declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {
-            length: 255;
-        }>;
-        user: drizzle_orm_pg_core.PgColumn<{
-            name: "user";
-            tableName: "user_positions";
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "liquidity_pools";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const liquidityLinks: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "liquidity_links";
+    schema: "router_v1.4";
+    columns: {
+        parentPoolId: drizzle_orm_pg_core.PgColumn<{
+            name: "parent_pool_id";
+            tableName: "liquidity_links";
             dataType: "string";
             columnType: "PgVarchar";
             data: string;
@@ -2237,30 +3378,32 @@ declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {
             length: 255;
         }>;
-        chainId: drizzle_orm_pg_core.PgColumn<{
-            name: "chain_id";
-            tableName: "user_positions";
-            dataType: "bigint";
-            columnType: "PgBigInt64";
-            data: bigint;
+        childPoolId: drizzle_orm_pg_core.PgColumn<{
+            name: "child_pool_id";
+            tableName: "liquidity_links";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: undefined;
+            enumValues: [string, ...string[]];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
-        }, {}, {}>;
-        amount: drizzle_orm_pg_core.PgColumn<{
-            name: "amount";
-            tableName: "user_positions";
-            dataType: "string";
-            columnType: "PgNumeric";
-            data: string;
-            driverParam: string;
+        }, {}, {
+            length: 255;
+        }>;
+        priority: drizzle_orm_pg_core.PgColumn<{
+            name: "priority";
+            tableName: "liquidity_links";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
@@ -2273,7 +3416,7 @@ declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
         }, {}, {}>;
         updatedAt: drizzle_orm_pg_core.PgColumn<{
             name: "updated_at";
-            tableName: "user_positions";
+            tableName: "liquidity_links";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -2293,16 +3436,102 @@ declare const userPositions: drizzle_orm_pg_core.PgTableWithColumns<{
 }>;
 
 declare const schema_VERSION: typeof VERSION;
-declare const schema_availableLiquidityPools: typeof availableLiquidityPools;
-declare const schema_availableLiquidityQueues: typeof availableLiquidityQueues;
-declare const schema_collectorBlockNumbers: typeof collectorBlockNumbers;
+declare const schema_chains: typeof chains;
+declare const schema_collectors: typeof collectors;
 declare const schema_consumed: typeof consumed;
-declare const schema_offerCollaterals: typeof offerCollaterals;
-declare const schema_offerStatus: typeof offerStatus;
+declare const schema_liquidityLinks: typeof liquidityLinks;
+declare const schema_liquidityPools: typeof liquidityPools;
+declare const schema_obligationCollaterals: typeof obligationCollaterals;
+declare const schema_obligations: typeof obligations;
+declare const schema_offerLiquidityPools: typeof offerLiquidityPools;
 declare const schema_offers: typeof offers;
-declare const schema_userPositions: typeof userPositions;
 declare namespace schema {
-  export { schema_VERSION as VERSION, schema_availableLiquidityPools as availableLiquidityPools, schema_availableLiquidityQueues as availableLiquidityQueues, schema_collectorBlockNumbers as collectorBlockNumbers, schema_consumed as consumed, schema_offerCollaterals as offerCollaterals, schema_offerStatus as offerStatus, schema_offers as offers, schema_userPositions as userPositions };
+  export { schema_VERSION as VERSION, schema_chains as chains, schema_collectors as collectors, schema_consumed as consumed, schema_liquidityLinks as liquidityLinks, schema_liquidityPools as liquidityPools, schema_obligationCollaterals as obligationCollaterals, schema_obligations as obligations, schema_offerLiquidityPools as offerLiquidityPools, schema_offers as offers };
+}
+
+declare function max$1(a: bigint, b: bigint): bigint;
+declare function min(a: bigint, b: bigint): bigint;
+
+/**
+ * Splits an array into batches of a specified size.
+ * @param array The array to split.
+ * @param batchSize The size of each batch.
+ * @returns An iterator that yields each batch.
+ * @example
+ * ```typescript
+ * const array = [1, 2, 3, 4, 5];
+ * for (const batch of batch(array, 2)) {
+ *  console.log(batch);
+ * }
+ * // Output:
+ * // [1, 2]
+ * // [3, 4]
+ * // [5]
+ * ```
+ */
+declare function batch<T>(array: Array<T>, batchSize: number): Generator<T[], void, unknown>;
+
+/**
+ * Helper function to execute multicall in batches with retry logic.
+ * Abstracts the common pattern of batching calls, retrying, and collecting results.
+ *
+ * @param parameters - Configuration for batched multicall
+ * @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;
+}): Promise<TResult[]>;
+
+/**
+ * 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;
+}) => () => boolean): () => AsyncGenerator<Awaited<NonNullable<T>>, void, unknown>;
+
+/**
+ * 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;
+}): () => boolean;
+
+declare const retry: <T>(fn: () => Promise<T>, attempts?: number, delayMs?: number) => Promise<T>;
+
+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 };
+}
+
+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_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$2 as fromSnakeCase, index_lazy as lazy, max$1 as max, index_min as min, index_poll as poll, index_retry as retry, toSnakeCase$1 as toSnakeCase, index_wait as wait };
 }
 
-export { Callback, index$1 as Collector, CollectorBlockStore$1 as CollectorBlockStore, Cursor$1 as Cursor, Liquidity$1 as Liquidity, LiquidityStore$1 as LiquidityStore, Logger$1 as Logger, OfferStore$1 as OfferStore, schema as OffersSchema, PG$1 as PG, index as RouterApi, RouterOffer$1 as RouterOffer, Services$1 as Services, Validation, ValidationRule };
+export { Abi, type Brand, BrandTypeId, Callback, Chain$1 as Chain, ChainHealth, ChainStore$1 as ChainStore, ChainsHealthResponse, Collateral$1 as Collateral, index$4 as Collector, CollectorHealth, CollectorStore$1 as CollectorStore, CollectorsHealthResponse, type Compute, Cursor$1 as Cursor, EVM, Errors, Format, Health, LLTV$1 as LLTV, Liquidity, LiquidityStore$1 as LiquidityStore, Logger$1 as Logger, Maturity$1 as Maturity, index$1 as Mempool, Obligation$1 as Obligation, ObligationResponse$1 as ObligationResponse, Offer$1 as Offer, OfferResponse$1 as OfferResponse, OfferStore$1 as OfferStore, schema as OffersSchema, OpenApi, PG$1 as PG, index$2 as RouterApi, Client$2 as RouterClient, RouterIndexer, RouterStatusResponse, Services$1 as Services, time as Time, index as Utils, Validation, ValidationRule, parse, safeParse };