@morpho-dev/router 0.1.11 → 0.1.15

package/dist/index.browser.js

@@ -1,133 +1,323 @@
 'use strict';
 
-var mempool = require('@morpho-dev/mempool');
+var v4 = require('zod/v4');
 var viem = require('viem');
+var actions = require('viem/actions');
+var chains$1 = require('viem/chains');
+var z7 = require('zod');
 var jsBase64 = require('js-base64');
-var v4 = require('zod/v4');
+var accounts = require('viem/accounts');
 var zodOpenapi = require('zod-openapi');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z7__namespace = /*#__PURE__*/_interopNamespace(z7);
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/api/Api/Schema/index.ts
+var Schema_exports = {};
+__export(Schema_exports, {
+  ChainHealth: () => ChainHealth,
+  ChainsHealthResponse: () => ChainsHealthResponse,
+  CollectorHealth: () => CollectorHealth,
+  CollectorsHealthResponse: () => CollectorsHealthResponse,
+  ObligationResponse: () => ObligationResponse_exports,
+  OfferResponse: () => OfferResponse_exports,
+  OpenApi: () => OpenApi,
+  RouterStatusResponse: () => RouterStatusResponse,
+  parse: () => parse,
+  safeParse: () => safeParse
+});
+var CollectorHealth = v4.z.object({
+  name: v4.z.string(),
+  chain_id: v4.z.number(),
+  block_number: v4.z.number().nullable(),
+  updated_at: v4.z.string().nullable(),
+  lag: v4.z.number().nullable(),
+  status: v4.z.enum(["live", "lagging", "unknown"])
+});
+var CollectorsHealthResponse = v4.z.object({
+  collectors: v4.z.array(CollectorHealth)
+});
+var ChainHealth = v4.z.object({
+  chain_id: v4.z.number(),
+  block_number: v4.z.number(),
+  updated_at: v4.z.string()
+});
+var ChainsHealthResponse = v4.z.object({
+  chains: v4.z.array(ChainHealth)
+});
+var RouterStatusResponse = v4.z.object({
+  status: v4.z.enum(["live", "syncing"])
+});
+
+// src/api/Api/Schema/ObligationResponse.ts
+var ObligationResponse_exports = {};
+__export(ObligationResponse_exports, {
+  from: () => from6
+});
+
+// src/core/Abi.ts
+var Abi_exports = {};
+__export(Abi_exports, {
+  ERC4626: () => ERC4626,
+  MetaMorpho: () => MetaMorpho,
+  MetaMorphoFactory: () => MetaMorphoFactory,
+  Morpho: () => Morpho,
+  Oracle: () => Oracle
+});
+var Oracle = [
+  {
+    type: "function",
+    name: "price",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var ERC4626 = [
+  {
+    type: "function",
+    name: "asset",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  }
+];
+var MetaMorphoFactory = [
+  {
+    type: "function",
+    name: "isMetaMorpho",
+    inputs: [{ name: "target", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  }
+];
+var MetaMorpho = [
+  {
+    type: "function",
+    name: "withdrawQueue",
+    inputs: [{ name: "index", type: "uint256" }],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "withdrawQueueLength",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxWithdraw",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var Morpho = [
+  {
+    type: "function",
+    name: "collateralOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "debtOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "market",
+    inputs: [
+      {
+        name: "id",
+        type: "bytes32",
+        internalType: "Id"
+      }
+    ],
+    outputs: [
+      {
+        name: "totalSupplyAssets",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalSupplyShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalBorrowAssets",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalBorrowShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "lastUpdate",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "fee",
+        type: "uint128",
+        internalType: "uint128"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "position",
+    inputs: [
+      {
+        name: "id",
+        type: "bytes32",
+        internalType: "Id"
+      },
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "supplyShares",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "borrowShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "collateral",
+        type: "uint128",
+        internalType: "uint128"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
 
 // src/core/Callback.ts
 var Callback_exports = {};
 __export(Callback_exports, {
   CallbackType: () => CallbackType,
   WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
-  buildLiquidity: () => buildLiquidity,
-  decode: () => decode,
-  encode: () => encode,
-  getCallbackIdForOffer: () => getCallbackIdForOffer
+  decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
+  decodeSellERC20Callback: () => decodeSellERC20Callback,
+  encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
+  encodeSellERC20Callback: () => encodeSellERC20Callback
 });
 var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
   CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-  CallbackType2["SellWithdrawFromWallet"] = "sell_withdraw_from_wallet";
+  CallbackType2["BuyVaultV1Callback"] = "buy_vault_v1_callback";
+  CallbackType2["SellERC20Callback"] = "sell_erc20_callback";
   return CallbackType2;
 })(CallbackType || {});
 var WhitelistedCallbackAddresses = {
   ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
-  ["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */]: [
+  ["buy_vault_v1_callback" /* BuyVaultV1Callback */]: [
+    "0x3333333333333333333333333333333333333333",
+    "0x4444444444444444444444444444444444444444"
+    // @TODO: update once deployed and add mapping per chain if needed
+  ].map((address) => address.toLowerCase()),
+  ["sell_erc20_callback" /* SellERC20Callback */]: [
     "0x1111111111111111111111111111111111111111",
     "0x2222222222222222222222222222222222222222"
     // @TODO: update once deployed and add mapping per chain if needed
   ].map((address) => address.toLowerCase())
 };
-function buildLiquidity(parameters) {
-  switch (parameters.type) {
-    case "buy_with_empty_callback" /* BuyWithEmptyCallback */: {
-      const { user, loanToken, chainId, amount, index = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
-      const amountStr = amount.toString();
-      const id = `${user}-${chainId.toString()}-${parameters.type}-${loanToken}`.toLowerCase();
-      const poolId = `${user}-${chainId.toString()}-${loanToken}`.toLowerCase();
-      return {
-        userPosition: {
-          id,
-          availableLiquidityQueueId: id,
-          user: user.toLowerCase(),
-          chainId,
-          amount: amountStr,
-          updatedAt
-        },
-        queues: [
-          {
-            queue: {
-              queueId: id,
-              availableLiquidityPoolId: poolId,
-              index,
-              callbackAmount: "0",
-              updatedAt
-            },
-            pool: {
-              id: poolId,
-              amount: amountStr,
-              updatedAt
-            }
-          }
-        ]
-      };
-    }
-    case "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */: {
-      const {
-        user,
-        termId,
-        chainId,
-        amount,
-        collaterals,
-        index = 0,
-        updatedAt = /* @__PURE__ */ new Date()
-      } = parameters;
-      const amountStr = amount.toString();
-      const id = `${user}-${chainId.toString()}-${parameters.type}-${termId}`.toLowerCase();
-      return {
-        userPosition: {
-          id,
-          availableLiquidityQueueId: id,
-          user: user.toLowerCase(),
-          chainId,
-          amount: amountStr,
-          updatedAt
-        },
-        queues: collaterals.map((collateral) => {
-          const poolId = `${user}-${chainId.toString()}-${collateral.collateralAddress}`.toLowerCase();
-          return {
-            queue: {
-              queueId: id,
-              availableLiquidityPoolId: poolId,
-              index,
-              callbackAmount: collateral.callbackAmount.toString(),
-              updatedAt
-            },
-            pool: {
-              id: poolId,
-              amount: collateral.balance.toString(),
-              updatedAt
-            }
-          };
-        })
-      };
-    }
-    default: {
-      throw new Error(`CallbackType not implemented`);
+function decodeBuyVaultV1Callback(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [vaults, amounts] = viem.decodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      data
+    );
+    if (vaults.length !== amounts.length) {
+      throw new Error("Mismatched array lengths");
     }
+    return vaults.map((v, i) => ({ vault: v, amount: amounts[i] }));
+  } catch (_) {
+    throw new Error("Invalid BuyVaultV1Callback callback data");
   }
 }
-function getCallbackIdForOffer(offer) {
-  if (offer.buy && offer.callback.data === "0x") {
-    return `${offer.offering}-${offer.chainId.toString()}-${"buy_with_empty_callback" /* BuyWithEmptyCallback */}-${offer.loanToken}`.toLowerCase();
-  }
-  if (!offer.buy && offer.callback.data !== "0x" && WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].includes(
-    offer.callback.address.toLowerCase()
-  )) {
-    return `${offer.offering}-${offer.chainId.toString()}-${"sell_withdraw_from_wallet" /* SellWithdrawFromWallet */}-${mempool.Offer.termId(offer)}`.toLowerCase();
-  }
-  return null;
-}
-function decodeSellWithdrawFromWalletData(data) {
+function decodeSellERC20Callback(data) {
   if (!data || data === "0x") throw new Error("Empty callback data");
   try {
     const [collaterals, amounts] = viem.decodeAbiParameters(
@@ -139,32 +329,449 @@ function decodeSellWithdrawFromWalletData(data) {
     }
     return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
   } catch (_) {
-    throw new Error("Invalid SellWithdrawFromWallet callback data");
+    throw new Error("Invalid SellERC20Callback callback data");
   }
 }
-function decode(parameters) {
-  const { type, data } = parameters;
-  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
-    return decodeSellWithdrawFromWalletData(data);
+function encodeBuyVaultV1Callback(parameters) {
+  return viem.encodeAbiParameters(
+    [{ type: "address[]" }, { type: "uint256[]" }],
+    [parameters.vaults, parameters.amounts]
+  );
+}
+function encodeSellERC20Callback(parameters) {
+  return viem.encodeAbiParameters(
+    [{ type: "address[]" }, { type: "uint256[]" }],
+    [parameters.collaterals, parameters.amounts]
+  );
+}
+
+// src/core/Chain.ts
+var Chain_exports = {};
+__export(Chain_exports, {
+  ChainId: () => ChainId,
+  InvalidBatchSizeError: () => InvalidBatchSizeError,
+  InvalidBlockRangeError: () => InvalidBlockRangeError,
+  InvalidBlockWindowError: () => InvalidBlockWindowError,
+  MissingBlockNumberError: () => MissingBlockNumberError,
+  chainIds: () => chainIds,
+  chainNames: () => chainNames,
+  chains: () => chains,
+  getChain: () => getChain,
+  getWhitelistedChains: () => getWhitelistedChains,
+  streamLogs: () => streamLogs
+});
+
+// src/utils/BigMath.ts
+function max(a, b) {
+  return a > b ? a : b;
+}
+function min(a, b) {
+  return a < b ? a : b;
+}
+
+// src/utils/batch.ts
+function* batch(array2, batchSize) {
+  for (let i = 0; i < array2.length; i += batchSize) {
+    yield array2.slice(i, i + batchSize);
   }
-  throw new Error(`CallbackType not implemented: ${type}`);
 }
-function encode(parameters) {
-  const { type, data } = parameters;
-  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
-    return viem.encodeAbiParameters(
-      [{ type: "address[]" }, { type: "uint256[]" }],
-      [data.collaterals, data.amounts]
+
+// src/utils/Errors.ts
+var Errors_exports = {};
+__export(Errors_exports, {
+  BaseError: () => BaseError
+});
+var BaseError = class _BaseError extends Error {
+  constructor(shortMessage, options = {}) {
+    const details = (() => {
+      if (options.cause instanceof _BaseError) {
+        if (options.cause.details) return options.cause.details;
+        if (options.cause.shortMessage) return options.cause.shortMessage;
+      }
+      if (options.cause && "details" in options.cause && typeof options.cause.details === "string")
+        return options.cause.details;
+      if (options.cause?.message) return options.cause.message;
+      return options.details;
+    })();
+    const message = [
+      shortMessage || "An error occurred.",
+      ...options.metaMessages ? ["", ...options.metaMessages] : [],
+      ...details ? ["", details ? `Details: ${details}` : void 0] : []
+    ].filter((x) => typeof x === "string").join("\n");
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    __publicField(this, "details");
+    __publicField(this, "shortMessage");
+    __publicField(this, "cause");
+    __publicField(this, "name", "BaseError");
+    this.cause = options.cause;
+    this.details = details;
+    this.shortMessage = shortMessage;
+  }
+  walk(fn) {
+    return walk(this, fn);
+  }
+};
+function walk(err, fn) {
+  if (fn?.(err)) return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause) return walk(err.cause, fn);
+  return fn ? null : err;
+}
+
+// src/core/Chain.ts
+var chainNames = ["ethereum", "base", "ethereum-virtual-testnet", "anvil"];
+var ChainId = {
+  ETHEREUM: BigInt(chains$1.mainnet.id),
+  BASE: BigInt(chains$1.base.id),
+  "ETHEREUM-VIRTUAL-TESTNET": 109111114n,
+  ANVIL: 505050505n
+  // random id to not clash with other chains
+};
+var chainIds = new Set(Object.values(ChainId));
+var chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [value, key]));
+function getChain(chainId) {
+  const chainName = chainNameLookup.get(chainId)?.toLowerCase();
+  if (!chainName) {
+    return void 0;
+  }
+  return chains[chainName];
+}
+var getWhitelistedChains = () => {
+  return [chains.ethereum, chains.base, chains["ethereum-virtual-testnet"], chains.anvil];
+};
+var chains = {
+  ethereum: {
+    ...chains$1.mainnet,
+    id: ChainId.ETHEREUM,
+    name: "ethereum",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000",
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x0000000000000000000000000000000000000000",
+      deploymentBlock: 23347674,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+    }
+  },
+  base: {
+    ...chains$1.base,
+    id: ChainId.BASE,
+    name: "base",
+    whitelistedAssets: new Set(
+      [
+        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        // USDC
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000",
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x0000000000000000000000000000000000000000",
+      deploymentBlock: 35449942,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0xFf62A7c278C62eD665133147129245053Bbf5918"
+    }
+  },
+  "ethereum-virtual-testnet": {
+    ...chains$1.mainnet,
+    id: ChainId["ETHEREUM-VIRTUAL-TESTNET"],
+    name: "ethereum-virtual-testnet",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
+    // @TODO: This is mock Consumed contract, update with Terms once stable
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x5b06224f736a57635b5bcb50b8ef178b189107cb",
+      deploymentBlock: 23224302,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+    }
+  },
+  anvil: {
+    ...chains$1.anvil,
+    id: ChainId.ANVIL,
+    name: "anvil",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+    morphoBlue: "0x0000000000000000000000000000000000000000",
+    // Set dynamically in tests
+    mempool: {
+      address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
+      deploymentBlock: 23223727,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0x0000000000000000000000000000000000000000",
+      "v1.1": "0x0000000000000000000000000000000000000000"
+    }
+  }
+};
+var MAX_BATCH_SIZE = 1e4;
+var DEFAULT_BATCH_SIZE = 2500;
+var MAX_BLOCK_WINDOW = 2e3;
+var DEFAULT_BLOCK_WINDOW = 500;
+async function* streamLogs(parameters) {
+  const {
+    client,
+    contractAddress,
+    event,
+    blockNumberGte,
+    blockNumberLte,
+    order = "desc",
+    options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = DEFAULT_BLOCK_WINDOW } = {}
+  } = parameters;
+  if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
+  if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
+  if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
+  const latestBlock = (await actions.getBlock(client, { blockTag: "latest", includeTransactions: false })).number;
+  let toBlock = 0n;
+  if (order === "asc")
+    toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), latestBlock);
+  if (order === "desc")
+    toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+  let fromBlock = 0n;
+  if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+  if (order === "desc")
+    fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
+  if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+  if (order === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
+  if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
+  let streaming = true;
+  while (streaming) {
+    const logs = await actions.getLogs(client, {
+      address: contractAddress,
+      event,
+      fromBlock,
+      toBlock
+    });
+    logs.sort((a, b) => {
+      if (a.blockNumber !== b.blockNumber)
+        return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
+      if (a.transactionIndex !== b.transactionIndex)
+        return order === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
+      return order === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
+    });
+    for (const logBatch of batch(logs, maxBatchSize)) {
+      if (logBatch.length === 0) break;
+      yield {
+        logs: logBatch,
+        blockNumber: logBatch.length === maxBatchSize ? (
+          // if the batch is full, return the last block number, block numbers are always sorted
+          Number(logBatch[logBatch.length - 1]?.blockNumber)
+        ) : (
+          // if the batch is not full, return `toBlock` or `fromBlock` to indicate until which block the logs were fetched
+          order === "asc" ? Number(toBlock) : Number(fromBlock)
+        )
+      };
+    }
+    streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+    if (order === "asc") {
+      fromBlock = min(BigInt(toBlock) + 1n, latestBlock);
+      toBlock = min(fromBlock + BigInt(blockWindow), latestBlock);
+    }
+    if (order === "desc") {
+      const lowerBound = BigInt(blockNumberGte || 0);
+      const windowSize = BigInt(blockWindow);
+      const nextToBlock = max(fromBlock - 1n, lowerBound);
+      const nextFromBlock = max(nextToBlock - windowSize, lowerBound);
+      toBlock = nextToBlock;
+      fromBlock = nextFromBlock;
+    }
+  }
+  yield { logs: [], blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock) };
+  return;
+}
+var InvalidBlockRangeError = class extends BaseError {
+  constructor(fromBlock, toBlock) {
+    super(
+      `Invalid block range while streaming data from chain. From block ${fromBlock} to block ${toBlock}.`
     );
+    __publicField(this, "name", "Chain.InvalidBlockRangeError");
   }
-  throw new Error(`CallbackType not implemented: ${type}`);
+};
+var InvalidBlockWindowError = class extends BaseError {
+  constructor(blockWindow) {
+    super(
+      `Invalid block window while streaming data from chain. Maximum is ${MAX_BLOCK_WINDOW}. Got ${blockWindow}.`
+    );
+    __publicField(this, "name", "Chain.InvalidBlockWindowError");
+  }
+};
+var InvalidBatchSizeError = class extends BaseError {
+  constructor(maxBatchSize) {
+    super(
+      `Invalid batch size while streaming data from chain. Maximum is ${MAX_BATCH_SIZE}. Got ${maxBatchSize}.`
+    );
+    __publicField(this, "name", "Chain.InvalidBatchSizeError");
+  }
+};
+var MissingBlockNumberError = class extends BaseError {
+  constructor() {
+    super("Missing block number when streaming data from chain in ascending order.");
+    __publicField(this, "name", "Chain.MissingBlockNumberError");
+  }
+};
+
+// src/core/Collateral.ts
+var Collateral_exports = {};
+__export(Collateral_exports, {
+  CollateralSchema: () => CollateralSchema,
+  CollateralsSchema: () => CollateralsSchema,
+  from: () => from2
+});
+var transformHex = (val, ctx) => {
+  if (viem.isHex(val)) return val;
+  ctx.addIssue({
+    code: "invalid_format",
+    input: val,
+    format: "hex",
+    error: "not a hex"
+  });
+  return z7__namespace.NEVER;
+};
+var transformAddress = (val, ctx) => {
+  if (viem.isAddress(val.toLowerCase())) return val.toLowerCase();
+  ctx.addIssue({
+    code: "invalid_format",
+    input: val,
+    format: "address",
+    error: "not a valid address"
+  });
+  return z7__namespace.NEVER;
+};
+
+// src/core/LLTV.ts
+var LLTV_exports = {};
+__export(LLTV_exports, {
+  InvalidLLTVError: () => InvalidLLTVError,
+  InvalidOptionError: () => InvalidOptionError,
+  LLTVSchema: () => LLTVSchema,
+  Options: () => Options,
+  from: () => from
+});
+var Options = [0.385, 0.5, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965, 0.98];
+var LLTV_SCALED = Options.map((lltv) => BigInt(lltv * 10 ** 18));
+function from(lltv) {
+  if (typeof lltv === "bigint" && !LLTV_SCALED.includes(lltv)) throw new InvalidLLTVError(lltv);
+  if (typeof lltv === "bigint") return lltv;
+  if (typeof lltv === "number" && !Options.includes(lltv)) throw new InvalidOptionError(lltv);
+  return BigInt(lltv * 10 ** 18);
 }
+var InvalidOptionError = class extends BaseError {
+  constructor(input) {
+    super(
+      `Invalid LLTV option. Input: "${input}". Accepted values are: ${Options.map(
+        (option) => `"${option}"`
+      ).join(", ")}.`
+    );
+    __publicField(this, "name", "LLTV.InvalidOptionError");
+  }
+};
+var InvalidLLTVError = class extends BaseError {
+  constructor(input) {
+    super(
+      `Invalid LLTV. Input: "${input}". Accepted values are: ${LLTV_SCALED.map(
+        (option) => `"${option}"`
+      ).join(", ")}.`
+    );
+    __publicField(this, "name", "LLTV.InvalidLLTVError");
+  }
+};
+var LLTVSchema = z7__namespace.bigint({ coerce: true }).refine(
+  (lltv) => {
+    try {
+      from(lltv);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  },
+  {
+    error: () => {
+      return "Invalid LLTV: must be one of 0.385, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965 or 0.98 (scaled by 1e18)";
+    }
+  }
+).transform((lltv) => from(lltv));
+
+// src/core/Collateral.ts
+var CollateralSchema = z7__namespace.object({
+  asset: z7__namespace.string().transform(transformAddress),
+  oracle: z7__namespace.string().transform(transformAddress),
+  lltv: LLTVSchema
+});
+var CollateralsSchema = z7__namespace.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine(
+  (collaterals) => {
+    for (let i = 1; i < collaterals.length; i++) {
+      if (collaterals[i - 1].asset.toLowerCase() > collaterals[i].asset.toLowerCase()) {
+        return false;
+      }
+    }
+    return true;
+  },
+  {
+    message: "Collaterals must be sorted alphabetically by address"
+  }
+).refine(
+  (collaterals) => {
+    const uniqueAssets = /* @__PURE__ */ new Set();
+    for (const collateral of collaterals) {
+      const assetAddress = collateral.asset.toLowerCase();
+      if (uniqueAssets.has(assetAddress)) {
+        return false;
+      }
+      uniqueAssets.add(assetAddress);
+    }
+    return true;
+  },
+  {
+    message: "Collaterals must not contain duplicate assets"
+  }
+);
+var from2 = (parameters) => {
+  return {
+    asset: parameters.asset.toLowerCase(),
+    lltv: from(parameters.lltv),
+    oracle: parameters.oracle.toLowerCase()
+  };
+};
 
 // src/core/Cursor.ts
 var Cursor_exports = {};
 __export(Cursor_exports, {
-  decode: () => decode2,
-  encode: () => encode2,
+  decode: () => decode,
+  encode: () => encode,
   validate: () => validate
 });
 function validate(cursor) {
@@ -234,12 +841,17 @@ function validate(cursor) {
       `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
     );
   }
+  if (c.page !== void 0) {
+    if (typeof c.page !== "number" || !Number.isInteger(c.page) || c.page < 1) {
+      throw new Error("Invalid page: must be a positive integer");
+    }
+  }
   return true;
 }
-function encode2(c) {
+function encode(c) {
   return jsBase64.Base64.encodeURL(JSON.stringify(c));
 }
-function decode2(token) {
+function decode(token) {
   if (!token) return null;
   const decoded = JSON.parse(jsBase64.Base64.decode(token));
   validate(decoded);
@@ -249,578 +861,780 @@ function decode2(token) {
 // src/core/Liquidity.ts
 var Liquidity_exports = {};
 __export(Liquidity_exports, {
-  fetch: () => fetch2,
-  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
-  serialize: () => serialize
+  calculateMaxDebt: () => calculateMaxDebt,
+  generateAllowancePoolId: () => generateAllowancePoolId,
+  generateBalancePoolId: () => generateBalancePoolId,
+  generateBuyVaultCallbackPoolId: () => generateBuyVaultCallbackPoolId,
+  generateDebtPoolId: () => generateDebtPoolId,
+  generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
+  generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
+  generateSellERC20CallbackPoolId: () => generateSellERC20CallbackPoolId,
+  generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
+  generateVaultPositionPoolId: () => generateVaultPositionPoolId
 });
-async function fetchBalancesAndAllowances(parameters) {
-  const { client, spender, pairs, options } = parameters;
-  if (pairs.length === 0) return /* @__PURE__ */ new Map();
-  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
-  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
-  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
-  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
-  const out = /* @__PURE__ */ new Map();
-  for (const pairsBatch of mempool.Utils.batch(pairs, batchSize)) {
-    const balanceContracts = [];
-    const allowanceContracts = [];
-    for (const { user, token } of pairsBatch) {
-      balanceContracts.push({
-        address: token,
-        abi: viem.erc20Abi,
-        functionName: "balanceOf",
-        args: [user]
-      });
-      allowanceContracts.push({
-        address: token,
-        abi: viem.erc20Abi,
-        functionName: "allowance",
-        args: [user, spender]
-      });
+function calculateMaxDebt(amount, oraclePrice, lltv) {
+  const ORACLE_PRICE_SCALE = 10n ** 36n;
+  const PRECISION = 10n ** 18n;
+  const collateralQuoted = amount * oraclePrice / ORACLE_PRICE_SCALE;
+  const maxDebt = collateralQuoted * lltv / PRECISION;
+  return maxDebt;
+}
+function generateBalancePoolId(parameters) {
+  const { user, chainId, token } = parameters;
+  return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
+}
+function generateAllowancePoolId(parameters) {
+  const { user, chainId, token } = parameters;
+  return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
+}
+function generateSellERC20CallbackPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2, token, offerHash } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
+}
+function generateObligationCollateralPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2, token } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token}-obligation-collateral`.toLowerCase();
+}
+function generateBuyVaultCallbackPoolId(parameters) {
+  const { user, chainId, vault, offerHash } = parameters;
+  return `${user}-${chainId.toString()}-${vault}-${offerHash}-${"buy_vault_v1_callback" /* BuyVaultV1Callback */}`.toLowerCase();
+}
+function generateDebtPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2 } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-debt`.toLowerCase();
+}
+function generateUserVaultPositionPoolId(parameters) {
+  const { user, chainId, vault } = parameters;
+  return `${user}-${chainId.toString()}-${vault}-user-vault-position`.toLowerCase();
+}
+function generateVaultPositionPoolId(parameters) {
+  const { vault, chainId, marketId } = parameters;
+  return `${vault}-${chainId.toString()}-${marketId}-vault-position`.toLowerCase();
+}
+function generateMarketLiquidityPoolId(parameters) {
+  const { chainId, marketId } = parameters;
+  return `${chainId.toString()}-${marketId}-market-liquidity`.toLowerCase();
+}
+
+// src/core/Maturity.ts
+var Maturity_exports = {};
+__export(Maturity_exports, {
+  InvalidDateError: () => InvalidDateError,
+  InvalidFormatError: () => InvalidFormatError,
+  InvalidOptionError: () => InvalidOptionError2,
+  MaturitySchema: () => MaturitySchema,
+  from: () => from3
+});
+var MaturitySchema = z7__namespace.number().int().refine(
+  (maturity) => {
+    try {
+      from3(maturity);
+      return true;
+    } catch (_e) {
+      return false;
     }
-    const [balances, allowances] = await Promise.all([
-      mempool.Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: balanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      ),
-      mempool.Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: allowanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      )
-    ]);
-    for (let i = 0; i < pairsBatch.length; i++) {
-      const { user, token } = pairsBatch[i];
-      const balance = balances[i];
-      const allowance = allowances[i];
-      let perUser = out.get(user);
-      if (!perUser) {
-        perUser = /* @__PURE__ */ new Map();
-        out.set(user, perUser);
+  },
+  {
+    error: (issue) => {
+      try {
+        const maturityDate = new Date(issue.input * 1e3);
+        return `The maturity is set to ${maturityDate}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+      } catch (_) {
+        return `The maturity is set to ${issue.input}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
       }
-      perUser.set(token, { balance, allowance });
     }
   }
-  return out;
+).transform((maturity) => maturity);
+var MaturityOptions = {
+  end_of_week: () => endOfWeek(),
+  end_of_next_week: () => endOfNextWeek(),
+  end_of_month: () => endOfMonth(),
+  end_of_next_month: () => endOfNextMonth(),
+  end_of_quarter: () => endOfQuarter(),
+  end_of_next_quarter: () => endOfNextQuarter()
+};
+function from3(ts) {
+  if (typeof ts === "string") {
+    if (ts in MaturityOptions) return MaturityOptions[ts]();
+    throw new InvalidOptionError2(ts);
+  }
+  if (typeof ts === "number" && ts > 1e12) throw new InvalidFormatError();
+  if (!Object.values(MaturityOptions).some((option) => option() === ts))
+    throw new InvalidDateError(ts);
+  return ts;
 }
-async function fetch2(parameters) {
-  const { client, chainId, spender, type, pairs, options } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const map = await fetchBalancesAndAllowances({
-    client,
-    spender,
-    pairs: pairs.map(({ user, loanToken }) => ({ user, token: loanToken })),
-    options
-  });
-  const out = [];
-  for (const [user, perLoanToken] of map) {
-    for (const [loanToken, { balance, allowance }] of perLoanToken) {
-      const amount = balance < allowance ? balance : allowance;
-      out.push(
-        buildLiquidity({
-          type,
-          user,
-          loanToken,
-          chainId,
-          amount,
-          index: 0
-        })
-      );
-    }
+var endOfWeek = () => fridayOfWeek(0);
+var endOfNextWeek = () => fridayOfWeek(1);
+var endOfMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth());
+var endOfNextMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth() + 1);
+var endOfQuarter = () => lastFridayOfQuarter(0);
+var endOfNextQuarter = () => lastFridayOfQuarter(1);
+var fridayOfWeek = (weeksAhead = 0) => {
+  const now2 = /* @__PURE__ */ new Date();
+  const today15H = new Date(
+    Date.UTC(now2.getUTCFullYear(), now2.getUTCMonth(), now2.getUTCDate(), 15)
+  );
+  let daysUntilFriday = (5 - today15H.getUTCDay() + 7) % 7;
+  if (daysUntilFriday === 0 && now2.getTime() >= today15H.getTime()) {
+    daysUntilFriday = 7;
   }
-  return out;
+  const friday = new Date(today15H);
+  friday.setUTCDate(friday.getUTCDate() + daysUntilFriday + weeksAhead * 7);
+  return friday.getTime() / 1e3;
+};
+var lastFridayOfMonth = (year, month) => {
+  const lastDayOfMonth15H = new Date(Date.UTC(year, month + 1, 0, 15));
+  while (lastDayOfMonth15H.getUTCDay() !== 5) {
+    lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate() - 1);
+  }
+  const maturity = lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate()) / 1e3;
+  return maturity;
+};
+var lastFridayOfQuarter = (quartersAhead = 0) => {
+  const now2 = /* @__PURE__ */ new Date();
+  const quarterIndex = Math.floor(now2.getUTCMonth() / 3) + quartersAhead;
+  const year = now2.getUTCFullYear() + Math.floor(quarterIndex / 4);
+  const quarter = quarterIndex % 4;
+  const lastMonth = quarter * 3 + 2;
+  return lastFridayOfMonth(year, lastMonth);
+};
+var InvalidFormatError = class extends BaseError {
+  constructor() {
+    super("Invalid maturity format. Maturity should be expressed in seconds.");
+    __publicField(this, "name", "Maturity.InvalidFormatError");
+  }
+};
+var InvalidDateError = class extends BaseError {
+  constructor(input) {
+    super(
+      `Invalid maturity date. Input: "${input}". Accepted values are: ${Object.values(
+        MaturityOptions
+      ).map((option) => `"${option()}"`).join(", ")}.`
+    );
+    __publicField(this, "name", "Maturity.InvalidDateError");
+  }
+};
+var InvalidOptionError2 = class extends BaseError {
+  constructor(input) {
+    super(
+      `Invalid maturity option. Input: "${input}". Accepted values are: ${Object.keys(
+        MaturityOptions
+      ).map((option) => `"${option}"`).join(", ")}.`
+    );
+    __publicField(this, "name", "Maturity.InvalidOptionError");
+  }
+};
+
+// src/core/Obligation.ts
+var Obligation_exports = {};
+__export(Obligation_exports, {
+  CollateralsAreNotSortedError: () => CollateralsAreNotSortedError,
+  InvalidObligationError: () => InvalidObligationError,
+  ObligationSchema: () => ObligationSchema,
+  from: () => from4,
+  fromSnakeCase: () => fromSnakeCase2,
+  id: () => id,
+  random: () => random
+});
+
+// src/utils/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  fromSnakeCase: () => fromSnakeCase,
+  toSnakeCase: () => toSnakeCase
+});
+function toSnakeCase(obj) {
+  return stringifyBigint(
+    processObject(
+      obj,
+      (s) => s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`),
+      (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? viem.getAddress(value.toLowerCase()) : value
+    )
+  );
 }
-function serialize(liquidity) {
-  const normalized = {
-    userPosition: {
-      id: liquidity.userPosition.id,
-      availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
-      user: liquidity.userPosition.user,
-      chainId: String(liquidity.userPosition.chainId),
-      amount: String(liquidity.userPosition.amount)
+function fromSnakeCase(obj) {
+  return processObject(
+    obj,
+    (s) => viem.isAddress(s.toLowerCase()) ? s : s.replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
+    (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? value.toLowerCase() : value
+  );
+}
+function processObject(obj, fnKey, fnValue) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map((item) => processObject(item, fnKey, fnValue));
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      const newKey = fnKey(key);
+      acc[newKey] = typeof value === "object" && value !== null ? processObject(value, fnKey, fnValue) : fnValue(value);
+      return acc;
     },
-    queues: liquidity.queues.map((queueWithPool) => ({
-      queue: {
-        queueId: queueWithPool.queue.queueId,
-        availableLiquidityPoolId: queueWithPool.queue.availableLiquidityPoolId,
-        index: queueWithPool.queue.index
-      },
-      pool: {
-        id: queueWithPool.pool.id,
-        amount: String(queueWithPool.pool.amount)
-      }
-    })).sort(
-      (left, right) => {
-        const leftQueueId = left.queue.queueId || "";
-        const rightQueueId = right.queue.queueId || "";
-        if (leftQueueId < rightQueueId) return -1;
-        if (leftQueueId > rightQueueId) return 1;
-        const leftPoolId = left.pool.id;
-        const rightPoolId = right.pool.id;
-        if (leftPoolId < rightPoolId) return -1;
-        if (leftPoolId > rightPoolId) return 1;
-        const leftIndex = left.queue.index;
-        const rightIndex = right.queue.index;
-        if (leftIndex < rightIndex) return -1;
-        if (leftIndex > rightIndex) return 1;
-        return 0;
-      }
+    {}
+  );
+}
+function stringifyBigint(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(stringifyBigint);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = stringifyBigint(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/core/Obligation.ts
+var ObligationSchema = z7__namespace.object({
+  chainId: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+  loanToken: z7__namespace.string().transform(transformAddress),
+  collaterals: CollateralsSchema,
+  maturity: MaturitySchema
+});
+function from4(parameters) {
+  try {
+    const parsedObligation = ObligationSchema.parse({
+      ...parameters,
+      maturity: from3(parameters.maturity)
+    });
+    return {
+      chainId: parsedObligation.chainId,
+      loanToken: parsedObligation.loanToken.toLowerCase(),
+      collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
+      maturity: parsedObligation.maturity
+    };
+  } catch (error) {
+    throw new InvalidObligationError(error);
+  }
+}
+function fromSnakeCase2(input) {
+  return from4(fromSnakeCase(input));
+}
+function id(obligation) {
+  let lastAsset = "";
+  for (const collateral of obligation.collaterals) {
+    const newAsset = collateral.asset.toLowerCase();
+    if (newAsset.localeCompare(lastAsset) < 0) throw new CollateralsAreNotSortedError();
+    lastAsset = newAsset;
+  }
+  return viem.keccak256(
+    viem.encodeAbiParameters(
+      [
+        { type: "uint256" },
+        { type: "address" },
+        {
+          type: "tuple[]",
+          components: [
+            { type: "address", name: "token" },
+            { type: "uint256", name: "lltv" },
+            { type: "address", name: "oracle" }
+          ]
+        },
+        { type: "uint256" }
+      ],
+      [
+        obligation.chainId,
+        obligation.loanToken.toLowerCase(),
+        obligation.collaterals.map((c) => ({
+          token: c.asset.toLowerCase(),
+          lltv: c.lltv,
+          oracle: c.oracle.toLowerCase()
+        })),
+        BigInt(obligation.maturity)
+      ]
     )
-  };
-  return JSON.stringify(normalized);
+  );
+}
+function random() {
+  return from4({
+    chainId: 1n,
+    loanToken: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    collaterals: [
+      from2({
+        asset: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+        oracle: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+        lltv: 0.965
+      })
+    ],
+    maturity: from3("end_of_next_quarter")
+  });
 }
+var InvalidObligationError = class extends BaseError {
+  constructor(error) {
+    super("Invalid obligation.", { cause: error });
+    __publicField(this, "name", "Obligation.InvalidObligationError");
+  }
+};
+var CollateralsAreNotSortedError = class extends BaseError {
+  constructor() {
+    super("Collaterals are not sorted alphabetically by address.");
+    __publicField(this, "name", "Obligation.CollateralsAreNotSortedError");
+  }
+};
 
-// src/core/RouterOffer.ts
-var RouterOffer_exports = {};
-__export(RouterOffer_exports, {
-  InvalidRouterOfferError: () => InvalidRouterOfferError,
-  OfferStatusValues: () => OfferStatusValues,
-  RouterOfferSchema: () => RouterOfferSchema,
+// src/core/Offer.ts
+var Offer_exports = {};
+__export(Offer_exports, {
+  AccountNotSetError: () => AccountNotSetError,
+  InvalidOfferError: () => InvalidOfferError,
+  OfferHashSchema: () => OfferHashSchema,
+  OfferSchema: () => OfferSchema,
   consumedEvent: () => consumedEvent,
-  from: () => from,
+  decode: () => decode2,
+  domain: () => domain,
+  encode: () => encode2,
+  from: () => from5,
   fromConsumedLog: () => fromConsumedLog,
+  fromSnakeCase: () => fromSnakeCase3,
+  hash: () => hash,
+  obligationId: () => obligationId,
+  random: () => random2,
+  sign: () => sign,
+  toSnakeCase: () => toSnakeCase2,
+  types: () => types
+});
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  BaseError: () => BaseError,
+  Time: () => time_exports,
+  batch: () => batch,
+  batchMulticall: () => batchMulticall,
   fromSnakeCase: () => fromSnakeCase,
-  random: () => random,
-  toSnakeCase: () => toSnakeCase
+  lazy: () => lazy,
+  max: () => max,
+  min: () => min,
+  poll: () => poll,
+  retry: () => retry,
+  toSnakeCase: () => toSnakeCase,
+  wait: () => wait
 });
-var OfferStatusValues = [
-  "valid",
-  "callback_not_supported",
-  "callback_error",
-  "unverified"
-];
-var RouterOfferSchema = (parameters) => mempool.Offer.OfferSchema(parameters).extend({
-  consumed: v4.z.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-  status: v4.z.enum(OfferStatusValues),
-  metadata: v4.z.object({
-    issue: v4.z.string()
-  }).optional()
+
+// src/utils/retry.ts
+var retry = async (fn, attempts = 3, delayMs = 50) => {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  throw lastErr;
+};
+
+// src/utils/batchMulticall.ts
+async function batchMulticall(parameters) {
+  const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
+  const results = [];
+  for (const callsBatch of batch(calls, batchSize)) {
+    const batchResults = await retry(
+      () => client.multicall({
+        allowFailure: false,
+        contracts: callsBatch,
+        ...blockNumber ? { blockNumber } : {}
+      }),
+      retryAttempts,
+      retryDelayMs
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/utils/lazy.ts
+function lazy(pollFn) {
+  return () => async function* () {
+    let active = true;
+    let resolveNext = null;
+    const queue = [];
+    const wait2 = () => new Promise((resolve) => {
+      resolveNext = resolve;
+    });
+    const emit = (item) => {
+      queue.push(item);
+      resolveNext?.();
+      resolveNext = null;
+    };
+    let unpoll = null;
+    const stop = () => {
+      active = false;
+      unpoll?.();
+      resolveNext?.();
+      resolveNext = null;
+    };
+    unpoll = pollFn(emit, { stop });
+    try {
+      while (active) {
+        if (queue.length === 0) await wait2();
+        while (queue.length > 0 && active) yield queue.shift();
+      }
+    } finally {
+      stop();
+    }
+  }();
+}
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
+}
+
+// src/utils/poll.ts
+function poll(fn, { interval }) {
+  let active = true;
+  const unwatch = () => active = false;
+  const watch2 = async () => {
+    await wait(interval);
+    const poll2 = async () => {
+      if (!active) return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch2();
+  return unwatch;
+}
+
+// src/utils/time.ts
+var time_exports = {};
+__export(time_exports, {
+  max: () => max2,
+  now: () => now
 });
-var consumedEvent = {
-  type: "event",
-  name: "Consumed",
-  inputs: [
-    { name: "user", type: "address", indexed: true, internalType: "address" },
-    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
-    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
-  ],
-  anonymous: false
+function now() {
+  return Math.floor(Date.now() / 1e3);
+}
+function max2() {
+  return 864e16;
+}
+
+// src/core/Offer.ts
+var OfferHashSchema = z7__namespace.string().regex(/^0x[0-9a-fA-F]{64}$/, {
+  message: "Hash must be a valid 32-byte hex string"
+}).transform(transformHex);
+var OfferSchema = (parameters) => {
+  const { omitHash = false } = parameters || {};
+  const now2 = time_exports.now();
+  let base = z7__namespace.object({
+    offering: z7__namespace.string().transform(transformAddress),
+    assets: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    rate: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    maturity: MaturitySchema,
+    expiry: z7__namespace.number().int().min(now2, { message: "Expiry must be set to a future date" }).max(Number.MAX_SAFE_INTEGER),
+    start: z7__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    nonce: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    buy: z7__namespace.boolean(),
+    chainId: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    loanToken: z7__namespace.string().transform(transformAddress),
+    collaterals: CollateralsSchema,
+    callback: z7__namespace.object({
+      address: z7__namespace.string().transform(transformAddress),
+      data: z7__namespace.string().transform(transformHex),
+      gasLimit: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+    }),
+    consumed: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    blockNumber: z7__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    signature: z7__namespace.string().regex(/^0x[0-9a-fA-F]{130}$/, {
+      message: "Signature must be a valid 65-byte hex string"
+    }).transform(transformHex).optional()
+  });
+  if (!omitHash) base = base.extend({ hash: OfferHashSchema });
+  return base.refine((data) => data.start < data.expiry, {
+    message: "Start must be before expiry",
+    path: ["start"]
+  }).refine((data) => data.expiry <= data.maturity, {
+    message: "Expiry cannot be after maturity",
+    path: ["expiry"]
+  });
 };
-function from(input) {
+function from5(input) {
   try {
-    const parsedOffer = RouterOfferSchema({ omitHash: true }).parse(input);
-    const parsedHash = mempool.Offer.OfferHashSchema.parse(mempool.Offer.hash(parsedOffer));
+    const parsedOffer = OfferSchema({ omitHash: true }).parse(input);
+    const parsedHash = OfferHashSchema.parse(hash(parsedOffer));
     return {
       ...parsedOffer,
       hash: parsedHash
     };
   } catch (error) {
-    throw new InvalidRouterOfferError(error);
+    throw new InvalidOfferError(error);
   }
 }
-function fromSnakeCase(input) {
-  return from(mempool.Format.fromSnakeCase(input));
+function fromSnakeCase3(input) {
+  return from5(fromSnakeCase(input));
 }
-function toSnakeCase(offer) {
-  return mempool.Format.toSnakeCase(offer);
+function toSnakeCase2(offer) {
+  return toSnakeCase(offer);
 }
-function random() {
-  const baseOffer = mempool.Offer.random();
-  return from({
-    ...baseOffer,
-    status: "valid",
-    metadata: void 0,
-    consumed: 0n
+function random2() {
+  const loanToken = accounts.privateKeyToAccount(accounts.generatePrivateKey()).address;
+  const maturity = from3("end_of_month");
+  const expiry = from3("end_of_week") - 1;
+  const lltv = from(0.965);
+  const offer = from5({
+    offering: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    assets: BigInt(Math.floor(Math.random() * 1e6)),
+    rate: BigInt(Math.floor(Math.random() * 1e6)),
+    maturity,
+    expiry,
+    start: expiry - 10,
+    nonce: BigInt(Math.floor(Math.random() * 1e6)),
+    buy: Math.random() > 0.5,
+    chainId: 1n,
+    loanToken,
+    collaterals: [
+      from2({
+        asset: viem.zeroAddress,
+        oracle: viem.zeroAddress,
+        lltv
+      })
+    ],
+    callback: {
+      address: viem.zeroAddress,
+      data: "0x",
+      gasLimit: 0n
+    },
+    consumed: 0n,
+    blockNumber: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
   });
+  return offer;
 }
-function fromConsumedLog(parameters) {
-  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
-  return {
-    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
-    chainId: BigInt(chainId),
-    offering: user,
-    nonce,
-    amount
-  };
-}
-var InvalidRouterOfferError = class extends mempool.Errors.BaseError {
-  constructor(error) {
-    super("Invalid router offer.", { cause: error });
-    __publicField(this, "name", "RouterOffer.InvalidRouterOfferError");
-  }
-};
-
-// src/core/router/Client.ts
-var Client_exports = {};
-__export(Client_exports, {
-  HttpForbiddenError: () => HttpForbiddenError,
-  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
-  HttpRateLimitError: () => HttpRateLimitError,
-  HttpUnauthorizedError: () => HttpUnauthorizedError,
-  InvalidUrlError: () => InvalidUrlError,
-  connect: () => connect,
-  get: () => get,
-  match: () => match
+var domain = (chainId) => ({
+  chainId,
+  verifyingContract: viem.zeroAddress
 });
-var MAX_LIMIT = 100;
-var DEFAULT_LIMIT = 20;
-var MAX_LLTV = 100;
-var MIN_LLTV = 0;
-var GetOffersQueryParams = v4.z.object({
-  // Core filtering parameters
-  creators: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Creators must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple creator addresses (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  side: v4.z.enum(["buy", "sell"]).optional().meta({
-    description: "Filter by offer type: buy offers or sell offers",
-    example: "buy"
-  }),
-  chains: v4.z.string().regex(/^\d+(,\d+)*$/, {
-    message: "Chains must be comma-separated chain IDs"
-  }).transform((val) => val.split(",").map(Number)).optional().meta({
-    description: "Filter by multiple blockchain networks (comma-separated chain IDs)",
-    example: "1,137,10"
-  }),
-  loan_tokens: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Loan assets must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple loan assets (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  status: v4.z.string().regex(/^[a-zA-Z_]+(,[a-zA-Z_]+)*$/, {
-    message: "Status must be comma-separated status values"
-  }).transform((val) => val.split(",")).refine((statuses) => statuses.every((status) => OfferStatusValues.includes(status)), {
-    message: `Invalid status value. Must be one of: ${OfferStatusValues.join(", ")}`
-  }).optional().meta({
-    description: `Filter by multiple statuses (comma-separated). Valid values: ${OfferStatusValues.join(", ")}. By default, only offers with 'valid' status are returned.`,
-    example: "valid,callback_error"
-  }),
-  callback_addresses: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Callback addresses must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple callback addresses (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  // Asset range
-  min_amount: v4.z.bigint({ coerce: true }).positive({
-    message: "Min amount must be a positive number"
-  }).optional().meta({
-    description: "Minimum amount of assets in the offer",
-    example: "1000"
-  }),
-  max_amount: v4.z.bigint({ coerce: true }).positive({
-    message: "Max amount must be a positive number"
-  }).optional().meta({
-    description: "Maximum amount of assets in the offer",
-    example: "10000"
-  }),
-  // Rate range
-  min_rate: v4.z.bigint({ coerce: true }).positive({
-    message: "Min rate must be a positive number"
-  }).optional().meta({
-    description: "Minimum rate per asset (in wei)",
-    example: "500000000000000000"
-  }),
-  max_rate: v4.z.bigint({ coerce: true }).positive({
-    message: "Max rate must be a positive number"
-  }).optional().meta({
-    description: "Maximum rate per asset (in wei)",
-    example: "1500000000000000000"
-  }),
-  // Time range
-  min_maturity: v4.z.coerce.number().int().min(0).optional().meta({
-    description: "Minimum maturity timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  max_maturity: v4.z.coerce.number().int().min(0).optional().meta({
-    description: "Maximum maturity timestamp (Unix timestamp in seconds)",
-    example: "1800000000"
-  }),
-  min_expiry: v4.z.coerce.number().int().optional().meta({
-    description: "Minimum expiry timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  max_expiry: v4.z.coerce.number().int().optional().meta({
-    description: "Maximum expiry timestamp (Unix timestamp in seconds)",
-    example: "1800000000"
-  }),
-  // Collateral filtering
-  collateral_assets: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Collateral assets must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple collateral assets (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  collateral_oracles: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Collateral oracles must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple rate oracles (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  collateral_tuple: v4.z.string().transform((val, ctx) => {
-    const pattern = /^(0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)(#0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)*$/;
-    if (!pattern.test(val)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "collateral_tuple has an invalid format",
-        input: val
-      });
-    }
-    return val.split("#").map((tuple) => {
-      const parts = tuple.split(":");
-      if (parts.length === 0 || !parts[0]) {
-        ctx.addIssue({
-          code: "custom",
-          message: "Asset address is required for each collateral tuple",
-          path: ["asset"],
-          input: val
-        });
-        return v4.z.NEVER;
-      }
-      const asset = parts[0]?.toLowerCase();
-      const oracle = parts[1]?.toLowerCase();
-      const lltv = parts[2] ? parseFloat(parts[2]) : void 0;
-      if (lltv !== void 0 && (lltv < MIN_LLTV || lltv > MAX_LLTV)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `LLTV must be between ${MIN_LLTV} and ${MAX_LLTV} (0-100%)`,
-          path: ["lltv"],
-          input: val
-        });
-        return v4.z.NEVER;
-      }
-      let lltvValue;
-      if (lltv !== void 0) {
-        try {
-          lltvValue = mempool.LLTV.from(viem.parseUnits(lltv.toString(), 16));
-        } catch (e) {
-          ctx.issues.push({
-            code: "custom",
-            message: e instanceof mempool.LLTV.InvalidLLTVError || e instanceof mempool.LLTV.InvalidOptionError ? e.message : "Invalid LLTV.",
-            input: lltv,
-            path: ["lltv"]
-          });
-          return v4.z.NEVER;
-        }
+var types = {
+  EIP712Domain: [
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" }
+  ],
+  Offer: [
+    { name: "offering", type: "address" },
+    { name: "assets", type: "uint256" },
+    { name: "rate", type: "uint256" },
+    { name: "maturity", type: "uint256" },
+    { name: "expiry", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "buy", type: "bool" },
+    { name: "loanToken", type: "address" },
+    { name: "collaterals", type: "Collateral[]" },
+    { name: "callback", type: "Callback" }
+  ],
+  Collateral: [
+    { name: "asset", type: "address" },
+    { name: "oracle", type: "address" },
+    { name: "lltv", type: "uint256" }
+  ],
+  Callback: [
+    { name: "address", type: "address" },
+    { name: "data", type: "bytes" },
+    { name: "gasLimit", type: "uint256" }
+  ]
+};
+function sign(offer, wallet) {
+  if (!wallet.account) throw new AccountNotSetError();
+  return wallet.signTypedData({
+    account: wallet.account,
+    domain: domain(offer.chainId),
+    types,
+    primaryType: "Offer",
+    message: {
+      offering: offer.offering.toLowerCase(),
+      assets: offer.assets,
+      rate: offer.rate,
+      maturity: BigInt(offer.maturity),
+      expiry: BigInt(offer.expiry),
+      nonce: offer.nonce,
+      buy: offer.buy,
+      loanToken: offer.loanToken.toLowerCase(),
+      collaterals: offer.collaterals,
+      callback: {
+        address: offer.callback.address.toLowerCase(),
+        data: offer.callback.data,
+        gasLimit: offer.callback.gasLimit
       }
-      return {
-        asset,
-        oracle,
-        lltv: lltvValue
-      };
-    });
-  }).optional().meta({
-    description: "Filter by collateral combinations in format: asset:oracle:lltv#asset2:oracle2:lltv2. Oracle and lltv are optional. Use # to separate multiple combinations.",
-    example: "0x1234567890123456789012345678901234567890:0xabcdefabcdefabcdefabcdefabcdefabcdefabcd:86#0x9876543210987654321098765432109876543210:94.5"
-  }),
-  min_lltv: v4.z.coerce.number().min(0, { message: "LLTV must be above 0" }).max(100, { message: "LLTV must be below 100" }).optional().meta({
-    description: "Minimum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal, e.g., 80.5 = 80.5%)",
-    example: "80.5"
-  }),
-  max_lltv: v4.z.coerce.number().min(0, { message: "LLTV must be above 0" }).max(100, { message: "LLTV must be below 100" }).optional().meta({
-    description: "Maximum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal, e.g., 95.5 = 95.5%)",
-    example: "95.5"
-  }),
-  // Sorting parameters
-  sort_by: v4.z.enum(["rate", "maturity", "expiry", "amount"]).optional().meta({
-    description: "Field to sort results by",
-    example: "rate"
-  }),
-  sort_order: v4.z.enum(["asc", "desc"]).optional().default("desc").meta({
-    description: "Sort direction: asc (ascending) or desc (descending, default)",
-    example: "desc"
-  }),
-  // Pagination
-  cursor: v4.z.string().optional().refine(
-    (val) => {
-      if (!val) return true;
-      try {
-        const decoded = decode2(val);
-        return decoded !== null;
-      } catch (_error) {
-        return false;
+    }
+  });
+}
+function hash(offer) {
+  return viem.hashTypedData({
+    domain: domain(offer.chainId),
+    message: {
+      offering: offer.offering.toLowerCase(),
+      assets: offer.assets,
+      rate: offer.rate,
+      maturity: BigInt(offer.maturity),
+      expiry: BigInt(offer.expiry),
+      nonce: offer.nonce,
+      buy: offer.buy,
+      loanToken: offer.loanToken.toLowerCase(),
+      collaterals: offer.collaterals,
+      callback: {
+        address: offer.callback.address.toLowerCase(),
+        data: offer.callback.data,
+        gasLimit: offer.callback.gasLimit
       }
     },
-    {
-      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
-    }
-  ).meta({
-    description: "Pagination cursor in base64url-encoded format",
-    example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
-  }),
-  limit: v4.z.string().regex(/^[1-9]\d*$/, {
-    message: "Limit must be a positive integer"
-  }).transform((val) => Number.parseInt(val, 10)).pipe(
-    v4.z.number().max(MAX_LIMIT, {
-      message: `Limit cannot exceed ${MAX_LIMIT}`
+    primaryType: "Offer",
+    types
+  });
+}
+function obligationId(offer) {
+  return id(
+    from4({
+      chainId: offer.chainId,
+      loanToken: offer.loanToken,
+      collaterals: offer.collaterals,
+      maturity: offer.maturity
     })
-  ).optional().default(DEFAULT_LIMIT).meta({
-    description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
-    example: 10
-  })
-}).refine(
-  (data) => data.min_maturity === void 0 || data.max_maturity === void 0 || data.max_maturity >= data.min_maturity,
-  {
-    message: "max_maturity must be greater than or equal to min_maturity",
-    path: ["max_maturity"]
-  }
-).refine(
-  (data) => data.min_expiry === void 0 || data.max_expiry === void 0 || data.max_expiry >= data.min_expiry,
-  {
-    message: "max_expiry must be greater than or equal to min_expiry",
-    path: ["max_expiry"]
-  }
-).refine(
-  (data) => data.min_amount === void 0 || data.max_amount === void 0 || data.max_amount >= data.min_amount,
+  );
+}
+var OfferAbi = [
+  { name: "offering", type: "address" },
+  { name: "assets", type: "uint256" },
+  { name: "rate", type: "uint256" },
+  { name: "maturity", type: "uint256" },
+  { name: "expiry", type: "uint256" },
+  { name: "nonce", type: "uint256" },
+  { name: "buy", type: "bool" },
+  { name: "chainId", type: "uint256" },
+  { name: "loanToken", type: "address" },
+  { name: "start", type: "uint256" },
   {
-    message: "max_amount must be greater than or equal to min_amount",
-    path: ["max_amount"]
-  }
-).refine(
-  (data) => data.min_rate === void 0 || data.max_rate === void 0 || data.max_rate >= data.min_rate,
+    name: "collaterals",
+    type: "tuple[]",
+    components: [
+      { name: "asset", type: "address" },
+      { name: "oracle", type: "address" },
+      { name: "lltv", type: "uint256" }
+    ]
+  },
   {
-    message: "max_rate must be greater than or equal to min_rate",
-    path: ["max_rate"]
+    name: "callback",
+    type: "tuple",
+    components: [
+      { name: "address", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "gasLimit", type: "uint256" }
+    ]
+  },
+  { name: "signature", type: "bytes" }
+];
+function encode2(offer) {
+  return viem.encodeAbiParameters(OfferAbi, [
+    offer.offering,
+    offer.assets,
+    offer.rate,
+    BigInt(offer.maturity),
+    BigInt(offer.expiry),
+    offer.nonce,
+    offer.buy,
+    offer.chainId,
+    offer.loanToken,
+    BigInt(offer.start),
+    offer.collaterals,
+    offer.callback,
+    offer.signature ?? "0x"
+  ]);
+}
+function decode2(data, blockNumber) {
+  let decoded;
+  try {
+    decoded = viem.decodeAbiParameters(OfferAbi, data);
+  } catch (error) {
+    throw new InvalidOfferError(error);
+  }
+  const offer = from5({
+    offering: decoded[0],
+    assets: decoded[1],
+    rate: decoded[2],
+    maturity: from3(Number(decoded[3])),
+    expiry: Number(decoded[4]),
+    nonce: decoded[5],
+    buy: decoded[6],
+    chainId: decoded[7],
+    loanToken: decoded[8],
+    start: Number(decoded[9]),
+    collaterals: decoded[10].map((c) => {
+      return from2({
+        asset: c.asset,
+        oracle: c.oracle,
+        lltv: c.lltv
+      });
+    }),
+    callback: {
+      address: decoded[11].address,
+      data: decoded[11].data,
+      gasLimit: decoded[11].gasLimit
+    },
+    consumed: 0n,
+    blockNumber: Number(blockNumber),
+    ...decoded[12] === "0x" ? {} : { signature: decoded[12] }
+  });
+  return offer;
+}
+var consumedEvent = {
+  type: "event",
+  name: "Consumed",
+  inputs: [
+    { name: "user", type: "address", indexed: true, internalType: "address" },
+    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
+    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
+  ],
+  anonymous: false
+};
+function fromConsumedLog(parameters) {
+  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
+  return {
+    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
+    chainId: BigInt(chainId),
+    offering: user,
+    nonce,
+    amount,
+    blockNumber: Number(blockNumber)
+  };
+}
+var InvalidOfferError = class extends BaseError {
+  constructor(error) {
+    super("Invalid offer.", { cause: error });
+    __publicField(this, "name", "Offer.InvalidOfferError");
   }
-).refine(
-  (data) => data.min_lltv === void 0 || data.max_lltv === void 0 || data.max_lltv >= data.min_lltv,
-  {
-    message: "max_lltv must be greater than or equal to min_lltv",
-    path: ["max_lltv"]
+};
+var AccountNotSetError = class extends BaseError {
+  constructor() {
+    super("Account not set.");
+    __publicField(this, "name", "Offer.AccountNotSetError");
   }
-);
-var MatchOffersQueryParams = v4.z.object({
-  // Required parameters
-  side: v4.z.enum(["buy", "sell"]).meta({
-    description: "The desired side of the match: 'buy' if you want to buy, 'sell' if you want to sell. If your intent is to sell, buy offers will be returned, and vice versa.",
-    example: "buy"
-  }),
-  chain_id: v4.z.string().transform((val, ctx) => {
-    const numericLike = /^-?\d+$/.test(val);
-    if (!numericLike) {
-      ctx.addIssue({
-        code: "custom",
-        message: "chain_id has an invalid format",
-        input: val
-      });
-      ctx.addIssue({
-        code: "custom",
-        message: "Invalid input: expected number, received NaN",
-        input: val
-      });
-      return v4.z.NEVER;
-    }
-    return Number.parseInt(val, 10);
-  }).pipe(v4.z.number().positive()).meta({
-    description: "The blockchain network chain ID",
-    example: "1"
-  }),
-  // Optional parameters
-  rate: v4.z.bigint({ coerce: true }).positive({
-    message: "Rate must be a positive number"
-  }).optional().meta({
-    description: "Rate per asset (in wei) for matching offers",
-    example: "1000000000000000000"
-  }),
-  // Collateral filtering
-  collaterals: v4.z.string().transform((val, ctx) => {
-    const pattern = /^(0x[a-fA-F0-9]{40}:0x[a-fA-F0-9]{40}:[0-9]+(\.[0-9]+)?)(#0x[a-fA-F0-9]{40}:0x[a-fA-F0-9]{40}:[0-9]+(\.[0-9]+)?)*$/;
-    if (!pattern.test(val)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "Collaterals must be in format: asset:oracle:lltv#asset2:oracle2:lltv2. All fields are required for each collateral.",
-        input: val
-      });
-    }
-    return val.split("#").map((collateral) => {
-      const parts = collateral.split(":");
-      if (parts.length !== 3) {
-        ctx.addIssue({
-          code: "custom",
-          message: "Each collateral must have exactly 3 parts: asset:oracle:lltv",
-          path: ["collaterals"],
-          input: val
-        });
-        return v4.z.NEVER;
-      }
-      const [asset, oracle, lltvStr] = parts;
-      if (!asset || !oracle || !lltvStr) {
-        ctx.addIssue({
-          code: "custom",
-          message: "Asset, oracle, and lltv are all required for each collateral",
-          path: ["collaterals"],
-          input: val
-        });
-      }
-      let lltvValue;
-      if (lltvStr !== void 0) {
-        try {
-          lltvValue = mempool.LLTV.from(viem.parseUnits(lltvStr, 16));
-        } catch (e) {
-          ctx.issues.push({
-            code: "custom",
-            message: e instanceof mempool.LLTV.InvalidLLTVError || e instanceof mempool.LLTV.InvalidOptionError ? e.message : "Invalid LLTV.",
-            input: lltvStr,
-            path: ["lltv"]
-          });
-          return v4.z.NEVER;
-        }
-      }
-      return {
-        asset: asset.toLowerCase(),
-        oracle: oracle.toLowerCase(),
-        lltv: lltvValue
-      };
-    });
-  }).optional().meta({
-    description: "Collateral requirements in format: asset:oracle:lltv#asset2:oracle2:lltv2. Use # to separate multiple collaterals.",
-    example: "0x1234567890123456789012345678901234567890:0xabcdefabcdefabcdefabcdefabcdefabcdefabcd:86#0x9876543210987654321098765432109876543210:0xfedcbafedcbafedcbafedcbafedcbafedcbafedc:94.5"
-  }),
-  // Maturity filtering
-  maturity: v4.z.coerce.number().int().min(0).optional().meta({
-    description: "Maturity timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  min_maturity: v4.z.coerce.number().int().min(0).optional().meta({
-    description: "Minimum maturity timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  max_maturity: v4.z.coerce.number().int().min(0).optional().meta({
-    description: "Maximum maturity timestamp (Unix timestamp in seconds)",
-    example: "1800000000"
-  }),
-  // Asset and creator filtering
-  loan_token: v4.z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
-    message: "Loan asset must be a valid Ethereum address"
-  }).transform((val) => val.toLowerCase()).optional().meta({
-    description: "The loan asset address to match against",
-    example: "0x1234567890123456789012345678901234567890"
-  }),
-  creator: v4.z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
-    message: "Creator must be a valid Ethereum address"
-  }).transform((val) => val.toLowerCase()).optional().meta({
-    description: "Filter by a specific offer creator address",
-    example: "0x1234567890123456789012345678901234567890"
-  }),
-  // Pagination
-  cursor: v4.z.string().optional().refine(
+};
+
+// src/core/types.ts
+var BrandTypeId = Symbol.for("mempool/Brand");
+
+// src/api/Api/Schema/ObligationResponse.ts
+function from6(obligation) {
+  return toSnakeCase({ id: Obligation_exports.id(obligation), ...obligation });
+}
+
+// src/api/Api/Schema/OfferResponse.ts
+var OfferResponse_exports = {};
+__export(OfferResponse_exports, {
+  from: () => from7
+});
+function from7(offer) {
+  return toSnakeCase(offer);
+}
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var PaginationQueryParams = z7__namespace.object({
+  cursor: z7__namespace.string().optional().refine(
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decode2(val);
+        const decoded = Cursor_exports.decode(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -833,34 +1647,49 @@ var MatchOffersQueryParams = v4.z.object({
     description: "Pagination cursor in base64url-encoded format",
     example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
   }),
-  limit: v4.z.string().regex(/^[1-9]\d*$/, {
+  limit: z7__namespace.string().regex(/^[1-9]\d*$/, {
     message: "Limit must be a positive integer"
   }).transform((val) => Number.parseInt(val, 10)).pipe(
-    v4.z.number().max(MAX_LIMIT, {
+    z7__namespace.number().max(MAX_LIMIT, {
       message: `Limit cannot exceed ${MAX_LIMIT}`
     })
   ).optional().default(DEFAULT_LIMIT).meta({
     description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
     example: 10
   })
-}).refine(
-  (data) => data.min_maturity === void 0 || data.max_maturity === void 0 || data.max_maturity >= data.min_maturity,
-  {
-    message: "max_maturity must be greater than or equal to min_maturity",
-    path: ["max_maturity"]
-  }
-);
+});
+var GetOffersQueryParams = z7__namespace.object({
+  ...PaginationQueryParams.shape,
+  side: z7__namespace.enum(["buy", "sell"]).meta({
+    description: "Side of the offer.",
+    example: "buy"
+  }),
+  obligation_id: z7__namespace.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+    description: "Offers obligation id",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var GetObligationsQueryParams = z7__namespace.object({
+  ...PaginationQueryParams.shape,
+  cursor: z7__namespace.string().optional().meta({
+    description: "Obligation id cursor",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
 var schemas = {
   get_offers: GetOffersQueryParams,
-  match_offers: MatchOffersQueryParams
+  get_obligations: GetObligationsQueryParams
 };
+function parse(action, query) {
+  return schemas[action].parse(query);
+}
 function safeParse(action, query, error) {
   return schemas[action].safeParse(query, {
     error
   });
 }
 
-// src/core/apiSchema/openapi.ts
+// src/api/Api/Schema/openapi.ts
 var successResponseSchema = v4.z.object({
   status: v4.z.literal("success"),
   cursor: v4.z.string().nullable(),
@@ -883,8 +1712,8 @@ var errorResponseSchema = v4.z.object({
 var paths = {
   "/v1/offers": {
     get: {
-      summary: "Get offers",
-      description: "Get all offers with optional filtering and pagination",
+      summary: "Offers",
+      description: "Find offers that match specific criteria",
       tags: ["Offers"],
       requestParams: {
         query: GetOffersQueryParams
@@ -909,13 +1738,13 @@ var paths = {
       }
     }
   },
-  "/v1/offers/match": {
+  "/v1/obligations": {
     get: {
-      summary: "Match offers",
-      description: "Find offers that match specific criteria",
-      tags: ["Offers"],
+      summary: "Obligations",
+      description: "List obligations with pagination support",
+      tags: ["Obligations"],
       requestParams: {
-        query: MatchOffersQueryParams
+        query: GetObligationsQueryParams
       },
       responses: {
         200: {
@@ -936,9 +1765,60 @@ var paths = {
         }
       }
     }
+  },
+  "/v1/health": {
+    get: {
+      summary: "Router status",
+      description: "Retrieve the aggregated status of the router.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: RouterStatusResponse
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/health/collectors": {
+    get: {
+      summary: "Collectors health",
+      description: "Retrieve the block numbers processed by collectors and their sync status.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: CollectorsHealthResponse
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/health/chains": {
+    get: {
+      summary: "Chains health",
+      description: "Retrieve the latest block processed for each chain.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: ChainsHealthResponse
+            }
+          }
+        }
+      }
+    }
   }
 };
-zodOpenapi.createDocument({
+var OpenApi = zodOpenapi.createDocument({
   openapi: "3.1.0",
   info: {
     title: "Router API",
@@ -948,6 +1828,12 @@ zodOpenapi.createDocument({
   tags: [
     {
       name: "Offers"
+    },
+    {
+      name: "Obligations"
+    },
+    {
+      name: "Health"
     }
   ],
   servers: [
@@ -963,120 +1849,40 @@ zodOpenapi.createDocument({
   paths
 });
 
-// src/core/apiSchema/utils.ts
-function toResponse(routerOffer) {
-  const { consumed, status, metadata, ...offer } = routerOffer;
-  return {
-    offer,
-    consumed,
-    status,
-    metadata
-  };
-}
-function fromResponse(offerResponse) {
-  const { offer, consumed, status, metadata } = offerResponse;
-  return {
-    ...offer,
-    consumed,
-    status,
-    metadata
-  };
-}
-
-// src/core/router/Client.ts
-function connect(opts) {
-  const u = new URL(opts?.url || "https://router.morpho.dev");
+// src/api/Client.ts
+var Client_exports = {};
+__export(Client_exports, {
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetApiFailedError: () => HttpGetApiFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InvalidUrlError: () => InvalidUrlError,
+  connect: () => connect,
+  getObligations: () => getObligations,
+  getOffers: () => getOffers
+});
+function connect(options) {
+  const u = new URL(options?.url || "https://router.morpho.dev");
   if (u.protocol !== "http:" && u.protocol !== "https:") {
     throw new InvalidUrlError(u.toString());
   }
-  const headers = opts?.headers ?? new Headers();
+  const headers = options?.headers ?? new Headers();
   headers.set("Content-Type", "application/json");
-  opts?.apiKey !== void 0 ? headers.set("X-API-Key", opts.apiKey) : null;
+  options?.apiKey !== void 0 ? headers.set("X-API-Key", options.apiKey) : null;
   const config = {
     url: u,
     headers
   };
   return {
     ...config,
-    get: (parameters) => get(config, parameters),
-    match: (parameters) => match(config, parameters)
+    getOffers: (parameters) => getOffers(config, parameters),
+    getObligations: (parameters) => getObligations(config, parameters)
   };
 }
-async function get(config, parameters) {
+async function getOffers(config, parameters) {
   const url = new URL(`${config.url.toString()}v1/offers`);
-  if (parameters.creators?.length) {
-    url.searchParams.set("creators", parameters.creators.join(","));
-  }
-  if (parameters.side) {
-    url.searchParams.set("side", parameters.side);
-  }
-  if (parameters.chains?.length) {
-    url.searchParams.set("chains", parameters.chains.join(","));
-  }
-  if (parameters.loanTokens?.length) {
-    url.searchParams.set("loan_tokens", parameters.loanTokens.join(","));
-  }
-  if (parameters.status?.length) {
-    url.searchParams.set("status", parameters.status.join(","));
-  }
-  if (parameters.callbackAddresses?.length) {
-    url.searchParams.set("callback_addresses", parameters.callbackAddresses.join(","));
-  }
-  if (parameters.minAmount !== void 0) {
-    url.searchParams.set("min_amount", parameters.minAmount.toString());
-  }
-  if (parameters.maxAmount !== void 0) {
-    url.searchParams.set("max_amount", parameters.maxAmount.toString());
-  }
-  if (parameters.minRate !== void 0) {
-    url.searchParams.set("min_rate", parameters.minRate.toString());
-  }
-  if (parameters.maxRate !== void 0) {
-    url.searchParams.set("max_rate", parameters.maxRate.toString());
-  }
-  if (parameters.minMaturity !== void 0) {
-    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
-  }
-  if (parameters.maxMaturity !== void 0) {
-    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
-  }
-  if (parameters.minExpiry !== void 0) {
-    url.searchParams.set("min_expiry", parameters.minExpiry.toString());
-  }
-  if (parameters.maxExpiry !== void 0) {
-    url.searchParams.set("max_expiry", parameters.maxExpiry.toString());
-  }
-  if (parameters.collateralAssets?.length) {
-    url.searchParams.set("collateral_assets", parameters.collateralAssets.join(","));
-  }
-  if (parameters.collateralOracles?.length) {
-    url.searchParams.set("collateral_oracles", parameters.collateralOracles.join(","));
-  }
-  if (parameters.collateralTuple?.length) {
-    const tupleStr = parameters.collateralTuple.map(({ asset, oracle, lltv }) => {
-      let result = asset;
-      if (oracle) {
-        result += `:${oracle}`;
-      } else if (lltv !== void 0) {
-        result += `:`;
-      }
-      if (lltv !== void 0) result += `:${viem.formatUnits(lltv, 16)}`;
-      return result;
-    }).join("#");
-    url.searchParams.set("collateral_tuple", tupleStr);
-  }
-  if (parameters.minLltv !== void 0) {
-    url.searchParams.set("min_lltv", viem.formatUnits(parameters.minLltv, 16));
-  }
-  if (parameters.maxLltv !== void 0) {
-    url.searchParams.set("max_lltv", viem.formatUnits(parameters.maxLltv, 16));
-  }
-  if (parameters.sortBy) {
-    url.searchParams.set("sort_by", parameters.sortBy);
-  }
-  if (parameters.sortOrder) {
-    url.searchParams.set("sort_order", parameters.sortOrder);
-  }
+  url.searchParams.set("side", parameters.side);
+  url.searchParams.set("obligation_id", parameters.obligationId.toString());
   if (parameters.cursor) {
     url.searchParams.set("cursor", parameters.cursor);
   }
@@ -1084,72 +1890,45 @@ async function get(config, parameters) {
     url.searchParams.set("limit", parameters.limit.toString());
   }
   const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(mempool.Format.fromSnakeCase).map(fromResponse);
+  const routerOffers = offers.map(Offer_exports.fromSnakeCase);
   return {
     cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
+    offers: routerOffers
   };
 }
-async function match(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/offers/match`);
-  url.searchParams.set("side", parameters.side);
-  url.searchParams.set("chain_id", parameters.chainId.toString());
-  if (parameters.rate !== void 0) {
-    url.searchParams.set("rate", parameters.rate.toString());
-  }
-  if (parameters.collaterals?.length) {
-    const collateralsStr = parameters.collaterals.map(({ asset, oracle, lltv }) => `${asset}:${oracle}:${viem.formatUnits(lltv, 16)}`).join("#");
-    url.searchParams.set("collaterals", collateralsStr);
-  }
-  if (parameters.maturity !== void 0) {
-    url.searchParams.set("maturity", parameters.maturity.toString());
-  }
-  if (parameters.minMaturity !== void 0) {
-    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
-  }
-  if (parameters.maxMaturity !== void 0) {
-    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
-  }
-  if (parameters.loanToken) {
-    url.searchParams.set("loan_token", parameters.loanToken);
-  }
-  if (parameters.creator) {
-    url.searchParams.set("creator", parameters.creator);
-  }
-  if (parameters.status?.length) {
-    url.searchParams.set("status", parameters.status.join(","));
-  }
-  if (parameters.cursor) {
+async function getObligations(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/obligations`);
+  if (parameters?.cursor !== void 0) {
     url.searchParams.set("cursor", parameters.cursor);
   }
-  if (parameters.limit !== void 0) {
+  if (parameters?.limit !== void 0) {
     url.searchParams.set("limit", parameters.limit.toString());
   }
-  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(mempool.Format.fromSnakeCase).map(fromResponse);
+  const { cursor: returnedCursor, data: obligationsSnake } = await getApi(config, url);
+  const obligations = obligationsSnake.map(Obligation_exports.fromSnakeCase);
   return {
     cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
+    obligations
   };
 }
 async function getApi(config, url) {
   const pathname = url.pathname;
   let action;
   switch (true) {
-    case pathname.includes("/v1/offers/match"):
-      action = "match_offers";
-      break;
     case pathname.includes("/v1/offers"):
       action = "get_offers";
       break;
+    case pathname.includes("/v1/obligations"):
+      action = "get_obligations";
+      break;
     default:
-      throw new HttpGetOffersFailedError("Unknown endpoint", {
+      throw new HttpGetApiFailedError("Unknown endpoint", {
         details: `Unsupported path: ${pathname}`
       });
   }
   const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
   if (!schemaParseResult.success) {
-    throw new HttpGetOffersFailedError(`Invalid URL parameters`, {
+    throw new HttpGetApiFailedError(`Invalid URL parameters`, {
       details: schemaParseResult.error.issues[0]?.message
     });
   }
@@ -1166,19 +1945,19 @@ async function getApi(config, url) {
       case 429:
         throw new HttpRateLimitError();
     }
-    throw new HttpGetOffersFailedError(`GET request returned ${response.status}`, {
+    throw new HttpGetApiFailedError(`GET request returned ${response.status}`, {
       details: await response.text()
     });
   }
   return response.json();
 }
-var InvalidUrlError = class extends mempool.Errors.BaseError {
+var InvalidUrlError = class extends BaseError {
   constructor(url) {
     super(`URL "${url}" is not http/https.`);
     __publicField(this, "name", "Router.InvalidUrlError");
   }
 };
-var HttpUnauthorizedError = class extends mempool.Errors.BaseError {
+var HttpUnauthorizedError = class extends BaseError {
   constructor() {
     super("Unauthorized.", {
       metaMessages: ["Ensure that an API key is provided."]
@@ -1186,7 +1965,7 @@ var HttpUnauthorizedError = class extends mempool.Errors.BaseError {
     __publicField(this, "name", "Router.HttpUnauthorizedError");
   }
 };
-var HttpForbiddenError = class extends mempool.Errors.BaseError {
+var HttpForbiddenError = class extends BaseError {
   constructor() {
     super("Forbidden.", {
       metaMessages: ["Ensure that the API key is valid."]
@@ -1194,7 +1973,7 @@ var HttpForbiddenError = class extends mempool.Errors.BaseError {
     __publicField(this, "name", "Router.HttpForbiddenError");
   }
 };
-var HttpRateLimitError = class extends mempool.Errors.BaseError {
+var HttpRateLimitError = class extends BaseError {
   constructor() {
     super("Rate limit exceeded.", {
       metaMessages: [
@@ -1204,16 +1983,16 @@ var HttpRateLimitError = class extends mempool.Errors.BaseError {
     __publicField(this, "name", "Router.HttpRateLimitError");
   }
 };
-var HttpGetOffersFailedError = class extends mempool.Errors.BaseError {
+var HttpGetApiFailedError = class extends BaseError {
   constructor(message, { details } = {}) {
     super(message, {
       metaMessages: [details]
     });
-    __publicField(this, "name", "Router.HttpGetOffersFailedError");
+    __publicField(this, "name", "Router.HttpGetApiFailedError");
   }
 };
 
-// src/core/Validation.ts
+// src/collectors/validations/Validation.ts
 var Validation_exports = {};
 __export(Validation_exports, {
   run: () => run
@@ -1260,17 +2039,17 @@ async function run(parameters) {
   };
 }
 
-// src/core/ValidationRule.ts
+// src/collectors/validations/ValidationRule.ts
 var ValidationRule_exports = {};
 __export(ValidationRule_exports, {
-  batch: () => batch,
+  batch: () => batch2,
   morpho: () => morpho,
   single: () => single
 });
 function single(name, run2) {
   return { kind: "single", name, run: run2 };
 }
-function batch(name, run2) {
+function batch2(name, run2) {
   return { kind: "batch", name, run: run2 };
 }
 function morpho() {
@@ -1308,7 +2087,17 @@ function morpho() {
     "buy_offers_non_empty_callback",
     (offer, _) => {
       if (offer.buy && offer.callback.data !== "0x") {
-        return { message: "Buy offers must use an empty callback." };
+        const allowed = new Set(
+          Callback_exports.WhitelistedCallbackAddresses[Callback_exports.CallbackType.BuyVaultV1Callback].map(
+            (a) => a.toLowerCase()
+          )
+        );
+        const callbackAddress = offer.callback.address?.toLowerCase();
+        if (!callbackAddress || !allowed.has(callbackAddress)) {
+          return {
+            message: "Buy offers with non-empty callback must use a whitelisted BuyVaultV1Callback."
+          };
+        }
       }
     }
   );
@@ -1317,7 +2106,7 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         const allowed = new Set(
-          WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].map(
+          Callback_exports.WhitelistedCallbackAddresses[Callback_exports.CallbackType.SellERC20Callback].map(
             (a) => a.toLowerCase()
           )
         );
@@ -1333,10 +2122,7 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         try {
-          const decoded = decode({
-            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
-            data: offer.callback.data
-          });
+          const decoded = Callback_exports.decodeSellERC20Callback(offer.callback.data);
           if (decoded.length === 0) {
             return { message: "Sell offer callback data must include at least one collateral." };
           }
@@ -1351,10 +2137,7 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         try {
-          const decoded = decode({
-            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
-            data: offer.callback.data
-          });
+          const decoded = Callback_exports.decodeSellERC20Callback(offer.callback.data);
           const offerCollaterals = new Set(
             offer.collaterals.map((c) => c.asset.toLowerCase())
           );
@@ -1368,32 +2151,325 @@ function morpho() {
       }
     }
   );
+  const buyCallbackDataInvalid = single(
+    "buy_offers_callback_data_invalid",
+    (offer, _) => {
+      if (offer.buy && offer.callback.data !== "0x") {
+        try {
+          const decoded = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
+          if (decoded.length === 0) {
+            return { message: "Buy offer callback data must include at least one vault." };
+          }
+        } catch (_2) {
+          return { message: "Buy offer callback data cannot be decoded." };
+        }
+      }
+    }
+  );
+  const buyCallbackVaultInvalid = batch2(
+    "buy_offers_callback_vault_invalid",
+    async (offers, { client, chain }) => {
+      const validationIssues = /* @__PURE__ */ new Map();
+      const offersByVaultAddress = /* @__PURE__ */ new Map();
+      for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+        if (offer.buy && offer.callback.data !== "0x") {
+          try {
+            const callbackVaults = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
+            for (const { vault } of callbackVaults) {
+              const normalizedVaultAddress = vault.toLowerCase();
+              if (!offersByVaultAddress.has(normalizedVaultAddress)) {
+                offersByVaultAddress.set(normalizedVaultAddress, []);
+              }
+              offersByVaultAddress.get(normalizedVaultAddress).push({ index: i, offer });
+            }
+          } catch (_) {
+          }
+        }
+      }
+      const uniqueVaultAddresses = Array.from(offersByVaultAddress.keys());
+      if (uniqueVaultAddresses.length === 0) return validationIssues;
+      const whitelistedFactories = Object.values(chain.vaultV1Factory);
+      const multicallContracts = [];
+      for (const vaultAddress of uniqueVaultAddresses) {
+        multicallContracts.push({
+          address: vaultAddress,
+          abi: Abi_exports.ERC4626,
+          functionName: "asset"
+        });
+        for (const factoryAddress of whitelistedFactories) {
+          multicallContracts.push({
+            address: factoryAddress,
+            abi: Abi_exports.MetaMorphoFactory,
+            functionName: "isMetaMorpho",
+            args: [vaultAddress]
+          });
+        }
+      }
+      const multicallResults = await client.multicall({
+        contracts: multicallContracts,
+        allowFailure: true
+      });
+      const vaultAssetByAddress = /* @__PURE__ */ new Map();
+      const registeredVaults = /* @__PURE__ */ new Set();
+      const numberOfFactories = whitelistedFactories.length;
+      let resultIndex = 0;
+      for (const vaultAddress of uniqueVaultAddresses) {
+        const assetCallResult = multicallResults[resultIndex++];
+        const assetAddress = assetCallResult.status === "success" ? assetCallResult.result : null;
+        vaultAssetByAddress.set(vaultAddress, assetAddress);
+        let isRegisteredInFactory = false;
+        for (let factoryIndex = 0; factoryIndex < numberOfFactories; factoryIndex++) {
+          const factoryCallResult = multicallResults[resultIndex++];
+          if (factoryCallResult.status === "success" && factoryCallResult.result === true) {
+            isRegisteredInFactory = true;
+          }
+        }
+        if (isRegisteredInFactory) {
+          registeredVaults.add(vaultAddress);
+        }
+      }
+      const uniqueOffers = /* @__PURE__ */ new Map();
+      for (const offersArray of offersByVaultAddress.values()) {
+        for (const { index, offer } of offersArray) {
+          uniqueOffers.set(index, offer);
+        }
+      }
+      for (const [index, offer] of uniqueOffers) {
+        try {
+          const callbackVaults = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
+          const vaultsWithIssues = [];
+          for (const { vault } of callbackVaults) {
+            const normalizedVaultAddress = vault.toLowerCase();
+            const assetAddress = vaultAssetByAddress.get(normalizedVaultAddress);
+            const isRegistered = registeredVaults.has(normalizedVaultAddress);
+            const failureReasons = [];
+            if (assetAddress === null) {
+              failureReasons.push("asset call failed");
+            } else if (assetAddress && assetAddress.toLowerCase() !== offer.loanToken.toLowerCase()) {
+              failureReasons.push("asset mismatch");
+            }
+            if (!isRegistered) {
+              failureReasons.push("not registered in factory");
+            }
+            if (failureReasons.length > 0) {
+              vaultsWithIssues.push({
+                vaultAddress: vault,
+                failureReasons: failureReasons.join(", ")
+              });
+            }
+          }
+          if (vaultsWithIssues.length > 0) {
+            const failureDetails = vaultsWithIssues.map((v) => `${v.vaultAddress} (${v.failureReasons})`).join("; ");
+            validationIssues.set(index, {
+              message: `Buy offer callback vaults are invalid: ${failureDetails}`
+            });
+          }
+        } catch (_) {
+        }
+      }
+      return validationIssues;
+    }
+  );
+  const maturity = single("maturity", (offer, _) => {
+    const allowedMaturities = [Maturity_exports.from("end_of_month"), Maturity_exports.from("end_of_next_month")];
+    if (!allowedMaturities.includes(offer.maturity)) {
+      return {
+        message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}`
+      };
+    }
+  });
   return [
     chainId,
     loanToken,
     expiry,
+    maturity,
     // note: callback rules should be the last ones, since they do not mean that the offer is forever invalid
     // integrators should be able to choose if they want to keep the offer or not
     sellEmptyCallback,
     buyNonEmptyCallback,
     sellNonWhitelistedCallback,
     sellCallbackDataInvalid,
-    sellCallbackCollateralInvalid
+    sellCallbackCollateralInvalid,
+    buyCallbackDataInvalid,
+    buyCallbackVaultInvalid
   ];
 }
 
+// src/mempool/MempoolClient.ts
+var MempoolClient_exports = {};
+__export(MempoolClient_exports, {
+  connect: () => connect2
+});
+var DEFAULT_BATCH_SIZE2 = 100;
+var DEFAULT_BLOCK_WINDOW2 = 100;
+function from8(parameters) {
+  const config = {
+    client: parameters.client,
+    mempoolAddress: parameters.mempoolAddress,
+    blockWindow: parameters.blockWindow || DEFAULT_BLOCK_WINDOW2
+  };
+  return {
+    add: (parameters2) => add(config, parameters2),
+    get: (parameters2) => get(config, parameters2),
+    watch: (parameters2) => watch(config, parameters2),
+    stream: (parameters2) => streamOffers(config, parameters2)
+  };
+}
+async function add(config, parameters) {
+  const offer = Offer_exports.from(parameters.offer);
+  if (!config.client.account) throw new WalletAccountNotSetError();
+  const chainId = await getChainId(config.client);
+  if (BigInt(chainId) !== offer.chainId)
+    throw new ChainIdMismatchError(offer.chainId, BigInt(chainId));
+  try {
+    const tx = await config.client.sendTransaction({
+      chain: config.client.chain,
+      account: config.client.account,
+      to: config.mempoolAddress,
+      data: Offer_exports.encode(offer)
+    });
+    return { offer, txHash: tx };
+  } catch (error) {
+    throw new ViemClientError(error instanceof Error ? error.message : "Unknown error");
+  }
+}
+async function* get(config, parameters) {
+  const {
+    loanToken,
+    blockNumberGte,
+    blockNumberLte,
+    order = "desc",
+    options: { maxBatchSize = DEFAULT_BATCH_SIZE2 } = {}
+  } = parameters || {};
+  yield* streamOffers(config, {
+    loanToken,
+    order,
+    blockNumberGte,
+    blockNumberLte,
+    options: { maxBatchSize, blockWindow: config.blockWindow }
+  });
+}
+function watch(config, parameters) {
+  const {
+    loanToken,
+    lastSyncedBlock,
+    polling: { interval = 3e4, maxBatchSize = DEFAULT_BATCH_SIZE2 } = {},
+    onOffers
+  } = parameters;
+  return poll(
+    async () => {
+      const blockNumberGte = await lastSyncedBlock();
+      const stream = streamOffers(config, {
+        loanToken,
+        order: "asc",
+        blockNumberGte,
+        options: { maxBatchSize, blockWindow: config.blockWindow }
+      });
+      for await (const { offers, blockNumber } of stream) {
+        await onOffers(offers, blockNumber);
+      }
+    },
+    { interval }
+  );
+}
+var chainIdCache = /* @__PURE__ */ new Map();
+var getChainId = async (client) => {
+  if (chainIdCache.has(client.uid)) return chainIdCache.get(client.uid);
+  const chainId = await client.getChainId();
+  chainIdCache.set(client.uid, chainId);
+  return chainId;
+};
+async function* streamOffers(config, parameters) {
+  const {
+    loanToken,
+    blockNumberGte,
+    blockNumberLte,
+    order = "desc",
+    options: { maxBatchSize = DEFAULT_BATCH_SIZE2, blockWindow = config.blockWindow } = {}
+  } = parameters;
+  const stream = Chain_exports.streamLogs({
+    client: config.client.extend(viem.publicActions),
+    contractAddress: config.mempoolAddress,
+    event: {
+      type: "event",
+      name: "Event",
+      inputs: [{ name: "data", type: "bytes", indexed: false, internalType: "bytes" }],
+      anonymous: false
+    },
+    blockNumberGte,
+    blockNumberLte,
+    order,
+    options: { maxBatchSize, blockWindow }
+  });
+  let blockNumber = order === "asc" ? blockNumberGte : blockNumberLte;
+  for await (const { logs, blockNumber: newBlockNumber } of stream) {
+    blockNumber = newBlockNumber;
+    if (logs.length === 0) break;
+    let offersAndBlockNumbers = logs.map((log) => {
+      const [payload] = viem.decodeAbiParameters([{ type: "bytes" }], log.data);
+      try {
+        return { offer: Offer_exports.decode(payload, log.blockNumber), blockNumber: log.blockNumber };
+      } catch (_) {
+        return null;
+      }
+    }).filter((item) => item !== null);
+    if (loanToken)
+      offersAndBlockNumbers = offersAndBlockNumbers.filter(
+        (o) => o.offer.loanToken.toLowerCase() === loanToken.toLowerCase()
+      );
+    if (offersAndBlockNumbers.length === 0) continue;
+    yield {
+      offers: offersAndBlockNumbers.map((item) => item.offer),
+      blockNumber
+    };
+  }
+  yield { offers: [], blockNumber };
+  return;
+}
+var WalletAccountNotSetError = class extends BaseError {
+  constructor() {
+    super("Wallet account is not set.");
+    __publicField(this, "name", "Mempool.WalletAccountNotSetError");
+  }
+};
+var ViemClientError = class extends BaseError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "Mempool.ViemClientError");
+  }
+};
+var ChainIdMismatchError = class extends BaseError {
+  constructor(expected, actual) {
+    super(`Chain ID mismatch. Offer chain ID is ${expected}, network chain ID is ${actual}.`);
+    __publicField(this, "name", "Mempool.ChainIdMismatchError");
+  }
+};
+
+// src/mempool/MempoolClient.ts
+function connect2(parameters) {
+  return from8(parameters);
+}
+
+exports.Abi = Abi_exports;
+exports.BrandTypeId = BrandTypeId;
 exports.Callback = Callback_exports;
+exports.Chain = Chain_exports;
+exports.Collateral = Collateral_exports;
 exports.Cursor = Cursor_exports;
+exports.Errors = Errors_exports;
+exports.Format = Format_exports;
+exports.LLTV = LLTV_exports;
 exports.Liquidity = Liquidity_exports;
-exports.Router = Client_exports;
-exports.RouterOffer = RouterOffer_exports;
+exports.Maturity = Maturity_exports;
+exports.Mempool = MempoolClient_exports;
+exports.Obligation = Obligation_exports;
+exports.Offer = Offer_exports;
+exports.RouterApi = Schema_exports;
+exports.RouterClient = Client_exports;
+exports.Time = time_exports;
+exports.Utils = utils_exports;
 exports.Validation = Validation_exports;
 exports.ValidationRule = ValidationRule_exports;
-Object.keys(mempool).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return mempool[k]; }
-  });
-});
 //# sourceMappingURL=index.browser.js.map
 //# sourceMappingURL=index.browser.js.map