@berachain/berajs 0.1.0 → 0.1.2

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,59 @@
+import {
+  type Address,
+  type ContractFunctionParameters,
+  erc20Abi,
+  formatUnits,
+  type PublicClient,
+} from "viem";
+
+import type { AllowanceToken, Token } from "~/types";
+
+export interface GetAllowances {
+  tokens: Token[] | undefined;
+  account: `0x${string}` | undefined;
+  spender: string | undefined;
+  publicClient: PublicClient | undefined;
+}
+
+export type GetAllowancesResponse = AllowanceToken[] | undefined;
+
+export async function getAllowances({
+  tokens,
+  account,
+  spender,
+  publicClient,
+}: 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;
+}

package/src/actions/tokens/getTokenInformation.ts

@@ -0,0 +1,57 @@
+import { type Address, erc20Abi, type PublicClient } from "viem";
+
+import { initBeraError } from "~/errors/initBeraError";
+import type { MinimalERC20 } from "~/types";
+
+export interface GetTokenInformation {
+  address: Address;
+  publicClient: PublicClient;
+}
+
+export type GetTokenInformationResponse = MinimalERC20 | undefined;
+
+export async function getTokenInformation({
+  address,
+  publicClient,
+}: 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,
+    };
+    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";
+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/getWalletBalances.integration.test.ts

@@ -0,0 +1,40 @@
+import { berachain } from "viem/chains";
+import { assert, describe, expect, it, vi } from "vitest";
+
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+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 () => {
+  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,
+    }).catch((error) => {
+      assert.fail(error);
+    });
+    expect(balances).toBeDefined();
+    const beraBalance = balances?.find((b) => isToken(b, "BERA"));
+
+    expect(beraBalance).toBeDefined();
+
+    expect(beraBalance?.balance).toBeGreaterThan(0n);
+  });
+});

package/src/actions/tokens/getWalletBalances.ts

@@ -0,0 +1,123 @@
+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 type { BalanceToken, Token } from "~/types/dex";
+import { isToken } from "~/utils/tokens";
+
+export interface GetWalletBalances {
+  account: string | undefined;
+  tokenList: Token[] | undefined;
+  publicClient: PublicClient | 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,
+  publicClient,
+}: GetWalletBalances): Promise<BalanceToken[] | undefined> {
+  if (!publicClient) throw new Error("publicClient is not defined");
+  if (!account || !tokenList)
+    throw new Error("account or tokenList is not defined");
+
+  if (!isAddress(account)) throw new Error("account is not a valid address");
+
+  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 { multicall3 } = publicClient.chain.contracts;
+
+  const multicall3Address =
+    typeof multicall3 === "string" ? multicall3 : multicall3.address;
+
+  assertAddress(multicall3Address, "multicall3Address");
+
+  const call = filteredTokenList.map((token: Token) =>
+    getBalanceCall({
+      token,
+      account,
+      multicallAddress: multicall3Address,
+    }),
+  );
+
+  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 balances as BalanceToken[];
+}

package/src/actions/transactions/beraWriteContract.integration.test.ts

