@berachain/berajs 0.1.0 → 0.1.2

package/src/hooks/useContractWrite/types.ts

@@ -0,0 +1,88 @@
+import type {
+  Abi,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  Hex,
+  TransactionReceipt,
+  WalletCallReceipt,
+} from "viem";
+
+import type { BeraError } from "~/errors/BeraError";
+import type { IContractWrite, IContractWriteFn } from "~/types/global";
+
+export interface UseContractWriteApi {
+  isLoading: boolean;
+  isSubmitting: boolean;
+  isSuccess: boolean;
+  isError: boolean;
+  write: IContractWriteFn;
+  reset: () => void;
+}
+
+type PropagatedArgs<args> = Omit<args, TxnEventKeys | "contractName"> & {
+  contractName?: string;
+};
+
+export type TxnEventKeys =
+  | "onSuccess"
+  | "onError"
+  | "onLoading"
+  | "onSubmission"
+  | "onWarning";
+export interface IUseContractWriteArgs<
+  abi extends Abi | undefined = undefined,
+  functionName extends abi extends Abi
+    ? ContractFunctionName<abi>
+    : never = abi extends Abi ? ContractFunctionName<abi> : never,
+  params extends abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never = abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never,
+> {
+  onSuccess?: (
+    receipts:
+      | TransactionReceipt
+      | WalletCallReceipt<bigint, "success" | "reverted">,
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>,
+  ) => void;
+  onError?: (
+    e: BeraError,
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>,
+  ) => void;
+  onLoading?: (
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>,
+  ) => void;
+  onSubmission?: (
+    /**
+     * @param args.id If request is a batch call, this will be the id of the request to the wallet provider
+     * @param args.txHash If request is a single transaction, this will be the hash of the transaction to wait for
+     */
+    args:
+      | { txHash: Hex; id?: never }
+      | {
+          id: string;
+          txHash?: never;
+        },
+    /**
+     * Arguments that were used to call the write function.
+     */
+    writeArgs: PropagatedArgs<IContractWrite<abi, functionName, params>>,
+  ) => void;
+  /**
+   * Callback function executed when a transaction encounters a warning. Transaction will still be submitted.
+   */
+  onWarning?: (
+    e: BeraError,
+    writeArgs: Omit<IContractWrite<abi, functionName, params>, TxnEventKeys>,
+  ) => void;
+}

package/src/hooks/useContractWrite/useBeraContractWrite.ts

