@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/pol/getRewardVaultRewards.ts

@@ -0,0 +1,109 @@
+import { type Address, formatUnits, type PublicClient } from "viem";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { msToSeconds } from "~/utils/time";
+
+export enum RewardVaultDistributionMode {
+  Duration = "duration",
+  TargetRate = "targetRate",
+  TargetApr = "targetApr",
+}
+export interface GetRewardVaultRewardsReturn {
+  rewardsDuration: number;
+  manager: Address;
+  /**
+   * The amount of BGT that will be distributed per second
+   */
+  rewardRate: string;
+  /**
+   * The timestamp when rewards will be depleted
+   */
+  periodFinish: number;
+  /**
+   * The amount of BGT that will be distributed from now until the periodFinish timestamp
+   */
+  availableRewards: string;
+  /**
+   * The amount of BGT that will be distributed per second.
+   *
+   * If this is 0, the duration mode is active.
+   */
+  targetRewardsPerSecond: string;
+  /**
+   * The minimum reward duration for the target rate
+   */
+  minRewardDurationForTargetRate: number;
+  /**
+   * The current mode of the vault
+   */
+  mode:
+    | RewardVaultDistributionMode.Duration
+    | RewardVaultDistributionMode.TargetRate;
+}
+
+export async function getRewardVaultRewards(
+  address: Address,
+  publicClient: PublicClient,
+): Promise<GetRewardVaultRewardsReturn> {
+  const [
+    rewardsDuration,
+    manager,
+    rewardRate,
+    periodFinish,
+    targetRewardsPerSecond,
+    minRewardDurationForTargetRate,
+  ] = await Promise.all([
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "rewardsDuration",
+    }),
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "rewardVaultManager",
+    }),
+
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "rewardRate",
+    }),
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "periodFinish",
+    }),
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "targetRewardsPerSecond",
+    }),
+    publicClient.readContract({
+      address: address,
+      abi: rewardVaultAbi,
+      functionName: "minRewardDurationForTargetRate",
+    }),
+  ]);
+
+  const availableRewards =
+    (rewardRate * (periodFinish - BigInt(msToSeconds(Date.now())))) /
+    10n ** 18n;
+
+  return {
+    rewardsDuration: Number(rewardsDuration),
+    mode:
+      targetRewardsPerSecond === 0n
+        ? RewardVaultDistributionMode.Duration
+        : RewardVaultDistributionMode.TargetRate,
+    manager,
+
+    // 36 decimals for the reward rate
+    rewardRate: formatUnits(rewardRate, 36),
+    periodFinish: Number(periodFinish),
+    // 36 decimals for the reward rate
+    availableRewards: formatUnits(availableRewards, 18),
+    minRewardDurationForTargetRate: Number(minRewardDurationForTargetRate),
+    targetRewardsPerSecond: formatUnits(targetRewardsPerSecond, 36),
+  };
+}

package/src/actions/pol/getRewardVaultStakingToken.ts

@@ -0,0 +1,19 @@
+import type { Address, PublicClient } from "viem";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+
+export async function getRewardVaultStakingToken({
+  address,
+  publicClient,
+}: {
+  address: Address;
+  publicClient: NonNullable<PublicClient>;
+}) {
+  const vaultAddress = await publicClient.readContract({
+    address: address,
+    abi: rewardVaultAbi,
+    functionName: "stakeToken",
+  });
+
+  return vaultAddress;
+}

package/src/actions/pol/getRewardVaults.ts

