@berachain/berajs 0.2.13 → 0.3.1

package/src/actions/pol/getUserClaimableIncentives.ts

@@ -1,40 +0,0 @@
-import type { Address } from "viem";
-
-import { BeraError } from "../../errors/BeraError";
-import type { BribeBoostRewardItem } from "../../types/bribeBoost";
-import { getErrorResponse } from "../../utils/getErrorResponse";
-import { parseBaseArgs } from "../../utils/parseBaseArgs";
-
-/**
- * Server-side function to get user claimable incentives grouped by validator
- */
-export async function getUserClaimableIncentives({
-  account,
-  ...args
-}: {
-  account: Address;
-} & BeraJS.BaseFunctionArgs): Promise<BribeBoostRewardItem[] | null> {
-  const { config } = parseBaseArgs(args);
-
-  // We'll try to revalidate on the client side by using the cache: "no-store" and swrImmutable
-  // In the future, we can look at using cache and tags to invalidate the cache on the server side to prevent stale data
-  const result = await fetch(
-    `${
-      config.pol.bribeBoostApi
-    }/api/v1/wallets/${account.toLowerCase()}/rewards/aggregation`,
-    {
-      cache: "no-store",
-    },
-  );
-
-  if (!result.ok) {
-    const error = await getErrorResponse(result);
-    throw new BeraError({
-      message: "Failed to fetch incentives on server",
-      cause: { error, result, account },
-      reason: error?.error,
-    });
-  }
-
-  return result.json();
-}

package/src/actions/validators/getValidatorAnalytics.ts

@@ -1,37 +0,0 @@
-import type { Address } from "viem";
-
-import type { GetValidatorAnalyticsQuery } from "@berachain/graphql/pol/subgraph";
-
-import { BeraError } from "../../errors/BeraError";
-import { beraFetchJson } from "../../utils/beraFetch";
-
-/**
- * Browser-only. Hits `/api/pol/validator-analytics`.
- *
- * @deprecated will be removed in pol vNext
- */
-export async function getValidatorAnalytics({
-  pubkey,
-  dayRange,
-}: {
-  pubkey: Address;
-  dayRange: number;
-}): Promise<GetValidatorAnalyticsQuery | undefined> {
-  if (typeof window === "undefined") {
-    throw new BeraError({
-      message:
-        "getValidatorAnalytics is browser-only; call from a Client Component / SWR hook",
-      level: "error",
-    });
-  }
-
-  const params = new URLSearchParams({
-    pubkey,
-    dayRange: String(dayRange),
-  });
-  return beraFetchJson<GetValidatorAnalyticsQuery>({
-    url: `/api/pol/validator-analytics?${params}`,
-    name: "pol-validator-analytics",
-    type: "rest",
-  });
-}

package/src/hooks/enso/useEnsoSwapBundle.ts

