@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/src/utils/getServerSideClient.ts

@@ -7,6 +7,8 @@ import {
   getRpcUrls,
 } from "@berachain/config/internal";
 
+import { tracedTransport } from "./tracedTransport";
+
 /**
  * This is a singleton to avoid creating a new client for each request.
  *
@@ -31,10 +33,10 @@ export const getServerSidePublicClient = (
     rpcs.publicJsonRpcUrl,
   ]
     .filter((i) => i)
-    .map((url) => http(url));
+    .map((url) => tracedTransport(http(url)));
 
   if (fallbackTransports.length === 0) {
-    fallbackTransports.push(http());
+    fallbackTransports.push(tracedTransport(http()));
   }
   const chain = chainId === ChainId.MAINNET ? berachain : berachainBepolia;
   const client = createPublicClient({

package/src/utils/polyfillAbortSignalAny.ts

@@ -0,0 +1,53 @@
+/**
+ * Polyfill for `AbortSignal.any`.
+ *
+ * `AbortSignal.any` ships in Chrome 116+, Safari 17.4+, Firefox 124+. Older
+ * environments — notably Android WebViews bundled with old Chromium (e.g.
+ * Chrome Mobile WebView 114) — lack it, and third-party libraries that call it
+ * (e.g. @pythnetwork/hermes-client) throw "AbortSignal.any is not a function".
+ *
+ * This installs a spec-compatible-enough fallback: it returns a controller's
+ * signal that aborts as soon as any of the input signals abort (propagating the
+ * abort reason). It is idempotent and a no-op when the native API exists.
+ */
+export function polyfillAbortSignalAny(): void {
+  if (typeof AbortSignal === "undefined") return;
+  if (typeof (AbortSignal as { any?: unknown }).any === "function") return;
+
+  (
+    AbortSignal as unknown as { any: (signals: AbortSignal[]) => AbortSignal }
+  ).any = (signals: AbortSignal[]): AbortSignal => {
+    const controller = new AbortController();
+
+    // Phase 1: if any signal is already aborted, short-circuit before attaching
+    // any listeners (attaching to the others would leave dangling listeners
+    // that never fire — the leak the WeakRef/FinalizationRegistry versions guard
+    // against; checking first avoids it without that machinery).
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        return controller.signal;
+      }
+    }
+
+    // Phase 2: forward the first abort, then detach every listener so none
+    // outlive the combined signal. Safe for our short-lived usage (per-request
+    // fetch signals that settle and are collected together).
+    const listeners: Array<() => void> = [];
+    const cleanup = () => {
+      for (let i = 0; i < signals.length; i++) {
+        signals[i].removeEventListener("abort", listeners[i]);
+      }
+    };
+    for (const signal of signals) {
+      const onAbort = () => {
+        if (!controller.signal.aborted) controller.abort(signal.reason);
+        cleanup();
+      };
+      listeners.push(onAbort);
+      signal.addEventListener("abort", onAbort);
+    }
+
+    return controller.signal;
+  };
+}

package/src/utils/polyfillAbortSignalAny.unit.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { polyfillAbortSignalAny } from "./polyfillAbortSignalAny.js";
+
+describe("polyfillAbortSignalAny", () => {
+  const original = (AbortSignal as { any?: unknown }).any;
+
+  afterEach(() => {
+    // restore whatever the runtime had (native or undefined)
+    (AbortSignal as { any?: unknown }).any = original;
+  });
+
+  it("does not overwrite a native AbortSignal.any", () => {
+    const native = () => new AbortController().signal;
+    (AbortSignal as { any?: unknown }).any = native;
+    polyfillAbortSignalAny();
+    expect((AbortSignal as { any?: unknown }).any).toBe(native);
+  });
+
+  it("installs a fallback when AbortSignal.any is missing", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+    expect(typeof (AbortSignal as { any?: unknown }).any).toBe("function");
+  });
+
+  it("aborts the combined signal when one input aborts", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    const b = new AbortController();
+    const combined = (
+      AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }
+    ).any([a.signal, b.signal]);
+
+    expect(combined.aborted).toBe(false);
+    b.abort("boom");
+    expect(combined.aborted).toBe(true);
+    expect(combined.reason).toBe("boom");
+  });
+
+  it("removes listeners from all inputs once the combined signal aborts", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    const b = new AbortController();
+    const removed: AbortSignal[] = [];
+    for (const c of [a, b]) {
+      const orig = c.signal.removeEventListener.bind(c.signal);
+      c.signal.removeEventListener = ((...args: Parameters<typeof orig>) => {
+        removed.push(c.signal);
+        return orig(...args);
+      }) as typeof orig;
+    }
+
+    (AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }).any([
+      a.signal,
+      b.signal,
+    ]);
+
+    a.abort("x");
+    // both inputs should have had their abort listener detached, not just the firing one
+    expect(removed).toContain(a.signal);
+    expect(removed).toContain(b.signal);
+  });
+
+  it("is already aborted if an input is already aborted", () => {
+    (AbortSignal as { any?: unknown }).any = undefined;
+    polyfillAbortSignalAny();
+
+    const a = new AbortController();
+    a.abort("early");
+    const combined = (
+      AbortSignal as unknown as { any: (s: AbortSignal[]) => AbortSignal }
+    ).any([a.signal]);
+
+    expect(combined.aborted).toBe(true);
+    expect(combined.reason).toBe("early");
+  });
+});

