@morpho-dev/router 0.2.1 → 0.3.0

package/dist/index.browser.d.mts

@@ -6,6 +6,10 @@ import * as z$1 from "zod";
 import { Client } from "openapi-fetch";
 import { Chain } from "viem/chains";
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
+import "@electric-sql/pglite";
+import "drizzle-orm/node-postgres";
+import "drizzle-orm/pglite";
+import "pg";
 
 //#region src/api/Schema/BookResponse.d.ts
 declare namespace BookResponse_d_exports {
@@ -331,7 +335,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",
@@ -343,7 +347,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;
@@ -692,7 +705,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$9 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$9 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. */
@@ -801,6 +814,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[];
@@ -1432,46 +1476,148 @@ declare namespace from$4 {
   type ReturnType = Transfer;
 }
 declare namespace Tree_d_exports {
-  export { Tree, VERSION, decode$1 as decode, encode$1 as encode, from$3 as from };
+  export { DecodeError, EncodeError, Proof, Tree, TreeError, VERSION, decode$1 as decode, encode$1 as encode, encodeUnsigned, from$3 as from, proofs };
 }
+/**
+ * A merkle tree of offers built from offer hashes.
+ * Constructed via {@link from}. The tree root can be signed for onchain broadcast.
+ */
 type Tree = Compute<StandardMerkleTree<[Hex]> & {
+  /** The offers in the tree. */
   offers: Offer[];
+  /** The root of the tree. */
   root: Hex;
 }>;
+type Proof = {
+  /** The offer that the proof is for. */
+  offer: Offer;
+  /** The merkle proof path for the offer. */
+  path: Hex[];
+};
 declare const VERSION = 1;
 /**
  * Builds a Merkle tree from a list of offers.
  *
  * Leaves are the offer `hash` values as `bytes32` and are deterministically
- * ordered in ascending lexicographic order so that the resulting root is stable
- * regardless of the input order.
+ * ordered following the StandardMerkleTree leaf ordering so that the resulting
+ * root is stable regardless of the input order.
  *
  * @param offers - Offers to include in the tree.
  * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+ * @throws {TreeError} If tree building fails due to offer inconsistencies.
  */
 declare const from$3: (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.
+ *
+ * Each proof allows independent verification that an offer is included in the tree
+ * without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+ *
+ * @param tree - The {@link Tree} to generate proofs for.
+ * @returns Array of proofs - {@link Proof}
+ */
+declare const proofs: (tree: Tree) => Proof[];
+/**
+ * Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+ *
+ * Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+ * - `{vv}`: 1-byte version (currently 0x01)
+ * - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+ * - `{root}`: 32-byte merkle root
+ * - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+ *
+ * Validates signature authenticity and root integrity before encoding.
+ *
+ * @example
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = await Tree.encode(tree, signature);
+ * await broadcast(calldata);
+ * ```
+ *
+ * @example
+ * Manual construction (for advanced users):
+ * ```typescript
+ * const tree = Tree.from(offers);
+ * const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+ * const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+ * const signature = await wallet.signMessage({ message: { raw: tree.root } });
+ * const calldata = `${partial}${signature.slice(2)}`;
+ * ```
+ *
+ * @param tree - Merkle tree of offers
+ * @param signature - EIP-191 signature over raw root bytes
+ * @returns Hex-encoded calldata ready for onchain broadcast
+ * @throws {EncodeError} If signature verification fails or root mismatch
+ */
+declare const 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
  *
- * - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
- * - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+ * Validates root integrity before encoding.
  *
- * @param tree - The offer Merkle tree to encode.
- * @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
- * @throws Error if the given `root` does not match the offers.
+ * @param tree - Merkle tree of offers
+ * @returns Hex-encoded unsigned payload
+ * @throws {EncodeError} If root mismatch
  */
-declare const encode$1: (tree: Tree) => Hex;
+declare const encodeUnsigned: (tree: Tree) => Hex;
 /**
- * Decodes a Hex string produced by {@link encode} back into an `Tree`.
+ * Decodes hex calldata into a validated merkle tree.
  *
- * - Ensures the first byte version matches {@link VERSION}.
- * - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+ * Validates signature before decompression for fail-fast rejection of invalid payloads.
+ * Returns the tree with separately validated signature and recovered signer address.
  *
- * @param encoded - Hex string in the form `0x{vv}{zip...}`.
- * @returns A validated `Tree` rebuilt from the offers.
- * @throws Error if the version is invalid or the root does not match the offers.
+ * Validation order:
+ * 1. Version check
+ * 2. Signature verification (fail-fast, before decompression)
+ * 3. Decompression (only if signature valid)
+ * 4. Root verification (computed from offers vs embedded root)
+ *
+ * @example
+ * ```typescript
+ * const { tree, signature, signer } = await Tree.decode(calldata);
+ * console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+ * ```
+ *
+ * @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+ * @returns Validated tree, signature, and recovered signer address
+ * @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+ */
+declare const decode$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 const decode$1: (encoded: Hex) => Tree;
+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);
+}
 //#endregion
 //#region src/api/Schema/generated/swagger.d.ts
 /**
@@ -1842,10 +1988,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]
@@ -1870,7 +2017,7 @@ interface paths {
             [name: string]: unknown;
           };
           content: {
-            "application/json": components["schemas"]["ValidateOffersListResponse"];
+            "application/json": components["schemas"]["ValidationSuccessResponse"];
           };
         };
         /** @description Bad Request */
