@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/dist/chunk-QVHEM4BG.mjs

@@ -0,0 +1,35 @@
+import {
+  bignumber_js_default
+} from "./chunk-E7YFXBBQ.mjs";
+import {
+  isToken,
+  wBeraToken
+} from "./chunk-IXIBY5FP.mjs";
+
+// src/utils/tokenWrapping.ts
+function wrapNativeToken(token) {
+  return {
+    ...token,
+    ...isToken(token, "BERA") && wBeraToken
+  };
+}
+function wrapNativeTokens(tokens) {
+  return tokens.map((token) => wrapNativeToken(token));
+}
+
+// src/utils/math.ts
+var computePriceImpact = (tokenInPrice, tokenOutPrice, inAmount, outAmount) => {
+  if (!tokenInPrice || !tokenOutPrice || !inAmount || !outAmount) return 0;
+  const usdIn = new bignumber_js_default(tokenInPrice).times(inAmount);
+  const usdOut = new bignumber_js_default(tokenOutPrice).times(outAmount);
+  if (usdIn.lt(0.01) || usdOut.lt(0.01)) return 0;
+  if (usdIn.isZero() || usdOut.isZero()) return 0;
+  const ratio = usdOut.div(usdIn);
+  return Number(new bignumber_js_default(1).minus(ratio).toFixed());
+};
+
+export {
+  wrapNativeToken,
+  wrapNativeTokens,
+  computePriceImpact
+};

package/dist/chunk-SGIJVHZO.mjs

@@ -0,0 +1,12 @@
+// src/enum/polling.ts
+var POLLING = /* @__PURE__ */ ((POLLING2) => {
+  POLLING2[POLLING2["FAST"] = 1e4] = "FAST";
+  POLLING2[POLLING2["NORMAL"] = 1e5] = "NORMAL";
+  POLLING2[POLLING2["SLOW"] = 18e4] = "SLOW";
+  POLLING2[POLLING2["REFRESH_BLOCK_INTERVAL"] = 1e4] = "REFRESH_BLOCK_INTERVAL";
+  return POLLING2;
+})(POLLING || {});
+
+export {
+  POLLING
+};

package/dist/chunk-SZ5C44L5.mjs

@@ -0,0 +1,35 @@
+// src/errors/BeraTracing.ts
+var _handlers = [];
+var BeraTracing = {
+  /**
+   * Execute a callback, wrapping it in all registered span handlers.
+   *
+   * Handlers chain so each wraps the next. First registered = outermost wrapper.
+   * If no handlers are registered, the callback is executed directly.
+   */
+  startSpan(context, callback) {
+    if (_handlers.length === 0) return callback();
+    return _handlers.reduceRight(
+      (next, handler) => () => handler(context, next),
+      callback
+    )();
+  },
+  /**
+   * Register a span tracing handler.
+   *
+   * @param _event - Must be "span". Exists for API consistency with BeraMonitoring.
+   * @param handler - A StartSpanFn, e.g. Sentry.startSpan.
+   * @returns An unsubscribe function to remove the handler.
+   */
+  addSpanHandler(handler) {
+    _handlers.push(handler);
+    return () => {
+      const idx = _handlers.indexOf(handler);
+      if (idx !== -1) _handlers.splice(idx, 1);
+    };
+  }
+};
+
+export {
+  BeraTracing
+};

package/dist/chunk-WNBWX23Q.mjs

