@berachain/berajs 0.2.13 → 0.3.1

package/src/actions/validators/getUserActiveValidators.ts

@@ -17,82 +17,144 @@ export type ValidatorWithUserBoost = ApiValidatorInListFragment & {
   userBoosts: UserBoostsOnValidator;
 };
 
-export async function getUserActiveValidators({
+export type UserValidatorsApiData = ApiValidatorInListFragment[];
+
+/**
+ * Fetches the API-side data for a user's boosted validators: the list of
+ * validator IDs the user has boosted (from the boosts API) and the validator
+ * info for each. On-chain boost amounts are fetched separately by
+ * {@link getUserActiveValidatorsOnChain} so the two can refresh independently.
+ */
+export async function getUserActiveValidatorsApi({
   account,
-  publicClient,
   chain,
   ...args
 }: {
   account: string;
-  publicClient: PublicClient | undefined;
   chain?: GqlChain;
-} & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[] | undefined> {
+} & BeraJS.BaseFunctionArgs): Promise<UserValidatorsApiData> {
   const { config } = parseBaseArgs(args);
   const resolvedChain = chain ?? (config.bex.chainName as GqlChain);
 
   const userBoosts = await getUserBoosts({ account });
 
-  const [validatorInfoList, onChainBoosts] = await Promise.all([
-    getAllValidators({
-      variables: {
-        chain: resolvedChain,
-        where: {
-          idIn: userBoosts.data.polGetValidatorBoosts.boosts.map(
-            (t) => t.validatorId,
-          ),
-        },
-      },
-    }),
-    Promise.all(
-      userBoosts.data.polGetValidatorBoosts.boosts
-        .filter(
-          (t) =>
-            // there's an edge case here where api doesn't return the pubkey
-            // because the user might have boosted a pubkey that doesn't exist
-            // api doesn't return the pubkey in this case, but we're choosing to filter them out
-            !!t.validator,
-        )
-        .map((t) =>
-          getUserBoostsOnValidator({
-            account: account as Address,
-            pubkey: t.validator!.pubkey,
-            publicClient: publicClient,
-          }),
+  const validatorInfoList = await getAllValidators({
+    variables: {
+      chain: resolvedChain,
+      where: {
+        idIn: userBoosts.data.polGetValidatorBoosts.boosts.map(
+          (t) => t.validatorId,
         ),
+      },
+    },
+  });
+
+  return validatorInfoList?.validators.validators ?? [];
+}
+
+/**
+ * Reads the on-chain boost amounts for each validator in the API data.
+ * Cheap to re-run on its own, which is what powers the hook's
+ * `refreshOnChain()`.
+ */
+export async function getUserActiveValidatorsOnChain({
+  account,
+  validators,
+  publicClient,
+}: {
+  account: string;
+  validators: UserValidatorsApiData;
+  publicClient: PublicClient | undefined;
+}): Promise<UserBoostsOnValidator[]> {
+  return await Promise.all(
+    validators.map((validator) =>
+      getUserBoostsOnValidator({
+        account: account as Address,
+        pubkey: validator.pubkey as Address,
+        publicClient,
+      }),
     ),
-  ]);
+  );
+}
 
-  return validatorInfoList?.validators.validators.map((validator) => {
+/**
+ * Merges API validator info with on-chain boost amounts into the shape widgets
+ * consume. Validators without a matching on-chain read are dropped (the API can
+ * return a pubkey that was never actually boosted on-chain).
+ */
+export function mergeUserActiveValidators({
+  validators,
+  onChainBoosts,
+}: {
+  validators: UserValidatorsApiData;
+  onChainBoosts: UserBoostsOnValidator[];
+}): ValidatorWithUserBoost[] {
+  return validators.flatMap((validator) => {
     const userDeposited = onChainBoosts.find(
       (data) => data.pubkey.toLowerCase() === validator.pubkey.toLowerCase(),
     );
 
     if (!userDeposited) {
-      throw new Error("User deposited not found");
+      // there's an edge case here where api doesn't return the pubkey
+      // because the user might have boosted a pubkey that doesn't exist
+      // api doesn't return the pubkey in this case, but we're choosing to
+      // filter them out
+      return [];
     }
 
     const droppableBoostAmount =
-      parseEther(userDeposited?.activeBoostAmount ?? "0") -
-      parseEther(userDeposited?.queuedDropBoostAmount);
+      parseEther(userDeposited.activeBoostAmount ?? "0") -
+      parseEther(userDeposited.queuedDropBoostAmount);
 
-    return {
-      ...validator,
-      userBoosts: {
-        pubkey: userDeposited.pubkey,
-        activeBoostAmount: userDeposited?.activeBoostAmount,
-        queuedBoostAmount: userDeposited?.queuedBoostAmount,
-        queuedBoostStartBlock: Number(userDeposited?.queuedBoostStartBlock),
-        queuedDropBoostAmount: userDeposited?.queuedDropBoostAmount,
-        queuedDropBoostStartBlock: Number(
-          userDeposited?.queuedDropBoostStartBlock,
-        ),
-        droppableBoostAmount: formatEther(droppableBoostAmount),
-        hasPendingBoosts:
-          Number(userDeposited?.queuedBoostAmount) > 0 ||
-          Number(userDeposited?.queuedDropBoostAmount) > 0,
-        hasActiveBoosts: Number(userDeposited?.activeBoostAmount) > 0,
-        hasDroppableBoosts: droppableBoostAmount > 0n,
-      } satisfies UserBoostsOnValidator,
-    } satisfies ValidatorWithUserBoost;
+    return [
+      {
+        ...validator,
+        userBoosts: {
+          pubkey: userDeposited.pubkey,
+          activeBoostAmount: userDeposited.activeBoostAmount,
+          queuedBoostAmount: userDeposited.queuedBoostAmount,
+          queuedBoostStartBlock: Number(userDeposited.queuedBoostStartBlock),
+          queuedDropBoostAmount: userDeposited.queuedDropBoostAmount,
+          queuedDropBoostStartBlock: Number(
+            userDeposited.queuedDropBoostStartBlock,
+          ),
+          droppableBoostAmount: formatEther(droppableBoostAmount),
+          hasPendingBoosts:
+            Number(userDeposited.queuedBoostAmount) > 0 ||
+            Number(userDeposited.queuedDropBoostAmount) > 0,
+          hasActiveBoosts: Number(userDeposited.activeBoostAmount) > 0,
+          hasDroppableBoosts: droppableBoostAmount > 0n,
+        } satisfies UserBoostsOnValidator,
+      } satisfies ValidatorWithUserBoost,
+    ];
+  });
+}
+
+/**
+ * Fetches a user's boosted validators with their on-chain boost amounts.
+ * Combines the API query, on-chain query, and merge; the hook
+ * `useUserActiveValidators` splits these so it can refresh the on-chain part
+ * alone.
+ */
+export async function getUserActiveValidators({
+  account,
+  publicClient,
+  chain,
+  ...args
+}: {
+  account: string;
+  publicClient: PublicClient | undefined;
+  chain?: GqlChain;
+} & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[]> {
+  const validators = await getUserActiveValidatorsApi({
+    account,
+    chain,
+    ...args,
+  });
+  const onChainBoosts = await getUserActiveValidatorsOnChain({
+    account,
+    validators,
+    publicClient,
   });
+  return mergeUserActiveValidators({ validators, onChainBoosts });
 }

package/src/actions/validators/getValidatorIncentiveDistribution.ts

@@ -1,8 +1,7 @@
 import type { Address } from "viem";
 
-import type { ValidatorIncentivesResponse } from "@berachain/graphql/beep";
-
 import { BeraError } from "../../errors/BeraError";
+import type { ValidatorIncentivesResponse } from "../../generated/beep";
 import { calculateTimestampFromDays } from "../../utils/formatTimestamps";
 import { fetchBeep } from "../clients/fetchBeep";
 

package/src/actions/validators/getValidatorRewardAllocation.ts

@@ -3,6 +3,7 @@ import type { Address, PublicClient } from "viem";
 import { beraChefAbi } from "@berachain/abis/pol/rewards/beraChef";
 
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
+import { isDefaultRewardAllocation } from "./getDefaultRewardAllocation";
 
 export interface ValidatorRewardAllocationRaw {
   startBlock: bigint;
@@ -86,6 +87,11 @@ export async function getValidatorRewardAllocation({
    */
   isBaseline: boolean;
 
+  /**
+   * Whether the reward allocation is the default reward allocation.
+   */
+  isDefault: boolean;
+
   isNeverSet: boolean;
 }> {
   const { config } = parseBaseArgs(args);
@@ -132,9 +138,13 @@ export async function getValidatorRewardAllocation({
       Number(lastRaUpdateSet.timestamp),
     );
 
+    const isDefault = isDefaultRewardAllocation(activeRewardAllocation);
+
     let isBaseline = false;
 
-    if (setRewardAllocation.start.blockNumber === 0) {
+    if (isDefault) {
+      isBaseline = false;
+    } else if (setRewardAllocation.start.blockNumber === 0) {
       // the validator has never set the reward allocation
       isBaseline = true;
     } else {
@@ -150,6 +160,7 @@ export async function getValidatorRewardAllocation({
       activeRewardAllocation: activeRewardAllocation,
       setRewardAllocation,
       isBaseline,
+      isDefault,
       isNeverSet: setRewardAllocation?.start.blockNumber === 0,
     };
   } catch (e) {

package/src/contexts/BeraFlags/BeraFlags.tsx

@@ -1,9 +1,6 @@
 import { createContext, useContext } from "react";
 
-import {
-  type EdgeConfigSchema,
-  isFlagEnabled,
-} from "@berachain/config/internal/edge-config";
+import { type EdgeConfigSchema, isFlagEnabled } from "@berachain/edge-config";
 
 import { type BeraFlags, defaultFlags } from "./defaultFlags";
 

package/src/contexts/BeraFlags/defaultFlags.ts

@@ -1,4 +1,4 @@
-import type { flags } from "@berachain/config/internal/flags";
+import type { flags } from "@berachain/edge-config/flags";
 
 type ClientSideFlags = keyof typeof flags;
 
@@ -19,7 +19,6 @@ export type BeraFlags = Record<
     | "isZapStakeBeraEnabled"
     | "mockValidatorOperator"
     | "mockValidatorRewardAllocator"
-    | "isBgtPolRewardToken"
     | "mockRewardDurationManager"
     | "mockIncentiveManager"
     | "isHoneyPythWrapperEnabled"
@@ -43,7 +42,6 @@ export const defaultFlags: BeraFlags = {
   isZapStakeBeraEnabled: false,
   mockValidatorOperator: false,
   mockValidatorRewardAllocator: false,
-  isBgtPolRewardToken: true,
   mockRewardDurationManager: false,
   mockIncentiveManager: false,
   isHoneyPythWrapperEnabled: true,

package/src/contexts/BexStatusProvider.tsx

@@ -8,7 +8,7 @@ import {
 } from "react";
 import type { Hex } from "viem";
 
-import type { EdgeConfigSchema } from "@berachain/config/internal/edge-config";
+import type { EdgeConfigSchema } from "@berachain/edge-config";
 
 import { BeraError } from "../errors/BeraError";
 

package/src/contexts/TokensProvider.tsx

@@ -1,9 +1,6 @@
 import { createContext, type PropsWithChildren, useMemo } from "react";
 
-import {
-  type EdgeConfigSchema,
-  isFlagEnabled,
-} from "@berachain/config/internal/edge-config";
+import { type EdgeConfigSchema, isFlagEnabled } from "@berachain/edge-config";
 
 import { useEnsoUserTokensWithBalances } from "../hooks/enso/useEnsoUserTokensWithBalances";
 import type { BalanceToken, Token, TokenWithMetadata } from "../types/dex";

package/src/enum/contracts.ts

@@ -8,7 +8,10 @@ export enum ContractName {
   BEX_POOL = "bex.pool",
   ERC20 = "others.erc20",
   ERC4626 = "others.erc4626",
+  POL_BGT = "pol.bgt",
   POL_STAKE_VAULT = "pol.stakeVault",
+  INFRARED_IBGT_VAULT = "infrared.ibgtVault",
+  INFRARED_IBGT_REDEEMER = "infrared.ibgtRedeemer",
   BEX_EXPLOITED_FUND_DISTRIBUTOR = "bex.exploitedFundDistributor",
   TW_MINIMAL_ACCOUNT = "thirdweb.minimalAccount",
 }

package/src/enum/txnEnum.ts

@@ -41,7 +41,7 @@ export enum TransactionActionType {
   RESET_REWARD_MODE = "Reset Reward Mode",
   CREATE_BRIBE = "Add Incentives",
   CLAIMING_BRIBES = "Claiming Incentives", // claiming others
-  CLAIMING_REWARDS = "Claiming BGT",
+  CLAIMING_REWARDS = "Claiming BERA",
   CLAIM_ALL_REWARDS = "Claim All Rewards",
 
   RECOVER_FUNDS = "Recover Bex Funds",

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

@@ -1,3 +1,4 @@
+import { WaitForTransactionReceiptTimeoutError } from "viem";
 import { describe, expect, it } from "vitest";
 
 import { BeraError } from "./BeraError.js";
@@ -69,3 +70,25 @@ describe("BeraError JSON-RPC code classification", () => {
     expect(err.level).toBe("fatal");
   });
 });
+
+// The transaction store (transactionStore.ts) pins a stable Sentry fingerprint
+// on receipt timeouts by keying off exactly this reason string (HUB-97H/HUB-981
+// grouping). If the pipeline ever stops deriving it, that grouping silently
+// breaks — so lock the contract here.
+describe("BeraError reason — receipt timeout fingerprint contract", () => {
+  it("derives WaitForTransactionReceiptTimeoutError from viem's timeout error", () => {
+    const err = new BeraError({
+      cause: new WaitForTransactionReceiptTimeoutError({ hash: "0xdeadbeef" }),
+    });
+
+    expect(err.reason).toBe("WaitForTransactionReceiptTimeoutError");
+  });
+
+  it("does not derive that reason for an unrelated transaction error", () => {
+    const err = new BeraError({
+      cause: { code: 4001, message: "User rejected the request." },
+    });
+
+    expect(err.reason).not.toBe("WaitForTransactionReceiptTimeoutError");
+  });
+});

package/src/errors/RequestError.ts

@@ -20,6 +20,27 @@ export class RequestError extends BeraError {
   static isCorsError(error: Error) {
     return error.cause instanceof Response && error.cause.type === "cors";
   }
+
+  /**
+   * Matches the standard error messages browsers produce when fetch fails due
+   * to a network or CORS error, as empirically collected from Sentry. The
+   * trailing "(host)" suffix is our own annotation and optional: bare fetch
+   * TypeErrors are just "Failed to fetch" / "Load failed".
+   */
+  private static readonly NETWORK_ERROR_MESSAGE_REGEX =
+    /^(?:NetworkError when attempting to fetch resource\.|Failed to fetch|Load failed)(?: \(([a-z0-9-.]+)\))?$/;
+
+  /**
+   * Whether a message is a browser fetch network-failure message. Used to tell
+   * genuine network TypeErrors apart from ordinary TypeErrors (which must NOT
+   * be grouped as network errors — see sentryBeforeSend).
+   */
+  static isNetworkErrorMessage(message: string): boolean {
+    return (
+      message.startsWith("Network Error") ||
+      RequestError.NETWORK_ERROR_MESSAGE_REGEX.test(message)
+    );
+  }
   /**
    * The endpoint that was requested.
    */
@@ -153,6 +174,19 @@ export class RequestError extends BeraError {
     this.message = `${message}${endpointLabel}: ${this.message}`;
   }
 
+  /**
+   * The hostname of the requested endpoint (e.g. "beep.berachain.com"), used to
+   * group network errors by domain in Sentry. Falls back to the full url for
+   * relative/malformed urls that have no parseable host.
+   */
+  get host(): string {
+    try {
+      return new URL(this.endpoint.url).hostname;
+    } catch {
+      return this.endpoint.url;
+    }
+  }
+
   setEndpoint(
     endpoint:
       | string
@@ -175,6 +209,14 @@ export class RequestError extends BeraError {
       };
     }
 
+    // Redact 40-hex addresses in the path (e.g. /wallets/0x…/autoclaimed) so
+    // per-wallet urls collapse to one Sentry fingerprint. Mirrors the span-url
+    // redaction in beraFetch; the error message/title is built from this url.
+    this.endpoint.url = this.endpoint.url.replace(
+      /0x[a-fA-F0-9]{40}/g,
+      ":address",
+    );
+
     if (
       this.queryRichfulDomains.some((domain) =>
         this.endpoint.url.includes(getUriFromLink(domain)),
@@ -223,16 +265,11 @@ export class RequestError extends BeraError {
         };
       }
 
-      // this matches standard error messages as they're returned by browser fetch when they either:
-      // - 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.
+      // We normalize all fetch network-failure variants to a single
+      // NETWORK_ERROR reason so they 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-.]+)\))?$/,
+        RequestError.NETWORK_ERROR_MESSAGE_REGEX,
       );
       if (failedToFetchMatch) {
         return {

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

@@ -24,6 +24,27 @@ describe("RequestError endpoint normalization (grouping)", () => {
     expect(b.endpoint.url).toBe(base);
     expect(a.endpoint.url).toBe(b.endpoint.url);
   });
+
+  it("redacts wallet addresses in the path so per-wallet urls group together (HUB-A8T)", () => {
+    function mk(addr: string) {
+      return new RequestError({
+        response: undefined,
+        statusCode: 500,
+        endpoint: {
+          url: `https://api-claim.berachain.com/api/v1/wallets/${addr}/autoclaimed/txhash`,
+          type: "rest",
+        },
+      });
+    }
+    const a = mk("0x9675b119c6907a1d17b4ad9ec14f03d3c4435635");
+    const b = mk("0x1111111111111111111111111111111111111111");
+
+    const expected =
+      "https://api-claim.berachain.com/api/v1/wallets/:address/autoclaimed/txhash";
+    expect(a.endpoint.url).toBe(expected);
+    expect(a.message).toBe(b.message);
+    expect(a.host).toBe("api-claim.berachain.com");
+  });
 });
 
 describe("RequestError network-error normalization (grouping)", () => {
@@ -52,6 +73,39 @@ describe("RequestError network-error normalization (grouping)", () => {
 
     expect(err.reason).not.toBe(RequestError.REASON_MAP.NETWORK_ERROR);
   });
+
+  it("groups network errors by host regardless of path/query (HONEY-1AH)", () => {
+    const a = new RequestError({
+      response: undefined,
+      cause: new TypeError("Failed to fetch"),
+      endpoint: {
+        url: "https://beep.berachain.com/v1/honey/balances",
+        type: "rest",
+      },
+    });
+    const b = new RequestError({
+      response: undefined,
+      cause: new TypeError("Failed to fetch"),
+      endpoint: {
+        url: "https://beep.berachain.com/v1/bonders?start=2025-11-28",
+        type: "rest",
+      },
+    });
+
+    expect(a.host).toBe("beep.berachain.com");
+    expect(a.host).toBe(b.host);
+  });
+
+  it("falls back to the raw url for a relative/malformed endpoint", () => {
+    const err = new RequestError({
+      response: undefined,
+      endpoint: { url: "/api/internal/foo", type: "rest" },
+    });
+
+    // No parseable host on a relative url → fall back to the url itself so the
+    // fingerprint stays stable rather than throwing.
+    expect(err.host).toBe("/api/internal/foo");
+  });
 });
 
 describe("RequestError NO_SWAP_PATHS leveling", () => {

package/src/errors/errorMap.ts

@@ -108,10 +108,15 @@ export const errorMsgMap = {
       errorMSG:
         "It seems an RPC error has occurred. Please try your request one more later.",
     },
-    HASH: {
-      keywords: ["hash"],
+    // Tx was broadcast but we timed out waiting for the receipt (RPC lag / dropped
+    // tx). Match on viem's error name (exact reason) — NOT a bare "hash" keyword,
+    // which used to match any message mentioning a tx/block/typehash and dumped
+    // unrelated errors into one meaningless "HASH" group (HUB-A9T).
+    TRANSACTION_TIMEOUT: {
+      reasons: ["WaitForTransactionReceiptTimeoutError"],
+      keywords: ["Timed out while waiting for transaction with hash"],
       errorMSG:
-        "It seems an RPC error has occurred. Please check if your transaction was finalized. If not, please try again.",
+        "Transaction sent, but we couldn't confirm it in time. Check your wallet — if it didn't go through, try again.",
     },
     USER_REJECTION: {
       reasons: ["UserRejectedRequestError"],

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+
+import { findMatchingError } from "./getErrorMessage.js";
+
+describe("findMatchingError — transaction timeout (HUB-A9T)", () => {
+  const timeoutMessage =
+    'Timed out while waiting for transaction with hash "0x18160719ceffa85166d389a3a075ca081e8925b69d6e73884af01082421d124b" to be confirmed.';
+
+  it("matches viem's timeout error name via exact reason", () => {
+    const matched = findMatchingError({
+      reason: "WaitForTransactionReceiptTimeoutError",
+      message: timeoutMessage,
+    });
+    expect(matched?.key).toBe("TRANSACTION_TIMEOUT");
+    expect(matched?.matchedByReason).toBe(true);
+  });
+
+  it("still matches the timeout by message keyword when reason is absent", () => {
+    const matched = findMatchingError({ message: timeoutMessage });
+    expect(matched?.key).toBe("TRANSACTION_TIMEOUT");
+  });
+
+  it("no longer misfiles unrelated hash-mentioning errors into a HASH bucket", () => {
+    // Regression: the old `keywords: ["hash"]` entry swallowed any message
+    // containing "hash" (tx hash, block hash, typehash, …).
+    const matched = findMatchingError({
+      message: "invalid domain separator typehash for permit signature",
+    });
+    expect(matched?.key).not.toBe("HASH");
+    expect(matched?.key).not.toBe("TRANSACTION_TIMEOUT");
+  });
+});