@morpho-dev/router 0.1.15 → 0.1.16

package/dist/index.node.mjs

@@ -2,7 +2,7 @@ import { serve as serve$1 } from '@hono/node-server';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { AsyncLocalStorage } from 'async_hooks';
-import { maxUint256, keccak256, toHex, isAddress, isHex, decodeAbiParameters, encodeAbiParameters, zeroAddress, hashTypedData, publicActions, parseUnits, createWalletClient, http, encodeFunctionData, parseEther, erc20Abi, stringify, getAddress, concatHex, pad, decodeFunctionResult, parseEventLogs } from 'viem';
+import { maxUint256, isAddress, isHex, decodeAbiParameters, encodeAbiParameters, keccak256, zeroAddress, hashTypedData, publicActions, parseUnits, createWalletClient, http, erc20Abi, stringify, getAddress, parseEventLogs } from 'viem';
 import { getBlock, getLogs } from 'viem/actions';
 import { base, mainnet, anvil } from 'viem/chains';
 import * as z6 from 'zod';
@@ -10,7 +10,7 @@ import { Base64 } from 'js-base64';
 import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
 import { asc, desc, sql, and, eq, gt, gte, lte, inArray } from 'drizzle-orm';
 import { pgSchema, integer, varchar, bigint, timestamp, text, boolean, numeric, index, primaryKey, uniqueIndex } from 'drizzle-orm/pg-core';
-import path2 from 'path';
+import path from 'path';
 import { PGlite } from '@electric-sql/pglite';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -19,10 +19,6 @@ import { migrate as migrate$1 } from 'drizzle-orm/pglite/migrator';
 import { Pool } from 'pg';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
