@morpho-dev/router 0.8.0 → 0.10.0

package/dist/index.browser.d.mts

@@ -1,11 +1,11 @@
 import { z } from "zod/v4";
-import { AbiEvent, Address, ChainContract, ChainFormatters, GetLogsReturnType, Hex, MulticallParameters, PublicClient, Transport, WalletClient } from "viem";
-import { Chain } from "viem/chains";
-import * as z$1 from "zod";
-import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
 import "reflect-metadata";
 import { OpenAPIDocument } from "openapi-metadata";
+import * as z$1 from "zod";
 import { Client } from "openapi-fetch";
+import { AbiEvent, Address, ChainContract, ChainFormatters, GetLogsReturnType, Hex, MulticallParameters, PublicClient, Transport, WalletClient } from "viem";
+import { Chain } from "viem/chains";
+import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
 import "@electric-sql/pglite";
 import "drizzle-orm/node-postgres";
 import "drizzle-orm/pglite";
@@ -582,7 +582,7 @@ declare const MorphoV2: readonly [{
   readonly stateMutability: "nonpayable";
   readonly inputs: readonly [{
     readonly type: "address";
-    readonly name: "recipient";
+    readonly name: "feeRecipient";
   }];
   readonly outputs: readonly [];
 }, {
@@ -662,6 +662,15 @@ declare const MorphoV2: readonly [{
   }, {
     readonly type: "address";
     readonly name: "taker";
+  }, {
+    readonly type: "address";
+    readonly name: "takerCallback";
+  }, {
+    readonly type: "bytes";
+    readonly name: "takerCallbackData";
+  }, {
+    readonly type: "address";
+    readonly name: "receiverIfTakerIsSeller";
   }, {
     readonly type: "tuple";
     readonly components: readonly [{
@@ -723,6 +732,9 @@ declare const MorphoV2: readonly [{
     }, {
       readonly type: "bytes";
       readonly name: "callbackData";
+    }, {
+      readonly type: "address";
+      readonly name: "receiverIfMakerIsSeller";
     }];
     readonly name: "offer";
   }, {
@@ -744,12 +756,6 @@ declare const MorphoV2: readonly [{
   }, {
     readonly type: "bytes32[]";
     readonly name: "proof";
-  }, {
-    readonly type: "address";
-    readonly name: "takerCallback";
-  }, {
-    readonly type: "bytes";
-    readonly name: "takerCallbackData";
   }];
   readonly outputs: readonly [{
     readonly type: "uint256";
@@ -871,6 +877,9 @@ declare const MorphoV2: readonly [{
   }, {
     readonly type: "address";
     readonly name: "onBehalf";
+  }, {
+    readonly type: "address";
+    readonly name: "receiver";
   }];
   readonly outputs: readonly [{
     readonly type: "uint256";
@@ -913,6 +922,9 @@ declare const MorphoV2: readonly [{
   }, {
     readonly type: "address";
     readonly name: "onBehalf";
+  }, {
+    readonly type: "address";
+    readonly name: "receiver";
   }];
   readonly outputs: readonly [];
 }, {
@@ -1100,7 +1112,7 @@ declare const MorphoV2: readonly [{
   readonly type: "event";
   readonly inputs: readonly [{
     readonly type: "address";
-    readonly name: "recipient";
+    readonly name: "feeRecipient";
     readonly indexed: true;
   }];
 }, {
@@ -1175,6 +1187,9 @@ declare const MorphoV2: readonly [{
   }, {
     readonly type: "bool";
     readonly name: "sellerIsBorrower";
+  }, {
+    readonly type: "address";
+    readonly name: "sellerReceiver";
   }, {
     readonly type: "bytes32";
     readonly name: "group";
@@ -1188,7 +1203,6 @@ declare const MorphoV2: readonly [{
   readonly inputs: readonly [{
     readonly type: "address";
     readonly name: "caller";
-    readonly indexed: true;
   }, {
     readonly type: "bytes32";
     readonly name: "id";
@@ -1203,6 +1217,10 @@ declare const MorphoV2: readonly [{
     readonly type: "address";
     readonly name: "onBehalf";
     readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "receiver";
+    readonly indexed: true;
   }];
 }, {
   readonly name: "WithdrawCollateral";
@@ -1225,6 +1243,9 @@ declare const MorphoV2: readonly [{
     readonly type: "address";
     readonly name: "onBehalf";
     readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "receiver";
   }];
 }];
 type MorphoV2 = typeof MorphoV2;
@@ -1398,7 +1419,7 @@ declare class ReorgError extends BaseError {
   constructor(blockNumber: number);
 }
 declare namespace Chain_d_exports {
-  export { Chain$1 as Chain, ChainId, Id, InvalidBatchSizeError, InvalidBlockRangeError, InvalidBlockWindowError, MissingBlockNumberError, Name, chainIds, chainNames, chains$1 as chains, getChain, getWhitelistedChains, streamLogs };
+  export { Chain$1 as Chain, ChainId, Id, InvalidBatchSizeError, InvalidBlockRangeError, InvalidBlockWindowError, MissingBlockNumberError, Name, chainIds, chainNames, chains, getChain, getWhitelistedChains, streamLogs };
 }
 type Chain$1 = Compute<Omit<Chain<ChainFormatters, {
   morpho: ChainContract;
@@ -1439,7 +1460,7 @@ type Id = (typeof ChainId)[Uppercase<Name>];
 declare const chainIds: readonly Id[];
 declare function getChain(chainId: Id): Chain$1 | undefined;
 declare const getWhitelistedChains: () => Chain$1[];
-declare const chains$1: Record<Lowercase<Name>, Chain$1>;
+declare const chains: Record<Lowercase<Name>, Chain$1>;
 declare function streamLogs<abiEvent extends AbiEvent | undefined = undefined>(parameters: {
   client: PublicClient;
   contractAddress?: Address;
@@ -1517,13 +1538,23 @@ 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$13 as from, random$3 as random };
+  export { Collateral, CollateralSchema, CollateralsSchema, abi$1 as abi, from$13 as from, random$3 as random };
 }
 type Collateral = {
   /** Asset being used as collateral. */asset: Address; /** Liquidation Loan-to-Value of the collateral. */
   lltv: LLTV; /** Oracle contract used to price the collateral. */
   oracle: Address;
 };
+declare const abi$1: readonly [{
+  readonly type: "address";
+  readonly name: "token";
+}, {
+  readonly type: "uint256";
+  readonly name: "lltv";
+}, {
+  readonly type: "address";
+  readonly name: "oracle";
+}];
 declare const CollateralSchema: z$1.ZodObject<{
   asset: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
   oracle: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
@@ -1637,102 +1668,33 @@ declare class DenominatorIsZeroError extends BaseError {
   readonly name = "ERC4626.DenominatorIsZeroError";
   constructor();
 }
-declare namespace Liquidity_d_exports {
-  export { LiquidityLink, LiquidityPool, OfferLiquidityPool, calculateMaxDebt, generateAllowancePoolId, generateBalancePoolId, generateDebtPoolId, generateMarketLiquidityPoolId, generateObligationCollateralPoolId, generateUserVaultPositionPoolId, generateVaultPositionPoolId };
+declare namespace Format_d_exports {
+  export { Snake, fromSnakeCase$3 as fromSnakeCase, stringifyBigint, toSnakeCase$1 as toSnakeCase };
 }
+/** The snake case representation of a type with bigint values stringified. */
+type Snake<T> = DeepMutable<SnakeKeys<StringifiedBigint<T>>>;
+/** Make arrays/tuples and object props mutable, deeply. */
+type DeepMutable<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepMutable<R[K]> } : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } : T;
+/** 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;
 /**
- * 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: Hex;
-  poolId: string;
-  /**
-   * The available capacity/liquidity from this pool for this offer.
-   * Matches allowance amount from pool below.
-   */
-  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 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 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.
+ * 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 generateVaultPositionPoolId(parameters: {
-  vault: Address;
-  chainId: Id;
-  marketId: string;
-}): string;
+declare function toSnakeCase$1<T>(obj: T): Snake<T>;
 /**
- * Generate pool ID for market total liquidity.
+ * 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 generateMarketLiquidityPoolId(parameters: {
-  chainId: Id;
-  marketId: string;
-}): string;
+declare function fromSnakeCase$3<T>(obj: Snake<T>): T;
+declare function stringifyBigint<T>(value: T): StringifiedBigint<T>;
 declare namespace Maturity_d_exports {
   export { InvalidDateError, InvalidFormatError, InvalidOptionError, Maturity, MaturityOptions, MaturitySchema, MaturityType, from$12 as from };
 }
@@ -1781,44 +1743,15 @@ declare class InvalidOptionError extends BaseError {
   readonly name = "Maturity.InvalidOptionError";
   constructor(input: string);
 }
-declare namespace Format_d_exports {
-  export { Snake, fromSnakeCase$3 as fromSnakeCase, stringifyBigint, toSnakeCase$1 as toSnakeCase };
-}
-/** The snake case representation of a type with bigint values stringified. */
-type Snake<T> = DeepMutable<SnakeKeys<StringifiedBigint<T>>>;
-/** Make arrays/tuples and object props mutable, deeply. */
-type DeepMutable<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends number | string | boolean | symbol | bigint | null | undefined ? T : T extends readonly [...infer R] ? { -readonly [K in keyof R]: DeepMutable<R[K]> } : T extends ReadonlyArray<infer U> ? Array<DeepMutable<U>> : T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } : T;
-/** 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$11 as from, fromOffer$1 as fromOffer, fromSnakeCase$2 as fromSnakeCase, id, random$2 as random };
+  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation$1 as Obligation, ObligationSchema, abi, from$11 as from, fromOffer$1 as fromOffer, fromSnakeCase$2 as fromSnakeCase, key$1 as key, random$2 as random, tupleAbi };
 }
-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. */
+type Obligation$1 = {
+  /** 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>>;
@@ -1827,6 +1760,49 @@ declare const ObligationSchema: z$1.ZodObject<{
   }, z$1.core.$strip>>;
   maturity: z$1.ZodPipe<z$1.ZodNumber, z$1.ZodTransform<Maturity, number>>;
 }, z$1.core.$strip>;
+declare const abi: readonly [{
+  readonly type: "address";
+  readonly name: "loanToken";
+}, {
+  readonly type: "tuple[]";
+  readonly name: "collaterals";
+  readonly components: readonly [{
+    readonly type: "address";
+    readonly name: "token";
+  }, {
+    readonly type: "uint256";
+    readonly name: "lltv";
+  }, {
+    readonly type: "address";
+    readonly name: "oracle";
+  }];
+}, {
+  readonly type: "uint256";
+  readonly name: "maturity";
+}];
+declare const tupleAbi: readonly [{
+  readonly type: "tuple";
+  readonly components: readonly [{
+    readonly type: "address";
+    readonly name: "loanToken";
+  }, {
+    readonly type: "tuple[]";
+    readonly name: "collaterals";
+    readonly components: readonly [{
+      readonly type: "address";
+      readonly name: "token";
+    }, {
+      readonly type: "uint256";
+      readonly name: "lltv";
+    }, {
+      readonly type: "address";
+      readonly name: "oracle";
+    }];
+  }, {
+    readonly type: "uint256";
+    readonly name: "maturity";
+  }];
+}];
 /**
  * Creates an obligation from the given parameters.
  * @constructor
@@ -1837,7 +1813,6 @@ declare const ObligationSchema: z$1.ZodObject<{
  * @example
  * ```ts
  * const obligation = Obligation.from({
- *   chainId: 1,
  *   loanToken: privateKeyToAccount(generatePrivateKey()).address,
  *   collaterals: [
  *     Collateral.from({
@@ -1853,12 +1828,11 @@ declare const ObligationSchema: z$1.ZodObject<{
 declare function from$11(parameters: from$11.Parameters): from$11.ReturnType;
 declare namespace from$11 {
   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. */
+    /** 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$13.Parameters[] | readonly from$13.Parameters[]; /** The maturity of the obligation. */
     maturity: from$12.Parameters;
   };
-  type ReturnType = Obligation;
+  type ReturnType = Obligation$1;
   type ErrorType = InvalidObligationError;
 }
 /**
@@ -1869,30 +1843,27 @@ declare namespace from$11 {
  */
 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 Parameters = Snake<Obligation$1>;
+  type ReturnType = Obligation$1;
   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)).
+ * Calculates a canonical key for an obligation payload.
+ * The key is computed as keccak256(abi.encode(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}
+ * @param parameters - {@link key.Parameters}
+ * @returns The obligation key as a 32-byte hex string. {@link key.ReturnType}
  *
  * @example
  * ```ts
  * const obligation = Obligation.random();
- * const id = Obligation.id(obligation);
- * console.log(id); // 0x1234567890123456789012345678901234567890123456789012345678901234
+ * const key = Obligation.key(obligation);
+ * console.log(key); // 0x1234567890123456789012345678901234567890123456789012345678901234
  * ```
  */
-declare function id(parameters: id.Parameters): id.ReturnType;
-declare namespace id {
+declare function key$1(parameters: key$1.Parameters): key$1.ReturnType;
+declare namespace key$1 {
   type Parameters = {
-    chainId: number;
     loanToken: Address;
     collaterals: {
       asset: Address;
@@ -1915,7 +1886,7 @@ declare namespace id {
  */
 declare function random$2(): random$2.ReturnType;
 declare namespace random$2 {
-  type ReturnType = Obligation;
+  type ReturnType = Obligation$1;
 }
 /**
  * Creates an obligation from an offer.
@@ -1927,7 +1898,7 @@ declare namespace random$2 {
 declare function fromOffer$1(offer: Offer): fromOffer$1.ReturnType;
 declare namespace fromOffer$1 {
   type Parameters = Offer;
-  type ReturnType = Obligation;
+  type ReturnType = Obligation$1;
 }
 declare class InvalidObligationError extends BaseError<z$1.ZodError | Error> {
   readonly name = "Obligation.InvalidObligationError";
@@ -1937,8 +1908,135 @@ declare class CollateralsAreNotSortedError extends BaseError {
   readonly name = "Obligation.CollateralsAreNotSortedError";
   constructor();
 }
+declare namespace Id_d_exports {
+  export { Obligation, creationCode, toId };
+}
+type Obligation = Obligation$1;
+/**
+ * Builds the same creation code as `IdLib.creationCode` in Solidity.
+ *
+ * Layout: `prefix (11 bytes) + chainId (32 bytes) + morphoV2 (20 bytes) + abi.encode(obligation)`.
+ *
+ * @param parameters - {@link creationCode.Parameters}
+ * @returns The CREATE2 init code bytes. {@link creationCode.ReturnType}
+ */
+declare function creationCode(parameters: creationCode.Parameters): creationCode.ReturnType;
+declare namespace creationCode {
+  type Parameters = {
+    obligation: Obligation;
+    chainId: Id;
+    morphoV2: Address;
+  };
+  type ReturnType = Hex;
+}
+/**
+ * Computes the same id as `IdLib.toId` in Solidity.
+ * @param parameters - {@link toId.Parameters}
+ * @returns The obligation id. {@link toId.ReturnType}
+ */
+declare function toId(parameters: toId.Parameters): toId.ReturnType;
+declare namespace toId {
+  type Parameters = creationCode.Parameters;
+  type ReturnType = Hex;
+}
+declare namespace Liquidity_d_exports {
+  export { LiquidityLink, LiquidityPool, OfferLiquidityPool, calculateMaxDebt, generateAllowancePoolId, generateBalancePoolId, generateDebtPoolId, generateMarketLiquidityPoolId, generateObligationCollateralPoolId, 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: Hex;
+  poolId: string;
+  /**
+   * The available capacity/liquidity from this pool for this offer.
+   * Matches allowance amount from pool below.
+   */
+  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 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 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 Offer_d_exports {
-  export { InvalidOfferError, Offer, OfferConsumed, OfferInput, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$1 as decode, domain, encode$1 as encode, from$10 as from, fromSnakeCase$1 as fromSnakeCase, hash, obligationId, random$1 as random, serialize, takeEvent, toSnakeCase, types };
+  export { InvalidOfferError, Offer, OfferConsumed, OfferInput, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$1 as decode, encode$1 as encode, from$10 as from, fromSnakeCase$1 as fromSnakeCase, hash, liquidateEvent, obligationId, random$1 as random, repayEvent, serialize, supplyCollateralEvent, takeEvent, toSnakeCase, withdrawCollateralEvent };
 }
 type Offer = {
   /** The address that made the offer. */readonly maker: Address; /** The amount of assets offered. Mutually exclusive with obligationUnits and obligationShares. */
@@ -1951,14 +2049,14 @@ type Offer = {
   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 buy: boolean; /** 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;
-  };
+  }; /** Receiver of loan token proceeds when maker is seller on `take()`. */
+  readonly receiverIfMakerIsSeller: Address;
 };
 declare enum Status {
   VALID = "VALID",
@@ -1966,6 +2064,7 @@ declare enum Status {
 }
 type Validation = {
   offerHash: Hex;
+  obligationId: Hex;
   status: Status;
 };
 declare const OfferSchema: () => z$1.ZodObject<{
@@ -1980,7 +2079,6 @@ declare const OfferSchema: () => z$1.ZodObject<{
   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>>;
@@ -1991,6 +2089,7 @@ declare const OfferSchema: () => 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>;
+  receiverIfMakerIsSeller: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
 }, z$1.core.$strip>;
 /**
  * Input type for creating offers. Accepts flexible group types that will be coerced to Hex.
@@ -2003,12 +2102,12 @@ declare const OfferSchema: () => z$1.ZodObject<{
  *
  * All values validated to be non-negative and within bytes32 range.
  */
-type OfferInput = Compute<Omit<Offer, "chainId" | "group" | "session" | "obligationUnits" | "obligationShares"> & {
-  chainId: number;
+type OfferInput = Compute<Omit<Offer, "group" | "session" | "obligationUnits" | "obligationShares" | "receiverIfMakerIsSeller"> & {
   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;
+  obligationShares?: bigint; /** Optional: defaults to maker for backward compatibility. */
+  receiverIfMakerIsSeller?: Address;
 }>;
 /**
  * Creates an offer from a plain object.
@@ -2026,9 +2125,9 @@ declare namespace from$10 {
  * @param input - The offer to create.
  * @returns The created offer.
  */
-declare function fromSnakeCase$1(input: Snake<Omit<Offer, "chainId" | "session"> & {
-  chainId: number;
-  session: string;
+declare function fromSnakeCase$1(input: Snake<Omit<Offer, "session" | "receiverIfMakerIsSeller"> & {
+  session?: Hex;
+  receiverIfMakerIsSeller?: Address;
 }>): Offer;
 /**
  * Converts an offer to a snake case object.
@@ -2055,7 +2154,6 @@ declare const serialize: (offer: Offer) => {
   group: `0x${string}`;
   session: `0x${string}`;
   buy: boolean;
-  chainId: Id;
   loanToken: `0x${string}`;
   collaterals: {
     asset: `0x${string}`;
@@ -2066,10 +2164,10 @@ declare const serialize: (offer: Offer) => {
     address: `0x${string}`;
     data: `0x${string}`;
   };
+  receiverIfMakerIsSeller: `0x${string}`;
   hash: `0x${string}`;
 };
 type RandomConfig = {
-  chains?: Chain$1[];
   loanTokens?: Address[];
   collateralTokens?: Address[];
   assetsDecimals?: Record<Address, number>;
@@ -2088,6 +2186,7 @@ type RandomConfig = {
     address: Address;
     data: Hex;
   };
+  receiverIfMakerIsSeller?: Address;
   collaterals?: readonly Collateral[];
 };
 /**
@@ -2098,93 +2197,28 @@ type RandomConfig = {
  */
 declare function random$1(config?: RandomConfig): Offer;
 /**
- * Creates an EIP-712 domain object.
- * @param chainId - The chain ID.
- * @returns The EIP-712 domain object.
- */
-declare const domain: (chainId: number) => {
-  chainId: bigint;
-  verifyingContract: "0x0000000000000000000000000000000000000000";
-};
-/**
- * The EIP-712 types for the offer.
- * @warning The ordering of the types should NEVER be changed. The offer hash is computed based on the order of the types.
- * @returns The EIP-712 types.
+ * Computes the canonical chain-agnostic offer hash.
+ * The hash is `keccak256(abi.encode(offer))` using {@link encode}.
+ *
+ * @param offer - Offer payload to hash.
+ * @returns 32-byte offer hash.
  */
-declare const types: {
-  readonly EIP712Domain: readonly [{
-    readonly name: "chainId";
-    readonly type: "uint256";
-  }, {
-    readonly name: "verifyingContract";
-    readonly type: "address";
-  }];
-  readonly Offer: readonly [{
-    readonly name: "maker";
-    readonly type: "address";
-  }, {
-    readonly name: "assets";
-    readonly type: "uint256";
-  }, {
-    readonly name: "obligationUnits";
-    readonly type: "uint256";
-  }, {
-    readonly name: "obligationShares";
-    readonly type: "uint256";
-  }, {
-    readonly name: "tick";
-    readonly type: "uint256";
-  }, {
-    readonly name: "maturity";
-    readonly type: "uint256";
-  }, {
-    readonly name: "expiry";
-    readonly type: "uint256";
-  }, {
-    readonly name: "group";
-    readonly type: "bytes32";
-  }, {
-    readonly name: "session";
-    readonly type: "bytes32";
-  }, {
-    readonly name: "buy";
-    readonly type: "bool";
-  }, {
-    readonly name: "loanToken";
-    readonly type: "address";
-  }, {
-    readonly name: "collaterals";
-    readonly type: "Collateral[]";
-  }, {
-    readonly name: "callback";
-    readonly type: "Callback";
-  }];
-  readonly Collateral: readonly [{
-    readonly name: "asset";
-    readonly type: "address";
-  }, {
-    readonly name: "oracle";
-    readonly type: "address";
-  }, {
-    readonly name: "lltv";
-    readonly type: "uint256";
-  }];
-  readonly Callback: readonly [{
-    readonly name: "address";
-    readonly type: "address";
-  }, {
-    readonly name: "data";
-    readonly type: "bytes";
-  }];
-};
 declare function hash(offer: Offer): 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)).
+ * Calculates the onchain obligation id for an offer.
+ * The id is computed with {@link Id.toId}.
  * @param offer - The offer to calculate the obligation id for.
+ * @param parameters - The chain context used by the onchain id function.
  * @returns The obligation id as a 32-byte hex string.
  */
-declare function obligationId(offer: Offer): Hex;
+declare function obligationId(offer: Offer, parameters: obligationId.Parameters): obligationId.ReturnType;
+declare namespace obligationId {
+  type Parameters = {
+    chainId: Id;
+    morphoV2: Address;
+  };
+  type ReturnType = Hex;
+}
 declare function encode$1(offer: Offer): `0x${string}`;
 declare function decode$1(data: Hex): Offer;
 type OfferConsumed = {
@@ -2256,6 +2290,11 @@ declare const takeEvent: {
     readonly type: "bool";
     readonly indexed: false;
     readonly internalType: "bool";
+  }, {
+    readonly name: "sellerReceiver";
+    readonly type: "address";
+    readonly indexed: false;
+    readonly internalType: "address";
   }, {
     readonly name: "group";
     readonly type: "bytes32";
@@ -2293,6 +2332,160 @@ declare const consumedEvent: {
   }];
   readonly anonymous: false;
 };
+/**
+ * ABI for the Repay event emitted by the MorphoV2 contract.
+ */
+declare const repayEvent: {
+  readonly type: "event";
+  readonly name: "Repay";
+  readonly inputs: readonly [{
+    readonly name: "caller";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "obligationUnits";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "onBehalf";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }];
+  readonly anonymous: false;
+};
+/**
+ * ABI for the Liquidate event emitted by the MorphoV2 contract.
+ */
+declare const liquidateEvent: {
+  readonly type: "event";
+  readonly name: "Liquidate";
+  readonly inputs: readonly [{
+    readonly name: "caller";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "seizures";
+    readonly type: "tuple[]";
+    readonly indexed: false;
+    readonly internalType: "struct IMorphoV2.Seizure[]";
+    readonly components: readonly [{
+      readonly name: "collateralIndex";
+      readonly type: "uint256";
+      readonly internalType: "uint256";
+    }, {
+      readonly name: "repaid";
+      readonly type: "uint256";
+      readonly internalType: "uint256";
+    }, {
+      readonly name: "seized";
+      readonly type: "uint256";
+      readonly internalType: "uint256";
+    }];
+  }, {
+    readonly name: "borrower";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "totalRepaid";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "badDebt";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }];
+  readonly anonymous: false;
+};
+/**
+ * ABI for the SupplyCollateral event emitted by the MorphoV2 contract.
+ */
+declare const supplyCollateralEvent: {
+  readonly type: "event";
+  readonly name: "SupplyCollateral";
+  readonly inputs: readonly [{
+    readonly name: "caller";
+    readonly type: "address";
+    readonly indexed: false;
+    readonly internalType: "address";
+  }, {
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "collateral";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "assets";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "onBehalf";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }];
+  readonly anonymous: false;
+};
+/**
+ * ABI for the WithdrawCollateral event emitted by the MorphoV2 contract.
+ */
+declare const withdrawCollateralEvent: {
+  readonly type: "event";
+  readonly name: "WithdrawCollateral";
+  readonly inputs: readonly [{
+    readonly name: "caller";
+    readonly type: "address";
+    readonly indexed: false;
+    readonly internalType: "address";
+  }, {
+    readonly name: "id";
+    readonly type: "bytes32";
+    readonly indexed: true;
+    readonly internalType: "bytes32";
+  }, {
+    readonly name: "collateral";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "assets";
+    readonly type: "uint256";
+    readonly indexed: false;
+    readonly internalType: "uint256";
+  }, {
+    readonly name: "onBehalf";
+    readonly type: "address";
+    readonly indexed: true;
+    readonly internalType: "address";
+  }, {
+    readonly name: "receiver";
+    readonly type: "address";
+    readonly indexed: false;
+    readonly internalType: "address";
+  }];
+  readonly anonymous: false;
+};
 declare class InvalidOfferError extends BaseError<z$1.ZodError | Error> {
   readonly name = "Offer.InvalidOfferError";
   constructor(error: z$1.ZodError | Error);
@@ -2362,6 +2555,7 @@ declare namespace fromCollateral {
 declare function fromOffer(parameters: fromOffer.Parameters): fromOffer.ReturnType;
 declare namespace fromOffer {
   type Parameters = {
+    chainId: Id;
     offer: Offer;
     blockNumber: number;
     price?: bigint | null;
@@ -2378,6 +2572,7 @@ declare namespace fromOffer {
 declare function fromOffers(parameters: fromOffers.Parameters): fromOffers.ReturnType;
 declare namespace fromOffers {
   type Parameters = {
+    chainId: Id;
     offers: Offer[];
     blockNumber: number;
     price?: bigint | null;
@@ -2416,7 +2611,7 @@ declare namespace Conversion {
   }): bigint;
 }
 declare namespace Position_d_exports {
-  export { Position, Type, from$8 as from };
+  export { Position, Type, from$8 as from, positionTypeId };
 }
 type Position = {
   /** The chain id. */chainId: Id;
@@ -2431,13 +2626,17 @@ type Position = {
   /** The underlying asset of the position.
    * For ERC20 positions, this equals the contract address.
    * For vault positions, this is the vault's underlying asset.
+   * For debt positions, this is the zero address (sentinel).
+   * For collateral positions, this is the collateral token address.
    */
-  asset?: Address; /** The block number at which the position was last updated. */
+  asset: Address; /** The block number at which the position was last updated. */
   blockNumber: number;
 };
 declare enum Type {
   ERC20 = "erc20",
-  VAULT_V1 = "vault_v1"
+  VAULT_V1 = "vault_v1",
+  DEBT_OF = "debtOf",
+  COLLATERAL_OF = "collateralOf"
 }
 /**
  * @constructor
@@ -2453,32 +2652,38 @@ declare namespace from$8 {
     user: Address;
     type: Type;
     balance?: bigint;
-    asset?: Address;
+    asset: Address;
     blockNumber: number;
   };
   type ReturnType = Position;
 }
+/**
+ * Maps a {@link Type} enum value to its 1-based integer ID used in the database.
+ * @param type - The position type.
+ * @returns The 1-based integer ID.
+ */
+declare const positionTypeId: (type: Type) => number;
 declare namespace Quote_d_exports {
-  export { InvalidQuoteError, Quote, QuoteSchema, from$7 as from, fromSnakeCase, random };
+  export { InvalidQuoteError, Quote, QuoteInput, Side, from$7 as from, fromSnakeCase, random };
 }
-type Quote = {
+type Side = {
+  /** The best side tick, or null when no active quote exists. */tick: number | null; /** The side price for the obligation. (18 decimals). */
+  price: bigint;
+};
+type QuoteInput = {
   /** The obligation id. */obligationId: Hex;
   ask: {
-    /** The ask price for the obligation. (18 decimals). */price: bigint;
+    /** The best ask tick, or null when there is no active ask quote. */tick: number | null;
   };
   bid: {
-    /** The bid price for the obligation. (18 decimals). */price: bigint;
+    /** The best bid tick, or null when there is no active bid quote. */tick: number | null;
   };
 };
-declare const QuoteSchema: z$1.ZodObject<{
-  obligationId: z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>;
-  ask: z$1.ZodObject<{
-    price: z$1.ZodBigInt;
-  }, z$1.core.$strip>;
-  bid: z$1.ZodObject<{
-    price: z$1.ZodBigInt;
-  }, z$1.core.$strip>;
-}, z$1.core.$strip>;
+type Quote = {
+  /** The obligation id. */obligationId: Hex;
+  ask: Side;
+  bid: Side;
+};
 /**
  * Creates a quote for a given obligation.
  * @constructor
@@ -2488,12 +2693,12 @@ declare const QuoteSchema: z$1.ZodObject<{
  *
  * @example
  * ```ts
- * const quote = Quote.from({ obligationId: "0x123", ask: { price: 100n }, bid: { price: 100n } });
+ * const quote = Quote.from({ obligationId: "0x123", ask: { tick: 500 }, bid: { tick: 510 } });
  * ```
  */
 declare function from$7(parameters: from$7.Parameters): from$7.ReturnType;
 declare namespace from$7 {
-  type Parameters = Quote;
+  type Parameters = QuoteInput;
   type ReturnType = Quote;
   type ErrorType = InvalidQuoteError;
 }
@@ -2505,7 +2710,7 @@ declare namespace from$7 {
  */
 declare function fromSnakeCase(snake: fromSnakeCase.Parameters): fromSnakeCase.ReturnType;
 declare namespace fromSnakeCase {
-  type Parameters = Snake<Quote>;
+  type Parameters = Snake<QuoteInput>;
   type ReturnType = Quote;
   type ErrorType = from$7.ErrorType;
 }
@@ -2646,6 +2851,8 @@ type Transfer = {
   from: Address;
   to: Address;
   value: bigint;
+  type: Type; /** The underlying asset of the transfer's position. */
+  asset: Address;
   blockNumber: number;
 };
 /**
@@ -2669,6 +2876,8 @@ declare namespace from$5 {
     from: Address;
     to: Address;
     value: bigint;
+    type: Type;
+    asset: Address;
     blockNumber: number;
   };
   type ReturnType = Transfer;
@@ -3132,11 +3341,16 @@ interface paths {
     };
     /**
      * List all obligations
-     * @description Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default.
+     * @description Returns a list of obligations with their current best ask and bid. Sorting is customizable with the sort parameter and defaults to id ascending.
      */
     get: {
       parameters: {
         query?: {
+          /**
+           * @description Sort order as comma-separated fields (`id`, `ask`, `bid`, `maturity`). Prefix with `-` for descending order. Max 3 fields.
+           * @example -ask,bid,maturity
+           */
+          sort?: string;
           /**
            * @description Filter by exact maturity timestamps (comma-separated, unix seconds).
            * @example 1761922800,1764524800
@@ -3163,8 +3377,8 @@ interface paths {
            */
           limit?: number;
           /**
-           * @description Obligation id cursor for pagination.
-           * @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc
+           * @description Pagination cursor in base64url-encoded format.
+           * @example eyJzb3J0IjpbImlkIl0sImlkIjoiMHgxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAiLCJhc2siOiIwIiwiYmlkIjoiMCIsIm1hdHVyaXR5IjoxNzYxOTIyODAwfQ
            */
           cursor?: string;
         };
@@ -3649,7 +3863,8 @@ interface components {
        *           "group": "0x000000000000000000000000000000000000000000000000000000000008b8f4",
        *           "session": "0x0000000000000000000000000000000000000000000000000000000000000000",
        *           "callback": "0x0000000000000000000000000000000000000000",
-       *           "callback_data": "0x"
+       *           "callback_data": "0x",
+       *           "receiver_if_maker_is_seller": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
        *         },
        *         "offer_hash": "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
        *         "obligation_id": "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
@@ -3693,7 +3908,8 @@ interface components {
        *       "group": "0x000000000000000000000000000000000000000000000000000000000008b8f4",
        *       "session": "0x0000000000000000000000000000000000000000000000000000000000000000",
        *       "callback": "0x0000000000000000000000000000000000000000",
-       *       "callback_data": "0x"
+       *       "callback_data": "0x",
+       *       "receiver_if_maker_is_seller": "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
        *     }
        */
       offer: components["schemas"]["OfferDataResponse"]; /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
@@ -3739,7 +3955,8 @@ interface components {
       group: string; /** @example 0x0000000000000000000000000000000000000000000000000000000000000000 */
       session: string; /** @example 0x0000000000000000000000000000000000000000 */
       callback: string; /** @example 0x */
-      callback_data: string;
+      callback_data: string; /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
+      receiver_if_maker_is_seller: string;
     };
     ObligationOfferResponse: {
       /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */loan_token: string;
@@ -3761,7 +3978,7 @@ interface components {
       oracle: string;
     };
     ObligationListResponse: {
-      meta: components["schemas"]["Meta"]; /** @example 0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc */
+      meta: components["schemas"]["Meta"]; /** @example eyJzb3J0IjpbImlkIl0sImlkIjoiMHgxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAiLCJhc2siOiIwIiwiYmlkIjoiMCIsIm1hdHVyaXR5IjoxNzYxOTIyODAwfQ */
       cursor: string | null; /** @description List of obligations with takable offers. */
       data: components["schemas"]["ObligationResponse"][];
     };
@@ -3775,10 +3992,20 @@ interface components {
       bid: components["schemas"]["BidResponse"];
     };
     AskResponse: {
-      /** @example 1000000000000000000 */price: string;
+      /**
+       * @description Best ask tick. Null when there is no active ask quote.
+       * @example 500
+       */
+      tick: number | null; /** @example 1000000000000000000 */
+      price: string;
     };
     BidResponse: {
-      /** @example 1000000000000000000 */price: string;
+      /**
+       * @description Best bid tick. Null when there is no active bid quote.
+       * @example 500
+       */
+      tick: number | null; /** @example 1000000000000000000 */
+      price: string;
     };
     ObligationSingleSuccessResponse: {
       meta: components["schemas"]["Meta"]; /** @example null */
@@ -3905,7 +4132,12 @@ interface components {
       block_number: number;
     };
     ValidateOffersRequest: {
-      /** @description Array of offers in snake_case format. Required, non-empty. */offers: components["schemas"]["ValidateOfferRequest"][];
+      /**
+       * @description Chain id used for chain-scoped validation rules.
+       * @example 1
+       */
+      chain_id: number; /** @description Array of offers in snake_case format. Required, non-empty. */
+      offers: components["schemas"]["ValidateOfferRequest"][];
     };
     ValidateOfferRequest: {
       /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */maker: string; /** @example 369216000000000000000000 */
@@ -3918,8 +4150,7 @@ interface components {
       start: number; /** @example 0x000000000000000000000000000000000000000000000000000000000008b8f4 */
       group: string; /** @example 0x0000000000000000000000000000000000000000000000000000000000000000 */
       session: string; /** @example false */
-      buy: boolean; /** @example 1 */
-      chain_id: number; /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
+      buy: boolean; /** @example 0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078 */
       loan_token: string;
       /**
        * @example [
@@ -3937,7 +4168,8 @@ interface components {
        *       "data": "0x"
        *     }
        */
-      callback: components["schemas"]["ValidateCallbackRequest"];
+      callback: components["schemas"]["ValidateCallbackRequest"]; /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
+      receiver_if_maker_is_seller: string;
     };
     ValidateCollateralRequest: {
       /** @example 0x34Cf890dB685FC536E05652FB41f02090c3fb751 */asset: string; /** @example 0x45093658BE7f90B63D7c359e8f408e503c2D9401 */
@@ -3980,15 +4212,18 @@ type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["c
  * Creates an `ObligationResponse` from a `Obligation`.
  * @constructor
  * @param obligation - {@link Obligation}
+ * @param quote - {@link Quote}
+ * @param chainId - The chain id used to compute `id`.
  * @returns The created `ObligationResponse`. {@link ObligationResponse}
  */
-declare function from$3(obligation: Obligation, quote: Quote): ObligationResponse;
+declare function from$3(obligation: Obligation$1, quote: Quote, chainId: Id): ObligationResponse;
 declare namespace OfferResponse_d_exports {
   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;
+  obligationId: Hex;
   maker: Address;
   assets: bigint;
   obligationUnits: bigint;
@@ -4011,6 +4246,7 @@ type Input = Readonly<{
     address: Address;
     data: Hex;
   };
+  receiverIfMakerIsSeller: Address;
   root?: Hex | undefined;
   proof?: Hex[] | undefined;
   signature?: Hex | undefined;
@@ -4063,7 +4299,8 @@ type PaginationParams = {
 };
 declare namespace getByUser {
   type Parameters = PaginationParams & {
-    /** The user address to get positions for. */user: Address;
+    /** The user address to get positions for. */user: Address; /** The type of position to get. Default is all types. */
+    type?: Type;
   };
   type PositionWithReserved = {
     chainId: Id;
@@ -4132,11 +4369,11 @@ declare const schemas: {
     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>>>;
     types: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodEnum<{
-      oracle: "oracle";
       maturity: "maturity";
       callback: "callback";
       loan_token: "loan_token";
       collateral_token: "collateral_token";
+      oracle: "oracle";
     }>>>>;
     chains: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>>>>;
   }, z$1.core.$strip>;
@@ -4168,6 +4405,7 @@ declare const schemas: {
     loan_tokens: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>>>;
     collateral_tokens: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>>>;
     maturities: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>>>>;
+    sort: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodString>>>;
     limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
   readonly get_obligation: z$1.ZodObject<{
@@ -4183,6 +4421,7 @@ 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<{
+    chain_id: z$1.ZodNumber;
     offers: z$1.ZodArray<z$1.ZodUnknown>;
   }, z$1.core.$strict>;
   readonly get_user_positions: z$1.ZodObject<{
@@ -4284,18 +4523,22 @@ declare namespace getOffers {
 }
 declare function getObligations(apiClient: Client<paths>, parameters?: getObligations.Parameters): Promise<getObligations.ReturnType>;
 declare namespace getObligations {
+  type SortField = "id" | "ask" | "bid" | "maturity";
+  type SortEntry = SortField | `-${SortField}`;
   type Parameters = {
-    /** Pagination cursor is a 32-byte hex string. */cursor?: Hex; /** Maximum number of obligations to return. @default 20 */
+    /** Pagination cursor in base64url-encoded format. */cursor?: string; /** Maximum number of obligations to return. @default 20 */
     limit?: number; /** Filter by chain IDs (comma-separated). */
     chainIds?: number[]; /** Filter by loan token addresses (comma-separated). */
     loanTokens?: Address[]; /** Filter by collateral tokens (comma-separated, matches any collateral). */
     collateralTokens?: Address[]; /** Filter by exact maturity timestamps (comma-separated, unix seconds). */
-    maturities?: number[];
+    maturities?: number[]; /** Sort order entries in priority order. Prefix with '-' for descending. Max 3 fields. */
+    sort?: SortEntry[];
   };
   type ReturnType = {
     obligations: Compute<{
-      /** The obligation id. Uses {@link Obligation.id} to calculate the id.*/id: () => Hex;
-    } & Obligation & Omit<Quote, "obligationId">>[]; /** The pagination cursor. */
+      /** The obligation id returned by the API. */id: Hex; /** The chain id used to compute the obligation id. */
+      chainId: Id;
+    } & Obligation$1 & Omit<Quote, "obligationId">>[]; /** The pagination cursor. */
     cursor: string | null;
   };
   type ErrorType = GetApiErrorType;
@@ -4467,7 +4710,10 @@ type GatekeeperClient = {
     statusCode: number;
     body: ConfigRulesPayload;
   }>; /** Validate offers and return decision results. */
-  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>; /** Base URL for the gatekeeper service. */
+  isAllowed: (parameters: {
+    offers: Offer[];
+    chainId: number;
+  }) => Promise<Result<Offer, string>>; /** Base URL for the gatekeeper service. */
   baseUrl: string;
 };
 type ClientConfig = {
@@ -4483,14 +4729,18 @@ type ClientConfig = {
  */
 declare function createHttpClient(config: ClientConfig): GatekeeperClient;
 declare namespace Gatekeeper_d_exports {
-  export { Gatekeeper, Rules, create };
+  export { Gatekeeper, Rules, RulesFactory, create };
 }
 type Rules = readonly Rule<Offer, string>[];
+type RulesFactory = (chainId: Id) => Rules;
 type Gatekeeper = {
-  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
+  isAllowed: (parameters: {
+    offers: Offer[];
+    chainId: Id;
+  }) => Promise<Result<Offer, string>>;
 };
 type GatekeeperParameters = {
-  rules: Rules;
+  rules: RulesFactory;
 };
 /**
  * Create a gatekeeper instance with the provided rules.
@@ -4500,25 +4750,13 @@ type GatekeeperParameters = {
 declare function create(parameters: GatekeeperParameters): Gatekeeper;
 //#endregion
 //#region src/gatekeeper/morphoRules.d.ts
-declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "mixed_maker"> | Rule<Offer, "amount_mutual_exclusivity"> | Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "loan_token"> | Rule<Offer, "collateral_token"> | Rule<Offer, "oracle">)[];
+declare const morphoRules: (parameters: {
+  chains: Chain$1[];
+  chainId: Id;
+}) => (Rule<Offer, "mixed_maker"> | Rule<Offer, "amount_mutual_exclusivity"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "loan_token"> | Rule<Offer, "collateral_token"> | Rule<Offer, "oracle">)[];
 declare namespace Rules_d_exports {
-  export { ValidityParameters, amountMutualExclusivity, callback, chains, collateralToken, loanToken, maturity, oracle, sameMaker, validity };
+  export { amountMutualExclusivity, callback, collateralToken, loanToken, maturity, oracle, sameMaker };
 }
-type ValidityParameters = {
-  client: PublicClient<Transport, Chain$1>;
-};
-/**
- * set of rules to validate offers.
- *
- * @param _parameters - Validity parameters with chain and client
- * @returns Array of validation rules to evaluate against offers
- */
-declare function validity(_parameters: ValidityParameters): Rule<Offer, "expiry">[];
-declare const chains: ({
-  chains
-}: {
-  chains: Chain$1[];
-}) => Rule<Offer, "chain_ids">;
 declare const maturity: ({
   maturities
 }: {
@@ -4536,9 +4774,11 @@ declare const callback: ({
  * @returns The issue that was found. If the offer is valid, this will be undefined.
  */
 declare const loanToken: ({
-  assetsByChainId
+  assetsByChainId,
+  chainId
 }: {
   assetsByChainId: Partial<Record<Id, Address[]>>;
+  chainId: Id;
 }) => Rule<Offer, "loan_token">;
 /**
  * A validation rule that checks if the offer's collateral tokens are allowed for its chain.
@@ -4546,9 +4786,11 @@ declare const loanToken: ({
  * @returns The issue that was found. If the offer is valid, this will be undefined.
  */
 declare const collateralToken: ({
-  collateralAssetsByChainId
+  collateralAssetsByChainId,
+  chainId
 }: {
   collateralAssetsByChainId: Partial<Record<Id, Address[]>>;
+  chainId: Id;
 }) => Rule<Offer, "collateral_token">;
 /**
  * A validation rule that checks if the offer's oracle addresses are allowed for its chain.
@@ -4556,9 +4798,11 @@ declare const collateralToken: ({
  * @returns The issue that was found. If the offer is valid, this will be undefined.
  */
 declare const oracle: ({
-  oraclesByChainId
+  oraclesByChainId,
+  chainId
 }: {
   oraclesByChainId: Partial<Record<Id, Address[]>>;
+  chainId: Id;
 }) => Rule<Offer, "oracle">;
 /**
  * A batch validation rule that ensures all offers in a tree have the same maker address.
@@ -4764,5 +5008,5 @@ declare namespace index_d_exports$2 {
   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, ChainRegistry_d_exports as ChainRegistry, Collateral_d_exports as Collateral, Compute, ConfigRule, ConfigRulesPayload, ERC4626_d_exports as ERC4626, ErrorPayload, Errors_d_exports as Errors, Format_d_exports as Format, Gatekeeper_d_exports as Gatekeeper, Client_d_exports as GatekeeperClient, 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$1 as RouterClient, Rules_d_exports as Rules, SuccessPayload, Tick_d_exports as Tick, time_d_exports as Time, TradingFee_d_exports as TradingFee, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, ValidateOffersData, ValidateOffersIssues, ValidateOffersSuccess, Gate_d_exports as Validation, ValidationIssue, 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, ConfigRule, ConfigRulesPayload, ERC4626_d_exports as ERC4626, ErrorPayload, Errors_d_exports as Errors, Format_d_exports as Format, Gatekeeper_d_exports as Gatekeeper, Client_d_exports as GatekeeperClient, Id_d_exports as Id, 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$1 as RouterClient, Rules_d_exports as Rules, SuccessPayload, Tick_d_exports as Tick, time_d_exports as Time, TradingFee_d_exports as TradingFee, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, ValidateOffersData, ValidateOffersIssues, ValidateOffersSuccess, Gate_d_exports as Validation, ValidationIssue, morphoRules };
 //# sourceMappingURL=index.browser.d.mts.map