@berachain/berajs 0.1.2 → 0.2.0

package/src/actions/honey/getHoneyVaultsBalance.ts

@@ -2,8 +2,7 @@ import { type Address, formatUnits, type PublicClient } from "viem";
 
 import { collateralVaultAbi } from "~/abi/honey/collateralVault";
 import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
-import type { Token } from "~/types/dex";
-import type { TokenBalance } from "~/types/global";
+import type { BalanceToken, Token } from "~/types/dex";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 interface GetVaultsBalancesArgs extends BeraJS.BaseFunctionArgs {
@@ -12,7 +11,7 @@ interface GetVaultsBalancesArgs extends BeraJS.BaseFunctionArgs {
   honeyFactoryAddress?: Address;
 }
 
-export interface GetHoneyVaultsBalanceResponse extends TokenBalance {
+export interface GetHoneyVaultsBalanceResponse extends BalanceToken {
   vault: Address;
 }
 
@@ -25,62 +24,59 @@ export async function getHoneyVaultsBalance({
   const { config } = parseBaseArgs(args);
   const factory = honeyFactoryAddress ?? config.honey.factory;
 
-  try {
-    const vaults = await Promise.all(
-      collateralList.map(async (coll) => {
-        const vault = await client.readContract({
-          address: config.honey.factory,
+  const vaults = await Promise.all(
+    collateralList.map(async (coll) => {
+      const vault = await client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi,
+        functionName: "vaults",
+        args: [coll.address],
+      });
+
+      const [
+        shares,
+        // this is most likely 0 since we're sending fees to PolFeeCollector
+        // here for future proofing
+        feeShares,
+        // if balance is held in a custodian, we need to return the custodian address
+        [isCustodian, custodianAddress],
+      ] = await Promise.all([
+        client.readContract({
+          address: vault,
+          abi: collateralVaultAbi,
+          functionName: "balanceOf",
+          args: [factory],
+        }),
+        client.readContract({
+          address: factory,
           abi: honeyFactoryAbi,
-          functionName: "vaults",
+          functionName: "collectedAssetFees",
           args: [coll.address],
-        });
-
-        const [
-          shares,
-          // this is most likely 0 since we're sending fees to PolFeeCollector
-          // here for future proofing
-          feeShares,
-          // if balance is held in a custodian, we need to return the custodian address
-          [isCustodian, custodianAddress],
-        ] = await Promise.all([
-          client.readContract({
-            address: vault,
-            abi: collateralVaultAbi,
-            functionName: "balanceOf",
-            args: [factory],
-          }),
-          client.readContract({
-            address: factory,
-            abi: honeyFactoryAbi,
-            functionName: "collectedAssetFees",
-            args: [coll.address],
-          }),
-          client.readContract({
-            address: vault,
-            abi: collateralVaultAbi,
-            functionName: "custodyInfo",
-          }),
-        ]);
-
-        const balance = await client.readContract({
+        }),
+        client.readContract({
           address: vault,
           abi: collateralVaultAbi,
-          functionName: "convertToAssets",
-          args: [shares - feeShares],
-        });
+          functionName: "custodyInfo",
+        }),
+      ]);
+
+      const balance = await client.readContract({
+        address: vault,
+        abi: collateralVaultAbi,
+        functionName: "convertToAssets",
+        args: [shares - feeShares],
+      });
 
-        return {
-          address: coll.address,
-          balance: balance.toString(),
-          formattedBalance: formatUnits(balance, coll.decimals),
-          vault: isCustodian ? custodianAddress : vault,
-        };
-      }),
-    );
+      return {
+        ...coll,
+        balance: {
+          raw: balance.toString(),
+          formatted: formatUnits(balance, coll.decimals),
+        },
+        vault: isCustodian ? custodianAddress : vault,
+      };
+    }),
+  );
 
-    return vaults;
-  } catch (e) {
-    console.log(e);
-    throw e;
-  }
+  return vaults;
 }

package/src/actions/honey/getSwapPayload.ts

@@ -28,12 +28,11 @@ interface GetSwapPayloadReturn {
         "nonpayable",
         "mint" | "redeem"
       >;
-  value?: bigint;
+  value: bigint;
 }
 
 export const getSwapPayload = async ({
   state,
-  account,
   publicClient,
   priceFeedMap,
   collateralList,
@@ -44,12 +43,11 @@ export const getSwapPayload = async ({
     IHoneySwapState,
     "actionType" | "fromAmount" | "collaterals" | "isBasketModeEnabled"
   >;
-  account: Address | undefined;
   collateralList: TokenWithMetadata[];
   publicClient: PublicClient | undefined;
   priceFeedMap?: PythPriceFeedMap;
   isPythWrapperEnabled: boolean;
-}): Promise<GetSwapPayloadReturn> => {
+}): Promise<({ account }: { account: Address }) => GetSwapPayloadReturn> => {
   const { config } = parseBaseArgs(args);
   const honeyToken = getHoneyToken(args);
   const { actionType, fromAmount, collaterals, isBasketModeEnabled } = state;
@@ -57,7 +55,7 @@ export const getSwapPayload = async ({
     ? config.honey.pythWrapper
     : config.honey.factory;
   const pairMainAddress = collateralList.map((coll) => coll.address);
-  if (account && fromAmount[0] && !!pairMainAddress.length) {
+  if (fromAmount[0] && !!pairMainAddress.length) {
     const isMint = actionType === "mint";
     if (isPythWrapperEnabled && publicClient && priceFeedMap) {
       // to mint or redeem we need to update the prices for all the collaterals
@@ -66,7 +64,7 @@ export const getSwapPayload = async ({
         priceFeedId: Object.values(priceFeedMap),
       });
       const calldata = latestPrices.calldata;
-      let pythUpdateFee: bigint | undefined;
+      let pythUpdateFee: bigint = 0n;
       try {
         // get the update fee from pyth that will be used inside the contract to update the prices
         pythUpdateFee = await getPythUpdateFee({
@@ -78,12 +76,38 @@ export const getSwapPayload = async ({
         pythUpdateFee = getPythDefaultUpdateFee(collaterals.length);
       }
 
-      const pythPayload: ContractFunctionArgs<
-        typeof pythWrapperAbi,
-        "payable",
+      return ({ account }) => {
+        const pythPayload: ContractFunctionArgs<
+          typeof pythWrapperAbi,
+          "payable",
+          "mint" | "redeem"
+        > = [
+          calldata,
+          collaterals[0]?.address,
+          parseUnits(
+            fromAmount[0],
+            (isMint ? collaterals[0]?.decimals : honeyToken?.decimals) ?? 18,
+          ),
+          account,
+          !!isBasketModeEnabled,
+        ];
+
+        return {
+          address: destinationContractAddress,
+          abi: pythWrapperAbi,
+          functionName: isMint ? "mint" : "redeem",
+          params: pythPayload,
+          value: pythUpdateFee,
+        };
+      };
+    }
+
+    return ({ account }) => {
+      const defaultPayload: ContractFunctionArgs<
+        typeof honeyFactoryAbi,
+        "nonpayable",
         "mint" | "redeem"
       > = [
-        calldata,
         collaterals[0]?.address,
         parseUnits(
           fromAmount[0],
@@ -92,35 +116,13 @@ export const getSwapPayload = async ({
         account,
         !!isBasketModeEnabled,
       ];
-
       return {
+        value: 0n,
         address: destinationContractAddress,
-        abi: pythWrapperAbi,
+        abi: honeyFactoryAbi,
         functionName: isMint ? "mint" : "redeem",
-        params: pythPayload,
-        value: pythUpdateFee,
+        params: defaultPayload,
       };
-    }
-
-    const defaultPayload: ContractFunctionArgs<
-      typeof honeyFactoryAbi,
-      "nonpayable",
-      "mint" | "redeem"
-    > = [
-      collaterals[0]?.address,
-      parseUnits(
-        fromAmount[0],
-        (isMint ? collaterals[0]?.decimals : honeyToken?.decimals) ?? 18,
-      ),
-      account,
-      !!isBasketModeEnabled,
-    ];
-
-    return {
-      address: destinationContractAddress,
-      abi: honeyFactoryAbi,
-      functionName: isMint ? "mint" : "redeem",
-      params: defaultPayload,
     };
   }
 

package/src/actions/honey/tests/pyth.integration.test.ts

@@ -33,7 +33,6 @@ describe("getPythLatestPrices", () => {
     const feedIdsMap = await getHoneyPythFeeds({
       tokenList: pairMainAddress,
       publicClient,
-      honeyPythOracle: config.honey.pythOracle,
     });
 
     const priceFeedId = pairMainAddress.map(

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

@@ -1,7 +1,7 @@
-import BigNumber from "bignumber.js";
 import { describe, expect, it } from "vitest";
 
 import { GetValidators } from "@berachain/graphql/pol/api";
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
 
 import { getAllValidators } from "~/actions/validators/getAllValidators";
 import { getServerSidePublicClient } from "~/utils/getServerSideClient";

package/src/actions/pol/getEarnedStakedBeraVault.ts

@@ -0,0 +1,31 @@
+import type { Address } from "viem";
+
+import { beraFetchJson } from "~/utils/beraFetch";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+type StakingHistoryData = {
+  currentDepositRate: string;
+  earningsRealized: string;
+  earningsTotal: string;
+};
+
+type GetEarnedStakedBeraVaultArgs = {
+  /**
+   * The token that the user has staked
+   */
+  address: Address;
+  /**
+   * The account that the user has staked
+   */
+  account: Address;
+};
+export async function getEarnedStakedBeraVault({
+  address,
+  account,
+  ...args
+}: BeraJS.BaseFunctionArgs &
+  GetEarnedStakedBeraVaultArgs): Promise<StakingHistoryData> {
+  const { config } = parseBaseArgs(args);
+  const url = `${config.bonder}/vaults/${address}/earnings/${account}`;
+  return beraFetchJson<StakingHistoryData>(url);
+}

package/src/actions/pol/getGlobalData.ts

@@ -1,8 +1,9 @@
-import * as Sentry from "@sentry/nextjs";
 import type { PublicClient } from "viem";
 
 import type { ApiVaultFragment } from "@berachain/graphql/pol/api";
 
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
+import { initBeraError } from "~/errors/initBeraError";
 import { type GlobalInfo, getBGTGlobalInfo } from "./getBGTGlobalInfo";
 import { getBgtTokenTotalBoosts } from "./getBgtTokenTotalBoosts";
 import { getBgtTokenTotalSupply } from "./getBgtTokenTotalSupply";
@@ -33,27 +34,27 @@ export async function getGlobalData(
   ]);
 
   if (globalDataRes.status === "rejected") {
-    Sentry.captureException(globalDataRes.reason, {
-      level: "warning",
-    });
+    BeraMonitoring.captureException(
+      initBeraError({ cause: globalDataRes.reason, level: "warning" }),
+    );
   }
 
   if (globalCuttingBoardRes.status === "rejected") {
-    Sentry.captureException(globalCuttingBoardRes.reason, {
-      level: "warning",
-    });
+    BeraMonitoring.captureException(
+      initBeraError({ cause: globalCuttingBoardRes.reason, level: "warning" }),
+    );
   }
 
   if (bgtTotalSupplyRes.status === "rejected") {
-    Sentry.captureException(bgtTotalSupplyRes.reason, {
-      level: "warning",
-    });
+    BeraMonitoring.captureException(
+      initBeraError({ cause: bgtTotalSupplyRes.reason, level: "warning" }),
+    );
   }
 
   if (bgtTotalBoostsRes.status === "rejected") {
-    Sentry.captureException(bgtTotalBoostsRes.reason, {
-      level: "warning",
-    });
+    BeraMonitoring.captureException(
+      initBeraError({ cause: bgtTotalBoostsRes.reason, level: "warning" }),
+    );
   }
 
   return {

package/src/actions/pol/getLSTStakeConfig.ts

@@ -0,0 +1,67 @@
+import type { Address, PublicClient } from "viem";
+
+import { lstStakerVaultAbi } from "~/abi/pol/LSTStakerVault";
+import { assertPublicClient } from "~/errors/assert";
+import type { TokenWithMetadata } from "~/types/dex";
+import type { StakingConfig } from "~/types/staking";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { isToken } from "~/utils/tokens";
+
+export type GetLSTStakeConfigArgs = {
+  tokenList: TokenWithMetadata[];
+  publicClient?: PublicClient;
+  lstStakingVaults: Address[];
+} & BeraJS.BaseFunctionArgs;
+
+/**
+ * Builds staking configs from on-chain LST vaults and optional native configs.
+ */
+export async function getLSTStakeConfig({
+  tokenList,
+  publicClient,
+  lstStakingVaults,
+  ...args
+}: GetLSTStakeConfigArgs): Promise<StakingConfig[]> {
+  assertPublicClient(publicClient);
+
+  const { config } = parseBaseArgs({
+    ...args,
+    chainId: publicClient.chain?.id ?? args.chainId,
+  });
+
+  const lstStakingTokens = tokenList.filter((token) =>
+    lstStakingVaults.includes(token.address),
+  );
+
+  if (lstStakingTokens.length === 0) {
+    return [];
+  }
+
+  const assets = await Promise.all(
+    lstStakingTokens.map(async (stakingToken) => {
+      // read the asset token address from the lst staking vault
+      const assetTokenAddress = await publicClient.readContract({
+        address: stakingToken.address,
+        abi: lstStakerVaultAbi,
+        functionName: "asset",
+      });
+      return { assetTokenAddress, stakingToken };
+    }),
+  );
+
+  return assets.reduce<StakingConfig[]>(
+    (acc, { assetTokenAddress, stakingToken }) => {
+      const assetToken = tokenList.find((token) =>
+        isToken(token, assetTokenAddress),
+      );
+      if (!assetToken) return acc;
+      acc.push({
+        id: stakingToken.address,
+        receiptToken: stakingToken,
+        inputTokens: [assetToken],
+      });
+      return acc;
+    },
+    [],
+  );
+}

package/src/actions/pol/getMarkets.ts

@@ -1,4 +1,4 @@
-import type { ProtocolMetadata } from "~/types";
+import type { ProtocolMetadata } from "~/types/staking";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 export interface GetMarkets {

package/src/actions/pol/getRewardProofsByValidator.ts

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
 
 import { BeraError } from "~/errors/BeraError";
-import type { BribeBoostRewardProof } from "~/types";
+import type { BribeBoostRewardProof } from "~/types/bribe-boost";
 import { getErrorResponse } from "~/utils/getErrorResponse";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 

package/src/actions/pol/getRewardVaultIncentives.ts

@@ -1,9 +1,9 @@
 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";
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
 
 export interface RewardVaultIncentive {
   token: Address;
@@ -99,19 +99,17 @@ export async function getRewardVaultIncentives({
 
   incentives.forEach((result, index) => {
     if (result.status === "rejected") {
-      Sentry.captureException(
+      BeraMonitoring.captureException(
         new BeraError({
           reason: result.reason,
           message: "Incorrect incentives token received.",
           level: "error",
-        }),
-        {
           extra: {
             token: whitelistedTokens[index],
             address: address,
             error: result.reason,
           },
-        },
+        }),
       );
     }
   });

package/src/actions/pol/getRewardVaults.ts

@@ -1,5 +1,4 @@
-import type { GetPublicClientReturnType } from "@wagmi/core";
-import { type Address, formatUnits } from "viem";
+import { type Address, formatUnits, type PublicClient } from "viem";
 
 import {
   type ApiVaultFragment,
@@ -25,7 +24,7 @@ export async function getRewardVaults({
   ...args
 }: {
   filter?: GetVaultsQueryVariables;
-  publicClient?: GetPublicClientReturnType;
+  publicClient?: PublicClient | undefined;
 } & BeraJS.BaseFunctionArgs = {}): Promise<GetGaugeData> {
   const bexApiGraphqlClient = getApolloClient("api", args);
 

package/src/actions/pol/getSWBeraVaultMetadata.ts

@@ -1,10 +1,10 @@
-import BigNumber from "bignumber.js";
 import { type Address, erc20Abi, type PublicClient } from "viem";
 
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
 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";
 
@@ -35,10 +35,12 @@ export interface VaultMetadata {
 export async function getSWBeraVaultMetadata({
   address,
   publicClient,
+  blockTime,
   ...args
 }: {
   address: Address;
   publicClient?: PublicClient;
+  blockTime: number;
 } & BeraJS.BaseFunctionArgs): Promise<VaultMetadata> {
   const { config } = parseBaseArgs(args);
   assertPublicClient(publicClient);
@@ -46,9 +48,8 @@ export async function getSWBeraVaultMetadata({
   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([
+    const [currentBlock] = 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);
@@ -121,7 +122,8 @@ export async function getSWBeraVaultMetadata({
         functionName: "totalSupply",
       }),
       getStakeWithdrawalCooldown({
-        publicClient: publicClient,
+        publicClient,
+        address,
       }),
       getIncentiveFeeClaimStats({}),
     ]);

package/src/actions/pol/getSWBeraWithdrawal.ts

@@ -1,8 +1,10 @@
 import type { Address, PublicClient } from "viem";
 
 import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
-import { getStakeWithdrawalCooldown } from "~/actions";
-import { formatTimeLeft, msToSeconds } from "~/utils";
+import { getStakeWithdrawalCooldown } from "~/actions/pol/getStakeWithdrawalCooldown";
+import { formatTimeLeft } from "~/utils/formatTimestamps";
+import { msToSeconds } from "~/utils/time";
+import { isToken } from "~/utils/tokens";
 
 /**
  * Calculates and returns formatted time remaining until a target date
@@ -27,6 +29,7 @@ function getTimeUntil(targetTime: number): string | undefined {
  * Interface representing a staked BERA withdrawal request
  */
 export interface StakedBeraWithdrawal {
+  receiptTokenAddress: Address;
   withdrawalAmount?: bigint;
   timeRemaining?: string;
   withdrawalRequestId?: bigint;
@@ -56,12 +59,17 @@ type WithdrawalRequestV1 = readonly [
  * @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[]> {
+export async function getSWBeraWithdrawal({
+  contractAddress,
+  accountAddress,
+  publicClient,
+  version,
+}: {
+  contractAddress: Address;
+  accountAddress: Address;
+  publicClient: PublicClient;
+  version: "V1" | "V2";
+}): Promise<StakedBeraWithdrawal[]> {
   const withdrawalRequests: StakedBeraWithdrawal[] = [];
 
   function withdrawalRequestV1Helper(
@@ -76,6 +84,7 @@ export async function getSWBeraWithdrawal(
     if (withdrawalAmount > 0) {
       const timeRemaining = getTimeUntil(timeLeft <= 0 ? 0 : readyTime);
       withdrawalRequests.push({
+        receiptTokenAddress: contractAddress,
         withdrawalAmount,
         timeRemaining,
       });
@@ -93,31 +102,35 @@ export async function getSWBeraWithdrawal(
         }),
         getStakeWithdrawalCooldown({
           publicClient,
+          address: contractAddress,
         }),
       ]);
       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);
+      const [withdrawalRequestIds, lockPeriod] = await Promise.all([
+        publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi,
+          functionName: "getERC721WithdrawalRequestIds" as const,
+          args: [accountAddress],
+        }),
+        getStakeWithdrawalCooldown({
+          publicClient,
+          address: contractAddress,
+        }),
+      ]);
+
+      if (isToken(contractAddress, "SWBERA")) {
+        const withdrawalRequestV1 = await publicClient.readContract({
+          address: contractAddress,
+          abi: stakeBeraVaultAbi,
+          functionName: "withdrawalRequests" as const,
+          args: [accountAddress],
+        });
+        withdrawalRequestV1Helper(withdrawalRequestV1, lockPeriod);
+      }
 
       // Process each withdrawal request ID to get detailed information
       const withdrawalResults = await Promise.all(
@@ -147,6 +160,7 @@ export async function getSWBeraWithdrawal(
                 withdrawalAmount,
                 timeRemaining,
                 withdrawalRequestId,
+                receiptTokenAddress: contractAddress,
               };
             }
             return null;

package/src/actions/pol/getStakeWithdrawalCooldown.ts

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