@berachain/berajs 0.1.2 → 0.2.0

package/src/actions/pol/getStakingDailyAssets.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+
+import { beraFetchJson } from "~/utils/beraFetch";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getStakingDailyAssets({
+  address,
+  range,
+}: {
+  address: Address;
+  range: 30 | 60 | 90;
+}): Promise<{ _timestamp: number; total_assets: string }[]> {
+  const now = new Date();
+  const startDayDate = new Date(
+    now.getTime() - Number(range) * 24 * 60 * 60 * 1000,
+  );
+
+  const { config } = parseBaseArgs({});
+  const url = `${config.bonder}/vaults/${address}/total-assets-by-day?start=${startDayDate.toISOString().split("T")[0]}`;
+  return beraFetchJson<{ _timestamp: number; total_assets: string }[]>(url);
+}

package/src/actions/pol/getStakingTokenInformation.ts

@@ -1,12 +1,11 @@
-import type { GetPublicClientReturnType } from "@wagmi/core";
-import { type Address, erc20Abi, formatUnits } from "viem";
+import { type Address, erc20Abi, formatUnits, type PublicClient } from "viem";
 
 import { assertPublicClient } from "~/errors/assert";
-import type { Token } from "~/types";
+import type { Token } from "~/types/dex";
 
 export interface GetStakingTokenInformation {
   address: Address;
-  publicClient: GetPublicClientReturnType;
+  publicClient: PublicClient | undefined;
 }
 
 export type GetStakingTokenInformationResponse = Partial<Token> | undefined;

package/src/actions/pol/getTotalStakedAmount.ts

