@berachain/berajs 0.1.1 → 0.1.2

package/src/actions/validators/getActiveBoostAndCommissionChangeDelay.integration.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getActiveBoostAndCommissionChangeDelay } from "./getActiveBoostAndCommissionChangeDelay";
+
+describe("getActiveBoostAndCommissionChangeDelay", () => {
+  const publicClient = getServerSidePublicClient();
+
+  it("should return the active boost and commission change delay", async () => {
+    const delay = await getActiveBoostAndCommissionChangeDelay({
+      publicClient: publicClient,
+      ui: {
+        blockDelayLabel: "a week",
+        hoursToWarnInAdvance: 24,
+      },
+    });
+
+    expect(delay).toBeDefined();
+
+    expect(delay.maxCommissionRate).toBeTypeOf("number");
+    expect(delay.maxCommissionRate).toBeGreaterThan(0);
+    expect(delay.maxCommissionRate).toBeLessThanOrEqual(1);
+
+    expect(delay.boostDelay).toBeTypeOf("number");
+    expect(delay.boostDelay).toBeGreaterThanOrEqual(0);
+
+    expect(delay.unboostDelay).toBeTypeOf("number");
+    expect(delay.unboostDelay).toBeGreaterThanOrEqual(0);
+
+    expect(delay.commissionChangeDelay).toBeTypeOf("number");
+    expect(delay.commissionChangeDelay).toBeGreaterThanOrEqual(0);
+
+    expect(delay.rewardAllocationBlockDelay).toBeTypeOf("number");
+    expect(delay.rewardAllocationBlockDelay).toBeGreaterThanOrEqual(0);
+
+    expect(delay.maxWeightPerVault).toBeTypeOf("number");
+    expect(delay.maxWeightPerVault).toBeGreaterThan(0);
+    expect(delay.maxWeightPerVault).toBeLessThanOrEqual(1);
+  });
+});

package/src/actions/validators/getActiveBoostAndCommissionChangeDelay.ts

@@ -0,0 +1,109 @@
+import type { PublicClient } from "viem";
+
+import type { EdgeConfigSchema } from "@berachain/config/internal/edge-config";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { bgtAbi } from "~/abi/pol/bgt";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export interface ActiveBoostAndCommissionChangeDelay {
+  boostDelay: number;
+  unboostDelay: number;
+  commissionChangeDelay: number;
+  rewardAllocationBlockDelay: number;
+  maxWeightPerVault: number;
+  maxNumWeightsPerRewardAllocation: number;
+  /**
+   * Percentage of the validator's commission rate that can be changed at once.
+   *
+   * @example 1 => 100%
+   */
+  maxCommissionRate: number;
+  /**
+   * The number of blocks after which a reward allocation is considered stale and will fallback
+   * to baseline reward allocation.
+   *
+   */
+  rewardAllocationInactivityBlockSpan: number;
+  /**
+   * The number of hours in advance to warn the operator that the reward allocation is expiring.
+   */
+  ui: EdgeConfigSchema["pol"]["automatedRewardAllocation"];
+}
+
+export async function getActiveBoostAndCommissionChangeDelay({
+  publicClient,
+  ui,
+  ...args
+}: BeraJS.BaseFunctionArgs &
+  Pick<ActiveBoostAndCommissionChangeDelay, "ui"> & {
+    publicClient: PublicClient;
+  }): Promise<ActiveBoostAndCommissionChangeDelay> {
+  const { config } = parseBaseArgs(args);
+
+  const [
+    maxCommissionRate,
+    commissionChangeDelay,
+    rewardAllocationBlockDelay,
+    maxWeightPerVault,
+    maxNumWeightsPerRewardAllocation,
+    dropBoostDelay,
+    activateBoostDelay,
+    rewardAllocationInactivityBlockSpan,
+  ] = await Promise.all([
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "MAX_COMMISSION_RATE",
+    }),
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "commissionChangeDelay",
+    }),
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "rewardAllocationBlockDelay",
+    }),
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "maxWeightPerVault",
+    }),
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "maxNumWeightsPerRewardAllocation",
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "dropBoostDelay",
+    }),
+    publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "activateBoostDelay",
+    }),
+    publicClient.readContract({
+      address: config.pol.beraChef,
+      abi: beraChefAbi,
+      functionName: "rewardAllocationInactivityBlockSpan",
+    }),
+  ]);
+
+  return {
+    maxCommissionRate: Number(maxCommissionRate) / 1e4,
+    boostDelay: Number(activateBoostDelay),
+    unboostDelay: Number(dropBoostDelay),
+    commissionChangeDelay: Number(commissionChangeDelay),
+    rewardAllocationBlockDelay: Number(rewardAllocationBlockDelay),
+    maxWeightPerVault: Number(maxWeightPerVault) / 1e4,
+    maxNumWeightsPerRewardAllocation: Number(maxNumWeightsPerRewardAllocation),
+    rewardAllocationInactivityBlockSpan: Number(
+      rewardAllocationInactivityBlockSpan,
+    ),
+    ui,
+  };
+}