@@ -0,0 +1,251 @@
+import {
+  type Address,
+  createWalletClient,
+  encodeFunctionData,
+  erc20Abi,
+  http,
+  parseEther,
+  zeroAddress,
+} from "viem";
+import { mnemonicToAccount } from "viem/accounts";
+import { assert, describe, expect, it } from "vitest";
+
+import { ChainId, getRpcUrls } from "@berachain/config/internal";
+
+import { defaultBeraNetworkConfig, wagmiConfig } from "@berachain/wagmi/config";
+
+import { bgtAbi } from "~/abi/pol/bgt";
+import { TransactionActionType } from "~/enum/txnEnum";
+import type { IContractWriteFn } from "~/types/global";
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { getTestClient } from "~/utils/getTestClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { anvilMnemonic } from "~/utils/test-utils";
+import { rewardVaultAbi } from "../../abi/pol/rewardVault";
+import { getUserVaults } from "../pol/getUserVaults";
+import { beraWriteContract } from "./beraWriteContract";
+
+const testFn: IContractWriteFn = async (_args) => {
+  return undefined;
+};
+
+describe("beraWriteContract", () => {
+  const { config, chainId } = parseBaseArgs({});
+  const anvilMockAccount = mnemonicToAccount(anvilMnemonic);
+
+  /**
+   * These are validator addresses for the chains we test on. We're assuming they have BGTs
+   */
+  const valMap: Record<ChainId, Address> = {
+    [ChainId.MAINNET]: "0xb71b3DaEA39012Fb0f2B14D2a9C86da9292fC126",
+    [ChainId.BEPOLIA]: "0x0d283A8AFf77f4fb7B7A9EC78B09b26E083dA304",
+  };
+
+  const wallet = valMap[chainId];
+
+  const publicClient = getServerSidePublicClient();
+  const walletClient = createWalletClient({
+    transport: http(getRpcUrls().publicJsonRpcUrl),
+    account: anvilMockAccount,
+    chain: defaultBeraNetworkConfig.chain,
+  });
+
+  it("should have proper types", async () => {
+    // THE FOLLOWING LINES ARE JUST FOR TESTING TYPESCRIPT
+    // THEY WILL NEVER EXECUTE
+    if (Date.now() === 0) {
+      await beraWriteContract({
+        config: wagmiConfig,
+        address: zeroAddress,
+        abi: erc20Abi,
+        // @ts-expect-error wrongMethod is not in the abi
+        functionName: "wrongMethod",
+        walletClient,
+        // @ts-expect-error wrong params
+        params: [],
+      }).catch(() => {});
+
+      await beraWriteContract({
+        config: wagmiConfig,
+        address: zeroAddress,
+        abi: erc20Abi,
+        functionName: "approve",
+        walletClient,
+        // @ts-expect-error wrong params
+        params: [zeroAddress, zeroAddress],
+      }).catch(() => {});
+
+      await testFn({
+        address: zeroAddress,
+        abi: erc20Abi,
+        // @ts-expect-error wrongMethod is not in the abi
+        functionName: "wrongMethod",
+        // @ts-expect-error wrong params
+        params: [],
+      }).catch(() => {});
+
+      await testFn({
+        address: zeroAddress,
+        abi: erc20Abi,
+        functionName: "approve",
+        // @ts-expect-error wrong params
+        params: [zeroAddress, zeroAddress],
+      }).catch(() => {});
+      await testFn({
+        address: zeroAddress,
+        abi: erc20Abi,
+        functionName: "approve",
+        // @ts-expect-error wrong params
+        params: [zeroAddress, zeroAddress],
+      }).catch(() => {});
+    }
+  });
+
+  it("should send raw value", async () => {
+    await beraWriteContract({
+      wagmiConfig,
+      account: anvilMockAccount,
+      address: zeroAddress,
+      value: 10n,
+      walletClient,
+      message: "test",
+      actionType: TransactionActionType.APPROVAL,
+      onError: (e) => assert.fail(e.message),
+    });
+  });
+
+  const redeemAmount = parseEther("1");
+
+  it(
+    "should encode and send tx",
+    {
+      // Fails frequently on CI probably because of the anvil node
+      retry: 3,
+    },
+    async () => {
+      const testClient = getTestClient();
+
+      await testClient.setBalance({
+        address: wallet,
+        value: parseEther("1000"),
+      });
+
+      const bgtBalance = await publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "balanceOf",
+        args: [wallet],
+      });
+
+      const tx = await beraWriteContract({
+        wagmiConfig,
+        walletClient,
+        account: wallet,
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        functionName: "redeem",
+        params: [zeroAddress, redeemAmount],
+        message: "test",
+        actionType: TransactionActionType.REDEEM_BGT,
+        onError: (e) => {
+          assert.fail(e.message);
+        },
+      });
+
+      expect(tx).toBeDefined();
+
+      const postTxBgtBalance = await publicClient.readContract({
+        address: config.tokens.bgt,
+        abi: bgtAbi,
+        blockTag: "pending",
+        functionName: "balanceOf",
+        args: [wallet],
+      });
+
+      expect(postTxBgtBalance).toBe(bgtBalance - redeemAmount);
+    },
+  );
+
+  it("should send raw tx", async () => {
+    const testClient = getTestClient();
+
+    await testClient.setBalance({
+      address: wallet,
+      value: parseEther("1000"),
+    });
+
+    const bgtBalance = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "balanceOf",
+      args: [wallet],
+    });
+
+    const data = encodeFunctionData({
+      abi: bgtAbi,
+      functionName: "redeem",
+      args: [zeroAddress, parseEther("1")],
+    });
+
+    const tx = await beraWriteContract({
+      wagmiConfig,
+      walletClient,
+      account: wallet,
+      address: config.tokens.bgt,
+      data,
+      message: "test",
+      actionType: TransactionActionType.REDEEM_BGT,
+      onError: (e) => assert.fail(e.message),
+    });
+
+    expect(tx).toBeDefined();
+
+    await testClient.mine({ blocks: 1 });
+
+    const postTxBalance = await publicClient.readContract({
+      address: config.tokens.bgt,
+      abi: bgtAbi,
+      functionName: "balanceOf",
+      args: [wallet],
+      blockTag: "pending",
+    });
+
+    expect(postTxBalance).toBe(bgtBalance - redeemAmount);
+  });
+
+  it.todo("should send batch calls", async () => {
+    const testClient = getTestClient();
+    const bepoliaGodWallet = "0x0cF32C7C003Bd9Fdbd5Ba635DAEDCb1070E77dE0";
+
+    const userVaults = await getUserVaults({
+      account: bepoliaGodWallet,
+      publicClient,
+    });
+    const eip7702Delegator = "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b";
+    await testClient.setCode({
+      address: bepoliaGodWallet,
+      bytecode: `0xef0100${eip7702Delegator.replace("0x", "")}`,
+    });
+    await testClient.setBalance({
+      address: bepoliaGodWallet,
+      value: parseEther("1000"),
+    });
+
+    const tx = await beraWriteContract({
+      wagmiConfig,
+      walletClient,
+      account: bepoliaGodWallet,
+      message: "test",
+      actionType: TransactionActionType.APPROVAL,
+      calls: userVaults.vaults.map((vault) => ({
+        address: vault.vault.address as Address,
+        abi: rewardVaultAbi,
+        functionName: "getReward",
+        params: [bepoliaGodWallet, bepoliaGodWallet],
+      })),
+      onError: (e) => assert.fail(e.message),
+    });
+
+    expect(tx).toBeDefined();
+  });
+});