@@ -1965,10 +2112,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"
        *       }
        *     ]
        */
@@ -2021,6 +2173,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;
     };
@@ -2152,13 +2313,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 */
@@ -2200,22 +2356,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;
@@ -2235,6 +2393,202 @@ type ObligationResponse = paths["/v1/obligations"]["get"]["responses"]["200"]["c
  * @returns The created `ObligationResponse`. {@link ObligationResponse}
  */
 declare function from$2(obligation: Obligation, quote: Quote): ObligationResponse;
+declare namespace Gate_d_exports {
+  export { Batch, Issue, Result, Rule, RuleNames, Single, batch$1 as batch, run, single };
+}
+/**
+ * A validation rule.
+ */
+type Rule<T, Name$1 extends string = string> = {
+  kind: "single";
+  name: Name$1;
+  description: string;
+  run: Single<T, Name$1>;
+} | {
+  kind: "batch";
+  name: Name$1;
+  description: string;
+  run: Batch<T, Name$1>;
+};
+type RuleNames<Rules$1 extends readonly {
+  name: string;
+}[]> = Rules$1[number]["name"];
+/**
+ * A single item validation rule.
+ * @param item - The item to validate.
+ * @returns The issue that was found. If the item is valid, this will be undefined.
+ */
+type Single<T, RuleName extends string> = (item: T) => Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined | Promise<Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined>;
+/**
+ * A batch item validation rule.
+ * @param items - The items to validate.
+ * @returns A map of the items to the issue that was found.
+ */
+type Batch<T, RuleName extends string> = (items: T[]) => Map<number, Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined> | Promise<Map<number, Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined>>;
+/**
+ * Create a validation rule iterating over a single item at a time.
+ * @param name - The name of the rule.
+ * @param description - A human-readable description of the rule.
+ * @param run - The function that validates the rule.
+ * @returns The created rule.
+ */
+declare function single<Name$1 extends string, T>(name: Name$1, description: string, run: Single<T, Name$1>): Rule<T, Name$1>;
+/**
+ * Create a validation rule iterating over a batch of items at a time.
+ * @param name - The name of the rule.
+ * @param description - A human-readable description of the rule.
+ * @param run - The function that validates the rule.
+ * @returns The created rule.
+ */
+declare function batch$1<Name$1 extends string, T>(name: Name$1, description: string, run: Batch<T, Name$1>): Rule<T, Name$1>;
+/**
+ * A validation issue.
+ */
+type Issue<T, RuleName extends string = string> = {
+  /** The name of the rule that caused the issue. */
+  ruleName: RuleName;
+  /** The message of the issue. */
+  message: string;
+  /** The item that was not valid. */
+  item: T;
+};
+/**
+ * The result of a validation.
+ */
+type Result<T, RuleName extends string = string> = {
+  /** The items that were valid. */
+  valid: T[];
+  /** The reports of the failed validations. */
+  issues: Issue<T, RuleName>[];
+};
+declare function run<T, Name$1 extends string, Rules$1 extends readonly Rule<T, Name$1>[]>(parameters: {
+  items: T[];
+  rules: Rules$1;
+  chunkSize?: number;
+}): Promise<Result<T, RuleNames<Rules$1>>>;
+declare namespace Gatekeeper_d_exports {
+  export { Gatekeeper, Rules, create };
+}
+type Rules = readonly Rule<Offer, string>[];
+type Gatekeeper = {
+  rules: Rules;
+  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
+};
+type GatekeeperParameters = {
+  rules: Rules;
+};
+declare function create(parameters: GatekeeperParameters): Gatekeeper;
+declare namespace GateConfig_d_exports {
+  export { CallbackConfig, GateConfig, assets$1 as assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
+}
+type GateConfig = {
+  callbacks?: CallbackConfig[];
+  maturities?: MaturityType[];
+};
+type CallbackConfig = {
+  type: CallbackType.BuyVaultV1Callback;
+  addresses: Address[];
+  vaultFactories: Address[];
+} | {
+  type: CallbackType.SellERC20Callback;
+  addresses: Address[];
+} | {
+  type: CallbackType.BuyWithEmptyCallback;
+};
+declare function getCallback(chain: Name, type: CallbackType.BuyVaultV1Callback): Extract<CallbackConfig, {
+  type: CallbackType.BuyVaultV1Callback;
+}> | undefined;
+declare function getCallback(chain: Name, type: CallbackType.SellERC20Callback): Extract<CallbackConfig, {
+  type: CallbackType.SellERC20Callback;
+}> | undefined;
+declare function getCallback(chain: Name, type: CallbackType.BuyWithEmptyCallback): Extract<CallbackConfig, {
+  type: CallbackType.BuyWithEmptyCallback;
+}> | undefined;
+declare function getCallback(chain: Name, type: CallbackType): 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, address: Address): CallbackType | 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, type: CallbackType): 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) => Address[];
+declare const assets$1: Record<string, Address[]>;
+declare const configs: Record<Name, GateConfig>;
+//#endregion
+//#region src/gatekeeper/morphoRules.d.ts
+declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "mixed_maker"> | Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token">)[];
+declare namespace Rules_d_exports {
+  export { ValidityParameters, callback, chains, maturity, sameMaker, token, validity };
+}
+type ValidityParameters = {
+  client: PublicClient<Transport, Chain$1>;
+};
+/**
+ * set of rules to validate offers.
+ *
+ * @param parameters - Validity parameters with chain and client
+ * @returns Array of validation rules to evaluate against offers
+ */
+declare function validity(parameters: ValidityParameters): (Rule<Offer, "expiry"> | Rule<Offer, "sell_erc20_callback_invalid"> | Rule<Offer, "buy_offers_callback_vault_invalid">)[];
+declare const chains: ({
+  chains
+}: {
+  chains: Chain$1[];
+}) => Rule<Offer, "chain_ids">;
+declare const maturity: ({
+  maturities
+}: {
+  maturities: MaturityType[];
+}) => Rule<Offer, "maturity">;
+declare const callback: ({
+  callbacks,
+  allowedAddresses
+}: {
+  callbacks: CallbackType[];
+  allowedAddresses: Address[];
+}) => Rule<Offer, "callback">;
+/**
+ * A validation rule that checks if the offer's token is allowed.
+ * @param offer - The offer to validate.
+ * @returns The issue that was found. If the offer is valid, this will be undefined.
+ */
+declare const token: ({
+  assets
+}: {
+  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">;
+//#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[];
+};
 declare namespace OfferResponse_d_exports {
   export { OfferResponse, from$1 as from };
 }
@@ -2243,9 +2597,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 {
@@ -2304,9 +2659,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]>;
@@ -2393,7 +2747,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;
   };
