@berachain/berajs 0.1.2 → 0.2.0

package/src/actions/enso/bend.ts

@@ -1,143 +0,0 @@
-import type { BundleAction, EnsoClient } from "@ensofinance/sdk";
-import { type Address, ethAddress, type PublicClient, zeroAddress } from "viem";
-
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import type { GetZapTransactionResponse, Quantity } from "~/types";
-import { getTransactionsFromBundle } from "./util";
-
-export interface GetBendTransactionRequestsArgs {
-  fromAddress: Address;
-  amountIn: Quantity;
-  tokenIn: Address;
-  loanToken: Address;
-  bendVault: Address;
-  rewardVault?: Address;
-  chainId: number;
-  ensoClient: EnsoClient;
-  destinationChainId?: number;
-  slippage: number;
-  publicClient: PublicClient;
-}
-
-export async function getBendTransactionRequests({
-  fromAddress,
-  amountIn,
-  tokenIn,
-  loanToken,
-  bendVault,
-  rewardVault,
-  chainId,
-  ensoClient,
-  destinationChainId,
-  slippage,
-  publicClient,
-}: GetBendTransactionRequestsArgs): Promise<GetZapTransactionResponse> {
-  if (!fromAddress) {
-    throw new InvalidArgumentError({
-      property: "fromAddress",
-      value: fromAddress,
-      expected: "string",
-    });
-  }
-  if (loanToken === zeroAddress) loanToken = ethAddress;
-
-  const bundleActions: BundleAction[] = [
-    {
-      protocol: "enso",
-      action: "route",
-      args: {
-        tokenIn,
-        tokenOut: loanToken,
-        amountIn,
-        slippage: slippage * 100, // Enso expects slippage in basis points
-      },
-    },
-  ];
-  /**
-   * If the zap is cross chain, we need to add the destination chain id and the refund receiver.
-   *
-   * Enso still need to update the sdk types to support this.
-   */
-  if (destinationChainId && destinationChainId !== chainId) {
-    bundleActions[0].args = {
-      ...bundleActions[0].args,
-      //@ts-expect-error enso are releasing a fix in the next 2 weeks for this.
-      destinationChainId: destinationChainId,
-      refundReceiver: fromAddress,
-    };
-  }
-  // vault output is the vault address
-  // vaults are in morpho-blue-vaults-v1
-  // markets are here morpho-markets-v1"
-  bundleActions.push({
-    protocol: "erc4626",
-    action: "deposit",
-    args: {
-      amountIn: { useOutputOfCallAt: 0 },
-      tokenIn: loanToken,
-      primaryAddress: bendVault,
-      tokenOut: bendVault,
-    },
-  });
-  if (rewardVault) {
-    bundleActions.push(
-      {
-        protocol: "enso",
-        action: "balance",
-        args: {
-          token: bendVault,
-        },
-      },
-      {
-        protocol: "erc20",
-        action: "approve",
-        args: {
-          amount: { useOutputOfCallAt: 2 },
-          spender: rewardVault,
-          token: bendVault,
-        },
-      },
-      {
-        protocol: "enso",
-        action: "call",
-        args: {
-          address: rewardVault,
-          args: [fromAddress, { useOutputOfCallAt: 2 }],
-          method: "stakeOnBehalf",
-          abi: "function stakeOnBehalf(address account, uint256 amount) external",
-        },
-      },
-      {
-        protocol: "enso",
-        action: "balance",
-        args: {
-          token: rewardVault,
-        },
-      },
-    );
-  }
-
-  const bundle = await ensoClient.getBundleData(
-    {
-      fromAddress: fromAddress,
-      receiver: fromAddress,
-      spender: fromAddress,
-      chainId: chainId,
-      routingStrategy: "router",
-    },
-    bundleActions,
-  );
-  const transactions = await getTransactionsFromBundle({
-    fromAddress,
-    amountIn,
-    tokenIn,
-    chainId,
-    ensoClient,
-    bundle,
-    publicClient,
-  });
-  return {
-    bundle,
-    transactions,
-  };
-}

package/src/actions/enso/getEnsoUserToken.debug.test.ts