package/src/actions/validators/getAllValidators.ts

@@ -0,0 +1,33 @@
+import {
+  GetValidators,
+  type GetValidatorsQuery,
+  type GetValidatorsQueryVariables,
+  type GqlChain,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getAllValidators({
+  variables = {},
+  ...args
+}: {
+  variables?: GetValidatorsQueryVariables;
+} & BeraJS.BaseFunctionArgs = {}): Promise<GetValidatorsQuery | undefined> {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const result = await bexApiGraphqlClient.query<
+    GetValidatorsQuery,
+    GetValidatorsQueryVariables
+  >({
+    query: GetValidators,
+    variables: {
+      chain: config.bex.chainName as GqlChain,
+      ...variables,
+    },
+  });
+
+  return result.data;
+}

package/src/actions/validators/getApiEnrichedAllocation.ts

@@ -0,0 +1,33 @@
+import { isAddressEqual } from "viem";
+
+import type { ApiRewardAllocationWeightFragment } from "@berachain/graphql/pol/api";
+
+import { getRewardVaults } from "../pol/getRewardVaults";
+import type { ValidatorRewardAllocation } from "./getValidatorRewardAllocation";
+
+export async function getApiEnrichedAllocation({
+  allocation,
+}: {
+  allocation: ValidatorRewardAllocation;
+}) {
+  const vaults = await getRewardVaults({
+    filter: {
+      where: {
+        vaultAddressIn: allocation.weights.map((weight) => weight.receiver),
+      },
+    },
+  });
+  const startBlock = allocation?.start.blockNumber ?? 0;
+  return allocation?.weights.map<ApiRewardAllocationWeightFragment>(
+    (allocation) => {
+      return {
+        percentage: allocation.percentage,
+        receiver: allocation.receiver,
+        startBlock,
+        receivingVault: vaults?.gaugeList.find((vault) =>
+          isAddressEqual(vault.address, allocation.receiver),
+        ),
+      };
+    },
+  );
+}

package/src/actions/validators/getApiValidator.ts

@@ -0,0 +1,38 @@
+import type { Address } from "viem";
+
+import {
+  GetValidator,
+  type GetValidatorQuery,
+  type GetValidatorQueryVariables,
+  type GqlChain,
+} from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getApiValidator({
+  id,
+  ...args
+}: {
+  /**
+   * The validator keccak256 pubkey
+   */
+  id: Address;
+} & BeraJS.BaseFunctionArgs): Promise<GetValidatorQuery> {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const results = await bexApiGraphqlClient.query<
+    GetValidatorQuery,
+    GetValidatorQueryVariables
+  >({
+    query: GetValidator,
+    variables: {
+      id,
+      chain: config.bex.chainName as GqlChain,
+    },
+  });
+
+  return results.data;
+}

package/src/actions/validators/getBaselineRewardAllocation.ts

@@ -0,0 +1,26 @@
+import type { PublicClient } from "viem";
+
+import { rewardAllocationFactoryAbi } from "~/abi/pol/rewardAllocationFactory";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { formatValidatorRewardAllocation } from "./getValidatorRewardAllocation";
+
+export async function getBaselineRewardAllocation({
+  publicClient,
+  ...args
+}: BeraJS.BaseFunctionArgs & { publicClient: PublicClient }) {
+  const { config } = parseBaseArgs(args);
+
+  const raw = await publicClient.readContract({
+    abi: rewardAllocationFactoryAbi,
+    address: config.pol.rewardAllocationFactory,
+    functionName: "getBaselineAllocation",
+  });
+  const block =
+    raw.startBlock !== 0n
+      ? await publicClient.getBlock({
+          blockNumber: raw.startBlock,
+        })
+      : { timestamp: 0 };
+
+  return formatValidatorRewardAllocation(raw, Number(block.timestamp));
+}

package/src/actions/validators/getDailyValidatorBlockStats.ts

@@ -0,0 +1,37 @@
+import type { Address } from "viem";
+
+import {
+  GetValidatorBlockStats,
+  type GetValidatorBlockStatsQuery,
+  type GetValidatorBlockStatsQueryVariables,
+} from "@berachain/graphql/pol/subgraph";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export async function getDailyValidatorBlockStats({
+  pubKey,
+  first = 1,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  pubKey: Address;
+  first?: number;
+}): Promise<GetValidatorBlockStatsQuery | undefined> {
+  const bgtClient = getApolloClient("pol.subgraph", args);
+  try {
+    const result = await bgtClient.query<
+      GetValidatorBlockStatsQuery,
+      GetValidatorBlockStatsQueryVariables
+    >({
+      query: GetValidatorBlockStats,
+      variables: {
+        pubKey,
+        first,
+      },
+    });
+
+    return result.data;
+  } catch (e) {
+    console.error("GetValidatorBlockStats:", e);
+    throw e;
+  }
+}

package/src/actions/validators/getDefaultRewardAllocation.ts

@@ -0,0 +1,39 @@
+import type { PublicClient } from "viem";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import {
+  formatValidatorRewardAllocation,
+  type ValidatorRewardAllocation,
+} from "./getValidatorRewardAllocation";
+
+export function isDefaultRewardAllocation(
+  rewardAllocation: ValidatorRewardAllocation,
+): boolean {
+  return rewardAllocation.start.blockNumber === 0;
+}
+
+export async function getDefaultRewardAllocation({
+  client,
+  ...args
+}: {
+  client: PublicClient;
+}): Promise<ValidatorRewardAllocation> {
+  const { config } = parseBaseArgs(args);
+
+  const rawDefaultRewardAllocation = await client.readContract({
+    address: config.pol.beraChef,
+    abi: beraChefAbi,
+    functionName: "getDefaultRewardAllocation",
+    args: [],
+  });
+
+  // Default reward allocation is active as soon as it's set by governance.
+  // Since startBlock is not validated and might be anything set in the payload
+  // (but it has no effect), we force it to 0 to avoid any confusion.
+  // this might change if smart contract is updated to validate startBlock.
+  return formatValidatorRewardAllocation(
+    { ...rawDefaultRewardAllocation, startBlock: 0n },
+    0,
+  );
+}

package/src/actions/validators/getManagedValidatorByAccount.ts

@@ -0,0 +1,32 @@
+import type { Address } from "viem";
+
+import {
+  GetValidatorByAccount,
+  type GetValidatorByAccountQuery,
+  type GetValidatorByAccountQueryVariables,
+} from "@berachain/graphql/pol/subgraph";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export async function getManagedValidatorByAccount({
+  account,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  account: Address;
+}): Promise<GetValidatorByAccountQuery | undefined> {
+  try {
+    const bgtClient = getApolloClient("pol.subgraph", args);
+    const result = await bgtClient.query<
+      GetValidatorByAccountQuery,
+      GetValidatorByAccountQueryVariables
+    >({
+      query: GetValidatorByAccount,
+      variables: { account },
+    });
+
+    return result.data;
+  } catch (e) {
+    console.error("getManagedValidatorByAccount:", e);
+    throw e;
+  }
+}

package/src/actions/validators/getStakingPoolBatch.ts

@@ -0,0 +1,20 @@
+import type { PublicClient } from "viem";
+
+/**
+ * Get the current number of BERA in the batch for a validator's staking pool
+ * The batch can contain at most 10K BERA, then the batch will be sent to the contract
+ * @param client - The public client
+ * @param valPubKey - The public key of the validator
+ * @returns The current batch number
+ */
+export async function getStakingPoolBatch({
+  client,
+  valPubKey,
+}: {
+  client: PublicClient;
+  valPubKey: `0x${string}`;
+}) {
+  // [TODO] Implement this
+  // probably going to be a contract call or better a query to read the subgraph
+  return 5614;
+}

package/src/actions/validators/getUserActiveValidators.ts

@@ -0,0 +1,101 @@
+import type { GetPublicClientReturnType } from "@wagmi/core";
+import type { Address } from "viem";
+
+import type {
+  ApiValidatorFragment,
+  GqlChain,
+} from "@berachain/graphql/pol/api";
+
+import { isSubgraphStale } from "~/utils/isSubgraphStale";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getAllValidators } from "./getAllValidators";
+import { getUserBoosts } from "./getUserBoosts";
+import {
+  getUserBoostsOnValidator,
+  type UserBoostsOnValidator,
+} from "./getUserBoostsOnValidator";
+
+export type ValidatorWithUserBoost = ApiValidatorFragment & {
+  userBoosts: UserBoostsOnValidator;
+};
+
+export async function getUserActiveValidators({
+  account,
+  publicClient,
+  chain,
+  ...args
+}: {
+  account: string;
+  publicClient?: GetPublicClientReturnType;
+  chain?: GqlChain;
+} & BeraJS.BaseFunctionArgs): Promise<ValidatorWithUserBoost[] | undefined> {
+  const { config } = parseBaseArgs(args);
+  const resolvedChain = chain ?? (config.bex.chainName as GqlChain);
+
+  const userBoosts = await getUserBoosts({ account });
+
+  const [validatorInfoList, onChainBoosts] = await Promise.all([
+    getAllValidators({
+      variables: {
+        chain: resolvedChain,
+        where: {
+          idIn: userBoosts.data.userValidatorInformations.map(
+            (t) => t.validator.id,
+          ),
+        },
+      },
+    }),
+    publicClient &&
+    isSubgraphStale({
+      lastBlockTimestamp: userBoosts.data._meta?.block.timestamp,
+      blockTime: config.averageBlockTime,
+    })
+      ? Promise.all(
+          userBoosts.data.userValidatorInformations.map((t) =>
+            getUserBoostsOnValidator({
+              account: account as Address,
+              pubkey: t.validator.publicKey,
+              publicClient: publicClient,
+            }),
+          ),
+        )
+      : undefined,
+  ]);
+
+  return validatorInfoList?.validators.validators.map((validator) => {
+    const userDeposited = onChainBoosts
+      ? onChainBoosts.find(
+          (data) =>
+            data.pubkey.toLowerCase() === validator.pubkey.toLowerCase(),
+        )
+      : userBoosts.data.userValidatorInformations.find(
+          (data) =>
+            data.validator.id.toLowerCase() === validator.id.toLowerCase(),
+        );
+
+    if (!userDeposited) {
+      throw new Error("User deposited not found");
+    }
+
+    return {
+      ...validator,
+      userBoosts: {
+        pubkey:
+          "pubkey" in userDeposited
+            ? userDeposited.pubkey
+            : userDeposited.validator.publicKey,
+        activeBoostAmount: userDeposited?.activeBoostAmount,
+        queuedBoostAmount: userDeposited?.queuedBoostAmount,
+        queuedBoostStartBlock: Number(userDeposited?.queuedBoostStartBlock),
+        queuedDropBoostAmount: userDeposited?.queuedDropBoostAmount,
+        queuedDropBoostStartBlock: Number(
+          userDeposited?.queuedDropBoostStartBlock,
+        ),
+        hasPendingBoosts:
+          Number(userDeposited?.queuedBoostAmount) > 0 ||
+          Number(userDeposited?.queuedDropBoostAmount) > 0,
+        hasActiveBoosts: Number(userDeposited?.activeBoostAmount) > 0,
+      } satisfies UserBoostsOnValidator,
+    } satisfies ValidatorWithUserBoost;
+  });
+}