@@ -1,121 +0,0 @@
-"use client";
-
-import { getPublicClient } from "@wagmi/core";
-import { parseUnits } from "viem";
-
-import { defaultChainId as berachainChainId } from "@berachain/config/internal";
-
-import { useBeraWallet, useConfig } from "@berachain/wagmi/hooks";
-import { useSWR } from "@berachain/utils/pkg/swr";
-
-import { getEnsoClient } from "../../actions/clients/getEnsoClient";
-import { getEnsoSwapBundle } from "../../actions/enso/getEnsoSwapBundle";
-import { useBeraFlag } from "../../contexts/BeraFlags/BeraFlags";
-import { POLLING } from "../../enum/polling";
-import {
-  assertAddress,
-  assertAmount,
-  assertDefined,
-  assertPublicClient,
-} from "../../errors/assert";
-import type { BalanceToken, MinimalERC20 } from "../../types/dex";
-import type { GetZapTransactionResponse } from "../../types/enso";
-import { usePollWalletBalances } from "../tokens/usePollWalletBalances";
-
-/**
- * Get the swap bundle for swapping tokens using Enso.
- * @param {Pick<BalanceToken, "address" | "decimals">} tokenIn - The input token to swap from
- * @param {Pick<BalanceToken, "address" | "decimals">} tokenOut - The output token to swap to
- * @param {string} amount - The amount of input token to swap
- * @param {number} slippage - The slippage tolerance to use for the route in percentage
- * @returns {DefaultHookReturnType<GetZapTransactionResponse> & {tokens: BalanceToken[], refresh: () => void}}
- *
- * The zap transaction response data with polling enabled, see {@link GetZapTransactionResponse} and {@link BalanceToken}
- * @remarks The hook is only enabled when all parameters are provided and amount is greater than 0
- */
-export function useEnsoSwapBundle({
-  tokenIn,
-  tokenOut,
-  amount,
-  slippage,
-}: {
-  tokenIn?: Pick<MinimalERC20, "address" | "decimals" | "chainId">;
-  tokenOut?: Pick<MinimalERC20, "address" | "decimals">;
-  amount?: string;
-  slippage?: number;
-}) {
-  const { address: fromAddress } = useBeraWallet();
-  const wagmiConfig = useConfig();
-  const proxyAggregatorsThroughVercel = useBeraFlag(
-    "proxyAggregatorsThroughVercel",
-  );
-  const ensoClient = getEnsoClient({
-    baseURL: proxyAggregatorsThroughVercel ? "/api/enso" : undefined,
-  });
-
-  const { refresh: refreshBalances } = usePollWalletBalances();
-
-  const isEnabled =
-    !!tokenIn &&
-    !!tokenOut &&
-    !!amount &&
-    Number(amount) > 0 &&
-    !!slippage &&
-    !!fromAddress &&
-    !!tokenIn.chainId;
-
-  const QUERY_KEY = isEnabled
-    ? ([
-        "useEnsoSwapBundle",
-        fromAddress,
-        tokenIn,
-        tokenOut,
-        amount,
-        slippage,
-        proxyAggregatorsThroughVercel ?? false,
-      ] as const)
-    : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([, fromAddress, tokenIn, tokenOut, amount, slippage]) => {
-      assertAddress(fromAddress, "fromAddress");
-      assertAddress(tokenIn?.address, "tokenInAddress");
-      assertDefined(tokenIn?.chainId, "tokenInChainId");
-      assertAddress(tokenOut?.address, "tokenOutAddress");
-      assertAmount(amount, "amount");
-      assertAmount(slippage, "slippage");
-
-      const publicClient = getPublicClient(wagmiConfig, {
-        chainId: tokenIn.chainId,
-      });
-      assertPublicClient(publicClient);
-
-      const rawAmount = parseUnits(amount, tokenIn.decimals).toString();
-
-      return getEnsoSwapBundle({
-        fromAddress,
-        amountIn: rawAmount,
-        tokenIn: tokenIn.address,
-        tokenOut: tokenOut.address,
-        chainId: tokenIn.chainId,
-        ensoClient,
-        destinationChainId: berachainChainId,
-        slippage,
-        publicClient,
-      });
-    },
-    {
-      refreshInterval: POLLING.NORMAL,
-      isEnabled: isEnabled,
-    },
-  );
-
-  return {
-    ...swrResponse,
-    refresh: () => {
-      swrResponse.refresh();
-      refreshBalances();
-    },
-  };
-}

package/src/hooks/pol/useBgtIncentiveDistributorPaused.ts