@@ -1,57 +0,0 @@
-import * as Sentry from "@sentry/nextjs";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  type MockInstance,
-  vi,
-} from "vitest";
-
-import { wagmiConfig } from "@berachain/wagmi/config";
-
-import { getEnsoClient } from "../clients/getEnsoClient";
-import { getEnsoUserToken } from "./getEnsoUserToken";
-
-describe("getEnsoUserToken", () => {
-  let fetchSpy: MockInstance<typeof global.fetch>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    vi.mock(import("@sentry/nextjs"), () => ({
-      captureException: vi.fn(),
-    }));
-
-    fetchSpy = vi.spyOn(global, "fetch");
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  const address = "0x79f453D56C4bC66586215827FbBc7B34Bc006b33";
-  it("should be using multicall for each chain", async () => {
-    const ensoClient = getEnsoClient();
-
-    const ensoUserToken = await getEnsoUserToken({
-      account: address,
-      wagmiConfig: wagmiConfig,
-      chainId: "all",
-      ensoClient: ensoClient,
-    });
-
-    expect(ensoUserToken.length).toBeGreaterThan(0);
-
-    expect(fetchSpy).toHaveBeenCalled();
-    expect(Sentry.captureException).not.toHaveBeenCalled();
-
-    const chains = Object.groupBy(ensoUserToken, (token) => token.chainId ?? 0);
-    const chainIds = Object.keys(chains)
-      .map(Number)
-      .filter((chainId) => chainId !== 0);
-
-    expect(fetchSpy).toHaveBeenCalledTimes(1 + chainIds.length);
-  });
-});

package/src/contexts/berajsProvider/context.tsx

@@ -1,49 +0,0 @@
-"use client";
-
-import {
-  createContext,
-  type PropsWithChildren,
-  useEffect,
-  useMemo,
-  useState,
-} from "react";
-import BigNumber from "bignumber.js";
-
-import { useBeraAccount, useBeraWagmi } from "@berachain/wagmi/hooks";
-
-import { TransactionStoreProvider } from "~/hooks/transactions/TransactionStoreContext";
-
-BigNumber.config({
-  EXPONENTIAL_AT: 1e9,
-});
-
-export interface IBeraJsAPI {
-  /**
-   * @deprecated check `useBeraAccount.isConnected` instead and wrap transaction in ActionButton to ensure it's wallet chain is connected.
-   */
-  isReady?: boolean;
-}
-
-export const BeraJsContext = createContext<IBeraJsAPI | undefined>(undefined);
-
-export function BeraJsProvider({ children }: PropsWithChildren) {
-  const [isMounted, setIsMounted] = useState(false);
-  const { walletClient } = useBeraWagmi();
-  const { wallet } = useBeraAccount();
-
-  useEffect(() => setIsMounted(true), []);
-
-  return (
-    <BeraJsContext.Provider
-      value={{
-        isReady: useMemo(
-          () => !!wallet?.address && isMounted,
-          [wallet?.address, isMounted, walletClient],
-        ),
-      }}
-    >
-      <TransactionStoreProvider>{children}</TransactionStoreProvider>
-    </BeraJsContext.Provider>
-  );
-}
-export default BeraJsProvider;

package/src/contexts/berajsProvider/index.ts

@@ -1,2 +0,0 @@
-export * from "./context";
-export { default as useBeraJs } from "./useBeraJs";

package/src/contexts/berajsProvider/useBeraJs.ts

@@ -1,18 +0,0 @@
-import { useContext } from "react";
-
-import { BeraJsContext } from "./context";
-
-/**
- * @deprecated use useBeraAccount and useBeraWagmi instead
- */
-export function useBeraJs() {
-  const beraJsContext = useContext(BeraJsContext);
-
-  if (beraJsContext === undefined) {
-    throw new Error("bera js context undefined");
-  }
-
-  return beraJsContext;
-}
-
-export default useBeraJs;

package/src/hooks/dex/usePollVaultIsPaused.ts

@@ -1,30 +0,0 @@
-import useSWR from "swr";
-
-import { usePublicClient } from "@berachain/wagmi/hooks";
-
-import { getVaultPausedState } from "~/actions/dex/getVaultPausedState";
-import { POLLING } from "~/enum/polling";
-import { assertPublicClient } from "~/errors/assert";
-import type { DefaultHookOptions } from "~/types/global";
-
-// Determine if a Vault status is paused or not NOTE: there is no recovery mode for vaults.
-export function usePollVaultIsPaused(options?: DefaultHookOptions) {
-  const publicClient = usePublicClient();
-
-  const swrResponse = useSWR(
-    publicClient ? ["usePollVaultIsPaused"] : null,
-    async () => {
-      assertPublicClient(publicClient);
-
-      return getVaultPausedState({ publicClient });
-    },
-    {
-      ...options?.opts,
-      refreshInterval: options?.opts?.refreshInterval ?? POLLING.NORMAL,
-    },
-  );
-
-  return {
-    ...swrResponse,
-  };
-}

