@berachain/berajs 0.2.8-beta.9 → 0.2.9

package/src/actions/validators/getValidatorAnalytics.ts

@@ -1,34 +1,33 @@
 import type { Address } from "viem";
 
-import {
-  GetValidatorAnalytics,
-  type GetValidatorAnalyticsQuery,
-  type GetValidatorAnalyticsQueryVariables,
-} from "@berachain/graphql/pol/subgraph";
+import type { GetValidatorAnalyticsQuery } from "@berachain/graphql/pol/subgraph";
 
-import { calculateTimestampFromDays } from "../../utils/formatTimestamps";
-import { getApolloClient } from "../clients/getApolloClient";
+import { BeraError } from "../../errors/BeraError";
+import { beraFetchJson } from "../../utils/beraFetch";
 
+/** Browser-only. Hits `/api/pol/validator-analytics`. */
 export async function getValidatorAnalytics({
   pubkey,
   dayRange,
-  ...args
-}: BeraJS.BaseFunctionArgs & {
+}: {
   pubkey: Address;
   dayRange: number;
 }): Promise<GetValidatorAnalyticsQuery | undefined> {
-  const bgtClient = getApolloClient("pol.subgraph", args);
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message:
+        "getValidatorAnalytics is browser-only; call from a Client Component / SWR hook",
+      level: "error",
+    });
+  }
 