@@ -0,0 +1,106 @@
+import type { GetPublicClientReturnType } from "@wagmi/core";
+import { type Address, formatUnits } from "viem";
+
+import {
+  type ApiVaultFragment,
+  GetVaults,
+  type GetVaultsQuery,
+  type GetVaultsQueryVariables,
+} from "@berachain/graphql/pol/api";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export interface GetGaugeData {
+  gaugeList: ApiVaultFragment[];
+  pagination: {
+    currentPage: number;
+    totalCount: number;
+  };
+}
+
+export async function getRewardVaults({
+  filter,
+  publicClient,
+  ...args
+}: {
+  filter?: GetVaultsQueryVariables;
+  publicClient?: GetPublicClientReturnType;
+} & BeraJS.BaseFunctionArgs = {}): Promise<GetGaugeData> {
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const res = await bexApiGraphqlClient.query<
+    GetVaultsQuery,
+    GetVaultsQueryVariables
+  >({
+    query: GetVaults,
+    variables: filter,
+  });
+
+  const incentives = await Promise.allSettled(
+    res.data.polGetRewardVaults.vaults.map(async (vault) => {
+      if (!publicClient) return undefined;
+
+      return Promise.allSettled(
+        vault.activeIncentives.map((incentive) =>
+          publicClient.readContract({
+            abi: rewardVaultAbi,
+            address: vault.address as Address,
+            functionName: "incentives",
+            args: [incentive.tokenAddress as Address],
+          }),
+        ),
+      );
+    }),
+  );
+
+  const vaults = res.data.polGetRewardVaults.vaults.map((vault, index) => {
+    let totalIncentiveInUsdc = 0;
+
+    const incentivesArray: typeof vault.activeIncentives =
+      vault.activeIncentives.map((apiIncentive, incIdx) => {
+        const tokenPrice =
+          Number(apiIncentive.remainingAmountUsd) &&
+          Number(apiIncentive.remainingAmount)
+            ? Number(apiIncentive.remainingAmountUsd) /
+              Number(apiIncentive.remainingAmount)
+            : 0;
+
+        const remainingAmount =
+          incentives[index]?.status === "fulfilled" &&
+          incentives[index]?.value?.[incIdx]?.status === "fulfilled"
+            ? formatUnits(
+                BigInt(incentives[index].value[incIdx].value[2]),
+                apiIncentive.token.decimals,
+              )
+            : apiIncentive.remainingAmount;
+
+        totalIncentiveInUsdc += Number(remainingAmount) * Number(tokenPrice);
+
+        return {
+          ...apiIncentive,
+          remainingAmount,
+        };
+      });
+
+    return {
+      ...vault,
+      dynamicData: {
+        ...vault.dynamicData,
+        allTimeReceivedBGTAmount:
+          vault.dynamicData?.allTimeReceivedBGTAmount ?? "0",
+        bgtCapturePercentage: vault.dynamicData?.bgtCapturePercentage ?? "0",
+        activeIncentivesValueUsd: totalIncentiveInUsdc.toString(),
+        activeIncentivesRateUsd:
+          vault.dynamicData?.activeIncentivesRateUsd ?? "0",
+        bgtCapturePerBlock: vault.dynamicData?.bgtCapturePerBlock ?? "0",
+      },
+      activeIncentives: incentivesArray,
+    } satisfies typeof vault;
+  });
+
+  return {
+    pagination: res.data.polGetRewardVaults.pagination,
+    gaugeList: vaults!,
+  };
+}

package/src/actions/pol/getSWBeraVaultMetadata.ts

