@berachain/berajs 0.2.8-beta.8 → 0.2.9

package/dist/actions/governance/exports.mjs

@@ -0,0 +1,226 @@
+import {
+  checkProposalField,
+  getAllProposals,
+  getBodyErrors,
+  getProposalDetails,
+  getProposalFromTx,
+  getProposalVotes,
+  parseProposalBody
+} from "../../chunk-AFN4CVD3.mjs";
+import "../../chunk-DKMAIU74.mjs";
+import "../../chunk-KQUMKB66.mjs";
+import "../../chunk-J5I45WGQ.mjs";
+
+// src/actions/governance/computeActualStatus.ts
+import {
+  ProposalStatus
+} from "@berachain/graphql/governance";
+var GOVERNANCE_ACCELERATE_PROPOSAL = false;
+var MOCKED_PROPOSAL_STATUSES = [
+  ProposalStatus.Active,
+  ProposalStatus.PendingQueue,
+  ProposalStatus.PendingExecution,
+  ProposalStatus.Defeated,
+  ProposalStatus.QuorumNotReached
+];
+function computeActualStatus(proposal, proposalOnChainState) {
+  const timestampInSeconds = Date.now() / 1e3;
+  if (proposalOnChainState !== void 0) {
+    if (proposal.status === ProposalStatus.CanceledByGuardian) {
+      return ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 2 /* Canceled */) {
+      if (Number(proposal.voteStartAt) < timestampInSeconds)
+        return ProposalStatus.CanceledByUser;
+      return ProposalStatus.CanceledByGuardian;
+    }
+    if (proposalOnChainState === 3 /* Defeated */) {
+      if (!proposal.pollResult) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (
+        // Quorum might be null if no votes were cast.
+        !proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)
+      ) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      return ProposalStatus.Defeated;
+    }
+    if (proposalOnChainState === 4 /* Succeeded */) {
+      return ProposalStatus.PendingQueue;
+    }
+    if (proposalOnChainState === 5 /* Queued */) {
+      if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+        return ProposalStatus.PendingExecution;
+      }
+      return ProposalStatus.InQueue;
+    }
+    if (proposalOnChainState === 6 /* Expired */) {
+      console.warn("Unexpected expired state on proposal id: ", proposal.id);
+      return ProposalStatus.Defeated;
+    }
+  }
+  if (proposal.status === ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return ProposalStatus.PendingExecution;
+    }
+  }
+  if (GOVERNANCE_ACCELERATE_PROPOSAL && proposalOnChainState === 1 /* Active */ && proposal.quorum && BigInt(proposal.quorum) < BigInt(proposal.pollResult.totalTowardsQuorum) && Number(proposal.pollResult.forPercentage) > Number(proposal.pollResult.againstPercentage)) {
+    return ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === ProposalStatus.Pending) {
+    if (Number(proposal.voteStartAt) < timestampInSeconds && Number(proposal.voteEndAt) > timestampInSeconds) {
+      return ProposalStatus.Active;
+    }
+    if (Number(proposal.voteEndAt) < timestampInSeconds) {
+      if (!proposal.pollResult) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+        return ProposalStatus.QuorumNotReached;
+      }
+      if (proposal.pollResult?.against > proposal.pollResult?.for) {
+        return ProposalStatus.Defeated;
+      }
+      return ProposalStatus.PendingQueue;
+    }
+    return ProposalStatus.Pending;
+  }
+  if (proposal.status === ProposalStatus.Active && Number(proposal.voteEndAt) < timestampInSeconds) {
+    if (!proposal.quorum || BigInt(proposal.quorum) > BigInt(proposal.pollResult.totalTowardsQuorum)) {
+      return ProposalStatus.QuorumNotReached;
+    }
+    if (BigInt(proposal.pollResult?.against ?? 0n) > BigInt(proposal.pollResult?.for ?? 0n)) {
+      return ProposalStatus.Defeated;
+    }
+    return ProposalStatus.PendingQueue;
+  }
+  if (proposal.status === ProposalStatus.InQueue) {
+    if (Number(proposal.queueEnd) < Date.now() / 1e3) {
+      return ProposalStatus.PendingExecution;
+    }
+  }
+  return proposal.status;
+}
+
+// src/actions/governance/getDecodedFunctionData.ts
+import {
+  decodeFunctionData,
+  erc20Abi,
+  pad,
+  toFunctionSignature,
+  trim
+} from "viem";
+import { appConfig, defaultChainId } from "@berachain/config/internal";
+import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
+import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
+function isProxyABI(abi) {
+  return abi.some((item) => {
+    const i = item;
+    return i.name === "implementation" || i.name === "proxyType" || i.type === "constructor" && i.inputs?.[0]?.name === "implementation";
+  });
+}
+async function _getAbi({
+  contractAddress,
+  chainId,
+  publicClient
+}) {
+  const url = `https://api.etherscan.io/v2/api?module=contract&action=getabi&address=${contractAddress}&apikey=${appConfig.apiKeys.private.etherscan}&chainId=${chainId}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ABI: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (data.status === "0") throw new Error(data.result);
+  const abi = JSON.parse(data.result);
+  if (!isProxyABI(abi)) return abi;
+  const implementationResult = await publicClient.getStorageAt({
+    address: contractAddress,
+    // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)).
+    slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"
+  });
+  if (!implementationResult || trim(implementationResult) === "0x00")
+    return abi;
+  const implementationAddress = pad(trim(implementationResult), { size: 20 });
+  return _getAbi({
+    contractAddress: implementationAddress,
+    chainId,
+    publicClient
+  });
+}
+async function _getAbiForCallData({
+  address,
+  callData,
+  knownAbi,
+  chainId,
+  publicClient
+}) {
+  try {
+    if (decodeFunctionData({ data: callData, abi: knownAbi })) {
+      return knownAbi;
+    }
+  } catch {
+  }
+  return _getAbi({ contractAddress: address, chainId, publicClient }).catch(
+    () => void 0
+  );
+}
+function _decodeCallData(callData, abi) {
+  try {
+    return decodeFunctionData({ data: callData, abi });
+  } catch {
+    return void 0;
+  }
+}
+function _findAbiItem(abi, functionName) {
+  return abi.find(
+    (a) => a.type === "function" && a.name === functionName
+  );
+}
+function _getFunctionSignature(abiItem) {
+  if (!abiItem) return;
+  try {
+    return toFunctionSignature(abiItem);
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function getDecodedFunctionData({
+  address,
+  callData,
+  chainId = defaultChainId,
+  publicClient
+}) {
+  const knownAbi = [...beraChefAbi, ...rewardVaultAbi, ...erc20Abi];
+  const abi = await _getAbiForCallData({
+    address,
+    callData,
+    knownAbi,
+    chainId,
+    publicClient
+  });
+  const decodedData = _decodeCallData(callData, abi);
+  if (!abi || !decodedData) {
+    return { args: [] };
+  }
+  const abiItem = _findAbiItem(abi, decodedData.functionName);
+  const functionSignature = _getFunctionSignature(abiItem);
+  return {
+    abiItem,
+    functionSignature,
+    functionName: decodedData.functionName,
+    args: decodedData.args
+  };
+}
+export {
+  MOCKED_PROPOSAL_STATUSES,
+  checkProposalField,
+  computeActualStatus,
+  getAllProposals,
+  getBodyErrors,
+  getDecodedFunctionData,
+  getProposalDetails,
+  getProposalFromTx,
+  getProposalVotes,
+  parseProposalBody
+};

package/dist/actions/server/exports.d.ts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+import { GetValidatorBlockStatsQuery } from '@berachain/graphql/pol/subgraph';
+
+/**
+ * Server-only RSC variant. Goes directly to the pol subgraph upstream
+ * (no auth required) through the shared Apollo client factory.
+ */
+declare function getDailyValidatorBlockStats({ pubKey, first, ...args }: BeraJS.BaseFunctionArgs & {
+    pubKey: Address;
+    first?: number;
+}): Promise<GetValidatorBlockStatsQuery | undefined>;
+
+export { getDailyValidatorBlockStats };

package/dist/actions/server/exports.mjs

@@ -0,0 +1,27 @@
+import {
+  getApolloClient
+} from "../../chunk-4Z4AK6SH.mjs";
+import "../../chunk-75M6TF7M.mjs";
+import "../../chunk-SZ5C44L5.mjs";
+import "../../chunk-XIYN6AL6.mjs";
+import "../../chunk-J5I45WGQ.mjs";
+
+// src/actions/server/getDailyValidatorBlockStats.ts
+import {
+  GetValidatorBlockStats
+} from "@berachain/graphql/pol/subgraph";
+async function getDailyValidatorBlockStats({
+  pubKey,
+  first = 1,
+  ...args
+}) {
+  const client = getApolloClient("pol.subgraph", args);
+  const result = await client.query({
+    query: GetValidatorBlockStats,
+    variables: { pubKey, first }
+  });
+  return result.data;
+}
+export {
+  getDailyValidatorBlockStats
+};

package/dist/{chunk-VA3BQ34H.mjs → chunk-3EARVV7K.mjs}

@@ -1,23 +1,25 @@
 import {
   getBalanceCall,
   getEnsoClient
-} from "./chunk-SGZP4O6R.mjs";
+} from "./chunk-HSSJKHZ4.mjs";
 import {
   BeraMonitoring,
   initBeraError
-} from "./chunk-ZBTRKBSI.mjs";
+} from "./chunk-EXIUPSFN.mjs";
 import {
   defaultFlags
-} from "./chunk-7TFV6UKF.mjs";
+} from "./chunk-BGMRHTBQ.mjs";
 import {
   beraToken,
-  isToken,
+  isToken
+} from "./chunk-NPBQLVL3.mjs";
+import {
   parseBaseArgs
-} from "./chunk-4GFN4LEP.mjs";
+} from "./chunk-75M6TF7M.mjs";
 import {
   BeraError,
   InvalidArgumentError
-} from "./chunk-7QKRRIHI.mjs";
+} from "./chunk-J5I45WGQ.mjs";
 
 // src/contexts/BeraFlags/BeraFlags.tsx
 import { createContext, useContext } from "react";
@@ -272,15 +274,25 @@ async function getEnsoUserTokensWithBalances({
 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] : null;
+  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()
+      ensoClient: getEnsoClient({
+        baseURL: proxyAggregatorsThroughVercel ? "/api/enso" : void 0
+      })
     }),
     {
       refreshInterval: 1e5 /* NORMAL */,
@@ -400,4 +412,3 @@ export {
   TokenContext,
   TokensProvider
 };
-//# sourceMappingURL=chunk-VA3BQ34H.mjs.map

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
+};