package/src/utils/sanitizeRpcUrl.ts

@@ -0,0 +1,22 @@
+/**
+ * Strips secret tokens from RPC URLs for safe use in span attributes and logs.
+ *
+ * QuickNode URLs embed API keys as path segments, e.g.:
+ *   https://polished-morning-sun.bera-mainnet.quiknode.pro/abc123def/
+ * This function trims the subpath, producing:
+ *   https://polished-morning-sun.bera-mainnet.quiknode.pro/
+ */
+export function sanitizeRpcUrl(url: string | undefined): string {
+  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;
+  }
+}

package/src/utils/tracedTransport.ts

@@ -0,0 +1,35 @@
+import type { Transport } from "viem";
+
+import { BeraTracing } from "../errors/BeraTracing";
+import { sanitizeRpcUrl } from "./sanitizeRpcUrl";
+
+/**
+ * Wraps a viem Transport to trace each RPC request via BeraTracing.
+ *
+ * Each `request()` call is wrapped in a span with the JSON-RPC method name,
+ * transport type, and URL as attributes. Works with `http()`, `fallback()`,
+ * and any other viem transport.
+ */
+export function tracedTransport<T extends Transport>(transport: T): T {
+  return ((opts: Parameters<Transport>[0]) => {
+    const result = transport(opts);
+    const originalRequest = result.request;
+
+    result.request = async (args, options) => {
+      return BeraTracing.startSpan(
+        {
+          name: `RPC ${args.method}`,
+          op: "rpc.request",
+          attributes: {
+            "rpc.method": args.method,
+            "rpc.transport": result.config.type,
+            "rpc.url": sanitizeRpcUrl(result.value?.url),
+          },
+        },
+        () => originalRequest(args, options),
+      );
+    };
+
+    return result;
+  }) as T;
+}

package/dist/BeraError-_mQdkanr.d.ts