@@ -1,34 +0,0 @@
-import { usePublicClient } from "@berachain/wagmi/hooks";
-import useSWR from "@berachain/utils/pkg/swr";
-
-import { getBgtIncentiveDistributorPaused } from "../../actions/pol/getBgtIncentiveDistributorPaused";
-import type {
-  DefaultHookOptions,
-  DefaultHookReturnType,
-} from "../../types/global";
-
-/**
- * Client hook around `getBgtIncentiveDistributorPaused`. When `paused()` is
- * true, users can no longer self-claim incentives and the bot distributes them
- * on their behalf. Fails closed (`false`) so a read error never blocks the UI.
- */
-export function useBgtIncentiveDistributorPaused(
-  options?: DefaultHookOptions,
-): DefaultHookReturnType<boolean> {
-  const publicClient = usePublicClient();
-
-  const QUERY_KEY = publicClient
-    ? (["useBgtIncentiveDistributorPaused", publicClient.chain?.id] as const)
-    : null;
-
-  return useSWR(
-    QUERY_KEY,
-    async () =>
-      getBgtIncentiveDistributorPaused({ publicClient }).catch(() => false),
-    {
-      revalidateOnFocus: false,
-      revalidateOnReconnect: false,
-      ...options,
-    },
-  );
-}

package/src/hooks/validators/useUserClaimableIncentives.ts

@@ -1,148 +0,0 @@
-import { useCallback, useMemo } from "react";
-
-import { useBeraWallet } from "@berachain/wagmi/hooks";
-import { useSWR } from "@berachain/utils/pkg/swr";
-
-import { getRewardProofsByValidator } from "../../actions/pol/getRewardProofsByValidator";
-import { getUserClaimableIncentives } from "../../actions/pol/getUserClaimableIncentives";
-import { POLLING } from "../../enum/polling";
-import { BeraError } from "../../errors/BeraError";
-import { BeraMonitoring } from "../../errors/BeraMonitoring";
-import { InvalidArgumentError } from "../../errors/InvalidArgumentError";
-import type { BribeBoostRewardProof } from "../../types/bribeBoost";
-import type { DefaultHookReturnType } from "../../types/global";
-import { formatIncentivesTokenMap } from "../../utils/formatIncentivesTokenMap";
-
-interface UseUserClaimableIncentivesReturnType
-  extends DefaultHookReturnType<BribeBoostRewardProof[]> {
-  tokenMap?: Set<string> | undefined;
-}
-
-export function useUserClaimableIncentives(): UseUserClaimableIncentivesReturnType {
-  const { address: account } = useBeraWallet();
-
-  const REWARDS_QUERY_KEY = account
-    ? (["useUserClaimableIncentives", account] as const)
-    : null;
-
-  const allRewardsResponse = useSWR(
-    REWARDS_QUERY_KEY,
-    async ([, account]) => {
-      if (!account) {
-        throw new BeraError({
-          message: "useUserClaimableIncentives needs a logged in account",
-          level: "error",
-        });
-      }
-
-      // Get all reward tokens and all claimable validator associated with the account
-      return await getUserClaimableIncentives({
-        account,
-      });
-    },
-    {
-      revalidateOnFocus: false,
-      revalidateOnReconnect: false,
-      revalidateIfStale: false,
-      refreshInterval: POLLING.SLOW,
-    },
-  );
-
-  const allRewards = allRewardsResponse?.data;
-  const tokenMap = useMemo(() => {
-    // Return empty set if no incentives data or still loading
-    if (!allRewards) {
-      return undefined;
-    }
-
-    // If the data is not an array, capture an error
-    if (!Array.isArray(allRewards)) {
-      BeraMonitoring.captureException(
-        new BeraError({
-          message: "Incorrect aggregated incentives data receieved.",
-          level: "error",
-          extra: {
-            allRewards,
-            account: account,
-          },
-        }),
-      );
-      return undefined;
-    }
-
-    return formatIncentivesTokenMap(allRewards);
-  }, [allRewards, account]);
-
-  const QUERY_KEY =
-    account && allRewards
-      ? (["useUserClaimableIncentives", account, allRewards] as const)
-      : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([, account, allRewards]) => {
-      if (!account) {
-        throw new InvalidArgumentError({
-          property: "account",
-          value: account,
-          expected: "Address",
-        });
-      }
-
-      // Return empty set if no incentives data or still loading
-      if (!allRewards) {
-        return [];
-      }
-
-      if (!Array.isArray(allRewards)) {
-        // If the data is unexpected, throw an error
-        throw new InvalidArgumentError({
-          message:
-            "Incorrect aggregated incentives data receieved to calculate proofs.",
-          property: "allRewards",
-          value: allRewards,
-          expected: "Array",
-          level: "error",
-        });
-      }
-
-      const validatorsSet = new Set(allRewards.map((item) => item.validator));
-      const validatorAddresses = Array.from(validatorsSet);
-
-      // Get total count of rewards for each validator in increments of MAX_PROOFS_SIZE_PER_INCENTIVE_CLAIM
-      return await Promise.all(
-        validatorAddresses.map(async (validator) => {
-          const proofsData = await getRewardProofsByValidator({
-            account: account,
-            validator: validator as `0x${string}`,
-            page: 1,
-            perPage: 10_000,
-          });
-
-          return {
-            ...proofsData,
-            validator: validator,
-          };
-        }),
-      );
-    },
-    {
-      revalidateOnFocus: false,
-      revalidateOnReconnect: false,
-      revalidateIfStale: false,
-      refreshInterval: POLLING.SLOW,
-    },
-  );
-
-  const refresh = useCallback(() => {
-    allRewardsResponse?.refresh();
-    swrResponse?.refresh();
-  }, [allRewardsResponse, swrResponse]);
-
-  return {
-    ...swrResponse,
-    isLoading: allRewardsResponse?.isLoading || swrResponse?.isLoading,
-    tokenMap,
-    refresh,
-  };
-}

