@berachain/berajs 0.2.8-beta.9 → 0.2.9

package/dist/chunk-FFB5LFDW.mjs

@@ -0,0 +1,35 @@
+import {
+  bignumber_js_default
+} from "./chunk-CDFWPU2R.mjs";
+import {
+  isToken,
+  wBeraToken
+} from "./chunk-NPBQLVL3.mjs";
+
+// src/utils/tokenWrapping.ts
+function wrapNativeToken(token) {
+  return {
+    ...token,
+    ...isToken(token, "BERA") && wBeraToken
+  };
+}
+function wrapNativeTokens(tokens) {
+  return tokens.map((token) => wrapNativeToken(token));
+}
+
+// src/utils/math.ts
+var computePriceImpact = (tokenInPrice, tokenOutPrice, inAmount, outAmount) => {
+  if (!tokenInPrice || !tokenOutPrice || !inAmount || !outAmount) return 0;
+  const usdIn = new bignumber_js_default(tokenInPrice).times(inAmount);
+  const usdOut = new bignumber_js_default(tokenOutPrice).times(outAmount);
+  if (usdIn.lt(0.01) || usdOut.lt(0.01)) return 0;
+  if (usdIn.isZero() || usdOut.isZero()) return 0;
+  const ratio = usdOut.div(usdIn);
+  return Number(new bignumber_js_default(1).minus(ratio).toFixed());
+};
+
+export {
+  wrapNativeToken,
+  wrapNativeTokens,
+  computePriceImpact
+};

package/dist/chunk-HQCOU6GY.mjs

@@ -0,0 +1,243 @@
+// src/abi/utils/multicall3.ts
+var multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes[]", name: "returnData", type: "bytes[]" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bool", name: "allowFailure", type: "bool" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call3[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bool", name: "allowFailure", type: "bool" },
+          { internalType: "uint256", name: "value", type: "uint256" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call3Value[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3Value",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "blockAndAggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getBasefee",
+    outputs: [{ internalType: "uint256", name: "basefee", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "blockNumber", type: "uint256" }],
+    name: "getBlockHash",
+    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getBlockNumber",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getChainId",
+    outputs: [{ internalType: "uint256", name: "chainid", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockCoinbase",
+    outputs: [{ internalType: "address", name: "coinbase", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockDifficulty",
+    outputs: [{ internalType: "uint256", name: "difficulty", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockGasLimit",
+    outputs: [{ internalType: "uint256", name: "gaslimit", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockTimestamp",
+    outputs: [{ internalType: "uint256", name: "timestamp", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "addr", type: "address" }],
+    name: "getEthBalance",
+    outputs: [{ internalType: "uint256", name: "balance", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getLastBlockHash",
+    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bool", name: "requireSuccess", type: "bool" },
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bool", name: "requireSuccess", type: "bool" },
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryBlockAndAggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+
+export {
+  multicall3Abi
+};

package/dist/chunk-HSSJKHZ4.mjs

@@ -0,0 +1,135 @@
+import {
+  multicall3Abi
+} from "./chunk-HQCOU6GY.mjs";
+import {
+  assertAddress,
+  assertDefined,
+  assertPublicClient
+} from "./chunk-KQUMKB66.mjs";
+import {
+  isToken
+} from "./chunk-NPBQLVL3.mjs";
+import {
+  parseBaseArgs
+} from "./chunk-75M6TF7M.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
+};