@morpho-dev/router 0.1.17 → 0.1.18

package/dist/index.node.js

@@ -447,8 +447,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x0000000000000000000000000000000000000000",
@@ -471,8 +475,12 @@ var chains = {
       [
         "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
         // USDC
-        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
         // DAI
+        "0x4200000000000000000000000000000000000006",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x0000000000000000000000000000000000000000",
@@ -495,8 +503,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
@@ -520,8 +532,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
@@ -1279,39 +1295,92 @@ function fromSnakeCase3(input) {
 function toSnakeCase2(offer) {
   return toSnakeCase(offer);
 }
-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);
+function random2(config) {
+  const chain = config?.chains ? config.chains[Math.floor(Math.random() * config.chains.length)] : chains.ethereum;
+  const loanToken = config?.loanTokens ? config.loanTokens[Math.floor(Math.random() * config.loanTokens.length)] : accounts.privateKeyToAccount(accounts.generatePrivateKey()).address;
+  const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [accounts.privateKeyToAccount(accounts.generatePrivateKey()).address];
+  const collateralAsset = collateralCandidates[Math.floor(Math.random() * collateralCandidates.length)];
+  const maturityOption = weightedChoice([
+    ["end_of_month", 1],
+    ["end_of_next_month", 1]
+  ]);
+  const maturity = config?.maturity ?? from3(maturityOption);
+  const lltv = from(
+    weightedChoice([
+      [0.385, 1],
+      [0.5, 1],
+      [0.625, 2],
+      [0.77, 8],
+      [0.86, 10],
+      [0.915, 8],
+      [0.945, 6],
+      [0.965, 4],
+      [0.98, 2]
+    ])
+  );
+  const buy = config?.buy !== void 0 ? config.buy : Math.random() > 0.5;
+  const ONE = 1000000000000000000n;
+  const qMin = buy ? 16 : 4;
+  const qMax = buy ? 32 : 16;
+  const len = qMax - qMin + 1;
+  const ratePairs = Array.from(
+    { length: len },
+    (_, idx) => {
+      const q = qMin + idx;
+      const scaledRate = BigInt(q) * (ONE / 4n);
+      const weight = buy ? 1 + idx : 1 + (len - 1 - idx);
+      return [scaledRate, weight];
+    }
+  );
+  const rate = config?.rate ?? weightedChoice(ratePairs);
+  const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
+  const unit = BigInt(10) ** BigInt(loanTokenDecimals);
+  const amountBase = BigInt(100 + Math.floor(Math.random() * (1e6 - 100 + 1)));
+  const assetsScaled = config?.assets ?? amountBase * unit;
+  const consumed2 = config?.consumed !== void 0 ? config.consumed : Math.random() < 0.8 ? 0n : assetsScaled * BigInt(1 + Math.floor(Math.random() * 900)) / 1000n;
+  const callbackBySide = (() => {
+    if (buy) return { address: viem.zeroAddress, data: "0x", gasLimit: 0n };
+    const sellCallbackAddress = WhitelistedCallbackAddresses["sell_erc20_callback" /* SellERC20Callback */][0].toLowerCase();
+    const amount = assetsScaled * 1000000000000000000000n;
+    const data = encodeSellERC20Callback({
+      collaterals: [collateralAsset],
+      amounts: [amount]
+    });
+    return { address: sellCallbackAddress, data, gasLimit: 500000n };
+  })();
   const offer = from5({
-    offering: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-    assets: BigInt(Math.floor(Math.random() * 1e6)),
-    rate: BigInt(Math.floor(Math.random() * 1e6)),
+    offering: config?.offering ?? accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    assets: assetsScaled,
+    rate,
     maturity,
-    expiry,
-    start: expiry - 10,
+    expiry: config?.expiry ?? maturity - 1,
+    start: config?.start ?? maturity - 10,
     nonce: BigInt(Math.floor(Math.random() * 1e6)),
-    buy: Math.random() > 0.5,
-    chainId: 1n,
+    buy,
+    chainId: chain.id,
     loanToken,
-    collaterals: [
+    collaterals: config?.collaterals ?? [
       from2({
-        asset: viem.zeroAddress,
+        asset: collateralAsset,
         oracle: viem.zeroAddress,
         lltv
       })
     ],
-    callback: {
-      address: viem.zeroAddress,
-      data: "0x",
-      gasLimit: 0n
-    },
-    consumed: 0n,
+    callback: config?.callback ?? callbackBySide,
+    consumed: consumed2,
     blockNumber: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
   });
   return offer;
 }
+var weightedChoice = (pairs) => {
+  const total = pairs.reduce((sum, [, weight]) => sum + weight, 0);
+  let roll = Math.random() * total;
+  for (const [value, weight] of pairs) {
+    roll -= weight;
+    if (roll < 0) return value;
+  }
+  return pairs[0][0];
+};
 var domain = (chainId) => ({
   chainId,
   verifyingContract: viem.zeroAddress
@@ -6141,6 +6210,157 @@ function serve(parameters) {
   });
 }
 
+// src/client/Client.ts
+var Client_exports = {};
+__export(Client_exports, {
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetApiFailedError: () => HttpGetApiFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InvalidUrlError: () => InvalidUrlError,
+  connect: () => connect3,
+  getObligations: () => getObligations2,
+  getOffers: () => getOffers2
+});
+function connect3(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 = options?.headers ?? new Headers();
+  headers.set("Content-Type", "application/json");
+  options?.apiKey !== void 0 ? headers.set("X-API-Key", options.apiKey) : null;
+  const config = {
+    url: u,
+    headers
+  };
+  return {
+    ...config,
+    getOffers: (parameters) => getOffers2(config, parameters),
+    getObligations: (parameters) => getObligations2(config, parameters)
+  };
+}
+async function getOffers2(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/offers`);
+  url.searchParams.set("side", parameters.side);
+  url.searchParams.set("obligation_id", parameters.obligationId.toString());
+  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: offers2 } = await getApi(config, url);
+  const routerOffers = offers2.map(Offer_exports.fromSnakeCase);
+  return {
+    cursor: returnedCursor,
+    offers: routerOffers
+  };
+}
+async function getObligations2(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) {
+    url.searchParams.set("limit", parameters.limit.toString());
+  }
+  const { cursor: returnedCursor, data: items } = await getApi(config, url);
+  const obligations2 = items.map((item) => {
+    const obligation = Obligation_exports.fromSnakeCase(item);
+    const { obligationId: _, ...returned } = {
+      id: () => Obligation_exports.id(obligation),
+      ...obligation,
+      ...Quote_exports.fromSnakeCase({ obligation_id: item.id, ask: item.ask, bid: item.bid })
+    };
+    return returned;
+  });
+  return {
+    cursor: returnedCursor,
+    obligations: obligations2
+  };
+}
+async function getApi(config, url) {
+  const pathname = url.pathname;
+  let action;
+  switch (true) {
+    case pathname.includes("/v1/offers"):
+      action = "get_offers";
+      break;
+    case pathname.includes("/v1/obligations"):
+      action = "get_obligations";
+      break;
+    default:
+      throw new HttpGetApiFailedError("Unknown endpoint", {
+        details: `Unsupported path: ${pathname}`
+      });
+  }
+  const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
+  if (!schemaParseResult.success) {
+    throw new HttpGetApiFailedError(`Invalid URL parameters`, {
+      details: schemaParseResult.error.issues[0]?.message
+    });
+  }
+  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 HttpGetApiFailedError(`GET request returned ${response.status}`, {
+      details: await response.text()
+    });
+  }
+  return response.json();
+}
+var InvalidUrlError = class extends BaseError {
+  name = "Router.InvalidUrlError";
+  constructor(url) {
+    super(`URL "${url}" is not http/https.`);
+  }
+};
+var HttpUnauthorizedError = class extends BaseError {
+  name = "Router.HttpUnauthorizedError";
+  constructor() {
+    super("Unauthorized.", {
+      metaMessages: ["Ensure that an API key is provided."]
+    });
+  }
+};
+var HttpForbiddenError = class extends BaseError {
+  name = "Router.HttpForbiddenError";
+  constructor() {
+    super("Forbidden.", {
+      metaMessages: ["Ensure that the API key is valid."]
+    });
+  }
+};
+var HttpRateLimitError = class extends BaseError {
+  name = "Router.HttpRateLimitError";
+  constructor() {
+    super("Rate limit exceeded.", {
+      metaMessages: [
+        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
+      ]
+    });
+  }
+};
+var HttpGetApiFailedError = class extends BaseError {
+  name = "Router.HttpGetApiFailedError";
+  constructor(message, { details } = {}) {
+    super(message, {
+      metaMessages: [details]
+    });
+  }
+};
+
 exports.Abi = Abi_exports;
 exports.BrandTypeId = BrandTypeId;
 exports.Callback = Callback_exports;
@@ -6173,6 +6393,7 @@ exports.OpenApi = OpenApi;
 exports.PG = PG_exports;
 exports.Quote = Quote_exports;
 exports.RouterApi = RouterApi_exports;
+exports.RouterClient = Client_exports;
 exports.RouterIndexer = RouterIndexer_exports;
 exports.RouterStatusResponse = RouterStatusResponse;
 exports.Services = Services_exports;