@berachain/berajs 0.1.1 → 0.1.2

package/src/actions/pol/getBlockTime.ts

@@ -0,0 +1,43 @@
+import {
+  GetBlocksTimeStamp,
+  type GetBlocksTimeStampQuery,
+  type GetBlocksTimeStampQueryVariables,
+} from "@berachain/graphql/chain";
+
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { hoursInSeconds, msToSeconds } from "~/utils/time";
+import { getApolloClient } from "../clients/getApolloClient";
+
+export async function getBlockTime({
+  defaultBlockTime,
+  blocksSpan,
+  ...args
+}: {
+  defaultBlockTime?: number;
+  blocksSpan?: number;
+} & BeraJS.BaseFunctionArgs = {}): Promise<number> {
+  const { config } = parseBaseArgs(args);
+
+  const blocksClient = getApolloClient("blocks.subgraph", args);
+
+  const blockTime = defaultBlockTime ?? config.averageBlockTime;
+  const span = blocksSpan ?? Math.floor(hoursInSeconds(1) / blockTime);
+
+  const res = await blocksClient.query<
+    GetBlocksTimeStampQuery,
+    GetBlocksTimeStampQueryVariables
+  >({
+    query: GetBlocksTimeStamp,
+    variables: {
+      skip: span,
+    },
+  });
+
+  const data = res.data;
+
+  return (
+    // we need to use current timestamp as the latest block might not have been minted (chain halted)
+    (msToSeconds(Date.now()) - Number(data?.oldest[0]?.timestamp)) /
+    (Number(data?.newest[0]?.number) - Number(data?.oldest[0]?.number))
+  );
+}

package/src/actions/pol/getGlobalCuttingBoard.ts

@@ -0,0 +1,25 @@
+import {
+  type ApiVaultFragment,
+  GqlRewardVaultOrderBy,
+  GqlRewardVaultOrderDirection,
+} from "@berachain/graphql/pol/api";
+
+import { getRewardVaults } from "./getRewardVaults";
+
+export async function getGlobalCuttingBoard(
+  threshold: number,
+): Promise<ApiVaultFragment[]> {
+  const { gaugeList } = await getRewardVaults({
+    filter: {
+      // TODO sort by bgt capture percentage
+      orderBy: GqlRewardVaultOrderBy.Apr,
+      orderDirection: GqlRewardVaultOrderDirection.Desc,
+      pageSize: threshold,
+      where: {
+        includeNonWhitelisted: false,
+      },
+    },
+  });
+
+  return gaugeList;
+}

package/src/actions/pol/getGlobalData.ts

@@ -0,0 +1,74 @@
+import * as Sentry from "@sentry/nextjs";
+import type { PublicClient } from "viem";
+
+import type { ApiVaultFragment } from "@berachain/graphql/pol/api";
+
+import { type GlobalInfo, getBGTGlobalInfo } from "./getBGTGlobalInfo";
+import { getBgtTokenTotalBoosts } from "./getBgtTokenTotalBoosts";
+import { getBgtTokenTotalSupply } from "./getBgtTokenTotalSupply";
+import { getGlobalCuttingBoard } from "./getGlobalCuttingBoard";
+
+export interface GlobalData extends GlobalInfo {
+  globalCuttingBoard: ApiVaultFragment[] | undefined;
+  bgtTotalSupply: string | undefined;
+  bgtTotalBoosts: string | undefined;
+}
+export async function getGlobalData(
+  publicClient: PublicClient,
+): Promise<GlobalData> {
+  const [
+    globalDataRes,
+    globalCuttingBoardRes,
+    bgtTotalSupplyRes,
+    bgtTotalBoostsRes,
+  ] = await Promise.allSettled([
+    getBGTGlobalInfo(),
+    getGlobalCuttingBoard(300),
+    getBgtTokenTotalSupply({
+      publicClient,
+    }),
+    getBgtTokenTotalBoosts({
+      publicClient,
+    }),
+  ]);
+
+  if (globalDataRes.status === "rejected") {
+    Sentry.captureException(globalDataRes.reason, {
+      level: "warning",
+    });
+  }
+
+  if (globalCuttingBoardRes.status === "rejected") {
+    Sentry.captureException(globalCuttingBoardRes.reason, {
+      level: "warning",
+    });
+  }
+
+  if (bgtTotalSupplyRes.status === "rejected") {
+    Sentry.captureException(bgtTotalSupplyRes.reason, {
+      level: "warning",
+    });
+  }
+
+  if (bgtTotalBoostsRes.status === "rejected") {
+    Sentry.captureException(bgtTotalBoostsRes.reason, {
+      level: "warning",
+    });
+  }
+
+  return {
+    bgtTotalSupply:
+      bgtTotalSupplyRes.status === "fulfilled"
+        ? bgtTotalSupplyRes.value
+        : undefined,
+    globalCuttingBoard:
+      globalCuttingBoardRes.status === "fulfilled"
+        ? globalCuttingBoardRes.value
+        : [],
+    bgtTotalBoosts:
+      bgtTotalBoostsRes.status === "fulfilled"
+        ? bgtTotalBoostsRes.value
+        : undefined,
+    ...(globalDataRes.status === "fulfilled" ? globalDataRes.value : {}),
+  } satisfies GlobalData;
+}

