@talismn/api-react-hooks/dist/useBalances.js

A set of react hooks to use the @talismn/api.

var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __export = (target, all) => {
  __markAsModule(target);
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __reExport = (target, module2, desc) => {
  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
    for (let key of __getOwnPropNames(module2))
      if (!__hasOwnProp.call(target, key) && key !== "default")
        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
  }
  return target;
};
var __toModule = (module2) => {
  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
};
__export(exports, {
  addPriceToTokenBalances: () => addPriceToTokenBalances,
  addTokensToBalances: () => addTokensToBalances,
  groupBalancesByAddress: () => groupBalancesByAddress,
  groupBalancesByChain: () => groupBalancesByChain,
  useBalances: () => useBalances
});
var import_api = __toModule(require("@talismn/api"));
var import_util = __toModule(require("@talismn/util"));
var import_react = __toModule(require("react"));
function useBalances(_addresses = [], chains = [], rpcs) {
  const [addresses, setAddresses] = (0, import_react.useState)([]);
  (0, import_react.useEffect)(() => {
    setAddresses((addresses2) => _addresses.some((address, index) => addresses2[index] !== address) ? _addresses : addresses2);
  }, [_addresses]);
  const [balancesIndexed, setBalancesIndexed] = (0, import_react.useState)({});
  (0, import_react.useEffect)(() => {
    if (!Array.isArray(addresses))
      return;
    if (addresses.filter(Boolean).length < 1)
      return;
    if (!Array.isArray(chains))
      return;
    if (chains.filter(Boolean).length < 1)
      return;
    const unsubscribe = import_api.default.init({ type: "WSPROVIDER", rpcs }).subscribeBalances(chains, addresses, (balance, chainId, address) => setBalancesIndexed((balances2) => __spreadProps(__spreadValues({}, balances2), { [`${chainId}_${address}`]: balance })));
    return unsubscribe;
  }, [addresses, chains]);
  const balances = (0, import_react.useMemo)(() => Object.values(balancesIndexed).filter(Boolean), [balancesIndexed]);
  return { balances };
}
function groupBalancesByChain(chainIds, balances) {
  const byChain = Object.fromEntries(chainIds.map((chainId) => [chainId, []]));
  balances.filter((balance) => balance !== null).filter((balance) => typeof balance.chainId === "string").filter((balance) => chainIds.includes(balance.chainId)).forEach((balance) => {
    byChain[balance.chainId].push(balance);
  });
  return byChain;
}
function groupBalancesByAddress(balances) {
  const byAddress = {};
  balances.filter((balance) => balance !== null).filter((balance) => typeof balance.address === "string").forEach((balance) => {
    if (!byAddress[balance.address])
      byAddress[balance.address] = [];
    byAddress[balance.address].push(balance);
  });
  return byAddress;
}
function addTokensToBalances(balances, tokenDecimals) {
  return balances.map((balance) => balance === null ? null : __spreadProps(__spreadValues({}, balance), { tokens: (0, import_util.planckToTokens)(balance.free, tokenDecimals) }));
}
function addPriceToTokenBalances(balances, tokenPrice) {
  if (typeof tokenPrice !== "number")
    return balances;
  return balances.map((balance) => balance === null ? null : __spreadProps(__spreadValues({}, balance), {
    usd: (0, import_util.multiplyBigNumbers)(balance.tokens, tokenPrice)
  }));
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  addPriceToTokenBalances,
  addTokensToBalances,
  groupBalancesByAddress,
  groupBalancesByChain,
  useBalances
});