@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/honey/getRelativeCapLimit.ts

@@ -0,0 +1,83 @@
+import { type Address, type PublicClient, parseEther } from "viem";
+
+import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
+import type { TokenWithOrder } from "~/contexts/HoneyConfigProvider";
+import { CAP_LIMIT_BUFFER } from "~/utils/constants";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getSharesWithoutFees } from "./getSharesWithoutFees";
+
+interface GetRelativeCapLimitArgs extends BeraJS.BaseFunctionArgs {
+  client: PublicClient;
+  asset: Address;
+  amount: string;
+  isMint: boolean;
+  referenceCollateral: TokenWithOrder;
+}
+
+/**
+ * Get the relative cap limit for a given asset.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Address} args.asset - The address of the asset to get the relative cap limit for.
+ * @param {string} args.amount - The amount of the asset to get the relative cap limit for.
+ * @param {boolean} args.isMint - Whether the transaction is a mint or a redeem.
+ *
+ * @returns {Promise<boolean | undefined>} If the asset is relatively capped.
+ */
+export async function getRelativeCapLimit({
+  client,
+  asset,
+  amount,
+  isMint,
+  referenceCollateral,
+  ...args
+}: GetRelativeCapLimitArgs): Promise<boolean | undefined> {
+  const { config } = parseBaseArgs(args);
+
+  if (asset === referenceCollateral.address) {
+    // reference collateral is never capped, as it would be relative to itself
+    return false;
+  }
+
+  try {
+    const [assetRelativeCap] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi,
+        functionName: "relativeCap",
+        args: [asset],
+      }),
+    ]);
+
+    const [assetBalance, referenceCollateralBalance] = await Promise.all([
+      getSharesWithoutFees({
+        client,
+        asset,
+        amount: isMint ? amount : undefined,
+      }),
+      getSharesWithoutFees({
+        client,
+        asset: referenceCollateral.address,
+        amount: isMint ? undefined : amount,
+      }),
+    ]);
+
+    if (referenceCollateralBalance === 0n) {
+      // If the balance of the asset is 0, it means that is capped`
+      // because the refence asset has also 0 balance.
+      return assetBalance !== 0n;
+    }
+
+    const weight =
+      parseEther((assetBalance ?? 0n).toString()) /
+      (referenceCollateralBalance ?? 0n);
+    if (weight >= assetRelativeCap - CAP_LIMIT_BUFFER) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}

package/src/actions/honey/getSharesWithoutFees.ts

@@ -0,0 +1,65 @@
+import { type Address, type PublicClient, parseEther } from "viem";
+
+import { collateralVaultAbi } from "~/abi/honey/collateralVault";
+import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Arguments for the getSharesWithoutFees function.
+ * The amount is optional because it's used to simulate a mint transaction to change
+ * the weights of the assets.
+ * This is needed for the global cap limit calculation.
+ */
+interface GetSharesWithoutFeesArgs extends BeraJS.BaseFunctionArgs {
+  client: PublicClient;
+  asset: Address;
+  amount?: string;
+}
+
+/**
+ * Get the balance that has been deposited in the asset vault without fees.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Address} args.asset - The address of the asset to get the shares without fees for.
+ * @param {string} args.amount - The amount that is being deposited in the asset vault. Used to simulate a mint transaction.
+ *
+ * @returns {Promise<bigint | undefined>} The shares without fees for the given asset.
+ */
+export async function getSharesWithoutFees({
+  client,
+  asset,
+  amount,
+  ...args
+}: GetSharesWithoutFeesArgs): Promise<bigint | undefined> {
+  const { config } = parseBaseArgs(args);
+
+  try {
+    const [vault, fees] = await Promise.all([
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi,
+        functionName: "vaults",
+        args: [asset],
+      }),
+      client.readContract({
+        address: config.honey.factory,
+        abi: honeyFactoryAbi,
+        functionName: "collectedFees",
+        args: [config.honey.factory, asset],
+      }),
+    ]);
+
+    const balance = await client.readContract({
+      address: vault,
+      abi: collateralVaultAbi,
+      functionName: "balanceOf",
+      args: [config.honey.factory],
+    });
+
+    return balance + parseEther(amount ?? "0") - fees;
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}

package/src/actions/honey/getSwapPayload.ts