@@ -0,0 +1,137 @@
+import { useCallback, useReducer } from "react";
+import type { Abi, ContractFunctionArgs, ContractFunctionName } from "viem";
+
+import { useBeraWagmi, useConfig } from "@berachain/wagmi/hooks";
+
+import { beraWriteContract } from "~/actions/transactions/beraWriteContract";
+import { useBeraFlag } from "~/contexts/BeraFlags/BeraFlags";
+import { TransactionFailedError } from "~/errors/TransactionFailedError";
+import type { IContractWrite } from "~/types/global";
+import { ActionEnum, initialState, reducer } from "./stateReducer";
+import type { IUseContractWriteArgs, UseContractWriteApi } from "./types";
+
+function useBeraContractWrite({
+  onlyPermissionless,
+  onSuccess,
+  onError,
+  onLoading,
+  onWarning,
+  onSubmission,
+}: IUseContractWriteArgs & {
+  /**
+   * Whether to allow only permissionless transactions.
+   *
+   * This is useful when UI is reading data for another account compared to the connected account.
+   */
+  onlyPermissionless?: boolean;
+} = {}): UseContractWriteApi {
+  const [state, dispatch] = useReducer(reducer, initialState);
+
+  const { account, onSmartAccountRejection } = useBeraWagmi();
+  const wagmiConfig = useConfig();
+
+  /**
+   * We are using a longer timeout for wallets with EIP-7702 (safe wallet) because it takes longer to confirm the transaction.
+   * 10 minutes for safe wallets
+   * 2 minutes for EOA wallets
+   *  */
+  const txConfirmationTimeout = account?.wallet?.isContract
+    ? 60_000 * 10
+    : 120_000;
+
+  // Reset the state of the hook to the initial state
+  const reset = useCallback(() => {
+    dispatch({ type: ActionEnum.RESET });
+  }, []);
+
+  const enableSimulateCalls = useBeraFlag("enableSimulateCalls");
+
+  const write = useCallback(
+    <
+      abi extends Abi | undefined = undefined,
+      functionName extends abi extends Abi
+        ? ContractFunctionName<abi>
+        : never = abi extends Abi ? ContractFunctionName<abi> : never,
+      params extends abi extends Abi
+        ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+        : never = abi extends Abi
+        ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+        : never,
+    >(
+      writeArgs: IContractWrite<abi, functionName, params>,
+    ) => {
+      if (onlyPermissionless && !writeArgs.permissionless) {
+        const er = new TransactionFailedError({
+          message:
+            "Trying to send a non-permissionless transaction with an overridden account",
+          displayMessage:
+            "You can't send this transaction with an overridden account. Please reset the account in the settings popover.",
+          level: "info",
+          input: writeArgs,
+        });
+        onWarning?.(er, writeArgs);
+        onError?.(er, writeArgs);
+
+        throw er;
+      }
+      return beraWriteContract({
+        wagmiConfig,
+        ...(writeArgs as IContractWrite),
+        txConfirmationTimeout,
+        enableSimulateCalls,
+        onLoading(...args) {
+          dispatch({ type: ActionEnum.LOADING });
+          // can't use ...args because of typing issues
+          writeArgs.onLoading?.(writeArgs);
+          onLoading?.(...args);
+        },
+        onWarning(...args) {
+          // can't use ...args because of typing issues
+          writeArgs.onWarning?.(args[0], writeArgs);
+          onWarning?.(...args);
+        },
+        onSubmission(...args) {
+          dispatch({ type: ActionEnum.SUBMITTING });
+          // can't use ...args because of typing issues
+          writeArgs.onSubmission?.(args[0], writeArgs);
+          onSubmission?.(...args);
+        },
+        onSuccess(...args) {
+          dispatch({ type: ActionEnum.SUCCESS });
+          // can't use ...args because of typing issues
+          writeArgs.onSuccess?.(args[0], writeArgs);
+          onSuccess?.(...args);
+        },
+        onError(...args) {
+          dispatch({ type: ActionEnum.ERROR });
+          writeArgs.onError?.(args[0], writeArgs);
+          if (args[0].reason === "AtomicReadyWalletRejectedUpgradeError") {
+            onSmartAccountRejection();
+          }
+          onError?.(...args);
+        },
+      });
+    },
+    [
+      wagmiConfig,
+      onLoading,
+      onWarning,
+      onSubmission,
+      onSuccess,
+      onError,
+      onlyPermissionless,
+      enableSimulateCalls,
+    ],
+  );
+
+  return {
+    isLoading: state.confirmState === "loading",
+    isSubmitting: state.confirmState === "submitting",
+    isSuccess: state.confirmState === "success",
+    isError: state.confirmState === "fail",
+    write,
+    reset,
+  };
+}
+
+export default useBeraContractWrite;

package/src/hooks/useGetVerifiedAbi.ts

@@ -0,0 +1,47 @@
+import useSWRImmutable from "swr/immutable";
+import { isAddress, zeroAddress } from "viem";
+
+import { chainId } from "@berachain/config/internal";
+
+import { beraFetchJson } from "~/utils/beraFetch";
+
+interface SuccessResponse {
+  status: "1";
+  message: "OK";
+  result: string;
+}
+
+interface ErrorResponse {
+  status: "0";
+  message: "NOTOK";
+  result: string;
+}
+
+type ApiResponse = SuccessResponse | ErrorResponse;
+
+async function fetchVerifiedAbi(address: string): Promise<string> {
+  const data = await beraFetchJson<ApiResponse>({
+    url: `https://api.routescan.io/v2/network/testnet/evm/${chainId}/etherscan/api?module=contract&action=getabi&address=${address}`,
+    type: "rest",
+    name: "RouteScan",
+  });
+
+  if (data.status === "0") {
+    throw new Error(data.result);
+  }
+
+  return data.result;
+}
+
+export const useGetVerifiedAbi = (address?: string) => {
+  return useSWRImmutable<string>(
+    address &&
+      isAddress(address) &&
+      // Address zero can't be a contract for sure
+      address !== zeroAddress
+      ? (["useGetVerifiedAbi", address] as const)
+      : null,
+    () => (address ? fetchVerifiedAbi(address) : Promise.resolve("")),
+    {},
+  );
+};

package/src/hooks/useHistoryState.ts

