@subwallet/extension-base 1.1.23-0 → 1.1.24-1

package/cjs/services/balance-service/helpers/group.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groupBalance = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/utils");
+var _bn = _interopRequireDefault(require("bn.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Group the balance of {token} from {items} into {address}
+ * @param {BalanceItem[]} items - List balance want to group
+ * @param {string} address - Address will be grouped to
+ * @param {string} token - Slug of token will be group balance
+ * @return {BalanceItem} - Grouped balance information of token
+ */
+const groupBalance = (items, address, token) => {
+  const states = items.map(item => item.state);
+  const result = {
+    address,
+    tokenSlug: token,
+    free: (0, _utils.sumBN)(items.map(item => new _bn.default(item.free))).toString(),
+    locked: (0, _utils.sumBN)(items.map(item => new _bn.default(item.locked))).toString(),
+    state: states.every(item => item === _KoniTypes.APIItemState.NOT_SUPPORT) ? _KoniTypes.APIItemState.NOT_SUPPORT : states.some(item => item === _KoniTypes.APIItemState.READY) ? _KoniTypes.APIItemState.READY : _KoniTypes.APIItemState.PENDING
+  };
+  for (const item of items) {
+    if (item.substrateInfo) {
+      if (!result.substrateInfo) {
+        result.substrateInfo = {
+          ...item.substrateInfo
+        };
+      } else {
+        const old = {
+          ...result.substrateInfo
+        };
+        const _new = {
+          ...item.substrateInfo
+        };
+        result.substrateInfo = {
+          reserved: new _bn.default(old.reserved || '0').add(new _bn.default(_new.reserved || '0')).toString(),
+          feeFrozen: new _bn.default(old.feeFrozen || '0').add(new _bn.default(_new.feeFrozen || '0')).toString(),
+          miscFrozen: new _bn.default(old.miscFrozen || '0').add(new _bn.default(_new.miscFrozen || '0')).toString()
+        };
+      }
+    }
+  }
+  return result;
+};
+exports.groupBalance = groupBalance;

package/cjs/services/balance-service/helpers/subscribe/balance.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeBalance = subscribeBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _account = require("@subwallet/extension-base/utils/account");
+var _evm = require("./evm");
+var _substrate = require("./substrate");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const filterAddress = (addresses, chainInfo) => {
+  const isEvmChain = (0, _utils._isChainEvmCompatible)(chainInfo);
+  const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+  if (isEvmChain) {
+    return [evmAddresses, []];
+  } else {
+    const fetchList = [];
+    const unfetchList = [];
+    substrateAddresses.forEach(address => {
+      const account = (0, _account.getAccountJsonByAddress)(address);
+      if (account) {
+        if (account.isHardware) {
+          const availGen = account.availableGenesisHashes || [];
+          const gen = (0, _utils._getSubstrateGenesisHash)(chainInfo);
+          if (availGen.includes(gen)) {
+            fetchList.push(address);
+          } else {
+            unfetchList.push(address);
+          }
+        } else {
+          fetchList.push(address);
+        }
+      } else {
+        fetchList.push(address);
+      }
+    });
+    return [fetchList, [...unfetchList, ...evmAddresses]];
+  }
+};
+
+// main subscription
+function subscribeBalance(addresses, chainInfoMap, substrateApiMap, evmApiMap, callback) {
+  // Looping over each chain
+  const unsubList = Object.entries(chainInfoMap).map(async _ref => {
+    let [chainSlug, chainInfo] = _ref;
+    const [useAddresses, notSupportAddresses] = filterAddress(addresses, chainInfo);
+    if (notSupportAddresses.length) {
+      const tokens = _handlers.state.chainService.getAssetByChainAndType(chainSlug, [_types._AssetType.NATIVE, _types._AssetType.ERC20, _types._AssetType.PSP22, _types._AssetType.LOCAL]);
+      const assetSetting = await _handlers.state.chainService.getAssetSettings();
+      const filtered = Object.values(tokens).filter(_ref2 => {
+        var _assetSetting$slug;
+        let {
+          slug
+        } = _ref2;
+        return (_assetSetting$slug = assetSetting[slug]) === null || _assetSetting$slug === void 0 ? void 0 : _assetSetting$slug.visible;
+      });
+      const now = new Date().getTime();
+      notSupportAddresses.forEach(address => {
+        const items = filtered.map(token => {
+          return {
+            address,
+            tokenSlug: token.slug,
+            free: '0',
+            locked: '0',
+            state: _KoniTypes.APIItemState.NOT_SUPPORT,
+            timestamp: now
+          };
+        });
+        callback(items);
+      });
+    }
+    if ((0, _utils._isPureEvmChain)(chainInfo)) {
+      const nativeTokenInfo = _handlers.state.getNativeTokenInfo(chainSlug);
+      return (0, _evm.subscribeEVMBalance)(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+    }
+
+    // if (!useAddresses || useAddresses.length === 0 || _PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
+    //   const fungibleTokensByChain = state.chainService.getFungibleTokensByChain(chainSlug, true);
+    //   const now = new Date().getTime();
+    //
+    //   Object.values(fungibleTokensByChain).map((token) => {
+    //     return {
+    //       tokenSlug: token.slug,
+    //       free: '0',
+    //       locked: '0',
+    //       state: APIItemState.READY,
+    //       timestamp: now
+    //     } as BalanceItem;
+    //   }).forEach(callback);
+    //
+    //   return undefined;
+    // }
+
+    const networkAPI = await substrateApiMap[chainSlug].isReady;
+    return (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}

package/cjs/services/balance-service/helpers/subscribe/evm.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeERC20Interval = subscribeERC20Interval;
+exports.subscribeEVMBalance = subscribeEVMBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _balance = require("@subwallet/extension-base/koni/api/tokens/evm/balance");
+var _web = require("@subwallet/extension-base/koni/api/tokens/evm/web3");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+function subscribeERC20Interval(addresses, chain, evmApiMap, callBack) {
+  let tokenList = {};
+  const erc20ContractMap = {};
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const contract = erc20ContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+            return await contract.methods.balanceOf(address).call();
+          } catch (e) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, e);
+            return '0';
+          }
+        }));
+        const items = balances.map((balance, index) => {
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            free: new _util.BN(balance || 0).toString(),
+            locked: '0',
+            state: _KoniTypes.APIItemState.READY
+          };
+        });
+        callBack(items);
+      } catch (err) {
+        console.log(tokenInfo.slug, err);
+      }
+    });
+  };
+  tokenList = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.ERC20]);
+  Object.entries(tokenList).forEach(_ref => {
+    let [slug, tokenInfo] = _ref;
+    erc20ContractMap[slug] = (0, _web.getERC20Contract)(chain, (0, _utils._getContractAddressOfToken)(tokenInfo), evmApiMap);
+  });
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, _constants.SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+function subscribeEVMBalance(chain, addresses, evmApiMap, callback, tokenInfo) {
+  function getBalance() {
+    (0, _balance.getEVMBalance)(chain, addresses, evmApiMap).then(balances => {
+      return balances.map((balance, index) => {
+        return {
+          address: addresses[index],
+          tokenSlug: tokenInfo.slug,
+          state: _KoniTypes.APIItemState.READY,
+          free: new _util.BN(balance || '0').toString(),
+          locked: '0'
+        };
+      });
+    }).catch(e => {
+      console.error(`Error on get native balance with token ${tokenInfo.slug}`, e);
+      return addresses.map(address => {
+        return {
+          address: address,
+          tokenSlug: tokenInfo.slug,
+          state: _KoniTypes.APIItemState.READY,
+          free: '0',
+          locked: '0'
+        };
+      });
+    }).then(items => {
+      callback(items);
+    }).catch(console.error);
+  }
+  getBalance();
+  const interval = setInterval(getBalance, _constants.ASTAR_REFRESH_BALANCE_INTERVAL);
+  const unsub2 = subscribeERC20Interval(addresses, chain, evmApiMap, callback);
+  return () => {
+    clearInterval(interval);
+    unsub2 && unsub2();
+  };
+}

