@morpho-dev/router 0.2.1 → 0.3.0

package/dist/index.node.d.ts

@@ -275,7 +275,7 @@ declare const Morpho: readonly [{
   readonly stateMutability: "view";
 }];
 declare namespace Callback_d_exports {
-  export { CallbackType, decode$3 as decode, decodeBuyVaultV1Callback, decodeSellERC20Callback, encode$3 as encode, encodeBuyVaultV1Callback, encodeSellERC20Callback, isEmptyCallback };
+  export { BuyVaultV1CallbackData, CallbackType, SellERC20CallbackData, decode$3 as decode, decodeBuyVaultV1Callback, decodeSellERC20Callback, encode$3 as encode, encodeBuyVaultV1Callback, encodeSellERC20Callback, isEmptyCallback };
 }
 declare enum CallbackType {
   BuyWithEmptyCallback = "buy_with_empty_callback",
@@ -287,7 +287,16 @@ declare function decode$3(type: CallbackType, data: Hex): {
   contract: Address;
   amount: bigint;
 }[];
-declare function encode$3(type: CallbackType, data: any): Hex;
+type BuyVaultV1CallbackData = {
+  vaults: Address[];
+  amounts: bigint[];
+};
+type SellERC20CallbackData = {
+  collaterals: Address[];
+  amounts: bigint[];
+};
+declare function encode$3(type: CallbackType.BuyVaultV1Callback, data: BuyVaultV1CallbackData): Hex;
+declare function encode$3(type: CallbackType.SellERC20Callback, data: SellERC20CallbackData): Hex;
 declare function decodeBuyVaultV1Callback(data: Hex): Array<{
   contract: Address;
   amount: bigint;
@@ -636,7 +645,7 @@ declare class InvalidOptionError extends BaseError {
   constructor(input: string);
 }
 declare namespace Offer_d_exports {
-  export { AccountNotSetError, InvalidOfferError, Offer, OfferConsumed, OfferHashSchema, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$2 as decode, domain, encode$2 as encode, from$12 as from, fromSnakeCase$2 as fromSnakeCase, hash, obligationId, random$2 as random, sign, signatureMsg, toSnakeCase, types };
+  export { AccountNotSetError, InvalidOfferError, Offer, OfferConsumed, OfferHashSchema, OfferSchema, RandomConfig, Status, Validation, consumedEvent, decode$2 as decode, domain, encode$2 as encode, from$12 as from, fromSnakeCase$2 as fromSnakeCase, hash, obligationId, random$2 as random, serialize, sign, signatureMsg, toSnakeCase, types };
 }
 type Offer = {
   /** The address that made the offer. */
@@ -745,6 +754,37 @@ declare function fromSnakeCase$2(input: Snake<Omit<Offer, "chainId" | "hash"> &
  * @returns The converted offer.
  */
 declare function toSnakeCase(offer: Offer): Snake<Offer>;
+/**
+ * Serializes an offer for merkle tree encoding.
+ * Converts BigInt fields to strings for JSON compatibility.
+ *
+ * @param offer - Offer to serialize
+ * @returns JSON-serializable offer object
+ */
+declare const serialize: (offer: Offer) => {
+  offering: `0x${string}`;
+  assets: string;
+  rate: string;
+  maturity: number;
+  expiry: number;
+  start: number;
+  nonce: string;
+  buy: boolean;
+  chainId: Id;
+  loanToken: `0x${string}`;
+  collaterals: {
+    asset: `0x${string}`;
+    oracle: `0x${string}`;
+    lltv: string;
+  }[];
+  callback: {
+    address: `0x${string}`;
+    data: `0x${string}`;
+    gasLimit: string;
+  };
+  signature: `0x${string}` | undefined;
+  hash: `0x${string}`;
+};
 type RandomConfig = {
   chains?: Chain$1[];
   loanTokens?: Address[];
@@ -1376,46 +1416,148 @@ declare namespace from$7 {
   type ReturnType = Transfer;
 }
 declare namespace Tree_d_exports {
-  export { Tree, VERSION$1 as VERSION, decode$1 as decode, encode$1 as encode, from$6 as from };
+  export { DecodeError, EncodeError, Proof, Tree, TreeError, VERSION$1 as VERSION, decode$1 as decode, encode$1 as encode, encodeUnsigned, from$6 as from, proofs };
 }
+/**
+ * A merkle tree of offers built from offer hashes.
+ * Constructed via {@link from}. The tree root can be signed for onchain broadcast.
+ */
 type Tree = Compute<StandardMerkleTree<[Hex]> & {
+  /** The offers in the tree. */
   offers: Offer[];
+  /** The root of the tree. */
   root: Hex;
 }>;
+type Proof = {
+  /** The offer that the proof is for. */
+  offer: Offer;
+  /** The merkle proof path for the offer. */
+  path: Hex[];
+};
 declare const VERSION$1 = 1;
 /**
  * Builds a Merkle tree from a list of offers.
  *
  * Leaves are the offer `hash` values as `bytes32` and are deterministically
- * ordered in ascending lexicographic order so that the resulting root is stable
- * regardless of the input order.
+ * ordered following the StandardMerkleTree leaf ordering so that the resulting
+ * root is stable regardless of the input order.
  *
  * @param offers - Offers to include in the tree.
  * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+ * @throws {TreeError} If tree building fails due to offer inconsistencies.
  */
 declare const from$6: (offers: Offer[]) => Tree;
 /**
- * Encodes an `Tree` into a Hex string with a version byte prefix and gzipped payload.
+ * Generates merkle proofs for all offers in a tree.
  *
- * - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
- * - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+ * Each proof allows independent verification that an offer is included in the tree
+ * without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
  *
- * @param tree - The offer Merkle tree to encode.
- * @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
- * @throws Error if the given `root` does not match the offers.
+ * @param tree - The {@link Tree} to generate proofs for.
+ * @returns Array of proofs - {@link Proof}
  */
-declare const encode$1: (tree: Tree) => Hex;
+declare const proofs: (tree: Tree) => Proof[];
 /**
- * Decodes a Hex string produced by {@link encode} back into an `Tree`.
+ * Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
+ * - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+ *
+ * Validates signature authenticity and root integrity before encoding.
+ *
+ * @example
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = await Tree.encode(tree, signature);
+ * await broadcast(calldata);
+ * ```
  *
- * - Ensures the first byte version matches {@link VERSION}.
- * - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+ * @example
+ * Manual construction (for advanced users):
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+ * const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = `${partial}${signature.slice(2)}`;
+ * ```
  *
- * @param encoded - Hex string in the form `0x{vv}{zip...}`.
- * @returns A validated `Tree` rebuilt from the offers.
- * @throws Error if the version is invalid or the root does not match the offers.
+ * @param tree - Merkle tree of offers
+ * @param signature - EIP-191 signature over raw root bytes
+ * @returns Hex-encoded calldata ready for onchain broadcast
+ * @throws {EncodeError} If signature verification fails or root mismatch
  */
-declare const decode$1: (encoded: Hex) => Tree;
+declare const encode$1: (tree: Tree, signature: Hex) => Promise<Hex>;
+/**
+ * Encodes a merkle tree without a signature into hex payload for client-side signing.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
+ *
+ * Validates root integrity before encoding.
+ *
+ * @param tree - Merkle tree of offers
+ * @returns Hex-encoded unsigned payload
+ * @throws {EncodeError} If root mismatch
+ */
+declare const encodeUnsigned: (tree: Tree) => Hex;
+/**
+ * Decodes hex calldata into a validated merkle tree.
+ *
+ * Validates signature before decompression for fail-fast rejection of invalid payloads.
+ * Returns the tree with separately validated signature and recovered signer address.
+ *
+ * Validation order:
+ * 1. Version check
+ * 2. Signature verification (fail-fast, before decompression)
+ * 3. Decompression (only if signature valid)
+ * 4. Root verification (computed from offers vs embedded root)
+ *
+ * @example
+ * ```typescript
+ * const { tree, signature, signer } = await Tree.decode(calldata);
+ * console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+ * ```
+ *
+ * @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+ * @returns Validated tree, signature, and recovered signer address
+ * @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+ */
+declare const decode$1: (encoded: Hex) => Promise<{
+  tree: Tree;
+  signature: Hex;
+  signer: Address;
+}>;
+/**
+ * Error thrown during tree building operations.
+ * Indicates structural issues with the tree (missing offers, inconsistent state).
+ */
+declare class TreeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+/**
+ * Error thrown during tree encoding.
+ * Indicates validation failures (signature, root mismatch, mixed makers).
+ */
+declare class EncodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
+/**
+ * Error thrown during tree decoding.
+ * Indicates payload corruption, version mismatch, or validation failures.
+ */
+declare class DecodeError extends BaseError {
+  name: string;
+  constructor(reason: string);
+}
 declare namespace Logger_d_exports {
   export { LogEntry, LogFn, LogLevel, LogLevelValues, Logger, defaultLogger, getLogger, runWithLogger, silentLogger };
 }
@@ -1441,11 +1583,11 @@ declare function getLogger(): Logger;
 //#region src/database/domains/Book.d.ts
 type BookDomain = {
   /** Get aggregated book levels for a given obligation side. */
-  get: (parameters: get$2.Parameters) => Promise<get$2.ReturnType>;
+  get: (parameters: get$4.Parameters) => Promise<get$4.ReturnType>;
   /** Get all offers for a given obligation side with cross-invalidation. */
   getOffers: (parameters: getOffers$2.Parameters) => Promise<getOffers$2.ReturnType>;
 };
-declare namespace get$2 {
+declare namespace get$4 {
   type Parameters = {
     /** The side of the offer. */
     side: "buy" | "sell";
@@ -1598,7 +1740,7 @@ declare function run<T, Name$2 extends string, Rules$1 extends readonly Rule<T,
   chunkSize?: number;
 }): Promise<Result<T, RuleNames<Rules$1>>>;
 declare namespace Gatekeeper_d_exports {
-  export { Gatekeeper, Rules, create$4 as create };
+  export { Gatekeeper, Rules, create$5 as create };
 }
 type Rules = readonly Rule<Offer, string>[];
 type Gatekeeper = {
@@ -1608,7 +1750,7 @@ type Gatekeeper = {
 type GatekeeperParameters = {
   rules: Rules;
 };
-declare function create$4(parameters: GatekeeperParameters): Gatekeeper;
+declare function create$5(parameters: GatekeeperParameters): Gatekeeper;
 declare namespace GateConfig_d_exports {
   export { CallbackConfig, GateConfig, assets$1 as assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
 }
@@ -1663,9 +1805,9 @@ declare const assets$1: 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, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token">)[];
+declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token"> | Rule<Offer, "mixed_maker">)[];
 declare namespace Rules_d_exports {
-  export { ValidityParameters, callback, chains$1 as chains, maturity, token, validity };
+  export { ValidityParameters, callback, chains$1 as chains, maturity, sameMaker, token, validity };
 }
 type ValidityParameters = {
   client: PublicClient<Transport, Chain$1>;
@@ -1704,8 +1846,14 @@ declare const token: ({
 }: {
   assets: Address[];
 }) => Rule<Offer, "token">;
+/**
+ * A batch validation rule that ensures all offers in a tree have the same maker (offering address).
+ * Returns an issue only for the first non-conforming offer.
+ * This rule is signing-agnostic; signer verification is handled at the collector level.
+ */
+declare const sameMaker: () => Rule<Offer, "mixed_maker">;
 declare namespace Indexer_d_exports {
-  export { Indexer, IndexerConfig, create$3 as create, from$5 as from };
+  export { Indexer, IndexerConfig, create$4 as create, from$5 as from };
 }
 type Indexer = {
   start: () => () => void;
@@ -1724,7 +1872,7 @@ type IndexerConfig<client extends PublicClient<Transport, Chain$1, Account | und
   retryDelayMs?: number;
 };
 declare function from$5<client extends PublicClient<Transport, Chain$1, Account | undefined>>(config: IndexerConfig<client>): Indexer;
-declare function create$3<client extends PublicClient<Transport, Chain$1, Account | undefined>>(params: {
+declare function create$4<client extends PublicClient<Transport, Chain$1, Account | undefined>>(params: {
   db: Database;
   collectors: Collector[];
   client: client;
@@ -1782,6 +1930,50 @@ type ConsumedDomain = {
   }) => Promise<number>;
 };
 //#endregion
+//#region src/database/domains/Lots.d.ts
+type Lot = {
+  chainId: Id;
+  user: Address;
+  contract: Address;
+  group: string;
+  lower: bigint;
+  upper: bigint;
+};
+type LotsDomain = {
+  /**
+   * Create or update lots for offers.
+   * Called when offers are created to reserve liquidity on positions.
+   * For each (position, group), keeps only the biggest offer by assets.
+   * If lot exists and new offer is bigger, grows the lot and shifts higher lots.
+   */
+  create: (parameters: create$3.Parameters) => Promise<void>;
+  /**
+   * Get lots with optional filtering.
+   */
+  get: (parameters?: get$3.Parameters) => Promise<Lot[]>;
+};
+declare namespace create$3 {
+  type OfferLotInfo = {
+    positionChainId: Id;
+    positionContract: Address;
+    positionUser: Address;
+    group: string;
+    size: bigint;
+  };
+  type Parameters = OfferLotInfo[];
+  type ReturnType = undefined;
+}
+declare namespace get$3 {
+  type Parameters = {
+    chainId?: Id;
+    user?: Address;
+    contract?: Address;
+    group?: string;
+  };
+  type ReturnType = Lot[];
+}
+declare function create$3(db: Core): LotsDomain;
+//#endregion
 //#region src/database/domains/Offers.d.ts
 type OffersDomain = {
   /** Create multiple offer. */
@@ -1826,6 +2018,30 @@ type GetOffersParams = {
   offering?: Address;
 } & PaginationParams$1;
 //#endregion
+//#region src/database/domains/Offsets.d.ts
+type Offset = {
+  chainId: Id;
+  user: Address;
+  contract: Address;
+  group: string;
+  value: bigint;
+};
+type OffsetsDomain = {
+  /**
+   * Get offsets with optional filtering.
+   */
+  get: (parameters?: get$2.Parameters) => Promise<Offset[]>;
+};
+declare namespace get$2 {
+  type Parameters = {
+    chainId?: Id;
+    user?: Address;
+    contract?: Address;
+    group?: string;
+  };
+  type ReturnType = Offset[];
+}
+//#endregion
 //#region src/database/domains/Oracles.d.ts
 type OraclesDomain = {
   /**
@@ -1916,6 +2132,39 @@ declare namespace create$2 {
 }
 declare const create$2: (db: Core) => TransfersDomain;
 //#endregion
+//#region src/database/domains/Trees.d.ts
+/**
+ * Attestation data for a single offer, containing the merkle root, signature, and proof.
+ */
+type Attestation = {
+  root: Hex;
+  signature: Hex;
+  proof: Hex[];
+};
+/**
+ * Input for creating trees with their signatures.
+ */
+type CreateInput = {
+  tree: Tree;
+  signature: Hex;
+};
+type TreesDomain = {
+  /**
+   * Creates trees, offers, 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
+   */
+  create: (trees: CreateInput[]) => Promise<Hex[]>;
+  /**
+   * Retrieves merkle attestations for execution flow.
+   *
+   * @param hashes - Array of offer hashes to look up
+   * @returns Map of offer hash to attestation (only entries with attestations are included)
+   */
+  getAttestations: (hashes: Hex[]) => Promise<Map<Hex, Attestation>>;
+};
+//#endregion
 //#region src/database/domains/Validations.d.ts
 type GetParams = {
   status?: Status;
@@ -1950,7 +2199,10 @@ type Domains = {
   offers: OffersDomain;
   chains: ChainsDomain;
   consumed: ConsumedDomain;
+  lots: LotsDomain;
+  offsets: OffsetsDomain;
   oracles: OraclesDomain;
+  trees: TreesDomain;
   validations: ValidationsDomain;
   positions: PositionsDomain;
   transfers: TransfersDomain;
@@ -2455,10 +2707,11 @@ interface paths {
     put?: never;
     /**
      * Validate offers
-     * @description Validates offers against router validation rules. Returns validation status for each offer.
+     * @description Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.
      *
      *     **Available validation rules:**
      *     - **parse_error**: Returns when an offer fails to parse due to invalid format or missing required fields
+     *     - **mixed_maker**: Validates that all offers in a batch have the same maker (offering address)
      *     - **chain_ids**: Validates that offer chain is one of: [109111114]
      *     - **maturity**: Validates that offer maturity is one of: [end_of_month, end_of_next_month]
      *     - **callback**: Validates callbacks: buy empty callback is allowed; sell offers must use a non-empty callback; non-empty callbacks must target one of [0x3333333333333333333333333333333333333333, 0x4444444444444444444444444444444444444444, 0x1111111111111111111111111111111111111111, 0x2222222222222222222222222222222222222222]
@@ -2483,7 +2736,7 @@ interface paths {
             [name: string]: unknown;
           };
           content: {
-            "application/json": components["schemas"]["ValidateOffersListResponse"];
+            "application/json": components["schemas"]["ValidationSuccessResponse"];
           };
         };
         /** @description Bad Request */
@@ -2578,10 +2831,15 @@ interface components {
        *           "data": "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
        *           "gas_limit": "500000"
        *         },
-       *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
        *         "consumed": "0",
        *         "takeable": "369216000000000000000000",
-       *         "block_number": 2942933377146801
+       *         "block_number": 2942933377146801,
+       *         "root": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+       *         "proof": [
+       *           "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *           "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *         ],
+       *         "signature": "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400"
        *       }
        *     ]
        */
@@ -2634,6 +2892,15 @@ interface components {
       consumed: string;
       /** @example 2942933377146801 */
       block_number: number;
+      /** @example 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef */
+      root: string | null;
+      /**
+       * @example [
+       *       "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+       *       "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"
+       *     ]
+       */
+      proof: string[] | null;
       /** @example 0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400 */
       signature: string | null;
     };
@@ -2765,13 +3032,8 @@ interface components {
       updated_at: string;
     };
     ValidateOffersRequest: {
-      /** @description Array of offers in snake_case format. Mutually exclusive with 'calldata'. */
-      offers?: components["schemas"]["ValidateOfferRequest"][];
-      /**
-       * @description Encoded tree calldata as a hex string (0x-prefixed). Mutually exclusive with 'offers'.
-       * @example 0x01...
-       */
-      calldata?: string;
+      /** @description Array of offers in snake_case format. Required, non-empty. */
+      offers: components["schemas"]["ValidateOfferRequest"][];
     };
     ValidateOfferRequest: {
       /** @example 0x7b093658BE7f90B63D7c359e8f408e503c2D9401 */
@@ -2813,22 +3075,24 @@ interface components {
        */
       callback: components["schemas"]["OfferCallbackResponse"];
     };
-    ValidateOffersListResponse: {
+    ValidationSuccessResponse: {
       meta: components["schemas"]["Meta"];
       /** @example null */
       cursor: string | null;
-      /** @description Validation results for each offer. */
-      data: components["schemas"]["ValidateOfferResultResponse"][];
+      /** @description Payload and root for client-side signing. */
+      data: components["schemas"]["ValidationSuccessDataResponse"];
     };
-    ValidateOfferResultResponse: {
-      /** @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427 */
-      offer_hash: string;
-      /** @example false */
-      valid: boolean;
-      /** @example parse_error */
-      rule: string | null;
-      /** @example Invalid offer. 'offering': invalid address */
-      message: string | null;
+    ValidationSuccessDataResponse: {
+      /**
+       * @description Unsigned payload: version (1B) + gzip(offers) + root (32B).
+       * @example 0x01789c...
+       */
+      payload: string;
+      /**
+       * @description Merkle tree root to sign with EIP-191.
+       * @example 0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427
+       */
+      root: string;
     };
   };
   responses: never;
@@ -2856,9 +3120,10 @@ type OfferResponse = paths["/v1/offers"]["get"]["responses"]["200"]["content"]["
  * Creates an `OfferResponse` from an `Offer`.
  * @constructor
  * @param offer - {@link Offer}
+ * @param attestation - {@link Attestation}
  * @returns The created `OfferResponse`. {@link OfferResponse}
  */
-declare function from$1(offer: Offer): OfferResponse;
+declare function from$1(offer: Offer, attestation?: Attestation): OfferResponse;
 //#endregion
 //#region src/api/Schema/openapi.d.ts
 declare class BooksController {
@@ -2917,9 +3182,8 @@ declare const schemas: {
     limit: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodPipe<z$1.ZodPipe<z$1.ZodString, z$1.ZodTransform<number, string>>, z$1.ZodNumber>>>;
   }, z$1.core.$strip>;
   readonly validate_offers: z$1.ZodObject<{
-    offers: z$1.ZodAny;
-    calldata: z$1.ZodOptional<z$1.ZodString>;
-  }, z$1.core.$strip>;
+    offers: z$1.ZodArray<z$1.ZodUnknown>;
+  }, z$1.core.$strict>;
 };
 type Action = keyof typeof schemas;
 declare function parse<A extends Action>(action: A, query: unknown): z$1.infer<(typeof schemas)[A]>;
@@ -2989,18 +3253,22 @@ declare function getObligations$1(queryParameters: object, db: Database): Promis
 declare function getOffers$1(queryParameters: object, db: Database): Promise<Payload<OfferResponse[]>>;
 //#endregion
 //#region src/api/Controllers/validateOffers.d.ts
-type ValidateOfferResult = {
-  offer_hash: Hex;
-  valid: true;
-} | {
-  offer_hash: Hex;
-  valid: false;
+type ValidationIssue = {
+  index: number;
   rule: string;
   message: string;
 };
-declare function validateOffers(body: object, gatekeeper: Gatekeeper): Promise<Payload<ValidateOfferResult[]>>;
+type ValidateOffersSuccessPayload = SuccessPayload<{
+  payload: Hex;
+  root: Hex;
+}>;
+type ValidateOffersIssuesPayload = SuccessPayload<{
+  issues: ValidationIssue[];
+}>;
+type ValidateOffersResponse = ValidateOffersSuccessPayload | ValidateOffersIssuesPayload;
+declare function validateOffers(body: object, gatekeeper: Gatekeeper): Promise<ValidateOffersResponse | ErrorPayload>;
 declare namespace index_d_exports$4 {
-  export { ValidateOfferResult, getBook, getDocsHtml, getHealth, getHealthChains, getHealthCollectors, getObligation, getObligations$1 as getObligations, getOffers$1 as getOffers, getSwaggerJson, validateOffers };
+  export { ValidationIssue, getBook, getDocsHtml, getHealth, getHealthChains, getHealthCollectors, getObligation, getObligations$1 as getObligations, getOffers$1 as getOffers, getSwaggerJson, validateOffers };
 }
 declare namespace RouterApi_d_exports {
   export { ApiConfig, BookResponse_d_exports as BookResponse, BooksController, ChainHealth, ChainsHealthResponse, CollectorHealth, CollectorsHealthResponse, index_d_exports$4 as Controllers, HealthController, ObligationResponse_d_exports as ObligationResponse, ObligationsController, OfferResponse_d_exports as OfferResponse, OffersController, OpenApi, OpenApiOptions, RouterApi, RouterStatusResponse, RuleInfo, ValidateController, create, from$4 as from, parse, safeParse };
@@ -3084,7 +3352,12 @@ declare namespace getOffers {
     limit?: number;
   };
   type ReturnType = {
-    offers: Offer[];
+    offers: Compute<Offer & {
+      /** 32-byte merkle root. */
+      root?: Hex;
+      /** Sibling hashes for the merkle proof. */
+      proof?: Hex[];
+    }>[];
     /** The pagination cursor. */
     cursor: string | null;
   };
@@ -3152,9 +3425,13 @@ declare enum EnumTableName {
   VALIDATIONS = "validations",
   COLLECTORS = "collectors",
   CHAINS = "chains",
+  LOTS = "lots",
+  OFFSETS = "offsets",
+  TREES = "trees",
+  MERKLE_PATHS = "merkle_paths",
 }
 declare const TABLE_NAMES: readonly EnumTableName[];
-declare const VERSIONED_TABLE_NAMES: ("\"router_v1.6\".\"obligations\"" | "\"router_v1.6\".\"groups\"" | "\"router_v1.6\".\"consumed_events\"" | "\"router_v1.6\".\"obligation_collaterals_v2\"" | "\"router_v1.6\".\"oracles\"" | "\"router_v1.6\".\"offers\"" | "\"router_v1.6\".\"offers_callbacks\"" | "\"router_v1.6\".\"callbacks\"" | "\"router_v1.6\".\"positions\"" | "\"router_v1.6\".\"transfers\"" | "\"router_v1.6\".\"validations\"" | "\"router_v1.6\".\"collectors\"" | "\"router_v1.6\".\"chains\"")[];
+declare const VERSIONED_TABLE_NAMES: ("\"router_v1.6\".\"obligations\"" | "\"router_v1.6\".\"groups\"" | "\"router_v1.6\".\"consumed_events\"" | "\"router_v1.6\".\"obligation_collaterals_v2\"" | "\"router_v1.6\".\"oracles\"" | "\"router_v1.6\".\"offers\"" | "\"router_v1.6\".\"offers_callbacks\"" | "\"router_v1.6\".\"callbacks\"" | "\"router_v1.6\".\"positions\"" | "\"router_v1.6\".\"transfers\"" | "\"router_v1.6\".\"validations\"" | "\"router_v1.6\".\"collectors\"" | "\"router_v1.6\".\"chains\"" | "\"router_v1.6\".\"lots\"" | "\"router_v1.6\".\"offsets\"" | "\"router_v1.6\".\"trees\"" | "\"router_v1.6\".\"merkle_paths\"")[];
 type TableName = (typeof TABLE_NAMES)[number];
 type VersionedTableName = `"${typeof VERSION}"."${TableName}"`;
 declare const obligations: drizzle_orm_pg_core0.PgTableWithColumns<{
@@ -4155,6 +4432,223 @@ declare const callbacks$1: drizzle_orm_pg_core0.PgTableWithColumns<{
   };
   dialect: "pg";
 }>;
+declare const lots: drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: EnumTableName.LOTS;
+  schema: "router_v1.6";
+  columns: {
+    chainId: drizzle_orm_pg_core0.PgColumn<{
+      name: "chain_id";
+      tableName: EnumTableName.LOTS;
+      dataType: "number";
+      columnType: "PgBigInt53";
+      data: Id;
+      driverParam: string | number;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: Id;
+    }>;
+    user: drizzle_orm_pg_core0.PgColumn<{
+      name: "user";
+      tableName: EnumTableName.LOTS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 42;
+    }>;
+    contract: drizzle_orm_pg_core0.PgColumn<{
+      name: "contract";
+      tableName: EnumTableName.LOTS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 42;
+    }>;
+    group: drizzle_orm_pg_core0.PgColumn<{
+      name: "group";
+      tableName: EnumTableName.LOTS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 66;
+    }>;
+    lower: drizzle_orm_pg_core0.PgColumn<{
+      name: "lower";
+      tableName: EnumTableName.LOTS;
+      dataType: "string";
+      columnType: "PgNumeric";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    upper: drizzle_orm_pg_core0.PgColumn<{
+      name: "upper";
+      tableName: EnumTableName.LOTS;
+      dataType: "string";
+      columnType: "PgNumeric";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+declare const offsets: drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: EnumTableName.OFFSETS;
+  schema: "router_v1.6";
+  columns: {
+    chainId: drizzle_orm_pg_core0.PgColumn<{
+      name: "chain_id";
+      tableName: EnumTableName.OFFSETS;
+      dataType: "number";
+      columnType: "PgBigInt53";
+      data: Id;
+      driverParam: string | number;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      $type: Id;
+    }>;
+    user: drizzle_orm_pg_core0.PgColumn<{
+      name: "user";
+      tableName: EnumTableName.OFFSETS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 42;
+    }>;
+    contract: drizzle_orm_pg_core0.PgColumn<{
+      name: "contract";
+      tableName: EnumTableName.OFFSETS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 42;
+    }>;
+    group: drizzle_orm_pg_core0.PgColumn<{
+      name: "group";
+      tableName: EnumTableName.OFFSETS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 66;
+    }>;
+    value: drizzle_orm_pg_core0.PgColumn<{
+      name: "value";
+      tableName: EnumTableName.OFFSETS;
+      dataType: "string";
+      columnType: "PgNumeric";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
 declare const PositionTypes: drizzle_orm_pg_core0.PgEnum<[Type, ...Type[]]>;
 declare const positionTypes: drizzle_orm_pg_core0.PgTableWithColumns<{
   name: "position_types";
@@ -4776,8 +5270,149 @@ declare const chains: drizzle_orm_pg_core0.PgTableWithColumns<{
   };
   dialect: "pg";
 }>;
+declare const trees: drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: EnumTableName.TREES;
+  schema: "router_v1.6";
+  columns: {
+    root: drizzle_orm_pg_core0.PgColumn<{
+      name: "root";
+      tableName: EnumTableName.TREES;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 66;
+    }>;
+    rootSignature: drizzle_orm_pg_core0.PgColumn<{
+      name: "root_signature";
+      tableName: EnumTableName.TREES;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 132;
+    }>;
+    createdAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "created_at";
+      tableName: EnumTableName.TREES;
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+declare const merklePaths: drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: EnumTableName.MERKLE_PATHS;
+  schema: "router_v1.6";
+  columns: {
+    offerHash: drizzle_orm_pg_core0.PgColumn<{
+      name: "offer_hash";
+      tableName: EnumTableName.MERKLE_PATHS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 66;
+    }>;
+    treeRoot: drizzle_orm_pg_core0.PgColumn<{
+      name: "tree_root";
+      tableName: EnumTableName.MERKLE_PATHS;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 66;
+    }>;
+    proofNodes: drizzle_orm_pg_core0.PgColumn<{
+      name: "proof_nodes";
+      tableName: EnumTableName.MERKLE_PATHS;
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    createdAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "created_at";
+      tableName: EnumTableName.MERKLE_PATHS;
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
 declare namespace index_d_exports$2 {
-  export { PositionTypes, StatusCode, TABLE_NAMES, TableName, VERSION, VERSIONED_TABLE_NAMES, VersionedTableName, callbacks$1 as callbacks, chains, collectors, consumedEvents, groups, obligationCollateralsV2, obligations, offers, offersCallbacks, oracles, positionTypes, positions, status, transfers, validations };
+  export { PositionTypes, StatusCode, TABLE_NAMES, TableName, VERSION, VERSIONED_TABLE_NAMES, VersionedTableName, callbacks$1 as callbacks, chains, collectors, consumedEvents, groups, lots, merklePaths, obligationCollateralsV2, obligations, offers, offersCallbacks, offsets, oracles, positionTypes, positions, status, transfers, trees, validations };
 }
 declare namespace Cursor_d_exports {
   export { Cursor, decode, encode, validate };
@@ -4969,6 +5604,41 @@ declare function poll<data>(fn: ({
 }: {
   interval: () => Promise<number>;
 }): () => boolean;
+declare namespace Random_d_exports {
+  export { address, bool, bytes, float, hex, int, seed, withSeed };
+}
+/**
+ * Runs a function with a deterministic RNG derived from the given seed.
+ */
+declare function withSeed<T>(seed: string, fn: () => T): T;
+/**
+ * Seeds the global RNG for deterministic test runs.
+ */
+declare function seed(seed: string): void;
+/**
+ * Returns a deterministic random float in [0, 1).
+ */
+declare function float(): number;
+/**
+ * Returns a deterministic random integer in [min, maxExclusive).
+ */
+declare function int(maxExclusive: number, min?: number): number;
+/**
+ * Returns a deterministic random boolean.
+ */
+declare function bool(probability?: number): boolean;
+/**
+ * Returns deterministic random bytes.
+ */
+declare function bytes(length: number): Uint8Array;
+/**
+ * Returns a deterministic random hex string for the given byte length.
+ */
+declare function hex(byteLength: number): Hex;
+/**
+ * Returns a deterministic random address.
+ */
+declare function address(): Address;
 //#endregion
 //#region src/utils/retry.d.ts
 declare const retry: <T>(fn: () => Promise<T>, attempts?: number, delayMs?: number) => Promise<T>;
@@ -4981,7 +5651,7 @@ declare function max(): number;
 //#region src/utils/wait.d.ts
 declare function wait(time: number): Promise<unknown>;
 declare namespace index_d_exports$3 {
-  export { BaseError, GlobalErrorType, ReorgError, Snake, time_d_exports as Time, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
+  export { BaseError, GlobalErrorType, Random_d_exports as Random, ReorgError, Snake, time_d_exports as Time, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
 }
 //#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, ChainsHealthResponse, Collateral_d_exports as Collateral, CollectorHealth, CollectorsHealthResponse, Compute, Cursor_d_exports as Cursor, Database_d_exports as Database, ERC4626_d_exports as ERC4626, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, 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, Quote_d_exports as Quote, RouterApi_d_exports as RouterApi, Client_d_exports as RouterClient, RouterStatusResponse, RuleInfo, Rules_d_exports as Rules, time_d_exports as Time, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$3 as Utils, ValidateController, Gate_d_exports as Validation, morphoRules, parse, safeParse };