-  const result = await bgtClient.query<
-    GetValidatorAnalyticsQuery,
-    GetValidatorAnalyticsQueryVariables
-  >({
-    query: GetValidatorAnalytics,
-    variables: {
-      pubKey: pubkey,
-      timestamp: calculateTimestampFromDays(dayRange).toString(),
-    },
+  const params = new URLSearchParams({
+    pubkey,
+    dayRange: String(dayRange),
+  });
+  return beraFetchJson<GetValidatorAnalyticsQuery>({
+    url: `/api/pol/validator-analytics?${params}`,
+    name: "pol-validator-analytics",
+    type: "rest",
   });
-
-  return result.data;
 }

package/src/actions/validators/getValidatorIncentiveDistribution.ts

@@ -0,0 +1,33 @@
+import type { Address } from "viem";
+
+import type { GetValidatorIncentiveDistributionQuery } from "@berachain/graphql/pol/subgraph";
+
+import { BeraError } from "../../errors/BeraError";
+import { beraFetchJson } from "../../utils/beraFetch";
+
+/** Browser-only. Hits `/api/pol/validator-incentive-distribution`. */
+export async function getValidatorIncentiveDistribution({
+  pubkey,
+  dayRange,
+}: {
+  pubkey: Address;
+  dayRange: number;
+}): Promise<GetValidatorIncentiveDistributionQuery | undefined> {
+  if (typeof window === "undefined") {
+    throw new BeraError({
+      message:
+        "getValidatorIncentiveDistribution is browser-only; call from a Client Component / SWR hook",
+      level: "error",
+    });
+  }
+
+  const params = new URLSearchParams({
+    pubkey,
+    dayRange: String(dayRange),
+  });
+  return beraFetchJson<GetValidatorIncentiveDistributionQuery>({
+    url: `/api/pol/validator-incentive-distribution?${params}`,
+    name: "pol-validator-incentive-distribution",
+    type: "rest",
+  });
+}

package/src/enum/contracts.ts

@@ -4,6 +4,7 @@
 export enum ContractName {
   ENSO_ROUTER = "enso.router",
   POL_REWARD_VAULT = "pol.rewardVault",
+  POL_REWARD_VAULT_HELPER = "pol.rewardVaultHelper",
   BEX_POOL = "bex.pool",
   ERC20 = "others.erc20",
   ERC4626 = "others.erc4626",

package/src/enum/exports.ts

@@ -1,6 +1,5 @@
 export * from "./contracts";
 export * from "./dex";
-export * from "./governance";
 export * from "./honey";
 export * from "./polling";
 export * from "./slippage";

package/src/enum/governance/exports.ts

@@ -0,0 +1 @@
+export * from "../governance";

package/src/errors/BeraError.ts

@@ -6,6 +6,7 @@ import { GENERAL_ERROR } from "./errorMap";
 import { findMatchingError } from "./getErrorMessage";
 import { parseViemError, rpcErrorToReason } from "./parseViemError";
 import type { SeverityLevel } from "./severity";
+import { reasonToSpanStatus, type SpanStatusType } from "./spanStatus";
 
 export interface IBeraErrorArgs {
   message?: string;
@@ -26,6 +27,12 @@ export interface IBeraErrorArgs {
    * Optional ABI to be used to parse the error.
    */
   abi?: Abi;
+  /**
+   * Span status for tracing. When set, the tracing adapter uses this to
+   * set the span status instead of a generic "internal_error".
+   * Auto-inferred from `reason` when not explicitly provided.
+   */
+  spanStatus?: SpanStatusType;
 }
 
 type Primitive = number | string | boolean | bigint | symbol | null | undefined;
@@ -123,6 +130,12 @@ export class BeraError extends Error {
 
   level: SeverityLevel = "error";
 
+  /**
+   * Span status for tracing providers.
+   * Auto-inferred from `reason` when not explicitly provided.
+   */
+  spanStatus?: SpanStatusType;
+
   extra: Record<string, unknown> = {};
 
   constructor({
@@ -135,6 +148,7 @@ export class BeraError extends Error {
     tags,
     chainId,
     fingerprint,
+    spanStatus,
   }: IBeraErrorArgs) {
     let message = m;
 
@@ -200,6 +214,19 @@ export class BeraError extends Error {
       this.level = "error";
     }
 
+    // ── Span status inference ───────────────────────────────────────────
+    // Priority:
+    //   1. Explicit `spanStatus` from caller
+    //   2. Cascaded from a BeraError cause
+    //   3. Auto-inferred from `reason` via reasonToSpanStatus()
+    if (spanStatus) {
+      this.spanStatus = spanStatus;
+    } else if (this.cause instanceof BeraError && this.cause.spanStatus) {
+      this.spanStatus = this.cause.spanStatus;
+    } else {
+      this.spanStatus = reasonToSpanStatus(this.reason);
+    }
+
     // ── displayMessage resolution ─────────────────────────────────────────
     // Priority:
     //   1. Explicit `displayMessage` passed by caller
@@ -243,13 +270,26 @@ export class BeraError extends Error {
       (process.env.NEXT_PUBLIC_IS_MONOBERA === "true" || currentDapp) &&
       process.env.NODE_ENV !== "test"
     ) {
-      console.group("BeraError thrown");
-      console.debug("Level", this.level);
-      console.debug("Reason", this.reason);
-      console.debug("Message", this.message);
-      console.debug("Display Message", this.displayMessage);
-      console.debug("Cause", this.cause);
-      console.groupEnd();
+      // `console.group`/`groupEnd` are not implemented in Vercel's edge
+      // runtime — calling them there throws a TypeError which masks the
+      // original error. Fall back to a single debug line in that case.
+      if (typeof console.group === "function") {
+        console.group("BeraError thrown");
+        console.debug("Level", this.level);
+        console.debug("Reason", this.reason);
+        console.debug("Message", this.message);
+        console.debug("Display Message", this.displayMessage);
+        console.debug("Cause", this.cause);
+        console.groupEnd();
+      } else {
+        console.debug("BeraError thrown", {
+          level: this.level,
+          reason: this.reason,
+          message: this.message,
+          displayMessage: this.displayMessage,
+          cause: this.cause,
+        });
+      }
     }
   }
 }

package/src/errors/BeraTracing.unit.test.ts

@@ -165,6 +165,71 @@ describe("BeraTracing", () => {
     });
   });
 
+  describe("span status adapter pattern", () => {
+    it("adapter handler can read spanStatus from BeraError", async () => {
+      const { BeraError } = await import("./BeraError.js");
+      const statuses: string[] = [];
+
+      // Simulates the Sentry adapter wrapper pattern
+      const adapterHandler = async (
+        _ctx: any,
+        callback: () => Promise<any>,
+      ) => {
+        try {
+          const result = await callback();
+          statuses.push("ok");
+          return result;
+        } catch (error) {
+          const status =
+            error instanceof BeraError && error.spanStatus
+              ? error.spanStatus
+              : "internal_error";
+          statuses.push(status);
+          throw error;
+        }
+      };
+
+      const unsub = BeraTracing.addSpanHandler(adapterHandler);
+
+      // Test: error with spanStatus propagates through
+      await expect(
+        BeraTracing.startSpan(
+          { name: "test", op: "test.op", attributes: {} },
+          async () => {
+            throw new BeraError({
+              message: "user cancelled",
+              reason: "UserRejectedRequestError",
+            });
+          },
+        ),
+      ).rejects.toThrow("user cancelled");
+
+      expect(statuses).toEqual(["cancelled"]);
+
+      // Test: success sets ok
+      statuses.length = 0;
+      await BeraTracing.startSpan(
+        { name: "test", op: "test.op", attributes: {} },
+        async () => "done",
+      );
+      expect(statuses).toEqual(["ok"]);
+
+      // Test: non-BeraError defaults to internal_error
+      statuses.length = 0;
+      await expect(
+        BeraTracing.startSpan(
+          { name: "test", op: "test.op", attributes: {} },
+          async () => {
+            throw new Error("plain error");
+          },
+        ),
+      ).rejects.toThrow("plain error");
+      expect(statuses).toEqual(["internal_error"]);
+
+      unsub();
+    });
+  });
+
   describe("Sentry.startSpan compatibility", () => {
     it("works with a handler that accepts (options, callback) like Sentry.startSpan", async () => {
       // Sentry.startSpan signature: <T>(options, callback: (span) => T) => T

package/src/errors/RequestError.ts

@@ -5,6 +5,7 @@ import { mainnet } from "@berachain/config/mainnet";
 
 import { BeraError, type IBeraErrorArgs } from "./BeraError";
 import { errorMsgMap } from "./errorMap";
+import { httpStatusToSpanStatus, reasonToSpanStatus } from "./spanStatus";
 
 /**
  * This is an error class that should be used to handle errors from fetch requests.
@@ -37,7 +38,7 @@ export class RequestError extends BeraError {
     // vercel internal proxy
     "/api/aggregators?aggregator",
     // bonder endpoints have date-based query params (e.g. ?start=2025-11-28)
-    mainnet.staking,
+    mainnet.backend,
   ];
 
   statusCode: number | undefined;
@@ -104,6 +105,17 @@ export class RequestError extends BeraError {
       }
     }
 
+    // ── Span status inference ─────────────────────────────────────────
+    // Re-infer from reason since it may have been set after super() ran
+    // (e.g. NETWORK_ERROR → unavailable, RATE_LIMITED_429 → resource_exhausted).
+    if (!this.spanStatus && this.reason) {
+      this.spanStatus = reasonToSpanStatus(this.reason);
+    }
+    // Fall back to HTTP status code mapping when no reason-based status.
+    if (!this.spanStatus && this.statusCode) {
+      this.spanStatus = httpStatusToSpanStatus(this.statusCode);
+    }
+
     this.tags = {
       ...this.tags,
       "error.statusCode": this.statusCode,

package/src/errors/exports.ts

@@ -12,4 +12,9 @@ export * from "./initBeraError";
 export * from "./NotFoundError";
 export * from "./RequestError";
 export type { SeverityLevel } from "./severity";
+export {
+  httpStatusToSpanStatus,
+  reasonToSpanStatus,
+  type SpanStatusType,
+} from "./spanStatus";
 export * from "./TransactionFailedError";

package/src/errors/getRevertReason.integration.test.ts

@@ -29,6 +29,7 @@ import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
 
 import { getConfig } from "@berachain/wagmi/config";
 
+import { testTransports } from "../actions/__test/transports";
 import { beraWriteContract } from "../actions/transactions/beraWriteContract";
 import { ContractName } from "../enum/contracts";
 import { TransactionActionType } from "../enum/txnEnum";
@@ -414,10 +415,9 @@ describe("eip5972 transactions", () => {
     account: anvilMockAccount,
     chain: publicClient.chain!,
   });
+
   const beraWagmiConfig = getConfig({
-    transports: {
-      [publicClient.chain!.id]: http(getRpcUrls().publicJsonRpcUrl),
-    },
+    transports: testTransports,
     defaultChain: publicClient.chain!,
     thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },
   });

package/src/errors/spanStatus.ts

@@ -0,0 +1,78 @@
+/**
+ * Span status codes for tracing.
+ * Mirrors Sentry's SpanStatusType for compatibility, but owned by berajs
+ * so we don't depend on @sentry/nextjs.
+ *
+ * @see https://develop.sentry.dev/sdk/foundations/transport/event-payloads/span/
+ */
+export type SpanStatusType =
+  | "ok"
+  | "cancelled"
+  | "unknown_error"
+  | "invalid_argument"
+  | "deadline_exceeded"
+  | "not_found"
+  | "already_exists"
+  | "permission_denied"
+  | "resource_exhausted"
+  | "failed_precondition"
+  | "aborted"
+  | "out_of_range"
+  | "unimplemented"
+  | "internal_error"
+  | "unavailable"
+  | "data_loss"
+  | "unauthenticated";
+
+/**
+ * Maps an HTTP status code to a span status.
+ */
+export function httpStatusToSpanStatus(code: number): SpanStatusType {
+  if (code >= 200 && code < 300) return "ok";
+  switch (code) {
+    case 400:
+      return "invalid_argument";
+    case 401:
+      return "unauthenticated";
+    case 403:
+      return "permission_denied";
+    case 404:
+      return "not_found";
+    case 409:
+      return "already_exists";
+    case 429:
+      return "resource_exhausted";
+    case 499:
+      return "cancelled";
+    case 501:
+      return "unimplemented";
+    case 503:
+      return "unavailable";
+    case 504:
+      return "deadline_exceeded";
+    default:
+      return code >= 500 ? "internal_error" : "unknown_error";
+  }
+}
+
+/**
+ * Maps a BeraError reason code to a span status.
+ * Returns undefined if no mapping exists (caller keeps existing spanStatus).
+ */
+export function reasonToSpanStatus(
+  reason: string | null,
+): SpanStatusType | undefined {
+  switch (reason) {
+    case "UserRejectedRequestError":
+    case "AtomicReadyWalletRejectedUpgradeError":
+      return "cancelled";
+    case "NO_SWAP_PATHS":
+      return "not_found";
+    case "RATE_LIMITED_429":
+      return "resource_exhausted";
+    case "NETWORK_ERROR":
+      return "unavailable";
+    default:
+      return undefined;
+  }
+}

package/src/errors/spanStatus.unit.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+
+import { httpStatusToSpanStatus, reasonToSpanStatus } from "./spanStatus.js";
+
+describe("httpStatusToSpanStatus", () => {
+  it("maps 2xx to ok", () => {
+    expect(httpStatusToSpanStatus(200)).toBe("ok");
+    expect(httpStatusToSpanStatus(201)).toBe("ok");
+    expect(httpStatusToSpanStatus(204)).toBe("ok");
+  });
+
+  it("maps specific 4xx codes", () => {
+    expect(httpStatusToSpanStatus(400)).toBe("invalid_argument");
+    expect(httpStatusToSpanStatus(401)).toBe("unauthenticated");
+    expect(httpStatusToSpanStatus(403)).toBe("permission_denied");
+    expect(httpStatusToSpanStatus(404)).toBe("not_found");
+    expect(httpStatusToSpanStatus(409)).toBe("already_exists");
+    expect(httpStatusToSpanStatus(429)).toBe("resource_exhausted");
+    expect(httpStatusToSpanStatus(499)).toBe("cancelled");
+  });
+
+  it("maps specific 5xx codes", () => {
+    expect(httpStatusToSpanStatus(500)).toBe("internal_error");
+    expect(httpStatusToSpanStatus(501)).toBe("unimplemented");
+    expect(httpStatusToSpanStatus(503)).toBe("unavailable");
+    expect(httpStatusToSpanStatus(504)).toBe("deadline_exceeded");
+  });
+
+  it("maps unknown 4xx to unknown_error", () => {
+    expect(httpStatusToSpanStatus(418)).toBe("unknown_error");
+  });
+
+  it("maps unknown 5xx to internal_error", () => {
+    expect(httpStatusToSpanStatus(502)).toBe("internal_error");
+  });
+});
+
+describe("reasonToSpanStatus", () => {
+  it("maps user rejection reasons to cancelled", () => {
+    expect(reasonToSpanStatus("UserRejectedRequestError")).toBe("cancelled");
+    expect(reasonToSpanStatus("AtomicReadyWalletRejectedUpgradeError")).toBe(
+      "cancelled",
+    );
+  });
+
+  it("maps NO_SWAP_PATHS to not_found", () => {
+    expect(reasonToSpanStatus("NO_SWAP_PATHS")).toBe("not_found");
+  });
+
+  it("maps RATE_LIMITED_429 to resource_exhausted", () => {
+    expect(reasonToSpanStatus("RATE_LIMITED_429")).toBe("resource_exhausted");
+  });
+
+  it("maps NETWORK_ERROR to unavailable", () => {
+    expect(reasonToSpanStatus("NETWORK_ERROR")).toBe("unavailable");
+  });
+
+  it("returns undefined for unknown reasons", () => {
+    expect(reasonToSpanStatus("SomeOtherError")).toBeUndefined();
+    expect(reasonToSpanStatus(null)).toBeUndefined();
+  });
+});

package/src/hooks/dex/useCreatePool.ts

@@ -1,23 +1,9 @@
 import { useMemo } from "react";
 import { PoolType } from "@berachain-foundation/berancer-sdk";
-import useSWRImmutable from "swr/immutable";
-import {
-  type Address,
-  formatUnits,
-  keccak256,
-  parseUnits,
-  zeroAddress,
-} from "viem";
+import { type Address, keccak256, parseUnits, zeroAddress } from "viem";
 
 import { poolCreationHelperAbi as balancerPoolCreationHelperAbi } from "@berachain/abis/bex/poolCreationHelper";
 
-import {
-  GetDedupedSubgraphPools,
-  type GetDedupedSubgraphPoolsQuery,
-  type SubgraphPoolFragment,
-} from "@berachain/graphql/dex/subgraph";
-
-import { getApolloClient } from "../../actions/clients/getApolloClient";
 import { TransactionActionType } from "../../enum/txnEnum";
 import type { Token, TokenWithAmount } from "../../types/dex";
 import type { IContractWrite } from "../../types/global";
@@ -25,9 +11,7 @@ import { DEFAULT_METAMASK_GAS_LIMIT } from "../../utils/constants";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { generatePoolName, generatePoolSymbol } from "../../utils/poolNamings";
 import { isToken } from "../../utils/tokens";
-import { wrapNativeTokens } from "../../utils/tokenWrapping";
 
-const DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD = 0.005;
 interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
   poolCreateTokens: Token[];
   initialLiquidityTokens: TokenWithAmount[];
@@ -38,17 +22,12 @@ interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
   poolSymbol: string;
   poolName: string;
   amplification: number;
-  weightsDuplicationThreshold?: number;
   oracles: Oracle[]; // NOTE: the default state for oracles should be 0x0 address for each token with cache duration of ~100
 }
 interface UseCreatePoolReturn {
   generatedPoolName: string;
   generatedPoolSymbol: string;
-  isDupePool: boolean;
-  dupePool?: SubgraphPoolFragment | null;
   createPoolArgs: any;
-  isLoadingPools: boolean;
-  errorLoadingPools: boolean;
 }
 
 export enum OracleMode {
@@ -276,70 +255,8 @@ export const useCreatePool = ({
   owner,
   amplification,
   oracles,
-  weightsDuplicationThreshold = DEFAULT_WEIGHTS_DUPLICATION_THRESHOLD,
   ...baseArgs
 }: UseCreatePoolProps): UseCreatePoolReturn => {
-  // 1. identify if the pool is a duplicate
-  const {
-    data: dupePool,
-    error: errorLoadingPools,
-    isLoading: isLoadingPools,
-  } = useSWRImmutable<SubgraphPoolFragment | null>(
-    [
-      "useCreatePool__deduped_pool",
-      poolCreateTokens,
-      poolType,
-      normalizedWeights,
-    ],
-    async () => {
-      if (poolCreateTokens.length === 0 || !poolType) {
-        return null;
-      }
-      const bexSubgraphClient = getApolloClient("bex.subgraph", {});
-      try {
-        // NOTE: it should not be possible for native token to be in poolCreateTokens
-        const tokensSorted = wrapNativeTokens(poolCreateTokens)
-          .map((token) => token.address.toLowerCase())
-          .sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : 1));
-
-        // fetch pools of the same type as the one we are creating
-        const res = await bexSubgraphClient.query<GetDedupedSubgraphPoolsQuery>(
-          {
-            query: GetDedupedSubgraphPools,
-            variables: {
-              tokens: tokensSorted,
-              type: poolType,
-            },
-          },
-        );
-
-        const matchingPools = res.data.pools.filter((pool) => {
-          return pool.tokens?.every((token) =>
-            poolType === PoolType.Weighted
-              ? // in weighted pools, a dupe is if tokens and weights match within tolerance FIXME: we aren't getting weighted pools returned here
-                tokensSorted.includes(token.address) &&
-                Math.abs(
-                  Number(token.weight) -
-                    Number(
-                      formatUnits(
-                        normalizedWeights[tokensSorted.indexOf(token.address)],
-                        18,
-                      ),
-                    ),
-                ) < weightsDuplicationThreshold
-              : // in composable pools a dupe is if the tokens match, handling that the LP token is in the tokens list
-                tokensSorted.includes(token.address) ||
-                token.address === pool.address,
-          );
-        });
-
-        return matchingPools?.at(0) ?? null;
-      } catch {
-        return null;
-      }
-    },
-  );
-
   // Generated names
   const { generatedPoolName, generatedPoolSymbol } = useMemo(() => {
     if (!poolCreateTokens) {
@@ -430,10 +347,6 @@ export const useCreatePool = ({
   return {
     generatedPoolName,
     generatedPoolSymbol,
-    isDupePool: !!dupePool,
-    dupePool,
     createPoolArgs,
-    isLoadingPools,
-    errorLoadingPools,
   };
 };

package/src/hooks/dex/useOnChainPoolData.ts

@@ -2,10 +2,10 @@ import { useMemo } from "react";
 import useSWRImmutable from "swr/immutable";
 import { type Address, formatUnits, isAddress } from "viem";
 
-import type { SubgraphPoolFragment } from "@berachain/graphql/dex/subgraph";
 import { usePublicClient } from "@berachain/wagmi/hooks";
 
 import { getOnChainPool } from "../../actions/dex/getOnChainPool";
+import type { TokenPriceInfo } from "../../types/dex";
 import { useMultipleTokenInformation } from "../tokens/useMultipleTokenInformation";
 import { useTokenCurrentPrices } from "../tokens/useTokenCurrentPrices";
 
@@ -21,7 +21,32 @@ export function useOnChainPoolDataQueryKey(
   return isValid && address ? (["useOnChainPoolData", address] as const) : null;
 }
 
-export interface OnChainPoolFragment extends SubgraphPoolFragment {
+interface OnChainPoolToken {
+  address: Address;
+  name: string;
+  decimals: number;
+  symbol: string;
+  index: number;
+  weight?: string;
+  balance: string;
+  token: {
+    __typename: "Token";
+    token: { address: Address; name: string; decimals: number; symbol: string };
+    latestUSDPrice: TokenPriceInfo | undefined;
+  };
+}
+
+export interface OnChainPoolFragment {
+  id: string;
+  name: string;
+  address: Address;
+  factory: Address;
+  swapFee: string;
+  totalShares: string;
+  totalLiquidity: string;
+  createTime: number;
+  type: string;
+  tokens: OnChainPoolToken[];
   // Reference: https://github.com/balancer/docs-developers/blob/main/references/valuing-balancer-lp-tokens/pools/stablepools.md#getamplificationparameter
   amplificationParameter:
     | {