@@ -0,0 +1,128 @@
+import {
+  type Abi,
+  type Address,
+  type ContractFunctionArgs,
+  type PublicClient,
+  parseUnits,
+} from "viem";
+
+import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
+import { pythWrapperAbi } from "~/abi/honey/pythWrapper";
+import type { IHoneySwapState } from "~/hooks/honey/useHoneySwapState";
+import type { TokenWithMetadata } from "~/types/dex";
+import type { PythPriceFeedMap } from "~/types/honeySwap";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getPythDefaultUpdateFee } from "~/utils/pythHoneyUtils";
+import { getHoneyToken } from "~/utils/tokens";
+import { getPythUpdateFee } from "../pyth/getUpdateFee";
+import { getPythLatestPrices } from "./getPythLatestPrices";
+
+interface GetSwapPayloadReturn {
+  address: Address;
+  abi: Abi;
+  functionName: "mint" | "redeem";
+  params:
+    | ContractFunctionArgs<typeof pythWrapperAbi, "payable", "mint" | "redeem">
+    | ContractFunctionArgs<
+        typeof honeyFactoryAbi,
+        "nonpayable",
+        "mint" | "redeem"
+      >;
+  value?: bigint;
+}
+
+export const getSwapPayload = async ({
+  state,
+  account,
+  publicClient,
+  priceFeedMap,
+  collateralList,
+  isPythWrapperEnabled,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  state: Pick<
+    IHoneySwapState,
+    "actionType" | "fromAmount" | "collaterals" | "isBasketModeEnabled"
+  >;
+  account: Address | undefined;
+  collateralList: TokenWithMetadata[];
+  publicClient: PublicClient | undefined;
+  priceFeedMap?: PythPriceFeedMap;
+  isPythWrapperEnabled: boolean;
+}): Promise<GetSwapPayloadReturn> => {
+  const { config } = parseBaseArgs(args);
+  const honeyToken = getHoneyToken(args);
+  const { actionType, fromAmount, collaterals, isBasketModeEnabled } = state;
+  const destinationContractAddress = isPythWrapperEnabled
+    ? config.honey.pythWrapper
+    : config.honey.factory;
+  const pairMainAddress = collateralList.map((coll) => coll.address);
+  if (account && 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
+      // get the price feed ids from pyth to update the calldata
+      const latestPrices = await getPythLatestPrices({
+        priceFeedId: Object.values(priceFeedMap),
+      });
+      const calldata = latestPrices.calldata;
+      let pythUpdateFee: bigint | undefined;
+      try {
+        // get the update fee from pyth that will be used inside the contract to update the prices
+        pythUpdateFee = await getPythUpdateFee({
+          client: publicClient,
+          priceFeedId: calldata,
+        });
+      } catch {
+        // if the update fee fails, we will use the default update fee
+        pythUpdateFee = getPythDefaultUpdateFee(collaterals.length);
+      }
+
+      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,
+      };
+    }
+
+    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,
+    };
+  }
+
+  throw new Error("Something went wrong while creating the Honey swap payload");
+};

package/src/actions/honey/isBadCollateralAsset.ts

@@ -0,0 +1,77 @@
+import { type PublicClient, parseUnits } from "viem";
+
+import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
+import { honeyFactoryReaderAbi } from "~/abi/honey/honeyFactoryReader";
+import type { Token } from "~/types/dex";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import type { PythLatestUpdates } from "./getPythLatestPrices";
+
+export interface IsBadCollateralArgs extends BeraJS.BaseFunctionArgs {
+  client: PublicClient;
+  collateral: Token;
+  latestPrices: PythLatestUpdates | undefined;
+  isPythWrapperEnabled: boolean;
+}
+
+export interface IsBadCollateralResponse {
+  isBlacklisted: boolean;
+  isDepegged: boolean;
+}
+
+/**
+ * Checks if a given collateral asset is considered bad, either by being blacklisted or depegged.
+ *
+ * @param {Object} args - The arguments object.
+ * @param {PublicClient} args.client - The client used to interact with the blockchain.
+ * @param {Token} args.collateral - The collateral asset to check.
+ *
+ * @returns {Promise<IsBadCollateralResponse | undefined>} An object indicating if the collateral is blacklisted or depegged.
+ */
+export async function isBadCollateralAsset({
+  client,
+  collateral,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}: IsBadCollateralArgs): Promise<IsBadCollateralResponse | undefined> {
+  const { config } = parseBaseArgs(args);
+
+  try {
+    const isBadCollateralCall = client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi,
+      functionName: "isBadCollateralAsset",
+      args: [collateral.address],
+    });
+
+    let isPeggedCall = client.readContract({
+      address: config.honey.factory,
+      abi: honeyFactoryAbi,
+      functionName: "isPegged",
+      args: [collateral.address],
+    });
+
+    if (isPythWrapperEnabled && latestPrices) {
+      const prices = latestPrices.prices.map((price) => parseUnits(price, 18));
+      isPeggedCall = client.readContract({
+        address: config.honey.reader,
+        abi: honeyFactoryReaderAbi,
+        functionName: "isPeggedWithPrice",
+        args: [collateral.address, prices[0]],
+      });
+    }
+    // Check if the collateral is bad = blacklisted OR depegged
+    const [badCollateralResult, isPeggedResult] = await Promise.all([
+      isBadCollateralCall,
+      isPeggedCall,
+    ]);
+
+    return {
+      isBlacklisted: badCollateralResult,
+      isDepegged: !isPeggedResult, // invert the result to get the correct value
+    };
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+}

