@morpho-dev/router 0.1.15 → 0.1.16

package/dist/index.node.js

@@ -12,7 +12,7 @@ var jsBase64 = require('js-base64');
 var accounts = require('viem/accounts');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
-var path2 = require('path');
+var path = require('path');
 var pglite = require('@electric-sql/pglite');
 var nodePostgres = require('drizzle-orm/node-postgres');
 var migrator = require('drizzle-orm/node-postgres/migrator');
@@ -21,10 +21,6 @@ var migrator$1 = require('drizzle-orm/pglite/migrator');
 var pg = require('pg');
 var v4 = require('zod/v4');
 var zodOpenapi = require('zod-openapi');
-var child_process = require('child_process');
-var fs = require('fs');
-var tevm = require('tevm');
-var common = require('tevm/common');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -47,8 +43,7 @@ function _interopNamespace(e) {
 }
 
 var z6__namespace = /*#__PURE__*/_interopNamespace(z6);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -3261,23 +3256,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();
@@ -3291,8 +3286,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();
@@ -3800,7 +3795,7 @@ function connect2(parameters) {
   return Object.assign(client, { name: "pglite", pool });
 }
 async function applyMigrations(pg) {
-  const migrationsFolder = process.env.AWS_LAMBDA_FUNCTION_NAME ? path2__default.default.join(process.cwd(), "drizzle", VERSION) : path2__default.default.join(__dirname, "drizzle", VERSION);
+  const migrationsFolder = process.env.AWS_LAMBDA_FUNCTION_NAME ? path__default.default.join(process.cwd(), "drizzle", VERSION) : path__default.default.join(__dirname, "drizzle", VERSION);
   await pg.execute(`create schema if not exists "${VERSION}"`);
   if (pg.name === "pg") {
     await migrator.migrate(pg, { migrationsFolder });
@@ -6029,588 +6024,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 = [
-  accounts.privateKeyToAccount(
-    // first anvil account private key
-    "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-  )
-];
-var assetList = ["USDC", "DAI"];
-var mockAddress = (asset) => {
-  return accounts.privateKeyToAccount(viem.keccak256(viem.toHex(asset))).address;
-};
-var mockOracleAddress = accounts.privateKeyToAccount(viem.keccak256(viem.toHex("ORACLE"))).address;
-var mockMorphoAddress = accounts.privateKeyToAccount(viem.keccak256(viem.toHex("MORPHO"))).address;
-var mockFactoryAddress = accounts.privateKeyToAccount(viem.keccak256(viem.toHex("FACTORY"))).address;
-var encodeConsumedEvent = (parameters) => {
-  return viem.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 = tevm.createMemoryClient({
-    account: users[0],
-    common: common.mainnet,
-    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 tevm.tevmCall(client, {
-    data: fs__default.default.readFileSync(path2__default.default.join(__dirname, "bytecode", "mempool.txt"), "utf8"),
-    addToBlockchain: true
-  });
-  if (!mempoolAddress) throw new Error("Failed to deploy mempool contract");
-  const { createdAddress: termsAddress } = await tevm.tevmCall(client, {
-    data: fs__default.default.readFileSync(path2__default.default.join(__dirname, "bytecode", "terms.txt"), "utf8"),
-    addToBlockchain: true
-  });
-  if (!termsAddress) throw new Error("Failed to deploy terms contract");
-  await Promise.all(
-    users.map(
-      (u) => tevm.tevmSetAccount(client, {
-        address: u.address,
-        balance: viem.parseEther("100")
-      })
-    )
-  );
-  await Promise.all(
-    assetList.map((a) => {
-      const bytecode = fs__default.default.readFileSync(
-        path2__default.default.join(__dirname, "bytecode", "erc20.txt"),
-        "utf8"
-      );
-      return tevm.tevmSetAccount(client, {
-        address: mockAddress(a),
-        deployedBytecode: bytecode
-      });
-    })
-  );
-  const setAccount = async ({ address, state }) => {
-    const previousState = globalState[address] ?? {};
-    globalState[address] = { ...previousState, ...state };
-    await tevm.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" ? viem.toHex(v) : v];
-        }
-        return stateFromAssetMethod(k, v);
-      })
-    );
-  };
-  const stateFromAssetMethod = (method, parameters) => {
-    if (method === "balanceOf") {
-      const { address: key, value } = parameters;
-      const slot = 9;
-      return [
-        viem.keccak256(viem.concatHex([viem.pad(key, { size: 32 }), viem.pad(viem.toHex(slot), { size: 32 })])),
-        viem.toHex(value)
-      ];
-    }
-    if (method === "allowance") {
-      const { owner: key, spender: key2, value } = parameters;
-      const slot = 10;
-      const outer = viem.keccak256(viem.concatHex([viem.pad(key, { size: 32 }), viem.pad(viem.toHex(slot), { size: 32 })]));
-      const inner = viem.keccak256(viem.concatHex([viem.pad(key2, { size: 32 }), viem.pad(outer, { size: 32 })]));
-      return [inner, viem.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([
-    tevm.tevmSetAccount(client, {
-      address: mockOracleAddress,
-      deployedBytecode: fs__default.default.readFileSync(
-        path2__default.default.join(__dirname, "bytecode", "oracle.txt"),
-        "utf8"
-      )
-    }),
-    tevm.tevmSetAccount(client, {
-      address: mockMorphoAddress,
-      deployedBytecode: fs__default.default.readFileSync(
-        path2__default.default.join(__dirname, "bytecode", "morpho.txt"),
-        "utf8"
-      )
-    }),
-    tevm.tevmSetAccount(client, {
-      address: mockFactoryAddress,
-      deployedBytecode: fs__default.default.readFileSync(
-        path2__default.default.join(__dirname, "bytecode", "factory.txt"),
-        "utf8"
-      )
-    })
-  ]);
-  const mockedOracle = {
-    address: mockOracleAddress,
-    set: async (method, parameters) => {
-      if (method === "price") {
-        const { value } = parameters;
-        await tevm.tevmCall(client, {
-          to: mockOracleAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockMorphoAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockMorphoAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockMorphoAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockMorphoAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockFactoryAddress,
-          data: viem.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 tevm.tevmCall(client, {
-          to: mockFactoryAddress,
-          data: viem.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 = accounts.privateKeyToAccount(
-      viem.keccak256(viem.toHex(`VAULT_${Date.now()}_${Math.random()}`))
-    ).address;
-    await tevm.tevmSetAccount(client, {
-      address: vaultAddress,
-      deployedBytecode: fs__default.default.readFileSync(
-        path2__default.default.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 tevm.tevmCall(client, {
-            to: vaultAddress,
-            data: viem.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 tevm.tevmCall(client, {
-            to: vaultAddress,
-            data: viem.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 tevm.tevmCall(client, {
-            to: vaultAddress,
-            data: viem.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 tevm.tevmCall(client, {
-            to: vaultAddress,
-            data: viem.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 tevm.tevmCall(client, {
-            to: vaultAddress,
-            data: viem.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 = viem.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 = viem.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 = child_process.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
-  };
-}
-
 exports.Abi = Abi_exports;
 exports.BrandTypeId = BrandTypeId;
 exports.Callback = Callback_exports;
@@ -6624,7 +6037,6 @@ exports.CollectorHealth = CollectorHealth;
 exports.CollectorStore = CollectorStore_exports;
 exports.CollectorsHealthResponse = CollectorsHealthResponse;
 exports.Cursor = Cursor_exports;
-exports.EVM = EVM_exports;
 exports.Errors = Errors_exports;
 exports.Format = Format_exports;
 exports.Health = Health_exports;