@berachain/berajs 0.1.1 → 0.2.0

package/src/actions/pol/getVaultsSupply.ts

@@ -0,0 +1,28 @@
+import type { Address, PublicClient } from "viem";
+
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+
+export interface GetVaultsSupply {
+  vaultAddress: Address;
+  publicClient: PublicClient | undefined;
+}
+
+export async function getVaultsSupply({
+  vaultAddress,
+  publicClient,
+}: GetVaultsSupply): Promise<bigint> {
+  if (!publicClient) throw new Error("Missing public client");
+  if (!vaultAddress) throw new Error("Missing vault address");
+  try {
+    const result = await publicClient.readContract({
+      address: vaultAddress,
+      abi: rewardVaultAbi,
+      functionName: "totalSupply",
+      args: [],
+    });
+    return result as bigint;
+  } catch (error) {
+    console.log(error);
+    throw error;
+  }
+}

package/src/actions/prices/__tests__/prices.integration.test.ts

@@ -0,0 +1,29 @@
+import { getAddress } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { getTokens } from "~/actions/tokens/getTokens";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getTokenCurrentPrices } from "../getTokenCurrentPrices";
+
+describe("prices", async () => {
+  const { config } = parseBaseArgs({});
+  const allTokens = await getTokens();
+
+  const allPrices = await getTokenCurrentPrices({
+    addressIn: allTokens.map((t) => t.address),
+  });
+
+  it("should have lowercase and normalized addresses", () => {
+    const addresses = Object.keys(allPrices ?? {});
+
+    for (const address of addresses) {
+      expect(addresses).toContain(getAddress(address));
+      expect(addresses).toContain(address.toLowerCase());
+    }
+  });
+
+  it("should return the correct price", () => {
+    expect(allPrices[config.tokens.wbera]).toBeDefined();
+    expect(allPrices[config.tokens.wbera]?.price).toBeGreaterThan(0);
+  });
+});

package/src/actions/prices/getTokenCurrentPrices.ts

@@ -0,0 +1,84 @@
+import { getAddress, zeroAddress } from "viem";
+
+import {
+  GetTokenCurrentPrices,
+  type GetTokenCurrentPricesQuery,
+  type GetTokenCurrentPricesQueryVariables,
+  type GqlChain,
+} from "@berachain/graphql/dex/api";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import type { TokenCurrentPriceMap } from "~/types/dex";
+import { getSafeNumber } from "~/utils/formatNumber";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { isToken } from "~/utils/tokens";
+
+export async function getTokenCurrentPrices({
+  addressIn: _addressIn,
+  ...args
+}: {
+  addressIn: string[];
+} & BeraJS.BaseFunctionArgs): Promise<TokenCurrentPriceMap> {
+  const { config, chainId } = parseBaseArgs(args);
+
+  const addressIn = _addressIn
+    .map((a) => a.toLowerCase())
+    .filter((addr, idx, arr) => addr && arr.indexOf(addr) === idx);
+
+  const bexApiGraphqlClient = getApolloClient("api", args);
+
+  const { data } = await bexApiGraphqlClient.query<
+    GetTokenCurrentPricesQuery,
+    GetTokenCurrentPricesQueryVariables
+  >({
+    query: GetTokenCurrentPrices,
+    variables: {
+      chains: [config.bex.chainName as GqlChain],
+      addressIn,
+    },
+  });
+
+  return data.tokenGetCurrentPrices.reduce<TokenCurrentPriceMap>(
+    (map, tokenInformation) => {
+      if (!tokenInformation.price || !tokenInformation.address) {
+        return map;
+      }
+
+      const formattedAddress = tokenInformation.address;
+
+      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,
+        };
+      }
+
+      return map;
+    },
+    {},
+  );
+}

package/src/actions/pyth/getHoneyPythFeeds.ts

