@berachain/berajs 0.1.0 → 0.1.2

package/src/hooks/validators/useValidatorCommission.ts

@@ -0,0 +1,36 @@
+import useSWR from "swr";
+import type { Address, PublicClient } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getValidatorCommission } from "~/actions/validators/getValidatorCommission";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export const useValidatorCommission = (
+  pubKey: Address,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<number | undefined | null> => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    publicClient && pubKey
+      ? (["useValidatorCommission", pubKey] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey]) => {
+      return await getValidatorCommission({
+        client: publicClient as PublicClient,
+        pubKey: pubKey,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/validators/useValidatorEstimatedBgtPerYear.ts

@@ -0,0 +1,24 @@
+import type { ApiValidatorMinimalFragment } from "@berachain/graphql/pol/api";
+
+import { getValidatorEstimatedBgtPerYear } from "~/actions/validators/getValidatorEstimatedBgtPerYear";
+import { useBlockTime } from "~/contexts/block-time-provider";
+import { usePollGlobalData } from "~/hooks/pol/usePollGlobalData";
+
+export const useValidatorEstimatedBgtPerYear = (
+  validator: ApiValidatorMinimalFragment,
+): { data: number | undefined; isLoading: boolean } => {
+  const { data: globalData, isLoading } = usePollGlobalData();
+
+  const blockTime = useBlockTime();
+
+  return {
+    data: globalData
+      ? getValidatorEstimatedBgtPerYear(
+          validator,
+          Number(globalData?.totalStakedBeraAmount),
+          blockTime,
+        )
+      : undefined,
+    isLoading,
+  };
+};

package/src/hooks/validators/useValidatorQueuedCommission.ts

@@ -0,0 +1,41 @@
+import useSWR from "swr";
+import type { Address } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import {
+  getValidatorQueuedCommission,
+  type ValidatorQueuedCommission,
+} from "~/actions/validators/getValidatorQueuedCommission";
+import { assertPublicClient } from "~/errors/assert";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export function useValidatorQueuedCommission(
+  pubKey: Address,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<ValidatorQueuedCommission | undefined | null> {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    publicClient && pubKey
+      ? (["useValidatorQueuedCommission", pubKey] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey]) => {
+      assertPublicClient(publicClient);
+      return await getValidatorQueuedCommission({
+        client: publicClient,
+        pubKey,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+}

package/src/hooks/validators/useValidatorQueuedOperatorAddress.ts

@@ -0,0 +1,39 @@
+import useSWR from "swr";
+import type { Address, PublicClient } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import {
+  getValidatorQueuedOperatorAddress,
+  type ValidatorQueuedOperatorAddress,
+} from "~/actions/validators/getValidatorQueuedOperatorAddress";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export const useValidatorQueuedOperatorAddress = (
+  pubKey: Address,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<ValidatorQueuedOperatorAddress | undefined> => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    publicClient && pubKey
+      ? (["useValidatorQueuedOperatorAddress", pubKey] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey]) => {
+      return await getValidatorQueuedOperatorAddress({
+        client: publicClient as PublicClient,
+        pubKey,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/validators/useValidatorQueuedRewardAllocation.ts

@@ -0,0 +1,37 @@
+import useSWR from "swr";
+import type { Address, PublicClient } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getValidatorQueuedRewardAllocation } from "~/actions/validators/getValidatorQueuedRewardAllocation";
+import type { ValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
+import type { DefaultHookOptions, DefaultHookReturnType } from "~/types";
+
+export const useValidatorQueuedRewardAllocation = (
+  pubKey: Address,
+  options?: DefaultHookOptions,
+): DefaultHookReturnType<ValidatorRewardAllocation | undefined> => {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    publicClient && pubKey
+      ? (["useValidatorQueuedRewardAllocation", pubKey] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey]) => {
+      return await getValidatorQueuedRewardAllocation({
+        client: publicClient as PublicClient,
+        pubKey,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+};

package/src/hooks/validators/useValidatorRewardAllocation.ts

@@ -0,0 +1,36 @@
+import useSWR from "swr";
+import type { Address, PublicClient } from "viem";
+
+import { usePublicClient } from "@berachain/wagmi/hooks";
+
+import { getValidatorRewardAllocation } from "~/actions/validators/getValidatorRewardAllocation";
+import type { DefaultHookOptions } from "~/types";
+
+export function useValidatorRewardAllocation(
+  pubKey: Address,
+  options?: DefaultHookOptions,
+) {
+  const publicClient = usePublicClient();
+  const QUERY_KEY =
+    publicClient && pubKey
+      ? (["useValidatorRewardAllocation", pubKey] as const)
+      : null;
+
+  const swrResponse = useSWR(
+    QUERY_KEY,
+    async ([, pubKey]) => {
+      return await getValidatorRewardAllocation({
+        client: publicClient as PublicClient,
+        pubKey,
+      });
+    },
+    {
+      ...options?.opts,
+    },
+  );
+
+  return {
+    ...swrResponse,
+    refresh: () => swrResponse.mutate(),
+  };
+}

package/src/types/bribe-boost.ts

@@ -0,0 +1,50 @@
+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;
+}
+
+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.ts

@@ -0,0 +1,196 @@
+import type { SwapKind } from "@berachain-foundation/berancer-sdk";
+import type { Abi, Address, PublicClient } from "viem";
+
+import type { aggregatorsRouterAbi } from "~/abi/bex/aggregatorsRouter";
+import type { HoneyConfigContextReturn } from "~/contexts/HoneyConfigProvider";
+import type { IContractWrite, TokenBalance } from "./global";
+
+export type MinimalERC20 = {
+  address: Address;
+  decimals: number;
+  symbol: string;
+  name: string;
+};
+
+export type TokenWithMetadata = MinimalERC20 & {
+  tags?: string[];
+  base64?: string;
+  logoURI?: string;
+  chainId?: number;
+};
+
+export type Token = TokenWithMetadata & {
+  /**
+   * @deprecated
+   */
+  default?: boolean;
+  totalSupply?: string;
+  weight?: number | string | null;
+};
+
+export interface TokenPriceInfo {
+  price: number;
+  updatedAt: number;
+}
+
+export type TokenCurrentPriceMap = Record<
+  Lowercase<Address> | string,
+  TokenPriceInfo | undefined
+>;
+
+export interface TokenWithAmount extends Token {
+  amount: string;
+}
+
+export interface BalanceToken extends Token {
+  balance: bigint;
+  formattedBalance: string;
+  price?: number;
+}
+
+export type BalanceTokenWithMetadata = BalanceToken & TokenWithMetadata;
+
+export interface TokenInput extends Token {
+  amount: string;
+  exceeding: boolean;
+}
+
+export interface SwapRequest {
+  tokenIn: Address;
+  tokenOut: Address;
+  tokenInDecimals: number;
+  tokenOutDecimals: number;
+  amount: string;
+  wberaIsBera: boolean;
+  swapKind: SwapKind;
+}
+
+export interface IUserPosition {
+  lpBalance?: TokenBalance;
+  tokenBalances?: TokenBalance[];
+  userSharePercentage?: number;
+  stakedBalance?: TokenBalance;
+  /**
+   * Just a utility to detect if there is a price for the LP token.
+   */
+  lpTokenPrice?: number;
+}
+
+export enum PoolCreationStep {
+  POOL_TYPE = "Pool Type",
+  SELECT_TOKENS = "Select Tokens",
+  DEPOSIT_LIQUIDITY = "Deposit Liquidity",
+  SET_PARAMETERS = "Set Parameters",
+  SET_INFO = "Set Info",
+}
+
+export type BexStatus = {
+  protocol: {
+    /**
+     * If the whole protocol is paused (i.e. ~the~ vault contract) disable any functionality except withdrawing proportional
+     * liquidity (provided that pool's recovery mode is enabled). Specifically we disable swaps and pool creation.
+     */
+    isPaused: boolean;
+  };
+  /**
+   * Pool is undefined if pool status is still loading if no pool address was provided.
+   */
+  pool?: {
+    /**
+     * Pool should be put into recovery mode if tx are reverting on-chain to do with fee computation or pool exits.
+     * It reduces the computation needed to withdraw liquidity and does not charge protocol fees on exits while enabled.
+     *
+     * NOTE: that you can potentially still do regular exits/joins/etc in recovery mode, but if the flag is true will only
+     * present the safe exit option to the user in FE.
+     */
+    isInRecoveryMode: boolean;
+    /**
+     * If the pool is paused you cannot do anything unless you also enable recovery mode (then you can withdraw safely).
+     */
+    isPaused: boolean;
+    /**
+     * Disable withdrawals for a pool due to a combination of pool and vault statuses.
+     */
+    disablePoolWithdrawals: boolean;
+    /**
+     * Disable deposits for a pool due to a combination of pool and vault statuses.
+     */
+    disablePoolDeposits: boolean;
+  };
+};
+
+export type IAggregatorArgs = {
+  tokenIn: string;
+  tokenOut: string;
+  tokenInDecimals?: number;
+  tokenOutDecimals?: number;
+  amount: string;
+  slippage: number;
+  account?: Address;
+  publicClient?: PublicClient;
+  aggregatorsFeeBps?: number;
+  proxyAggregatorsThroughVercel?: boolean;
+  referrer?: SwapReferrer;
+  /**
+   * If provided, the aggregator will stake into the reward vault after the swap.
+   */
+  rewardVault?: Address;
+  honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList">;
+};
+
+export enum Aggregators {
+  Oogabooga = "Oogabooga",
+  Fly = "Fly",
+  HubPools = "Hub Pools",
+  Wrap = "Wrap",
+  Unwrap = "Unwrap",
+  KyberSwap = "KyberSwap",
+  OpenOcean = "OpenOcean",
+  Haiku = "Haiku",
+  Enso = "Enso",
+  RedeemBgt = "RedeemBgt",
+  Honey = "Honey",
+}
+
+export type IRawAggregatorQuote<isRoutedThroughAggregator = true> = {
+  amountOut: string;
+  amountIn: string;
+  name: Aggregators;
+  spender: Address | undefined;
+  /**
+   * True if it's bera wrap/unwrap or bgt redeem.
+   */
+  isNativeSwap?: boolean;
+  priceImpactPercentage?: number;
+  swapFeeBps: number;
+  calldata?: isRoutedThroughAggregator extends true
+    ? Omit<
+        IContractWrite<typeof aggregatorsRouterAbi, "swap">,
+        "message" | "actionType"
+      >
+    : {
+        params: readonly unknown[] | undefined;
+        functionName: string;
+        abi: Abi;
+        address: Address;
+        value?: bigint;
+      };
+};
+
+export type IAggregatorQuote =
+  // no need to force to swapAndStake as type check is done on each getQuote
+  IRawAggregatorQuote<false> & {
+    amountOut: string;
+    amountOutUsd: string;
+    amountIn: string;
+    amountInUsd: string;
+    priceImpactPercentage: number;
+    exchangeRate: number;
+    relativeLossPercentage: number;
+    isBest?: boolean;
+  };
+
+export enum SwapReferrer {
+  SWAP = "SWAP",
+  ZAP = "ZAP",
+}

package/src/types/enso.ts

@@ -0,0 +1,42 @@
+import type { BundleData, EnsoClient } from "@ensofinance/sdk";
+import type { Address, Hex, PublicClient, TransactionRequest } from "viem";
+
+export type Quantity = string | number;
+export type ActionOutputReference<T> = T | StrictOutputReference<T>;
+type StrictOutputReference<T> = {
+  useOutputOfCallAt: number;
+  index?: number;
+};
+
+export interface GetZapTransactionRequestsArgs {
+  fromAddress: Address;
+  amountIn: Quantity;
+  tokenIn: Address;
+  tokenOut: Address;
+  chainId: number;
+  ensoClient: EnsoClient;
+  slippage: number;
+  destinationChainId?: number;
+  publicClient: PublicClient;
+}
+
+export type GetZapTransaction = TransactionRequest & {
+  to: Address;
+  data: Hex;
+  value?: bigint;
+  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 GetZapTransactionResponse {
+  bundle: BundleData;
+  transactions: GetZapTransactions;
+}