@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/dist/chunk-HYDP32P6.mjs

@@ -0,0 +1,135 @@
+import {
+  multicall3Abi
+} from "./chunk-HQCOU6GY.mjs";
+import {
+  assertAddress,
+  assertDefined,
+  assertPublicClient
+} from "./chunk-GY6B3PD5.mjs";
+import {
+  isToken
+} from "./chunk-IXIBY5FP.mjs";
+import {
+  parseBaseArgs
+} from "./chunk-DQRH5VE3.mjs";
+
+// src/actions/clients/getEnsoClient.ts
+import { EnsoClient } from "@ensofinance/sdk";
+import { appConfig } from "@berachain/config/internal";
+var isProduction = process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test";
+function getEnsoClient({
+  baseURL,
+  ...args
+} = {}) {
+  const { config } = parseBaseArgs(args);
+  const resolvedBaseURL = baseURL !== void 0 ? baseURL : isProduction ? `${config.bex.aggregatorsProxyUrl}/enso/api/v1/` : void 0;
+  return new EnsoClient({
+    baseURL: resolvedBaseURL,
+    // no API key when routing through a proxy — the proxy handles auth
+    apiKey: resolvedBaseURL ? "" : appConfig.apiKeys.public.enso
+  });
+}
+
+// src/actions/tokens/getWalletBalances.ts
+import { getChainId, getPublicClient } from "@wagmi/core";
+import {
+  erc20Abi,
+  formatUnits,
+  isAddress
+} from "viem";
+function getBalanceCall({
+  token,
+  account,
+  multicallAddress
+}) {
+  if (isToken(token, "BERA") || isToken(token, "ETH")) {
+    return {
+      address: multicallAddress,
+      abi: multicall3Abi,
+      functionName: "getEthBalance",
+      args: [account]
+    };
+  }
+  return {
+    address: token.address,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [account]
+  };
+}
+async function getWalletBalances({
+  account,
+  tokenList,
+  wagmiConfig: config
+}) {
+  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) => 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 = {
+          ...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
+          }
+        };
+        return resultBalanceToken;
+      });
+    })
+  );
+  return res.flatMap(
+    (result) => result.status === "fulfilled" ? result.value : []
+  );
+}
+
+export {
+  getEnsoClient,
+  getBalanceCall,
+  getWalletBalances
+};

package/dist/chunk-IXIBY5FP.mjs

@@ -0,0 +1,80 @@
+import {
+  parseBaseArgs
+} from "./chunk-DQRH5VE3.mjs";
+import {
+  InvalidArgumentError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/utils/tokens.ts
+import { ethAddress, isAddress, zeroAddress } from "viem";
+import { mainnet } from "@berachain/config/mainnet";
+var beraToken = {
+  address: zeroAddress,
+  decimals: 18,
+  name: "Bera",
+  symbol: "BERA",
+  logoURI: "https://imagedelivery.net/qNj7Q3MCke89zoKzav7eDQ/tokens/0x0000000000000000000000000000000000000000.png/public"
+};
+var wBeraToken = {
+  address: mainnet.tokens.wbera,
+  decimals: 18,
+  name: "WBera",
+  symbol: "WBERA"
+};
+function getHoneyToken(baseArgs) {
+  const { config, chainId } = parseBaseArgs(baseArgs);
+  return {
+    address: config.honey.token,
+    symbol: "HONEY",
+    name: "Honey",
+    decimals: 18,
+    chainId
+  };
+}
+function isToken(...args) {
+  const [token, compareTo, baseArgs] = args;
+  if (token === void 0) return false;
+  const tokenAddress = typeof token === "string" ? token : token.address;
+  if (typeof compareTo === "string" && !isAddress(compareTo) && // this is a safeguard against weird inputs from enso. `0x00`
+  !compareTo.startsWith("0x")) {
+    if (compareTo === "BERA") {
+      return tokenAddress.toLowerCase() === zeroAddress;
+    }
+    if (compareTo === "WBERA") {
+      return tokenAddress.toLowerCase() === mainnet.tokens.wbera;
+    }
+    if (compareTo === "ETH") {
+      return tokenAddress.toLowerCase() === ethAddress;
+    }
+    if (compareTo === "SWBERA") {
+      return tokenAddress.toLowerCase() === mainnet.tokens.swbera.toLowerCase();
+    }
+    if (baseArgs === void 0) {
+      throw new InvalidArgumentError({
+        property: "baseArgs",
+        value: baseArgs,
+        expected: "BeraJS.BaseFunctionArgs",
+        message: "baseArgs is required when compared to a known token different than BERA or WBERA. Checking against token: " + compareTo + " and token address: " + tokenAddress
+      });
+    }
+    const { config } = parseBaseArgs(baseArgs);
+    const tokenMap = {
+      BGT: config.tokens.bgt,
+      HONEY: config.honey.token,
+      SWBERA: config.tokens.swbera,
+      ETH: ethAddress
+    };
+    if (compareTo in tokenMap) {
+      return tokenAddress.toLowerCase() === tokenMap[compareTo].toLowerCase();
+    }
+  }
+  const compareToAddress = typeof compareTo === "object" ? compareTo.address : compareTo;
+  return tokenAddress.toLowerCase() === compareToAddress.toLowerCase();
+}
+
+export {
+  beraToken,
+  wBeraToken,
+  getHoneyToken,
+  isToken
+};