@@ -0,0 +1,46 @@
+import type { PublicClient } from "viem";
+
+import type { Address } from "@berachain/config";
+
+import { pythPriceOracleAbi } from "~/abi/honey/pythPriceOracle";
+import type { PythPriceFeedMap } from "~/types/honeySwap";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Given a list of tokens, it will return the price feed ids for each token according to honey priceOracle
+ * @returns
+ */
+export async function getHoneyPythFeeds({
+  tokenList,
+  publicClient,
+  ...args
+}: {
+  tokenList: readonly Address[];
+  publicClient: PublicClient;
+} & BeraJS.BaseFunctionArgs): Promise<PythPriceFeedMap> {
+  const { config } = parseBaseArgs(args);
+
+  try {
+    const priceFeedIds = await Promise.all(
+      tokenList.map((token) =>
+        publicClient.readContract({
+          address: config.honey.pythOracle,
+          abi: pythPriceOracleAbi,
+          functionName: "feeds",
+          args: [token],
+        }),
+      ),
+    );
+
+    return tokenList.reduce<PythPriceFeedMap>(
+      (acc, token, index) => ({
+        ...acc,
+        [token]: priceFeedIds[index],
+      }),
+      {},
+    );
+  } catch (e) {
+    console.error("getPythPriceFeedId", e);
+    throw e;
+  }
+}

package/src/actions/pyth/getUpdateFee.ts

@@ -0,0 +1,27 @@
+import type { Address, PublicClient } from "viem";
+
+import { pythAbi } from "~/abi/pyth/pyth";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getPythUpdateFee({
+  client,
+  priceFeedId,
+  ...args
+}: {
+  client: PublicClient;
+  priceFeedId: Address[];
+} & BeraJS.BaseFunctionArgs) {
+  const { config } = parseBaseArgs(args);
+  try {
+    const result = await client.readContract({
+      address: config.external.pyth,
+      abi: pythAbi,
+      functionName: "getUpdateFee",
+      args: [priceFeedId],
+    });
+    return result;
+  } catch (e) {
+    console.error("getPythUpdateFee", e);
+    throw e;
+  }
+}

package/src/actions/tokens/getAllowances.ts

