@morpho-dev/router 0.2.1 → 0.4.0

package/dist/index.browser.d.ts

@@ -8,15 +8,15 @@ import { Client } from "openapi-fetch";
 
 //#region rolldown:runtime
 declare namespace BookResponse_d_exports {
-  export { BookLevelResponse, from$13 as from };
+  export { BookLevelResponse, from$14 as from };
 }
 type BookLevelResponse = {
-  rate: string;
+  price: string;
   assets: string;
   count: number;
 };
-declare function from$13(level: {
-  rate: bigint;
+declare function from$14(level: {
+  price: bigint;
   assets: bigint;
   count: number;
 }): BookLevelResponse;
@@ -29,10 +29,11 @@ declare const CollectorHealth: z.ZodObject<{
   updated_at: z.ZodNullable<z.ZodString>;
   lag: z.ZodNullable<z.ZodNumber>;
   status: z.ZodEnum<{
+    unknown: "unknown";
     live: "live";
     lagging: "lagging";
-    unknown: "unknown";
   }>;
+  initialized: z.ZodBoolean;
 }, z.core.$strip>;
 declare const CollectorsHealthResponse: z.ZodArray<z.ZodObject<{
   name: z.ZodString;
@@ -41,28 +42,37 @@ declare const CollectorsHealthResponse: z.ZodArray<z.ZodObject<{
   updated_at: z.ZodNullable<z.ZodString>;
   lag: z.ZodNullable<z.ZodNumber>;
   status: z.ZodEnum<{
+    unknown: "unknown";
     live: "live";
     lagging: "lagging";
-    unknown: "unknown";
   }>;
+  initialized: z.ZodBoolean;
 }, z.core.$strip>>;
 declare const ChainHealth: z.ZodObject<{
   chain_id: z.ZodNumber;
-  local_block_number: z.ZodNumber;
+  local_block_number: z.ZodNullable<z.ZodNumber>;
   remote_block_number: z.ZodNullable<z.ZodNumber>;
-  updated_at: z.ZodString;
+  updated_at: z.ZodNullable<z.ZodString>;
+  initialized: z.ZodBoolean;
 }, z.core.$strip>;
 declare const ChainsHealthResponse: z.ZodArray<z.ZodObject<{
   chain_id: z.ZodNumber;
-  local_block_number: z.ZodNumber;
+  local_block_number: z.ZodNullable<z.ZodNumber>;
   remote_block_number: z.ZodNullable<z.ZodNumber>;
-  updated_at: z.ZodString;
+  updated_at: z.ZodNullable<z.ZodString>;
+  initialized: z.ZodBoolean;
 }, z.core.$strip>>;
 declare const RouterStatusResponse: z.ZodObject<{
   status: z.ZodEnum<{
     live: "live";
     syncing: "syncing";
   }>;
+  initialized: z.ZodBoolean;
+  missing_chains: z.ZodArray<z.ZodNumber>;
+  missing_collectors: z.ZodArray<z.ZodObject<{
+    chain_id: z.ZodNumber;
+    name: z.ZodString;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type CollectorsHealthResponse = z.infer<typeof CollectorsHealthResponse>;
 type ChainsHealthResponse = z.infer<typeof ChainsHealthResponse>;
@@ -330,7 +340,7 @@ declare const Morpho: readonly [{
   readonly stateMutability: "view";
 }];
 declare namespace Callback_d_exports {
-  export { CallbackType, decode$3 as decode, decodeBuyVaultV1Callback, decodeSellERC20Callback, encode$3 as encode, encodeBuyVaultV1Callback, encodeSellERC20Callback, isEmptyCallback };
+  export { BuyVaultV1CallbackData, CallbackType, SellERC20CallbackData, decode$2 as decode, decodeBuyVaultV1Callback, decodeSellERC20Callback, encode$2 as encode, encodeBuyVaultV1Callback, encodeSellERC20Callback, isEmptyCallback };
 }
 declare enum CallbackType {
   BuyWithEmptyCallback = "buy_with_empty_callback",
@@ -338,11 +348,20 @@ declare enum CallbackType {
   SellERC20Callback = "sell_erc20_callback",
 }
 declare const isEmptyCallback: (offer: Offer) => boolean;
-declare function decode$3(type: CallbackType, data: Hex): {
+declare function decode$2(type: CallbackType, data: Hex): {
   contract: Address;
   amount: bigint;
 }[];
-declare function encode$3(type: CallbackType, data: any): Hex;
+type BuyVaultV1CallbackData = {
+  vaults: Address[];
+  amounts: bigint[];
+};
+type SellERC20CallbackData = {
+  collaterals: Address[];
+  amounts: bigint[];
+};
+declare function encode$2(type: CallbackType.BuyVaultV1Callback, data: BuyVaultV1CallbackData): Hex;
+declare function encode$2(type: CallbackType.SellERC20Callback, data: SellERC20CallbackData): Hex;
 declare function decodeBuyVaultV1Callback(data: Hex): Array<{
   contract: Address;
   amount: bigint;
@@ -394,7 +413,7 @@ declare class ReorgError extends BaseError {
 declare namespace Chain_d_exports {
   export { Chain$1 as Chain, ChainId, Id, InvalidBatchSizeError, InvalidBlockRangeError, InvalidBlockWindowError, MissingBlockNumberError, Name, chainIds, chainNames, chains$1 as chains, getChain, getWhitelistedChains, streamLogs };
 }
-type Chain$1 = Compute<Chain<ChainFormatters, {
+type Chain$1 = Compute<Omit<Chain<ChainFormatters, {
   morpho: ChainContract;
   morphoBlue: ChainContract;
   mempool: ChainContract;
@@ -404,9 +423,20 @@ type Chain$1 = Compute<Chain<ChainFormatters, {
       v1_1: ChainContract;
     };
   };
-}> & {
+}>, "custom"> & {
   id: Id;
   name: Name;
+  custom: {
+    morpho: ChainContract;
+    morphoBlue: ChainContract;
+    mempool: ChainContract;
+    vaults: {
+      factories: {
+        v1_0: ChainContract;
+        v1_1: ChainContract;
+      };
+    };
+  };
 }>;
 declare const ChainId: {
   readonly ETHEREUM: 1;
@@ -452,6 +482,14 @@ declare class MissingBlockNumberError extends BaseError {
   name: string;
   constructor();
 }
+declare namespace ChainRegistry_d_exports {
+  export { ChainRegistry, create$1 as create };
+}
+type ChainRegistry = {
+  getById: (chainId: Id) => Chain$1 | undefined;
+  list: () => Chain$1[];
+};
+declare function create$1(chains: Chain$1[]): ChainRegistry;
 //#endregion
 //#region src/core/types.d.ts
 /** Combines members of an intersection into a readable type. */
@@ -461,7 +499,7 @@ type Brand<in out ID extends string | symbol> = {
   readonly [BrandTypeId]: { readonly [id in ID]: ID };
 };
 declare namespace LLTV_d_exports {
-  export { InvalidLLTVError, InvalidOptionError$1 as InvalidOptionError, LLTV, LLTVSchema, Options, from$12 as from };
+  export { InvalidLLTVError, InvalidOptionError$1 as InvalidOptionError, LLTV, LLTVSchema, Options, from$13 as from };
 }
 type LLTV = bigint & Brand<"LLTV">;
 declare const Options: readonly [0.385, 0.5, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965, 0.98];
@@ -471,8 +509,8 @@ type Options = (typeof Options)[number];
  * @param lltv - The LLTV option or the scaled LLTV.
  * @returns The LLTV.
  */
-declare function from$12(lltv: Options | bigint): LLTV;
-declare namespace from$12 {
+declare function from$13(lltv: Options | bigint): LLTV;
+declare namespace from$13 {
   type ErrorType = InvalidOptionError$1 | InvalidLLTVError;
 }
 declare class InvalidOptionError$1 extends BaseError {
@@ -485,7 +523,7 @@ declare class InvalidLLTVError extends BaseError {
 }
 declare const LLTVSchema: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
 declare namespace Collateral_d_exports {
-  export { Collateral, CollateralSchema, CollateralsSchema, from$11 as from, random$3 as random };
+  export { Collateral, CollateralSchema, CollateralsSchema, from$12 as from, random$3 as random };
 }
 type Collateral = {
   /** Asset being used as collateral. */
@@ -505,8 +543,8 @@ declare const CollateralsSchema: z$1.ZodArray<z$1.ZodObject<{
   oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
   lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
 }, z$1.core.$strip>>;
-declare const from$11: (parameters: from$11.Parameters) => from$11.ReturnType;
-declare namespace from$11 {
+declare const from$12: (parameters: from$12.Parameters) => from$12.ReturnType;
+declare namespace from$12 {
   type Parameters = {
     asset: Address;
     lltv: Options | bigint;
@@ -615,35 +653,127 @@ declare class DenominatorIsZeroError extends BaseError {
   readonly name = "ERC4626.DenominatorIsZeroError";
   constructor();
 }
-declare namespace Format_d_exports {
-  export { Snake, fromSnakeCase$3 as fromSnakeCase, stringifyBigint, toSnakeCase$1 as toSnakeCase };
+declare namespace Liquidity_d_exports {
+  export { LiquidityLink, LiquidityPool, OfferLiquidityPool, calculateMaxDebt, generateAllowancePoolId, generateBalancePoolId, generateBuyVaultCallbackPoolId, generateDebtPoolId, generateMarketLiquidityPoolId, generateObligationCollateralPoolId, generateSellERC20CallbackPoolId, generateUserVaultPositionPoolId, generateVaultPositionPoolId };
 }
-/** The snake case representation of a type with bigint values stringified. */
-type Snake<T> = DeepMutable<SnakeKeys<StringifiedBigint<T>>>;
-/** Make arrays/tuples and object props mutable, deeply. */
-type DeepMutable<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepMutable<R[K]> } : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } : T;
-/** Stringifies bigint values to strings and preserves branded primitives. */
-type StringifiedBigint<T> = [T] extends [bigint] ? string : [T] extends [`0x${string}`] ? string : T extends number ? T : T extends string ? T : T extends boolean ? T : T extends symbol ? T : T extends null | undefined ? T : T extends readonly (infer U)[] ? readonly StringifiedBigint<U>[] : T extends object ? { [K in keyof T]: StringifiedBigint<T[K]> } : T;
-/** 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.
+ * Represents a liquidity pool with a unique ID and amount.
  */
-declare function toSnakeCase$1<T>(obj: T): Snake<T>;
+type LiquidityPool = {
+  id: string;
+  amount: bigint;
+};
 /**
- * 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.
+ * Represents a hierarchical relationship between two liquidity pools.
  */
-declare function fromSnakeCase$3<T>(obj: Snake<T>): T;
-declare function stringifyBigint<T>(value: T): StringifiedBigint<T>;
+type LiquidityLink = {
+  parentPoolId: string;
+  childPoolId: string;
+  priority: number;
+};
+/**
+ * Represents the connection between an offer and its liquidity pools.
+ */
+type OfferLiquidityPool = {
+  offerHash: Hex;
+  poolId: string;
+  /**
+   * The available capacity/liquidity from this pool for this offer.
+   * Meaning varies by pool type:
+   * - BuyWithEmptyCallback: Matches allowance amount from pool bellow
+   * - SellERC20Callback: Sell Callback/Predeposited -> Maximum debt capacity calculated from collateral (collateralAmount * oraclePrice * lltv)
+   * - SellERC20Callback: Existing debt as negative value (reduces available capacity)
+   */
+  amount: bigint;
+};
+/**
+ * Calculate maximum debt capacity from collateral amount.
+ * @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: Id;
+  token: Address;
+}): string;
+/**
+ * Generate pool ID for allowance pools.
+ */
+declare function generateAllowancePoolId(parameters: {
+  user: Address;
+  chainId: Id;
+  token: Address;
+}): string;
+/**
+ * Generate pool ID for sell ERC20 callback pools.
+ * Each offer has its own callback pool to prevent liquidity conflicts.
+ */
+declare function generateSellERC20CallbackPoolId(parameters: {
+  user: Address;
+  chainId: Id;
+  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: Id;
+  obligationId: Hex;
+  token: Address;
+}): string;
+/**
+ * Generate pool ID for buy vault callback pools.
+ */
+declare function generateBuyVaultCallbackPoolId(parameters: {
+  user: Address;
+  chainId: Id;
+  vault: Address;
+  offerHash: Hex;
+}): string;
+/**
+ * Generate pool ID for debt pools.
+ */
+declare function generateDebtPoolId(parameters: {
+  user: Address;
+  chainId: Id;
+  obligationId: Hex;
+}): string;
+/**
+ * Generate pool ID for user position in a vault.
+ */
+declare function generateUserVaultPositionPoolId(parameters: {
+  user: Address;
+  chainId: Id;
+  vault: Address;
+}): string;
+/**
+ * Generate pool ID for vault position in a market.
+ */
+declare function generateVaultPositionPoolId(parameters: {
+  vault: Address;
+  chainId: Id;
+  marketId: string;
+}): string;
+/**
+ * Generate pool ID for market total liquidity.
+ */
+declare function generateMarketLiquidityPoolId(parameters: {
+  chainId: Id;
+  marketId: string;
+}): string;
 declare namespace Maturity_d_exports {
-  export { InvalidDateError, InvalidFormatError, InvalidOptionError, Maturity, MaturityOptions, MaturitySchema, MaturityType, from$10 as from };
+  export { InvalidDateError, InvalidFormatError, InvalidOptionError, Maturity, MaturityOptions, MaturitySchema, MaturityType, from$11 as from };
 }
 /**
  * Maturity is a number that represents a date in seconds.
@@ -673,8 +803,8 @@ type MaturityOptions = keyof typeof MaturityOptions;
  * @throws {InvalidDateError} If the maturity is in seconds but not a valid date.
  * @throws {InvalidOptionError} If the maturity is not a valid option.
  */
-declare function from$10(ts: from$10.Parameters): Maturity;
-declare namespace from$10 {
+declare function from$11(ts: from$11.Parameters): Maturity;
+declare namespace from$11 {
   type Parameters = number | MaturityOptions;
   type ErrorType = InvalidFormatError | InvalidDateError | InvalidOptionError;
 }
@@ -690,72 +820,47 @@ declare class InvalidOptionError extends BaseError {
   readonly name = "Maturity.InvalidOptionError";
   constructor(input: string);
 }
-declare namespace Offer_d_exports {
-  export { AccountNotSetError, InvalidOfferError, Offer, OfferConsumed, OfferHashSchema, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$2 as decode, domain, encode$2 as encode, from$9 as from, fromSnakeCase$2 as fromSnakeCase, hash, obligationId, random$2 as random, sign, signatureMsg, toSnakeCase, types };
+declare namespace Format_d_exports {
+  export { Snake, fromSnakeCase$3 as fromSnakeCase, stringifyBigint, toSnakeCase$1 as toSnakeCase };
 }
-type Offer = {
-  /** The address that made the offer. */
-  readonly offering: Address;
-  /** The amount of assets offered. */
-  readonly assets: bigint;
-  /**
-   * The amount of assets that can be taken from the offer. takeable = min(max - consumed, available)
-   * Where available is the total amount of assets retrievable from offering positions.
-   */
-  readonly takeable: bigint;
-  /** The interest rate (with 18 decimals). */
-  readonly rate: bigint;
-  /** The date at which all interests will be paid. */
-  readonly maturity: Maturity;
-  /** The date at which the offer will expire. */
-  readonly expiry: number;
-  /** The date at which the offer will start. */
-  readonly start: number;
-  /** The nonce. Used for OCO (One-Cancelled-Other) mechanism. */
-  readonly nonce: bigint;
-  /** The side of the offer. `true` for buy, `false` for sell. */
-  readonly buy: boolean;
-  /** The chain id where the liquidity for this offer is located. */
-  readonly chainId: Id;
-  /** The token that is being borrowed. */
-  readonly loanToken: Address;
-  /** The exact set of collaterals required to borrow the loan token. */
-  readonly collaterals: readonly Collateral[];
-  /** The optional callback data to retrieve the maker funds. */
-  readonly callback: {
-    readonly address: Address;
-    readonly data: Hex;
-    readonly gasLimit: bigint;
-  };
-  /** The amount of assets consumed from the offer. */
-  consumed: bigint;
-  /** The hash of the offer. */
-  readonly hash: Hex;
-  /** The block number at which the offer was created. */
-  readonly blockNumber: number;
-  /** The signature of the offer. */
-  signature?: Hex;
-};
-declare enum Status {
-  VALID = "VALID",
-  SIMULATION_ERROR = "SIMULATION_ERROR",
+/** The snake case representation of a type with bigint values stringified. */
+type Snake<T> = DeepMutable<SnakeKeys<StringifiedBigint<T>>>;
+/** Make arrays/tuples and object props mutable, deeply. */
+type DeepMutable<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepMutable<R[K]> } : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } : T;
+/** Stringifies bigint values to strings and preserves branded primitives. */
+type StringifiedBigint<T> = [T] extends [bigint] ? string : [T] extends [`0x${string}`] ? string : T extends number ? T : T extends string ? T : T extends boolean ? T : T extends symbol ? T : T extends null | undefined ? T : T extends readonly (infer U)[] ? readonly StringifiedBigint<U>[] : T extends object ? { [K in keyof T]: StringifiedBigint<T[K]> } : T;
+/** 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$3<T>(obj: Snake<T>): T;
+declare function stringifyBigint<T>(value: T): StringifiedBigint<T>;
+declare namespace Obligation_d_exports {
+  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation, ObligationSchema, from$10 as from, fromSnakeCase$2 as fromSnakeCase, id, random$2 as random };
 }
-type Validation = {
-  offerHash: Hex;
-  status: Status;
+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 OfferHashSchema: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-declare const OfferSchema: (parameters?: {
-  omitHash?: boolean;
-}) => z$1.ZodObject<{
-  offering: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-  assets: z$1.ZodBigInt;
-  rate: z$1.ZodBigInt;
-  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
-  expiry: z$1.ZodNumber;
-  start: z$1.ZodNumber;
-  nonce: z$1.ZodBigInt;
-  buy: z$1.ZodBoolean;
+declare const ObligationSchema: z$1.ZodObject<{
   chainId: z$1.ZodNumber;
   loanToken: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
   collaterals: z$1.ZodArray<z$1.ZodObject<{
@@ -763,43 +868,259 @@ declare const OfferSchema: (parameters?: {
     oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
     lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
   }, z$1.core.$strip>>;
-  callback: z$1.ZodObject<{
-    address: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-    data: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-    gasLimit: z$1.ZodBigInt;
-  }, z$1.core.$strip>;
-  signature: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
-  consumed: z$1.ZodOptional<z$1.ZodBigInt>;
-  takeable: z$1.ZodOptional<z$1.ZodBigInt>;
-  blockNumber: z$1.ZodOptional<z$1.ZodNumber>;
+  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
 }, z$1.core.$strip>;
 /**
- * Creates an offer from a plain object.
- * @throws {InvalidOfferError} If the offer is invalid.
- * @param input - The offer to create.
- * @returns The created offer with its hash.
- */
-declare function from$9(input: Compute<Omit<Offer, "chainId" | "hash"> & {
-  chainId: number;
-}>): Offer;
-declare namespace from$9 {
-  type ErrorType = InvalidOfferError;
-}
-/**
- * Creates an offer from a snake case object.
- * @throws {InvalidOfferError} If the offer is invalid.
- * @param input - The offer to create.
- * @returns The created offer with its hash.
- */
-declare function fromSnakeCase$2(input: Snake<Omit<Offer, "chainId" | "hash"> & {
-  chainId: number;
-}>): Offer;
-/**
+ * 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: 1,
+ *   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 from$10(parameters: from$10.Parameters): from$10.ReturnType;
+declare namespace from$10 {
+  type Parameters = {
+    /** The chain id where the liquidity for this obligation is located. */
+    chainId: number;
+    /** The token that is being borrowed for this obligation. */
+    loanToken: Address;
+    /** The exact set of collaterals required to borrow the loan token. Must be sorted alphabetically by address. */
+    collaterals: from$12.Parameters[] | readonly from$12.Parameters[];
+    /** The maturity of the obligation. */
+    maturity: from$11.Parameters;
+  };
+  type ReturnType = Obligation;
+  type ErrorType = InvalidObligationError;
+}
+/**
+ * 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 fromSnakeCase$2(input: fromSnakeCase$2.Parameters): fromSnakeCase$2.ReturnType;
+declare namespace fromSnakeCase$2 {
+  type Parameters = Snake<Omit<Obligation, "chainId"> & {
+    chainId: number;
+  }>;
+  type ReturnType = Obligation;
+  type ErrorType = InvalidObligationError;
+}
+/**
+ * Calculates the obligation id based on the smart contract's Obligation struct.
+ * 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 parameters - {@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(parameters: id.Parameters): id.ReturnType;
+declare namespace id {
+  type Parameters = {
+    chainId: number;
+    loanToken: Address;
+    collaterals: {
+      asset: Address;
+      lltv: bigint;
+      oracle: Address;
+    }[];
+    maturity: number;
+  };
+  type ReturnType = Hex;
+  type ErrorType = CollateralsAreNotSortedError;
+}
+/**
+ * Generates a random obligation.
+ * @returns A randomly generated obligation. {@link random.ReturnType}
+ *
+ * @example
+ * ```ts
+ * const obligation = Obligation.random();
+ * ```
+ */
+declare function random$2(): random$2.ReturnType;
+declare namespace random$2 {
+  type ReturnType = Obligation;
+}
+declare class InvalidObligationError extends BaseError<z$1.ZodError | Error> {
+  readonly name = "Obligation.InvalidObligationError";
+  constructor(error: z$1.ZodError | Error);
+}
+declare class CollateralsAreNotSortedError extends BaseError {
+  readonly name = "Obligation.CollateralsAreNotSortedError";
+  constructor();
+}
+declare namespace Offer_d_exports {
+  export { AccountNotSetError, InvalidOfferError, Offer, OfferConsumed, OfferInput, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$1 as decode, domain, encode$1 as encode, from$9 as from, fromSnakeCase$1 as fromSnakeCase, hash, obligationId, random$1 as random, serialize, sign, signatureMsg, toSnakeCase, types };
+}
+type Offer = {
+  /** The address that made the offer. */
+  readonly maker: Address;
+  /** The amount of assets offered. Mutually exclusive with obligationUnits and obligationShares. */
+  readonly assets: bigint;
+  /** The max debt units to trade. Mutually exclusive with assets and obligationShares. */
+  readonly obligationUnits: bigint;
+  /** The max lending shares to trade. Mutually exclusive with assets and obligationUnits. */
+  readonly obligationShares: bigint;
+  /** The price (18 decimals). */
+  readonly price: 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 group. Used for OCO (One-Cancelled-Other) mechanism. */
+  readonly group: Hex;
+  /** The session. Used for session-based offer management. */
+  readonly session: Hex;
+  /** The side of the offer. `true` for buy, `false` for sell. */
+  readonly buy: boolean;
+  /** The chain id where the liquidity for this offer is located. */
+  readonly chainId: Id;
+  /** The token that is being borrowed. */
+  readonly loanToken: Address;
+  /** The exact set of collaterals required to borrow the loan token. */
+  readonly collaterals: readonly Collateral[];
+  /** The optional callback data to retrieve the maker funds. */
+  readonly callback: {
+    readonly address: Address;
+    readonly data: Hex;
+  };
+};
+declare enum Status {
+  VALID = "VALID",
+  SIMULATION_ERROR = "SIMULATION_ERROR",
+}
+type Validation = {
+  offerHash: Hex;
+  status: Status;
+};
+declare const OfferSchema: () => z$1.ZodObject<{
+  maker: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  assets: z$1.ZodBigInt;
+  obligationUnits: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBigInt>>;
+  obligationShares: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBigInt>>;
+  price: z$1.ZodBigInt;
+  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
+  expiry: z$1.ZodNumber;
+  start: z$1.ZodNumber;
+  group: z$1.ZodPipe<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBigInt]>, z$1.ZodTransform<`0x${string}`, string | number | bigint>>;
+  session: z$1.ZodPipe<z$1.ZodDefault<z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber, z$1.ZodBigInt]>>>, z$1.ZodTransform<`0x${string}`, string | number | bigint>>;
+  buy: z$1.ZodBoolean;
+  chainId: z$1.ZodNumber;
+  loanToken: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  collaterals: z$1.ZodArray<z$1.ZodObject<{
+    asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
+  }, z$1.core.$strip>>;
+  callback: z$1.ZodObject<{
+    address: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    data: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+  }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+/**
+ * Input type for creating offers. Accepts flexible group types that will be coerced to Hex.
+ *
+ * The `group` field accepts multiple input formats:
+ * - **Hex string** (`0x...`): Padded to 32 bytes if needed
+ * - **Numeric string**: Converted to hex (e.g., `"123"` -> `"0x...7b"`)
+ * - **Number**: Non-negative safe integer, converted to hex
+ * - **BigInt**: Non-negative, must fit in bytes32
+ *
+ * All values validated to be non-negative and within bytes32 range.
+ */
+type OfferInput = Compute<Omit<Offer, "chainId" | "group" | "session" | "obligationUnits" | "obligationShares"> & {
+  chainId: number;
+  group: Hex | bigint | number | string;
+  /** Optional: defaults to zero bytes32. */
+  session?: Hex | bigint | number | string;
+  /** Optional: defaults to 0n. Mutually exclusive with assets and obligationShares. */
+  obligationUnits?: bigint;
+  /** Optional: defaults to 0n. Mutually exclusive with assets and obligationUnits. */
+  obligationShares?: bigint;
+}>;
+/**
+ * Creates an offer from a plain object.
+ * @throws {InvalidOfferError} If the offer is invalid.
+ * @param input - The offer to create.
+ * @returns The created offer.
+ */
+declare function from$9(input: OfferInput): Offer;
+declare namespace from$9 {
+  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.
+ */
+declare function fromSnakeCase$1(input: Snake<Omit<Offer, "chainId" | "session"> & {
+  chainId: number;
+  session: string;
+}>): Offer;
+/**
  * Converts an offer to a snake case object.
  * @param offer - The offer to convert.
  * @returns The converted offer.
  */
 declare function toSnakeCase(offer: Offer): Snake<Offer>;
+/**
+ * Serializes an offer for merkle tree encoding.
+ * Converts BigInt fields to strings for JSON compatibility.
+ *
+ * @param offer - Offer to serialize
+ * @returns JSON-serializable offer object
+ */
+declare const serialize: (offer: Offer) => {
+  maker: `0x${string}`;
+  assets: string;
+  obligationUnits: string;
+  obligationShares: string;
+  price: string;
+  maturity: number;
+  expiry: number;
+  start: number;
+  group: `0x${string}`;
+  session: `0x${string}`;
+  buy: boolean;
+  chainId: Id;
+  loanToken: `0x${string}`;
+  collaterals: {
+    asset: `0x${string}`;
+    oracle: `0x${string}`;
+    lltv: string;
+  }[];
+  callback: {
+    address: `0x${string}`;
+    data: `0x${string}`;
+  };
+  hash: `0x${string}`;
+};
 type RandomConfig = {
   chains?: Chain$1[];
   loanTokens?: Address[];
@@ -807,22 +1128,20 @@ type RandomConfig = {
   assetsDecimals?: Record<Address, number>;
   buy?: boolean;
   assets?: bigint;
-  consumed?: bigint;
-  takeable?: bigint;
-  offering?: Address;
+  obligationUnits?: bigint;
+  obligationShares?: bigint;
+  maker?: Address;
   maturity?: Maturity;
   start?: number;
   expiry?: number;
-  nonce?: bigint;
-  rate?: bigint;
+  group?: Hex | bigint | number | string;
+  session?: Hex | bigint | number | string;
+  price?: bigint;
   callback?: {
     address: Address;
     data: Hex;
-    gasLimit: bigint;
   };
   collaterals?: readonly Collateral[];
-  signature?: Hex;
-  blockNumber?: number;
 };
 /**
  * Generates a random Offer.
@@ -830,7 +1149,7 @@ type RandomConfig = {
  * @warning The generated Offer should not be used for production usage.
  * @returns {Offer} A randomly generated Offer object.
  */
-declare function random$2(config?: RandomConfig): Offer;
+declare function random$1(config?: RandomConfig): Offer;
 /**
  * Creates an EIP-712 domain object.
  * @param chainId - The chain ID.
@@ -854,13 +1173,19 @@ declare const types: {
     readonly type: "address";
   }];
   readonly Offer: readonly [{
-    readonly name: "offering";
+    readonly name: "maker";
     readonly type: "address";
   }, {
     readonly name: "assets";
     readonly type: "uint256";
   }, {
-    readonly name: "rate";
+    readonly name: "obligationUnits";
+    readonly type: "uint256";
+  }, {
+    readonly name: "obligationShares";
+    readonly type: "uint256";
+  }, {
+    readonly name: "price";
     readonly type: "uint256";
   }, {
     readonly name: "maturity";
@@ -869,8 +1194,11 @@ declare const types: {
     readonly name: "expiry";
     readonly type: "uint256";
   }, {
-    readonly name: "nonce";
-    readonly type: "uint256";
+    readonly name: "group";
+    readonly type: "bytes32";
+  }, {
+    readonly name: "session";
+    readonly type: "bytes32";
   }, {
     readonly name: "buy";
     readonly type: "bool";
@@ -898,320 +1226,82 @@ declare const types: {
     readonly name: "address";
     readonly type: "address";
   }, {
-    readonly name: "data";
-    readonly type: "bytes";
-  }, {
-    readonly name: "gasLimit";
-    readonly type: "uint256";
-  }];
-};
-/**
- * Signs an array of offers.
- * @throws {Error} If the wallet account is not set.
- * @param offers - The offers to sign.
- * @param wallet - The wallet to sign the offers with.
- * @returns The signed offers.
- */
-declare function sign(offers: Offer[], wallet: WalletClient): Promise<Hex>;
-declare function signatureMsg(offers: Offer[]): 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$2(offer: Offer): `0x${string}`;
-declare function decode$2(data: Hex, blockNumber: number | bigint): Offer;
-type OfferConsumed = {
-  id: string;
-  chainId: Id;
-  offering: Address;
-  nonce: bigint;
-  amount: bigint;
-  blockNumber: number;
-};
-/**
- * ABI for the Consumed event emitted by the Obligation contract.
- */
-declare const consumedEvent: {
-  readonly type: "event";
-  readonly name: "Consumed";
-  readonly inputs: readonly [{
-    readonly name: "user";
-    readonly type: "address";
-    readonly indexed: true;
-    readonly internalType: "address";
-  }, {
-    readonly name: "nonce";
-    readonly type: "uint256";
-    readonly indexed: true;
-    readonly internalType: "uint256";
-  }, {
-    readonly name: "amount";
-    readonly type: "uint256";
-    readonly indexed: false;
-    readonly internalType: "uint256";
-  }];
-  readonly anonymous: false;
-};
-declare class InvalidOfferError extends BaseError<z$1.ZodError | Error> {
-  readonly name = "Offer.InvalidOfferError";
-  constructor(error: z$1.ZodError | Error);
-  /**
-   * Formats ZodError issues into a human-readable string with line breaks.
-   * @example
-   * "- 'assets': too small, expected >= 0
-   *  - 'start': must be before expiry"
-   */
-  static formatDetails(error: z$1.ZodError | Error): string;
-  /**
-   * Returns the formatted human-readable message.
-   */
-  get formattedMessage(): string;
-}
-declare class AccountNotSetError extends BaseError {
-  readonly name = "Offer.AccountNotSetError";
-  constructor();
-}
-declare namespace Liquidity_d_exports {
-  export { LiquidityLink, LiquidityPool, OfferLiquidityPool, calculateMaxDebt, generateAllowancePoolId, generateBalancePoolId, generateBuyVaultCallbackPoolId, generateDebtPoolId, generateMarketLiquidityPoolId, generateObligationCollateralPoolId, generateSellERC20CallbackPoolId, generateUserVaultPositionPoolId, generateVaultPositionPoolId };
-}
-/**
- * Represents a liquidity pool with a unique ID and amount.
- */
-type LiquidityPool = {
-  id: string;
-  amount: bigint;
-};
-/**
- * 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;
-};
-/**
- * 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: Id;
-  token: Address;
-}): string;
-/**
- * Generate pool ID for allowance pools.
- */
-declare function generateAllowancePoolId(parameters: {
-  user: Address;
-  chainId: Id;
-  token: Address;
-}): string;
-/**
- * Generate pool ID for sell ERC20 callback pools.
- * Each offer has its own callback pool to prevent liquidity conflicts.
- */
-declare function generateSellERC20CallbackPoolId(parameters: {
-  user: Address;
-  chainId: Id;
-  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: Id;
-  obligationId: Hex;
-  token: Address;
-}): string;
-/**
- * Generate pool ID for buy vault callback pools.
- */
-declare function generateBuyVaultCallbackPoolId(parameters: {
-  user: Address;
-  chainId: Id;
-  vault: Address;
-  offerHash: Hex;
-}): string;
-/**
- * Generate pool ID for debt pools.
- */
-declare function generateDebtPoolId(parameters: {
-  user: Address;
-  chainId: Id;
-  obligationId: Hex;
-}): string;
-/**
- * Generate pool ID for user position in a vault.
- */
-declare function generateUserVaultPositionPoolId(parameters: {
-  user: Address;
-  chainId: Id;
-  vault: Address;
-}): string;
-/**
- * Generate pool ID for vault position in a market.
- */
-declare function generateVaultPositionPoolId(parameters: {
-  vault: Address;
-  chainId: Id;
-  marketId: string;
-}): string;
-/**
- * Generate pool ID for market total liquidity.
- */
-declare function generateMarketLiquidityPoolId(parameters: {
-  chainId: Id;
-  marketId: string;
-}): string;
-declare namespace Obligation_d_exports {
-  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation, ObligationSchema, from$8 as from, fromSnakeCase$1 as fromSnakeCase, id, random$1 as random };
-}
-type Obligation = {
-  /** The chain id where the liquidity for this obligation is located. */
-  chainId: Id;
-  /** The token that is being borrowed for this obligation. */
-  loanToken: Address;
-  /** The exact set of collaterals required to borrow the loan token. */
-  collaterals: Collateral[];
-  /** The maturity of the obligation. */
-  maturity: Maturity;
-};
-declare const ObligationSchema: z$1.ZodObject<{
-  chainId: z$1.ZodNumber;
-  loanToken: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-  collaterals: z$1.ZodArray<z$1.ZodObject<{
-    asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-    oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-    lltv: z$1.ZodPipe<z$1.ZodBigInt, z$1.ZodTransform<LLTV, bigint>>;
-  }, z$1.core.$strip>>;
-  maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
-}, z$1.core.$strip>;
-/**
- * Creates an obligation from the given parameters.
- * @constructor
- * @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: 1,
- *   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 from$8(parameters: from$8.Parameters): from$8.ReturnType;
-declare namespace from$8 {
-  type Parameters = {
-    /** The chain id where the liquidity for this obligation is located. */
-    chainId: number;
-    /** The token that is being borrowed for this obligation. */
-    loanToken: Address;
-    /** The exact set of collaterals required to borrow the loan token. Must be sorted alphabetically by address. */
-    collaterals: from$11.Parameters[] | readonly from$11.Parameters[];
-    /** The maturity of the obligation. */
-    maturity: from$10.Parameters;
-  };
-  type ReturnType = Obligation;
-  type ErrorType = InvalidObligationError;
-}
+    readonly name: "data";
+    readonly type: "bytes";
+  }];
+};
 /**
- * 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}
+ * Signs an array of offers.
+ * @throws {Error} If the wallet account is not set.
+ * @param offers - The offers to sign.
+ * @param wallet - The wallet to sign the offers with.
+ * @returns The signed offers.
  */
-declare function fromSnakeCase$1(input: fromSnakeCase$1.Parameters): fromSnakeCase$1.ReturnType;
-declare namespace fromSnakeCase$1 {
-  type Parameters = Snake<Omit<Obligation, "chainId"> & {
-    chainId: number;
-  }>;
-  type ReturnType = Obligation;
-  type ErrorType = InvalidObligationError;
-}
+declare function sign(offers: Offer[], wallet: WalletClient): Promise<Hex>;
+declare function signatureMsg(offers: Offer[]): Hex;
+declare function hash(offer: Offer): Hex;
 /**
- * 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
- * ```
+ * 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 id(obligation: id.Parameters): id.ReturnType;
-declare namespace id {
-  type Parameters = Obligation;
-  type ReturnType = Hex;
-  type ErrorType = CollateralsAreNotSortedError;
-}
+declare function obligationId(offer: Offer): Hex;
+declare function encode$1(offer: Offer): `0x${string}`;
+declare function decode$1(data: Hex): Offer;
+type OfferConsumed = {
+  id: string;
+  chainId: Id;
+  maker: Address;
+  group: Hex;
+  amount: bigint;
+  blockNumber: number;
+};
 /**
- * Generates a random obligation.
- * @returns A randomly generated obligation. {@link random.ReturnType}
- *
- * @example
- * ```ts
- * const obligation = Obligation.random();
- * ```
+ * ABI for the Consume event emitted by the Obligation contract.
  */
-declare function random$1(): random$1.ReturnType;
-declare namespace random$1 {
-  type ReturnType = Obligation;
-}
-declare class InvalidObligationError extends BaseError<z$1.ZodError | Error> {
-  readonly name = "Obligation.InvalidObligationError";
+declare const consumedEvent: {
+  readonly type: "event";
+  readonly name: "Consume";
+  readonly inputs: readonly [{
+    readonly name: "user";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "group";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "amount";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }];
+  readonly anonymous: false;
+};
+declare class InvalidOfferError extends BaseError<z$1.ZodError | Error> {
+  readonly name = "Offer.InvalidOfferError";
   constructor(error: z$1.ZodError | Error);
+  /**
+   * Formats ZodError issues into a human-readable string with line breaks.
+   * @example
+   * "- 'assets': too small, expected >= 0
+   *  - 'start': must be before expiry"
+   */
+  static formatDetails(error: z$1.ZodError | Error): string;
+  /**
+   * Returns the formatted human-readable message.
+   */
+  get formattedMessage(): string;
 }
-declare class CollateralsAreNotSortedError extends BaseError {
-  readonly name = "Obligation.CollateralsAreNotSortedError";
+declare class AccountNotSetError extends BaseError {
+  readonly name = "Offer.AccountNotSetError";
   constructor();
 }
 declare namespace Oracle_d_exports {
-  export { Conversion, Oracle, from$7 as from };
+  export { Conversion, Oracle, from$8 as from };
 }
 /**
  * An oracle contract that provides price information for assets.
@@ -1231,8 +1321,8 @@ type Oracle = {
  * @param data - The data to create the oracle from.
  * @returns The created oracle.
  */
-declare function from$7(data: from$7.Parameters): from$7.ReturnType;
-declare namespace from$7 {
+declare function from$8(data: from$8.Parameters): from$8.ReturnType;
+declare namespace from$8 {
   type Parameters = {
     chainId: Id;
     address: Address;
@@ -1273,7 +1363,7 @@ declare namespace Conversion {
   }): bigint;
 }
 declare namespace Position_d_exports {
-  export { Position, Type, from$6 as from };
+  export { Position, Type, from$7 as from };
 }
 type Position = {
   /** The chain id. */
@@ -1307,8 +1397,8 @@ declare enum Type {
  * @param parameters - {@link from.Parameters}
  * @returns The created Position. {@link from.ReturnType}
  */
-declare function from$6(parameters: from$6.Parameters): from$6.ReturnType;
-declare namespace from$6 {
+declare function from$7(parameters: from$7.Parameters): from$7.ReturnType;
+declare namespace from$7 {
   type Parameters = {
     chainId: Id;
     contract: Address;
@@ -1321,27 +1411,27 @@ declare namespace from$6 {
   type ReturnType = Position;
 }
 declare namespace Quote_d_exports {
-  export { InvalidQuoteError, Quote, QuoteSchema, from$5 as from, fromSnakeCase, random };
+  export { InvalidQuoteError, Quote, QuoteSchema, from$6 as from, fromSnakeCase, random };
 }
 type Quote = {
   /** The obligation id. */
   obligationId: Hex;
   ask: {
-    /** The highest interest rate the seller will accept to pay for the obligation. (18 decimals). */
-    rate: bigint;
+    /** The ask price for the obligation. (18 decimals). */
+    price: bigint;
   };
   bid: {
-    /** The lowest interest rate a buyer is willing to be paid for the obligation. (18 decimals). */
-    rate: bigint;
+    /** The bid price for the obligation. (18 decimals). */
+    price: bigint;
   };
 };
 declare const QuoteSchema: z$1.ZodObject<{
   obligationId: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
   ask: z$1.ZodObject<{
-    rate: z$1.ZodBigInt;
+    price: z$1.ZodBigInt;
   }, z$1.core.$strip>;
   bid: z$1.ZodObject<{
-    rate: z$1.ZodBigInt;
+    price: z$1.ZodBigInt;
   }, z$1.core.$strip>;
 }, z$1.core.$strip>;
 /**
@@ -1353,11 +1443,11 @@ declare const QuoteSchema: z$1.ZodObject<{
  *
  * @example
  * ```ts
- * const quote = Quote.from({ obligationId: "0x123", ask: { assets: 100n, rate: 100n }, bid: { assets: 100n, rate: 100n } });
+ * const quote = Quote.from({ obligationId: "0x123", ask: { price: 100n }, bid: { price: 100n } });
  * ```
  */
-declare function from$5(parameters: from$5.Parameters): from$5.ReturnType;
-declare namespace from$5 {
+declare function from$6(parameters: from$6.Parameters): from$6.ReturnType;
+declare namespace from$6 {
   type Parameters = Quote;
   type ReturnType = Quote;
   type ErrorType = InvalidQuoteError;
@@ -1372,7 +1462,7 @@ declare function fromSnakeCase(snake: fromSnakeCase.Parameters): fromSnakeCase.R
 declare namespace fromSnakeCase {
   type Parameters = Snake<Quote>;
   type ReturnType = Quote;
-  type ErrorType = from$5.ErrorType;
+  type ErrorType = from$6.ErrorType;
 }
 /**
  * Generates a random quote.
@@ -1387,14 +1477,14 @@ declare function random(): random.ReturnType;
 declare namespace random {
   type Parameters = never;
   type ReturnType = Quote;
-  type ErrorType = from$5.ErrorType;
+  type ErrorType = from$6.ErrorType;
 }
 declare class InvalidQuoteError extends BaseError<z$1.ZodError | Error> {
   readonly name = "Quote.InvalidQuoteError";
   constructor(error: z$1.ZodError | Error);
 }
 declare namespace Transfer_d_exports {
-  export { Transfer, from$4 as from };
+  export { Transfer, from$5 as from };
 }
 type Transfer = {
   id: string;
@@ -1417,8 +1507,8 @@ type Transfer = {
  * const transfer = Transfer.from({ id: "1", chainId: 1, contract: "0x123", from: "0x456", to: "0x789", value: 100n, blockNumber: 100n });
  * ```
  */
-declare function from$4(parameters: from$4.Parameters): from$4.ReturnType;
-declare namespace from$4 {
+declare function from$5(parameters: from$5.Parameters): from$5.ReturnType;
+declare namespace from$5 {
   type Parameters = {
     id: string;
     chainId: Id;
@@ -1431,46 +1521,148 @@ declare namespace from$4 {
   type ReturnType = Transfer;
 }
 declare namespace Tree_d_exports {
-  export { Tree, VERSION, decode$1 as decode, encode$1 as encode, from$3 as from };
+  export { DecodeError, EncodeError, Proof, Tree, TreeError, VERSION, decode, encode, encodeUnsigned, from$4 as from, proofs };
 }
+/**
+ * A merkle tree of offers built from offer hashes.
+ * Constructed via {@link from}. The tree root can be signed for onchain broadcast.
+ */
 type Tree = Compute<StandardMerkleTree<[Hex]> & {
+  /** The offers in the tree. */
   offers: Offer[];
+  /** The root of the tree. */
   root: Hex;
 }>;
+type Proof = {
+  /** The offer that the proof is for. */
+  offer: Offer;
+  /** The merkle proof path for the offer. */
+  path: Hex[];
+};
 declare const VERSION = 1;
 /**
  * Builds a Merkle tree from a list of offers.
  *
  * Leaves are the offer `hash` values as `bytes32` and are deterministically
- * ordered in ascending lexicographic order so that the resulting root is stable
- * regardless of the input order.
+ * ordered following the StandardMerkleTree leaf ordering so that the resulting
+ * root is stable regardless of the input order.
  *
  * @param offers - Offers to include in the tree.
  * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+ * @throws {TreeError} If tree building fails due to offer inconsistencies.
+ */
+declare const from$4: (offers: Offer[]) => Tree;
+/**
+ * Generates merkle proofs for all offers in a tree.
+ *
+ * Each proof allows independent verification that an offer is included in the tree
+ * without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+ *
+ * @param tree - The {@link Tree} to generate proofs for.
+ * @returns Array of proofs - {@link Proof}
+ */
+declare const proofs: (tree: Tree) => Proof[];
+/**
+ * Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
+ * - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+ *
+ * Validates signature authenticity and root integrity before encoding.
+ *
+ * @example
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = await Tree.encode(tree, signature);
+ * await broadcast(calldata);
+ * ```
+ *
+ * @example
+ * Manual construction (for advanced users):
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+ * const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = `${partial}${signature.slice(2)}`;
+ * ```
+ *
+ * @param tree - Merkle tree of offers
+ * @param signature - EIP-191 signature over raw root bytes
+ * @returns Hex-encoded calldata ready for onchain broadcast
+ * @throws {EncodeError} If signature verification fails or root mismatch
  */
-declare const from$3: (offers: Offer[]) => Tree;
+declare const encode: (tree: Tree, signature: Hex) => Promise<Hex>;
 /**
- * Encodes an `Tree` into a Hex string with a version byte prefix and gzipped payload.
+ * Encodes a merkle tree without a signature into hex payload for client-side signing.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
  *
- * - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
- * - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+ * Validates root integrity before encoding.
  *
- * @param tree - The offer Merkle tree to encode.
- * @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
- * @throws Error if the given `root` does not match the offers.
+ * @param tree - Merkle tree of offers
+ * @returns Hex-encoded unsigned payload
+ * @throws {EncodeError} If root mismatch
  */
-declare const encode$1: (tree: Tree) => Hex;
+declare const encodeUnsigned: (tree: Tree) => Hex;
 /**
- * Decodes a Hex string produced by {@link encode} back into an `Tree`.
+ * Decodes hex calldata into a validated merkle tree.
  *
- * - Ensures the first byte version matches {@link VERSION}.
- * - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+ * Validates signature before decompression for fail-fast rejection of invalid payloads.
+ * Returns the tree with separately validated signature and recovered signer address.
  *
- * @param encoded - Hex string in the form `0x{vv}{zip...}`.
- * @returns A validated `Tree` rebuilt from the offers.
- * @throws Error if the version is invalid or the root does not match the offers.
+ * Validation order:
+ * 1. Version check
+ * 2. Signature verification (fail-fast, before decompression)
+ * 3. Decompression (only if signature valid)
+ * 4. Root verification (computed from offers vs embedded root)
+ *
+ * @example
+ * ```typescript
+ * const { tree, signature, signer } = await Tree.decode(calldata);
+ * console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+ * ```
+ *
+ * @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+ * @returns Validated tree, signature, and recovered signer address
+ * @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+ */
+declare const decode: (encoded: Hex) => Promise<{
+  tree: Tree;
+  signature: Hex;
+  signer: Address;
+}>;
+/**
+ * Error thrown during tree building operations.
+ * Indicates structural issues with the tree (missing offers, inconsistent state).
+ */
+declare class TreeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+/**
+ * Error thrown during tree encoding.
+ * Indicates validation failures (signature, root mismatch, mixed makers).
+ */
+declare class EncodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+/**
+ * Error thrown during tree decoding.
+ * Indicates payload corruption, version mismatch, or validation failures.
  */
-declare const decode$1: (encoded: Hex) => Tree;
+declare class DecodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
 //#endregion
 //#region src/api/Schema/generated/swagger.d.ts
 /**
@@ -1488,13 +1680,13 @@ interface paths {
     };
     /**
      * Get aggregated book
-     * @description Returns aggregated book data for a given obligation and side. Offers are grouped by rate with summed takeable amounts. Book levels are sorted by rate (ascending for buy side, descending for sell side).
+     * @description Returns aggregated book data for a given obligation and side. Offers are grouped by computed price with summed takeable amounts. Book levels are sorted by price (ascending for buy side, descending for sell side).
      */
     get: {
       parameters: {
         query?: {
           /**
-           * @description Maximum number of rate levels to return.
+           * @description Maximum number of price levels to return.
            * @example 10
            */
           limit?: number;
@@ -1505,7 +1697,18 @@ interface paths {
           cursor?: string;
         };
         header?: never;
-        path?: never;
+        path: {
+          /**
+           * @description Book side (buy or sell).
+           * @example buy
+           */
+          side: "buy" | "sell";
+          /**
+           * @description Obligation id.
+           * @example 0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67
+           */
+          obligationId: string;
+        };
         cookie?: never;
       };
       requestBody?: never;
@@ -1538,6 +1741,45 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/config": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get router configuration
+     * @description Returns chain configurations including contract addresses and supported maturity timestamps.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ConfigSuccessResponse"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/offers": {
     parameters: {
       query?: never;
@@ -1547,7 +1789,7 @@ interface paths {
     };
     /**
      * List all offers
-     * @description Returns offers. Provide either `obligation_id` + `side` (order book) or `offering` (by maker).
+     * @description Returns offers. Provide either `obligation_id` + `side` (order book) or `maker` (by maker address).
      */
     get: {
       parameters: {
@@ -1566,9 +1808,9 @@ interface paths {
            * @description Maker address to filter offers by. Alternative to obligation_id + side.
            * @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401
            */
-          offering?: string;
+          maker?: string;
           /**
-           * @description Obligation id used to filter offers. Required when not using offering.
+           * @description Obligation id used to filter offers. Required when not using maker.
            * @example 0x1234567890123456789012345678901234567890123456789012345678901234
            */
           obligation_id?: string;
@@ -1626,9 +1868,35 @@ interface paths {
     get: {
       parameters: {
         query?: {
-          /** @example 10 */
+          /**
+           * @description Filter by exact maturity timestamp (unix seconds).
+           * @example 1761922800
+           */
+          maturity?: number;
+          /**
+           * @description Filter by collateral token (matches any collateral in the obligation).
+           * @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751
+           */
+          collateral_token?: string;
+          /**
+           * @description Filter by loan token address.
+           * @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078
+           */
+          loan_token?: string;
+          /**
+           * @description Filter by chain ID.
+           * @example 1
+           */
+          chain?: number;
+          /**
+           * @description Maximum number of obligations to return.
+           * @example 10
+           */
           limit?: number;
-          /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
+          /**
+           * @description Obligation id cursor for pagination.
+           * @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc
+           */
           cursor?: string;
         };
         header?: never;
@@ -1680,7 +1948,13 @@ interface paths {
       parameters: {
         query?: never;
         header?: never;
-        path?: never;
+        path: {
+          /**
+           * @description Obligation id.
+           * @example 0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67
+           */
+          obligationId: string;
+        };
         cookie?: never;
       };
       requestBody?: never;
@@ -1726,7 +2000,13 @@ interface paths {
      */
     get: {
       parameters: {
-        query?: never;
+        query?: {
+          /**
+           * @description Fail the request if initialization is incomplete.
+           * @example true
+           */
+          strict?: boolean;
+        };
         header?: never;
         path?: never;
         cookie?: never;
@@ -1765,7 +2045,13 @@ interface paths {
      */
     get: {
       parameters: {
-        query?: never;
+        query?: {
+          /**
+           * @description Fail the request if initialization is incomplete.
+           * @example true
+           */
+          strict?: boolean;
+        };
         header?: never;
         path?: never;
         cookie?: never;
@@ -1791,7 +2077,52 @@ interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/health/chains": {
+  "/v1/health/chains": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Retrieve chains health
+     * @description Returns the latest block that can be processed by collectors for each chain.
+     */
+    get: {
+      parameters: {
+        query?: {
+          /**
+           * @description Fail the request if initialization is incomplete.
+           * @example true
+           */
+          strict?: boolean;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ChainsHealthSuccessResponse"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/users/{userAddress}/positions": {
     parameters: {
       query?: never;
       header?: never;
@@ -1799,14 +2130,31 @@ interface paths {
       cookie?: never;
     };
     /**
-     * Retrieve chains health
-     * @description Returns the latest block that can be processed by collectors for each chain.
+     * Get user positions
+     * @description Returns positions for a user with reserved balance. The reserved balance is the amount locked by active offers (max lot upper - offset - consumed).
      */
     get: {
       parameters: {
-        query?: never;
+        query?: {
+          /**
+           * @description Maximum number of positions to return.
+           * @example 10
+           */
+          limit?: number;
+          /**
+           * @description Pagination cursor in base64url-encoded format.
+           * @example eyJvZmZzZXQiOjEwMH0
+           */
+          cursor?: string;
+        };
         header?: never;
-        path?: never;
+        path: {
+          /**
+           * @description User address to get positions for.
+           * @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401
+           */
+          userAddress: string;
+        };
         cookie?: never;
       };
       requestBody?: never;
@@ -1817,7 +2165,16 @@ interface paths {
             [name: string]: unknown;
           };
           content: {
-            "application/json": components["schemas"]["ChainsHealthSuccessResponse"];
+            "application/json": components["schemas"]["PositionListResponse"];
+          };
+        };
+        /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
           };
         };
       };
@@ -1841,14 +2198,16 @@ interface paths {
     put?: never;
     /**
      * Validate offers
-     * @description Validates offers against router validation rules. Returns validation status for each offer.
+     * @description Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.
      *
      *     **Available validation rules:**
      *     - **parse_error**: Returns when an offer fails to parse due to invalid format or missing required fields
+     *     - **mixed_maker**: Validates that all offers in a batch have the same maker address
+     *     - **amount_mutual_exclusivity**: Validates that at most one of (assets, obligationUnits, obligationShares) is non-zero
      *     - **chain_ids**: Validates that offer chain is one of: [109111114]
      *     - **maturity**: Validates that offer maturity is one of: [end_of_month, end_of_next_month]
      *     - **callback**: Validates callbacks: buy empty callback is allowed; sell offers must use a non-empty callback; non-empty callbacks must target one of [0x3333333333333333333333333333333333333333, 0x4444444444444444444444444444444444444444, 0x1111111111111111111111111111111111111111, 0x2222222222222222222222222222222222222222]
-     *     - **token**: Validates that offer loan token and collateral tokens are in the allowed assets list
+     *     - **token**: Validates that offer loan token and collateral tokens are in the allowed assets list for the offer chain
      */
     post: {
       parameters: {
@@ -1869,7 +2228,7 @@ interface paths {
             [name: string]: unknown;
           };
           content: {
-            "application/json": components["schemas"]["ValidateOffersListResponse"];
+            "application/json": components["schemas"]["ValidationSuccessResponse"];
           };
         };
         /** @description Bad Request */
@@ -1896,7 +2255,7 @@ interface components {
       meta: components["schemas"]["Meta"];
       /** @example eyJvZmZzZXQiOjEwMH0 */
       cursor: string | null;
-      /** @description Aggregated book levels grouped by rate. */
+      /** @description Aggregated book levels grouped by computed price. */
       data: components["schemas"]["BookLevelResponse"][];
     };
     Meta: {
@@ -1905,7 +2264,7 @@ interface components {
     };
     BookLevelResponse: {
       /** @example 2750000000000000000 */
-      rate: string;
+      price: string;
       /** @example 369216000000000000000000 */
       assets: string;
       /** @example 5 */
@@ -1933,6 +2292,56 @@ interface components {
        */
       details: Record<string, never>;
     };
+    ConfigSuccessResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example null */
+      cursor: string | null;
+      /**
+       * @description Array of chain configurations for all indexed chains.
+       * @example [
+       *       {
+       *         "chain_id": 505050505,
+       *         "contracts": {
+       *           "mempool": "0xD946246695A9259F3B33a78629026F61B3Ab40aF"
+       *         },
+       *         "maturities": {
+       *           "end_of_month": 1738335600,
+       *           "end_of_next_month": 1740754800
+       *         }
+       *       }
+       *     ]
+       */
+      data: components["schemas"]["ConfigDataResponse"][];
+    };
+    ConfigDataResponse: {
+      /** @example 505050505 */
+      chain_id: number;
+      contracts: components["schemas"]["ConfigContractsResponse"];
+      /**
+       * @description Supported maturity timestamps. Offers must use one of these values.
+       * @example {
+       *       "end_of_month": 1738335600,
+       *       "end_of_next_month": 1740754800
+       *     }
+       */
+      maturities: components["schemas"]["MaturitiesResponse"];
+    };
+    ConfigContractsResponse: {
+      /** @example 0xD946246695A9259F3B33a78629026F61B3Ab40aF */
+      mempool: string;
+    };
+    MaturitiesResponse: {
+      /**
+       * @description Unix timestamp for end of current month maturity (last Friday 15:00 UTC).
+       * @example 1738335600
+       */
+      end_of_month: number;
+      /**
+       * @description Unix timestamp for end of next month maturity (last Friday 15:00 UTC).
+       * @example 1740754800
+       */
+      end_of_next_month: number;
+    };
     OfferListResponse: {
       meta: components["schemas"]["Meta"];
       /** @example eyJvZmZzZXQiOjEwMH0 */
@@ -1941,103 +2350,164 @@ interface components {
        * @description Offers matching the provided filters.
        * @example [
        *       {
-       *         "hash": "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
-       *         "offering": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-       *         "assets": "369216000000000000000000",
-       *         "rate": "2750000000000000000",
-       *         "maturity": 1761922799,
-       *         "expiry": 1761922799,
-       *         "start": 1761922790,
-       *         "nonce": "571380",
-       *         "buy": false,
-       *         "chain_id": 1,
-       *         "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
-       *         "collaterals": [
-       *           {
-       *             "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
-       *             "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
-       *             "lltv": "860000000000000000"
-       *           }
-       *         ],
-       *         "callback": {
-       *           "address": "0x1111111111111111111111111111111111111111",
-       *           "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
-       *           "gas_limit": "500000"
+       *         "offer": {
+       *           "obligation": {
+       *             "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+       *             "collaterals": [
+       *               {
+       *                 "token": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *                 "lltv": "860000000000000000",
+       *                 "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
+       *               }
+       *             ],
+       *             "maturity": 1761922799
+       *           },
+       *           "buy": false,
+       *           "maker": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+       *           "assets": "369216000000000000000000",
+       *           "obligation_units": "0",
+       *           "obligation_shares": "0",
+       *           "start": 1761922790,
+       *           "expiry": 1761922799,
+       *           "price": "2750000000000000000",
+       *           "group": "0x000000000000000000000000000000000000000000000000000000000008b8f4",
+       *           "session": "0x0000000000000000000000000000000000000000000000000000000000000000",
+       *           "callback": "0x1111111111111111111111111111111111111111",
+       *           "callback_data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
        *         },
-       *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
+       *         "offer_hash": "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
+       *         "obligation_id": "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
+       *         "chain_id": 1,
        *         "consumed": "0",
        *         "takeable": "369216000000000000000000",
-       *         "block_number": 2942933377146801
+       *         "block_number": 2942933377146801,
+       *         "root": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+       *         "proof": [
+       *           "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *           "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *         ],
+       *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400"
        *       }
        *     ]
        */
       data: components["schemas"]["OfferListItemResponse"][];
     };
     OfferListItemResponse: {
+      /**
+       * @example {
+       *       "obligation": {
+       *         "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+       *         "collaterals": [
+       *           {
+       *             "token": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *             "lltv": "860000000000000000",
+       *             "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
+       *           }
+       *         ],
+       *         "maturity": 1761922799
+       *       },
+       *       "buy": false,
+       *       "maker": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+       *       "assets": "369216000000000000000000",
+       *       "obligation_units": "0",
+       *       "obligation_shares": "0",
+       *       "start": 1761922790,
+       *       "expiry": 1761922799,
+       *       "price": "2750000000000000000",
+       *       "group": "0x000000000000000000000000000000000000000000000000000000000008b8f4",
+       *       "session": "0x0000000000000000000000000000000000000000000000000000000000000000",
+       *       "callback": "0x1111111111111111111111111111111111111111",
+       *       "callback_data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+       *     }
+       */
+      offer: components["schemas"]["OfferDataResponse"];
       /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
-      hash: string;
+      offer_hash: string;
+      /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
+      obligation_id: string;
+      /** @example 1 */
+      chain_id: number;
+      /** @example 0 */
+      consumed: string;
+      /** @example 369216000000000000000000 */
+      takeable: string;
+      /** @example 2942933377146801 */
+      block_number: number;
+      /** @example 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef */
+      root: string | null;
+      /**
+       * @example [
+       *       "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *       "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *     ]
+       */
+      proof: string[] | null;
+      /** @example 0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400 */
+      signature: string | null;
+    };
+    OfferDataResponse: {
+      /**
+       * @example {
+       *       "loan_token": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+       *       "collaterals": [
+       *         {
+       *           "token": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *           "lltv": "860000000000000000",
+       *           "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
+       *         }
+       *       ],
+       *       "maturity": 1761922799
+       *     }
+       */
+      obligation: components["schemas"]["ObligationOfferResponse"];
+      /** @example false */
+      buy: boolean;
       /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
-      offering: string;
+      maker: string;
       /** @example 369216000000000000000000 */
       assets: string;
-      /** @example 2750000000000000000 */
-      rate: string;
-      /** @example 1761922799 */
-      maturity: number;
-      /** @example 1761922799 */
-      expiry: number;
+      /** @example 0 */
+      obligation_units: string;
+      /** @example 0 */
+      obligation_shares: string;
       /** @example 1761922790 */
       start: number;
-      /** @example 571380 */
-      nonce: string;
-      /** @example false */
-      buy: boolean;
-      /** @example 1 */
-      chain_id: number;
+      /** @example 1761922799 */
+      expiry: number;
+      /** @example 2750000000000000000 */
+      price: string;
+      /** @example 0x000000000000000000000000000000000000000000000000000000000008b8f4 */
+      group: string;
+      /** @example 0x0000000000000000000000000000000000000000000000000000000000000000 */
+      session: string;
+      /** @example 0x1111111111111111111111111111111111111111 */
+      callback: string;
+      /** @example 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000 */
+      callback_data: string;
+    };
+    ObligationOfferResponse: {
       /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
       loan_token: string;
       /**
        * @example [
        *       {
-       *         "asset": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
-       *         "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
-       *         "lltv": "860000000000000000"
+       *         "token": "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+       *         "lltv": "860000000000000000",
+       *         "oracle": "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
        *       }
        *     ]
        */
       collaterals: components["schemas"]["CollateralResponse"][];
-      /**
-       * @example {
-       *       "address": "0x1111111111111111111111111111111111111111",
-       *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
-       *       "gas_limit": "500000"
-       *     }
-       */
-      callback: components["schemas"]["OfferCallbackResponse"];
-      /** @example 369216000000000000000000 */
-      takeable: string;
-      /** @example 0 */
-      consumed: string;
-      /** @example 2942933377146801 */
-      block_number: number;
-      /** @example 0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400 */
-      signature: string | null;
+      /** @example 1761922799 */
+      maturity: number;
     };
     CollateralResponse: {
       /** @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751 */
-      asset: string;
-      /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
-      oracle: string;
+      token: string;
       /** @example 860000000000000000 */
       lltv: string;
-    };
-    OfferCallbackResponse: {
-      /** @example 0x1111111111111111111111111111111111111111 */
-      address: string;
-      /** @example 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000 */
-      data: string;
-      /** @example 500000 */
-      gas_limit: string;
+      /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
+      oracle: string;
     };
     ObligationListResponse: {
       meta: components["schemas"]["Meta"];
@@ -2061,11 +2531,11 @@ interface components {
     };
     AskResponse: {
       /** @example 1000000000000000000 */
-      rate: string;
+      price: string;
     };
     BidResponse: {
       /** @example 1000000000000000000 */
-      rate: string;
+      price: string;
     };
     ObligationSingleSuccessResponse: {
       meta: components["schemas"]["Meta"];
@@ -2079,7 +2549,10 @@ interface components {
       /**
        * @description Aggregated router status.
        * @example {
-       *       "status": "live"
+       *       "status": "live",
+       *       "initialized": true,
+       *       "missing_chains": [],
+       *       "missing_collectors": []
        *     }
        */
       data: components["schemas"]["RouterStatusDataResponse"];
@@ -2090,6 +2563,24 @@ interface components {
        * @enum {string}
        */
       status: "live" | "syncing";
+      /** @example true */
+      initialized: boolean;
+      /**
+       * @description Configured chain ids missing initialization rows.
+       * @example []
+       */
+      missing_chains: number[];
+      /**
+       * @description Collectors missing initialization rows.
+       * @example []
+       */
+      missing_collectors: components["schemas"]["MissingCollectorResponse"][];
+    };
+    MissingCollectorResponse: {
+      /** @example 1 */
+      chain_id: number;
+      /** @example offers */
+      name: string;
     };
     CollectorsHealthSuccessResponse: {
       meta: components["schemas"]["Meta"];
@@ -2102,7 +2593,8 @@ interface components {
        *         "block_number": 21345678,
        *         "updated_at": "2024-01-01T12:00:00.000Z",
        *         "lag": 0,
-       *         "status": "live"
+       *         "status": "live",
+       *         "initialized": true
        *       }
        *     ]
        */
@@ -2124,6 +2616,8 @@ interface components {
        * @enum {string}
        */
       status: "live" | "lagging" | "unknown";
+      /** @example true */
+      initialized: boolean;
     };
     ChainsHealthSuccessResponse: {
       meta: components["schemas"]["Meta"];
@@ -2134,7 +2628,8 @@ interface components {
        *         "chain_id": 1,
        *         "local_block_number": 21345678,
        *         "remote_block_number": 21345690,
-       *         "updated_at": "2024-01-01T12:00:00.000Z"
+       *         "updated_at": "2024-01-01T12:00:00.000Z",
+       *         "initialized": true
        *       }
        *     ]
        */
@@ -2144,36 +2639,69 @@ interface components {
       /** @example 1 */
       chain_id: number;
       /** @example 21345678 */
-      local_block_number: number;
+      local_block_number: number | null;
       /** @example 21345690 */
       remote_block_number: number | null;
       /** @example 2024-01-01T12:00:00.000Z */
-      updated_at: string;
+      updated_at: string | null;
+      /** @example true */
+      initialized: boolean;
     };
-    ValidateOffersRequest: {
-      /** @description Array of offers in snake_case format. Mutually exclusive with 'calldata'. */
-      offers?: components["schemas"]["ValidateOfferRequest"][];
+    PositionListResponse: {
+      meta: components["schemas"]["Meta"];
+      /** @example eyJvZmZzZXQiOjEwMH0 */
+      cursor: string | null;
       /**
-       * @description Encoded tree calldata as a hex string (0x-prefixed). Mutually exclusive with 'offers'.
-       * @example 0x01...
+       * @description User positions with reserved balances from active offers.
+       * @example [
+       *       {
+       *         "chain_id": 1,
+       *         "contract": "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+       *         "user": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+       *         "reserved": "200000000000000000000",
+       *         "block_number": 21345678
+       *       }
+       *     ]
        */
-      calldata?: string;
+      data: components["schemas"]["PositionListItemResponse"][];
+    };
+    PositionListItemResponse: {
+      /** @example 1 */
+      chain_id: number;
+      /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
+      contract: string;
+      /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
+      user: string;
+      /** @example 200000000000000000000 */
+      reserved: string;
+      /** @example 21345678 */
+      block_number: number;
+    };
+    ValidateOffersRequest: {
+      /** @description Array of offers in snake_case format. Required, non-empty. */
+      offers: components["schemas"]["ValidateOfferRequest"][];
     };
     ValidateOfferRequest: {
       /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
-      offering: string;
+      maker: string;
       /** @example 369216000000000000000000 */
       assets: string;
+      /** @example 0 */
+      obligation_units?: string;
+      /** @example 0 */
+      obligation_shares?: string;
       /** @example 2750000000000000000 */
-      rate: string;
+      price: string;
       /** @example 1761922799 */
       maturity: number;
       /** @example 1761922799 */
       expiry: number;
       /** @example 1761922790 */
       start: number;
-      /** @example 571380 */
-      nonce: string;
+      /** @example 0x000000000000000000000000000000000000000000000000000000000008b8f4 */
+      group: string;
+      /** @example 0x0000000000000000000000000000000000000000000000000000000000000000 */
+      session: string;
       /** @example false */
       buy: boolean;
       /** @example 1 */
@@ -2189,32 +2717,47 @@ interface components {
        *       }
        *     ]
        */
-      collaterals: components["schemas"]["CollateralResponse"][];
+      collaterals: components["schemas"]["ValidateCollateralRequest"][];
       /**
        * @example {
        *       "address": "0x1111111111111111111111111111111111111111",
-       *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
-       *       "gas_limit": "500000"
+       *       "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
        *     }
        */
-      callback: components["schemas"]["OfferCallbackResponse"];
+      callback: components["schemas"]["ValidateCallbackRequest"];
+    };
+    ValidateCollateralRequest: {
+      /** @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751 */
+      asset: string;
+      /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
+      oracle: string;
+      /** @example 860000000000000000 */
+      lltv: string;
+    };
+    ValidateCallbackRequest: {
+      /** @example 0x1111111111111111111111111111111111111111 */
+      address: string;
+      /** @example 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000 */
+      data: string;
     };
-    ValidateOffersListResponse: {
+    ValidationSuccessResponse: {
       meta: components["schemas"]["Meta"];
       /** @example null */
       cursor: string | null;
-      /** @description Validation results for each offer. */
-      data: components["schemas"]["ValidateOfferResultResponse"][];
+      /** @description Payload and root for client-side signing. */
+      data: components["schemas"]["ValidationSuccessDataResponse"];
     };
-    ValidateOfferResultResponse: {
-      /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
-      offer_hash: string;
-      /** @example false */
-      valid: boolean;
-      /** @example parse_error */
-      rule: string | null;
-      /** @example Invalid offer. 'offering': invalid address */
-      message: string | null;
+    ValidationSuccessDataResponse: {
+      /**
+       * @description Unsigned payload: version (1B) + gzip(offers) + root (32B).
+       * @example 0x01789c...
+       */
+      payload: string;
+      /**
+       * @description Merkle tree root to sign with EIP-191.
+       * @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427
+       */
+      root: string;
     };
   };
   responses: never;
@@ -2224,7 +2767,7 @@ interface components {
   pathItems: never;
 }
 declare namespace ObligationResponse_d_exports {
-  export { ObligationResponse, from$2 as from };
+  export { ObligationResponse, from$3 as from };
 }
 type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["content"]["application/json"]["data"][number];
 /**
@@ -2233,18 +2776,49 @@ type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["c
  * @param obligation - {@link Obligation}
  * @returns The created `ObligationResponse`. {@link ObligationResponse}
  */
-declare function from$2(obligation: Obligation, quote: Quote): ObligationResponse;
+declare function from$3(obligation: Obligation, quote: Quote): ObligationResponse;
 declare namespace OfferResponse_d_exports {
-  export { OfferResponse, from$1 as from };
+  export { Input, OfferResponse, from$2 as from };
 }
 type OfferResponse = paths["/v1/offers"]["get"]["responses"]["200"]["content"]["application/json"]["data"][number];
+type Input = Readonly<{
+  hash: Hex;
+  maker: Address;
+  assets: bigint;
+  obligationUnits: bigint;
+  obligationShares: bigint;
+  price: bigint;
+  maturity: number;
+  expiry: number;
+  start: number;
+  group: Hex;
+  session: Hex;
+  buy: boolean;
+  chainId: number;
+  loanToken: Address;
+  collaterals: Readonly<{
+    asset: Address;
+    lltv: bigint;
+    oracle: Address;
+  }[]>;
+  callback: {
+    address: Address;
+    data: Hex;
+  };
+  root?: Hex | undefined;
+  proof?: Hex[] | undefined;
+  signature?: Hex | undefined;
+  consumed: bigint;
+  takeable: bigint;
+  blockNumber: number;
+}>;
 /**
- * Creates an `OfferResponse` from an `Offer`.
+ * Creates an `OfferResponse` matching the Solidity Offer struct layout.
  * @constructor
- * @param offer - {@link Offer}
+ * @param input - {@link Input}
  * @returns The created `OfferResponse`. {@link OfferResponse}
  */
-declare function from$1(offer: Offer): OfferResponse;
+declare function from$2(input: Input): OfferResponse;
 //#endregion
 //#region src/api/Schema/openapi.d.ts
 declare class BooksController {
@@ -2261,10 +2835,16 @@ declare class HealthController {
   getCollectorsHealth(): Promise<void>;
   getChainsHealth(): Promise<void>;
 }
+declare class ConfigController {
+  getConfig(): Promise<void>;
+}
 declare class ObligationsController {
   getObligations(): Promise<void>;
   getObligation(): Promise<void>;
 }
+declare class UsersController {
+  getUserPositions(): Promise<void>;
+}
 type RuleInfo = {
   name: string;
   description: string;
@@ -2274,20 +2854,91 @@ type OpenApiOptions = {
 };
 declare const OpenApi: (options?: OpenApiOptions) => Promise<OpenAPIDocument>;
 //#endregion
+//#region src/database/domains/Positions.d.ts
+type PaginationParams = {
+  /** Cursor string returned by a previous call, for pagination */
+  cursor?: string;
+  /** Page size; defaults to {@link DEFAULT_LIMIT} */
+  limit?: number;
+};
+declare namespace getByUser {
+  type Parameters = PaginationParams & {
+    /** The user address to get positions for. */
+    user: Address;
+  };
+  type PositionWithReserved = {
+    chainId: Id;
+    contract: Address;
+    user: Address;
+    blockNumber: number;
+    /** The amount reserved by active offers: max(lot.upper) - offset - consumed */
+    reserved: bigint;
+  };
+  type ReturnType = {
+    positions: PositionWithReserved[];
+    nextCursor: string | null;
+  };
+}
+declare namespace PositionResponse_d_exports {
+  export { PositionResponse, PositionWithReserved$1 as PositionWithReserved, from$1 as from };
+}
+type PositionResponse = {
+  chain_id: Id;
+  contract: Address;
+  user: Address;
+  reserved: string;
+  block_number: number;
+};
+type PositionWithReserved$1 = getByUser.PositionWithReserved;
+/**
+ * Creates a `PositionResponse` from a `PositionWithReserved`.
+ * @param position - {@link PositionWithReserved}
+ * @returns The created `PositionResponse`. {@link PositionResponse}
+ */
+declare function from$1(position: PositionWithReserved$1): PositionResponse;
+//#endregion
 //#region src/api/Schema/requests.d.ts
 declare const schemas: {
+  readonly get_health: z$1.ZodObject<{
+    strict: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodEnum<{
+      0: "0";
+      1: "1";
+      true: "true";
+      false: "false";
+    }>, z$1.ZodTransform<boolean, "0" | "1" | "true" | "false">>>;
+  }, z$1.core.$strip>;
+  readonly get_health_collectors: z$1.ZodObject<{
+    strict: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodEnum<{
+      0: "0";
+      1: "1";
+      true: "true";
+      false: "false";
+    }>, z$1.ZodTransform<boolean, "0" | "1" | "true" | "false">>>;
+  }, z$1.core.$strip>;
+  readonly get_health_chains: z$1.ZodObject<{
+    strict: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodEnum<{
+      0: "0";
+      1: "1";
+      true: "true";
+      false: "false";
+    }>, z$1.ZodTransform<boolean, "0" | "1" | "true" | "false">>>;
+  }, z$1.core.$strip>;
   readonly get_offers: z$1.ZodObject<{
     side: z$1.ZodOptional<z$1.ZodEnum<{
       buy: "buy";
       sell: "sell";
     }>>;
     obligation_id: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
-    offering: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    maker: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
     cursor: z$1.ZodOptional<z$1.ZodString>;
     limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
   readonly get_obligations: z$1.ZodObject<{
     cursor: z$1.ZodOptional<z$1.ZodString>;
+    chain: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>>;
+    loan_token: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    collateral_token: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    maturity: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>>;
     limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
   readonly get_obligation: z$1.ZodObject<{
@@ -2303,15 +2954,19 @@ declare const schemas: {
     limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
   readonly validate_offers: z$1.ZodObject<{
-    offers: z$1.ZodAny;
-    calldata: z$1.ZodOptional<z$1.ZodString>;
+    offers: z$1.ZodArray<z$1.ZodUnknown>;
+  }, z$1.core.$strict>;
+  readonly get_user_positions: z$1.ZodObject<{
+    user_address: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
 };
 type Action = keyof typeof schemas;
 declare function parse<A extends Action>(action: A, query: unknown): z$1.infer<(typeof schemas)[A]>;
 declare function safeParse<A extends Action>(action: A, query: unknown, error?: z$1.core.$ZodErrorMap<z$1.core.$ZodIssue>): z$1.ZodSafeParseResult<z$1.infer<(typeof schemas)[A]>>;
 declare namespace index_d_exports$1 {
-  export { BookResponse_d_exports as BookResponse, BooksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, OpenApiOptions, RouterStatusResponse, RuleInfo, ValidateController, parse, safeParse };
+  export { BookResponse_d_exports as BookResponse, BooksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, ConfigController, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, OpenApiOptions, PositionResponse_d_exports as PositionResponse, RouterStatusResponse, RuleInfo, UsersController, ValidateController, parse, safeParse };
 }
 declare namespace Client_d_exports {
   export { Client$2 as Client, ConnectOptions, HttpForbiddenError, HttpGetApiFailedError, HttpRateLimitError, HttpUnauthorizedError, InvalidUrlError, connect$1 as connect, getObligations, getOffers };
@@ -2392,7 +3047,19 @@ declare namespace getOffers {
     limit?: number;
   };
   type ReturnType = {
-    offers: Offer[];
+    offers: Compute<Offer & {
+      hash: Hex;
+      blockNumber: number;
+      consumed: bigint;
+      takeable: bigint;
+    } & {
+      /** 32-byte merkle root. */
+      root?: Hex;
+      /** Sibling hashes for the merkle proof. */
+      proof?: Hex[];
+      /** Offer signature from the Merkle tree. */
+      signature?: Hex;
+    }>[];
     /** The pagination cursor. */
     cursor: string | null;
   };
@@ -2405,6 +3072,14 @@ declare namespace getObligations {
     cursor?: Hex;
     /** Maximum number of obligations to return. @default 20 */
     limit?: number;
+    /** Filter by chain ID. */
+    chainId?: number;
+    /** Filter by loan token address. */
+    loanToken?: Address;
+    /** Filter by collateral token (matches any collateral in the obligation). */
+    collateralToken?: Address;
+    /** Filter by exact maturity timestamp (unix seconds). */
+    maturity?: number;
   };
   type ReturnType = {
     obligations: Compute<{
@@ -2441,22 +3116,6 @@ declare class HttpGetApiFailedError extends BaseError {
     details?: string;
   });
 }
-declare namespace Cursor_d_exports {
-  export { Cursor, decode, encode, validate };
-}
-type Cursor = {
-  sort: "rate" | "maturity" | "expiry" | "amount";
-  dir: "asc" | "desc";
-  rate?: string;
-  maturity?: number;
-  expiry?: number;
-  assets?: string;
-  hash: string;
-  page?: number;
-};
-declare function validate(cursor: unknown): cursor is Cursor;
-declare function encode(c: Cursor): string;
-declare function decode(token?: string): Cursor | null;
 declare namespace Gate_d_exports {
   export { Batch, Issue, Result, Rule, RuleNames, Single, batch$1 as batch, run, single };
 }
@@ -2531,7 +3190,7 @@ declare function run<T, Name$1 extends string, Rules$1 extends readonly Rule<T,
   chunkSize?: number;
 }): Promise<Result<T, RuleNames<Rules$1>>>;
 declare namespace GateConfig_d_exports {
-  export { CallbackConfig, GateConfig, assets$1 as assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
+  export { CallbackConfig, GateConfig, assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
 }
 type GateConfig = {
   callbacks?: CallbackConfig[];
@@ -2580,7 +3239,7 @@ declare function getCallbackTypeAddresses(chain: Name, type: CallbackType): Addr
  * @returns Array of allowed callback addresses (lowercased). Empty when none configured
  */
 declare const getCallbackAddresses: (chain: Name) => Address[];
-declare const assets$1: Record<string, Address[]>;
+declare const assets: Record<string, Address[]>;
 declare const configs: Record<Name, GateConfig>;
 declare namespace Gatekeeper_d_exports {
   export { Gatekeeper, Rules, create };
@@ -2596,9 +3255,9 @@ type GatekeeperParameters = {
 declare function create(parameters: GatekeeperParameters): Gatekeeper;
 //#endregion
 //#region src/gatekeeper/morphoRules.d.ts
-declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token">)[];
+declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token"> | Rule<Offer, "mixed_maker"> | Rule<Offer, "amount_mutual_exclusivity">)[];
 declare namespace Rules_d_exports {
-  export { ValidityParameters, callback, chains, maturity, token, validity };
+  export { ValidityParameters, amountMutualExclusivity, callback, chains, maturity, sameMaker, token, validity };
 }
 type ValidityParameters = {
   client: PublicClient<Transport, Chain$1>;
@@ -2628,15 +3287,27 @@ declare const callback: ({
   allowedAddresses: Address[];
 }) => Rule<Offer, "callback">;
 /**
- * A validation rule that checks if the offer's token is allowed.
- * @param offer - The offer to validate.
+ * A validation rule that checks if the offer's tokens are allowed for its chain.
+ * @param assetsByChainId - Allowed assets indexed by chain id.
  * @returns The issue that was found. If the offer is valid, this will be undefined.
  */
 declare const token: ({
-  assets
+  assetsByChainId
 }: {
-  assets: Address[];
+  assetsByChainId: Partial<Record<Id, Address[]>>;
 }) => Rule<Offer, "token">;
+/**
+ * A batch validation rule that ensures all offers in a tree have the same maker address.
+ * Returns an issue only for the first non-conforming offer.
+ * This rule is signing-agnostic; signer verification is handled at the collector level.
+ */
+declare const sameMaker: () => Rule<Offer, "mixed_maker">;
+/**
+ * A validation rule that ensures mutual exclusivity of offer amount fields.
+ * At most one of (assets, obligationUnits, obligationShares) can be non-zero.
+ * Matches contract requirement: `atMostOneNonZero(offer.assets, offer.obligationUnits, offer.obligationShares)`.
+ */
+declare const amountMutualExclusivity: () => Rule<Offer, "amount_mutual_exclusivity">;
 //#endregion
 //#region src/mempool/MempoolEVMClient.d.ts
 declare function from(parameters: from.Parameters): from.ReturnType;
@@ -2655,7 +3326,7 @@ declare namespace from {
 declare namespace MempoolClient_d_exports {
   export { AddParameters, Client$1 as Client, GetParameters, connect };
 }
-type AddParameters = Compute<Omit<Offer, "hash" | "createdAt">[]>;
+type AddParameters = Compute<Omit<Offer, "createdAt">[]>;
 type GetParameters = {
   /** The block number to get offers from. */
   blockNumberGte?: number;
@@ -2710,6 +3381,12 @@ declare namespace connect {
 //#region src/utils/BigMath.d.ts
 declare function max$1(a: bigint, b: bigint): bigint;
 declare function min(a: bigint, b: bigint): bigint;
+/**
+ * Checks if at most one of the given values is non-zero.
+ * @param values - The bigint values to check.
+ * @returns True if zero or one value is non-zero, false if two or more are non-zero.
+ */
+declare function atMostOneNonZero(...values: bigint[]): boolean;
 //#endregion
 //#region src/utils/batch.d.ts
 /**
@@ -2747,6 +3424,15 @@ declare function batchMulticall<TResult>(parameters: {
   retryDelayMs: number;
   blockNumber?: bigint;
 }): Promise<TResult[]>;
+declare namespace Group_d_exports {
+  export { fromNumber };
+}
+/**
+ * Creates a bytes32 group identifier from a number.
+ * @param n - A non-negative integer.
+ * @throws {Error} If n is negative or not an integer.
+ */
+declare const fromNumber: (n: number) => Hex;
 //#endregion
 //#region src/utils/lazy.d.ts
 /**
@@ -2774,6 +3460,41 @@ declare function poll<data>(fn: ({
 }: {
   interval: () => Promise<number>;
 }): () => boolean;
+declare namespace Random_d_exports {
+  export { address, bool, bytes, float, hex, int, seed, withSeed };
+}
+/**
+ * Runs a function with a deterministic RNG derived from the given seed.
+ */
+declare function withSeed<T>(seed: string, fn: () => T): T;
+/**
+ * Seeds the global RNG for deterministic test runs.
+ */
+declare function seed(seed: string): void;
+/**
+ * Returns a deterministic random float in [0, 1).
+ */
+declare function float(): number;
+/**
+ * Returns a deterministic random integer in [min, maxExclusive).
+ */
+declare function int(maxExclusive: number, min?: number): number;
+/**
+ * Returns a deterministic random boolean.
+ */
+declare function bool(probability?: number): boolean;
+/**
+ * Returns deterministic random bytes.
+ */
+declare function bytes(length: number): Uint8Array;
+/**
+ * Returns a deterministic random hex string for the given byte length.
+ */
+declare function hex(byteLength: number): Hex;
+/**
+ * Returns a deterministic random address.
+ */
+declare function address(): Address;
 //#endregion
 //#region src/utils/retry.d.ts
 declare const retry: <T>(fn: () => Promise<T>, attempts?: number, delayMs?: number) => Promise<T>;
@@ -2786,8 +3507,8 @@ declare function max(): number;
 //#region src/utils/wait.d.ts
 declare function wait(time: number): Promise<unknown>;
 declare namespace index_d_exports$2 {
-  export { BaseError, GlobalErrorType, ReorgError, Snake, time_d_exports as Time, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
+  export { BaseError, GlobalErrorType, Group_d_exports as Group, Random_d_exports as Random, ReorgError, Snake, time_d_exports as Time, atMostOneNonZero, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
 }
 //#endregion
-export { index_d_exports as Abi, Brand, BrandTypeId, Callback_d_exports as Callback, Chain_d_exports as Chain, Collateral_d_exports as Collateral, Compute, Cursor_d_exports as Cursor, ERC4626_d_exports as ERC4626, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Maturity_d_exports as Maturity, MempoolClient_d_exports as Mempool, Obligation_d_exports as Obligation, Offer_d_exports as Offer, Oracle_d_exports as Oracle, Position_d_exports as Position, Quote_d_exports as Quote, index_d_exports$1 as RouterApi, Client_d_exports as RouterClient, Rules_d_exports as Rules, time_d_exports as Time, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, Gate_d_exports as Validation, morphoRules };
+export { index_d_exports as Abi, Brand, BrandTypeId, Callback_d_exports as Callback, Chain_d_exports as Chain, ChainRegistry_d_exports as ChainRegistry, Collateral_d_exports as Collateral, Compute, ERC4626_d_exports as ERC4626, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Maturity_d_exports as Maturity, MempoolClient_d_exports as Mempool, Obligation_d_exports as Obligation, Offer_d_exports as Offer, Oracle_d_exports as Oracle, Position_d_exports as Position, Quote_d_exports as Quote, index_d_exports$1 as RouterApi, Client_d_exports as RouterClient, Rules_d_exports as Rules, time_d_exports as Time, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, Gate_d_exports as Validation, morphoRules };
 //# sourceMappingURL=index.browser.d.ts.map