@berachain/berajs 0.2.8-beta.9 → 0.2.9

package/dist/chunk-CDFWPU2R.mjs

@@ -0,0 +1,473 @@
+import {
+  BeraTracing
+} from "./chunk-SZ5C44L5.mjs";
+import {
+  RequestError
+} from "./chunk-XIYN6AL6.mjs";
+
+// src/utils/getErrorResponse.ts
+async function getErrorResponse(response) {
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  } else {
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {
+        message: "Unknown error, can't decode response into JSON",
+        cause: text
+      };
+    }
+  }
+}
+
+// src/utils/sanitizeRpcUrl.ts
+function sanitizeRpcUrl(url) {
+  if (!url) return "";
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname.endsWith(".quiknode.pro")) {
+      parsed.pathname = "/";
+      parsed.search = "";
+      return parsed.toString();
+    }
+    return url;
+  } catch {
+    return url;
+  }
+}
+
+// src/utils/beraFetch.ts
+async function beraFetch(endpoint, options, spanContext) {
+  try {
+    let spanUrl = sanitizeRpcUrl(
+      typeof endpoint === "string" || endpoint instanceof URL ? endpoint.toString() : endpoint.url.toString()
+    ).replace(/0x[a-fA-F0-9]{40}/g, ":address");
+    if (spanContext?.keepQueryParams !== true && URL.canParse(spanUrl)) {
+      const queryParams = new URL(spanUrl).searchParams;
+      if (Array.isArray(spanContext?.keepQueryParams)) {
+        const searchParams = new URLSearchParams();
+        for (const param of spanContext.keepQueryParams) {
+          searchParams.set(param, queryParams.get(param) ?? "");
+        }
+        const newUrl = new URL(spanUrl);
+        newUrl.search = searchParams.toString();
+        spanUrl = newUrl.toString();
+      } else {
+        const newUrl = new URL(spanUrl);
+        newUrl.search = "";
+        spanUrl = newUrl.toString();
+      }
+    }
+    const endpointName = typeof endpoint === "string" || endpoint instanceof URL ? void 0 : endpoint.name;
+    return await BeraTracing.startSpan(
+      {
+        op: "beraFetch",
+        name: endpointName ? `beraFetch ${endpointName}` : "beraFetch",
+        attributes: typeof endpoint === "string" || endpoint instanceof URL ? {
+          "operation.source.url": spanUrl,
+          ...spanContext?.attributes
+        } : {
+          "operation.source.url": spanUrl,
+          "operation.source.type": endpoint.type,
+          "operation.source.name": endpoint.name,
+          ...spanContext?.attributes
+        }
+      },
+      async () => {
+        const response = await fetch(
+          typeof endpoint === "string" || endpoint instanceof URL ? endpoint : endpoint.url,
+          {
+            ...options
+          }
+        );
+        if (!response.ok) {
+          const error = await getErrorResponse(response);
+          throw new RequestError({
+            cause: error,
+            // @to-do import getErrorResponse logic in this function
+            // when it's removed from other places
+            response,
+            endpoint
+          });
+        }
+        return response;
+      }
+    );
+  } catch (error) {
+    if (error instanceof RequestError) {
+      throw error;
+    }
+    throw new RequestError({
+      cause: error,
+      endpoint,
+      response: void 0
+    });
+  }
+}
+async function beraFetchJson(endpoint, options) {
+  const response = await beraFetch(endpoint, {
+    ...options,
+    headers: {
+      Accept: "application/json",
+      ...options?.headers
+    }
+  });
+  return response.json();
+}
+
+// src/utils/constants.ts
+import { parseEther } from "viem";
+var CAP_LIMIT_BUFFER = parseEther("0.005");
+var MAX_CUSTOM_DEADLINE = 1e5;
+var MIN_CUSTOM_DEADLINE = 1;
+var MIN_CUSTOM_SLIPPAGE = 0.1;
+var MAX_CUSTOM_SLIPPAGE = 50;
+var DEFAULT_METAMASK_GAS_LIMIT = 7920027n;
+
+// src/utils/pythHoneyUtils.ts
+var getPythDefaultUpdateFee = (tokenListLength) => {
+  return 2n * BigInt(tokenListLength);
+};
+
+// src/utils/time.ts
+function msToSeconds(ms) {
+  return Math.floor(ms / 1e3);
+}
+function seconds(seconds2) {
+  return seconds2 * 1e3;
+}
+function minutes(minutes2) {
+  return minutes2 * seconds(60);
+}
+function minutesInSeconds(minutes2) {
+  return minutes2 * 60;
+}
+function hours(hours2) {
+  return hours2 * minutes(60);
+}
+function hoursInSeconds(hours2) {
+  return hours2 * minutesInSeconds(60);
+}
+function days(days2) {
+  return days2 * hours(24);
+}
+function daysInSeconds(days2) {
+  return days2 * hoursInSeconds(24);
+}
+function weeks(weeks2) {
+  return weeks2 * days(7);
+}
+function weeksInSeconds(weeks2) {
+  return weeks2 * daysInSeconds(7);
+}
+function months(months2) {
+  return months2 * days(30);
+}
+function monthsInSeconds(months2) {
+  return months2 * daysInSeconds(30);
+}
+function years(years2) {
+  return years2 * days(365);
+}
+function yearsInSeconds(years2) {
+  return years2 * daysInSeconds(365);
+}
+
+// src/utils/formatTimestamps.ts
+function calculateTimestampFromDays(daysRange) {
+  const currentDate = /* @__PURE__ */ new Date();
+  return currentDate.setDate(currentDate.getDate() - daysRange) * 1e3;
+}
+var monthNames = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var shortMonthNames = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatUnixTimestamp(unixTimestamp, isShort) {
+  const date = new Date(unixTimestamp * 1e3);
+  const day = date.getDate();
+  let daySuffix = "th";
+  if (day === 1 || day === 21 || day === 31) {
+    daySuffix = "st";
+  } else if (day === 2 || day === 22) {
+    daySuffix = "nd";
+  } else if (day === 3 || day === 23) {
+    daySuffix = "rd";
+  }
+  if (isShort) {
+    return `${shortMonthNames[date.getMonth()]} ${day}`;
+  }
+  return `${monthNames[date.getMonth()]} ${day}${daySuffix}, ${date.getFullYear()}`;
+}
+function formatTimeLeft(...args) {
+  const timeLeftInSeconds = args[0];
+  let condensed;
+  let showDays;
+  let showMinutes;
+  let showSeconds;
+  if (typeof args[1] !== "object") {
+    condensed = args[1] ?? false;
+    showDays = args[2] ?? false;
+    showSeconds = args[3] ?? false;
+    showMinutes = true;
+  } else {
+    const opts = args[1];
+    condensed = opts.condensed ?? false;
+    const greaterUnit = opts.greaterUnit ?? "hours";
+    if (greaterUnit === "days") {
+      showDays = true;
+      showMinutes = true;
+    } else if (greaterUnit === "hours") {
+      showDays = false;
+      showMinutes = true;
+      showSeconds = false;
+    } else {
+      showDays = false;
+      showMinutes = true;
+    }
+    showSeconds = opts.showSeconds ?? false;
+  }
+  let days2 = Math.floor(timeLeftInSeconds / (3600 * 24));
+  let hours2 = Math.floor(timeLeftInSeconds % (3600 * 24) / 3600);
+  const minutes2 = Math.floor(timeLeftInSeconds % 3600 / 60);
+  const seconds2 = timeLeftInSeconds % 60;
+  if (!showDays) {
+    hours2 += days2 * 24;
+    days2 = 0;
+  }
+  if (days2 === 0 && hours2 === 0 && minutes2 === 0) {
+    return condensed ? "< 1 M" : "less than a minute";
+  }
+  const daysDisplay = days2 > 0 ? `${days2}${condensed ? "D" : " day"}${!condensed && days2 !== 1 ? "s" : ""}` : "";
+  const hoursDisplay = hours2 > 0 ? `${hours2}${condensed ? "H" : " hour"}${!condensed && hours2 !== 1 ? "s" : ""}` : "";
+  const minutesDisplay = minutes2 > 0 && showMinutes || !days2 && !hours2 ? `${minutes2}${condensed ? "M" : " minute"}${!condensed && minutes2 !== 1 ? "s" : ""}` : "";
+  const secondsDisplay = seconds2 > 0 && showSeconds ? `${seconds2}${condensed ? "S" : " second"}${!condensed && seconds2 !== 1 ? "s" : ""}` : "";
+  return [daysDisplay, hoursDisplay, minutesDisplay, secondsDisplay].filter(Boolean).join(condensed ? " " : ", ");
+}
+
+// ../utils/src/pkg/bignumber.js.ts
+import BigNumber from "bignumber.js";
+BigNumber.set({
+  // The EXPONENTIAL_AT option defines the exponent value(s) at which toString returns exponential notation.
+  // - Single number: the exponent magnitude at and above which exponential notation is used (e.g., `1e9` here disables it for almost all values).
+  // - 1e9 is the maximum value supported by BigNumber.js.
+  // See: https://mikemcl.github.io/bignumber.js/#exponential-at
+  EXPONENTIAL_AT: 1e9
+});
+var bignumber_js_default = BigNumber;
+
+// src/utils/formatNumber.ts
+var POSTFIXES = ["", "K", "M", "B", "T", "P", "E", "Z", "Y"];
+function valueToBigNumber(amount) {
+  if (amount instanceof bignumber_js_default) return amount;
+  return new bignumber_js_default(amount);
+}
+function normalizeBN(n, decimals) {
+  return valueToBigNumber(n).shiftedBy(decimals * -1);
+}
+function formatNumber(value, options = {}) {
+  if (typeof options === "number") {
+    const decimals2 = options;
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    if (typeof value === "object") {
+      throw new Error("Value must be a number if using deprecated version");
+    }
+    let formatted = Number(value).toFixed(decimals2);
+    formatted = formatted.replace(/(\.\d*?[1-9])0+$|\.0*$/, "$1");
+    return formatted;
+  }
+  const {
+    visibleDecimals,
+    compact = true,
+    percent = false,
+    roundDown = false,
+    roundUp = false,
+    compactThreshold,
+    maxValue,
+    symbol,
+    prefixText = "",
+    suffixText = "",
+    showIsSmallerThanMin = true,
+    ifNullish = ""
+  } = options || {};
+  if (value === void 0 || value === null) {
+    return ifNullish;
+  }
+  const number = percent ? Number(value) * 100 : Number(value);
+  if (Number.isNaN(number)) {
+    return "NaN";
+  }
+  if (number === Number.POSITIVE_INFINITY) {
+    return "Infinity";
+  }
+  if (number === Number.NEGATIVE_INFINITY) {
+    return "-Infinity";
+  }
+  let decimals = visibleDecimals ?? 0;
+  if (number === 0) {
+    decimals = 0;
+  } else if (visibleDecimals === void 0) {
+    if (Math.abs(number) > 1 || percent || symbol === "USD") {
+      decimals = 2;
+    } else {
+      decimals = 7;
+    }
+  }
+  const minValue = 10 ** -decimals;
+  const isSmallerThanMin = number !== 0 && Math.abs(number) < Math.abs(minValue);
+  const isNegative = number < 0;
+  const isBiggerThanMax = maxValue ? Math.abs(number) > maxValue : false;
+  let formattedNumber = isSmallerThanMin ? minValue : number;
+  const forceCompact = compact && (!compactThreshold || Math.abs(number) > compactThreshold);
+  if (roundDown && !forceCompact) {
+    formattedNumber = Math.trunc(Number(formattedNumber) * 10 ** decimals) / 10 ** decimals;
+  } else if (roundUp && !forceCompact) {
+    formattedNumber = Math.ceil(Number(formattedNumber) * 10 ** decimals) / 10 ** decimals;
+  }
+  let formattedValue;
+  if (isBiggerThanMax) {
+    formattedValue = number > maxValue ? "\u221E" : "-\u221E";
+  } else if (!forceCompact) {
+    const absFormatted = new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: decimals,
+      minimumFractionDigits: decimals
+    }).format(Math.abs(formattedNumber));
+    formattedValue = `${isNegative ? "-" : ""}${absFormatted}`;
+  } else {
+    const bnValue = valueToBigNumber(formattedNumber);
+    let integerPlaces = bnValue.abs().toFixed(0).length;
+    if (compactThreshold && Math.abs(number) <= compactThreshold) {
+      integerPlaces = 0;
+    }
+    const significantDigitsGroup = Math.min(
+      Math.floor(integerPlaces ? (integerPlaces - 1) / 3 : 0),
+      POSTFIXES.length - 1
+    );
+    const postfix = POSTFIXES[significantDigitsGroup];
+    let compactValue = normalizeBN(
+      bnValue,
+      3 * significantDigitsGroup
+    ).toNumber();
+    if (roundDown) {
+      compactValue = Math.trunc(Number(compactValue) * 10 ** decimals) / 10 ** decimals;
+    } else if (roundUp) {
+      compactValue = Math.ceil(Number(compactValue) * 10 ** decimals) / 10 ** decimals;
+    }
+    const prefix = new Intl.NumberFormat("en-US", {
+      maximumFractionDigits: decimals,
+      minimumFractionDigits: decimals
+    }).format(compactValue);
+    formattedValue = `${prefix}${postfix}`;
+  }
+  const parts = [];
+  if (prefixText) {
+    parts.push(prefixText);
+  }
+  if (isSmallerThanMin && showIsSmallerThanMin) {
+    parts.push(number < 0 ? ">" : "<");
+  }
+  if (symbol?.toLowerCase() === "usd" && !percent) {
+    parts.push("$");
+  }
+  parts.push(formattedValue);
+  if (percent) {
+    parts.push("%");
+  }
+  if (symbol?.toLowerCase() !== "usd" && typeof symbol !== "undefined") {
+    parts.push(" ", symbol);
+  }
+  if (suffixText) {
+    parts.push(suffixText);
+  }
+  return parts.join("");
+}
+var getSafeNumber = (value) => {
+  if (!value) return 0;
+  return Number(value) > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(value) ?? 0;
+};
+var truncateDecimal = (value, maxDecimal) => {
+  if (!value) return "0";
+  const [integerPart = "0", decimalPart = "0"] = `${value}`.split(".");
+  return `${integerPart}.${decimalPart.substring(0, maxDecimal)}`;
+};
+
+// src/utils/getTestClient.ts
+import { createTestClient, http } from "viem";
+import {
+  defaultChainId,
+  getRpcUrls
+} from "@berachain/config/internal";
+function getTestClient(chainId = defaultChainId) {
+  const rpc = getRpcUrls(chainId);
+  if (!rpc.isAnvil) {
+    throw new Error("No anvil RPC URL found");
+  }
+  return createTestClient({
+    mode: "anvil",
+    transport: http(rpc.jsonRpcUrl)
+  });
+}
+
+export {
+  bignumber_js_default,
+  getErrorResponse,
+  sanitizeRpcUrl,
+  beraFetch,
+  beraFetchJson,
+  CAP_LIMIT_BUFFER,
+  MAX_CUSTOM_DEADLINE,
+  MIN_CUSTOM_DEADLINE,
+  MIN_CUSTOM_SLIPPAGE,
+  MAX_CUSTOM_SLIPPAGE,
+  DEFAULT_METAMASK_GAS_LIMIT,
+  getPythDefaultUpdateFee,
+  msToSeconds,
+  seconds,
+  minutes,
+  minutesInSeconds,
+  hours,
+  hoursInSeconds,
+  days,
+  daysInSeconds,
+  weeks,
+  weeksInSeconds,
+  months,
+  monthsInSeconds,
+  years,
+  yearsInSeconds,
+  calculateTimestampFromDays,
+  formatUnixTimestamp,
+  formatTimeLeft,
+  formatNumber,
+  getSafeNumber,
+  truncateDecimal,
+  getTestClient
+};