@@ -0,0 +1,86 @@
+import { type Config, getPublicClient } from "@wagmi/core";
+import {
+  type Address,
+  type ContractFunctionParameters,
+  erc20Abi,
+  formatUnits,
+} from "viem";
+
+import { assertDefined, assertPublicClient } from "~/errors/assert";
+import type { AllowanceQueryItem, AllowanceToken } from "~/types/dex";
+
+export interface GetAllowances {
+  items: AllowanceQueryItem[] | undefined;
+  account: `0x${string}` | undefined;
+  config: Config | undefined;
+}
+
+export type GetAllowancesResponse = AllowanceToken[] | undefined;
+
+export async function getAllowances({
+  items: itemsList,
+  account,
+  config,
+}: GetAllowances): Promise<GetAllowancesResponse> {
+  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

@@ -0,0 +1,60 @@
+import { type Address, erc20Abi, type PublicClient } from "viem";
+
+import { initBeraError } from "~/errors/initBeraError";
+import type { MinimalERC20 } from "~/types/dex";
+
+export interface GetTokenInformation {
+  address: Address;
+  publicClient: PublicClient;
+  chainId: number;
+}
+
+export type GetTokenInformationResponse = MinimalERC20 | undefined;
+
+export async function getTokenInformation({
+  address,
+  publicClient,
+  chainId,
+}: GetTokenInformation): Promise<GetTokenInformationResponse> {
+  try {
+    if (!publicClient) {
+      throw new Error("Public client not found");
+    }
+
+    const [decimals, name, symbol] = await Promise.all([
+      publicClient.readContract({
+        address: address,
+        abi: erc20Abi,
+        functionName: "decimals",
+      }),
+      publicClient.readContract({
+        address: address,
+        abi: erc20Abi,
+        functionName: "name",
+      }),
+      publicClient.readContract({
+        address: address,
+        abi: erc20Abi,
+        functionName: "symbol",
+      }),
+    ]);
+
+    const token = {
+      address,
+      decimals,
+      name,
+      symbol,
+      chainId,
+    };
+    if (
+      typeof token.decimals !== "number" ||
+      typeof token.name !== "string" ||
+      typeof token.symbol !== "string"
+    )
+      throw new Error(`Invalid ERC20 token. Address: ${address}`);
+    return token satisfies MinimalERC20;
+  } catch (e) {
+    console.error(e);
+    throw initBeraError({ cause: e });
+  }
+}

package/src/actions/tokens/getTokens.ts

@@ -0,0 +1,19 @@
+import type { TokenWithMetadata } from "~/types/dex";
+import { beraFetchJson } from "~/utils/beraFetch";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+export async function getTokens({
+  url,
+  ...args
+}: BeraJS.BaseFunctionArgs & { url?: string } = {}): Promise<
+  TokenWithMetadata[]
+> {
+  const { config } = parseBaseArgs(args);
+  const tokenList = await beraFetchJson<{ tokens: TokenWithMetadata[] }>({
+    url: url ?? config.lists.tokenList,
+    type: "rest",
+    name: "GitHub",
+  });
+
+  return tokenList.tokens ?? [];
+}

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

@@ -0,0 +1,79 @@
+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 { isToken } from "~/utils/tokens";
+import { getTokens } from "./getTokens";
+import { getWalletBalances } from "./getWalletBalances";
+
+/**
+ * This is a test EOA that was generated randomly. It's used for this test only.
+ *
+ * We'll send it small amounts of balances that will never change since now one can transfer them.
+ */
+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 balances = await getWalletBalances({
+      account,
+      wagmiConfig,
+      tokenList: [
+        ...tokenList,
+        {
+          address: "0x0000000000000000000000000000000000000000",
+          decimals: 18,
+          symbol: "ETH",
+          name: "Ether",
+          chainId: 1,
+        },
+      ],
+    }).catch((error) => {
+      assert.fail(error);
+    });
+    expect(balances).toBeDefined();
+    const beraBalance = balances?.find((b) => isToken(b, "BERA"));
+
+    expect(beraBalance).toBeDefined();
+
+    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

@@ -0,0 +1,149 @@
+import { type Config, getChainId, getPublicClient } from "@wagmi/core";
+import {
+  type Address,
+  type ContractFunctionParameters,
+  erc20Abi,
+  formatUnits,
+  isAddress,
+} from "viem";
+
+import { multicall3Abi } from "~/abi/utils/multicall3";
+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;
+  wagmiConfig: Config | undefined;
+}
+
+/**
+ * Returns the payload for the balanceOf call for a given token and account.
+ *
+ * @internal
+ * @returns
+ */
+export function getBalanceCall({
+  token,
+  account,
+  multicallAddress,
+}: {
+  token: Token;
+  account: Address;
+  multicallAddress: Address;
+}) {
+  if (isToken(token, "BERA") || isToken(token, "ETH")) {
+    return {
+      address: multicallAddress,
+      abi: multicall3Abi,
+      functionName: "getEthBalance",
+      args: [account],
+    } as const satisfies ContractFunctionParameters<
+      typeof multicall3Abi,
+      "view",
+      "getEthBalance"
+    >;
+  }
+  return {
+    address: token.address as Address,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [account],
+  } as const satisfies ContractFunctionParameters<
+    typeof erc20Abi,
+    "view",
+    "balanceOf"
+  >;
+}
+
+/**
+ * fetch the balances of a given wallet address
+ */
+export async function getWalletBalances({
+  account,
+  tokenList,
+  wagmiConfig: config,
+}: GetWalletBalances): Promise<BalanceToken[] | undefined> {
+  assertDefined(config, "config");
+  if (!account || !tokenList)
+    throw new Error("account or tokenList is not defined");
+
+  assertAddress(account, "account");
+
+  const filteredTokenList = tokenList.filter((token) =>
+    isAddress(token.address),
+  );
+
+  const tokensByChainId = Object.groupBy(
+    filteredTokenList,
+    (token) => token.chainId ?? getChainId(config),
+  );
+
+  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;
+
+      assertAddress(multicall3Address, "multicall3Address");
+
+      const call = tokens.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;
+      });
+    }),
+  );
+
+  return res.flatMap((result) =>
+    result.status === "fulfilled" ? result.value : [],
+  );
+}