@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/dex/getPoolEvents.ts

@@ -0,0 +1,35 @@
+import {
+  GetPoolEvents,
+  type GetPoolEventsQuery,
+  type GetPoolEventsQueryVariables,
+} from "@berachain/graphql/dex/api";
+import type { GqlChain, GqlPoolEventType } from "@berachain/graphql/pol/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getPoolEvents({
+  poolId,
+  typeInArray,
+  ...args
+}: {
+  poolId: string;
+  typeInArray: GqlPoolEventType[];
+} & BeraJS.BaseFunctionArgs) {
+  const { config } = parseBaseArgs(args);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+  const response = await bexApiGraphqlClient.query<
+    GetPoolEventsQuery,
+    GetPoolEventsQueryVariables
+  >({
+    query: GetPoolEvents,
+    variables: {
+      poolId,
+      typeIn: typeInArray,
+      chain: config.bex.chainName as GqlChain,
+    },
+  });
+
+  return response.data;
+}

package/src/actions/dex/getPoolHistoricalData.ts

@@ -0,0 +1,51 @@
+import { isHex } from "viem";
+
+import {
+  GetPoolHistoricalData,
+  type GetPoolHistoricalDataQuery,
+  type GetPoolHistoricalDataQueryVariables,
+  type GqlChain,
+  type PoolHistoricalDataFragment,
+} from "@berachain/graphql/dex/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+
+/** @deprecated */
+export type PoolDayData = {
+  date: number;
+  tvlUsd: string;
+  volumeUsd: string;
+  feesUsd: string;
+};
+
+interface GetPoolHistoricalDataProps {
+  poolId: string;
+  chain: GqlChain;
+}
+
+export async function getPoolHistoricalData({
+  poolId,
+  chain,
+  ...args
+}: GetPoolHistoricalDataProps & BeraJS.BaseFunctionArgs): Promise<
+  PoolHistoricalDataFragment[] | undefined
+> {
+  if (!poolId || !isHex(poolId))
+    throw new InvalidArgumentError({
+      property: "poolId",
+      value: poolId,
+      expected: "hex string",
+    });
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const { data } = await bexApiGraphqlClient.query<
+    GetPoolHistoricalDataQuery,
+    GetPoolHistoricalDataQueryVariables
+  >({
+    query: GetPoolHistoricalData,
+    variables: { poolId, chain },
+  });
+  return data.poolGetSnapshots;
+}

package/src/actions/dex/getPoolPausedState.ts

@@ -0,0 +1,40 @@
+import { weightedPoolV4Abi_V2 } from "@berachain-foundation/berancer-sdk";
+import type { Address, PublicClient } from "viem";
+
+export interface PoolStatus {
+  isPoolInRecoveryMode: boolean;
+  isPoolPaused: boolean;
+}
+
+export async function getPoolPausedState({
+  publicClient,
+  poolAddress,
+}: {
+  publicClient: PublicClient;
+  poolAddress: Address;
+}) {
+  const abi = weightedPoolV4Abi_V2;
+  // NOTE: we are only intersted in functions that span both ABIs, so I'll use weighted here. For SOME REASON. Balancer did
+  // not include inRecoveryMode etc in the stable ABI (despite it EXISTING in both weighted/stable) see for yourself:
+  // <scanner>/address/0xF7F214A9543c1153eF5DF2edCd839074615F248c/contract/80000/readContract#F28
+  // ... so we will just use the weighted ABI here no matter the pool type, just be mindful not to call any type-specific functions
+  const results = await publicClient.multicall({
+    contracts: [
+      {
+        address: poolAddress,
+        abi,
+        functionName: "inRecoveryMode",
+      },
+      {
+        address: poolAddress,
+        abi,
+        functionName: "getPausedState",
+      },
+    ],
+    allowFailure: false, // NOTE: this disallows partial failures of the multicall
+  });
+  return {
+    isPoolInRecoveryMode: results[0],
+    isPoolPaused: results[1][0],
+  } as PoolStatus;
+}

package/src/actions/dex/getPoolWithState.ts

@@ -0,0 +1,24 @@
+import {
+  type MinimalToken,
+  mapPoolType,
+  type PoolState,
+} from "@berachain-foundation/berancer-sdk";
+import type { Address } from "viem";
+
+import type { MinimalPoolFragment } from "@berachain/graphql/dex/api";
+
+export const getPoolState = (apiPool: MinimalPoolFragment): PoolState => {
+  return {
+    type: mapPoolType(apiPool.type),
+    protocolVersion: apiPool.protocolVersion as 1 | 2 | 3,
+    tokens: apiPool.tokens.map<MinimalToken>(
+      (pt) =>
+        ({
+          ...pt,
+          address: pt.address as Address,
+        }) satisfies MinimalToken,
+    ),
+    id: apiPool.id as Address,
+    address: apiPool.address as Address,
+  } satisfies PoolState;
+};

