@berachain/berajs 0.2.8-beta.11 → 0.2.8-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@berachain/berajs",
-  "version": "0.2.8-beta.11",
+  "version": "0.2.8-beta.12",
   "sideEffects": false,
   "files": [
     "dist",
@@ -12,18 +12,18 @@
   "dependencies": {
     "@apollo/client": "4.1.6",
     "@berachain-foundation/berancer-sdk": "1.1.4",
-    "@berachain/abis": "0.1.0",
-    "@berachain/config": "0.1.8-beta.0",
-    "@berachain/graphql": "0.4.10-beta.1",
-    "@ensofinance/sdk": "2.0.12",
+    "@berachain/abis": "0.1.2",
+    "@berachain/config": "0.1.9-beta.0",
+    "@berachain/graphql": "0.4.10-beta.2",
+    "@ensofinance/sdk": "2.3.1",
     "@pythnetwork/hermes-client": "2.0.0",
     "@wagmi/core": "2.22.1",
     "gray-matter": "4.0.3",
     "swr": "2.4.1"
   },
   "devDependencies": {
-    "@types/react-dom": "19.1.6",
-    "@types/react": "19.1.8",
+    "@types/react-dom": "19.2.3",
+    "@types/react": "19.2.14",
     "@typescript/analyze-trace": "0.10.1",
     "tsup": "8.5.1",
     "typescript": "5.5.4",
@@ -33,55 +33,50 @@
     "@berachain/wagmi": "0.4.2-beta.6"
   },
   "exports": {
-    "./actions/governance": {
-      "types": "./dist/actions/governance/exports.d.ts",
-      "import": "./dist/actions/governance/exports.mjs",
-      "require": "./dist/actions/governance/exports.cjs",
-      "module": "./dist/actions/governance/exports.mjs",
-      "default": "./dist/actions/governance/exports.cjs"
+    "./actions/*": {
+      "types": "./dist/actions/*/exports.d.ts",
+      "import": "./dist/actions/*/exports.mjs",
+      "require": "./dist/actions/*/exports.cjs",
+      "default": "./dist/actions/*/exports.cjs"
     },
-    "./hooks/governance": {
-      "types": "./dist/hooks/governance/exports.d.ts",
-      "import": "./dist/hooks/governance/exports.mjs",
-      "require": "./dist/hooks/governance/exports.cjs",
-      "module": "./dist/hooks/governance/exports.mjs",
-      "default": "./dist/hooks/governance/exports.cjs"
+    "./hooks/*": {
+      "types": "./dist/hooks/*/exports.d.ts",
+      "import": "./dist/hooks/*/exports.mjs",
+      "require": "./dist/hooks/*/exports.cjs",
+      "default": "./dist/hooks/*/exports.cjs"
     },
-    "./enum/governance": {
-      "types": "./dist/enum/governance/exports.d.ts",
-      "import": "./dist/enum/governance/exports.mjs",
-      "require": "./dist/enum/governance/exports.cjs",
-      "module": "./dist/enum/governance/exports.mjs",
-      "default": "./dist/enum/governance/exports.cjs"
+    "./enum/*": {
+      "types": "./dist/enum/*/exports.d.ts",
+      "import": "./dist/enum/*/exports.mjs",
+      "require": "./dist/enum/*/exports.cjs",
+      "default": "./dist/enum/*/exports.cjs"
     },
-    "./types/governance": {
-      "types": "./dist/types/governance/exports.d.ts",
-      "import": "./dist/types/governance/exports.mjs",
-      "require": "./dist/types/governance/exports.cjs",
-      "module": "./dist/types/governance/exports.mjs",
-      "default": "./dist/types/governance/exports.cjs"
+    "./types/*": {
+      "types": "./dist/types/*/exports.d.ts",
+      "import": "./dist/types/*/exports.mjs",
+      "require": "./dist/types/*/exports.cjs",
+      "default": "./dist/types/*/exports.cjs"
     },
     "./*": {
       "types": "./dist/*/exports.d.ts",
       "import": "./dist/*/exports.mjs",
       "require": "./dist/*/exports.cjs",
-      "module": "./dist/*/exports.mjs",
       "default": "./dist/*/exports.cjs"
     }
   },
   "typesVersions": {
     "*": {
-      "actions/governance": [
-        "dist/actions/governance/exports.d.ts"
+      "actions/*": [
+        "dist/actions/*/exports.d.ts"
       ],
-      "hooks/governance": [
-        "dist/hooks/governance/exports.d.ts"
+      "hooks/*": [
+        "dist/hooks/*/exports.d.ts"
       ],
-      "enum/governance": [
-        "dist/enum/governance/exports.d.ts"
+      "enum/*": [
+        "dist/enum/*/exports.d.ts"
       ],
-      "types/governance": [
-        "dist/types/governance/exports.d.ts"
+      "types/*": [
+        "dist/types/*/exports.d.ts"
       ],
       "*": [
         "dist/*/exports.d.ts"
@@ -94,6 +89,17 @@
     "viem": "^2.41.2",
     "@berachain/wagmi": "0.4.2-beta.6"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "viem": {
+      "optional": false
+    }
+  },
   "scripts": {
     "build": "NODE_OPTIONS='--max-old-space-size=8192' tsup",
     "prebuild": "pnpm contracts:update",

package/src/actions/__test/transports.ts

@@ -0,0 +1,61 @@
+import { fallback, http } from "viem";
+import {
+  arbitrum,
+  avalanche,
+  base,
+  bsc,
+  mainnet,
+  optimism,
+  polygon,
+} from "viem/chains";
+
+import { publicJsonRpcUrl } from "@berachain/config/internal";
+import { defaultChain } from "@berachain/config/internal/wagmi";
+
+const transportOptions = {
+  batch: { wait: 35 },
+};
+
+const externalTransportOptions = {
+  batch: { wait: 15 },
+};
+
+export const urls = [publicJsonRpcUrl].filter(Boolean) as string[];
+
+/**
+ * Thirdweb RPC URLs have a rate limit of 3 RPS.
+ * http() uses default viem transport which varies based on the chain definition.
+ *
+ * Quicknode RPC URLs are CORS restricted to *.berachain.com, *.berachain-staging.com. They have a 100rpm rate limit.
+ */
+export const testTransports = {
+  [defaultChain.id]: fallback(urls.map((url) => http(url, transportOptions))),
+  [mainnet.id]: fallback([
+    http("https://1.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [polygon.id]: fallback([
+    http("https://137.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [optimism.id]: fallback([
+    http("https://10.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [base.id]: fallback([
+    http("https://8453.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [bsc.id]: fallback([
+    http("https://56.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [avalanche.id]: fallback([
+    http("https://43114.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+  [arbitrum.id]: fallback([
+    http("https://42161.rpc.thirdweb.com/", externalTransportOptions),
+    http(),
+  ]),
+};

package/src/actions/enso/__tests__/getEnsoUserTokensWithBalances.debug.test.ts

@@ -9,15 +9,12 @@ import {
 } from "vitest";
 
 import { appConfig } from "@berachain/config/internal";
-import {
-  defaultChain,
-  externalChains,
-  transports,
-} from "@berachain/config/internal/wagmi";
+import { defaultChain, externalChains } from "@berachain/config/internal/wagmi";
 
 import { getConfig } from "@berachain/wagmi/config";
 
 import { BeraMonitoring } from "../../../errors/BeraMonitoring";
+import { testTransports } from "../../__test/transports";
 import { getEnsoClient } from "../../clients/getEnsoClient";
 import { getEnsoUserTokensWithBalances } from "../getEnsoUserTokensWithBalances";
 
@@ -41,7 +38,7 @@ describe("getEnsoUserTokensWithBalances", () => {
     const ensoClient = getEnsoClient();
 
     const beraWagmiConfig = getConfig({
-      transports,
+      transports: testTransports,
       defaultChain,
       chains: externalChains,
       thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },

package/src/actions/tokens/getWalletBalances.integration.test.ts

@@ -2,15 +2,12 @@ import { ethAddress } from "viem";
 import { assert, describe, expect, it } from "vitest";
 
 import { appConfig } from "@berachain/config/internal";
-import {
-  defaultChain,
-  externalChains,
-  transports,
-} from "@berachain/config/internal/wagmi";
+import { defaultChain, externalChains } from "@berachain/config/internal/wagmi";
 
 import { getConfig } from "@berachain/wagmi/config";
 
 import { isToken } from "../../utils/tokens";
+import { testTransports } from "../__test/transports";
 import { getTokens } from "./getTokens";
 import { getWalletBalances } from "./getWalletBalances";
 
@@ -22,7 +19,7 @@ import { getWalletBalances } from "./getWalletBalances";
 const account = "0x08194D89A52C1410F4bcc46FE11AC2387aC69de8";
 describe("getWalletBalances", async () => {
   const { wagmi: wagmiConfig } = getConfig({
-    transports,
+    transports: testTransports,
     defaultChain,
     chains: externalChains,
     thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },

package/src/actions/transactions/beraWriteContract.integration.test.ts

@@ -11,11 +11,7 @@ import { mnemonicToAccount } from "viem/accounts";
 import { assert, describe, expect, it } from "vitest";
 
 import { appConfig, ChainId, getRpcUrls } from "@berachain/config/internal";
-import {
-  defaultChain,
-  externalChains,
-  transports,
-} from "@berachain/config/internal/wagmi";
+import { defaultChain, externalChains } from "@berachain/config/internal/wagmi";
 
 import { bgtAbi } from "@berachain/abis/pol/bgt";
 import { rewardVaultAbi } from "@berachain/abis/pol/rewards/rewardVault";
@@ -28,6 +24,7 @@ import { getServerSidePublicClient } from "../../utils/getServerSideClient";
 import { getTestClient } from "../../utils/getTestClient";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 import { anvilMnemonic } from "../../utils/test-utils";
+import { testTransports } from "../__test/transports";
 import { getUserVaults } from "../pol/getUserVaults";
 import { beraWriteContract } from "./beraWriteContract";
 
@@ -38,7 +35,7 @@ const testFn: IContractWriteFn = async (_args) => {
 describe("beraWriteContract", () => {
   const { config } = parseBaseArgs({ chainId: defaultChain.id });
   const beraWagmiConfig = getConfig({
-    transports,
+    transports: testTransports,
     defaultChain,
     chains: externalChains,
     thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },

package/src/data/contracts.ts

@@ -327,6 +327,11 @@ export const contracts = [
     "80094": "0xc8FD9a3fB3Dad4C22c9F8Cfa7cecC318A667A791",
     name: "pol.rewardAllocationFactory",
   },
+  {
+    "80069": "0xAf10B532cCC25B26a8e28913D5C4056a77e7a178",
+    "80094": "0xc41bbD6695AB6bdc6D04701b15f4CE5EbA2e2500",
+    name: "pol.lstStakerVaultFactory",
+  },
   {
     "80069": "0xba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1b",
     "80094": "0xba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1ba1b",

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

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.
@@ -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/utils/beraFetch.ts

@@ -1,6 +1,7 @@
 import { BeraTracing, type SpanContext } from "../errors/BeraTracing";
 import { RequestError } from "../errors/RequestError";
 import { getErrorResponse } from "./getErrorResponse";
+import { sanitizeRpcUrl } from "./sanitizeRpcUrl";
 
 type RequestOptions = RequestInit;
 
@@ -18,10 +19,10 @@ export async function beraFetch(
   },
 ) {
   try {
-    let spanUrl = (
+    let spanUrl = sanitizeRpcUrl(
       typeof endpoint === "string" || endpoint instanceof URL
         ? endpoint.toString()
-        : endpoint.url.toString()
+        : endpoint.url.toString(),
     ).replace(/0x[a-fA-F0-9]{40}/g, ":address");
 
     if (spanContext?.keepQueryParams !== true && URL.canParse(spanUrl)) {
@@ -43,10 +44,15 @@ export async function beraFetch(
       }
     }
 
+    const endpointName =
+      typeof endpoint === "string" || endpoint instanceof URL
+        ? undefined
+        : endpoint.name;
+
     return await BeraTracing.startSpan(
       {
         op: "beraFetch",
-        name: "beraFetch",
+        name: endpointName ? `beraFetch ${endpointName}` : "beraFetch",
         attributes:
           typeof endpoint === "string" || endpoint instanceof URL
             ? {

package/src/utils/exports.ts

@@ -24,5 +24,6 @@ export {
   wBeraToken as internal_wBeraToken,
 } from "./tokens";
 export * from "./tokenWrapping";
+export { tracedTransport } from "./tracedTransport";
 export * from "./truncateHash";
 export * from "./validatorUptimeStatus";