package/src/actions/honey/isBasketModeEnabled.ts

@@ -0,0 +1,47 @@
+import { type PublicClient, parseUnits } from "viem";
+
+import { honeyFactoryAbi } from "~/abi/honey/honeyFactory";
+import { honeyFactoryReaderAbi } from "~/abi/honey/honeyFactoryReader";
+import type { Token } from "~/types/dex";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import type { PythLatestUpdates } from "./getPythLatestPrices";
+
+export async function isBasketModeEnabled({
+  client,
+  isMint,
+  collateralList,
+  latestPrices,
+  isPythWrapperEnabled,
+  ...args
+}: {
+  client: PublicClient;
+  isMint: boolean;
+  collateralList: Token[];
+  latestPrices: PythLatestUpdates | undefined;
+  isPythWrapperEnabled: boolean;
+} & BeraJS.BaseFunctionArgs): Promise<boolean | undefined> {
+  const { config } = parseBaseArgs(args);
+
+  if (isPythWrapperEnabled && latestPrices) {
+    if (collateralList.length === 0) return undefined;
+
+    const prices = latestPrices.prices.map((price) => parseUnits(price, 18));
+
+    const isActive = await client.readContract({
+      address: config.honey.reader,
+      abi: honeyFactoryReaderAbi,
+      functionName: "isBasketModeEnabledWithPrices",
+      args: [isMint, prices],
+    });
+
+    return isActive;
+  }
+
+  const isActive = await client.readContract({
+    address: config.honey.factory,
+    abi: honeyFactoryAbi,
+    functionName: "isBasketModeEnabled",
+    args: [isMint],
+  });
+  return isActive;
+}

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

@@ -0,0 +1,63 @@
+import { createPublicClient, http } from "viem";
+import { berachainBepolia } from "viem/chains";
+import { describe, expect, it } from "vitest";
+
+import { ChainId } from "@berachain/config";
+
+import { pythAbi } from "~/abi/pyth/pyth";
+import { getHoneyPythFeeds } from "~/actions/pyth/getHoneyPythFeeds";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getPythLatestPrices } from "../getPythLatestPrices";
+
+describe("getPythLatestPrices", () => {
+  it("should return calldata that can be used to calculate update fee", async () => {
+    const { config } = parseBaseArgs({ chainId: ChainId.BEPOLIA });
+
+    const publicClient = createPublicClient({
+      chain: berachainBepolia,
+      transport: http(),
+    });
+
+    // Test for BEPOLIA
+    const pairMainAddress = [
+      "0x6e8d0eCfCE5c2b7587263923e23d141F6364c7f9", //bbUSDC
+      "0xe0037233a4a21c6334CFa67895A4BeaDc87B2c40", //bbBYUSD
+    ] as const;
+
+    // Test for MAINNET
+    // const pairMainAddress = [
+    //   "0x549943e04f40284185054145c6E4e9568C1D3241", //USDC.e
+    //   "0x688e72142674041f8f6Af4c808a4045cA1D6aC82", //BYUSD
+    // ] as const;
+
+    const feedIdsMap = await getHoneyPythFeeds({
+      tokenList: pairMainAddress,
+      publicClient,
+      honeyPythOracle: config.honey.pythOracle,
+    });
+
+    const priceFeedId = pairMainAddress.map(
+      (address) => feedIdsMap[address],
+    ) as string[];
+
+    const priceUpdate = await getPythLatestPrices({
+      priceFeedId,
+    });
+
+    const calldata = priceUpdate.calldata;
+    // Verify calldata is an array
+    expect(Array.isArray(calldata)).toBe(true);
+
+    // Simulate the fee calculation logic from usePythUpdateFee
+    const result = await publicClient.readContract({
+      address: config.external.pyth,
+      abi: pythAbi,
+      functionName: "getUpdateFee",
+      args: [calldata],
+    });
+
+    // Verify fee is a valid number
+    expect(typeof result).toBe("bigint");
+    expect(result).toBeGreaterThan(0n);
+  });
+});