package/src/actions/dex/getSubgraphPool.ts

@@ -0,0 +1,30 @@
+import { isHex } from "viem";
+
+import {
+  GetSubgraphPool,
+  type GetSubgraphPoolQuery,
+  type GetSubgraphPoolQueryVariables,
+} from "@berachain/graphql/dex/subgraph";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export async function getSubgraphPool({
+  poolId,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  poolId: string;
+}) {
+  if (!isHex(poolId)) {
+    throw new Error("poolId is not a valid hex string");
+  }
+  const bexSubgraphClient = getApolloClient("bex.subgraph", args);
+  const res = await bexSubgraphClient.query<
+    GetSubgraphPoolQuery,
+    GetSubgraphPoolQueryVariables
+  >({
+    query: GetSubgraphPool,
+    variables: { id: poolId },
+  });
+
+  return res.data.pool;
+}

package/src/actions/dex/getTransactionCount.ts

@@ -0,0 +1,29 @@
+import { type Address, isAddress, type PublicClient } from "viem";
+
+import { assertPublicClient, InvalidArgumentError } from "~/errors";
+
+export interface GetTransactionCount {
+  address: Address | undefined;
+  publicClient: PublicClient;
+}
+
+export type GetTransactionCountResponse = number | undefined;
+
+export async function getTransactionCount({
+  address,
+  publicClient,
+}: GetTransactionCount): Promise<GetTransactionCountResponse> {
+  assertPublicClient(publicClient);
+
+  if (!address || !isAddress(address))
+    throw new InvalidArgumentError({
+      property: "address",
+      value: address,
+      expected: "Address",
+    });
+
+  const transactionCount = await publicClient.getTransactionCount({
+    address,
+  });
+  return transactionCount;
+}

package/src/actions/dex/getVaultPausedState.ts

@@ -0,0 +1,21 @@
+import type { PublicClient } from "viem";
+
+import { balancerVaultAbi } from "~/abi/bex/balancerVault";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getVaultPausedState({
+  publicClient,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  publicClient: PublicClient;
+}) {
+  const { config } = parseBaseArgs(args);
+
+  const vaultPausedState = await publicClient.readContract({
+    address: config.bex.vault,
+    abi: balancerVaultAbi,
+    functionName: "getPausedState",
+  });
+
+  return vaultPausedState[0];
+}

package/src/actions/enso/bend.ts

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,57 @@
+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/actions/enso/getEnsoUserToken.ts