@@ -0,0 +1,47 @@
+import type { PublicClient } from "viem";
+
+import type { Address } from "@berachain/config";
+
+import { stakeBeraVaultAbi } from "~/abi/pol/stakeBeraVault";
+import { assertPublicClient } from "~/errors/assert";
+
+/**
+ * Get the total staked amount for a given vault address
+ * @param vaultAddresses - The addresses of the vaults to get the total staked amount for
+ * @param publicClient - The public client to use to get the total staked amount
+ * @returns The total staked amount for the given vault addresses
+ */
+export async function getTotalStakedAmount({
+  vaultAddresses,
+  publicClient,
+}: {
+  vaultAddresses: Address[];
+  publicClient?: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<Record<Address, bigint>> {
+  assertPublicClient(publicClient);
+
+  try {
+    const totalAssets = await Promise.all(
+      vaultAddresses.map(async (address) => {
+        return await publicClient.readContract({
+          address,
+          abi: stakeBeraVaultAbi,
+          functionName: "totalAssets",
+        });
+      }),
+    );
+
+    const stakedAmount = vaultAddresses.reduce(
+      (acc, address, index) => {
+        acc[address] = totalAssets[index];
+        return acc;
+      },
+      {} as Record<Address, bigint>,
+    );
+
+    return stakedAmount;
+  } catch (error) {
+    console.error("Failed to get total staked amount", error);
+    throw error;
+  }
+}

package/src/actions/pol/getUserClaimableIncentives.ts

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

package/src/actions/pol/getUserVaults.ts

@@ -1,4 +1,3 @@
-import * as Sentry from "@sentry/nextjs";
 import { type Address, formatUnits, type PublicClient } from "viem";
 
 import {
@@ -11,6 +10,8 @@ import {
 
 import { rewardVaultAbi } from "~/abi/pol/rewardVault";
 import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { BeraError } from "~/errors/BeraError";
+import { BeraMonitoring } from "~/errors/BeraMonitoring";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 
 export interface UserVault {
@@ -100,13 +101,14 @@ export async function getUserVaults({
       if (!deposit.vault) {
         // This is in case the API is missing the vault data
 
-        Sentry.captureException(
-          new Error("Deposit data from API is missing vault"),
-          {
-            data: {
+        BeraMonitoring.captureException(
+          new BeraError({
+            message: "Deposit data from API is missing vault",
+            level: "error",
+            extra: {
               deposit,
             },
-          },
+          }),
         );
 
         console.error("Deposit data from API is missing vault", deposit);

package/src/actions/pol/getUserVaultsBalance.ts

@@ -1,7 +1,7 @@
-import { type Address, isAddress, type PublicClient } from "viem";
+import type { Address, PublicClient } from "viem";
 
 import { rewardVaultAbi } from "~/abi/pol/rewardVault";
-import { assertPublicClient, InvalidArgumentError } from "~/errors";
+import { assertAddress, assertPublicClient } from "~/errors/assert";
 
 export interface GetUserVaultsInfo {
   account: string | undefined;
@@ -15,20 +15,8 @@ export async function getUserVaultsBalance({
   publicClient,
 }: GetUserVaultsInfo): Promise<{ balance: bigint; delegated: bigint }> {
   assertPublicClient(publicClient);
-
-  if (!account || !isAddress(account))
-    throw new InvalidArgumentError({
-      property: "account",
-      value: account,
-      expected: "Address",
-    });
-
-  if (!vaultAddress || !isAddress(vaultAddress))
-    throw new InvalidArgumentError({
-      property: "vaultAddress",
-      value: vaultAddress,
-      expected: "Address",
-    });
+  assertAddress(account, "account");
+  assertAddress(vaultAddress, "vaultAddress");
 
   try {
     const [balance, delegated] = await Promise.all([

package/src/actions/prices/getTokenCurrentPrices.ts

@@ -8,8 +8,8 @@ import {
 } from "@berachain/graphql/dex/api";
 
 import { getApolloClient } from "~/actions/clients/getApolloClient";
-import type { TokenCurrentPriceMap } from "~/types";
-import { getSafeNumber } from "~/utils";
+import type { TokenCurrentPriceMap } from "~/types/dex";
+import { getSafeNumber } from "~/utils/formatNumber";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 import { isToken } from "~/utils/tokens";
 
@@ -19,7 +19,7 @@ export async function getTokenCurrentPrices({
 }: {
   addressIn: string[];
 } & BeraJS.BaseFunctionArgs): Promise<TokenCurrentPriceMap> {
-  const { config } = parseBaseArgs(args);
+  const { config, chainId } = parseBaseArgs(args);
 
   const addressIn = _addressIn
     .map((a) => a.toLowerCase())
@@ -49,26 +49,31 @@ export async function getTokenCurrentPrices({
       map[getAddress(formattedAddress)] = {
         price: getSafeNumber(tokenInformation.price.toString()),
         updatedAt: tokenInformation.updatedAt,
+        chainId,
       };
 
       map[formattedAddress.toLowerCase()] = {
         price: getSafeNumber(tokenInformation.price.toString()),
         updatedAt: tokenInformation.updatedAt,
+        chainId,
       };
 
       if (isToken(formattedAddress, "WBERA")) {
         map[zeroAddress] = {
           price: getSafeNumber(tokenInformation.price.toString()),
           updatedAt: tokenInformation.updatedAt,
+          chainId,
         };
         map[config.tokens.bgt.toLowerCase()] = {
           price: getSafeNumber(tokenInformation.price.toString()),
           updatedAt: tokenInformation.updatedAt,
+          chainId,
         };
 
         map[config.tokens.bgt] = {
           price: getSafeNumber(tokenInformation.price.toString()),
           updatedAt: tokenInformation.updatedAt,
+          chainId,
         };
       }
 

package/src/actions/tokens/getAllowances.ts

@@ -1,59 +1,86 @@
+import { type Config, getPublicClient } from "@wagmi/core";
 import {
   type Address,
   type ContractFunctionParameters,
   erc20Abi,
   formatUnits,
-  type PublicClient,
 } from "viem";
 
-import type { AllowanceToken, Token } from "~/types";
+import { assertDefined, assertPublicClient } from "~/errors/assert";
+import type { AllowanceQueryItem, AllowanceToken } from "~/types/dex";
 
 export interface GetAllowances {
-  tokens: Token[] | undefined;
+  items: AllowanceQueryItem[] | undefined;
   account: `0x${string}` | undefined;
-  spender: string | undefined;
-  publicClient: PublicClient | undefined;
+  config: Config | undefined;
 }
 
 export type GetAllowancesResponse = AllowanceToken[] | undefined;
 
 export async function getAllowances({
-  tokens,
+  items: itemsList,
   account,
-  spender,
-  publicClient,
+  config,
 }: GetAllowances): Promise<GetAllowancesResponse> {
-  if (!publicClient || !tokens || !spender)
-    throw new Error("missing publicClient, tokens, or spender");
-  if (account) {
-    const call = tokens.map<ContractFunctionParameters<typeof erc20Abi>>(
-      (item: Token) => ({
-        address: item.address as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "allowance",
-        args: [account, spender as Address],
-      }),
-    );
-
-    const result = await publicClient.multicall({
-      contracts: call,
-    });
-
-    const allowances = result.map((item: any, index: number) => {
-      const token = tokens[index];
-      if (item.error) {
-        return { balance: 0, ...token };
-      }
-
-      const resultAllowanceToken: AllowanceToken = {
-        allowance: item.result,
-        formattedAllowance: formatUnits(item.result, token?.decimals || 18),
-        ...token,
-      } as AllowanceToken;
-      return resultAllowanceToken;
-    });
-    return allowances as AllowanceToken[];
-  }
-
-  return undefined;
+  assertDefined(itemsList, "items");
+  assertDefined(config, "config");
+  assertDefined(account, "account");
+
+  const tokensByChainId = Object.groupBy(
+    itemsList,
+    (item) => item.token.chainId,
+  );
+
+  const res = await Promise.allSettled(
+    Object.entries(tokensByChainId).map(async ([chainId, items]) => {
+      if (!items) return [];
+
+      const publicClient = getPublicClient(config, {
+        chainId: Number(chainId),
+      });
+      assertPublicClient(publicClient, `publicClient ${chainId}`);
+
+      const result = await publicClient.multicall({
+        contracts: items.map(
+          (item) =>
+            ({
+              address: item.token.address,
+              abi: erc20Abi,
+              functionName: "allowance",
+              args: [account, item.spender as Address],
+            }) as const as ContractFunctionParameters<
+              typeof erc20Abi,
+              "view",
+              "allowance"
+            >,
+        ),
+      });
+
+      const allowances = result.map((item, index: number) => {
+        const token = items[index];
+        if (item.error) {
+          return undefined;
+        }
+
+        const resultAllowanceToken: AllowanceToken = {
+          token: token.token,
+          spender: token.spender,
+          amount: token.amount,
+          allowance: {
+            raw: item.result.toString(),
+            formatted: formatUnits(item.result, token.token.decimals),
+          },
+          needsApproval: item.result < BigInt(token.amount.raw),
+        } satisfies AllowanceToken;
+        return resultAllowanceToken;
+      });
+      return allowances.filter((i): i is AllowanceToken => Boolean(i));
+    }),
+  );
+
+  return res
+    .flatMap((result) =>
+      result.status === "fulfilled" ? result.value : undefined,
+    )
+    .filter((i): i is AllowanceToken => Boolean(i));
 }

package/src/actions/tokens/getTokenInformation.ts

@@ -1,11 +1,12 @@
 import { type Address, erc20Abi, type PublicClient } from "viem";
 
 import { initBeraError } from "~/errors/initBeraError";
-import type { MinimalERC20 } from "~/types";
+import type { MinimalERC20 } from "~/types/dex";
 
 export interface GetTokenInformation {
   address: Address;
   publicClient: PublicClient;
+  chainId: number;
 }
 
 export type GetTokenInformationResponse = MinimalERC20 | undefined;
@@ -13,6 +14,7 @@ export type GetTokenInformationResponse = MinimalERC20 | undefined;
 export async function getTokenInformation({
   address,
   publicClient,
+  chainId,
 }: GetTokenInformation): Promise<GetTokenInformationResponse> {
   try {
     if (!publicClient) {
@@ -42,6 +44,7 @@ export async function getTokenInformation({
       decimals,
       name,
       symbol,
+      chainId,
     };
     if (
       typeof token.decimals !== "number" ||

package/src/actions/tokens/getTokens.ts

@@ -1,4 +1,4 @@
-import type { TokenWithMetadata } from "~/types";
+import type { TokenWithMetadata } from "~/types/dex";
 import { beraFetchJson } from "~/utils/beraFetch";
 import { parseBaseArgs } from "~/utils/parseBaseArgs";
 

package/src/actions/tokens/getUnderlyingToken.ts

@@ -0,0 +1,53 @@
+import { type Config, getPublicClient } from "@wagmi/core";
+import { erc4626Abi } from "viem";
+
+import { assertPublicClient } from "~/errors/assert";
+import { initBeraError } from "~/errors/initBeraError";
+import type { MinimalERC20 } from "~/types/dex";
+import { isToken } from "~/utils/tokens";
+import { getTokenInformation } from "./getTokenInformation";
+
+/**
+ * Attempts to resolve the underlying asset of an ERC4626 vault by calling `asset()`.
+ * Returns the full token info if the token is an ERC4626 vault, or `null` if it isn't
+ * (i.e. the `asset()` call reverts). Skips the native gas token (BERA) since it can't be a vault.
+ */
+export async function getUnderlyingToken({
+  token,
+  wagmiConfig,
+}: {
+  token: MinimalERC20;
+  wagmiConfig: Config;
+}) {
+  try {
+    if (isToken(token, "BERA")) {
+      // gas token can't have an underlying token
+      return null;
+    }
+
+    const publicClient = getPublicClient(wagmiConfig, {
+      chainId: token.chainId,
+    });
+
+    assertPublicClient(publicClient);
+
+    const address = await publicClient.readContract({
+      address: token.address,
+      abi: erc4626Abi,
+      functionName: "asset",
+    });
+
+    return await getTokenInformation({
+      address: address,
+      publicClient,
+      chainId: token.chainId,
+    });
+  } catch (e) {
+    const err = initBeraError({ cause: e });
+    if (err.reason === 'The contract function "asset" reverted.') {
+      return null;
+    }
+
+    throw err;
+  }
+}

package/src/actions/tokens/getWalletBalances.integration.test.ts

@@ -1,7 +1,15 @@
-import { berachain } from "viem/chains";
-import { assert, describe, expect, it, vi } from "vitest";
+import { ethAddress } from "viem";
+import { assert, describe, expect, it } from "vitest";
+
+import { appConfig } from "@berachain/config/internal";
+import {
+  defaultChain,
+  externalChains,
+  transports,
+} from "@berachain/config/internal/wagmi";
+
+import { getConfig } from "@berachain/wagmi/config";
 
-import { getServerSidePublicClient } from "~/utils/getServerSideClient";
 import { isToken } from "~/utils/tokens";
 import { getTokens } from "./getTokens";
 import { getWalletBalances } from "./getWalletBalances";
@@ -13,20 +21,28 @@ import { getWalletBalances } from "./getWalletBalances";
  */
 const account = "0x08194D89A52C1410F4bcc46FE11AC2387aC69de8";
 describe("getWalletBalances", async () => {
+  const { wagmi: wagmiConfig } = getConfig({
+    transports,
+    defaultChain,
+    chains: externalChains,
+    thirdweb: { clientId: appConfig.apiKeys.public.thirdweb },
+  });
+
   it("should have gas balance", async () => {
     const tokenList = await getTokens();
-    const publicClient = getServerSidePublicClient();
-    publicClient.chain = berachain;
-    publicClient.multicall = vi.fn().mockResolvedValue(
-      tokenList.map(() => ({
-        result: 123n,
-      })),
-    );
-
     const balances = await getWalletBalances({
       account,
-      publicClient,
-      tokenList,
+      wagmiConfig,
+      tokenList: [
+        ...tokenList,
+        {
+          address: "0x0000000000000000000000000000000000000000",
+          decimals: 18,
+          symbol: "ETH",
+          name: "Ether",
+          chainId: 1,
+        },
+      ],
     }).catch((error) => {
       assert.fail(error);
     });
@@ -35,6 +51,29 @@ describe("getWalletBalances", async () => {
 
     expect(beraBalance).toBeDefined();
 
-    expect(beraBalance?.balance).toBeGreaterThan(0n);
+    expect(BigInt(beraBalance?.balance.raw)).toBeGreaterThan(0n);
+  });
+
+  it("should have balance for multiple chains", async () => {
+    const balances = await getWalletBalances({
+      account,
+      wagmiConfig,
+      tokenList: [
+        {
+          address: ethAddress,
+          decimals: 18,
+          symbol: "ETH",
+          name: "Ether",
+          chainId: 1,
+        },
+      ],
+    }).catch((error) => {
+      assert.fail(error);
+    });
+    expect(balances).toBeDefined();
+    expect(balances?.length).toBeGreaterThan(0);
+    expect(balances?.some((b) => isToken(b, "ETH") && b.chainId === 1)).toBe(
+      true,
+    );
   });
 });

package/src/actions/tokens/getWalletBalances.ts

@@ -1,21 +1,25 @@
+import { type Config, getChainId, getPublicClient } from "@wagmi/core";
 import {
   type Address,
   type ContractFunctionParameters,
   erc20Abi,
   formatUnits,
   isAddress,
-  type PublicClient,
 } from "viem";
 
 import { multicall3Abi } from "~/abi/utils/multicall3";
-import { assertAddress, assertDefined } from "~/errors/assert";
+import {
+  assertAddress,
+  assertDefined,
+  assertPublicClient,
+} from "~/errors/assert";
 import type { BalanceToken, Token } from "~/types/dex";
 import { isToken } from "~/utils/tokens";
 
 export interface GetWalletBalances {
   account: string | undefined;
   tokenList: Token[] | undefined;
-  publicClient: PublicClient | undefined;
+  wagmiConfig: Config | undefined;
 }
 
 /**
@@ -63,61 +67,83 @@ export function getBalanceCall({
 export async function getWalletBalances({
   account,
   tokenList,
-  publicClient,
+  wagmiConfig: config,
 }: GetWalletBalances): Promise<BalanceToken[] | undefined> {
-  if (!publicClient) throw new Error("publicClient is not defined");
+  assertDefined(config, "config");
   if (!account || !tokenList)
     throw new Error("account or tokenList is not defined");
 
-  if (!isAddress(account)) throw new Error("account is not a valid address");
+  assertAddress(account, "account");
 
   const filteredTokenList = tokenList.filter((token) =>
     isAddress(token.address),
   );
-  assertDefined(publicClient.chain, "publicClient.chain");
-  assertDefined(publicClient.chain.contracts, "publicClient.chain.contracts");
-  assertDefined(
-    publicClient.chain.contracts.multicall3,
-    "publicClient.chain.contracts.multicall3",
+
+  const tokensByChainId = Object.groupBy(
+    filteredTokenList,
+    (token) => token.chainId ?? getChainId(config),
   );
 
-  const { multicall3 } = publicClient.chain.contracts;
+  const res = await Promise.allSettled(
+    Object.entries(tokensByChainId).map(async ([chainId, tokens]) => {
+      assertDefined(tokens, "tokens");
+      const publicClient = getPublicClient(config, {
+        chainId: Number(chainId),
+      });
+      assertPublicClient(publicClient, `publicClient ${chainId}`);
+      assertDefined(publicClient.chain, "publicClient.chain");
+      assertDefined(
+        publicClient.chain.contracts,
+        "publicClient.chain.contracts",
+      );
+      assertDefined(
+        publicClient.chain.contracts.multicall3,
+        "publicClient.chain.contracts.multicall3",
+      );
+
+      const { multicall3 } = publicClient.chain.contracts;
+
+      const multicall3Address =
+        typeof multicall3 === "string" ? multicall3 : multicall3.address;
 
-  const multicall3Address =
-    typeof multicall3 === "string" ? multicall3 : multicall3.address;
+      assertAddress(multicall3Address, "multicall3Address");
 
-  assertAddress(multicall3Address, "multicall3Address");
+      const call = tokens.map((token: Token) =>
+        getBalanceCall({
+          token,
+          account,
+          multicallAddress: multicall3Address,
+        }),
+      );
 
-  const call = filteredTokenList.map((token: Token) =>
-    getBalanceCall({
-      token,
-      account,
-      multicallAddress: multicall3Address,
+      const result = await publicClient.multicall({
+        contracts: call,
+      });
+
+      return result.map((item, index) => {
+        const token = tokens[index];
+        if (item.error) {
+          return { ...token, balance: { raw: "0", formatted: "0" } };
+        }
+        const formattedBalance = formatUnits(
+          item.result,
+          token?.decimals || 18,
+        );
+
+        const resultBalanceToken: BalanceToken = {
+          ...token,
+          balance: {
+            raw: item.result.toString(),
+            // TODO: this was done 10 months ago, i'm not sure it's a good solution.
+            formatted: formattedBalance.includes("e") ? "0" : formattedBalance,
+          },
+        } satisfies BalanceToken;
+        return resultBalanceToken;
+      });
     }),
   );
 
-  const result = await publicClient.multicall({
-    contracts: call,
-  });
-
-  const balances = await Promise.all(
-    result.map(async (item, index) => {
-      const token = filteredTokenList[index];
-      if (item.error) {
-        return { balance: 0n, formattedBalance: "0", ...token };
-      }
-      const formattedBalance = formatUnits(item.result, token?.decimals || 18);
-
-      const resultBalanceToken: BalanceToken = {
-        balance: item.result,
-        // TODO: this was done 10 months ago, i'm not sure it's a good solution.
-        formattedBalance: formattedBalance.includes("e")
-          ? "0"
-          : formattedBalance,
-        ...token,
-      } as BalanceToken;
-      return resultBalanceToken;
-    }),
+  return res.flatMap((result) =>
+    result.status === "fulfilled" ? result.value : [],
   );
-  return balances as BalanceToken[];
 }