@berachain/berajs 0.1.1 → 0.2.0

package/src/actions/pol/__tests__/getValidator.integration.test.ts

@@ -0,0 +1,32 @@
+import { keccak256 } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { getApiValidator } from "../../validators/getApiValidator";
+import { getRewardVault } from "../getRewardVault";
+
+describe.todo("getValidator", async () => {
+  const { validator } = await getApiValidator({
+    id: keccak256(
+      // Manticore
+      "0x89c8b925d5d0e4233df6db338efc41a2529b31da77e088b03087ce9cd6f7f61552a806fdeced8d7a51ec5c6b4827e387",
+    ),
+  });
+
+  it.todo("should have a cutting board for usdt honey vault", async () => {
+    const usdtHoneyVault = await getRewardVault({
+      address: "0x0cc03066a3a06f3ac68d3a0d36610f52f7c20877",
+    });
+    const cuttingBoardItem = validator?.rewardAllocationWeights.find(
+      (cb) =>
+        cb.receiver.toLowerCase() === usdtHoneyVault.address.toLowerCase(),
+    );
+
+    const cuttingBoardWeightPercentage = cuttingBoardItem?.percentage ?? 0;
+
+    // const _perProposal =
+    //   cuttingBoardWeightPercentage *
+    //   Number.parseFloat(validator?.dynamicData?.rewardRate ?? "0");
+
+    expect(cuttingBoardWeightPercentage).toBeDefined();
+  });
+});

package/src/actions/pol/__tests__/rewardVaults.integration.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+
+import { getRewardVaults } from "~/actions/pol/getRewardVaults";
+
+describe("rewardVaults", async () => {
+  const result = await getRewardVaults({
+    filter: {
+      pageSize: 1000,
+      where: {
+        includeNonWhitelisted: false,
+      },
+    },
+  });
+
+  if (!result) {
+    throw new Error("Failed to fetch vaults");
+  }
+
+  const { gaugeList } = result;
+
+  it("should return vaults", () => {
+    expect(gaugeList.length).toBeGreaterThan(0);
+  });
+
+  it("should have consistent data", () => {
+    const totalBgtCatpure = gaugeList.reduce(
+      (acc, vault) =>
+        acc + Number(vault.dynamicData?.bgtCapturePercentage ?? 0),
+      0,
+    );
+
+    expect(totalBgtCatpure).toBeCloseTo(1, 9);
+  });
+});

package/src/actions/pol/getBGTGlobalInfo.ts

