@morpho-dev/router 0.5.0 → 0.6.0

package/dist/index.node.d.ts

@@ -821,7 +821,7 @@ declare function toSnakeCase$1<T>(obj: T): Snake<T>;
 declare function fromSnakeCase$3<T>(obj: Snake<T>): T;
 declare function stringifyBigint<T>(value: T): StringifiedBigint<T>;
 declare namespace Obligation_d_exports {
-  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation, ObligationSchema, from$14 as from, fromSnakeCase$2 as fromSnakeCase, id, random$2 as random };
+  export { CollateralsAreNotSortedError, InvalidObligationError, Obligation, ObligationSchema, from$14 as from, fromOffer$1 as fromOffer, fromSnakeCase$2 as fromSnakeCase, id, random$2 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. */
@@ -929,6 +929,18 @@ declare function random$2(): random$2.ReturnType;
 declare namespace random$2 {
   type ReturnType = Obligation;
 }
+/**
+ * Creates an obligation from an offer.
+ * @constructor
+ *
+ * @param offer - The offer to create the obligation from.
+ * @returns The created obligation. {@link fromOffer.ReturnType}
+ */
+declare function fromOffer$1(offer: Offer): fromOffer$1.ReturnType;
+declare namespace fromOffer$1 {
+  type Parameters = Offer;
+  type ReturnType = Obligation;
+}
 declare class InvalidObligationError extends BaseError<z$1.ZodError | Error> {
   readonly name = "Obligation.InvalidObligationError";
   constructor(error: z$1.ZodError | Error);
@@ -938,7 +950,7 @@ declare class CollateralsAreNotSortedError extends BaseError {
   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$13 as from, fromSnakeCase$1 as fromSnakeCase, hash, obligationId, random$1 as random, serialize, sign, signatureMsg, toSnakeCase, types };
+  export { InvalidOfferError, Offer, OfferConsumed, OfferInput, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$1 as decode, domain, encode$1 as encode, from$13 as from, fromSnakeCase$1 as fromSnakeCase, hash, obligationId, random$1 as random, serialize, toSnakeCase, types };
 }
 type Offer = {
   /** The address that made the offer. */readonly maker: Address; /** The amount of assets offered. Mutually exclusive with obligationUnits and obligationShares. */
@@ -1177,15 +1189,6 @@ declare const types: {
     readonly type: "bytes";
   }];
 };
-/**
- * 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: Offer): Hex;
 /**
  * Calculates the obligation id for an offer based on the smart contract's Obligation struct.
@@ -1243,12 +1246,8 @@ declare class InvalidOfferError extends BaseError<z$1.ZodError | Error> {
    */
   get formattedMessage(): string;
 }
-declare class AccountNotSetError extends BaseError {
-  readonly name = "Offer.AccountNotSetError";
-  constructor();
-}
 declare namespace Oracle_d_exports {
-  export { Conversion, Oracle, from$12 as from };
+  export { Conversion, Oracle, from$12 as from, fromCollateral, fromOffer, fromOffers };
 }
 /**
  * An oracle contract that provides price information for assets.
@@ -1274,6 +1273,55 @@ declare namespace from$12 {
   };
   type ReturnType = Oracle;
 }
+/**
+ * Creates an oracle from a collateral.
+ * @constructor
+ *
+ * @param parameters - {@link fromCollateral.Parameters}
+ * @returns The created oracle. {@link fromCollateral.ReturnType}
+ */
+declare function fromCollateral(parameters: fromCollateral.Parameters): fromCollateral.ReturnType;
+declare namespace fromCollateral {
+  type Parameters = {
+    chainId: Id;
+    collateral: Collateral;
+    blockNumber: number;
+    price?: bigint | null;
+  };
+  type ReturnType = Oracle;
+}
+/**
+ * Creates oracles from a single offer.
+ * @constructor
+ *
+ * @param parameters - {@link fromOffer.Parameters}
+ * @returns The created oracles. {@link fromOffer.ReturnType}
+ */
+declare function fromOffer(parameters: fromOffer.Parameters): fromOffer.ReturnType;
+declare namespace fromOffer {
+  type Parameters = {
+    offer: Offer;
+    blockNumber: number;
+    price?: bigint | null;
+  };
+  type ReturnType = Oracle[];
+}
+/**
+ * Creates oracles from a list of offers.
+ * @constructor
+ *
+ * @param parameters - {@link fromOffers.Parameters}
+ * @returns The created oracles. {@link fromOffers.ReturnType}
+ */
+declare function fromOffers(parameters: fromOffers.Parameters): fromOffers.ReturnType;
+declare namespace fromOffers {
+  type Parameters = {
+    offers: Offer[];
+    blockNumber: number;
+    price?: bigint | null;
+  };
+  type ReturnType = Oracle[];
+}
 /**
  * Conversion utilities for converting between collateral and loan token amounts
  * using oracle prices and LLTV
@@ -1529,7 +1577,7 @@ declare namespace from$8 {
   type ReturnType = Transfer;
 }
 declare namespace Tree_d_exports {
-  export { DecodeError, EncodeError, Proof, Tree, TreeError, VERSION$1 as VERSION, decode, encode, encodeUnsigned, from$7 as from, proofs };
+  export { DecodeError, EncodeError, NormalizedSignatureDomain, Proof, SignatureDomain, SignatureDomainError, Tree, TreeError, VERSION$1 as VERSION, decode, encode, encodeUnsigned, from$7 as from, proofs, signatureDomain, signatureTypes };
 }
 /**
  * A merkle tree of offers built from offer hashes.
@@ -1544,6 +1592,31 @@ type Proof = {
   path: Hex[];
 };
 declare const VERSION$1 = 1;
+type SignatureDomain = {
+  /** Chain id used in the EIP-712 domain. */chainId: number | bigint; /** MorphoV2 contract address used as verifying contract. */
+  verifyingContract: Address;
+};
+/** Normalized Root signature domain (BigInt chain id, lowercase address). */
+type NormalizedSignatureDomain = {
+  chainId: bigint;
+  verifyingContract: Address;
+};
+/**
+ * EIP-712 types for signing the tree root (Root(bytes32 root)).
+ */
+declare const signatureTypes: {
+  readonly EIP712Domain: readonly [{
+    readonly name: "chainId";
+    readonly type: "uint256";
+  }, {
+    readonly name: "verifyingContract";
+    readonly type: "address";
+  }];
+  readonly Root: readonly [{
+    readonly name: "root";
+    readonly type: "bytes32";
+  }];
+};
 /**
  * Builds a Merkle tree from a list of offers.
  *
@@ -1566,6 +1639,11 @@ declare const from$7: (offers: Offer[]) => Tree;
  * @returns Array of proofs - {@link Proof}
  */
 declare const proofs: (tree: Tree) => Proof[];