package/src/actions/pol/getIncentiveFeeClaimStats.ts

@@ -0,0 +1,43 @@
+import {
+  GetIncentiveFeeClaimStats,
+  type GetIncentiveFeeClaimStatsQuery,
+  type GetIncentiveFeeClaimStatsQueryVariables,
+} from "@berachain/graphql/pol/subgraph";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { days } from "~/utils/time";
+
+export async function getIncentiveFeeClaimStats({
+  ...args
+}: BeraJS.BaseFunctionArgs) {
+  const bgtClient = getApolloClient("pol.subgraph", args);
+  const { data } = await bgtClient.query<
+    GetIncentiveFeeClaimStatsQuery,
+    GetIncentiveFeeClaimStatsQueryVariables
+  >({
+    query: GetIncentiveFeeClaimStats,
+  });
+
+  if (data.incentiveFeeClaims.length > 0) {
+    const sumAllClaims = data?.incentiveFeeClaims.reduce(
+      (acc, curr) => acc + Number(curr.payoutAmount),
+      30_000, // this is due to a bug in the subgraph, where the first claim of 50_000 was counted as 20_000, once hunter pushed the fix we can upgrade it.
+    );
+    const claimsInLast24Hours = data?.incentiveFeeClaims.filter(
+      (claim) => Number(claim.timestamp) / 1000 > Date.now() - days(1),
+    );
+    const sumClaimsInLast24Hours = claimsInLast24Hours.reduce(
+      (acc, curr) => acc + Number(curr.payoutAmount),
+      0,
+    );
+    return {
+      sumAllClaims,
+      sumClaimsInLast24Hours,
+    };
+  }
+
+  return {
+    sumAllClaims: 0,
+    sumClaimsInLast24Hours: 0,
+  };
+}

package/src/actions/pol/getMarkets.ts

@@ -0,0 +1,36 @@
+import type { ProtocolMetadata } from "~/types";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export interface GetMarkets {
+  marketList: ProtocolMetadata[];
+  marketDictionary: { [key: string]: ProtocolMetadata };
+}
+
+export async function getMarkets(
+  args: BeraJS.BaseFunctionArgs = {},
+): Promise<GetMarkets> {
+  const { config } = parseBaseArgs(args);
+
+  try {
+    const markets = await fetch(config.lists.rewardVaultList);
+    const temp = await markets.json();
+
+    if (!temp.protocols) {
+      throw new Error("Missing protocols in market list");
+    }
+
+    return {
+      marketList: temp.protocols,
+      marketDictionary: temp.protocols.reduce(
+        (acc: { [key: string]: ProtocolMetadata }, item: ProtocolMetadata) => {
+          acc[item.name] = item;
+          return acc;
+        },
+        {},
+      ),
+    };
+  } catch (error) {
+    console.error("Error fetching validator information", error);
+    throw error;
+  }
+}

package/src/actions/pol/getRewardProofsByValidator.ts

