@morpho-dev/router 0.0.10 → 0.0.12

package/dist/index.browser.js

@@ -0,0 +1,603 @@
+'use strict';
+
+var mempool = require('@morpho-dev/mempool');
+var chains$1 = require('viem/chains');
+var viem = require('viem');
+
+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);
+
+// src/Chain.ts
+var Chain_exports = {};
+__export(Chain_exports, {
+  ChainId: () => ChainId,
+  chainIds: () => chainIds,
+  chainNames: () => chainNames,
+  chains: () => chains,
+  getChain: () => getChain
+});
+var chainNames = ["ethereum", "base"];
+var ChainId = {
+  ETHEREUM: BigInt(chains$1.mainnet.id),
+  BASE: BigInt(chains$1.base.id)
+};
+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 chains = {
+  ethereum: {
+    ...chains$1.mainnet,
+    id: ChainId.ETHEREUM,
+    name: "ethereum",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000"
+  },
+  base: {
+    ...chains$1.base,
+    id: ChainId.BASE,
+    name: "base",
+    whitelistedAssets: new Set(
+      [
+        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        // USDC
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+        // DAI
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000"
+  }
+};
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InvalidUrlError: () => InvalidUrlError,
+  connect: () => connect,
+  get: () => get,
+  match: () => match
+});
+var MAX_BATCH_SIZE = 100;
+function connect(opts) {
+  const u = new URL(opts?.url || "https://router.morpho.dev");
+  if (u.protocol !== "http:" && u.protocol !== "https:") {
+    throw new InvalidUrlError(u.toString());
+  }
+  const headers = new Headers();
+  headers.set("Content-Type", "application/json");
+  opts?.apiKey !== void 0 ? headers.set("X-API-Key", opts.apiKey) : null;
+  const config = {
+    url: u,
+    headers
+  };
+  return {
+    ...config,
+    get: (parameters) => get(config, parameters),
+    match: (parameters) => match(config, parameters)
+  };
+}
+async function get(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 += `:${lltv}`;
+      return result;
+    }).join("#");
+    url.searchParams.set("collateral_tuple", tupleStr);
+  }
+  if (parameters.minLltv !== void 0) {
+    url.searchParams.set("min_lltv", parameters.minLltv.toString());
+  }
+  if (parameters.maxLltv !== void 0) {
+    url.searchParams.set("max_lltv", parameters.maxLltv.toString());
+  }
+  if (parameters.sortBy) {
+    url.searchParams.set("sort_by", parameters.sortBy);
+  }
+  if (parameters.sortOrder) {
+    url.searchParams.set("sort_order", parameters.sortOrder);
+  }
+  if (parameters.cursor) {
+    url.searchParams.set("cursor", parameters.cursor);
+  }
+  if (parameters.limit !== void 0) {
+    url.searchParams.set("limit", parameters.limit.toString());
+  }
+  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
+  return {
+    cursor: returnedCursor,
+    offers: offers.map((offer) => {
+      const baseOffer = mempool.Offer.fromSnakeCase(offer);
+      return {
+        ...baseOffer,
+        status: offer.status,
+        metadata: offer.metadata
+      };
+    })
+  };
+}
+async function match(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/match-offers`);
+  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}:${lltv}`).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) {
+    url.searchParams.set("cursor", parameters.cursor);
+  }
+  if (parameters.limit !== void 0) {
+    url.searchParams.set("limit", parameters.limit.toString());
+  }
+  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
+  return {
+    cursor: returnedCursor,
+    offers: offers.map((offer) => {
+      const baseOffer = mempool.Offer.fromSnakeCase(offer);
+      return {
+        ...baseOffer,
+        status: offer.status,
+        metadata: offer.metadata
+      };
+    })
+  };
+}
+async function getApi(config, url) {
+  if (url.searchParams.get("limit") && Number(url.searchParams.get("limit")) > MAX_BATCH_SIZE) {
+    throw new HttpGetOffersFailedError(
+      `The maximum number of offers that can be returned is ${MAX_BATCH_SIZE}.`,
+      {
+        details: `The limit is set to ${url.searchParams.get("limit")}. Maximum is ${MAX_BATCH_SIZE}.`
+      }
+    );
+  }
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: config.headers
+  });
+  if (!response.ok) {
+    switch (response.status) {
+      case 401:
+        throw new HttpUnauthorizedError();
+      case 403:
+        throw new HttpForbiddenError();
+      case 429:
+        throw new HttpRateLimitError();
+    }
+    throw new HttpGetOffersFailedError(`GET request returned ${response.status}`, {
+      details: await response.text()
+    });
+  }
+  return response.json();
+}
+var InvalidUrlError = class extends mempool.Errors.BaseError {
+  constructor(url) {
+    super(`URL "${url}" is not http/https.`);
+    __publicField(this, "name", "Router.InvalidUrlError");
+  }
+};
+var HttpUnauthorizedError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Unauthorized.", {
+      metaMessages: ["Ensure that an API key is provided."]
+    });
+    __publicField(this, "name", "Router.HttpUnauthorizedError");
+  }
+};
+var HttpForbiddenError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Forbidden.", {
+      metaMessages: ["Ensure that the API key is valid."]
+    });
+    __publicField(this, "name", "Router.HttpForbiddenError");
+  }
+};
+var HttpRateLimitError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Rate limit exceeded.", {
+      metaMessages: [
+        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
+      ]
+    });
+    __publicField(this, "name", "Router.HttpRateLimitError");
+  }
+};
+var HttpGetOffersFailedError = class extends mempool.Errors.BaseError {
+  constructor(message, { details } = {}) {
+    super(message, {
+      metaMessages: [details]
+    });
+    __publicField(this, "name", "Router.HttpGetOffersFailedError");
+  }
+};
+
+// src/RouterEvent.ts
+var RouterEvent_exports = {};
+__export(RouterEvent_exports, {
+  buildId: () => buildId,
+  types: () => types
+});
+var types = ["offer_created", "offer_matched", "offer_validation"];
+function buildId(event) {
+  switch (event.type) {
+    case "offer_created":
+      return `offer_created:${event.offer.hash.toLowerCase()}`;
+    case "offer_matched":
+      return `offer_matched:${event.offer.hash.toLowerCase()}`;
+    case "offer_validation":
+      return `offer_validation:${event.offer.hash.toLowerCase()}`;
+    default: {
+      throw new Error("Unhandled event type");
+    }
+  }
+}
+
+// src/RouterOffer.ts
+var RouterOffer_exports = {};
+__export(RouterOffer_exports, {
+  OfferStatusValues: () => OfferStatusValues
+});
+var OfferStatusValues = [
+  "valid",
+  "callback_not_supported",
+  "callback_error",
+  "unverified"
+];
+
+// src/utils/batch.ts
+function* batch(array, batchSize) {
+  for (let i = 0; i < array.length; i += batchSize) {
+    yield array.slice(i, i + batchSize);
+  }
+}
+
+// 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 watch = async () => {
+    await wait(interval);
+    const poll2 = async () => {
+      if (!active) return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch();
+  return unwatch;
+}
+
+// src/Validation.ts
+var Validation_exports = {};
+__export(Validation_exports, {
+  run: () => run
+});
+async function run(parameters) {
+  const { items, rules, ctx = {}, chunkSize } = parameters;
+  const issues = [];
+  let validItems = items.slice();
+  for (const rule of rules) {
+    if (validItems.length === 0) return { valid: [], issues };
+    const indicesToRemove = /* @__PURE__ */ new Set();
+    if (rule.kind === "single") {
+      for (let i = 0; i < validItems.length; i++) {
+        const item = validItems[i];
+        const issue = await rule.run(item, ctx);
+        if (issue) {
+          issues.push({ ...issue, ruleName: rule.name, item });
+          indicesToRemove.add(i);
+        }
+      }
+    } else if (rule.kind === "batch") {
+      const exec = async (slice, offset) => {
+        const map = await rule.run(slice, ctx);
+        for (let i = 0; i < slice.length; i++) {
+          const issue = map.get(i);
+          if (issue !== void 0) {
+            issues.push({ ...issue, ruleName: rule.name, item: slice[i] });
+            indicesToRemove.add(offset + i);
+          }
+        }
+      };
+      if (!chunkSize) await exec(validItems, 0);
+      else {
+        for (let i = 0; i < validItems.length; i += chunkSize) {
+          await exec(validItems.slice(i, i + chunkSize), i);
+        }
+      }
+    }
+    validItems = validItems.filter((_, i) => !indicesToRemove.has(i));
+  }
+  return {
+    valid: validItems,
+    issues
+  };
+}
+
+// src/ValidationRule.ts
+var ValidationRule_exports = {};
+__export(ValidationRule_exports, {
+  batch: () => batch2,
+  morpho: () => morpho,
+  single: () => single
+});
+function single(name, run2) {
+  return { kind: "single", name, run: 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` };
+    }
+  });
+  const loanToken = single("loan_token", (offer, _) => {
+    if (!whitelistedLoanTokensPerChain.get(offer.chainId)?.has(offer.loanToken.toLowerCase())) {
+      return {
+        message: `Loan token ${offer.loanToken} is not whitelisted on chain ${offer.chainId}`
+      };
+    }
+  });
+  const expiry = single("expiry", (offer, _) => {
+    if (offer.expiry < Math.floor(Date.now() / 1e3)) {
+      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 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: viem.parseAbi([
+                    "function balanceOf(address owner) view returns (uint256 balance)"
+                  ]),
+                  functionName: "balanceOf",
+                  args: [offer.offering]
+                }),
+                publicClient.readContract({
+                  address: loanToken2,
+                  abi: viem.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
+  ];
+}
+
+exports.Chain = Chain_exports;
+exports.Router = core_exports;
+exports.RouterEvent = RouterEvent_exports;
+exports.RouterOffer = RouterOffer_exports;
+exports.Validation = Validation_exports;
+exports.ValidationRule = ValidationRule_exports;
+exports.batch = batch;
+exports.poll = poll;
+exports.wait = wait;
+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