@@ -2458,186 +2817,6 @@ type Cursor = {
 declare function validate(cursor: unknown): cursor is Cursor;
 declare function encode(c: Cursor): string;
 declare function decode(token?: string): Cursor | null;
-declare namespace Gate_d_exports {
-  export { Batch, Issue, Result, Rule, RuleNames, Single, batch$1 as batch, run, single };
-}
-/**
- * A validation rule.
- */
-type Rule<T, Name$1 extends string = string> = {
-  kind: "single";
-  name: Name$1;
-  description: string;
-  run: Single<T, Name$1>;
-} | {
-  kind: "batch";
-  name: Name$1;
-  description: string;
-  run: Batch<T, Name$1>;
-};
-type RuleNames<Rules$1 extends readonly {
-  name: string;
-}[]> = Rules$1[number]["name"];
-/**
- * A single item validation rule.
- * @param item - The item to validate.
- * @returns The issue that was found. If the item is valid, this will be undefined.
- */
-type Single<T, RuleName extends string> = (item: T) => Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined | Promise<Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined>;
-/**
- * A batch item validation rule.
- * @param items - The items to validate.
- * @returns A map of the items to the issue that was found.
- */
-type Batch<T, RuleName extends string> = (items: T[]) => Map<number, Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined> | Promise<Map<number, Omit<Issue<T, RuleName>, "ruleName" | "item"> | undefined>>;
-/**
- * Create a validation rule iterating over a single item at a time.
- * @param name - The name of the rule.
- * @param description - A human-readable description of the rule.
- * @param run - The function that validates the rule.
- * @returns The created rule.
- */
-declare function single<Name$1 extends string, T>(name: Name$1, description: string, run: Single<T, Name$1>): Rule<T, Name$1>;
-/**
- * Create a validation rule iterating over a batch of items at a time.
- * @param name - The name of the rule.
- * @param description - A human-readable description of the rule.
- * @param run - The function that validates the rule.
- * @returns The created rule.
- */
-declare function batch$1<Name$1 extends string, T>(name: Name$1, description: string, run: Batch<T, Name$1>): Rule<T, Name$1>;
-/**
- * A validation issue.
- */
-type Issue<T, RuleName extends string = string> = {
-  /** The name of the rule that caused the issue. */
-  ruleName: RuleName;
-  /** The message of the issue. */
-  message: string;
-  /** The item that was not valid. */
-  item: T;
-};
-/**
- * The result of a validation.
- */
-type Result<T, RuleName extends string = string> = {
-  /** The items that were valid. */
-  valid: T[];
-  /** The reports of the failed validations. */
-  issues: Issue<T, RuleName>[];
-};
-declare function run<T, Name$1 extends string, Rules$1 extends readonly Rule<T, Name$1>[]>(parameters: {
-  items: T[];
-  rules: Rules$1;
-  chunkSize?: number;
-}): Promise<Result<T, RuleNames<Rules$1>>>;
-declare namespace GateConfig_d_exports {
-  export { CallbackConfig, GateConfig, assets$1 as assets, configs, getCallback, getCallbackAddresses, getCallbackType, getCallbackTypeAddresses };
-}
-type GateConfig = {
-  callbacks?: CallbackConfig[];
-  maturities?: MaturityType[];
-};
-type CallbackConfig = {
-  type: CallbackType.BuyVaultV1Callback;
-  addresses: Address[];
-  vaultFactories: Address[];
-} | {
-  type: CallbackType.SellERC20Callback;
-  addresses: Address[];
-} | {
-  type: CallbackType.BuyWithEmptyCallback;
-};
-declare function getCallback(chain: Name, type: CallbackType.BuyVaultV1Callback): Extract<CallbackConfig, {
-  type: CallbackType.BuyVaultV1Callback;
-}> | undefined;
-declare function getCallback(chain: Name, type: CallbackType.SellERC20Callback): Extract<CallbackConfig, {
-  type: CallbackType.SellERC20Callback;
-}> | undefined;
-declare function getCallback(chain: Name, type: CallbackType.BuyWithEmptyCallback): Extract<CallbackConfig, {
-  type: CallbackType.BuyWithEmptyCallback;
-}> | undefined;
-declare function getCallback(chain: Name, type: CallbackType): 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, address: Address): CallbackType | 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, type: CallbackType): 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) => Address[];
-declare const assets$1: Record<string, Address[]>;
-declare const configs: Record<Name, GateConfig>;
-declare namespace Gatekeeper_d_exports {
-  export { Gatekeeper, Rules, create };
-}
-type Rules = readonly Rule<Offer, string>[];
-type Gatekeeper = {
-  rules: Rules;
-  isAllowed: (offers: Offer[]) => Promise<Result<Offer, string>>;
-};
-type GatekeeperParameters = {
-  rules: Rules;
-};
-declare function create(parameters: GatekeeperParameters): Gatekeeper;
-//#endregion
-//#region src/gatekeeper/morphoRules.d.ts
-declare const morphoRules: (chains: Chain$1[]) => (Rule<Offer, "chain_ids"> | Rule<Offer, "maturity"> | Rule<Offer, "callback"> | Rule<Offer, "token">)[];
-declare namespace Rules_d_exports {
-  export { ValidityParameters, callback, chains, maturity, token, validity };
-}
-type ValidityParameters = {
-  client: PublicClient<Transport, Chain$1>;
-};
-/**
- * set of rules to validate offers.
- *
- * @param parameters - Validity parameters with chain and client
- * @returns Array of validation rules to evaluate against offers
- */
-declare function validity(parameters: ValidityParameters): (Rule<Offer, "expiry"> | Rule<Offer, "sell_erc20_callback_invalid"> | Rule<Offer, "buy_offers_callback_vault_invalid">)[];
-declare const chains: ({
-  chains
-}: {
-  chains: Chain$1[];
-}) => Rule<Offer, "chain_ids">;
-declare const maturity: ({
-  maturities
-}: {
-  maturities: MaturityType[];
-}) => Rule<Offer, "maturity">;
-declare const callback: ({
-  callbacks,
-  allowedAddresses
-}: {
-  callbacks: CallbackType[];
-  allowedAddresses: Address[];
-}) => Rule<Offer, "callback">;
-/**
- * A validation rule that checks if the offer's token is allowed.
- * @param offer - The offer to validate.
- * @returns The issue that was found. If the offer is valid, this will be undefined.
- */
-declare const token: ({
-  assets
-}: {
-  assets: Address[];
-}) => Rule<Offer, "token">;
 //#endregion
 //#region src/mempool/MempoolEVMClient.d.ts
 declare function from(parameters: from.Parameters): from.ReturnType;