@@ -0,0 +1,43 @@
+import type { GqlChain } from "@berachain/graphql/dex/api";
+import {
+  GlobalData,
+  type GlobalDataQuery,
+  type GlobalDataQueryVariables,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+type ReturnedFromQuery = GlobalDataQuery["polGetGlobalInfo"] & {
+  top3EmittingValidators: GlobalDataQuery["top3EmittingValidators"]["validators"];
+  allValidatorsCount: number;
+};
+
+export interface GlobalInfo extends Partial<ReturnedFromQuery> {}
+
+export async function getBGTGlobalInfo(
+  args: BeraJS.BaseFunctionArgs = {},
+): Promise<GlobalInfo> {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const apiRes = await bexApiGraphqlClient.query<
+    GlobalDataQuery,
+    GlobalDataQueryVariables
+  >({
+    query: GlobalData,
+    variables: {
+      chain: config.bex.chainName as GqlChain,
+    },
+  });
+
+  const data = apiRes.data;
+
+  // allValidatorCount include inactive validators for the purpose of ranking
+  return {
+    ...data.polGetGlobalInfo,
+    top3EmittingValidators: apiRes.data.top3EmittingValidators.validators,
+    allValidatorsCount: apiRes.data.allValidatorsCount.pagination.totalCount,
+  } satisfies GlobalInfo;
+}

package/src/actions/pol/getBgtAprSimulation.ts

@@ -0,0 +1,207 @@
+import { msToSeconds, yearsInSeconds } from "~/utils/time";
+import { RewardVaultDistributionMode } from "./getRewardVaultRewards";
+
+export type GetBgtAprSimulationArgs = {
+  /**
+   * Staked TVL of the vault in USD.
+   *
+   * Null if not available
+   */
+  tvl: number | null;
+
+  /**
+   * Price of BGT in USD
+   */
+  bgtPrice: number;
+
+  /**
+   * Undistributed BGT rewards
+   */
+  availableRewards: number;
+
+  /**
+   * Finish period of the reward distribution in seconds
+   */
+  periodFinish: number;
+
+  /**
+   * Current duration of the reward distribution in seconds. This will be used if the reward rate is 0.
+   *
+   */
+  currentDuration: number;
+
+  /**
+   * Maximum reward duration in seconds
+   */
+  MAX_REWARD_DURATION: number;
+
+  /**
+   * Minimum reward duration in seconds
+   */
+  MIN_REWARD_DURATION: number;
+} & (
+  | {
+      /**
+       *
+       */
+      mode: RewardVaultDistributionMode.TargetApr;
+      apr: number;
+      /**
+       * Minimum reward duration for the target rate
+       */
+      minRewardDurationForTargetRate: number;
+    }
+  | {
+      /**
+       *
+       */
+      mode: RewardVaultDistributionMode.TargetRate;
+      rewardRate: number;
+      /**
+       * Minimum reward duration for the target rate
+       */
+      minRewardDurationForTargetRate: number;
+    }
+  | {
+      /**
+       *
+       */
+      mode: RewardVaultDistributionMode.Duration;
+      /**
+       * Duration of the reward distribution in seconds
+       */
+      duration: number;
+      rewardRate?: never;
+      /**
+       * Must be between MIN_REWARD_DURATION and MAX_REWARD_DURATION
+       */
+      minRewardDurationForTargetRate?: never;
+    }
+);
+
+export type GetBgtAprSimulationResult = {
+  apr: number | null;
+  duration: number;
+  rewardRate: number;
+  periodFinish: number;
+  /**
+   * It's the input target rate for the target rate mode.
+   *
+   * If input was target apr, it will be the calculated reward rate.
+   *
+   * If input was duration, it will be null.
+   */
+  targetRate: string | null;
+  /**
+   * If the mode is changed, this will be the new mode. Null otherwise.
+   */
+  mode: RewardVaultDistributionMode | null;
+};
+
+function _getApr(tvl: number | null, bgtPrice: number, rewardRate: number) {
+  // If TVL is null, there is no price for staking, so we return null
+  // Also if it's falsy, we return null as well
+  return tvl ? (rewardRate * bgtPrice * yearsInSeconds(1)) / tvl : null;
+}
+
+function _getRewardRate(apr: number, bgtPrice: number, tvl: number | null) {
+  return tvl ? (apr * tvl) / (bgtPrice * yearsInSeconds(1)) : 0;
+}
+
+export function getBgtAprSimulation({
+  availableRewards,
+  periodFinish,
+  tvl,
+  bgtPrice,
+  MIN_REWARD_DURATION,
+  MAX_REWARD_DURATION,
+  ...args
+}: GetBgtAprSimulationArgs): GetBgtAprSimulationResult {
+  const currentTime = msToSeconds(Date.now());
+
+  if (currentTime > periodFinish) {
+    return {
+      apr: 0,
+      duration: 0,
+      rewardRate: 0,
+      targetRate: null,
+      periodFinish: 0,
+      mode: null,
+    };
+  }
+
+  if (args.mode === "targetRate" || args.mode === "targetApr") {
+    let rewardRate: number;
+    const {
+      minRewardDurationForTargetRate: _providedMinRewardDurationForTargetRate,
+      currentDuration,
+    } = args;
+
+    if (args.mode === "targetRate") {
+      rewardRate = args.rewardRate;
+    } else {
+      rewardRate = _getRewardRate(args.apr, bgtPrice, tvl);
+    }
+
+    if (rewardRate === 0) {
+      const newDuration = Math.min(currentDuration, MAX_REWARD_DURATION);
+      const rewardRate = availableRewards ? availableRewards / newDuration : 0;
+
+      return {
+        apr: _getApr(tvl, bgtPrice, rewardRate),
+        // When switching to duration mode, the current duration will be used if it's in the allowed range.
+        // Current duration on chain can never be lower than MIN_REWARD_DURATION, so we just check the max.
+        duration: newDuration,
+        rewardRate,
+        targetRate: null,
+        periodFinish: newDuration + currentTime,
+        mode: RewardVaultDistributionMode.Duration,
+      };
+    }
+
+    const minRewardDurationForTargetRate =
+      // minRewardDurationForTargetRate might be zero the first time the target rate is set.
+      // If it's not set, we use the max reward duration.
+      _providedMinRewardDurationForTargetRate || MIN_REWARD_DURATION;
+
+    const duration = availableRewards ? availableRewards / rewardRate : 0;
+
+    if (duration < minRewardDurationForTargetRate) {
+      const rewardRate = availableRewards
+        ? availableRewards / minRewardDurationForTargetRate
+        : 0;
+      return {
+        apr: _getApr(tvl, bgtPrice, rewardRate),
+        duration: minRewardDurationForTargetRate,
+        rewardRate,
+        targetRate: rewardRate.toString(),
+        periodFinish: minRewardDurationForTargetRate + currentTime,
+        mode: null,
+      };
+    }
+
+    return {
+      apr: _getApr(tvl, bgtPrice, rewardRate),
+      duration: duration,
+      rewardRate,
+      targetRate: rewardRate.toString(),
+      periodFinish: duration + currentTime,
+      mode: null,
+    };
+  }
+
+  const { duration } = args;
+
+  const newRewardRate = availableRewards / duration;
+
+  const apr = _getApr(tvl, bgtPrice, newRewardRate);
+
+  return {
+    apr,
+    mode: null,
+    targetRate: null,
+    duration,
+    rewardRate: newRewardRate,
+    periodFinish: duration + currentTime,
+  };
+}

package/src/actions/pol/getBgtAprSimultaion.unit.test.ts

@@ -0,0 +1,297 @@
+import { describe, expect, it } from "vitest";
+
+import { daysInSeconds, msToSeconds, yearsInSeconds } from "~/utils/time";
+import {
+  type GetBgtAprSimulationArgs,
+  getBgtAprSimulation,
+} from "./getBgtAprSimulation";
+import { RewardVaultDistributionMode } from "./getRewardVaultRewards";
+
+describe("getBgtAprSimulation", () => {
+  const MIN_REWARD_DURATION = daysInSeconds(3);
+  const MAX_REWARD_DURATION = daysInSeconds(7);
+
+  it("should return the correct apr for target rate", () => {
+    /*
+     * In a day, we distribute 1 BGT per second
+     */
+    const supposedRewards = daysInSeconds(1);
+    const supposedDuration = daysInSeconds(3);
+
+    const bgtPrice = 1; // 1 USD
+    const supposedTvl = 1; // 1 USD
+
+    const thisMoment = msToSeconds(Date.now());
+
+    const newRewardRate = supposedRewards / supposedDuration;
+    const expectedApr =
+      (newRewardRate * bgtPrice * yearsInSeconds(1)) / supposedTvl;
+
+    // This is just to make sure that the mock data are legit
+    expect(supposedDuration).toBeGreaterThanOrEqual(MIN_REWARD_DURATION);
+    expect(expectedApr).toBeCloseTo(yearsInSeconds(1 / 3) / supposedTvl);
+
+    const sharedArgs = {
+      tvl: supposedTvl,
+      bgtPrice,
+      availableRewards: supposedRewards,
+      periodFinish: thisMoment + supposedDuration,
+    } as const;
+
+    const targetRateArgs: GetBgtAprSimulationArgs = {
+      ...sharedArgs,
+      currentDuration: daysInSeconds(3),
+      mode: RewardVaultDistributionMode.TargetRate,
+      rewardRate: newRewardRate,
+      minRewardDurationForTargetRate: daysInSeconds(3),
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    };
+
+    const result = getBgtAprSimulation(targetRateArgs);
+
+    expect(result.apr).toBe(expectedApr);
+
+    const result2 = getBgtAprSimulation({
+      ...targetRateArgs,
+      bgtPrice: bgtPrice * 2,
+    });
+
+    expect(result2.duration).toBe(supposedDuration);
+    expect(result2.apr).not.toBeNull();
+    expect(result2.apr).toBe(result.apr! * 2);
+    expect(result2.rewardRate).toBe(result.rewardRate);
+
+    // Test for tvl
+    const result3 = getBgtAprSimulation({
+      ...targetRateArgs,
+      tvl: supposedTvl * 2,
+    });
+
+    expect(result3.apr).not.toBeNull();
+    expect(result3.apr).toBe(result.apr! / 2);
+    expect(result3.duration).toBe(supposedDuration);
+    expect(result3.rewardRate).toBe(result.rewardRate);
+
+    const result4 = getBgtAprSimulation({
+      ...targetRateArgs,
+      rewardRate: newRewardRate / 2,
+    });
+
+    expect(result4.apr).not.toBeNull();
+    expect(result4.apr).toBe(result.apr! / 2);
+    expect(result4.duration).toBe(supposedDuration * 2);
+    expect(result4.rewardRate).toBe(result.rewardRate / 2);
+  });
+
+  it("should return the correct apr for duration", () => {
+    /*
+     * In a day, we distribute 1 BGT per second
+     */
+    const supposedRewards = daysInSeconds(1);
+    const newDuration = daysInSeconds(1);
+
+    const bgtPrice = 1; // 1 USD
+    const supposedTvl = 1; // 1 USD
+
+    const thisMoment = msToSeconds(Date.now());
+
+    const expectedRewardRate = supposedRewards / newDuration;
+    const expectedApr =
+      (expectedRewardRate * bgtPrice * yearsInSeconds(1)) / supposedTvl;
+
+    const sharedArgs = {
+      tvl: supposedTvl,
+      bgtPrice,
+      availableRewards: supposedRewards,
+      periodFinish: thisMoment + newDuration,
+    } as const;
+
+    const durationArgs: GetBgtAprSimulationArgs = {
+      ...sharedArgs,
+      currentDuration: daysInSeconds(3),
+      mode: RewardVaultDistributionMode.Duration,
+      duration: newDuration,
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    };
+
+    const result = getBgtAprSimulation(durationArgs);
+
+    expect(result.apr).toBe(expectedApr);
+    expect(result.rewardRate).toBe(expectedRewardRate);
+    expect(result.duration).toBe(newDuration);
+    expect(result.periodFinish).toBe(thisMoment + newDuration);
+    expect(result.mode).toBeNull();
+
+    const result2 = getBgtAprSimulation({
+      ...durationArgs,
+      bgtPrice: bgtPrice * 2,
+    });
+
+    expect(result2.apr).not.toBeNull();
+    expect(result2.apr).toBe(result.apr! * 2);
+    expect(result2.rewardRate).toBe(result.rewardRate);
+    expect(result2.mode).toBeNull();
+    expect(result2.duration).toBe(newDuration);
+    expect(result2.periodFinish).toBe(thisMoment + newDuration);
+
+    const result3 = getBgtAprSimulation({
+      ...durationArgs,
+      tvl: supposedTvl * 2,
+    });
+
+    expect(result3.apr).not.toBeNull();
+    expect(result3.apr).toBe(result.apr! / 2);
+    expect(result3.rewardRate).toBe(result.rewardRate);
+    expect(result3.duration).toBe(newDuration);
+    expect(result3.mode).toBeNull();
+    expect(result3.periodFinish).toBe(thisMoment + newDuration);
+
+    const result4 = getBgtAprSimulation({
+      ...durationArgs,
+      duration: newDuration * 2,
+    });
+
+    expect(result4.apr).not.toBeNull();
+    expect(result4.apr).toBe(result.apr! / 2);
+    expect(result4.rewardRate).toBe(result.rewardRate / 2);
+    expect(result4.duration).toBe(newDuration * 2);
+    expect(result4.mode).toBeNull();
+    expect(result4.periodFinish).toBe(thisMoment + newDuration * 2);
+  });
+
+  it("should return 0 apr if the finish period is in the past", () => {
+    const args = {
+      tvl: 1,
+      bgtPrice: 1,
+      currentDuration: daysInSeconds(4),
+      availableRewards: daysInSeconds(1),
+      periodFinish: msToSeconds(Date.now()) - 1,
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    } as const;
+
+    const result = getBgtAprSimulation({
+      ...args,
+      mode: RewardVaultDistributionMode.Duration,
+      duration: daysInSeconds(1),
+    });
+
+    expect(result.apr).toBe(0);
+    expect(result.rewardRate).toBe(0);
+    expect(result.duration).toBe(0);
+    expect(result.mode).toBeNull();
+    expect(result.periodFinish).toBe(result.periodFinish);
+
+    const result2 = getBgtAprSimulation({
+      ...args,
+      minRewardDurationForTargetRate: daysInSeconds(3),
+      mode: RewardVaultDistributionMode.TargetRate,
+      rewardRate: daysInSeconds(1),
+    });
+    expect(result2.apr).toBe(0);
+    expect(result2.rewardRate).toBe(0);
+    expect(result.mode).toBeNull();
+    expect(result2.duration).toBe(0);
+    expect(result2.periodFinish).toBe(result2.periodFinish);
+  });
+
+  it("should handle 0 as a reward rate", () => {
+    const args: GetBgtAprSimulationArgs = {
+      tvl: 1,
+      bgtPrice: 1,
+      availableRewards: daysInSeconds(1),
+      periodFinish: msToSeconds(Date.now()) + daysInSeconds(1),
+      mode: RewardVaultDistributionMode.TargetRate,
+      rewardRate: 0,
+      currentDuration: daysInSeconds(3),
+      minRewardDurationForTargetRate: daysInSeconds(3),
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    };
+
+    const result = getBgtAprSimulation(args);
+    expect(result.periodFinish).toBe(
+      args.currentDuration + msToSeconds(Date.now()),
+    );
+    expect(result.mode).not.toBe(args.mode);
+  });
+
+  it("should return the correct apr for target APR", () => {
+    const targetApr = 1.0; // 100% APR
+    const bgtPrice = 1;
+    const tvl = 1;
+    const availableRewards = daysInSeconds(1);
+    const thisMoment = msToSeconds(Date.now());
+
+    const expectedRewardRate =
+      (targetApr * tvl) / (bgtPrice * yearsInSeconds(1));
+
+    const result = getBgtAprSimulation({
+      tvl,
+      bgtPrice,
+      availableRewards,
+      periodFinish: thisMoment + daysInSeconds(5),
+      currentDuration: daysInSeconds(3),
+      mode: RewardVaultDistributionMode.TargetApr,
+      apr: targetApr,
+      minRewardDurationForTargetRate: daysInSeconds(3),
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    });
+
+    expect(result.apr).toBe(targetApr);
+    expect(result.rewardRate).toBeCloseTo(expectedRewardRate);
+    expect(result.duration).toBe(availableRewards / expectedRewardRate);
+    expect(result.mode).toBeNull();
+  });
+
+  it("should handle target APR with minimum duration constraint", () => {
+    const targetApr = 10.0; // High APR requiring short duration
+    const minDuration = daysInSeconds(3);
+    const availableRewards = daysInSeconds(1);
+
+    const result = getBgtAprSimulation({
+      tvl: 1,
+      bgtPrice: 1,
+      availableRewards,
+      periodFinish: msToSeconds(Date.now()) + daysInSeconds(5),
+      currentDuration: daysInSeconds(3),
+      mode: RewardVaultDistributionMode.TargetApr,
+      apr: targetApr,
+      minRewardDurationForTargetRate: minDuration,
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    });
+
+    expect(result.duration).toBeGreaterThan(minDuration);
+    expect(result.rewardRate).toBeLessThan(availableRewards / minDuration);
+    expect(result.apr).toBe(targetApr);
+    expect(result.mode).toBeNull();
+  });
+
+  it("should fallback to duration mode when target APR is zero", () => {
+    const currentDuration = daysInSeconds(3);
+    const availableRewards = daysInSeconds(1);
+
+    const result = getBgtAprSimulation({
+      tvl: 1,
+      bgtPrice: 1,
+      availableRewards,
+      periodFinish: msToSeconds(Date.now()) + daysInSeconds(5),
+      currentDuration,
+      mode: RewardVaultDistributionMode.TargetApr,
+      apr: 0,
+      minRewardDurationForTargetRate: daysInSeconds(3),
+      MAX_REWARD_DURATION,
+      MIN_REWARD_DURATION,
+    });
+
+    expect(result.mode).toBe(RewardVaultDistributionMode.Duration);
+    expect(result.duration).toBe(
+      Math.min(currentDuration, MAX_REWARD_DURATION),
+    );
+    expect(result.rewardRate).toBe(availableRewards / result.duration);
+  });
+});

package/src/actions/pol/getBgtTokenTotalBoosts.ts

@@ -0,0 +1,30 @@
+import { formatEther, type PublicClient } from "viem";
+
+import { bgtAbi } from "~/abi/pol/bgt";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export interface GetBgtTokenTotalBoosts extends BeraJS.BaseFunctionArgs {
+  publicClient: PublicClient | undefined;
+}
+
+export async function getBgtTokenTotalBoosts({
+  publicClient,
+  ...args
+}: GetBgtTokenTotalBoosts): Promise<string> {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "totalBoosts",
+      args: [],
+    });
+    return formatEther(result);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}

package/src/actions/pol/getBgtTokenTotalSupply.ts

@@ -0,0 +1,29 @@
+import { erc20Abi, formatEther, type PublicClient } from "viem";
+
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export interface GetBgtTokenTotalSupply extends BeraJS.BaseFunctionArgs {
+  publicClient: PublicClient | undefined;
+}
+
+export async function getBgtTokenTotalSupply({
+  publicClient,
+  ...args
+}: GetBgtTokenTotalSupply): Promise<string> {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+
+  try {
+    const result = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: erc20Abi,
+      functionName: "totalSupply",
+      args: [],
+    });
+    return formatEther(result ?? 0n);
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}