@@ -0,0 +1,64 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+type UseHistoryStateOptions<T> = {
+  key: string;
+  defaultValue: T;
+};
+
+/**
+ * useHistoryState is a hook that allows storing state in the browser's history state
+ * it is useful for storing state that you want to persist across pages
+ * It is indexed by the key parameter to be able to store multiple states on the same page and
+ * also to not override nextjs usage of the history state
+ * @param {string} key - the key to store the state under
+ * @param {T} defaultValue - the default value to use if the state is not found
+ * @returns {T} state - the current state
+ * @returns {function} setHistoryState - a function to set the state
+ */
+export function useHistoryState<T>({
+  key,
+  defaultValue,
+}: UseHistoryStateOptions<T>) {
+  // function to get current state from history
+  const getCurrentState = useCallback((): T => {
+    if (typeof window === "undefined") {
+      return defaultValue;
+    }
+    const existing = window.history.state?.[key];
+    const state = existing !== undefined ? existing : defaultValue;
+    return state;
+  }, [key, defaultValue]);
+
+  // use useState to trigger re-renders
+  const [state, setState] = useState<T>(getCurrentState());
+
+  const setHistoryState = useCallback(
+    (value: T | ((prev: T) => T)) => {
+      const currentState = getCurrentState();
+
+      const newValue = value instanceof Function ? value(currentState) : value;
+
+      const historyState = window.history.state || {};
+      const newHistoryState = { ...historyState, [key]: newValue };
+
+      // always use replaceState for updates to avoid creating new history entries
+      window.history.replaceState(newHistoryState, "");
+      setState(newValue);
+    },
+    [key, getCurrentState],
+  );
+
+  useEffect(() => {
+    const existing = window.history.state?.[key];
+    if (existing === undefined) {
+      // if no existing state, create initial history entry
+      const currentState = window.history.state || {};
+      const newState = { ...currentState, [key]: defaultValue };
+      window.history.replaceState(newState, "");
+    }
+  }, [key, defaultValue]);
+
+  return [state, setHistoryState] as const;
+}

package/src/hooks/usePrevious.ts

@@ -0,0 +1,13 @@
+import { useEffect, useRef } from "react";
+
+/**
+ * Returns the previous value of a variable before the render
+ * @param value - the value to return the previous value for
+ */
+export function usePrevious<T>(value: T): T | undefined {
+  const ref = useRef<T | undefined>(undefined);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}

package/src/hooks/validators/useAllValidators.ts