@@ -0,0 +1,49 @@
+import type { Address } from "viem";
+
+import { BeraError } from "~/errors/BeraError";
+import type { BribeBoostRewardProof } from "~/types";
+import { getErrorResponse } from "~/utils/getErrorResponse";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getRewardProofsByValidator({
+  account,
+  validator,
+  page = 1,
+  perPage = 1000,
+  ...args
+}: {
+  account: Address;
+  validator: Address;
+  page?: number;
+  perPage?: number;
+} & BeraJS.BaseFunctionArgs): Promise<BribeBoostRewardProof> {
+  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()}/proofs/validator/${validator.toLowerCase()}?page=${page}&per_page=${perPage}`,
+    {
+      cache: "no-store",
+    },
+  );
+
+  if (!result.ok) {
+    const error = await getErrorResponse(result);
+    throw new BeraError({
+      message: "Failed to fetch proofs on server",
+      cause: {
+        error,
+        result: result,
+        account,
+        validator,
+      },
+      reason: error?.reason,
+    });
+  }
+
+  const data = await result.json();
+  return data;
+}

package/src/actions/pol/getRewardTokenToBeraRate.ts

@@ -0,0 +1,30 @@
+import { type Address, formatUnits, type PublicClient, parseUnits } from "viem";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { assertPublicClient } from "~/errors/assert";
+
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+export async function getRewardTokenToBeraRate({
+  address,
+  publicClient,
+}: {
+  address: Address;
+  publicClient?: PublicClient;
+}): Promise<number> {
+  assertPublicClient(publicClient);
+
+  return publicClient
+    .readContract({
+      address,
+      abi: stakeBeraVaultAbi,
+      functionName: "previewRedeem" as const,
+      args: [parseUnits("1", 18)],
+    })
+    .then((rate) => Number(formatUnits(rate, 18)))
+    .catch(() => 0);
+}

package/src/actions/pol/getRewardVault.ts

@@ -0,0 +1,54 @@
+import type { Address } from "viem";
+
+import {
+  type ApiVaultFragment,
+  GetRewardVault,
+  type GetRewardVaultQuery,
+  type GetRewardVaultQueryVariables,
+  type GqlChain,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { NotFoundError } from "~/errors/NotFoundError";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+export async function getRewardVault({
+  address,
+  chainName,
+  ...args
+}: {
+  address: Address;
+  chainName?: GqlChain;
+} & BeraJS.BaseFunctionArgs): Promise<ApiVaultFragment> {
+  const { config } = parseBaseArgs(args);
+  const resolvedChainName = chainName ?? (config.bex.chainName as GqlChain);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const { data } = await bexApiGraphqlClient.query<
+    GetRewardVaultQuery,
+    GetRewardVaultQueryVariables
+  >({
+    query: GetRewardVault,
+    variables: {
+      vaultId: address,
+      chain: resolvedChainName,
+    },
+  });
+
+  if (!data?.rewardVault) {
+    throw new NotFoundError({
+      resource: "Reward vault",
+      id: address,
+      chainId: config.chainId,
+    });
+  }
+
+  return data.rewardVault;
+}

package/src/actions/pol/getRewardVaultBeaconImplementation.integration.test.ts

@@ -0,0 +1,18 @@
+import { isAddress, zeroAddress } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getRewardVaultBeaconImplementation } from "./getRewardVaultBeaconImplementation";
+
+describe("getRewardVaultBeaconImplementation", () => {
+  const publicClient = getServerSidePublicClient();
+  it("should return the beacon implementation", async () => {
+    const beaconImplementation = await getRewardVaultBeaconImplementation({
+      publicClient,
+    });
+
+    expect(beaconImplementation).toBeDefined();
+    expect(isAddress(beaconImplementation)).toBe(true);
+    expect(beaconImplementation).not.toBe(zeroAddress);
+  });
+});

package/src/actions/pol/getRewardVaultBeaconImplementation.ts

@@ -0,0 +1,35 @@
+import type { Address, PublicClient } from "viem";
+
+import { rewardVaultFactoryAbi } from "~/abi/pol/rewardVaultFactory";
+import { upgradableBeaconAbi } from "~/abi/utils/upgradableBeacon";
+import { assertAddress, assertDefined } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Returns the beacon implementation address for all reward vaults.
+ */
+export async function getRewardVaultBeaconImplementation({
+  publicClient,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  publicClient: PublicClient;
+}): Promise<Address> {
+  const { config } = parseBaseArgs(args);
+  const factoryAddress = config.pol.factory;
+  assertDefined(publicClient, "publicClient");
+  assertAddress(config.pol.factory, "factoryAddress");
+
+  // from the factory contract, we get the beacon address
+  const beacon = await publicClient.readContract({
+    address: factoryAddress,
+    abi: rewardVaultFactoryAbi,
+    functionName: "beacon",
+  });
+
+  // from the beacon contract, we get the current implementation address
+  return await publicClient.readContract({
+    address: beacon,
+    abi: upgradableBeaconAbi,
+    functionName: "implementation",
+  });
+}

package/src/actions/pol/getRewardVaultDurationConstants.integration.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getRewardVaultDurationConstants } from "./getRewardVaultDurationConstants";
+
+describe("getRewardVaultDurationConstants", () => {
+  it("should return the reward vault duration constants", async () => {
+    const publicClient = getServerSidePublicClient();
+    const rewardVaultDurationConstants = await getRewardVaultDurationConstants({
+      publicClient,
+    });
+
+    expect(rewardVaultDurationConstants).toBeDefined();
+    expect(rewardVaultDurationConstants.minRewardDuration).toBeTypeOf("number");
+    expect(rewardVaultDurationConstants.minRewardDuration).toBeGreaterThan(0);
+
+    expect(rewardVaultDurationConstants.maxRewardDuration).toBeTypeOf("number");
+    expect(rewardVaultDurationConstants.maxRewardDuration).toBeGreaterThan(0);
+
+    expect(rewardVaultDurationConstants.minRewardDuration).toBeLessThan(
+      rewardVaultDurationConstants.maxRewardDuration,
+    );
+  });
+});

package/src/actions/pol/getRewardVaultDurationConstants.ts

@@ -0,0 +1,45 @@
+import type { PublicClient } from "viem";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { assertPublicClient } from "~/errors/assert";
+import { getRewardVaultBeaconImplementation } from "./getRewardVaultBeaconImplementation";
+
+export interface RewardVaultDurationConstants {
+  minRewardDuration: number;
+  maxRewardDuration: number;
+}
+
+/**
+ * Returns the minimum and maximum reward duration constants for all reward vaults.
+ */
+export async function getRewardVaultDurationConstants({
+  publicClient,
+  ...baseArgs
+}: BeraJS.BaseFunctionArgs & {
+  publicClient: PublicClient;
+}): Promise<RewardVaultDurationConstants> {
+  assertPublicClient(publicClient);
+
+  const beaconImplementation = await getRewardVaultBeaconImplementation({
+    publicClient,
+    ...baseArgs,
+  });
+
+  const [minRewardDuration, maxRewardDuration] = await Promise.all([
+    publicClient.readContract({
+      address: beaconImplementation,
+      abi: rewardVaultAbi,
+      functionName: "MIN_REWARD_DURATION",
+    }),
+    publicClient.readContract({
+      address: beaconImplementation,
+      abi: rewardVaultAbi,
+      functionName: "MAX_REWARD_DURATION",
+    }),
+  ]);
+
+  return {
+    minRewardDuration: Number(minRewardDuration),
+    maxRewardDuration: Number(maxRewardDuration),
+  };
+}

package/src/actions/pol/getRewardVaultFromToken.ts

@@ -0,0 +1,30 @@
+import { type Address, type PublicClient, zeroAddress } from "viem";
+
+import { rewardVaultFactoryAbi } from "~/abi/pol/rewardVaultFactory";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getRewardVaultFromToken({
+  tokenAddress,
+  publicClient,
+  factoryAddress,
+  ...args
+}: {
+  tokenAddress: Address;
+  publicClient: PublicClient;
+  factoryAddress?: Address;
+} & BeraJS.BaseFunctionArgs) {
+  const { config } = parseBaseArgs(args);
+
+  const vaultAddress = await publicClient.readContract({
+    address: factoryAddress ?? config.pol.factory,
+    abi: rewardVaultFactoryAbi,
+    functionName: "getVault",
+    args: [tokenAddress],
+  });
+
+  if (vaultAddress === zeroAddress) {
+    return null;
+  }
+
+  return vaultAddress;
+}

package/src/actions/pol/getRewardVaultIncentives.ts

@@ -0,0 +1,122 @@
+import { isSameAddress } from "@berachain-foundation/berancer-sdk";
+import * as Sentry from "@sentry/nextjs";
+import { type Address, erc20Abi, formatUnits, type PublicClient } from "viem";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { BeraError } from "~/errors/BeraError";
+
+export interface RewardVaultIncentive {
+  token: Address;
+  manager: Address;
+  minIncentiveRate: string;
+  incentiveRate: string;
+  remainingAmount: string;
+  symbol?: string;
+  /**
+   * Amount of tokens that needs approval before they can be added to the incentive.
+   *
+   * Anyone can just `transfer` ERC20 to the vault, but incentive manager need to send accountIncentives to turn on distribution.
+   */
+  pendingAmount: string;
+  decimals: number;
+}
+
+export async function getRewardVaultIncentives({
+  address,
+  stakingToken,
+  publicClient,
+}: {
+  address: Address;
+  stakingToken: Address;
+  publicClient: PublicClient;
+}): Promise<RewardVaultIncentive[]> {
+  const whitelistedTokens = await publicClient.readContract({
+    address: address,
+    abi: rewardVaultAbi,
+    functionName: "getWhitelistedTokens",
+  });
+
+  // Only fetch totalSupply if stakingToken is in whitelistedTokens
+  const stakingTokenIndex = whitelistedTokens.findIndex((token) =>
+    isSameAddress(stakingToken, token),
+  );
+
+  const totalSupply =
+    stakingTokenIndex !== -1
+      ? await publicClient.readContract({
+          address: address,
+          abi: rewardVaultAbi,
+          functionName: "totalSupply",
+        })
+      : 0n;
+
+  const incentives = await Promise.allSettled(
+    whitelistedTokens.map(async (token) => {
+      const [incentiveInfo, decimals, symbol, totalBalance] = await Promise.all(
+        [
+          publicClient.readContract({
+            address: address,
+            abi: rewardVaultAbi,
+            functionName: "incentives",
+            args: [token],
+          }),
+          publicClient.readContract({
+            address: token,
+            abi: erc20Abi,
+            functionName: "decimals",
+          }),
+          publicClient.readContract({
+            address: token,
+            abi: erc20Abi,
+            functionName: "symbol",
+          }),
+          publicClient.readContract({
+            address: token,
+            abi: erc20Abi,
+            functionName: "balanceOf",
+            args: [address],
+          }),
+        ],
+      );
+
+      const [minIncentiveRate, incentiveRate, remainingAmount, manager] =
+        incentiveInfo;
+
+      return {
+        token,
+        manager,
+        minIncentiveRate: formatUnits(minIncentiveRate, decimals),
+        incentiveRate: formatUnits(incentiveRate, decimals),
+        remainingAmount: formatUnits(remainingAmount, decimals),
+        symbol,
+        decimals,
+        pendingAmount: isSameAddress(stakingToken, token)
+          ? formatUnits(totalBalance - totalSupply - remainingAmount, decimals)
+          : formatUnits(totalBalance - remainingAmount, decimals),
+      };
+    }),
+  );
+
+  incentives.forEach((result, index) => {
+    if (result.status === "rejected") {
+      Sentry.captureException(
+        new BeraError({
+          reason: result.reason,
+          message: "Incorrect incentives token received.",
+          level: "error",
+        }),
+        {
+          extra: {
+            token: whitelistedTokens[index],
+            address: address,
+            error: result.reason,
+          },
+        },
+      );
+    }
+  });
+
+  return incentives
+    .map((result) => (result.status === "fulfilled" ? result.value : null))
+    .filter((incentive) => incentive !== null);
+}