-import { spawn } from 'child_process';
-import fs from 'fs';
-import { createMemoryClient, tevmCall, tevmSetAccount } from 'tevm';
-import { mainnet as mainnet$1 } from 'tevm/common';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -3235,23 +3231,23 @@ async function nodeJsFindMatchingOffers(db, params) {
   })) {
     if (pathsChunk.length === 0) continue;
     for (let i = 0; i < pathsChunk.length; i++) {
-      const path3 = pathsChunk[i];
-      const offerHash = path3.offer_hash;
+      const path2 = pathsChunk[i];
+      const offerHash = path2.offer_hash;
       if (offerHashInvalid.has(offerHash) || offerHashValid.has(offerHash)) continue;
-      for (const poolId of path3.path) {
+      for (const poolId of path2.path) {
         if (intermediateState.has(poolId)) continue;
-        const poolAmount = globalState.has(poolId) ? globalState.get(poolId) : BigInt(path3.pools.find((p) => p.pool_id === poolId)?.amount || 0);
+        const poolAmount = globalState.has(poolId) ? globalState.get(poolId) : BigInt(path2.pools.find((p) => p.pool_id === poolId)?.amount || 0);
         intermediateState.set(poolId, poolAmount);
       }
       const bottleneck = Array.from(intermediateState.entries()).reduce((acc, [id2, curr]) => {
-        if (!path3.path.includes(id2) || id2 === path3.root_id) return acc;
+        if (!path2.path.includes(id2) || id2 === path2.root_id) return acc;
         return acc < curr ? acc : curr;
-      }, intermediateState.get(path3.root_id));
+      }, intermediateState.get(path2.root_id));
       for (const [poolId, amount] of intermediateState.entries()) {
-        if (!path3.path.includes(poolId)) continue;
+        if (!path2.path.includes(poolId)) continue;
         intermediateState.set(poolId, amount - bottleneck);
       }
-      const isPoolRootUsedBeforeByAnotherOffer = globalState.has(path3.root_id) && globalState.get(path3.root_id) === 0n;
+      const isPoolRootUsedBeforeByAnotherOffer = globalState.has(path2.root_id) && globalState.get(path2.root_id) === 0n;
       if (isPoolRootUsedBeforeByAnotherOffer) {
         offerHashInvalid.add(offerHash);
         intermediateState.clear();
@@ -3265,8 +3261,8 @@ async function nodeJsFindMatchingOffers(db, params) {
         intermediateState.clear();
         continue;
       }
-      const isNextPathUsingSameRoot = path3.root_id === pathsChunk[i + 1]?.root_id;
-      const isPoolRootTotallyConsumed = intermediateState.get(path3.root_id) === 0n;
+      const isNextPathUsingSameRoot = path2.root_id === pathsChunk[i + 1]?.root_id;
+      const isPoolRootTotallyConsumed = intermediateState.get(path2.root_id) === 0n;
       if (!isNextPathUsingSameRoot && !isPoolRootTotallyConsumed) {
         offerHashInvalid.add(offerHash);
         intermediateState.clear();
@@ -3774,7 +3770,7 @@ function connect2(parameters) {
   return Object.assign(client, { name: "pglite", pool });
 }
 async function applyMigrations(pg) {
-  const migrationsFolder = process.env.AWS_LAMBDA_FUNCTION_NAME ? path2.join(process.cwd(), "drizzle", VERSION) : path2.join(__dirname, "drizzle", VERSION);
+  const migrationsFolder = process.env.AWS_LAMBDA_FUNCTION_NAME ? path.join(process.cwd(), "drizzle", VERSION) : path.join(__dirname, "drizzle", VERSION);
   await pg.execute(`create schema if not exists "${VERSION}"`);
   if (pg.name === "pg") {
     await migrate(pg, { migrationsFolder });
@@ -6003,588 +5999,6 @@ var HttpGetApiFailedError = class extends BaseError {
   }
 };
 
-// src/evm/EVM.ts
-var EVM_exports = {};
-__export(EVM_exports, {
-  assetList: () => assetList,
-  assetMethods: () => assetMethods,
-  encodeConsumedEvent: () => encodeConsumedEvent,
-  factoryMethods: () => factoryMethods,
-  mock: () => mock,
-  mockAddress: () => mockAddress,
-  mockFactoryAddress: () => mockFactoryAddress,
-  mockMorphoAddress: () => mockMorphoAddress,
-  mockOracleAddress: () => mockOracleAddress,
-  morphoMethods: () => morphoMethods,
-  oracleMethods: () => oracleMethods,
-  serve: () => serve2,
-  users: () => users,
-  vaultMethods: () => vaultMethods
-});
-var users = [
-  privateKeyToAccount(
-    // first anvil account private key
-    "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-  )
-];
-var assetList = ["USDC", "DAI"];
-var mockAddress = (asset) => {
-  return privateKeyToAccount(keccak256(toHex(asset))).address;
-};
-var mockOracleAddress = privateKeyToAccount(keccak256(toHex("ORACLE"))).address;
-var mockMorphoAddress = privateKeyToAccount(keccak256(toHex("MORPHO"))).address;
-var mockFactoryAddress = privateKeyToAccount(keccak256(toHex("FACTORY"))).address;
-var encodeConsumedEvent = (parameters) => {
-  return encodeFunctionData({
-    abi: [
-      {
-        type: "function",
-        name: "consume",
-        stateMutability: "nonpayable",
-        inputs: [
-          { name: "user", type: "address" },
-          { name: "nonce", type: "uint256" },
-          { name: "amount", type: "uint256" }
-        ],
-        outputs: []
-      }
-    ],
-    functionName: "consume",
-    args: [parameters.user, parameters.nonce, parameters.amount]
-  });
-};
-var assetMethods = ["balanceOf", "allowance"];
-var oracleMethods = ["price"];
-var morphoMethods = ["debtOf", "collateralOf", "market", "position"];
-var vaultMethods = [
-  "asset",
-  "balanceOf",
-  "totalSupply",
-  "totalAssets",
-  "withdrawQueue"
-];
-var factoryMethods = ["isMetaMorpho", "morpho"];
-async function mock(name) {
-  const client = createMemoryClient({
-    account: users[0],
-    common: mainnet$1,
-    miningConfig: {
-      // makes tests deterministic by forcing to call mine() manually
-      type: "manual"
-    },
-    // makes tests faster by only waiting 50ms to fetch the current state
-    pollingInterval: 50
-  });
-  await client.tevmReady();
-  const mine = async () => {
-    await client.mine({ blocks: 1 });
-  };
-  const globalState = {};
-  const { createdAddress: mempoolAddress } = await tevmCall(client, {
-    data: fs.readFileSync(path2.join(__dirname, "bytecode", "mempool.txt"), "utf8"),
-    addToBlockchain: true
-  });
-  if (!mempoolAddress) throw new Error("Failed to deploy mempool contract");
-  const { createdAddress: termsAddress } = await tevmCall(client, {
-    data: fs.readFileSync(path2.join(__dirname, "bytecode", "terms.txt"), "utf8"),
-    addToBlockchain: true
-  });
-  if (!termsAddress) throw new Error("Failed to deploy terms contract");
-  await Promise.all(
-    users.map(
-      (u) => tevmSetAccount(client, {
-        address: u.address,
-        balance: parseEther("100")
-      })
-    )
-  );
-  await Promise.all(
-    assetList.map((a) => {
-      const bytecode = fs.readFileSync(
-        path2.join(__dirname, "bytecode", "erc20.txt"),
-        "utf8"
-      );
-      return tevmSetAccount(client, {
-        address: mockAddress(a),
-        deployedBytecode: bytecode
-      });
-    })
-  );
-  const setAccount = async ({ address, state }) => {
-    const previousState = globalState[address] ?? {};
-    globalState[address] = { ...previousState, ...state };
-    await tevmSetAccount(client, {
-      address,
-      state: globalState[address]
-    });
-  };
-  const translate = (patch) => {
-    return Object.fromEntries(
-      Object.entries(patch).map(([k, v]) => {
-        if (typeof k === "string" && k.startsWith("0x")) {
-          if (typeof v !== "bigint" && typeof v !== "string") {
-            throw new Error("Invalid value");
-          }
-          return [k, typeof v === "bigint" ? toHex(v) : v];
-        }
-        return stateFromAssetMethod(k, v);
-      })
-    );
-  };
-  const stateFromAssetMethod = (method, parameters) => {
-    if (method === "balanceOf") {
-      const { address: key, value } = parameters;
-      const slot = 9;
-      return [
-        keccak256(concatHex([pad(key, { size: 32 }), pad(toHex(slot), { size: 32 })])),
-        toHex(value)
-      ];
-    }
-    if (method === "allowance") {
-      const { owner: key, spender: key2, value } = parameters;
-      const slot = 10;
-      const outer = keccak256(concatHex([pad(key, { size: 32 }), pad(toHex(slot), { size: 32 })]));
-      const inner = keccak256(concatHex([pad(key2, { size: 32 }), pad(outer, { size: 32 })]));
-      return [inner, toHex(value)];
-    }
-    return ["0x0", "0x0"];
-  };
-  const mockedAssets = Object.fromEntries(
-    assetList.map((name2) => [
-      name2,
-      {
-        address: mockAddress(name2),
-        set: async (slot, parameters) => {
-          const patch = { [slot]: parameters };
-          await setAccount({
-            address: mockAddress(name2),
-            state: translate(
-              patch
-            )
-          });
-        }
-      }
-    ])
-  );
-  await Promise.all([
-    tevmSetAccount(client, {
-      address: mockOracleAddress,
-      deployedBytecode: fs.readFileSync(
-        path2.join(__dirname, "bytecode", "oracle.txt"),
-        "utf8"
-      )
-    }),
-    tevmSetAccount(client, {
-      address: mockMorphoAddress,
-      deployedBytecode: fs.readFileSync(
-        path2.join(__dirname, "bytecode", "morpho.txt"),
-        "utf8"
-      )
-    }),
-    tevmSetAccount(client, {
-      address: mockFactoryAddress,
-      deployedBytecode: fs.readFileSync(
-        path2.join(__dirname, "bytecode", "factory.txt"),
-        "utf8"
-      )
-    })
-  ]);
-  const mockedOracle = {
-    address: mockOracleAddress,
-    set: async (method, parameters) => {
-      if (method === "price") {
-        const { value } = parameters;
-        await tevmCall(client, {
-          to: mockOracleAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setPrice",
-                inputs: [{ name: "newPrice", type: "uint256" }],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setPrice",
-            args: [value]
-          }),
-          addToBlockchain: true
-        });
-      }
-    }
-  };
-  const mockedMorpho = {
-    address: mockMorphoAddress,
-    set: async (method, parameters) => {
-      if (method === "debtOf") {
-        const { user, obligationId: obligationId2, value } = parameters;
-        await tevmCall(client, {
-          to: mockMorphoAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setDebtOf",
-                inputs: [
-                  { name: "user", type: "address" },
-                  { name: "termId", type: "bytes32" },
-                  { name: "debt", type: "uint256" }
-                ],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setDebtOf",
-            args: [user, obligationId2, value]
-          }),
-          addToBlockchain: true
-        });
-      } else if (method === "collateralOf") {
-        const { user, obligationId: obligationId2, collateralAsset, value } = parameters;
-        await tevmCall(client, {
-          to: mockMorphoAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setCollateralOf",
-                inputs: [
-                  { name: "user", type: "address" },
-                  { name: "termId", type: "bytes32" },
-                  { name: "collateralAsset", type: "address" },
-                  { name: "amount", type: "uint256" }
-                ],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setCollateralOf",
-            args: [user, obligationId2, collateralAsset, value]
-          }),
-          addToBlockchain: true
-        });
-      } else if (method === "market") {
-        const {
-          marketId,
-          totalSupplyAssets,
-          totalSupplyShares,
-          totalBorrowAssets,
-          totalBorrowShares,
-          lastUpdate,
-          fee
-        } = parameters;
-        await tevmCall(client, {
-          to: mockMorphoAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setMarket",
-                inputs: [
-                  { name: "id", type: "bytes32" },
-                  { name: "totalSupplyAssets", type: "uint128" },
-                  { name: "totalSupplyShares", type: "uint128" },
-                  { name: "totalBorrowAssets", type: "uint128" },
-                  { name: "totalBorrowShares", type: "uint128" },
-                  { name: "lastUpdate", type: "uint128" },
-                  { name: "fee", type: "uint128" }
-                ],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setMarket",
-            args: [
-              marketId,
-              totalSupplyAssets,
-              totalSupplyShares,
-              totalBorrowAssets,
-              totalBorrowShares,
-              lastUpdate,
-              fee
-            ]
-          }),
-          addToBlockchain: true
-        });
-      } else if (method === "position") {
-        const { marketId, user, supplyShares, borrowShares, collateral } = parameters;
-        await tevmCall(client, {
-          to: mockMorphoAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setPosition",
-                inputs: [
-                  { name: "id", type: "bytes32" },
-                  { name: "user", type: "address" },
-                  { name: "supplyShares", type: "uint256" },
-                  { name: "borrowShares", type: "uint128" },
-                  { name: "collateral", type: "uint128" }
-                ],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setPosition",
-            args: [marketId, user, supplyShares, borrowShares, collateral]
-          }),
-          addToBlockchain: true
-        });
-      }
-    }
-  };
-  const mockedFactory = {
-    address: mockFactoryAddress,
-    set: async (method, parameters) => {
-      if (method === "isMetaMorpho") {
-        const { vault, value } = parameters;
-        await tevmCall(client, {
-          to: mockFactoryAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setIsMetaMorpho",
-                inputs: [
-                  { name: "vault", type: "address" },
-                  { name: "isValid", type: "bool" }
-                ],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setIsMetaMorpho",
-            args: [vault, value]
-          }),
-          addToBlockchain: true
-        });
-      } else if (method === "morpho") {
-        const { value } = parameters;
-        await tevmCall(client, {
-          to: mockFactoryAddress,
-          data: encodeFunctionData({
-            abi: [
-              {
-                type: "function",
-                name: "setMorpho",
-                inputs: [{ name: "morpho_", type: "address" }],
-                outputs: [],
-                stateMutability: "nonpayable"
-              }
-            ],
-            functionName: "setMorpho",
-            args: [value]
-          }),
-          addToBlockchain: true
-        });
-      }
-    }
-  };
-  const deployVault = async () => {
-    const vaultAddress = privateKeyToAccount(
-      keccak256(toHex(`VAULT_${Date.now()}_${Math.random()}`))
-    ).address;
-    await tevmSetAccount(client, {
-      address: vaultAddress,
-      deployedBytecode: fs.readFileSync(
-        path2.join(__dirname, "bytecode", "vault.txt"),
-        "utf8"
-      )
-    });
-    if (!vaultAddress) throw new Error("Failed to deploy vault contract");
-    return {
-      address: vaultAddress,
-      set: async (method, parameters) => {
-        if (method === "asset") {
-          const { value } = parameters;
-          await tevmCall(client, {
-            to: vaultAddress,
-            data: encodeFunctionData({
-              abi: [
-                {
-                  type: "function",
-                  name: "setAsset",
-                  inputs: [{ name: "asset_", type: "address" }],
-                  outputs: [],
-                  stateMutability: "nonpayable"
-                }
-              ],
-              functionName: "setAsset",
-              args: [value]
-            }),
-            addToBlockchain: true
-          });
-        } else if (method === "balanceOf") {
-          const { user, value } = parameters;
-          await tevmCall(client, {
-            to: vaultAddress,
-            data: encodeFunctionData({
-              abi: [
-                {
-                  type: "function",
-                  name: "setBalanceOf",
-                  inputs: [
-                    { name: "user", type: "address" },
-                    { name: "amount", type: "uint256" }
-                  ],
-                  outputs: [],
-                  stateMutability: "nonpayable"
-                }
-              ],
-              functionName: "setBalanceOf",
-              args: [user, value]
-            }),
-            addToBlockchain: true
-          });
-        } else if (method === "totalSupply") {
-          const { value } = parameters;
-          await tevmCall(client, {
-            to: vaultAddress,
-            data: encodeFunctionData({
-              abi: [
-                {
-                  type: "function",
-                  name: "setTotalSupply",
-                  inputs: [{ name: "amount", type: "uint256" }],
-                  outputs: [],
-                  stateMutability: "nonpayable"
-                }
-              ],
-              functionName: "setTotalSupply",
-              args: [value]
-            }),
-            addToBlockchain: true
-          });
-        } else if (method === "totalAssets") {
-          const { value } = parameters;
-          await tevmCall(client, {
-            to: vaultAddress,
-            data: encodeFunctionData({
-              abi: [
-                {
-                  type: "function",
-                  name: "setTotalAssets",
-                  inputs: [{ name: "amount", type: "uint256" }],
-                  outputs: [],
-                  stateMutability: "nonpayable"
-                }
-              ],
-              functionName: "setTotalAssets",
-              args: [value]
-            }),
-            addToBlockchain: true
-          });
-        } else if (method === "withdrawQueue") {
-          const { value } = parameters;
-          await tevmCall(client, {
-            to: vaultAddress,
-            data: encodeFunctionData({
-              abi: [
-                {
-                  type: "function",
-                  name: "setWithdrawQueue",
-                  inputs: [{ name: "queue", type: "bytes32[]" }],
-                  outputs: [],
-                  stateMutability: "nonpayable"
-                }
-              ],
-              functionName: "setWithdrawQueue",
-              args: [value]
-            }),
-            addToBlockchain: true
-          });
-        }
-      }
-    };
-  };
-  return {
-    name,
-    client: Object.assign(client, {
-      extend: /* @__PURE__ */ ((originalExtend) => (actions) => {
-        const extended = originalExtend(actions);
-        const multicall = async (parameters) => {
-          const results = [];
-          for (const c of parameters.contracts) {
-            const data = encodeFunctionData({
-              abi: c.abi,
-              functionName: c.functionName,
-              args: c.args ?? []
-            });
-            const callResult = await client.call({
-              to: c.address,
-              data,
-              ...parameters.blockNumber ? { blockNumber: parameters.blockNumber } : {}
-            });
-            try {
-              const decoded = decodeFunctionResult({
-                abi: c.abi,
-                functionName: c.functionName,
-                data: callResult.data
-              });
-              if (parameters.allowFailure === true) {
-                results.push({ status: "success", result: decoded });
-              } else {
-                results.push(decoded);
-              }
-            } catch (err) {
-              if (parameters.allowFailure !== true) throw err;
-              results.push({ status: "failure", error: err });
-            }
-          }
-          return results;
-        };
-        return Object.assign({}, extended, { multicall });
-      })(client.extend.bind(client))
-    }),
-    mempoolAddress,
-    termsAddress,
-    mine,
-    reset: async () => await client.reset({ blockNumber: 0n }),
-    deployVault,
-    oracle: mockedOracle,
-    morpho: mockedMorpho,
-    factory: mockedFactory,
-    ...mockedAssets
-  };
-}
-async function serve2(parameters) {
-  const { port, forkUrl, blockNumber } = parameters;
-  let started = false;
-  const args = [
-    "--chain-id",
-    Chain_exports.ChainId.ANVIL.toString(),
-    "--fork-url",
-    forkUrl,
-    "--port",
-    String(port)
-  ];
-  if (blockNumber) args.push("--fork-block-number", String(blockNumber));
-  const stop = await new Promise((resolve, reject) => {
-    const subprocess = spawn("anvil", args, {
-      env: { ...process.env, FOUNDRY_DISABLE_NIGHTLY_WARNING: "1" }
-    });
-    subprocess.stdout.on("data", (data) => {
-      const message = `[port ${port}] ${data.toString()}`;
-      if (message.includes("Listening on")) {
-        started = true;
-        resolve(() => subprocess.kill("SIGINT"));
-      }
-    });
-    subprocess.stderr.on("data", (data) => {
-      const message = `[port ${port}] ${data.toString()}`;
-      console.warn(message);
-      if (!started) reject(message);
-      else console.warn(message);
-    });
-  });
-  return {
-    rpcUrl: `http://localhost:${port}`,
-    stop
-  };
-}
-
-export { Abi_exports as Abi, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainHealth, ChainStore_exports as ChainStore, ChainsHealthResponse, Collateral_exports as Collateral, collectors_exports as Collector, CollectorHealth, CollectorStore_exports as CollectorStore, CollectorsHealthResponse, Cursor_exports as Cursor, EVM_exports as EVM, Errors_exports as Errors, Format_exports as Format, Health_exports as Health, LLTV_exports as LLTV, Liquidity_exports as Liquidity, LiquidityStore_exports as LiquidityStore, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OfferStore_exports as OfferStore, schema_exports as OffersSchema, OpenApi, PG_exports as PG, Api_exports2 as RouterApi, Client_exports as RouterClient, RouterIndexer_exports as RouterIndexer, RouterStatusResponse, Services_exports as Services, time_exports as Time, utils_exports as Utils, Validation_exports as Validation, ValidationRule_exports as ValidationRule, parse, safeParse };
+export { Abi_exports as Abi, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainHealth, ChainStore_exports as ChainStore, ChainsHealthResponse, Collateral_exports as Collateral, collectors_exports as Collector, CollectorHealth, CollectorStore_exports as CollectorStore, CollectorsHealthResponse, Cursor_exports as Cursor, Errors_exports as Errors, Format_exports as Format, Health_exports as Health, LLTV_exports as LLTV, Liquidity_exports as Liquidity, LiquidityStore_exports as LiquidityStore, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OfferStore_exports as OfferStore, schema_exports as OffersSchema, OpenApi, PG_exports as PG, Api_exports2 as RouterApi, Client_exports as RouterClient, RouterIndexer_exports as RouterIndexer, RouterStatusResponse, Services_exports as Services, time_exports as Time, utils_exports as Utils, Validation_exports as Validation, ValidationRule_exports as ValidationRule, parse, safeParse };
 //# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map