@berachain/berajs 0.2.13 → 0.3.0

package/src/hooks/tokens/useMultipleTokenInformation.ts

@@ -1,12 +1,13 @@
-import { isAddress } from "viem";
+import type { PublicClient } from "viem";
 
+import type { ChainId } from "@berachain/config";
 import { defaultChainId } from "@berachain/config/internal";
 
 import { usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWRImmutable } from "@berachain/utils/pkg/swr";
 
 import { getTokenInformation } from "../../actions/tokens/getTokenInformation";
-import { assertPublicClient } from "../../errors/assert";
+import { assertAddress, assertPublicClient } from "../../errors/assert";
 import type { Token } from "../../types/dex";
 import type {
   DefaultHookOptions,
@@ -17,10 +18,66 @@ export type UseMultipleTokenInformationResponse = DefaultHookReturnType<
   Token[]
 >;
 
+/**
+ * Resolve ERC20 metadata for a batch of addresses, best-effort. An address whose
+ * metadata can't be read — a non-ERC20 / codeless contract (e.g. a single-asset
+ * staking vault whose `decimals()` reverts), an invalid address, or a missing
+ * token — is simply omitted from the result rather than failing the whole batch.
+ * Consumers key results by address and treat a missing entry as absent.
+ */
+export async function fetchMultipleTokenInformation({
+  addresses,
+  publicClient,
+  chainId,
+}: {
+  addresses: readonly string[];
+  publicClient: PublicClient;
+  chainId: ChainId;
+}): Promise<Token[]> {
+  const settled = await Promise.allSettled(
+    addresses.map(async (address) => {
+      assertAddress(address, "address");
+
+      const tk = await getTokenInformation({
+        address,
+        publicClient,
+        chainId,
+      });
+
+      if (!tk) {
+        throw new Error(`Token ${address} not found`);
+      }
+
+      return tk;
+    }),
+  );
+
+  return settled
+    .filter((r): r is PromiseFulfilledResult<Token> => r.status === "fulfilled")
+    .map((r) => r.value);
+}
+
 export type useMultipleTokenInformationArgs = {
+  /** Addresses to resolve metadata for. `undefined` disables the query. */
   addresses: string[] | readonly string[] | undefined;
+  /** Chain to read from. Defaults to the app's `defaultChainId`. */
   chainId?: number;
 };
+
+/**
+ * Batch-resolves ERC20 metadata for `addresses`, best-effort.
+ *
+ * Metadata resolution is best-effort:
+ * any address that can't be resolved — a non-ERC20 / codeless contract (e.g. a
+ * single-asset staking vault whose `decimals()` reverts), an invalid address, or
+ * a missing token — is OMITTED rather than failing the whole batch. So the result
+ * length and order do not necessarily match the input `addresses`.
+ *
+ * ⚠️ The returned array is NOT positional.
+ * Do NOT index the result positionally (`data[i]` for `addresses[i]`). Always
+ * look tokens up by address, e.g. `data?.find(t => t.address === addr)` or build
+ * an address-keyed map.
+ */
 export function useMultipleTokenInformation(
   args: useMultipleTokenInformationArgs,
   options?: DefaultHookOptions,
@@ -44,25 +101,11 @@ export function useMultipleTokenInformation(
       // but we need this for correct type inference
       assertPublicClient(publicClient);
 
-      return Promise.all(
-        addresses.map(async (address) => {
-          if (!address || !isAddress(address, { strict: false })) {
-            throw new Error("Invalid address");
-          }
-
-          const tk = await getTokenInformation({
-            address: address,
-            publicClient,
-            chainId,
-          });
-
-          if (!tk) {
-            throw new Error(`Token ${address} not found`);
-          }
-
-          return tk;
-        }),
-      );
+      return fetchMultipleTokenInformation({
+        addresses,
+        publicClient,
+        chainId,
+      });
     },
     { ...options },
   );

package/src/hooks/tokens/useMultipleTokenInformation.unit.test.ts

@@ -0,0 +1,91 @@
+import type { Address, PublicClient } from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { getTokenInformation } from "../../actions/tokens/getTokenInformation";
+import type { Token } from "../../types/dex";
+import { fetchMultipleTokenInformation } from "./useMultipleTokenInformation";
+
+vi.mock("../../actions/tokens/getTokenInformation", () => ({
+  getTokenInformation: vi.fn(),
+}));
+
+const mockGetTokenInformation = vi.mocked(getTokenInformation);
+
+// publicClient is only forwarded to (the mocked) getTokenInformation, so a stub
+// is enough here.
+const publicClient = {} as unknown as PublicClient;
+const chainId = ChainId.MAINNET;
+
+const ADDR_A = "0xac03caba51e17c86c921e1f6cbfbdc91f8bb2e6b" as Address;
+const ADDR_B = "0xbaadcc2962417c01af99fb2b7c75706b9bd6babe" as Address;
+const STAKING_CONTRACT =
+  "0x75f3be06b02e235f6d0e7ef2d462b29739168301" as Address;
+
+function makeToken(address: Address, symbol: string): Token {
+  return {
+    address,
+    decimals: 18,
+    symbol,
+    name: symbol,
+    chainId,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("fetchMultipleTokenInformation", () => {
+  it("omits an address whose metadata read reverts instead of rejecting the batch", async () => {
+    // Simulates a non-ERC20 single-asset staking contract: `decimals()` reverts,
+    // so getTokenInformation rethrows.
+    mockGetTokenInformation.mockImplementation(async ({ address }) => {
+      if (address === STAKING_CONTRACT) {
+        throw new Error('The contract function "decimals" reverted.');
+      }
+      return makeToken(address, address === ADDR_A ? "iBGT" : "LBGT");
+    });
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: [ADDR_A, STAKING_CONTRACT, ADDR_B],
+      publicClient,
+      chainId,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result.map((t) => t.address)).toEqual([ADDR_A, ADDR_B]);
+    expect(result.some((t) => t.address === STAKING_CONTRACT)).toBe(false);
+  });
+
+  it("drops invalid addresses without reading them", async () => {
+    mockGetTokenInformation.mockImplementation(async ({ address }) =>
+      makeToken(address, "iBGT"),
+    );
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: ["not-an-address", ADDR_A],
+      publicClient,
+      chainId,
+    });
+
+    expect(result.map((t) => t.address)).toEqual([ADDR_A]);
+    // The invalid address never reaches getTokenInformation.
+    expect(mockGetTokenInformation).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns all tokens for an all-valid batch, preserving order", async () => {
+    mockGetTokenInformation.mockImplementation(async ({ address }) =>
+      makeToken(address, address === ADDR_A ? "iBGT" : "LBGT"),
+    );
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: [ADDR_A, ADDR_B],
+      publicClient,
+      chainId,
+    });
+
+    expect(result.map((t) => t.address)).toEqual([ADDR_A, ADDR_B]);
+  });
+});