package/src/actions/index.ts

@@ -0,0 +1,105 @@
+/**
+ * This file avoids more barrel files.
+ *
+ * It's used to speed up the build process.
+ *
+ * @see {@link https://marvinh.dev/blog/speeding-up-javascript-ecosystem-part-7/}
+ */
+
+export * from "./bend/getConvertToAssets";
+export * from "./bend/getMaxDeposit";
+export {
+  getApolloClient,
+  gql,
+} from "./clients/getApolloClient";
+export * from "./dex/aggregators/base";
+export * from "./dex/b-sdk";
+export * from "./dex/getAllPools";
+export * from "./dex/getApiPool";
+export * from "./dex/getGlobalLiquidityAndSwapVolume";
+export * from "./dex/getOnChainPool";
+export * from "./dex/getPoolEvents";
+export * from "./dex/getPoolHistoricalData";
+export * from "./dex/getPoolPausedState";
+export * from "./dex/getPoolWithState";
+export * from "./dex/getSubgraphPool";
+export * from "./dex/getVaultPausedState";
+export * from "./governance/checkProposalField";
+export * from "./governance/computeActualStatus";
+export * from "./governance/getAllProposals";
+export * from "./governance/getBodyErrors";
+export * from "./governance/getDecodedFunctionData";
+export * from "./governance/getProposalDetails";
+export * from "./governance/getProposalFromTx";
+export * from "./governance/getProposalVotes";
+export * from "./governance/parseProposalBody";
+export * from "./honey/getChartData";
+export * from "./honey/getCollateralWeights";
+export * from "./honey/getGlobalCapLimit";
+export * from "./honey/getHoneyCollaterals";
+export * from "./honey/getHoneyFees";
+export * from "./honey/getHoneyGlobalData";
+export * from "./honey/getHoneyPausedState";
+export * from "./honey/getHoneyPreview";
+export * from "./honey/getHoneyPythPriceOracle";
+export * from "./honey/getHoneyRootPriceOracle";
+export * from "./honey/getHoneyVaultsBalance";
+export * from "./honey/getPythLatestPrices";
+export * from "./honey/getRelativeCapLimit";
+export * from "./honey/getSwapPayload";
+export * from "./honey/isBadCollateralAsset";
+export * from "./honey/isBasketModeEnabled";
+export * from "./misc/getBlockTimestamp";
+export * from "./pol/getBgtAprSimulation";
+export * from "./pol/getBlockTime";
+export * from "./pol/getGlobalData";
+export * from "./pol/getIncentiveFeeClaimStats";
+export * from "./pol/getMarkets";
+export * from "./pol/getRewardProofsByValidator";
+export * from "./pol/getRewardTokenToBeraRate";
+export * from "./pol/getRewardVault";
+export * from "./pol/getRewardVaultDurationConstants";
+export * from "./pol/getRewardVaultFromToken";
+export * from "./pol/getRewardVaultIncentives";
+export * from "./pol/getRewardVaultRewards";
+export * from "./pol/getRewardVaultStakingToken";
+export * from "./pol/getRewardVaults";
+export * from "./pol/getStakedBeraAPR";
+export * from "./pol/getStakedBeraSnapshots";
+export * from "./pol/getStakeWithdrawalCooldown";
+export * from "./pol/getSWBeraVaultMetadata";
+export * from "./pol/getSWBeraWithdrawal";
+export * from "./pol/getUserClaimableIncentives";
+export * from "./pol/getUserVaultInfo";
+export * from "./pol/getUserVaults";
+export * from "./pol/getUserVaultsReward";
+export * from "./pol/getVaultHistory";
+export * from "./pol/getVaultValidators";
+export * from "./prices/getTokenCurrentPrices";
+export * from "./pyth/getHoneyPythFeeds";
+export * from "./pyth/getUpdateFee";
+export * from "./tokens/getAllowances";
+export * from "./tokens/getTokenInformation";
+export * from "./tokens/getTokens";
+export * from "./tokens/getWalletBalances";
+export * from "./transactions/beraWriteContract";
+export * from "./validators/getActiveBoostAndCommissionChangeDelay";
+export * from "./validators/getAllValidators";
+export * from "./validators/getApiEnrichedAllocation";
+export * from "./validators/getApiValidator";
+export * from "./validators/getDailyValidatorBlockStats";
+export * from "./validators/getDefaultRewardAllocation";
+export * from "./validators/getManagedValidatorByAccount";
+export * from "./validators/getStakingPoolBatch";
+export * from "./validators/getUserActiveValidators";
+export * from "./validators/getUserBoostsOnValidator";
+export * from "./validators/getUserStakingPositions";
+export * from "./validators/getValidatorAnalytics";
+export * from "./validators/getValidatorCommission";
+export * from "./validators/getValidatorEstimatedBgtPerYear";
+export * from "./validators/getValidatorOperatorAddress";
+export * from "./validators/getValidatorQueuedCommission";
+export * from "./validators/getValidatorQueuedOperatorAddress";
+export * from "./validators/getValidatorQueuedRewardAllocation";
+export * from "./validators/getValidatorRewardAllocation";
+export * from "./validators/utils/getValidatorBoostApy";