@@ -1,94 +0,0 @@
-import { Abi } from 'viem';
-
-/**
- * Severity levels for error reporting.
- * Mirrors Sentry's SeverityLevel for compatibility, but owned by berajs
- * so we don't depend on @sentry/nextjs.
- */
-type SeverityLevel = "fatal" | "error" | "warning" | "log" | "info" | "debug";
-
-interface IBeraErrorArgs {
-    message?: string;
-    displayMessage?: string;
-    cause?: unknown;
-    reason?: string;
-    chainId?: number;
-    fingerprint?: string[];
-    /**
-     * The level of the error to be used for error reporting.
-     */
-    level?: SeverityLevel;
-    tags?: {
-        [key in TagsKey]?: Primitive;
-    };
-    extra?: Record<string, unknown>;
-    /**
-     * Optional ABI to be used to parse the error.
-     */
-    abi?: Abi;
-}
-type Primitive = number | string | boolean | bigint | symbol | null | undefined;
-/**
- * An helper type to make sure we only use the allowed tags. Sync this with docs/errors.md
- */
-type TagsKey = "wallet.chain" | "wallet.connector" | "wallet.address" | "error.reason" | "operation.type" | "operation.key" | "operation.txn.functionName" | "operation.txn.to" | "operation.txn.status" | "operation.source.url" | "operation.source.name" | "operation.source.queryName" | "operation.source.type";
-/**
- * Base error class for the entire berajs SDK.
- *
- * All errors should be a BeraError or one of its subclasses. Unknown errors should be
- * normalized via `initBeraError({ cause })`.
- *
- * Key design: the constructor runs an **automatic reason detection pipeline** when `reason`
- * is not explicitly provided. It calls `parseViemError` on the `cause` to extract a
- * machine-readable reason code (e.g. "NotEnoughBalance", "BAL#508", "UserRejectedRequestError").
- * That reason is then matched against `errorMap.ts` to resolve a user-friendly `displayMessage`.
- *
- * This means: for most viem errors, you only need to pass `cause` and everything else
- * (reason, displayMessage, level) is derived automatically.
- *
- * @see parseViemError — the reason extraction engine
- * @see errorMap.ts — reason → displayMessage mapping
- * @see initBeraError — normalizes any error into a BeraError (preferred entry point)
- */
-declare class BeraError extends Error {
-    /**
-     * A human-readable message that can be displayed to end user.
-     *
-     * In berachain dapps, this is shown in the error pop-up.
-     */
-    displayMessage: string;
-    /**
-     * The cause of the error.
-     *
-     * This is typically the error that was thrown.
-     */
-    cause: unknown;
-    /**
-     * The chain id of the error.
-     */
-    chainId?: number;
-    /**
-     * The code for the reason for the error.
-     *
-     * This is typically the error code can be found in the errorMap.ts file. I.e. NotEnoughBalance or BAL#508
-     */
-    reason: string | null;
-    /**
-     * The fingerprint for the error.
-     *
-     * This is typically used to group errors in Sentry.
-     */
-    fingerprint: string[] | undefined;
-    private _tags;
-    set tags(tags: {
-        [key: string | TagsKey]: Primitive;
-    });
-    get tags(): {
-        [key: string | TagsKey]: Primitive;
-    };
-    level: SeverityLevel;
-    extra: Record<string, unknown>;
-    constructor({ message: m, displayMessage: dm, cause, reason, level, abi, tags, chainId, fingerprint, }: IBeraErrorArgs);
-}
-
-export { BeraError as B, type IBeraErrorArgs as I, type SeverityLevel as S };

package/dist/BexStatusProvider-DRymVlQf.d.cts

@@ -1,70 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as react from 'react';
-import { Dispatch, SetStateAction, PropsWithChildren } from 'react';
-import { Hex } from 'viem';
-import { EdgeConfigSchema } from '@berachain/config/internal/edge-config';
-
-type FactoryStatus = {
-    /**
-     * If the composable stable factory is enabled
-     */
-    composableStable: "paused" | "enabled";
-    /**
-     * If the weighted factory is enabled
-     */
-    weighted: "paused" | "enabled";
-};
-interface BexStatusProviderProps {
-    isVaultPaused: boolean;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-    };
-    factories: FactoryStatus;
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-}
-declare const BexStateContext: react.Context<{
-    protocol: {
-        isPaused: boolean;
-        factories: FactoryStatus & {
-            allPaused: boolean;
-        };
-    };
-    onPoolChange: Dispatch<SetStateAction<BexStatusProviderProps["pool"]>>;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-        disablePoolWithdrawals: boolean;
-        disablePoolDeposits: boolean;
-    };
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-}>;
-/**
- * @description Determines the status of a pool or vault and returns the appropriate messages and flags to disable functionality.
- * More information here https://www.notion.so/berachain/BEX-RecoveryMode-and-Pause-explained-17c6120abced80e0985dd589b57ff018
- *
- * @returns status flags to enable/disable/notify users across the BEX
- *
- **/
-declare function useBexStatus(): {
-    protocol: {
-        isPaused: boolean;
-        factories: FactoryStatus & {
-            allPaused: boolean;
-        };
-    };
-    onPoolChange: Dispatch<SetStateAction<BexStatusProviderProps["pool"]>>;
-    pool?: {
-        id: Hex;
-        isInRecoveryMode: boolean;
-        isPaused: boolean;
-        disablePoolWithdrawals: boolean;
-        disablePoolDeposits: boolean;
-    };
-    labels?: NonNullable<EdgeConfigSchema["bex"]>["emergencyLabels"];
-};
-declare function BexStatusProvider({ children, isVaultPaused, labels, factories, }: PropsWithChildren<BexStatusProviderProps>): react_jsx_runtime.JSX.Element;
-
-export { BexStateContext as B, BexStatusProvider as a, type BexStatusProviderProps as b, useBexStatus as u };