+/**
+ * Normalizes a Root signature domain (BigInt chain id, lowercase address).
+ * @throws {SignatureDomainError} When the domain is invalid.
+ */
+declare const signatureDomain: (domain: SignatureDomain) => NormalizedSignatureDomain;
 /**
  * Encodes a merkle tree with signature into hex calldata for onchain broadcast.
  *
@@ -1573,15 +1651,21 @@ declare const proofs: (tree: Tree) => Proof[];
  * - `{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
+ * - `{signature}`: 65-byte EIP-712 signature over Root(bytes32 root)
  *
  * 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);
+ * const signature = await wallet.signTypedData({
+ *   account: wallet.account,
+ *   domain: Tree.signatureDomain({ chainId, verifyingContract }),
+ *   types: Tree.signatureTypes,
+ *   primaryType: "Root",
+ *   message: { root: tree.root },
+ * });
+ * const calldata = await Tree.encode(tree, signature, { chainId, verifyingContract });
  * await broadcast(calldata);
  * ```
  *
@@ -1591,16 +1675,23 @@ declare const proofs: (tree: Tree) => Proof[];
  * 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 signature = await wallet.signTypedData({
+ *   account: wallet.account,
+ *   domain: Tree.signatureDomain({ chainId, verifyingContract }),
+ *   types: Tree.signatureTypes,
+ *   primaryType: "Root",
+ *   message: { root: tree.root },
+ * });
  * const calldata = `${partial}${signature.slice(2)}`;
  * ```
  *
  * @param tree - Merkle tree of offers
- * @param signature - EIP-191 signature over raw root bytes
+ * @param signature - EIP-712 signature over Root(bytes32 root)
+ * @param domain - EIP-712 domain with chain id and verifying contract
  * @returns Hex-encoded calldata ready for onchain broadcast
  * @throws {EncodeError} If signature verification fails or root mismatch
  */
-declare const encode: (tree: Tree, signature: Hex) => Promise<Hex>;
+declare const encode: (tree: Tree, signature: Hex, domain: SignatureDomain) => Promise<Hex>;
 /**
  * Encodes a merkle tree without a signature into hex payload for client-side signing.
  *
@@ -1630,15 +1721,16 @@ declare const encodeUnsigned: (tree: Tree) => Hex;
  *
  * @example
  * ```typescript
- * const { tree, signature, signer } = await Tree.decode(calldata);
+ * const { tree, signature, signer } = await Tree.decode(calldata, { chainId, verifyingContract });
  * console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
  * ```
  *
  * @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+ * @param domain - EIP-712 domain with chain id and verifying contract
  * @returns Validated tree, signature, and recovered signer address
  * @throws {DecodeError} If version invalid, signature invalid, or root mismatch
  */
-declare const decode: (encoded: Hex) => Promise<{
+declare const decode: (encoded: Hex, domain: SignatureDomain) => Promise<{
   tree: Tree;
   signature: Hex;
   signer: Address;
@@ -1667,6 +1759,13 @@ declare class DecodeError extends BaseError {
   name: string;
   constructor(reason: string);
 }
+/**
+ * Error thrown when an invalid signature domain is supplied.
+ */
+declare class SignatureDomainError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
 //#endregion
 //#region src/indexer/collectors/Collector.d.ts
 declare const names: readonly ["offers", "consumed_events", "positions", "prices"];
@@ -1800,7 +1899,7 @@ type Row = {
   blockNumber: number;
 };
 type OffersDomain = {
-  /** Create multiple offers. */create: (batches: CreateBatch[]) => Promise<Hex[]>;
+  /** Insert offers (insert-only). */create: (batches: CreateBatch[]) => Promise<Hex[]>;
   /** Delete multiple offers by hashes or block number greater than or equal to the given value on a given chain.
    * @returns the number of offers deleted.
    */
@@ -1809,7 +1908,7 @@ type OffersDomain = {
   } | {
     blockNumberGte: number;
     chainId: Id;
-  }) => Promise<number>; /** Get all offers. */
+  }) => Promise<number>; /** Get offers with collaterals only (no availability/takeable computation). */
   get: (parameters?: GetOffersParams) => Promise<{
     rows: Row[];
     nextCursor: string | null;
@@ -1873,6 +1972,35 @@ declare namespace getOffers$2 {
   };
 }
 //#endregion
+//#region src/database/domains/Callbacks.d.ts
+type CallbackInput = {
+  chainId: Id;
+  contract: Address;
+  user: Address;
+  amount: bigint;
+};
+type OfferCallbacks = {
+  offerHash: Hex;
+  callbacks: CallbackInput[];
+};
+type CallbacksDomain = {
+  /**
+   * Upsert callbacks and their offer associations.
+   * @param inputs - Callback associations grouped by offer hash. {@link OfferCallbacks}
+   */
+  upsert: (inputs: OfferCallbacks[]) => Promise<void>;
+  /**
+   * Delete callback associations by offer hashes.
+   * @param parameters - Offer hashes to delete. {@link DeleteParameters}
+   * @returns Number of rows deleted. {@link DeleteReturnType}
+   */
+  delete: (parameters: DeleteParameters) => Promise<DeleteReturnType>;
+};
+type DeleteParameters = {
+  offers: Hex[];
+};
+type DeleteReturnType = number;
+//#endregion
 //#region src/database/domains/Consumed.d.ts
 type Event = {
   id: string;
@@ -1890,6 +2018,22 @@ type ConsumedDomain = {
   }) => Promise<number>;
 };
 //#endregion