@@ -0,0 +1,166 @@
+import BigNumber from "bignumber.js";
+import { type Address, erc20Abi, type PublicClient } from "viem";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getBlockTime } from "./getBlockTime";
+import { getIncentiveFeeClaimStats } from "./getIncentiveFeeClaimStats";
+import { getStakeWithdrawalCooldown } from "./getStakeWithdrawalCooldown";
+
+export interface VaultMetadata {
+  current: {
+    exchangeRate: string;
+    totalSupply: string;
+    totalAssets: string;
+    tvl: string;
+  };
+  previous: {
+    exchangeRate: string;
+    totalSupply: string;
+    totalAssets: string;
+    tvl: string;
+  };
+  totalWBeraIssued: string;
+  lockPeriod?: number;
+  totalBuyBacks: number;
+  totalBuyBacksInLast24Hours: number;
+}
+/**
+ *
+ * @param address - The address of the vault
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+export async function getSWBeraVaultMetadata({
+  address,
+  publicClient,
+  ...args
+}: {
+  address: Address;
+  publicClient?: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<VaultMetadata> {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+
+  const hoursWindow = 26; // 26 hours is the window for the vault to ensure at least 1 claim per APR window.
+  try {
+    // Get current block number
+    const [currentBlock, blockTime] = await Promise.all([
+      publicClient.getBlock({ blockTag: "latest" }),
+      getBlockTime(),
+    ]);
+    const blocksPerWindow = Math.floor((hoursWindow * 60 * 60) / blockTime); // hoursWindow * 60 minutes * 60 seconds / actual block time
+    const blockWindowAgo = currentBlock.number - BigInt(blocksPerWindow);
+
+    const [
+      curretTotalAssets,
+      currentTotalSupply,
+      currentOneShareWorth,
+      currentTVL,
+      totalAssets24HoursAgo,
+      totalSupply24HoursAgo,
+      oneShareWorthWindowAgo,
+      tvl24HoursAgo,
+      totalWBeraIssued,
+      lockPeriod,
+      incentiveFeeClaimStats,
+    ] = await Promise.all([
+      publicClient.readContract({
+        address,
+        abi: stakeBeraVaultAbi,
+        functionName: "totalAssets",
+      }),
+      publicClient.readContract({
+        address,
+        abi: stakeBeraVaultAbi,
+        functionName: "totalSupply",
+      }),
+      publicClient.readContract({
+        address,
+        abi: stakeBeraVaultAbi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: currentBlock.number,
+      }),
+      publicClient.readContract({
+        address: config.tokens.wbera,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+      }),
+      publicClient.readContract({
+        address,
+        abi: stakeBeraVaultAbi,
+        functionName: "totalAssets",
+        blockNumber: blockWindowAgo,
+      }),
+      publicClient.readContract({
+        address,
+        abi: erc20Abi,
+        functionName: "totalSupply",
+        blockNumber: blockWindowAgo,
+      }),
+      publicClient.readContract({
+        address,
+        abi: stakeBeraVaultAbi,
+        functionName: "previewRedeem",
+        args: [10n ** 18n],
+        blockNumber: blockWindowAgo,
+      }),
+      publicClient.readContract({
+        address: config.tokens.wbera,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+        blockNumber: blockWindowAgo,
+      }),
+      publicClient.readContract({
+        address: config.tokens.wbera,
+        abi: erc20Abi,
+        functionName: "totalSupply",
+      }),
+      getStakeWithdrawalCooldown({
+        publicClient: publicClient,
+      }),
+      getIncentiveFeeClaimStats({}),
+    ]);
+    const exchangeRateWindowAgo = new BigNumber(
+      oneShareWorthWindowAgo.toString(),
+    );
+
+    const currentExchangeRate = new BigNumber(currentOneShareWorth.toString());
+
+    return {
+      current: {
+        exchangeRate: currentExchangeRate.toString(),
+        totalSupply: new BigNumber(currentTotalSupply.toString())
+          .dividedBy(1e18)
+          .toString(),
+        totalAssets: new BigNumber(curretTotalAssets.toString())
+          .dividedBy(1e18)
+          .toString(),
+        tvl: new BigNumber(currentTVL.toString()).dividedBy(1e18).toString(),
+      },
+      previous: {
+        exchangeRate: exchangeRateWindowAgo.toString(),
+        totalSupply: new BigNumber(totalSupply24HoursAgo.toString())
+          .dividedBy(1e18)
+          .toString(),
+        totalAssets: new BigNumber(totalAssets24HoursAgo.toString())
+          .dividedBy(1e18)
+          .toString(),
+        tvl: new BigNumber(tvl24HoursAgo.toString()).dividedBy(1e18).toString(),
+      },
+      totalWBeraIssued: new BigNumber(totalWBeraIssued.toString())
+        .dividedBy(1e18)
+        .toString(),
+      lockPeriod,
+      totalBuyBacks: incentiveFeeClaimStats.sumAllClaims,
+      totalBuyBacksInLast24Hours: incentiveFeeClaimStats.sumClaimsInLast24Hours,
+    };
+  } catch (error) {
+    console.error("Failed to get SW Bera Vault Metadata", error);
+    throw error;
+  }
+}

package/src/actions/pol/getSWBeraWithdrawal.ts

@@ -0,0 +1,165 @@
+import type { Address, PublicClient } from "viem";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { getStakeWithdrawalCooldown } from "~/actions";
+import { formatTimeLeft, msToSeconds } from "~/utils";
+
+/**
+ * Calculates and returns formatted time remaining until a target date
+ * @param targetTime - Unix timestamp in seconds representing the target time
+ * @returns Formatted time string (e.g., "2h 30m") or undefined if time has passed
+ */
+function getTimeUntil(targetTime: number): string | undefined {
+  const currentTime = Date.now();
+  const timeDiff = targetTime * 1000 - currentTime;
+
+  // If time has already passed, return undefined
+  if (timeDiff <= 0) {
+    return;
+  }
+
+  // Convert milliseconds to seconds for formatTimeLeft function
+  const totalSeconds = msToSeconds(timeDiff);
+  return formatTimeLeft(totalSeconds, true, true);
+}
+
+/**
+ * Interface representing a staked BERA withdrawal request
+ */
+export interface StakedBeraWithdrawal {
+  withdrawalAmount?: bigint;
+  timeRemaining?: string;
+  withdrawalRequestId?: bigint;
+}
+
+/**
+ * Interface representing a withdrawal request for V1
+ */
+type WithdrawalRequestV1 = readonly [
+  bigint,
+  bigint,
+  bigint,
+  `0x${string}`,
+  `0x${string}`,
+];
+
+/**
+ * Retrieves staked BERA withdrawal information for a given account
+ *
+ * This function handles both V1 and V2 versions of the stake vault contract:
+ * - V1: Uses a single withdrawal request per account
+ * - V2: Uses ERC721 tokens to represent multiple withdrawal requests per account
+ *
+ * @param contractAddress - The address of the stake vault contract
+ * @param accountAddress - The address of the account to check withdrawals for
+ * @param publicClient - Viem public client for blockchain interactions
+ * @param version - The version of the stake vault contract ("V1" or "V2")
+ * @returns Promise resolving to an array of withdrawal request information
+ */
+export async function getSWBeraWithdrawal(
+  contractAddress: Address,
+  accountAddress: Address,
+  publicClient: PublicClient,
+  version: "V1" | "V2",
+): Promise<StakedBeraWithdrawal[]> {
+  const withdrawalRequests: StakedBeraWithdrawal[] = [];
+
+  function withdrawalRequestV1Helper(
+    withdrawalRequest: WithdrawalRequestV1,
+    lockPeriod: number,
+  ): void {
+    const [assets, _shares, timestamp] = withdrawalRequest;
+    const withdrawalAmount = assets;
+    const readyTime = Number(timestamp) + Number(lockPeriod);
+    const currentTime = msToSeconds(Date.now());
+    const timeLeft = readyTime - currentTime;
+    if (withdrawalAmount > 0) {
+      const timeRemaining = getTimeUntil(timeLeft <= 0 ? 0 : readyTime);
+      withdrawalRequests.push({
+        withdrawalAmount,
+        timeRemaining,
+      });
+    }
+  }
+
+  switch (version) {
+    case "V1": {
+      const [withdrawalRequest, lockPeriod] = await Promise.all([
+        publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi,
+          functionName: "withdrawalRequests" as const,
+          args: [accountAddress],
+        }),
+        getStakeWithdrawalCooldown({
+          publicClient,
+        }),
+      ]);
+      withdrawalRequestV1Helper(withdrawalRequest, lockPeriod);
+      return withdrawalRequests;
+    }
+    case "V2": {
+      const [withdrawalRequestV1, withdrawalRequestIds, lockPeriod] =
+        await Promise.all([
+          publicClient.readContract({
+            address: contractAddress,
+            abi: stakeBeraVaultAbi,
+            functionName: "withdrawalRequests" as const,
+            args: [accountAddress],
+          }),
+          publicClient.readContract({
+            address: contractAddress,
+            abi: stakeBeraVaultAbi,
+            functionName: "getERC721WithdrawalRequestIds" as const,
+            args: [accountAddress],
+          }),
+          getStakeWithdrawalCooldown({
+            publicClient,
+          }),
+        ]);
+      withdrawalRequestV1Helper(withdrawalRequestV1, lockPeriod);
+
+      // Process each withdrawal request ID to get detailed information
+      const withdrawalResults = await Promise.all(
+        withdrawalRequestIds.map(
+          async (withdrawalRequestId): Promise<StakedBeraWithdrawal | null> => {
+            const withdrawalRequest = await publicClient.readContract({
+              address: contractAddress,
+              abi: stakeBeraVaultAbi,
+              functionName: "getERC721WithdrawalRequest",
+              args: [withdrawalRequestId as bigint],
+            });
+
+            const { assets, requestTime: timestamp } = withdrawalRequest;
+            if (!assets || !timestamp)
+              throw new Error("Invalid withdrawal request");
+            const withdrawalAmount = assets;
+
+            // Calculate when this specific withdrawal will be ready
+            const readyTime = Number(timestamp) + Number(lockPeriod);
+            const currentTime = msToSeconds(Date.now());
+            const timeLeft = readyTime - currentTime;
+
+            // Only include withdrawal if there's an amount to withdraw
+            if (withdrawalAmount > 0) {
+              const timeRemaining = getTimeUntil(timeLeft <= 0 ? 0 : readyTime);
+              return {
+                withdrawalAmount,
+                timeRemaining,
+                withdrawalRequestId,
+              };
+            }
+            return null;
+          },
+        ),
+      );
+
+      // Filter out null results (withdrawals with no amount)
+      const filteredRequests = withdrawalResults.filter(
+        (request): request is StakedBeraWithdrawal => request !== null,
+      );
+      withdrawalRequests.push(...filteredRequests);
+      return withdrawalRequests;
+    }
+  }
+}

