@berachain/berajs 0.2.12 → 0.3.0

package/src/hooks/pol/useVaultValidators.ts

@@ -12,10 +12,10 @@ import type {
 export interface UsePollValidatorInfoResponse
   extends DefaultHookReturnType<ApiValidatorFragment[] | undefined> {}
 
-export const useVaultValidators = (
+export function useVaultValidators(
   id: Address,
   options?: DefaultHookOptions,
-): UsePollValidatorInfoResponse => {
+): UsePollValidatorInfoResponse {
   const QUERY_KEY = id ? (["useVaultValidators", id] as const) : null;
   return useSWR(
     QUERY_KEY,
@@ -28,4 +28,4 @@ export const useVaultValidators = (
       ...options,
     },
   );
-};
+}

package/src/hooks/tokens/useBeraCurrentPrice.ts

@@ -1,12 +1,16 @@
-import { zeroAddress } from "viem";
+import { defaultChainId } from "@berachain/config/internal";
 
 import type { DefaultHookOptions } from "../../types/global";
-import { useTokenCurrentPrice } from "./useTokenCurrentPrice";
+import { beraToken } from "../../utils/tokens";
+import { useTokenPrice } from "./useTokenPrice";
 
 /**
- * Shorthand for `useTokenCurrentPrice` with the Bera token address.
+ * Shorthand for `useTokenPrice` with the Bera token address.
  * @returns
  */
 export function useBeraCurrentPrice(opts?: DefaultHookOptions) {
-  return useTokenCurrentPrice({ address: zeroAddress }, opts);
+  return useTokenPrice(
+    { token: { ...beraToken, chainId: defaultChainId } },
+    opts,
+  );
 }

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/tokens/useStakingTokenInformation.ts

@@ -18,10 +18,10 @@ export type UseStakingTokenInformationResponse = DefaultHookReturnType<
 export type useStakingTokenInformationArgs = {
   address: string | undefined;
 };
-export const useStakingTokenInformation = (
+export function useStakingTokenInformation(
   args: useStakingTokenInformationArgs,
   options?: DefaultHookOptions,
-): UseStakingTokenInformationResponse => {
+): UseStakingTokenInformationResponse {
   const publicClient = usePublicClient();
   const QUERY_KEY =
     args?.address && publicClient && isAddress(args.address)
@@ -46,4 +46,4 @@ export const useStakingTokenInformation = (
     },
     { ...options },
   );
-};
+}

package/src/hooks/useBlockToTimestamp.ts

@@ -2,7 +2,7 @@ import { useBlockNumber, usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWRImmutable } from "@berachain/utils/pkg/swr";
 
 import { getBlockTimestamp } from "../actions/misc/getBlockTimestamp";
-import { useBlockTime } from "../contexts/block-time-provider";
+import { useBlockTime } from "../contexts/BlockTimeProvider";
 import { assertPublicClient } from "../errors/assert";
 import { parseBaseArgs } from "../utils/parseBaseArgs";
 import { msToSeconds, seconds } from "../utils/time";

package/src/hooks/useContractWrite/index.ts

@@ -1,2 +1,2 @@
 export * from "./types";
-export { default as useBeraContractWrite } from "./useBeraContractWrite";
+export { useBeraContractWrite } from "./useBeraContractWrite";

package/src/hooks/useContractWrite/stateReducer.ts

@@ -27,7 +27,7 @@ export const initialState: State = {
   message: "",
 };
 