@@ -0,0 +1,426 @@
+import {
+  getBalanceCall,
+  getEnsoClient
+} from "./chunk-HYDP32P6.mjs";
+import {
+  BeraMonitoring,
+  initBeraError
+} from "./chunk-7YVNSDXG.mjs";
+import {
+  defaultFlags
+} from "./chunk-BGMRHTBQ.mjs";
+import {
+  beraToken,
+  isToken
+} from "./chunk-IXIBY5FP.mjs";
+import {
+  parseBaseArgs
+} from "./chunk-DQRH5VE3.mjs";
+import {
+  BeraError,
+  InvalidArgumentError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/contexts/BeraFlags/BeraFlags.tsx
+import { createContext, useContext } from "react";
+import {
+  isFlagEnabled
+} from "@berachain/config/internal/edge-config";
+import { jsx } from "react/jsx-runtime";
+var BeraFlagContext = createContext(
+  void 0
+);
+function BeraFlagsProvider({
+  children,
+  flags,
+  aggregators,
+  swberaAprWindow = "DAY"
+}) {
+  return /* @__PURE__ */ jsx(
+    BeraFlagContext.Provider,
+    {
+      value: {
+        ...defaultFlags,
+        ...flags,
+        aggregators: aggregators ? Object.entries(aggregators).filter(([, value]) => isFlagEnabled(value)).map(([key]) => key) : void 0,
+        swberaAprWindow
+      },
+      children
+    }
+  );
+}
+function useBeraFlags() {
+  const context = useContext(BeraFlagContext);
+  if (!context) {
+    throw new Error("BeraFlagsProvider not found");
+  }
+  return context;
+}
+function useBeraFlag(key) {
+  const flags = useBeraFlags();
+  return flags[key];
+}
+
+// src/contexts/BexStatusProvider.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useState
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BexStateContext = createContext2({
+  protocol: {
+    isPaused: false,
+    factories: {
+      composableStable: "enabled",
+      weighted: "enabled",
+      allPaused: false
+    }
+  },
+  onPoolChange: () => {
+  },
+  pool: void 0
+});
+function useBexStatus() {
+  const context = useContext2(BexStateContext);
+  if (!context) {
+    throw new BeraError({
+      level: "fatal",
+      message: "BexStateContext is not defined"
+    });
+  }
+  return context;
+}
+function BexStatusProvider({
+  children,
+  isVaultPaused,
+  labels,
+  factories
+}) {
+  const [poolState, setPoolState] = useState();
+  const disablePoolWithdrawals = (poolState?.isPaused && !poolState?.isInRecoveryMode) ?? false;
+  const disablePoolDeposits = isVaultPaused || poolState?.isPaused;
+  return /* @__PURE__ */ jsx2(
+    BexStateContext.Provider,
+    {
+      value: {
+        protocol: {
+          isPaused: isVaultPaused,
+          factories: {
+            ...factories,
+            allPaused: factories.composableStable === "paused" && factories.weighted === "paused"
+          }
+        },
+        labels,
+        onPoolChange: setPoolState,
+        pool: poolState ? {
+          ...poolState,
+          disablePoolWithdrawals: !!disablePoolWithdrawals,
+          disablePoolDeposits: !!disablePoolDeposits
+        } : void 0
+      },
+      children
+    }
+  );
+}
+
+// src/contexts/block-time-provider.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { mainnet } from "@berachain/config/mainnet";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function useBlockTime() {
+  return useContext3(BlockTimeContext);
+}
+var BlockTimeContext = createContext3(
+  // this is the default block time for berachain, but actually overridden by the block time provider
+  mainnet.averageBlockTime
+);
+function BlockTimeProvider({
+  children,
+  blockTime,
+  ...args
+}) {
+  const { config } = parseBaseArgs(args);
+  return /* @__PURE__ */ jsx3(BlockTimeContext.Provider, { value: blockTime ?? config.averageBlockTime, children });
+}
+
+// src/contexts/HoneyConfigProvider.tsx
+import { createContext as createContext4, useContext as useContext4 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var HoneyConfigContext = createContext4(void 0);
+function HoneyConfigProvider({
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx4(HoneyConfigContext.Provider, { value: props, children });
+}
+function useHoneyConfig() {
+  const context = useContext4(HoneyConfigContext);
+  if (!context) {
+    throw new Error("useHoneyConfig must be used within a HoneyConfigProvider");
+  }
+  return context;
+}
+
+// src/hooks/enso/useEnsoUserTokensWithBalances.ts
+import useSWR from "swr";
+import { useBeraWallet, useConfig } from "@berachain/wagmi/hooks";
+
+// src/actions/enso/getEnsoUserTokensWithBalances.ts
+import { getChains, multicall } from "@wagmi/core";
+import { formatUnits } from "viem";
+async function getEnsoUserTokensWithBalances({
+  account,
+  wagmiConfig,
+  chainId,
+  ensoClient
+}) {
+  const ensoBalances = await ensoClient.getBalances({
+    useEoa: true,
+    chainId: chainId ?? "all",
+    eoaAddress: account
+  });
+  if (!Array.isArray(ensoBalances)) {
+    BeraMonitoring.captureException(
+      new InvalidArgumentError({
+        property: "ensoBalances",
+        value: ensoBalances,
+        expected: "BalanceToken[]",
+        chainId: typeof chainId === "number" ? chainId : void 0,
+        extra: { account, chainId }
+      })
+    );
+    return [];
+  }
+  const tokens = ensoBalances.map(
+    (balance) => ({
+      name: balance.name,
+      symbol: balance.symbol,
+      decimals: balance.decimals,
+      address: isToken(balance.token, "ETH") ? beraToken.address : balance.token,
+      logoURI: balance.logoUri,
+      balance: {
+        raw: balance.amount.toString(),
+        formatted: formatUnits(BigInt(balance.amount), balance.decimals)
+      },
+      chainId: Number(
+        // @ts-expect-error - balance.chainId is defined just not typed by enso
+        balance.chainId
+      ),
+      price: Number(balance.price)
+    })
+  );
+  const tokenByChainId = Object.groupBy(tokens, (a) => a.chainId ?? 0);
+  const balances = await Promise.allSettled(
+    Object.entries(tokenByChainId).map(async ([chainId2, chainTokens]) => {
+      if (!chainTokens) return void 0;
+      const chainConfig = getChains(wagmiConfig).find(
+        (chain) => chain.id === Number(chainId2)
+      );
+      if (!chainConfig) {
+        return void 0;
+      }
+      const multicall3 = chainConfig.contracts?.multicall3;
+      const multicallAddress = multicall3?.address;
+      if (!multicallAddress) {
+        BeraMonitoring.captureException(
+          new InvalidArgumentError({
+            property: "multicallAddress",
+            value: multicallAddress,
+            expected: "Address",
+            chainId: Number(chainId2)
+          })
+        );
+        return chainTokens;
+      }
+      const balances2 = await multicall(wagmiConfig, {
+        chainId: Number(chainId2),
+        contracts: chainTokens.map(
+          (token) => getBalanceCall({
+            token,
+            account,
+            multicallAddress
+          })
+        ),
+        allowFailure: true
+      });
+      const tokensWithBalances = [];
+      for (let index = 0; index < chainTokens.length; index++) {
+        const token = chainTokens[index];
+        if (balances2[index].status === "success") {
+          const balance = balances2[index].result;
+          tokensWithBalances.push({
+            ...token,
+            balance: {
+              raw: balance?.toString() ?? "0",
+              formatted: formatUnits(balance ?? 0n, token.decimals)
+            }
+          });
+        } else {
+          console.error("error getting balance", balances2[index].error);
+          BeraMonitoring.captureException(
+            initBeraError({ cause: balances2[index].error })
+          );
+          tokensWithBalances.push(token);
+        }
+      }
+      return tokensWithBalances;
+    })
+  );
+  const flattenedBalances = [];
+  for (const result of balances) {
+    if (result.status === "fulfilled") {
+      flattenedBalances.push(...result.value ?? []);
+    } else {
+      BeraMonitoring.captureException(initBeraError({ cause: result.reason }));
+    }
+  }
+  return flattenedBalances.sort((a, b) => {
+    const aValue = Number(a.balance.formatted) * (a.price ?? 0);
+    const bValue = Number(b.balance.formatted) * (b.price ?? 0);
+    return bValue - aValue;
+  });
+}
+
+// src/hooks/enso/useEnsoUserTokensWithBalances.ts
+function useEnsoUserTokensWithBalances({ chainId } = {}, options) {
+  const { address: fromAddress } = useBeraWallet();
+  const wagmiConfig = useConfig();
+  const proxyAggregatorsThroughVercel = useBeraFlag(
+    "proxyAggregatorsThroughVercel"
+  );
+  const isEnabled = !!fromAddress && (options?.opts?.isEnabled ?? true);
+  const QUERY_KEY = isEnabled && wagmiConfig ? [
+    "useEnsoUserTokensWithBalances",
+    fromAddress,
+    chainId,
+    proxyAggregatorsThroughVercel ?? false
+  ] : null;
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, fromAddress2, chainId2]) => getEnsoUserTokensWithBalances({
+      account: fromAddress2,
+      wagmiConfig,
+      chainId: chainId2 ?? "all",
+      ensoClient: getEnsoClient({
+        baseURL: proxyAggregatorsThroughVercel ? "/api/enso" : void 0
+      })
+    }),
+    {
+      refreshInterval: 1e5 /* NORMAL */,
+      isEnabled,
+      ...options?.opts
+    }
+  );
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate()
+  };
+}
+
+// src/contexts/TokensProvider.tsx
+import { createContext as createContext5, useMemo } from "react";
+import {
+  isFlagEnabled as isFlagEnabled2
+} from "@berachain/config/internal/edge-config";
+
+// src/utils/formatTokenList.ts
+function formatTokenList({
+  defaultTokenList = [],
+  externalList = []
+}) {
+  if (defaultTokenList.length === 0) {
+    return {
+      tokenList: externalList,
+      customTokenList: externalList,
+      featuredTokenList: []
+    };
+  }
+  const defaultList = defaultTokenList.map((token) => {
+    return { ...token, default: true };
+  });
+  const featuredTokenList = defaultList.filter((token) => {
+    return token.tags?.some((tag) => tag === "featured");
+  });
+  const mergedList = [...defaultList, ...externalList];
+  const uniqueList = mergedList.filter(
+    (item, index) => mergedList.findIndex((i) => isToken(i, item)) === index
+  );
+  return {
+    tokenList: uniqueList,
+    customTokenList: externalList,
+    featuredTokenList
+  };
+}
+
+// src/contexts/TokensProvider.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var TokenContext = createContext5(
+  void 0
+);
+function TokensProvider({
+  children,
+  defaultTokens,
+  edgeConfigTokenList,
+  userTokens,
+  onAddToken,
+  onRemoveToken
+}) {
+  const { data: ensoTokens, refresh } = useEnsoUserTokensWithBalances();
+  const { tokenList = [], featuredTokenList = [] } = useMemo(
+    () => formatTokenList({
+      defaultTokenList: [
+        ...defaultTokens,
+        ...edgeConfigTokenList?.filter(
+          (token) => isFlagEnabled2(token.enabled)
+        )
+      ],
+      externalList: [
+        ...userTokens,
+        ...(ensoTokens ?? []).map((t) => ({
+          ...t,
+          balance: void 0,
+          price: void 0
+        }))
+      ]
+    }),
+    [defaultTokens, userTokens, edgeConfigTokenList, ensoTokens]
+  );
+  return /* @__PURE__ */ jsx5(
+    TokenContext.Provider,
+    {
+      value: {
+        tokenList,
+        userTokens,
+        featuredTokens: featuredTokenList,
+        ensoTokens,
+        onAddToken(tk) {
+          onAddToken(tk, { defaultTokens, userTokens, tokenList });
+        },
+        onRemoveToken,
+        refresh: () => {
+          refresh();
+        }
+      },
+      children
+    }
+  );
+}
+
+export {
+  BeraFlagsProvider,
+  useBeraFlags,
+  useBeraFlag,
+  BexStateContext,
+  useBexStatus,
+  BexStatusProvider,
+  useBlockTime,
+  BlockTimeContext,
+  BlockTimeProvider,
+  HoneyConfigContext,
+  HoneyConfigProvider,
+  useHoneyConfig,
+  useEnsoUserTokensWithBalances,
+  TokenContext,
+  TokensProvider
+};

package/dist/chunk-Y6THHG77.mjs

@@ -0,0 +1,126 @@
+import {
+  BeraTracing
+} from "./chunk-SZ5C44L5.mjs";
+import {
+  RequestError
+} from "./chunk-ZLTMIFCZ.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();
+}
+
+export {
+  getErrorResponse,
+  sanitizeRpcUrl,
+  beraFetch,
+  beraFetchJson
+};