package/src/actions/pol/getStakeWithdrawalCooldown.ts

@@ -0,0 +1,21 @@
+import type { PublicClient } from "viem";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getStakeWithdrawalCooldown({
+  publicClient,
+  ...args
+}: {
+  publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<number> {
+  const { config } = parseBaseArgs(args);
+
+  const lockPeriod = await publicClient.readContract({
+    address: config.tokens.swbera,
+    abi: stakeBeraVaultAbi,
+    functionName: "WITHDRAWAL_COOLDOWN" as const,
+  });
+
+  return Number(lockPeriod);
+}

package/src/actions/pol/getStakedBeraAPR.ts

@@ -0,0 +1,56 @@
+import {
+  GetSWberaVaultMetadata,
+  type GetSWberaVaultMetadataQuery,
+  type GetSWberaVaultMetadataQueryVariables,
+  type GqlChain,
+  GqlSWberaVaultMetadataResolution,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+function getResolution(window: "DAY" | "WEEK") {
+  if (window === "DAY") {
+    return GqlSWberaVaultMetadataResolution.OneDay;
+  }
+  return GqlSWberaVaultMetadataResolution.SevenDays;
+}
+
+/**
+ *
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+export async function getStakedBeraAPR({
+  window,
+  ...args
+}: {
+  /**
+   * APR might vary depending on the annualized time window (day or week)
+   */
+  window: "DAY" | "WEEK";
+} & BeraJS.BaseFunctionArgs): Promise<number> {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  try {
+    const data = await bexApiGraphqlClient.query<
+      GetSWberaVaultMetadataQuery,
+      GetSWberaVaultMetadataQueryVariables
+    >({
+      query: GetSWberaVaultMetadata,
+      variables: {
+        chain: config.bex.chainName as GqlChain,
+        resolution: getResolution(window ?? "DAY"),
+      },
+    });
+
+    const { apr } = data.data.polGetSWberaVaultMetadata;
+
+    return Number(apr);
+  } catch (error) {
+    console.error("Failed to get SW Bera APR", error);
+    throw error;
+  }
+}

package/src/actions/pol/getStakedBeraSnapshots.ts

@@ -0,0 +1,48 @@
+import {
+  GetSWberaVaultSnapshots,
+  type GetSWberaVaultSnapshotsQuery,
+  type GetSWberaVaultSnapshotsQueryVariables,
+  type GqlChain,
+  GqlVaultSnapshotDataRange,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export type GetStakedBeraSnapshotsArgs = {
+  chain?: GqlChain;
+  range?: GqlVaultSnapshotDataRange;
+} & BeraJS.BaseFunctionArgs;
+
+/**
+ *
+ * @throws {Error} If the vault is not found
+ * @returns
+ */
+export async function getStakedBeraSnapshots({
+  chain,
+  range = GqlVaultSnapshotDataRange.ThirtyDays,
+  ...args
+}: GetStakedBeraSnapshotsArgs = {}): Promise<
+  GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]
+> {
+  const { config } = parseBaseArgs(args);
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  try {
+    const data = await bexApiGraphqlClient.query<
+      GetSWberaVaultSnapshotsQuery,
+      GetSWberaVaultSnapshotsQueryVariables
+    >({
+      query: GetSWberaVaultSnapshots,
+      variables: {
+        chain: chain ?? (config.bex.chainName as GqlChain),
+        range,
+      },
+    });
+
+    return data.data.polGetSWberaVaultSnapshots;
+  } catch (error) {
+    console.error("Failed to get SW Bera Snapshots", error);
+    throw error;
+  }
+}