package/cjs/services/balance-service/helpers/subscribe/substrate/equilibrium.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeEqBalanceAccountPallet = subscribeEqBalanceAccountPallet;
+exports.subscribeEquilibriumTokenBalance = subscribeEquilibriumTokenBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function subscribeEquilibriumTokenBalance(addresses, chain, api, callBack, includeNativeToken) {
+  const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  try {
+    const unsub = await api.query.system.account.multi(addresses, balances => {
+      // Equilibrium customizes the SystemAccount pallet
+      Object.values(tokenMap).forEach(tokenInfo => {
+        const assetId = (0, _utils._getTokenOnChainAssetId)(tokenInfo);
+        const items = balances.map((balance, index) => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+          const balancesData = JSON.parse(balance.data.toString());
+          const balanceList = balancesData.v0.balance;
+
+          // @ts-ignore
+          const freeTokenBalance = balanceList.find(data => data[0] === parseInt(assetId));
+          const bnFreeTokenBalance = freeTokenBalance ? new _util.BN(new _bignumber.default(freeTokenBalance[1].positive).toString()) : _util.BN_ZERO;
+          return {
+            address: addresses[index],
+            free: bnFreeTokenBalance.toString(),
+            locked: '0',
+            // Equilibrium doesn't show locked balance
+            state: _KoniTypes.APIItemState.READY,
+            tokenSlug: tokenInfo.slug
+          };
+        });
+        callBack(items);
+      });
+    });
+    return () => {
+      unsub();
+    };
+  } catch (e) {
+    Object.values(tokenMap).forEach(tokenInfo => {
+      const items = addresses.map(address => {
+        return {
+          address: address,
+          free: '0',
+          locked: '0',
+          // Equilibrium doesn't show locked balance
+          state: _KoniTypes.APIItemState.READY,
+          tokenSlug: tokenInfo.slug
+        };
+      });
+      callBack(items);
+    });
+    return () => {
+      // Empty
+    };
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/require-await
+async function subscribeEqBalanceAccountPallet(addresses, chain, api, callBack, includeNativeToken) {
+  const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const assetId = (0, _utils._getTokenOnChainAssetId)(tokenInfo);
+      const unsub = await api.query.eqBalances.account.multi(addresses.map(address => [address, [assetId]]), balances => {
+        const items = balances.map((balance, index) => {
+          return {
+            address: addresses[index],
+            free: balance.asPositive.toString(),
+            locked: '0',
+            // Equilibrium doesn't show locked balance
+            state: _KoniTypes.APIItemState.READY,
+            tokenSlug: tokenInfo.slug
+          };
+        });
+        callBack(items);
+      });
+      return unsub;
+    } catch (err) {
+      console.warn(err);
+      const items = addresses.map(address => {
+        return {
+          address: address,
+          free: '0',
+          locked: '0',
+          // Equilibrium doesn't show locked balance
+          state: _KoniTypes.APIItemState.READY,
+          tokenSlug: tokenInfo.slug
+        };
+      });
+      callBack(items);
+      return undefined;
+    }
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}