package/src/hooks/validators/useValidatorAnalytics.ts

@@ -1,37 +0,0 @@
-import type { Address } from "viem";
-
-import type { GetValidatorAnalyticsQuery } from "@berachain/graphql/pol/subgraph";
-import { useSWR } from "@berachain/utils/pkg/swr";
-
-import { getValidatorAnalytics } from "../../actions/validators/getValidatorAnalytics";
-import { POLLING } from "../../enum/polling";
-import type { DefaultHookReturnType } from "../../types/global";
-
-/**
- * @deprecated will be removed in pol vNext
- */
-export function useValidatorAnalytics({
-  pubkey,
-  dayRange,
-}: {
-  pubkey: Address | undefined;
-  dayRange: number;
-}): DefaultHookReturnType<GetValidatorAnalyticsQuery> {
-  const QUERY_KEY =
-    pubkey && dayRange
-      ? (["useValidatorAnalytics", pubkey, dayRange] as const)
-      : null;
-
-  return useSWR(
-    QUERY_KEY,
-    async ([, pubkey, dayRange]) => {
-      return await getValidatorAnalytics({
-        pubkey: pubkey,
-        dayRange,
-      });
-    },
-    {
-      refreshInterval: POLLING.SLOW,
-    },
-  );
-}

package/src/utils/formatIncentivesTokenMap.ts

@@ -1,19 +0,0 @@
-import type { BribeBoostRewardItem } from "../types/bribeBoost";
-
-export function formatIncentivesTokenMap(
-  allRewards: BribeBoostRewardItem[],
-): Set<string> {
-  const tokenMap = new Set<string>();
-
-  for (const item of allRewards) {
-    if (Array.isArray(item.rewards)) {
-      for (const reward of item.rewards) {
-        if (reward.token) {
-          tokenMap.add(reward.token);
-        }
-      }
-    }
-  }
-
-  return tokenMap;
-}

package/src/utils/layerZeroScan.ts

