@berachain/berajs 0.2.8-beta.9 → 0.2.9

package/dist/chunk-3EARVV7K.mjs

@@ -0,0 +1,414 @@
+import {
+  getBalanceCall,
+  getEnsoClient
+} from "./chunk-HSSJKHZ4.mjs";
+import {
+  BeraMonitoring,
+  initBeraError
+} from "./chunk-EXIUPSFN.mjs";
+import {
+  defaultFlags
+} from "./chunk-BGMRHTBQ.mjs";
+import {
+  beraToken,
+  isToken
+} from "./chunk-NPBQLVL3.mjs";
+import {
+  parseBaseArgs
+} from "./chunk-75M6TF7M.mjs";
+import {
+  BeraError,
+  InvalidArgumentError
+} from "./chunk-J5I45WGQ.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
+  });
+  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-4Z4AK6SH.mjs

@@ -0,0 +1,211 @@
+import {
+  parseBaseArgs
+} from "./chunk-75M6TF7M.mjs";
+import {
+  BeraTracing
+} from "./chunk-SZ5C44L5.mjs";
+import {
+  RequestError
+} from "./chunk-XIYN6AL6.mjs";
+import {
+  BeraError
+} from "./chunk-J5I45WGQ.mjs";
+
+// src/actions/clients/BeraApolloClient.ts
+import {
+  ApolloClient,
+  ServerError
+} from "@apollo/client";
+import { appConfig } from "@berachain/config/internal";
+var BeraApolloClient = class extends ApolloClient {
+  /**
+   * The URL of the endpoint. Used for error reporting only.
+   */
+  url;
+  serviceName;
+  constructor(options) {
+    super(options);
+    this.url = options.url;
+    this.serviceName = options.name;
+  }
+  async query(options) {
+    const queryName = getQueryName(options.query);
+    const endpoint = {
+      url: this.url,
+      type: "graphql",
+      name: this.serviceName
+    };
+    const tags = {
+      "operation.type": "query",
+      "operation.source.name": endpoint.name,
+      "operation.source.url": endpoint.url,
+      "operation.source.type": endpoint.type,
+      "operation.source.queryName": queryName
+    };
+    try {
+      const executeQuery = () => super.query(
+        options
+      );
+      const res = await BeraTracing.startSpan(
+        {
+          name: `GraphQL ${queryName}`,
+          op: "BeraApolloClient.query",
+          attributes: tags
+        },
+        executeQuery
+      );
+      if (res.error || res.data === void 0) {
+        throw new BeraError({
+          level: "fatal",
+          tags,
+          message: "Bera Apollo Client: No data returned from query, but error should be thrown since errorPolicy is none"
+        });
+      }
+      return { data: res.data };
+    } catch (error) {
+      !appConfig.env.isProduction && console.error("BeraApolloClient error", error);
+      if (ServerError.is(error)) {
+        throw new RequestError({
+          // reason: error,
+          response: error.response,
+          cause: error,
+          statusCode: error.statusCode,
+          endpoint,
+          tags
+        });
+      }
+      if (error instanceof TypeError) {
+        throw new RequestError({
+          level: "fatal",
+          reason: "TypeError",
+          response: error,
+          cause: error,
+          endpoint,
+          tags
+        });
+      }
+      throw new RequestError({
+        response: error,
+        tags,
+        cause: error,
+        endpoint
+      });
+    }
+  }
+};
+function getQueryName(queryDefinition) {
+  const likelyNode = queryDefinition.definitions.find(
+    (def) => def.kind === "OperationDefinition"
+  );
+  return likelyNode?.name?.value;
+}
+
+// src/actions/clients/getApolloClient.ts
+import { InMemoryCache } from "@apollo/client";
+import { HttpLink } from "@apollo/client/link/http";
+import { getUriFromLink } from "@berachain/config";
+import { currentDapp, goldskyBaseUrl } from "@berachain/config/internal";
+import apiResults from "@berachain/graphql/dex/api";
+import { gql } from "@apollo/client";
+function applyStellateClientName(url) {
+  const headers = typeof url === "string" ? void 0 : url.headers;
+  const isDapp = !!currentDapp;
+  const isTest = process.env.VERCEL_ENV === "test";
+  const uri = getUriFromLink(url);
+  const name = typeof url === "string" ? "unknown" : url.name;
+  return {
+    uri,
+    name,
+    headers: {
+      ...headers,
+      "x-graphql-client-name": `berachain.${isDapp ? "dapps" : isTest ? "test" : (
+        // this tracks usage of the berajs package in other packages
+        "berajs"
+      )}`,
+      "x-graphql-client-version": `${process.env.VERCEL_TARGET_ENV}.${process.env.VERCEL_GIT_COMMIT_SHA}`
+    }
+  };
+}
+function getClient(endpoint, {
+  ssrMode,
+  inMemoryCacheOptions
+} = {}) {
+  const url = getUriFromLink(endpoint);
+  const headers = typeof endpoint === "string" ? void 0 : endpoint.headers;
+  let name = typeof endpoint === "string" ? void 0 : endpoint.name;
+  if (!name && url.includes(goldskyBaseUrl)) {
+    name = url.replace(goldskyBaseUrl, "").replace("/gn", "");
+  }
+  return new BeraApolloClient({
+    url,
+    name: name ?? "unknown",
+    link: new HttpLink({
+      uri: url,
+      headers
+    }),
+    defaultOptions: {
+      query: {
+        // With the default none error policy, an error causes the promise to reject.
+        errorPolicy: "none",
+        fetchPolicy: "no-cache"
+      }
+    },
+    cache: new InMemoryCache(inMemoryCacheOptions),
+    ssrMode
+  });
+}
+var SUBGRAPH_CLIENTS = [
+  "honey.subgraph",
+  "pol.subgraph"
+];
+function isSubgraphClient(name) {
+  return SUBGRAPH_CLIENTS.includes(name);
+}
+var clientCache = /* @__PURE__ */ new Map();
+function store(cacheKey, client) {
+  if (cacheKey) clientCache.set(cacheKey, client);
+  return client;
+}
+function getApolloClient(clientName, { ...args }) {
+  if (typeof window !== "undefined" && isSubgraphClient(clientName)) {
+    throw new BeraError({
+      message: "Subgraph Apollo client is server-only",
+      level: "error"
+    });
+  }
+  const { config, chainId } = parseBaseArgs(args);
+  const cacheKey = args.config ? null : `${chainId}:${clientName}`;
+  if (cacheKey) {
+    const cached = clientCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  switch (clientName) {
+    case "api":
+      return store(
+        cacheKey,
+        getClient(applyStellateClientName(config.api), {
+          inMemoryCacheOptions: {
+            possibleTypes: apiResults.possibleTypes
+          }
+        })
+      );
+    case "bend.whisk":
+      if (!config.bend.whiskApi) {
+        throw new BeraError({
+          message: "Bend whisk API is not configured on this chain",
+          level: "error"
+        });
+      }
+      return store(cacheKey, getClient(config.bend.whiskApi));
+    case "honey.subgraph":
+      return store(cacheKey, getClient(config.honey.subgraph));
+    case "pol.subgraph":
+      return store(cacheKey, getClient(config.pol.subgraph));
+  }
+}
+
+export {
+  BeraApolloClient,
+  getApolloClient,
+  gql
+};

package/dist/chunk-75M6TF7M.mjs

@@ -0,0 +1,25 @@
+import {
+  InvalidArgumentError
+} from "./chunk-J5I45WGQ.mjs";
+
+// src/utils/parseBaseArgs.ts
+import {
+  chainConfigs,
+  defaultChainId
+} from "@berachain/config/internal";
+function parseBaseArgs(args) {
+  const chainId = args.chainId ?? defaultChainId;
+  const config = args.config ?? chainConfigs[chainId];
+  if (args.chainId && args.chainId !== config.chainId) {
+    throw new InvalidArgumentError({
+      property: "chainId",
+      value: chainId,
+      expected: `config.chainId: ${config.chainId}`
+    });
+  }
+  return { config, chainId: config.chainId };
+}
+
+export {
+  parseBaseArgs
+};