package/src/hooks/enso/useBendTransactionRequests.ts

@@ -1,247 +0,0 @@
-"use client";
-
-import useSWR from "swr";
-import type { Address } from "viem";
-
-import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
-
-import { getConvertToAssets } from "~/actions";
-import { POLLING } from "~/enum/polling";
-import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
-import type {
-  BalanceTokenWithMetadata,
-  GetZapTransactionResponse,
-} from "~/types";
-import type { DefaultHookOptions } from "~/types/global";
-import { computePriceImpact } from "~/utils/math";
-import { isToken } from "~/utils/tokens";
-import { useEnsoZap } from "./useEnsoZap";
-
-type UseBendTransactionRequestsArgs = {
-  /*
-   * The input token to swap from
-   */
-  tokenIn?: Pick<
-    BalanceTokenWithMetadata,
-    "address" | "decimals" | "price" | "formattedBalance" | "chainId"
-  >;
-  /*
-   * The loan token to swap to
-   */
-  loanTokenAddress: Address;
-  /*
-   * The price of the loan token
-   */
-  loanTokenPrice: number | undefined;
-  /*
-   * The bend vault to swap to
-   */
-  bendVault: Address;
-  /*
-   * The reward vault to swap to
-   */
-  rewardVault?: Address;
-  /*
-   * The amount of input token to swap
-   */
-  amount?: string;
-  /*
-   * The slippage tolerance to use for the route in percentage
-   */
-  slippage?: number;
-  /*
-   * The chain id to use for the public client
-   */
-  chainId?: number;
-};
-
-/**
- * Get the bend transaction requests for swapping tokens using Enso.
- * @param {UseBendTransactionRequestsArgs} props - The props for the hook see {@link UseBendTransactionRequestsArgs}
- * @returns {DefaultHookReturnType<GetZapTransactionResponse> & {tokens: BalanceTokenWithMetadata[], refresh: () => void}}
- *
- * The bend transaction response data with polling enabled, see {@link GetZapTransactionResponse} and {@link BalanceTokenWithMetadata}
- * @remarks The hook is only enabled when all parameters are provided and amount is greater than 0
- * @see {@link useEnsoZap}
- */
-export function useBendTransactionRequests(
-  {
-    tokenIn,
-    loanTokenAddress,
-    loanTokenPrice,
-    bendVault,
-    rewardVault,
-    amount,
-    slippage,
-    chainId,
-  }: UseBendTransactionRequestsArgs,
-  options?: DefaultHookOptions,
-) {
-  const { tokens, refreshTokens } = useEnsoZap({
-    chainId,
-  });
-
-  // this is using a dummy amount to get the gas
-  // this allows us to not wait on the user input for fees
-  const { data: dataForGas, error: errorForGas } =
-    useBendTransactionRequestsHelper(
-      {
-        tokenIn,
-        loanTokenAddress,
-        loanTokenPrice,
-        bendVault,
-        rewardVault,
-        amount: tokenIn?.formattedBalance,
-        slippage,
-        chainId: tokenIn?.chainId,
-      },
-      options,
-    );
-
-  // sum the value of the transactions
-  const transactionValue =
-    dataForGas?.transactions?.reduce(
-      (acc, transaction) => acc + BigInt(transaction.value ?? 0n),
-      0n,
-    ) ?? 0n;
-
-  const nativeToken = tokens?.find(
-    (token) => isToken(token, "ETH") && token.chainId === tokenIn?.chainId,
-  );
-
-  // enso is charging a fee, we need to subtract the value of the transaction from the chain token balance to get fee
-  const nativeFee =
-    BigInt(transactionValue) - BigInt(nativeToken?.balance ?? 0n);
-
-  const swrResponse = useBendTransactionRequestsHelper(
-    {
-      tokenIn,
-      loanTokenAddress,
-      loanTokenPrice,
-      bendVault,
-      rewardVault,
-      amount,
-      slippage,
-      chainId,
-    },
-    options,
-  );
-
-  return {
-    ...swrResponse,
-    nativeFee,
-    error: errorForGas || swrResponse.error,
-    tokens,
-    refresh: () => {
-      swrResponse.mutate();
-      refreshTokens();
-    },
-  };
-}
-
-export function useBendTransactionRequestsHelper(
-  {
-    tokenIn,
-    loanTokenAddress,
-    loanTokenPrice,
-    bendVault,
-    rewardVault,
-    amount,
-    slippage,
-    chainId,
-  }: UseBendTransactionRequestsArgs,
-  options?: DefaultHookOptions,
-) {
-  const { address: fromAddress } = useBeraWallet();
-  const { getBendTransactionRequests } = useEnsoZap({
-    chainId,
-  });
-  const isEnabled =
-    !!tokenIn &&
-    !!loanTokenAddress &&
-    !!bendVault &&
-    !!amount &&
-    !!fromAddress &&
-    !isToken(loanTokenAddress, tokenIn?.address) &&
-    tokenIn.chainId &&
-    Number(amount) > 0 &&
-    !!slippage;
-  const publicClient = usePublicClient({
-    chainId,
-  });
-  const publicClientBeraChain = usePublicClient();
-  const QUERY_KEY = isEnabled
-    ? ([
-        "useBendTransactionRequests",
-        tokenIn,
-        loanTokenAddress,
-        loanTokenPrice,
-        bendVault,
-        rewardVault,
-        amount,
-        slippage,
-      ] as const)
-    : null;
-
-  return useSWR(
-    QUERY_KEY,
-    async ([
-      ,
-      tokenIn,
-      loanTokenAddress,
-      loanTokenPrice,
-      bendVault,
-      rewardVault,
-      amount,
-      slippage,
-    ]) => {
-      if (!publicClient || !publicClientBeraChain) {
-        throw new InvalidArgumentError({
-          property: "publicClient",
-          value: publicClient,
-          expected: "PublicClient",
-        });
-      }
-
-      const response = await getBendTransactionRequests({
-        amount,
-        tokenIn: tokenIn,
-        loanToken: loanTokenAddress,
-        bendVault,
-        rewardVault,
-        slippage,
-      });
-
-      const amountOutObject = response.bundle.amountsOut;
-      const address = rewardVault
-        ? (rewardVault.toLowerCase() as Address)
-        : (bendVault.toLowerCase() as Address);
-      const amountOut = amountOutObject[address];
-      const supplyAmount = await getConvertToAssets({
-        sharesAmount: BigInt(amountOut),
-        vaultAddress: bendVault,
-        publicClient: publicClientBeraChain,
-      });
-
-      const priceImpact =
-        tokenIn?.price && loanTokenPrice
-          ? computePriceImpact(
-              tokenIn?.price?.toString(),
-              loanTokenPrice?.toString(),
-              amount,
-              supplyAmount.formatted,
-            )
-          : undefined;
-
-      return {
-        supplyAmount,
-        priceImpact,
-        ...response,
-      };
-    },
-    {
-      ...options?.opts,
-      refreshInterval: POLLING.NORMAL,
-    },
-  );
-}