@@ -0,0 +1,133 @@
+import type { EnsoClient } from "@ensofinance/sdk";
+import * as Sentry from "@sentry/nextjs";
+import { type Config, getChains, multicall } from "@wagmi/core";
+import { type Address, formatUnits } from "viem";
+
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { initBeraError } from "~/errors/initBeraError";
+import type { BalanceTokenWithMetadata } from "~/types/dex";
+import { getBalanceCall } from "../tokens/getWalletBalances";
+
+/**
+ * Get user balances for each supported chain.
+ *
+ * This uses enso's balance endpoint to get the balances and RPC to get fresh balances.
+ */
+export async function getEnsoUserToken({
+  account,
+  wagmiConfig,
+  chainId,
+  ensoClient,
+}: {
+  account: Address;
+  wagmiConfig: Config;
+  chainId: number | "all";
+  ensoClient: EnsoClient;
+}): Promise<BalanceTokenWithMetadata[]> {
+  const ensoBalances = await ensoClient.getBalances({
+    useEoa: true,
+    chainId: chainId ?? "all",
+    eoaAddress: account,
+  });
+
+  const tokens: BalanceTokenWithMetadata[] = ensoBalances.map((balance) => ({
+    name: balance.name,
+    symbol: balance.symbol,
+    decimals: balance.decimals,
+    address: balance.token,
+    logoURI: balance.logoUri,
+    balance: BigInt(balance.amount),
+    formattedBalance: formatUnits(BigInt(balance.amount), balance.decimals),
+    chainId: Number(
+      // @ts-expect-error - balance.chainId is defined just not typed by enso
+      balance.chainId,
+    ),
+    price: Number(balance.price),
+  }));
+
+  const tokenByChainId = Object.groupBy(tokens, (a) => a.chainId ?? 0);
+
+  const balances = await Promise.allSettled(
+    Object.entries(tokenByChainId).map(async ([chainId, chainTokens]) => {
+      if (!chainTokens) return undefined;
+      const chainConfig = getChains(wagmiConfig).find(
+        (chain) => chain.id === Number(chainId),
+      );
+
+      if (!chainConfig) {
+        // if we've queried a chain that is not supported, we need to return undefined
+        return undefined;
+      }
+
+      const multicall3 = chainConfig.contracts?.multicall3;
+
+      const multicallAddress = multicall3?.address;
+
+      if (!multicallAddress) {
+        // if multicall is not supported on this chain, we need to use the enso balance
+        // first let's report the error, as this is likely unexpected
+        Sentry.captureException(
+          new InvalidArgumentError({
+            property: "multicallAddress",
+            value: multicallAddress,
+            expected: "Address",
+            chainId: Number(chainId),
+          }),
+        );
+
+        // we can return the tokens as is, as the balance is already set from the enso client
+        return chainTokens;
+      }
+
+      const balances = await multicall(wagmiConfig, {
+        chainId: Number(chainId),
+        contracts: chainTokens.map((token) =>
+          getBalanceCall({
+            token,
+            account,
+            multicallAddress,
+          }),
+        ),
+        allowFailure: true,
+      });
+
+      const tokensWithBalances: BalanceTokenWithMetadata[] = [];
+
+      for (let index = 0; index < chainTokens.length; index++) {
+        const token = chainTokens[index];
+        if (balances[index].status === "success") {
+          tokensWithBalances.push({
+            ...token,
+            balance: balances[index].result as bigint,
+            formattedBalance: formatUnits(
+              balances[index].result as bigint,
+              token.decimals,
+            ),
+          });
+        } else {
+          console.error("error getting balance", balances[index].error);
+          captureException(initBeraError({ cause: balances[index].error }));
+          // uses enso balance as fallback
+          tokensWithBalances.push(token);
+        }
+      }
+
+      return tokensWithBalances;
+    }),
+  );
+
+  const flattenedBalances: BalanceTokenWithMetadata[] = [];
+  for (const result of balances) {
+    if (result.status === "fulfilled") {
+      flattenedBalances.push(...(result.value ?? []));
+    } else {
+      captureException(initBeraError({ cause: result.reason }));
+    }
+  }
+
+  return flattenedBalances.sort((a, b) => {
+    const aValue = Number(a.formattedBalance) * (a.price ?? 0);
+    const bValue = Number(b.formattedBalance) * (b.price ?? 0);
+    return bValue - aValue;
+  });
+}

package/src/actions/enso/util.ts

@@ -0,0 +1,60 @@
+import { type Address, erc20Abi, ethAddress } from "viem";
+
+import type { GetZapTransactions, GetZapTransactionsArgs } from "~/types";
+
+/**
+ * Get the zap transactions for a given bundle.
+ * @param args - The arguments for the zap transactions.
+ * @returns The the zap transaction & approval transaction if required.
+ */
+export const getTransactionsFromBundle = async ({
+  fromAddress,
+  amountIn,
+  tokenIn,
+  chainId,
+  ensoClient,
+  bundle,
+  publicClient,
+}: GetZapTransactionsArgs): Promise<GetZapTransactions> => {
+  const transactions: GetZapTransactions = [];
+  /**
+   * If the token is not the native token, we need to check if approval is required.
+   */
+  if (tokenIn !== ethAddress) {
+    const approvalRequest = await ensoClient.getApprovalData({
+      fromAddress,
+      tokenAddress: tokenIn,
+      chainId,
+      amount: amountIn,
+    });
+
+    // check if approval is actually required by checking current allowance
+    let requiresApproval = true;
+    if (publicClient) {
+      const currentAllowance = await publicClient.readContract({
+        address: tokenIn as Address,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [fromAddress, approvalRequest.spender],
+      });
+      requiresApproval = currentAllowance < BigInt(amountIn);
+    }
+
+    // Only add approval transaction if it's actually required
+    if (requiresApproval) {
+      transactions.push({
+        to: approvalRequest.tx.to,
+        data: approvalRequest.tx.data as `0x${string}`,
+        value: approvalRequest.tx.value as unknown as bigint,
+        gasLimit: BigInt(approvalRequest.gas),
+      });
+    }
+  }
+  transactions.push({
+    to: bundle.tx.to,
+    data: bundle.tx.data as `0x${string}`,
+    value: bundle.tx.value as unknown as bigint,
+    gasLimit: BigInt(bundle.gas),
+  });
+  return transactions;
+};