-export const reducer = (state: State, actions: Action): State => {
+export function reducer(state: State, actions: Action): State {
   switch (actions.type) {
     case ActionEnum.LOADING:
       return {
@@ -57,4 +57,4 @@ export const reducer = (state: State, actions: Action): State => {
     default:
       return state;
   }
-};
+}

package/src/hooks/useContractWrite/useBeraContractWrite.ts

@@ -10,7 +10,7 @@ import type { IContractWrite } from "../../types/global";
 import { ActionEnum, initialState, reducer } from "./stateReducer";
 import type { IUseContractWriteArgs, UseContractWriteApi } from "./types";
 
-function useBeraContractWrite({
+export function useBeraContractWrite({
   onlyPermissionless,
   onSuccess,
   onError,
@@ -133,5 +133,3 @@ function useBeraContractWrite({
     reset,
   };
 }
-
-export default useBeraContractWrite;

package/src/hooks/useGetVerifiedAbi.ts

@@ -34,7 +34,7 @@ async function fetchVerifiedAbi(address: string): Promise<string> {
   return data.result;
 }
 
-export const useGetVerifiedAbi = (address?: string) => {
+export function useGetVerifiedAbi(address?: string) {
   return useSWRImmutable<string>(
     address &&
       isAddress(address) &&
@@ -45,4 +45,4 @@ export const useGetVerifiedAbi = (address?: string) => {
     () => (address ? fetchVerifiedAbi(address) : Promise.resolve("")),
     {},
   );
-};
+}

package/src/hooks/validators/useAllValidators.ts

@@ -13,18 +13,18 @@ import type {
 } from "../../types/global";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
-export const useAllValidatorsQueryKey = ({
+export function useAllValidatorsQueryKey({
   variables,
 }: {
   variables?: GetValidatorsQueryVariables;
-} = {}) => {
+} = {}): (string | GetValidatorsQueryVariables | undefined)[] {
   return ["useAllValidators", variables];
-};
+}
 
-export const useAllValidators = (
+export function useAllValidators(
   variables: GetValidatorsQueryVariables & BeraJS.BaseFunctionArgs,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<GetValidatorsQuery | undefined> => {
+): DefaultHookReturnType<GetValidatorsQuery | undefined> {
   const { config } = parseBaseArgs(variables);
   return useSWR<GetValidatorsQuery | undefined>(
     useAllValidatorsQueryKey({ variables }),
@@ -42,4 +42,4 @@ export const useAllValidators = (
       ...options,
     },
   );
-};
+}

package/src/hooks/validators/useApiValidator.ts

@@ -12,13 +12,14 @@ import type {
 export interface UsePollValidatorInfoResponse
   extends DefaultHookReturnType<GetValidatorQuery> {}
 
-export const useApiValidatorQueryKey = (id: Address) =>
-  id ? (["useApiValidator", id] as const) : null;
+export function useApiValidatorQueryKey(id: Address) {
+  return id ? (["useApiValidator", id] as const) : null;
+}
 
-export const useApiValidator = (
+export function useApiValidator(
   id: Address,
   options?: DefaultHookOptions,
-): UsePollValidatorInfoResponse => {
+): UsePollValidatorInfoResponse {
   const QUERY_KEY = useApiValidatorQueryKey(id);
   return useSWR(
     id ? QUERY_KEY : null,
@@ -29,4 +30,4 @@ export const useApiValidator = (
     },
     options,
   );
-};
+}

package/src/hooks/validators/useOnChainValidator.ts

@@ -15,10 +15,10 @@ import type {
 } from "../../types/global";
 import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
-export const useOnChainValidator = (
+export function useOnChainValidator(
   { pubkey }: { pubkey: Address },
   options: DefaultHookOptions,
-): DefaultHookReturnType<Partial<ApiValidatorFragment>> => {
+): DefaultHookReturnType<Partial<ApiValidatorFragment>> {
   const publicClient = usePublicClient();
   const QUERY_KEY = pubkey ? (["useOnChainValidator", pubkey] as const) : null;
   return useSWR(
@@ -60,4 +60,4 @@ export const useOnChainValidator = (
     },
     options,
   );
-};
+}

package/src/hooks/validators/useStakingPoolBatch.ts

@@ -11,13 +11,13 @@ import type {
   DefaultHookReturnType,
 } from "../../types/global";
 
-export const useStakingPoolBatch = ({
+export function useStakingPoolBatch({
   valPubKey,
   options,
 }: {
   valPubKey: Address;
   options?: DefaultHookOptions;
-}): DefaultHookReturnType<number | undefined> => {
+}): DefaultHookReturnType<number | undefined> {
   const publicClient = usePublicClient();
   const QUERY_KEY =
     publicClient && valPubKey
@@ -39,4 +39,4 @@ export const useStakingPoolBatch = ({
       ...options,
     },
   );
-};
+}

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 const useUserActiveValidators = (
+export function useUserActiveValidators(
   options?: DefaultHookOptions,
-): UseUserActiveValidatorsResponse => {
+): 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 const 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/useUserBoostsOnValidator.ts

@@ -10,13 +10,13 @@ import {
 import { POLLING } from "../../enum/polling";
 import type { DefaultHookReturnType } from "../../types/global";
 
-export const useUserBoostsOnValidator = ({
+export function useUserBoostsOnValidator({
   pubkey,
   ...args
 }: {
   pubkey: Address | undefined;
   account?: Address;
-}): DefaultHookReturnType<UserBoostsOnValidator> => {
+}): DefaultHookReturnType<UserBoostsOnValidator> {
   const { address: connectedAccount } = useBeraWallet();
 
   const publicClient = usePublicClient();
@@ -40,4 +40,4 @@ export const useUserBoostsOnValidator = ({
       refreshInterval: POLLING.NORMAL,
     },
   );
-};
+}

package/src/hooks/validators/useUserStakingPositions.ts

@@ -29,13 +29,13 @@ import { getUserStakingPositions } from "../../actions/validators/getUserStaking
  * });
  * ```
  */
-export const useUserStakingPositions = ({
+export function useUserStakingPositions({
   account,
   validatorAddress,
 }: {
   account: Address | undefined;
   validatorAddress?: Address;
-}) => {
+}) {
   const queryClient = account
     ? (["useUserStakingPositions", account, validatorAddress] as const)
     : null;
@@ -53,4 +53,4 @@ export const useUserStakingPositions = ({
       return userStakingPolls;
     },
   );
-};
+}

package/src/hooks/validators/useValidatorCommission.ts

@@ -9,10 +9,10 @@ import type {
   DefaultHookReturnType,
 } from "../../types/global";
 
-export const useValidatorCommission = (
+export function useValidatorCommission(
   pubKey: Address,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<number | undefined | null> => {
+): DefaultHookReturnType<number | undefined | null> {
   const publicClient = usePublicClient();
   const QUERY_KEY =
     publicClient && pubKey
@@ -31,4 +31,4 @@ export const useValidatorCommission = (
       ...options,
     },
   );
-};
+}

package/src/hooks/validators/useValidatorEstimatedBgtPerYear.ts

@@ -1,12 +1,12 @@
 import type { ApiValidatorMinimalFragment } from "@berachain/graphql/pol/api";
 
 import { getValidatorEstimatedBgtPerYear } from "../../actions/validators/getValidatorEstimatedBgtPerYear";
-import { useBlockTime } from "../../contexts/block-time-provider";
+import { useBlockTime } from "../../contexts/BlockTimeProvider";
 import { usePollGlobalData } from "../pol/usePollGlobalData";
 
-export const useValidatorEstimatedBgtPerYear = (
+export function useValidatorEstimatedBgtPerYear(
   validator: ApiValidatorMinimalFragment,
-): { data: number | undefined; isLoading: boolean } => {
+): { data: number | undefined; isLoading: boolean } {
   const { data: globalData, isLoading } = usePollGlobalData();
 
   const blockTime = useBlockTime();
@@ -21,4 +21,4 @@ export const useValidatorEstimatedBgtPerYear = (
       : undefined,
     isLoading,
   };
-};
+}

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/hooks/validators/useValidatorQueuedOperatorAddress.ts

@@ -12,10 +12,10 @@ import type {
   DefaultHookReturnType,
 } from "../../types/global";
 
-export const useValidatorQueuedOperatorAddress = (
+export function useValidatorQueuedOperatorAddress(
   pubKey: Address,
   options?: DefaultHookOptions,
-): DefaultHookReturnType<ValidatorQueuedOperatorAddress | undefined> => {
+): DefaultHookReturnType<ValidatorQueuedOperatorAddress | undefined> {
   const publicClient = usePublicClient();
   const QUERY_KEY =
     publicClient && pubKey
@@ -34,4 +34,4 @@ export const useValidatorQueuedOperatorAddress = (
       ...options,
     },
   );
-};
+}