@berachain/berajs 0.2.9 → 0.2.10

package/src/actions/pol/getAutoclaimedIncentivesTxHash.ts

@@ -0,0 +1,41 @@
+import type { Address } from "viem";
+
+import { RequestError } from "../../errors/RequestError";
+import type { AutoclaimedIncentivesTxHashResponse } from "../../types/bribe-boost";
+import { beraFetchJson } from "../../utils/beraFetch";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
+
+/**
+ * Companion to `getAutoclaimedIncentives` that fetches the on-chain tx hash
+ * for each autoclaimed token. Same nested shape as `/autoclaimed`, but each
+ * token leaf is `{ txhash }` where the hash may be absent or empty while the
+ * bot is still in flight.
+ *
+ * Returns `null` on 404 (bot has not run yet for this wallet).
+ */
+export async function getAutoclaimedIncentivesTxHash({
+  account,
+  ...args
+}: {
+  account: Address;
+} & BeraJS.BaseFunctionArgs): Promise<AutoclaimedIncentivesTxHashResponse | null> {
+  const { config } = parseBaseArgs(args);
+
+  try {
+    return await beraFetchJson<AutoclaimedIncentivesTxHashResponse>(
+      {
+        url: `${
+          config.pol.bribeBoostApi
+        }/api/v1/wallets/${account.toLowerCase()}/autoclaimed/txhash`,
+        name: "pol-autoclaimed-incentives-txhash",
+        type: "rest",
+      },
+      { cache: "no-store" },
+    );
+  } catch (error) {
+    if (error instanceof RequestError && error.statusCode === 404) {
+      return null;
+    }
+    throw error;
+  }
+}

package/src/actions/pol/getBgtIncentiveDistributorPaused.ts

@@ -9,8 +9,6 @@ import { parseBaseArgs } from "../../utils/parseBaseArgs";
  * Reads `paused()` on the BGT incentive distributor. Used to gate the
  * autoclaim banner — when `true`, users can no longer self-claim and the
  * bot is responsible for distributing incentives on their behalf.