package/src/hooks/tokens/usePollBalance.ts

@@ -110,8 +110,10 @@ export function usePollBalance(
 
   return {
     ...rest,
-    isLoading: isLoading || isNativeToken ? isLoadingTokenInformation : false,
-    error: error || !isNativeToken ? error : undefined,
+    isLoading: isNativeToken
+      ? isLoading
+      : isLoading || isLoadingTokenInformation,
+    error,
     data: tokenBalance,
   };
 }

package/src/hooks/validators/useUserActiveValidators.ts

@@ -1,8 +1,12 @@
+import { useMemo } from "react";
+
 import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import {
-  getUserActiveValidators,
+  getUserActiveValidatorsApi,
+  getUserActiveValidatorsOnChain,
+  mergeUserActiveValidators,
   type ValidatorWithUserBoost,
 } from "../../actions/validators/getUserActiveValidators";
 import { POLLING } from "../../enum/polling";
@@ -12,23 +16,42 @@ import type {
 } from "../../types/global";
 
 interface UseUserActiveValidatorsResponse
-  extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {}
+  extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {
+  /**
+   * Re-reads the on-chain boost amounts without re-fetching the API validator
+   * list. Use after a boost/drop tx to reflect new amounts immediately.
+   */
+  refreshOnChain: () => void;
+}
 
 export function useUserActiveValidators(
   options?: DefaultHookOptions,
 ): UseUserActiveValidatorsResponse {
   const { address: account } = useBeraWallet();
   const publicClient = usePublicClient();
-  const QUERY_KEY =
-    publicClient && account
-      ? (["useUserActiveValidators", account] as const)
-      : null;
 
-  return useSWR(
-    QUERY_KEY,
+  const apiSwr = useSWR(
+    account ? (["useUserActiveValidatorsApi", account] as const) : null,
     async ([, account]) => {
-      return await getUserActiveValidators({
+      return await getUserActiveValidatorsApi({ account });
+    },
+    {
+      ...options,
+      refreshInterval: options?.refreshInterval ?? POLLING.SLOW,
+      keepPreviousData: true,
+    },
+  );
+
+  const validators = apiSwr.data;
+
+  const onChainSwr = useSWR(
+    publicClient && account && validators
+      ? (["useUserActiveValidatorsOnChain", account, validators] as const)
+      : null,
+    async ([, account, validators]) => {
+      return await getUserActiveValidatorsOnChain({
         account,
+        validators,
         publicClient,
       });
     },
@@ -38,4 +61,26 @@ export function useUserActiveValidators(
       keepPreviousData: true,
     },
   );
+
+  const onChainBoosts = onChainSwr.data;
+
+  const data = useMemo(() => {
+    if (!validators || !onChainBoosts) return undefined;
+    return mergeUserActiveValidators({ validators, onChainBoosts });
+  }, [validators, onChainBoosts]);
+
+  return {
+    ...apiSwr,
+    data,
+    isLoading: apiSwr.isLoading || onChainSwr.isLoading,
+    isValidating: apiSwr.isValidating || onChainSwr.isValidating,
+    error: apiSwr.error ?? onChainSwr.error,
+    refresh: () => {
+      apiSwr.refresh();
+      onChainSwr.refresh();
+    },
+    refreshOnChain: () => {
+      onChainSwr.refresh();
+    },
+  };
 }

package/src/hooks/validators/useValidatorIncentiveDistribution.ts

@@ -8,10 +8,9 @@ import { POLLING } from "../../enum/polling";
 import type { DefaultHookReturnType } from "../../types/global";
 
 /**
- * Historical per-validator incentive distribution. Split from
- * `useValidatorAnalytics` so the IncentivesEarned chart can switch data
- * sources independently of the other charts that still consume the umbrella
- * `GetValidatorAnalytics` query.
+ * Historical per-validator incentive distribution, powering the
+ * IncentivesEarned chart. Owns its own data source so it can be swapped
+ * independently.
  */
 export function useValidatorIncentiveDistribution({
   pubkey,

package/src/types/bribeBoost.d.ts

@@ -1,37 +1,5 @@
 import type { Address } from "viem";
 
-export interface BribeBoostReward {
-  token: string;
-  total_unclaimed: string;
-}
-
-export interface BribeBoostRewardItem {
-  rewards: BribeBoostReward[];
-  validator: string;
-}
-
-export interface BribeBoostRewardProof {
-  validator?: string;
-  pagination: {
-    next: number;
-    previous: number;
-    record_per_page: number;
-    current_page: number;
-    total_page: number;
-  };
-  rewards:
-    | {
-        id: string;
-        dist_id: string;
-        token: Address;
-        recipient: string;
-        amount: string;
-        merkle_proof: string[];
-        available_at: number;
-      }[]
-    | null;
-}
-
 // Response shape of GET /api/v1/wallets/:wallet/autoclaimed:
 //   { [wallet]: { [validatorPubkey]: { [tokenAddress]: { amount } } } }
 // `amount` is a stringified bigint in token base units. The backend now
@@ -50,20 +18,3 @@ export type AutoclaimedIncentivesTxHashResponse = Record<
   Address,
   Record<Address, Record<Address, { txhash: string }>>
 >;
-
-export interface BribeBoostValidatorApr {
-  id: string;
-  boost_total_bgt: string;
-  rewards_total_usd: string;
-  daily_rate: string;
-  apr: string;
-  apy: string;
-  tokens: Address[]; // Confirm this type with backend real data
-  validator: string;
-  start_block: number;
-  end_block: number;
-  start_timestamp: number;
-  end_timestamp: number;
-  created_at: string;
-  updated_at: string;
-}

package/src/types/dex.d.ts

@@ -195,6 +195,13 @@ export type Calldata = {
   data?: Hex;
   value: bigint;
   gasLimit?: bigint;
+  /**
+   * Extra Sentry tags to attach when this calldata is submitted via `useTxn`.
+   * Aggregators set `{ aggregator: this.name }` so failures like
+   * AggregatorNotWhitelisted can be attributed to a source without decoding
+   * calldata.
+   */
+  extraTags?: Record<string, string>;
 };
 
 export type IRawAggregatorQuote = {
@@ -208,6 +215,16 @@ export type IRawAggregatorQuote = {
   isNativeSwap?: boolean;
   priceImpactPercentage?: number | null;
   swapFeeBps: number;
+  /** True when the route bridges chains; set by the aggregator (source of truth). */
+  isCrossChain?: boolean;
+  /** Chain the input token (and therefore the tx) lives on. */
+  srcChainId?: number;
+  /**
+   * Bridge the cross-chain route uses, from Enso's chosen bridge hop
+   * (`relay` | `stargate` | `ccip`). Drives which explorer/status API the
+   * tracker uses; undefined for same-chain routes.
+   */
+  bridgeProtocol?: string;
   getCalldata?: ({ account }: { account: Address }) => Calldata;
 };
 

package/src/types/enso.d.ts

@@ -1,26 +1,9 @@
-import type { BundleData, EnsoClient } from "@ensofinance/sdk";
+import type { BundleData } from "@ensofinance/sdk";
 import type { Address, Hex, PublicClient, TransactionRequest } from "viem";
 
 import type { MinimalERC20 } from "./dex";
 
 export type Quantity = string | number;
-export type ActionOutputReference<T> = T | StrictOutputReference<T>;
-type StrictOutputReference<T> = {
-  useOutputOfCallAt: number;
-  index?: number;
-};
-
-export interface GetEnsoSwapBundleArgs {
-  fromAddress: Address;
-  amountIn: Quantity;
-  tokenIn: Address;
-  tokenOut: Address;
-  chainId: number;
-  ensoClient: EnsoClient;
-  slippage: number;
-  destinationChainId?: number;
-  publicClient: PublicClient;
-}
 
 export type GetZapTransaction = TransactionRequest & {
   to: Address;
@@ -29,15 +12,6 @@ export type GetZapTransaction = TransactionRequest & {
   gasLimit?: bigint;
 };
 export type GetZapTransactions = GetZapTransaction[];
-export interface GetZapTransactionsArgs {
-  fromAddress: Address;
-  amountIn: Quantity;
-  tokenIn: Address;
-  chainId: number;
-  ensoClient: EnsoClient;
-  bundle: BundleData;
-  publicClient: PublicClient;
-}
 
 export interface GetEnsoWalletTransactionsWithApprovalArgs {
   fromAddress: Address;

package/src/types/global.d.ts

@@ -94,6 +94,13 @@ export type IContractWrite<
    */
   actionType: TransactionActionType;
   txnName?: string;
+  /**
+   * Extra Sentry tags to attach to this transaction's scope, merged under the
+   * `operation.txn.*` namespace (e.g. `{ aggregator: "oogabooga" }` becomes the
+   * `operation.txn.aggregator` tag). Use for context that helps triage failures
+   * without decoding calldata.
+   */
+  extraTags?: Record<string, string>;
   gasLimit?: bigint;
   account?: Account | Address;
   /**

package/src/types/pol.d.ts

@@ -1,49 +1,4 @@
-import type { Address } from "viem";
-
-import type { ApiValidatorFragment } from "@berachain/graphql/pol/api";
-
-import type { Token, TokenWithMetadata } from "./dex";
-
-export type IncentiveReward = {
-  tokenMetadata: Token | undefined;
-  tokenPrice: number;
-  tokenValue: number;
-  id: string;
-  dist_id: string;
-  token: string;
-  recipient: string;
-  formattedAmount: string;
-  amount: string;
-  merkle_proof: string[];
-  available_at: number;
-};
-export interface IncentiveRewardChunksWithValidatorData {
-  validator: ApiValidatorInListFragment | ApiValidatorFragment | undefined;
-  maxTimestamp: number | undefined;
-  minTimestamp: number | undefined;
-  totalValue: number;
-  tokenTotals: {
-    chainId: number;
-    address: Address;
-    amount: number;
-    value: number;
-    metadata: Token | undefined;
-  }[];
-  rewards: IncentiveReward[];
-  isCurrent: boolean;
-}
-
-export interface AggregatedTokenTotals {
-  address: Address;
-  amount: number;
-  value: number;
-  metadata: Token | undefined;
-  chainId: number;
-}
-
-export type ClaimedIncentives = Record<string, string>;
-
-export type ClaimedIncentivesLocalState = Record<string, ClaimedIncentives>;
+import type { TokenWithMetadata } from "./dex";
 
 export interface UserVaultInfo {
   balance: bigint;
@@ -56,11 +11,11 @@ export interface UserVaultInfo {
 export type StakedBeraAsset = {
   token: TokenWithMetadata;
   /**
-   * Staking APR, or `undefined` when unavailable (e.g. the APR backend is
+   * Staking APY, or `undefined` when unavailable (e.g. the APY backend is
    * down). `undefined` lets the UI render a "—" placeholder instead of a
    * misleading "0%".
    */
-  apr: number | undefined;
+  apy: number | undefined;
   stakedAmount: number;
   /**
    * USD value of the staked amount, or `undefined` when the token price is