@@ -1,124 +0,0 @@
-import { BeraError } from "../errors/BeraError";
-import { InvalidArgumentError } from "../errors/InvalidArgumentError";
-import { RequestError } from "../errors/RequestError";
-import { beraFetchJson } from "./beraFetch";
-
-const LAYERZERO_SCAN_MAINNET_URL = "https://api-mainnet.layerzero-scan.com";
-
-export enum LayerZeroMessageStatus {
-  INFLIGHT = "INFLIGHT",
-  DELIVERED = "DELIVERED",
-  FAILED = "FAILED",
-}
-
-export type LayerZeroMessage = {
-  srcUaAddress: string;
-  dstUaAddress: string;
-  srcChainId: number;
-  dstChainId: number;
-  dstTxHash?: string;
-  dstTxError?: string;
-  srcTxHash?: string;
-  srcBlockHash?: string;
-  srcBlockNumber?: string;
-  srcUaNonce: number;
-  status: LayerZeroMessageStatus;
-};
-
-export type LayerZeroDeliveredMessage = LayerZeroMessage & {
-  dstTxHash: string;
-};
-
-type GetMessagesBySrcTxHashResponse = {
-  messages: LayerZeroMessage[];
-};
-
-function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function getMessagesBySrcTxHash(
-  srcTxHash: string,
-): Promise<GetMessagesBySrcTxHashResponse> {
-  return beraFetchJson<GetMessagesBySrcTxHashResponse>({
-    url: `${LAYERZERO_SCAN_MAINNET_URL}/tx/${srcTxHash}`,
-    type: "rest",
-    name: "LayerZero Scan",
-  });
-}
-
-export type WaitForMessageReceivedOptions = {
-  pollInterval?: number;
-  timeout?: number;
-};
-
-/**
- * Polls LayerZero scan API until the cross-chain message is delivered or fails.
- * HTTP errors are silently retried until timeout.
- *
- * @param srcTxHash - The source transaction hash to track
- * @param options - Configuration options
- * @param options.pollInterval - Polling interval in ms (default: 3000)
- * @param options.timeout - Timeout in ms (default: 600000 / 10 minutes)
- * @returns The delivered message with destination tx hash
- * @throws InvalidArgumentError if srcTxHash is missing
- * @throws BeraError if message fails, times out, or multiple messages found
- */
-export async function waitForLayerZeroMessageReceived(
-  srcTxHash: string,
-  options: WaitForMessageReceivedOptions = {},
-): Promise<LayerZeroDeliveredMessage> {
-  const { pollInterval = 3000, timeout = 600_000 } = options;
-
-  if (!srcTxHash) {
-    throw new InvalidArgumentError({
-      property: "srcTxHash",
-      value: srcTxHash,
-      expected: "string",
-    });
-  }
-
-  const startTime = Date.now();
-
-  while (true) {
-    // check timeout
-    if (Date.now() - startTime > timeout) {
-      throw new BeraError({
-        message: `LayerZero message tracking timed out after ${timeout}ms`,
-        reason: "LAYERZERO_TIMEOUT",
-        level: "warning",
-      });
-    }
-
-    try {
-      const { messages } = await getMessagesBySrcTxHash(srcTxHash);
-      const message = messages[0];
-
-      if (messages.length > 1) {
-        throw new BeraError({
-          message: "More than one LayerZero message found for transaction",
-          reason: "LAYERZERO_MULTIPLE_MESSAGES",
-        });
-      }
-
-      if (message?.status === LayerZeroMessageStatus.FAILED) {
-        throw new BeraError({
-          message: `LayerZero message failed: ${message.dstTxError}`,
-          reason: "LAYERZERO_MESSAGE_FAILED",
-        });
-      }
-
-      if (message?.status === LayerZeroMessageStatus.DELIVERED) {
-        return message as LayerZeroDeliveredMessage;
-      }
-    } catch (error) {
-      // re-throw non-retryable errors (validation, timeout, failed message)
-      // but allow RequestError to retry (network issues, temporary API errors)
-      if (error instanceof BeraError && !(error instanceof RequestError)) {
-        throw error;
-      }
-    }
-
-    await sleep(pollInterval);
-  }
-}