+//#region src/database/domains/Groups.d.ts
+type GroupInput = {
+  chainId: Id;
+  maker: Address;
+  group: Hex;
+  blockNumber: number;
+  consumed?: bigint;
+};
+type GroupsDomain = {
+  /**
+   * Insert groups (insert-only).
+   * @param groups - Groups to insert. {@link GroupInput}
+   */
+  create: (groups: GroupInput[]) => Promise<void>;
+};
+//#endregion
 //#region src/database/domains/Lots.d.ts
 type Lot = {
   chainId: Id;
@@ -1934,6 +2078,15 @@ declare namespace get$3 {
 }
 declare function create$5(db: Core): LotsDomain;
 //#endregion
+//#region src/database/domains/Obligations.d.ts
+type ObligationsDomain = {
+  /**
+   * Insert obligations (insert-only).
+   * @param obligations - Obligations to insert. {@link Obligation.Obligation}
+   */
+  create: (obligations: Obligation[]) => Promise<void>;
+};
+//#endregion
 //#region src/database/domains/Offsets.d.ts
 type Offset = {
   chainId: Id;
@@ -2078,11 +2231,10 @@ type Attestation = {
 type CreateInput = {
   tree: Tree;
   signature: Hex;
-  blockNumber: number;
 };
 type TreesDomain = {
   /**
-   * Creates trees, offers, and attestation links in a single transaction.
+   * Creates trees and attestation links in a single transaction.
    *
    * @param trees - Array of decoded trees with signatures (batch insertion)
    * @returns Array of tree roots that were created/upserted
@@ -2128,9 +2280,12 @@ type Driver = ReturnType<typeof drizzle> | ReturnType<typeof drizzle$1>;
 type Domains = {
   book: BookDomain;
   blocks: BlocksDomain;
+  callbacks: CallbacksDomain;
   offers: OffersDomain;
   consumed: ConsumedDomain;
+  groups: GroupsDomain;
   lots: LotsDomain;
+  obligations: ObligationsDomain;
   offsets: OffsetsDomain;
   oracles: OraclesDomain;
   trees: TreesDomain;
@@ -2225,12 +2380,20 @@ declare function run<T, Name extends string, Rules extends readonly Rule<T, Name
 }): Promise<Result<T, RuleNames<Rules>>>;
 //#endregion
 //#region src/gatekeeper/types.d.ts
-type RuleInfo = {
-  name: string;
-  description: string;
-};
-type RulesProvider = {
-  getRules: () => Promise<RuleInfo[]>;
+type ConfigRule = {
+  type: "maturity";
+  chain_id: Id;
+  name: MaturityType;
+  timestamp: Maturity;
+} | {
+  type: "callback";
+  chain_id: Id;
+  address: Address;
+  callback_type: Exclude<Type$1, Type$1.BuyWithEmptyCallback>;
+} | {
+  type: "loan_token";
+  chain_id: Id;
+  address: Address;
 };
 type ValidationIssue = {
   index: number;
@@ -2245,9 +2408,21 @@ type ValidateOffersIssues = {
   issues: ValidationIssue[];
 };
 type ValidateOffersData = ValidateOffersSuccess | ValidateOffersIssues;
+type CallbackType = Type$1 | "not_supported";
+type CallbackTypesRequest = {
+  callbacks: Array<{
+    chain_id: Id;
+    addresses: Address[];
+  }>;
+};
+type CallbackTypesResponse = Array<{
+  chain_id: Id;
+} & Partial<Record<CallbackType, Address[]>>>;
+type ConfigRulesPayload = SuccessPayload<ConfigRule[]> | ErrorPayload;
 type SuccessPayload<T> = {
   meta: {
     timestamp: string;
+    checksum?: string;
   };
   cursor: string | null;
   data: T;
@@ -2255,6 +2430,7 @@ type SuccessPayload<T> = {
 type ErrorPayload = {
   meta: {
     timestamp: string;
+    checksum?: string;
   };
   error: {
     code: string;
@@ -2265,18 +2441,28 @@ type ErrorPayload = {
 declare namespace Client_d_exports {
   export { ClientConfig, GatekeeperClient, createHttpClient };
 }
-type GatekeeperClient = RulesProvider & {
+type GatekeeperClient = {
   /** Validate offers and return the raw response payload. */validate: (body: unknown) => Promise<{
     statusCode: number;
     body: unknown;
+  }>; /** Get configured rules for supported chains. */
+  getConfigRules: (query?: {
+    cursor?: string;
+    limit?: number | string;
+    types?: Array<ConfigRule["type"]> | ConfigRule["type"];
+  }) => Promise<{
+    statusCode: number;
+    body: ConfigRulesPayload;
   }>; /** Validate offers and return decision results. */
-  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>; /** Base URL for the gatekeeper service. */
+  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>; /** Resolve callback types for callback addresses. */
+  getCallbackTypes: (request: CallbackTypesRequest) => Promise<CallbackTypesResponse>; /** Base URL for the gatekeeper service. */
   baseUrl: string;
 };
 type ClientConfig = {
   baseUrl: string;
   timeoutMs?: number;
   fetchFn?: typeof fetch;
+  originSecret?: string;
 };
 /**
  * Create an HTTP client for a gatekeeper service.
@@ -2528,7 +2714,7 @@ interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/config": {
+  "/v1/config/contracts": {
     parameters: {
       query?: never;
       header?: never;
@@ -2536,12 +2722,28 @@ interface paths {
       cookie?: never;
     };
     /**
-     * Get router configuration
-     * @description Returns chain configurations including contract addresses and supported callback types.
+     * Get indexer contract configuration
+     * @description Returns contract addresses used by indexers (mempool, v2) and multicall for indexed chains.
      */
     get: {
       parameters: {
-        query?: never;
+        query?: {
+          /**
+           * @description Filter by chain IDs (comma-separated).
+           * @example 1,8453
+           */
+          chains?: number[];
+          /**
+           * @description Maximum number of contracts to return (max 1000).
+           * @example 1000
+           */
+          limit?: number;
+          /**
+           * @description Pagination cursor in chain_id:address format (lowercase address).
+           * @example 505050505:0xd946246695a9259f3b33a78629026f61b3ab40af
+           */
+          cursor?: string;
+        };
         header?: never;
         path?: never;
         cookie?: never;
@@ -2553,7 +2755,66 @@ interface paths {
             [name: string]: unknown;
           };
           content: {
-            "application/json": components["schemas"]["ConfigSuccessResponse"];
+            "application/json": components["schemas"]["ConfigContractsSuccessResponse"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/v1/config/rules": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get config rules
+     * @description Returns configured rules for supported chains.
+     */
+    get: {
+      parameters: {
+        query?: {
+          /**
+           * @description Filter by chain IDs (comma-separated).
+           * @example 1,8453
+           */
+          chains?: number[];
+          /**
+           * @description Filter by rule types (comma-separated).
+           * @example maturity,loan_token
+           */
+          types?: string[];
+          /**
+           * @description Maximum number of rules to return (max 1000).
+           * @example 100
+           */
+          limit?: number;
+          /**
+           * @description Pagination cursor in type:chain_id:<value> format.
+           * @example maturity:1:1730415600:end_of_next_month
+           */
+          cursor?: string;
+        };
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Success */200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ConfigRulesSuccessResponse"];
           };
         };
       };
@@ -2974,15 +3235,6 @@ interface paths {
     /**
      * Validate offers
      * @description Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.
-     *
-     *     **Available validation rules:**
-     *     - **parse_error**: Returns when an offer fails to parse due to invalid format or missing required fields
-     *     - **mixed_maker**: Validates that all offers in a batch have the same maker 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 for the offer chain
      */
     post: {
       parameters: {
@@ -3021,6 +3273,56 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/callbacks": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Resolve callback types
+     * @description Returns callback types for callback addresses grouped by chain.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: {
+        content: {
+          "application/json": components["schemas"]["CallbackTypesRequest"];
+        };
+      };
+      responses: {
+        /** @description Success */200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["CallbackTypesSuccessResponse"];
+          };
+        }; /** @description Bad Request */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["BadRequestResponse"];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
 }
 interface components {
   schemas: {
@@ -3058,39 +3360,78 @@ interface components {
        */
       details: Record<string, never>;
     };
-    ConfigSuccessResponse: {
+    ConfigContractsSuccessResponse: {
       meta: components["schemas"]["Meta"]; /** @example null */
       cursor: string | null;
       /**
-       * @description Array of chain configurations for all indexed chains.
+       * @description Indexer contract configuration for all indexed chains.
        * @example [
        *       {
        *         "chain_id": 505050505,
-       *         "contracts": {
-       *           "mempool": "0xD946246695A9259F3B33a78629026F61B3Ab40aF"
-       *         },
-       *         "callbacks": [
-       *           "buy_with_empty_callback"
-       *         ]
+       *         "address": "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
+       *         "name": "mempool"
+       *       },
+       *       {
+       *         "chain_id": 505050505,
+       *         "address": "0x8A409D5D6394fC197c596d4E6E2c35e5d13f8a4d",
+       *         "name": "multicall"
+       *       },
+       *       {
+       *         "chain_id": 505050505,
+       *         "address": "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+       *         "name": "v2"
        *       }
        *     ]
        */
-      data: components["schemas"]["ConfigDataResponse"][];
+      data: components["schemas"]["ConfigContractResponse"][];
     };
-    ConfigDataResponse: {
-      /** @example 505050505 */chain_id: number;
-      contracts: components["schemas"]["ConfigContractsResponse"];
+    ConfigContractResponse: {
+      /** @example 505050505 */chain_id: number; /** @example 0xD946246695A9259F3B33a78629026F61B3Ab40aF */
+      address: string;
       /**
-       * @description Supported callback types for this chain.
+       * @example mempool
+       * @enum {string}
+       */
+      name: "mempool" | "multicall" | "v2";
+    };
+    ConfigRulesSuccessResponse: {
+      meta: components["schemas"]["ConfigRulesMeta"]; /** @example null */
+      cursor: string | null;
+      /**
+       * @description Configured rules returned by the router API.
        * @example [
-       *       "buy_with_empty_callback"
+       *       {
+       *         "type": "maturity",
+       *         "chain_id": 1,
+       *         "name": "end_of_next_month",
+       *         "timestamp": 1730415600
+       *       },
+       *       {
+       *         "type": "callback",
+       *         "chain_id": 1,
+       *         "address": "0x1111111111111111111111111111111111111111",
+       *         "callback_type": "sell_erc20_callback"
+       *       },
+       *       {
+       *         "type": "loan_token",
+       *         "chain_id": 1,
+       *         "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+       *       }
        *     ]
-       * @enum {string}
        */
-      callbacks: "buy_with_empty_callback" | "buy_erc20" | "buy_vault_v1_callback" | "sell_erc20_callback";
+      data: components["schemas"]["ConfigRulesRuleResponse"][];
+    };
+    ConfigRulesMeta: {
+      /** @example 2024-01-01T12:00:00.000Z */timestamp: string; /** @example f1d2d2f924e986ac86fdf7b36c94bcdf */
+      checksum: string;
     };
-    ConfigContractsResponse: {
-      /** @example 0xD946246695A9259F3B33a78629026F61B3Ab40aF */mempool: string;
+    ConfigRulesRuleResponse: {
+      /** @example maturity */type: string; /** @example 1 */
+      chain_id: number; /** @example end_of_next_month */
+      name?: string; /** @example 1730415600 */
+      timestamp?: number; /** @example 0x1111111111111111111111111111111111111111 */
+      address?: string; /** @example sell_erc20_callback */
+      callback_type?: string;
     };
     OfferListResponse: {
       meta: components["schemas"]["Meta"]; /** @example eyJvZmZzZXQiOjEwMH0 */
@@ -3432,6 +3773,84 @@ interface components {
        */
       root: string;
     };
+    CallbackTypesRequest: {
+      /**
+       * @example [
+       *       {
+       *         "chain_id": 1,
+       *         "addresses": [
+       *           "0x1111111111111111111111111111111111111111",
+       *           "0x3333333333333333333333333333333333333333",
+       *           "0x9999999999999999999999999999999999999999"
+       *         ]
+       *       }
+       *     ]
+       */
+      callbacks: components["schemas"]["CallbackTypesChainRequest"][];
+    };
+    CallbackTypesChainRequest: {
+      /** @example 1 */chain_id: number;
+      /**
+       * @example [
+       *       "0x1111111111111111111111111111111111111111",
+       *       "0x3333333333333333333333333333333333333333",
+       *       "0x9999999999999999999999999999999999999999"
+       *     ]
+       */
+      addresses: string[];
+    };
+    CallbackTypesSuccessResponse: {
+      meta: components["schemas"]["Meta"]; /** @example maturity:1:1730415600:end_of_next_month */
+      cursor: string | null;
+      /**
+       * @description Callback types grouped by chain.
+       * @example [
+       *       {
+       *         "chain_id": 1,
+       *         "sell_erc20_callback": [
+       *           "0x1111111111111111111111111111111111111111"
+       *         ],
+       *         "buy_erc20": [
+       *           "0x5555555555555555555555555555555555555555"
+       *         ],
+       *         "buy_vault_v1_callback": [
+       *           "0x3333333333333333333333333333333333333333"
+       *         ],
+       *         "not_supported": [
+       *           "0x9999999999999999999999999999999999999999"
+       *         ]
+       *       }
+       *     ]
+       */
+      data: components["schemas"]["CallbackTypesChainResponse"][];
+    };
+    CallbackTypesChainResponse: {
+      /** @example 1 */chain_id: number;
+      /**
+       * @example [
+       *       "0x3333333333333333333333333333333333333333"
+       *     ]
+       */
+      buy_vault_v1_callback?: string[];
+      /**
+       * @example [
+       *       "0x1111111111111111111111111111111111111111"
+       *     ]
+       */
+      sell_erc20_callback?: string[];
+      /**
+       * @example [
+       *       "0x5555555555555555555555555555555555555555"
+       *     ]
+       */
+      buy_erc20?: string[];
+      /**
+       * @example [
+       *       "0x9999999999999999999999999999999999999999"
+       *     ]
+       */
+      not_supported: string[];
+    };
   };
   responses: never;
   parameters: never;
@@ -3500,6 +3919,9 @@ declare class BooksController {
 declare class ValidateController {
   validateOffers(): Promise<void>;
 }
+declare class CallbacksController {
+  resolveCallbackTypes(): Promise<void>;
+}
 declare class OffersController {
   getOffers(): Promise<void>;
 }
@@ -3508,8 +3930,11 @@ declare class HealthController {
   getCollectorsHealth(): Promise<void>;
   getChainsHealth(): Promise<void>;
 }
-declare class ConfigController {
-  getConfig(): Promise<void>;
+declare class ConfigContractsController {
+  getConfigContracts(): Promise<void>;
+}
+declare class ConfigRulesController {
+  getConfigRules(): Promise<void>;
 }
 declare class ObligationsController {
   getObligations(): Promise<void>;
@@ -3518,10 +3943,7 @@ declare class ObligationsController {
 declare class UsersController {
   getUserPositions(): Promise<void>;
 }
-type OpenApiOptions = {
-  rules?: RuleInfo[];
-};
-declare const OpenApi: (options?: OpenApiOptions) => Promise<OpenAPIDocument>;
+declare const OpenApi: () => Promise<OpenAPIDocument>;
 declare namespace PositionResponse_d_exports {
   export { PositionResponse, PositionWithReserved$1 as PositionWithReserved, from$1 as from };
 }
@@ -3566,6 +3988,21 @@ declare const schemas: {
       false: "false";
     }>, z$1.ZodTransform<boolean, "0" | "1" | "true" | "false">>>;
   }, z$1.core.$strip>;
+  readonly get_config_contracts: z$1.ZodObject<{
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
+    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>;
+  readonly get_config_rules: z$1.ZodObject<{
+    cursor: z$1.ZodOptional<z$1.ZodString>;
+    limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
+    types: z$1.ZodOptional<z$1.ZodPipe<z$1.ZodTransform<{} | null | undefined, unknown>, z$1.ZodArray<z$1.ZodEnum<{
+      maturity: "maturity";
+      callback: "callback";
+      loan_token: "loan_token";
+    }>>>>;
+    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>;
   readonly get_offers: z$1.ZodObject<{
     side: z$1.ZodOptional<z$1.ZodEnum<{
       buy: "buy";
@@ -3599,6 +4036,12 @@ declare const schemas: {
   readonly validate_offers: z$1.ZodObject<{
     offers: z$1.ZodArray<z$1.ZodUnknown>;
   }, z$1.core.$strict>;
+  readonly callback_types: z$1.ZodObject<{
+    callbacks: z$1.ZodArray<z$1.ZodObject<{
+      chain_id: z$1.ZodNumber;
+      addresses: z$1.ZodArray<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<`0x${string}`, string>>>;
+    }, z$1.core.$strict>>;
+  }, 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>;
@@ -3620,6 +4063,7 @@ declare enum STATUS_CODE {
 }
 type Meta = {
   timestamp: string;
+  checksum?: string;
 };
 type ErrorDetail = {
   code: APIErrorCode;
@@ -3646,42 +4090,42 @@ type Payload<T> = SuccessPayload$1<T> | ErrorPayload$1;
 //#region src/api/Controllers/getBook.d.ts
 declare function getBook(params: object, db: Database): Promise<Payload<BookLevelResponse[]>>;
 //#endregion
-//#region src/api/Controllers/getConfig.d.ts
-type ChainConfig = {
+//#region src/api/Controllers/getConfigContracts.d.ts
+declare const CONFIG_CONTRACT_NAMES: readonly ["mempool", "multicall", "v2"];
+type ConfigContractName = (typeof CONFIG_CONTRACT_NAMES)[number];
+type ConfigContract = {
   chain_id: Id;
-  contracts: {
-    mempool: string;
-  };
-  callbacks: string[];
+  address: Address;
+  name: ConfigContractName;
 };
 /**
- * Returns the configuration for all chains the router is indexing.
+ * Returns contract addresses used by indexers (mempool, v2) plus multicall per chain.
+ * @param query - Raw query parameters containing optional chain filters.
  * @param chainRegistry - The chain registry instance. {@link ChainRegistry.ChainRegistry}
- * @returns The configuration for all chains the router is indexing. {@link ApiPayload.Payload<ChainConfig[]>}
+ * @returns The indexer contract configuration. {@link ApiPayload.Payload<ConfigContract[]>}
+ */
+declare function getConfigContracts(query: unknown, chainRegistry: ChainRegistry): Promise<Payload<ConfigContract[]>>;
+//#endregion
+//#region src/api/Controllers/getConfigRules.d.ts
+/**
+ * Returns configured rules for the configured chains.
+ * @param query - Raw query parameters containing filters/cursor/limit.
+ * @param chains - Chains to include in the configured rules.
+ * @returns Config rules response payload. {@link ApiPayload.Payload}
  */
-declare function getConfig(chainRegistry: ChainRegistry): Promise<Payload<ChainConfig[]>>;
+declare function getConfigRules(query: unknown, chains: Chain$1[]): Promise<Payload<ConfigRule[]>>;
 //#endregion
 //#region src/api/Controllers/getDocs.d.ts
 /**
  * Build the OpenAPI document for the router.
- * @param parameters - Includes a {@link RulesProvider} to fetch gatekeeper rules.
  * @returns OpenAPI document. {@link OpenAPIDocument}
  */
-declare function getSwaggerJson({
-  gatekeeper
-}: {
-  gatekeeper: RulesProvider;
-}): Promise<OpenAPIDocument>;
+declare function getSwaggerJson(): Promise<OpenAPIDocument>;
 /**
  * Render the API documentation HTML page.
- * @param parameters - Includes a {@link RulesProvider} to fetch gatekeeper rules.
  * @returns HTML page as string.
  */
-declare function getDocsHtml({
-  gatekeeper
-}: {
-  gatekeeper: RulesProvider;
-}): Promise<string>;
+declare function getDocsHtml(): Promise<string>;
 /**
  * Renders the integrator documentation as HTML.
  * @returns HTML page with the rendered markdown documentation.
@@ -3700,6 +4144,21 @@ declare function getObligation(params: object, db: Database): Promise<Payload<Ob
 declare function getObligations$1(queryParameters: object, db: Database): Promise<Payload<ObligationResponse[]>>;
 //#endregion
 //#region src/api/Controllers/getOffers.d.ts
+type GetOffersQueryParams = {
+  /** Filter by maker address */maker?: Address; /** Cursor string returned by a previous call, for pagination */
+  cursor?: string; /** Page size; defaults to {@link OffersDomain.DEFAULT_LIMIT} */
+  limit?: number;
+};
+/**
+ * Query offers with computed consumed/available/takeable values.
+ * @param db - The database client. {@link Database.Core}
+ * @param parameters - {@link GetOffersQueryParams}
+ * @returns The offers with pagination cursor.
+ */
+declare function getOffersQuery(db: Core, parameters?: GetOffersQueryParams): Promise<{
+  rows: Row[];
+  nextCursor: string | null;
+}>;
 declare function getOffers$1(queryParameters: object, db: Database): Promise<Payload<OfferResponse[]>>;
 //#endregion
 //#region src/api/Controllers/getUserPositions.d.ts
@@ -3710,13 +4169,22 @@ declare function getOffers$1(queryParameters: object, db: Database): Promise<Pay
  * @returns Paginated list of positions with remaining balances.
  */
 declare function getUserPositions(queryParameters: object, db: Database): Promise<Payload<PositionResponse[]>>;
+//#endregion
+//#region src/api/Controllers/resolveCallbackTypes.d.ts
+type CallbackTypesPayload = SuccessPayload$1<CallbackTypesResponse>;
+/**
+ * Resolve callback types for a list of callback addresses grouped by chain.
+ * @param body - Request body with callback addresses. {@link CallbackTypesRequest}
+ * @param chains - Chains to resolve callback types against. {@link Chain.Chain}
+ * @returns Callback types grouped by chain. {@link CallbackTypesPayload}
+ */
+declare function resolveCallbackTypes(body: object, chains: Chain$1[]): Promise<CallbackTypesPayload | ErrorPayload$1>;
 declare namespace Gatekeeper_d_exports {
   export { Gatekeeper, Rules, create };
 }
 type Rules = readonly Rule<Offer, string>[];
 type Gatekeeper = {
   isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
-  getRules: () => Promise<RuleInfo[]>;
 };
 type GatekeeperParameters = {
   rules: Rules;
@@ -3744,10 +4212,10 @@ type ValidateOffersIssuesPayload = SuccessPayload$1<{
 type ValidateOffersResponse = ValidateOffersSuccessPayload | ValidateOffersIssuesPayload;
 declare function validateOffers(body: object, gatekeeper: Gatekeeper): Promise<ValidateOffersResponse | ErrorPayload$1>;
 declare namespace index_d_exports$4 {
-  export { ChainConfig, ValidationIssue$1 as ValidationIssue, getBook, getConfig, getDocsHtml, getHealth, getHealthChains, getHealthCollectors, getIntegratorDocsHtml, getObligation, getObligations$1 as getObligations, getOffers$1 as getOffers, getSwaggerJson, getUserPositions, validateOffers };
+  export { CONFIG_CONTRACT_NAMES, ConfigContract, ConfigContractName, GetOffersQueryParams, ValidationIssue$1 as ValidationIssue, getBook, getConfigContracts, getConfigRules, getDocsHtml, getHealth, getHealthChains, getHealthCollectors, getIntegratorDocsHtml, getObligation, getObligations$1 as getObligations, getOffers$1 as getOffers, getOffersQuery, getSwaggerJson, getUserPositions, resolveCallbackTypes, validateOffers };
 }
 declare namespace RouterApi_d_exports {
-  export { ApiConfig, BookResponse_d_exports as BookResponse, BooksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, ConfigController, index_d_exports$4 as Controllers, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, OpenApiOptions, PositionResponse_d_exports as PositionResponse, RouterApi, RouterStatusResponse, UsersController, ValidateController, create$1 as create, from$5 as from, parse, safeParse };
+  export { ApiConfig, BookResponse_d_exports as BookResponse, BooksController, CallbacksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, ConfigContractsController, ConfigRulesController, index_d_exports$4 as Controllers, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, PositionResponse_d_exports as PositionResponse, RouterApi, RouterStatusResponse, UsersController, ValidateController, create$1 as create, from$5 as from, parse, safeParse };
 }
 declare namespace Client_d_exports$1 {
   export { Client$3 as Client, ConnectOptions, HttpForbiddenError, HttpGetApiFailedError, HttpRateLimitError, HttpUnauthorizedError, InvalidUrlError, connect$1 as connect, getObligations, getOffers };
@@ -4332,23 +4800,6 @@ declare const obligationCollateralsV2: drizzle_orm_pg_core0.PgTableWithColumns<{
       identity: undefined;
       generated: undefined;
     }, {}, {}>;
-    blockNumber: drizzle_orm_pg_core0.PgColumn<{
-      name: "block_number";
-      tableName: EnumTableName.OBLIGATION_COLLATERALS_V2;
-      dataType: "number";
-      columnType: "PgBigInt53";
-      data: number;
-      driverParam: string | number;
-      notNull: true;
-      hasDefault: false;
-      isPrimaryKey: false;
-      isAutoincrement: false;
-      hasRuntimeDefault: false;
-      enumValues: undefined;
-      baseColumn: never;
-      identity: undefined;
-      generated: undefined;
-    }, {}, {}>;
     updatedAt: drizzle_orm_pg_core0.PgColumn<{
       name: "updated_at";
       tableName: EnumTableName.OBLIGATION_COLLATERALS_V2;
@@ -5919,58 +6370,6 @@ declare const merklePaths: drizzle_orm_pg_core0.PgTableWithColumns<{
 declare namespace index_d_exports$2 {
   export { PositionTypes, StatusCode, TABLE_NAMES, TableName, VERSION, VERSIONED_TABLE_NAMES, VersionedTableName, callbacks$1 as callbacks, chains$1 as chains, collectors, consumedEvents, groups, lots, merklePaths, obligationCollateralsV2, obligations, offers, offersCallbacks, offsets, oracles, positionTypes, positions, status, transfers, trees, validations };
 }
-declare namespace GateConfig_d_exports {
-  export { CallbackConfig, GateConfig, assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
-}
-type GateConfig = {
-  callbacks?: CallbackConfig[];
-  maturities?: MaturityType[];
-};
-type CallbackConfig = {
-  type: Type$1.BuyVaultV1Callback;
-  addresses: Address[];
-  vaultFactories: Address[];
-} | {
-  type: Type$1.SellERC20Callback;
-  addresses: Address[];
-} | {
-  type: Type$1.BuyWithEmptyCallback;
-};
-declare function getCallback(chain: Name$1, type: Type$1.BuyVaultV1Callback): Extract<CallbackConfig, {
-  type: Type$1.BuyVaultV1Callback;
-}> | undefined;
-declare function getCallback(chain: Name$1, type: Type$1.SellERC20Callback): Extract<CallbackConfig, {
-  type: Type$1.SellERC20Callback;
-}> | undefined;
-declare function getCallback(chain: Name$1, type: Type$1.BuyWithEmptyCallback): Extract<CallbackConfig, {
-  type: Type$1.BuyWithEmptyCallback;
-}> | undefined;
-declare function getCallback(chain: Name$1, type: Type$1): CallbackConfig | undefined;
-/**
- * Attempts to infer the configured callback type from a callback address on a chain.
- * Skips the empty callback type as it does not carry addresses.
- *
- * @param chain - Chain name for which to infer the callback type
- * @param address - Callback contract address
- * @returns The callback type when found, otherwise undefined
- */
-declare function getCallbackType(chain: Name$1, address: Address): Type$1.BuyWithEmptyCallback | Type$1.BuyVaultV1Callback | Type$1.SellERC20Callback | undefined;
-/**
- * Returns the callback addresses for a given chain and callback type, if it exists.
- * @param chain - Chain name for which to read the validation configuration
- * @param type - Callback type to retrieve
- * @returns The matching callback addresses or an empty array if not configured
- */
-declare function getCallbackTypeAddresses(chain: Name$1, type: Type$1): Address[];
-/**
- * Returns the list of allowed non-empty callback addresses for a chain.
- *
- * @param chain - Chain name
- * @returns Array of allowed callback addresses (lowercased). Empty when none configured
- */
-declare const getCallbackAddresses: (chain: Name$1) => Address[];
-declare const assets: Record<string, Address[]>;
-declare const configs: Record<Name$1, GateConfig>;
 //#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, "token">)[];
@@ -6031,13 +6430,15 @@ declare const amountMutualExclusivity: () => Rule<Offer, "amount_mutual_exclusiv
 type MempoolEVMClientConfig = {
   readonly client: WalletClient;
   readonly mempoolAddress: Address;
+  readonly morphoAddress?: Address;
   readonly blockWindow?: number;
 };
 declare function from(parameters: from.Parameters): from.ReturnType;
 declare namespace from {
   type Parameters = {
     /** The viem client to use. */client: WalletClient; /** The mempool address. */
-    mempoolAddress: Address; /** The block window to use for the mempool. Defaults to 100. */
+    mempoolAddress: Address; /** The MorphoV2 contract address used for signature verification. */
+    morphoAddress?: Address; /** The block window to use for the mempool. Defaults to 100. */
     blockWindow?: number;
   };
   type ReturnType = Client$2;
@@ -6052,7 +6453,7 @@ declare namespace from {
  */
 declare function add(config: MempoolEVMClientConfig, offers: AddParameters): Promise<Hex>;
 declare namespace add {
-  type ErrorType = WalletAccountNotSetError | ViemClientError | InvalidOfferError | ChainIdMismatchError;
+  type ErrorType = WalletAccountNotSetError | ViemClientError | InvalidOfferError | ChainIdMismatchError | MissingMorphoAddressError;
 }
 declare function get(config: MempoolEVMClientConfig, parameters?: GetParameters): AsyncGenerator<{
   offers: Offer[];
@@ -6061,7 +6462,7 @@ declare function get(config: MempoolEVMClientConfig, parameters?: GetParameters)
 declare namespace get {
   type ErrorType = streamOffersReturnType;
 }
-type streamOffersReturnType = WalletAccountNotSetError | ChainIdMismatchError;
+type streamOffersReturnType = WalletAccountNotSetError | ChainIdMismatchError | MissingMorphoAddressError;
 declare class WalletAccountNotSetError extends BaseError {
   name: string;
   constructor();
@@ -6073,6 +6474,10 @@ declare class ChainIdMismatchError extends BaseError {
   name: string;
   constructor(expected: Id, actual: Id);
 }
+declare class MissingMorphoAddressError extends BaseError {
+  name: string;
+  constructor();
+}
 //#endregion
 //#region src/mempool/MempoolClient.d.ts
 type AddParameters = Compute<Omit<Offer, "createdAt">[]>;
@@ -6119,7 +6524,7 @@ declare namespace connect {
   type ErrorType = from.ErrorType;
 }
 declare namespace index_d_exports$1 {
-  export { AddParameters, ChainIdMismatchError, Client$2 as Client, GetParameters, ViemClientError, WalletAccountNotSetError, add, connect, from, get };
+  export { AddParameters, ChainIdMismatchError, Client$2 as Client, GetParameters, MissingMorphoAddressError, ViemClientError, WalletAccountNotSetError, add, connect, from, get };
 }
 //#endregion
 //#region src/utils/BigMath.d.ts
@@ -6254,5 +6659,5 @@ declare namespace index_d_exports$3 {
   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, BookResponse_d_exports as BookResponse, BooksController, Brand, BrandTypeId, Callback_d_exports as Callback, Chain_d_exports as Chain, ChainHealth, ChainRegistry_d_exports as ChainRegistry, ChainsHealthResponse, Collateral_d_exports as Collateral, CollectorHealth, CollectorsHealthResponse, Compute, ConfigController, Database_d_exports as Database, ERC4626_d_exports as ERC4626, ErrorPayload, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, Client_d_exports as GatekeeperClient, Health_d_exports as Health, HealthController, Indexer_d_exports as Indexer, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Logger_d_exports as Logger, Maturity_d_exports as Maturity, index_d_exports$1 as Mempool, Obligation_d_exports as Obligation, ObligationResponse_d_exports as ObligationResponse, ObligationsController, Offer_d_exports as Offer, OfferResponse_d_exports as OfferResponse, OffersController, index_d_exports$2 as OffersSchema, OpenApi, OpenApiOptions, Oracle_d_exports as Oracle, Position_d_exports as Position, PositionResponse_d_exports as PositionResponse, Quote_d_exports as Quote, RouterApi_d_exports as RouterApi, Client_d_exports$1 as RouterClient, RouterStatusResponse, RuleInfo, Rules_d_exports as Rules, RulesProvider, SuccessPayload, time_d_exports as Time, TradingFee_d_exports as TradingFee, Transfer_d_exports as Transfer, Tree_d_exports as Tree, UsersController, index_d_exports$3 as Utils, ValidateController, ValidateOffersData, ValidateOffersIssues, ValidateOffersSuccess, Gate_d_exports as Validation, ValidationIssue, morphoRules, parse, safeParse };
+export { index_d_exports as Abi, BookResponse_d_exports as BookResponse, BooksController, Brand, BrandTypeId, Callback_d_exports as Callback, CallbackType, CallbackTypesRequest, CallbackTypesResponse, CallbacksController, Chain_d_exports as Chain, ChainHealth, ChainRegistry_d_exports as ChainRegistry, ChainsHealthResponse, Collateral_d_exports as Collateral, CollectorHealth, CollectorsHealthResponse, Compute, ConfigContractsController, ConfigRule, ConfigRulesController, ConfigRulesPayload, Database_d_exports as Database, 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, Health_d_exports as Health, HealthController, Indexer_d_exports as Indexer, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Logger_d_exports as Logger, Maturity_d_exports as Maturity, index_d_exports$1 as Mempool, Obligation_d_exports as Obligation, ObligationResponse_d_exports as ObligationResponse, ObligationsController, Offer_d_exports as Offer, OfferResponse_d_exports as OfferResponse, OffersController, index_d_exports$2 as OffersSchema, OpenApi, Oracle_d_exports as Oracle, Position_d_exports as Position, PositionResponse_d_exports as PositionResponse, Quote_d_exports as Quote, RouterApi_d_exports as RouterApi, Client_d_exports$1 as RouterClient, RouterStatusResponse, Rules_d_exports as Rules, SuccessPayload, time_d_exports as Time, TradingFee_d_exports as TradingFee, Transfer_d_exports as Transfer, Tree_d_exports as Tree, UsersController, index_d_exports$3 as Utils, ValidateController, ValidateOffersData, ValidateOffersIssues, ValidateOffersSuccess, Gate_d_exports as Validation, ValidationIssue, morphoRules, parse, safeParse };
 //# sourceMappingURL=index.node.d.ts.map