- *
- * Fails closed: any read error returns `false` so the banner stays hidden.
  */
 export async function getBgtIncentiveDistributorPaused({
   publicClient,
@@ -22,14 +20,9 @@ export async function getBgtIncentiveDistributorPaused({
 
   const { config } = parseBaseArgs(args);
 
-  try {
-    const paused = await publicClient.readContract({
-      address: config.pol.bgtIncentiveDistributor,
-      abi: bgtIncentiveDistributorAbi,
-      functionName: "paused",
-    });
-    return paused;
-  } catch {
-    return false;
-  }
+  return publicClient.readContract({
+    address: config.pol.bgtIncentiveDistributor,
+    abi: bgtIncentiveDistributorAbi,
+    functionName: "paused",
+  });
 }

package/src/actions/pol/getEarnedStakedBeraVault.ts

@@ -1,11 +1,8 @@
 import type { Address } from "viem";
 
-import { getUriFromLink } from "@berachain/config";
-
-import type { VaultEarningResponse } from "@berachain/graphql/api";
-
-import { beraFetchJson } from "../../utils/beraFetch";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { fetchBeep } from "../clients/fetchBeep";
+import { fetchRailwayBackend } from "../clients/fetchRailwayBackend";
 
 type GetEarnedStakedBeraVaultArgs = {
   /**
@@ -21,17 +18,24 @@ export async function getEarnedStakedBeraVault({
   address,
   account,
   ...args
-}: BeraJS.BaseFunctionArgs &
-  GetEarnedStakedBeraVaultArgs): Promise<VaultEarningResponse> {
+}: BeraJS.BaseFunctionArgs & GetEarnedStakedBeraVaultArgs) {
   const { config } = parseBaseArgs(args);
 
-  const url = `${getUriFromLink(config.backend)}/vaults/${address}/earnings/${account}`;
-  return beraFetchJson<VaultEarningResponse>({
-    url,
-    name:
-      typeof config.backend === "string"
-        ? "backend-railway"
-        : config.backend.name,
-    type: "rest",
-  });
+  // TODO(beep): remove this entire block once `beep` is deployed on every
+  // chain. It is the only legacy-Railway-specific code left here; deleting it
+  // leaves the `beep` path below as the sole implementation.
+  if (!config.beep) {
+    return fetchRailwayBackend(
+      "/vaults/{vault}/earnings/{owner}",
+      { path: { vault: address, owner: account } },
+      args,
+    );
+  }
+
+  // beep backend (next-gen), typed against `@berachain/graphql/beep`.
+  return fetchBeep(
+    "/v0/stake/{vault}/earnings/{owner}",
+    { path: { vault: address, owner: account } },
+    args,
+  );
 }

package/src/actions/pol/getRewardVaults.ts

@@ -87,13 +87,13 @@ export async function getRewardVaults({
       ...vault,
       dynamicData: {
         ...vault.dynamicData,
-        allTimeReceivedBGTAmount:
-          vault.dynamicData?.allTimeReceivedBGTAmount ?? "0",
-        bgtCapturePercentage: vault.dynamicData?.bgtCapturePercentage ?? "0",
+        allTimeRewards: vault.dynamicData?.allTimeRewards ?? "0",
+        rewardCapturePercentage:
+          vault.dynamicData?.rewardCapturePercentage ?? 0,
         activeIncentivesValueUsd: totalIncentiveInUsdc.toString(),
         activeIncentivesRateUsd:
           vault.dynamicData?.activeIncentivesRateUsd ?? "0",
-        bgtCapturePerBlock: vault.dynamicData?.bgtCapturePerBlock ?? "0",
+        rewardCapturePerBlock: vault.dynamicData?.rewardCapturePerBlock ?? 0,
       },
       activeIncentives: incentivesArray,
     } satisfies typeof vault;

package/src/actions/pol/getStakingDailyAssets.ts

@@ -1,11 +1,8 @@
 import type { Address } from "viem";
 
-import { getUriFromLink } from "@berachain/config";
-
-import type { VaultStatsByDayResponse } from "@berachain/graphql/api";
-
-import { beraFetchJson } from "../../utils/beraFetch";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { fetchBeep } from "../clients/fetchBeep";
+import { fetchRailwayBackend } from "../clients/fetchRailwayBackend";
 
 export async function getStakingDailyAssets({
   address,
@@ -13,15 +10,22 @@ export async function getStakingDailyAssets({
 }: {
   address: Address;
   range: 30 | 60 | 90;
-}): Promise<VaultStatsByDayResponse> {
+}) {
   const { config } = parseBaseArgs({});
-  const url = `${getUriFromLink(config.backend)}/vaults/${address}/stats-by-day?days=${range}`;
-  return beraFetchJson<VaultStatsByDayResponse>({
-    url,
-    name:
-      typeof config.backend === "string"
-        ? "backend-railway"
-        : config.backend.name,
-    type: "rest",
+
+  // TODO(beep): remove this entire block once `beep` is deployed on every
+  // chain. It is the only legacy-Railway-specific code left here; deleting it
+  // leaves the `beep` path below as the sole implementation.
+  if (!config.beep) {
+    return fetchRailwayBackend("/vaults/{vault}/stats-by-day", {
+      path: { vault: address },
+      query: { days: `${range}` },
+    });
+  }
+
+  // beep backend (next-gen), typed against `@berachain/graphql/beep`.
+  return fetchBeep("/v0/stake/{vault}/stats-by-day", {
+    path: { vault: address },
+    query: { days: `${range}` },
   });
 }

package/src/actions/validators/utils/getValidatorBoostApy.ts

@@ -51,7 +51,7 @@ export function getValidatorBoostApy({
 
   const boostApy =
     (returnPerBgt *
-      Number(validator.dynamicData?.lastDayDistributedBGTAmount ?? 0) *
+      Number(validator.dynamicData?.lastDayDistributedRewards ?? 0) *
       365) /
     (validatorActiveBoostAmount * bgtPrice);
 

package/src/errors/RequestError.ts

@@ -1,6 +1,7 @@
 import type { ErrorLike } from "@apollo/client";
 
 import { getUriFromLink } from "@berachain/config";
+import { bepolia } from "@berachain/config/bepolia";
 import { mainnet } from "@berachain/config/mainnet";
 
 import { BeraError, type IBeraErrorArgs } from "./BeraError";
@@ -33,12 +34,16 @@ export class RequestError extends BeraError {
    */
   private queryRichfulDomains = [
     mainnet.bex.aggregatorsProxyUrl,
-    "https://api.fly.trade/aggregator/quote",
+    // covers both /aggregator/quote and /aggregator/transaction?quoteId=...
+    // (the transaction endpoint's quoteId would otherwise fragment grouping)
+    "https://api.fly.trade/aggregator",
     "https://open-api.openocean.finance/v4/bera/swap",
     // vercel internal proxy
     "/api/aggregators?aggregator",
     // bonder endpoints have date-based query params (e.g. ?start=2025-11-28)
     mainnet.backend,
+    // beep (next-gen backend) on testnet — same date-based bonder query params
+    bepolia.beep,
   ];
 
   statusCode: number | undefined;
@@ -208,14 +213,18 @@ export class RequestError extends BeraError {
       // - have a network error
       // - have CORS errors
       // the list is empirically collected from sentry error logs.
+      // The trailing "(host)" suffix is optional: some browsers/transports omit
+      // it (e.g. bare "Failed to fetch" / "Load failed"). We normalize all of
+      // them to a single NETWORK_ERROR reason so the variants group together,
+      // falling back to the endpoint url when no host is present in the message.
       const failedToFetchMatch = message.match(
-        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed) \(([a-z0-9-.]+)\)$/,
+        /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed)(?: \(([a-z0-9-.]+)\))?$/,
       );
       if (failedToFetchMatch) {
         return {
           reason: RequestError.REASON_MAP.NETWORK_ERROR,
           message: message,
-          url: failedToFetchMatch[1],
+          url: failedToFetchMatch[1] ?? this.endpoint.url,
         };
       }
     }

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { RequestError } from "./RequestError.js";
+
+describe("RequestError endpoint normalization (grouping)", () => {
+  it("strips query params from the fly.trade transaction endpoint so quoteId no longer fragments groups", () => {
+    const base = "https://api.fly.trade/aggregator/transaction";
+    const a = new RequestError({
+      response: undefined,
+      endpoint: {
+        url: `${base}?quoteId=aaaa-1111&estimateGas=false`,
+        type: "rest",
+      },
+    });
+    const b = new RequestError({
+      response: undefined,
+      endpoint: {
+        url: `${base}?quoteId=bbbb-2222&estimateGas=false`,
+        type: "rest",
+      },
+    });
+
+    expect(a.endpoint.url).toBe(base);
+    expect(b.endpoint.url).toBe(base);
+    expect(a.endpoint.url).toBe(b.endpoint.url);
+  });
+});
+
+describe("RequestError network-error normalization (grouping)", () => {
+  it.each([
+    "Failed to fetch",
+    "Load failed",
+    "NetworkError when attempting to fetch resource.",
+    "Failed to fetch (api.berachain.com)",
+  ])("normalizes %s to NETWORK_ERROR reason", (message) => {
+    const err = new RequestError({
+      response: undefined,
+      cause: new TypeError(message),
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.reason).toBe(RequestError.REASON_MAP.NETWORK_ERROR);
+    expect(err.level).toBe("warning");
+  });
+
+  it("does not treat unrelated messages as network errors", () => {
+    const err = new RequestError({
+      response: undefined,
+      cause: new TypeError("Cannot read properties of undefined"),
+      endpoint: { url: "https://api.berachain.com", type: "graphql" },
+    });
+
+    expect(err.reason).not.toBe(RequestError.REASON_MAP.NETWORK_ERROR);
+  });
+});

package/src/errors/errorMap.ts

@@ -89,6 +89,14 @@ export const errorMsgMap = {
       errorMSG:
         "Nonce is too low. Your wallet might have unconfirmed transactions.",
     },
+    REPLACEMENT_UNDERPRICED: {
+      // Transient resubmission issue (gas bump too low). Not function-specific —
+      // normalizing the raw RPC string to this key collapses the per-function
+      // Sentry groups (functionName is still kept as a tag).
+      keywords: ["replacement transaction underpriced"],
+      errorMSG:
+        "Your wallet tried to replace a pending transaction without raising the gas enough. Please wait for the previous transaction to finish, or try again.",
+    },
     GAS_PRICE: {
       keywords: ["gasLimit"],
       errorMSG:

package/src/hooks/exports.ts

@@ -49,6 +49,7 @@ export * from "./honey/useIsBasketModeEnabled";
 export * from "./honey/usePythLatestPrices";
 export * from "./perps/usePythUpdateFee";
 export { useAutoclaimedIncentives } from "./pol/useAutoclaimedIncentives";
+export { useAutoclaimedIncentivesTxHash } from "./pol/useAutoclaimedIncentivesTxHash";
 export * from "./pol/useBgtAprSimulation";
 export { useBgtUnstakedBalance } from "./pol/useBgtUnstakedBalance";
 export { useClaimableFees } from "./pol/useClaimableFees";

package/src/hooks/pol/useAutoclaimedIncentives.ts

@@ -3,7 +3,6 @@ import useSWR from "swr";
 import { useBeraWallet } from "@berachain/wagmi/hooks";
 
 import { getAutoclaimedIncentives } from "../../actions/pol/getAutoclaimedIncentives";
-import { BeraError } from "../../errors/BeraError";
 import type { AutoclaimedIncentivesResponse } from "../../types/bribe-boost";
 import type { DefaultHookReturnType } from "../../types/global";
 
@@ -26,15 +25,7 @@ export function useAutoclaimedIncentives({
 
   const swrResponse = useSWR(
     QUERY_KEY,
-    async ([, account]) => {
-      if (!account) {
-        throw new BeraError({
-          message: "useAutoclaimedIncentives needs a logged in account",
-          level: "error",
-        });
-      }
-      return await getAutoclaimedIncentives({ account });
-    },
+    async ([, account]) => getAutoclaimedIncentives({ account }),
     {
       revalidateOnFocus: false,
       revalidateOnReconnect: false,

package/src/hooks/pol/useAutoclaimedIncentivesTxHash.ts

@@ -0,0 +1,45 @@
+import useSWR from "swr";
+
+import { useBeraWallet } from "@berachain/wagmi/hooks";
+
+import { getAutoclaimedIncentivesTxHash } from "../../actions/pol/getAutoclaimedIncentivesTxHash";
+import { POLLING } from "../../enum/polling";
+import type { AutoclaimedIncentivesTxHashResponse } from "../../types/bribe-boost";
+import type { DefaultHookReturnType } from "../../types/global";
+
+interface UseAutoclaimedIncentivesTxHashArgs {
+  // Hard gate, identical to `useAutoclaimedIncentives` — only flip true once
+  // both `!isBgtPolRewardToken` and `bgtIncentiveDistributor.paused()` hold.
+  enabled: boolean;
+}
+
+export function useAutoclaimedIncentivesTxHash({
+  enabled,
+}: UseAutoclaimedIncentivesTxHashArgs): DefaultHookReturnType<AutoclaimedIncentivesTxHashResponse | null> {
+  const { address: account } = useBeraWallet();
+
+  const QUERY_KEY =
+    enabled && account
+      ? (["useAutoclaimedIncentivesTxHash", account] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, account]) => getAutoclaimedIncentivesTxHash({ account }),
+    {
+      // txhashes flip from absent → present as the bot processes each token,
+      // so we need to actually poll. Cadence matches the bot's tx cadence
+      // (minutes, not seconds) and lets the user watch pending → claimed
+      // transitions without reloading the page.
+      refreshInterval: POLLING.NORMAL,
+      revalidateOnFocus: true,
+      revalidateOnReconnect: true,
+      revalidateIfStale: false,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse?.mutate?.(),
+  };
+}

package/src/hooks/validators/useValidator.ts

@@ -40,12 +40,8 @@ export function useValidator(
                   "",
                 queuedBoostAmount:
                   indexerValidator?.dynamicData?.queuedBoostAmount ?? "",
-                usersActiveBoostCount:
-                  indexerValidator?.dynamicData?.usersActiveBoostCount ?? 0,
-                usersQueuedBoostCount:
-                  indexerValidator?.dynamicData?.usersQueuedBoostCount ?? 0,
-                allTimeDistributedBGTAmount:
-                  indexerValidator?.dynamicData?.allTimeDistributedBGTAmount ??
+                allTimeDistributedRewards:
+                  indexerValidator?.dynamicData?.allTimeDistributedRewards ??
                   "0",
                 rewardRate:
                   onChainValidator?.dynamicData?.rewardRate ??
@@ -53,8 +49,8 @@ export function useValidator(
                   "",
                 stakedBeraAmount:
                   indexerValidator?.dynamicData?.stakedBeraAmount ?? "",
-                lastDayDistributedBGTAmount:
-                  indexerValidator?.dynamicData?.lastDayDistributedBGTAmount ??
+                lastDayDistributedRewards:
+                  indexerValidator?.dynamicData?.lastDayDistributedRewards ??
                   "",
                 lastDayProposedBlockCount:
                   indexerValidator?.dynamicData?.lastDayProposedBlockCount ?? 0,

package/src/types/bribe-boost.d.ts

@@ -33,11 +33,22 @@ export interface BribeBoostRewardProof {
 }
 
 // Response shape of GET /api/v1/wallets/:wallet/autoclaimed:
-//   { [wallet]: { [validatorPubkey]: { [tokenAddress]: rawAmount (stringified bigint) } } }
-// Top-level wallet key is the lowercase wallet address that was queried.
+//   { [wallet]: { [validatorPubkey]: { [tokenAddress]: { amount } } } }
+// `amount` is a stringified bigint in token base units. The backend now
+// aggregates across validators under a single fake pubkey (`0x000…000`),
+// so consumers can collapse the validator dimension blindly.
 export type AutoclaimedIncentivesResponse = Record<
   Address,
-  Record<Address, Record<Address, string>>
+  Record<Address, Record<Address, { amount: string }>>
+>;
+
+// Response shape of GET /api/v1/wallets/:wallet/autoclaimed/txhash: same
+// nesting, but each token leaf is `{ txhash }`. Tokens still pending are
+// simply absent — when a token from `/autoclaimed` has no entry here, the
+// bot hasn't distributed it yet.
+export type AutoclaimedIncentivesTxHashResponse = Record<
+  Address,
+  Record<Address, Record<Address, { txhash: string }>>
 >;
 
 export interface BribeBoostValidatorApr {

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