package/src/hooks/enso/useEnsoZap.ts

@@ -1,166 +0,0 @@
-"use client";
-
-import { useCallback } from "react";
-import type { BundleData, EnsoClient } from "@ensofinance/sdk";
-import { getPublicClient } from "@wagmi/core";
-import useSWR from "swr";
-import { type Address, isAddress, parseUnits } from "viem";
-
-import { defaultChainId as berachainChainId } from "@berachain/config/internal";
-
-import { useBeraWallet, useConfig } from "@berachain/wagmi/hooks";
-
-import { getBendTransactionRequests as getBendTransactionRequestsHelper } from "~/actions/enso/bend";
-import { getZapTransactionRequests as getZapTransactionRequestsHelper } from "~/actions/enso/zap";
-import type {
-  BalanceToken,
-  BalanceTokenWithMetadata,
-  GetZapTransactionResponse,
-} from "~/types";
-
-export type { GetZapTransactionResponse, BundleData, BalanceTokenWithMetadata };
-
-import { getEnsoClient } from "~/actions/clients/getEnsoClient";
-import { getEnsoUserToken } from "~/actions/enso/getEnsoUserToken";
-import { POLLING } from "~/enum/polling";
-import {
-  assertAddress,
-  assertDefined,
-  assertPublicClient,
-} from "~/errors/assert";
-import type { DefaultHookOptions } from "~/types/global";
-
-function useEnsoBalances(
-  { ensoClient, chainId }: { ensoClient: EnsoClient; chainId?: number },
-  options?: DefaultHookOptions,
-) {
-  const { address: fromAddress } = useBeraWallet();
-  const wagmiConfig = useConfig();
-  const isEnabled = !!fromAddress && isAddress(fromAddress);
-
-  const QUERY_KEY =
-    isEnabled && wagmiConfig
-      ? (["useEnsoBalances", fromAddress, chainId] as const)
-      : null;
-
-  const swrResponse = useSWR(
-    QUERY_KEY,
-    async ([, fromAddress, chainId]): Promise<BalanceTokenWithMetadata[]> =>
-      getEnsoUserToken({
-        account: fromAddress,
-        wagmiConfig,
-        chainId: chainId ?? "all",
-        ensoClient,
-      }),
-    {
-      refreshInterval: POLLING.FAST,
-      isEnabled,
-      ...options?.opts,
-    },
-  );
-  return {
-    ...swrResponse,
-    refresh: () => swrResponse.mutate(),
-  };
-}
-
-/**
- * Get the enso client.
- * @returns {EnsoClient} The enso client, see {@link EnsoClient}
- * @see {@link useEnsoBalances}
- * @see {@link useTokens}
- */
-export function useEnsoZap({ chainId }: { chainId?: number }) {
-  const { address: fromAddress } = useBeraWallet();
-  const wagmiConfig = useConfig();
-  const ensoClient = getEnsoClient();
-  const { data: tokens, refresh: refreshTokens } = useEnsoBalances({
-    ensoClient,
-    chainId,
-  });
-
-  const getZapTransactionRequests = useCallback(
-    async ({
-      tokenIn,
-      tokenOut,
-      amount,
-      slippage,
-    }: {
-      tokenIn?: Pick<BalanceToken, "address" | "decimals" | "chainId">;
-      tokenOut: Address;
-      amount: string;
-      slippage: number;
-    }): Promise<GetZapTransactionResponse> => {
-      assertAddress(fromAddress, "fromAddress");
-      assertAddress(tokenIn?.address, "tokenInAddress");
-      assertDefined(tokenIn?.chainId, "tokenInChainId");
-      const publicClient = getPublicClient(wagmiConfig, {
-        chainId: tokenIn.chainId,
-      });
-      assertPublicClient(publicClient);
-      const rawAmount = parseUnits(amount, tokenIn.decimals).toString();
-
-      return getZapTransactionRequestsHelper({
-        fromAddress,
-        amountIn: rawAmount,
-        tokenIn: tokenIn?.address,
-        tokenOut,
-        chainId: tokenIn.chainId,
-        ensoClient,
-        destinationChainId: berachainChainId,
-        slippage,
-        publicClient,
-      });
-    },
-    [fromAddress, ensoClient, wagmiConfig],
-  );
-
-  const getBendTransactionRequests = useCallback(
-    async ({
-      tokenIn,
-      amount,
-      loanToken,
-      bendVault,
-      rewardVault,
-      slippage,
-    }: {
-      tokenIn?: Pick<BalanceToken, "address" | "decimals" | "chainId">;
-      amount: string;
-      loanToken: Address;
-      bendVault: Address;
-      rewardVault?: Address;
-      slippage: number;
-    }): Promise<GetZapTransactionResponse> => {
-      assertAddress(fromAddress, "fromAddress");
-      assertAddress(tokenIn?.address, "tokenInAddress");
-      assertDefined(tokenIn?.chainId, "tokenInChainId");
-      const publicClient = getPublicClient(wagmiConfig, {
-        chainId: tokenIn.chainId,
-      });
-      assertPublicClient(publicClient);
-      const rawAmount = parseUnits(amount, tokenIn.decimals).toString();
-
-      return getBendTransactionRequestsHelper({
-        fromAddress,
-        amountIn: rawAmount,
-        tokenIn: tokenIn.address,
-        loanToken,
-        bendVault,
-        rewardVault,
-        chainId: tokenIn.chainId,
-        ensoClient,
-        destinationChainId: berachainChainId,
-        slippage,
-        publicClient,
-      });
-    },
-    [fromAddress, ensoClient, wagmiConfig],
-  );
-
-  return {
-    tokens,
-    getBendTransactionRequests,
-    getZapTransactionRequests,
-    refreshTokens,
-  };
-}