@morpho-dev/router 0.1.1 → 0.1.3

package/dist/index.node.mjs

@@ -1,9 +1,8 @@
 import { Errors, LLTV, Offer, Format, Time, Maturity } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
-import { base, mainnet } from 'viem/chains';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
-import { parseUnits, maxUint256, formatUnits, parseAbi } from 'viem';
+import { parseUnits, maxUint256, formatUnits } from 'viem';
 import { Base64 } from 'js-base64';
 import { serve as serve$1 } from '@hono/node-server';
 import { Hono } from 'hono';
@@ -15,85 +14,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/Chain.ts
-var Chain_exports = {};
-__export(Chain_exports, {
-  ChainId: () => ChainId,
-  chainIds: () => chainIds,
-  chainNames: () => chainNames,
-  chains: () => chains,
-  getChain: () => getChain,
-  getWhitelistedChains: () => getWhitelistedChains
-});
-var chainNames = ["ethereum", "base", "ethereum-virtual-testnet"];
-var ChainId = {
-  ETHEREUM: BigInt(mainnet.id),
-  BASE: BigInt(base.id),
-  "ETHEREUM-VIRTUAL-TESTNET": 109111114n
-};
-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"]];
-};
-var chains = {
-  ethereum: {
-    ...mainnet,
-    id: ChainId.ETHEREUM,
-    name: "ethereum",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x0000000000000000000000000000000000000000"
-  },
-  base: {
-    ...base,
-    id: ChainId.BASE,
-    name: "base",
-    whitelistedAssets: new Set(
-      [
-        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        // USDC
-        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x0000000000000000000000000000000000000000"
-  },
-  "ethereum-virtual-testnet": {
-    ...mainnet,
-    id: 109111114n,
-    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
-    mempool: {
-      address: "0x7be3164eeee8b35092f6128ec32c2e6ff8f6c890",
-      deploymentBlock: 23223727,
-      reindexBuffer: 10
-    }
-  }
-};
-
 // src/core/apiSchema/index.ts
 var apiSchema_exports = {};
 __export(apiSchema_exports, {
@@ -1101,7 +1021,6 @@ function memory(parameters) {
   const map = parameters.offers;
   const filled = parameters.filled;
   const consumedIds = /* @__PURE__ */ new Set();
-  const indexingProgress = /* @__PURE__ */ new Map();
   const create = async (parameters2) => {
     if (map.has(parameters2.offer.hash.toLowerCase())) return parameters2.offer.hash;
     map.set(parameters2.offer.hash.toLowerCase(), {
@@ -1172,7 +1091,7 @@ function memory(parameters) {
       let {
         creators,
         side,
-        chains: chains2,
+        chains,
         loanTokens,
         status = ["valid"],
         callbackAddresses,
@@ -1243,7 +1162,7 @@ function memory(parameters) {
       offers = offers.filter((o) => o.expiry >= now);
       creators && (offers = offers.filter((o) => creators.includes(o.offering.toLowerCase())));
       side && (offers = offers.filter((o) => o.buy === buy));
-      chains2 && (offers = offers.filter((o) => chains2.includes(Number(o.chainId))));
+      chains && (offers = offers.filter((o) => chains.includes(Number(o.chainId))));
       loanTokens && (offers = offers.filter((o) => loanTokens.includes(o.loanToken.toLowerCase())));
       status && (offers = offers.filter((o) => status.includes(o.status)));
       callbackAddresses && (offers = offers.filter(
@@ -1449,15 +1368,6 @@ function memory(parameters) {
       filledForOffering.set(nonce, current + parameters2.consumed);
       filledForChain.set(address, filledForOffering);
       filled.set(chainId, filledForChain);
-    },
-    saveLatestBlockNumberProcessed: async (parameters2) => {
-      const key = `${parameters2.chainId.toString()}:${parameters2.eventType}`;
-      indexingProgress.set(key, parameters2.latestBlockNumber);
-    },
-    getLatestBlockNumberProcessed: async (parameters2) => {
-      const key = `${parameters2.chainId.toString()}:${parameters2.eventType}`;
-      const value = indexingProgress.get(key);
-      return value === void 0 ? null : { latestBlockNumber: value };
     }
   };
 }
@@ -1711,18 +1621,6 @@ function getLogger() {
   return loggerContext.getStore() ?? defaultLogger();
 }
 
-// src/RouterEvent.ts
-var RouterEvent_exports = {};
-__export(RouterEvent_exports, {
-  from: () => from2,
-  types: () => types
-});
-var types = ["offer_created", "offer_consumed", "offer_validation"];
-function from2(base) {
-  const id = base.type === "offer_consumed" ? `${base.type}:${base.offerConsumed.id}` : `${base.type}:${base.offer.hash.toLowerCase()}`;
-  return { id, ...base };
-}
-
 // src/Validation.ts
 var Validation_exports = {};
 __export(Validation_exports, {
@@ -1783,25 +1681,19 @@ function single(name, run2) {
 function batch2(name, run2) {
   return { kind: "batch", name, run: run2 };
 }
-function morpho(parameters) {
-  const { whitelistedChains } = parameters;
-  const whitelistedChainIds = new Set(whitelistedChains.map((chain) => chain.id));
-  const whitelistedLoanTokensPerChain = new Map(
-    whitelistedChains.map((chain) => [
-      chain.id,
-      new Set(Array.from(chain.whitelistedAssets).map((a) => a.toLowerCase()))
-    ])
-  );
-  const morphoPerChain = new Map(
-    whitelistedChains.map((chain) => [chain.id, chain.morpho.toLowerCase()])
-  );
-  const chainId = single("chain_id", (offer, _) => {
-    if (!whitelistedChainIds.has(offer.chainId)) {
-      return { message: `Chain ID ${offer.chainId} is not whitelisted` };
+function morpho() {
+  const chainId = single("chain_id", (offer, { chain }) => {
+    if (chain.id !== offer.chainId) {
+      return {
+        message: `Chain ID ${offer.chainId} is not the same as the chain ID in the context (${chain.id})`
+      };
     }
   });
-  const loanToken = single("loan_token", (offer, _) => {
-    if (!whitelistedLoanTokensPerChain.get(offer.chainId)?.has(offer.loanToken.toLowerCase())) {
+  const loanToken = single("loan_token", (offer, { chain }) => {
+    const tokens = new Set(
+      Array.from(chain.whitelistedAssets.values()).map((a) => a.toLowerCase())
+    );
+    if (!tokens.has(offer.loanToken.toLowerCase())) {
       return {
         message: `Loan token ${offer.loanToken} is not whitelisted on chain ${offer.chainId}`
       };
@@ -1812,130 +1704,21 @@ function morpho(parameters) {
       return { message: "Expiry mismatch" };
     }
   });
-  const emptyCallback = single("empty_callback", (offer, _) => {
-    if (offer.callback.data !== "0x") {
-      return { message: "Callback data is not empty. Not supported yet." };
+  const callback = single("empty_callback", (offer, _) => {
+    if (!offer.buy || offer.callback.data !== "0x") {
+      return { message: "Callback not supported yet." };
     }
   });
-  const sellOffersEmptyCallback = single(
-    "sell_offers_empty_callback",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data === "0x") {
-        return { message: "Sell offers with empty callback are not supported yet." };
-      }
-    }
-  );
-  const buyOffersEmptyCallback = batch2(
-    "buy_offers_empty_callback",
-    async (offers, { publicClients }) => {
-      const issues = /* @__PURE__ */ new Map();
-      const hashToIndex = /* @__PURE__ */ new Map();
-      for (let i = 0; i < offers.length; i++) {
-        const offer = offers[i];
-        hashToIndex.set(offer.hash, i);
-      }
-      const { buyOffers, sellOffers: _sellOffers } = offers.reduce(
-        (acc, offer) => {
-          offer.buy ? acc.buyOffers.push(offer) : issues.set(hashToIndex.get(offer.hash), {
-            message: "Onchain callback for sell offers is not supported yet."
-          });
-          return acc;
-        },
-        { buyOffers: [], sellOffers: [] }
-      );
-      const buyOffersPerLoanAsset = /* @__PURE__ */ new Map();
-      for (const offer of buyOffers) {
-        const chainName = getChain(offer.chainId)?.name;
-        const loanTokens = buyOffersPerLoanAsset.get(chainName) ?? /* @__PURE__ */ new Map();
-        const offers2 = loanTokens.get(offer.loanToken.toLowerCase()) ?? [];
-        offers2.push(offer);
-        loanTokens.set(offer.loanToken.toLowerCase(), offers2);
-        buyOffersPerLoanAsset.set(chainName, loanTokens);
-      }
-      await Promise.all(
-        Array.from(buyOffersPerLoanAsset.entries()).map(async ([name, loanTokens]) => {
-          const chainName = name;
-          const publicClient = publicClients[chainName];
-          const morpho2 = morphoPerChain.get(chains[chainName].id);
-          if (!publicClient) {
-            const offers2 = Array.from(loanTokens.values()).flat();
-            for (const offer of offers2) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Public client for chain "${chainName}" is not available`
-              });
-            }
-            return;
-          }
-          const balances = /* @__PURE__ */ new Map();
-          const allowances = /* @__PURE__ */ new Map();
-          for (const [loanToken2, offers2] of loanTokens) {
-            const data = await Promise.all(
-              offers2.flatMap((offer) => [
-                publicClient.readContract({
-                  address: loanToken2,
-                  abi: parseAbi([
-                    "function balanceOf(address owner) view returns (uint256 balance)"
-                  ]),
-                  functionName: "balanceOf",
-                  args: [offer.offering]
-                }),
-                publicClient.readContract({
-                  address: loanToken2,
-                  abi: parseAbi([
-                    "function allowance(address owner, address spender) public view returns (uint256 remaining)"
-                  ]),
-                  functionName: "allowance",
-                  args: [offer.offering, morpho2]
-                })
-              ])
-            );
-            for (let i = 0; i < offers2.length; i++) {
-              const user = offers2[i].offering.toLowerCase();
-              const balance = data[i * 2] || 0n;
-              const allowance = data[i * 2 + 1] || 0n;
-              const userBalances = balances.get(user) ?? /* @__PURE__ */ new Map();
-              userBalances.set(loanToken2.toLowerCase(), balance);
-              const userAllowances = allowances.get(user) ?? /* @__PURE__ */ new Map();
-              userAllowances.set(loanToken2.toLowerCase(), allowance);
-              balances.set(user, userBalances);
-              allowances.set(user, userAllowances);
-            }
-          }
-          for (const offer of Array.from(loanTokens.values()).flat()) {
-            const user = offer.offering.toLowerCase();
-            const userBalances = balances.get(user);
-            const balance = userBalances?.get(offer.loanToken.toLowerCase());
-            if (balance < offer.assets) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Insufficient balance for ${offer.loanToken} on chain ${offer.chainId} (${balance.toString()} < ${offer.assets.toString()})`
-              });
-              continue;
-            }
-            const userAllowances = allowances.get(user);
-            const allowance = userAllowances?.get(offer.loanToken.toLowerCase());
-            if (allowance < offer.assets) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Insufficient allowance for ${offer.loanToken} on chain ${offer.chainId} (${allowance.toString()} < ${offer.assets.toString()})`
-              });
-            }
-          }
-        })
-      );
-      return issues;
-    }
-  );
   return [
     chainId,
     loanToken,
     expiry,
-    // note: callback onchain check should be done last since it does not mean that the offer is forever invalid
-    // integrators should be able to keep the offers that have an invalid callback onchain and be sure that is the only check that is not valid
-    emptyCallback,
-    sellOffersEmptyCallback,
-    buyOffersEmptyCallback
+    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
+    // integrators should be able to choose if they want to keep the offer or not
+    callback
   ];
 }
 
-export { apiSchema_exports as ApiSchema, Chain_exports as Chain, Logger_exports as Logger, OfferStore_exports as OfferStore, router_exports as Router, RouterEvent_exports as RouterEvent, RouterOffer_exports as RouterOffer, utils_exports as Utils, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
+export { apiSchema_exports as ApiSchema, Logger_exports as Logger, OfferStore_exports as OfferStore, router_exports as Router, RouterOffer_exports as RouterOffer, utils_exports as Utils, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
 //# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map