package/src/actions/validators/getUserBoosts.ts

@@ -0,0 +1,28 @@
+import type { Address } from "viem";
+
+import {
+  GetUserValidatorInformation,
+  type GetUserValidatorInformationQuery,
+  type GetUserValidatorInformationQueryVariables,
+} from "@berachain/graphql/pol/subgraph";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export async function getUserBoosts({
+  account,
+  block,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  account: string;
+  block?: GetUserValidatorInformationQueryVariables["block"];
+}) {
+  const bgtClient = getApolloClient("pol.subgraph", args);
+  // TODO: handle more than 1000 validators
+  return await bgtClient.query<
+    GetUserValidatorInformationQuery,
+    GetUserValidatorInformationQueryVariables
+  >({
+    query: GetUserValidatorInformation,
+    variables: { address: account.toLowerCase() as Address, block },
+  });
+}

package/src/actions/validators/getUserBoostsOnValidator.ts

@@ -0,0 +1,70 @@
+import type { GetPublicClientReturnType } from "@wagmi/core";
+import { type Address, formatEther } from "viem";
+
+import { bgtAbi } from "~/abi/pol/bgt";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export type UserBoostsOnValidator = {
+  pubkey: Address;
+  activeBoostAmount: string;
+  queuedBoostAmount: string;
+  queuedBoostStartBlock: number;
+  queuedDropBoostAmount: string;
+  queuedDropBoostStartBlock: number;
+  hasPendingBoosts: boolean;
+  hasActiveBoosts: boolean;
+};
+
+export async function getUserBoostsOnValidator({
+  account,
+  pubkey,
+  publicClient,
+  ...args
+}: {
+  account: Address;
+  pubkey: Address;
+  publicClient: GetPublicClientReturnType;
+} & BeraJS.BaseFunctionArgs): Promise<UserBoostsOnValidator> {
+  const { config } = parseBaseArgs(args);
+
+  if (!account) {
+    throw new Error("account is required");
+  }
+  if (!publicClient) {
+    throw new Error("publicClient is required");
+  }
+
+  const [activeBoostAmount, queuedBoostAmount, queuedDropBoostAmount] =
+    await Promise.all([
+      publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "boosted",
+        args: [account!, pubkey!],
+      }),
+      publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "boostedQueue",
+        args: [account!, pubkey!],
+      }),
+      publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "dropBoostQueue",
+        args: [account!, pubkey!],
+      }),
+    ]);
+
+  return {
+    pubkey,
+    activeBoostAmount: formatEther(activeBoostAmount),
+    queuedBoostAmount: formatEther(queuedBoostAmount[1]),
+    queuedDropBoostAmount: formatEther(queuedDropBoostAmount[1]),
+    queuedBoostStartBlock: queuedBoostAmount[0],
+    queuedDropBoostStartBlock: queuedDropBoostAmount[0],
+    hasPendingBoosts:
+      Number(queuedBoostAmount[1]) > 0 || Number(queuedDropBoostAmount[1]) > 0,
+    hasActiveBoosts: Number(activeBoostAmount) > 0,
+  };
+}