@@ -2775,6 +2954,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>;
@@ -2787,7 +3001,7 @@ declare function max(): number;
 //#region src/utils/wait.d.ts
 declare function wait(time: number): Promise<unknown>;
 declare namespace index_d_exports$2 {
-  export { BaseError, GlobalErrorType, ReorgError, Snake, time_d_exports as Time, batch, batchMulticall, fromSnakeCase$3 as fromSnakeCase, lazy, max$1 as max, min, poll, retry, stringifyBigint, toSnakeCase$1 as toSnakeCase, wait };
+  export { BaseError, GlobalErrorType, 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, Brand, BrandTypeId, Callback_d_exports as Callback, Chain_d_exports as Chain, Collateral_d_exports as Collateral, Compute, Cursor_d_exports as Cursor, ERC4626_d_exports as ERC4626, Errors_d_exports as Errors, Format_d_exports as Format, GateConfig_d_exports as GateConfig, Gatekeeper_d_exports as Gatekeeper, LLTV_d_exports as LLTV, Liquidity_d_exports as Liquidity, Maturity_d_exports as Maturity, MempoolClient_d_exports as Mempool, Obligation_d_exports as Obligation, Offer_d_exports as Offer, Oracle_d_exports as Oracle, Position_d_exports as Position, Quote_d_exports as Quote, index_d_exports$1 as RouterApi, Client_d_exports as RouterClient, Rules_d_exports as Rules, time_d_exports as Time, Transfer_d_exports as Transfer, Tree_d_exports as Tree, index_d_exports$2 as Utils, Gate_d_exports as Validation, morphoRules };