package/src/actions/misc/getBlockTimestamp.ts

@@ -0,0 +1,41 @@
+import type { PublicClient } from "viem";
+
+import { assertDefined, assertPublicClient } from "~/errors/assert";
+import { msToSeconds } from "~/utils/time";
+
+/**
+ * Gets the timestamp of a block or an estimated timestamp if the block is in the future.
+ * @returns
+ */
+export async function getBlockTimestamp({
+  block,
+  currentBlock,
+  blockTime,
+  publicClient,
+}: {
+  block: number | bigint | string;
+  currentBlock: number | bigint | string;
+  blockTime: number;
+  publicClient: PublicClient;
+}): Promise<{ timestamp: number }> {
+  assertDefined(block, "block");
+  assertPublicClient(publicClient);
+
+  if (currentBlock > block) {
+    const blockData = await publicClient.getBlock({
+      blockNumber: BigInt(block),
+      includeTransactions: false,
+    });
+
+    return {
+      timestamp: Number(blockData.timestamp),
+    };
+  }
+  const ts =
+    msToSeconds(Date.now()) +
+    blockTime * (Number(block) - Number(currentBlock));
+
+  return {
+    timestamp: ts,
+  };
+}

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

@@ -0,0 +1,55 @@
+import BigNumber from "bignumber.js";
+import { describe, expect, it } from "vitest";
+
+import { GetValidators } from "@berachain/graphql/pol/api";
+
+import { getAllValidators } from "~/actions/validators/getAllValidators";
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getGlobalData } from "../getGlobalData";
+
+describe("getAllValidators", () => {
+  it("should be defined", () => {
+    expect(GetValidators).toBeDefined();
+  });
+});
+
+describe("getAllValidators", async () => {
+  const result = await getAllValidators({
+    variables: {
+      pageSize: 1000,
+    },
+  });
+
+  const globalData = await getGlobalData(getServerSidePublicClient());
+
+  if (!result) {
+    throw new Error("Failed to fetch validators");
+  }
+
+  const { validators } = result;
+
+  it("should return all validators", async () => {
+    expect(validators?.validators?.length).toBeGreaterThan(0);
+  });
+
+  it("should have consistent data", async () => {
+    const totalStakedBeraAmount = validators?.validators
+      .filter((v) => v.lastBlockUptime?.isActive)
+      .reduce(
+        (acc, validator) =>
+          BigNumber(validator.dynamicData?.stakedBeraAmount ?? 0).plus(acc),
+        BigNumber(0),
+      );
+
+    expect(totalStakedBeraAmount.toNumber()).toBeCloseTo(
+      Number(globalData?.totalStakedBeraAmount ?? 0),
+      1,
+    );
+  });
+});
+
+describe("getAllValidators", () => {
+  it("should be defined", () => {
+    expect(true).toBeDefined();
+  });
+});