@@ -0,0 +1,48 @@
+import useSWR from "swr";
+
+import type {
+  GetValidatorsQuery,
+  GetValidatorsQueryVariables,
+  GqlChain,
+} from "@berachain/graphql/pol/api";
+
+import { getAllValidators } from "~/actions/validators/getAllValidators";
+import { POLLING } from "~/enum/polling";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export const useAllValidatorsQueryKey = ({
+  variables,
+}: {
+  variables?: GetValidatorsQueryVariables;
+} = {}) => {
+  return ["useAllValidators", variables];
+};
+
+export const useAllValidators = (
+  variables: GetValidatorsQueryVariables & BeraJS.BaseFunctionArgs,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<GetValidatorsQuery | undefined> => {
+  const { config } = parseBaseArgs(variables);
+  const swrResponse = useSWR<GetValidatorsQuery | undefined>(
+    useAllValidatorsQueryKey({ variables }),
+    async ([, variables]) => {
+      const result = await getAllValidators({
+        variables: {
+          chain: config.bex.chainName as GqlChain,
+          ...variables,
+        },
+      });
+      return result;
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/validators/useApiEnrichedAllocation.ts

@@ -0,0 +1,17 @@
+import useSWR from "swr";
+
+import { getApiEnrichedAllocation } from "~/actions/validators/getApiEnrichedAllocation";
+import type { ValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
+
+export function useApiEnrichedAllocation({
+  allocation,
+}: {
+  allocation: ValidatorRewardAllocation | undefined;
+}) {
+  return useSWR(
+    allocation ? ["useApiEnrichedAllocation", allocation] : null,
+    ([, allocation]) => {
+      return getApiEnrichedAllocation({ allocation });
+    },
+  );
+}

package/src/hooks/validators/useApiValidator.ts

@@ -0,0 +1,37 @@
+import useSWR from "swr";
+import { type Address, isHex } from "viem";
+
+import type { GetValidatorQuery } from "@berachain/graphql/pol/api";
+
+import { getApiValidator } from "~/actions/validators/getApiValidator";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export interface UsePollValidatorInfoResponse
+  extends DefaultHookReturnType<GetValidatorQuery> {}
+
+export const useApiValidatorQueryKey = (id: Address) =>
+  id ? (["useApiValidator", id] as const) : null;
+
+export const useApiValidator = (
+  id: Address,
+  options?: DefaultHookOptions,
+): UsePollValidatorInfoResponse => {
+  const QUERY_KEY = useApiValidatorQueryKey(id);
+  const isEnabled = options?.opts?.isEnabled ?? true;
+  const swrResponse = useSWR(
+    isEnabled && id ? QUERY_KEY : null,
+    async ([, id]) => {
+      if (!id || !isHex(id)) throw new Error(`Invalid validator ID: ${id}`);
+
+      return getApiValidator({ id });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/validators/useBaselineRewardAllocation.ts

@@ -0,0 +1,16 @@
+import useSWR from "swr";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getBaselineRewardAllocation } from "~/actions/validators/getBaselineRewardAllocation";
+import { assertPublicClient } from "~/errors/assert";
+
+export function useBaselineRewardAllocation() {
+  const publicClient = usePublicClient();
+  return useSWR(publicClient ? ["baselineRewardAllocation"] : null, () => {
+    assertPublicClient(publicClient);
+    return getBaselineRewardAllocation({
+      publicClient,
+    });
+  });
+}

package/src/hooks/validators/useDailyValidatorBlockStats.ts

@@ -0,0 +1,35 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import type { GetValidatorBlockStatsQuery } from "@berachain/graphql/pol/subgraph";
+
+import { getDailyValidatorBlockStats } from "~/actions/validators/getDailyValidatorBlockStats";
+import { POLLING } from "~/enum/polling";
+import type { DefaultHookReturnType } from "~/types";
+
+export const useDailyValidatorBlockStats = ({
+  pubKey,
+  first = 1,
+}: {
+  pubKey: Address | undefined;
+  first?: number;
+}): DefaultHookReturnType<GetValidatorBlockStatsQuery> => {
+  const QUERY_KEY = pubKey
+    ? (["useDailyValidatorBlockStats", pubKey, first] as const)
+    : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey, first]) => {
+      return await getDailyValidatorBlockStats({
+        pubKey: pubKey,
+        first,
+      });
+    },
+    {
+      refreshInterval: POLLING.SLOW,
+    },
+  );
+
+  return { ...swrResponse, refresh: () => swrResponse.mutate() };
+};

package/src/hooks/validators/useDefaultRewardAllocation.ts

@@ -0,0 +1,32 @@
+import useSWR from "swr";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getDefaultRewardAllocation } from "~/actions/validators/getDefaultRewardAllocation";
+import type { ValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions } from "~/types/global";
+
+export function useDefaultRewardAllocation(options?: DefaultHookOptions) {
+  const publicClient = usePublicClient();
+  const QUERY_KEY = publicClient ? ["useDefaultRewardAllocation"] : null;
+
+  const swrResponse = useSWR<ValidatorRewardAllocation | undefined>(
+    QUERY_KEY,
+    async () => {
+      assertPublicClient(publicClient);
+
+      return await getDefaultRewardAllocation({
+        client: publicClient,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+}

package/src/hooks/validators/useManagedValidatorByAccount.ts

@@ -0,0 +1,40 @@
+import useSWRImmutable from "swr/immutable";
+import type { Address } from "viem";
+
+import { getManagedValidatorByAccount } from "~/actions/validators/getManagedValidatorByAccount";
+import type { DefaultHookOptions } from "~/types";
+
+/**
+ * Return the validators managed by the account
+ * Roles:
+ * - Validator Operator
+ * - Validator Reward Allocator
+ * @param address
+ * @param options
+ * @returns
+ */
+export const useManagedValidatorByAccount = (
+  { account }: { account: Address | undefined },
+  options?: DefaultHookOptions,
+) => {
+  const QUERY_KEY = account
+    ? (["useManagedValidatorByAccount", account] as const)
+    : null;
+
+  const swrResponse = useSWRImmutable(
+    QUERY_KEY,
+    async ([, account]) => {
+      return await getManagedValidatorByAccount({
+        account,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};