@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/cjs/koni/background/handlers/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = handlers;
+exports.tabs = exports.state = exports.nftHandler = exports.mobile = exports.extension = void 0;
+var _defaults = require("@subwallet/extension-base/defaults");
+var _nft = require("@subwallet/extension-base/koni/api/nft");
+var _Extension = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Extension"));
+var _Mobile = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Mobile"));
+var _State = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/State"));
+var _Tabs = _interopRequireDefault(require("@subwallet/extension-base/koni/background/handlers/Tabs"));
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// import Migration from '@subwallet/extension-base/koni/migration';
+
+const state = new _State.default();
+exports.state = state;
+const extension = new _Extension.default(state);
+exports.extension = extension;
+const tabs = new _Tabs.default(state);
+exports.tabs = tabs;
+const mobile = new _Mobile.default(state);
+exports.mobile = mobile;
+const nftHandler = new _nft.NftHandler();
+
+// Migration
+// async function makeSureStateReady () {
+//   const poll = (resolve: (value: unknown) => void) => {
+//     if (state.isReady()) {
+//       resolve(true);
+//     } else {
+//       console.log('Waiting for State is ready...');
+//       setTimeout(() => poll(resolve), 400);
+//     }
+//   };
+//
+//   return new Promise(poll);
+// }
+
+// makeSureStateReady().then(() => {
+//   const migration = new Migration(state);
+//
+//   migration.run().catch((err) => console.warn(err));
+// }).catch((e) => console.warn(e));
+exports.nftHandler = nftHandler;
+function handlers(_ref, port) {
+  let {
+    id,
+    message,
+    request
+  } = _ref;
+  let extensionPortName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _defaults.PORT_EXTENSION;
+  const isMobile = port.name === _defaults.PORT_MOBILE;
+  const isExtension = port.name === extensionPortName;
+  const sender = port.sender;
+  const from = isExtension ? 'extension' : sender.tab && sender.tab.url || sender.url || '<unknown>';
+  const source = `${from}: ${id}: ${message}`;
+  console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
+
+  const promise = isMobile ? mobile.handle(id, message, request, port) : isExtension ? extension.handle(id, message, request, port) : tabs.handle(id, message, request, from, port);
+  promise.then(response => {
+    console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
+
+    // between the start and the end of the promise, the user may have closed
+    // the tab, in which case port will be undefined
+    (0, _util.assert)(port, 'Port has been disconnected');
+    port.postMessage({
+      id,
+      response
+    });
+  }).catch(error => {
+    console.error(error);
+    console.log(`[err] ${source}:: ${error.message}`);
+
+    // only send message back to port if it's still connected
+    if (port) {
+      port.postMessage({
+        error: error.message,
+        errorCode: error.code,
+        errorData: error.data,
+        id
+      });
+    }
+  });
+}

package/cjs/koni/background/subscription.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KoniSubscription = void 0;
+var _constants = require("@subwallet/extension-base/constants");
+var _balance = require("@subwallet/extension-base/koni/api/dotsama/balance");
+var _crowdloan = require("@subwallet/extension-base/koni/api/dotsama/crowdloan");
+var _staking = require("@subwallet/extension-base/koni/api/staking");
+var _bonding = require("@subwallet/extension-base/koni/api/staking/bonding");
+var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/relayChain");
+var _paraChain = require("@subwallet/extension-base/koni/api/staking/paraChain");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class KoniSubscription {
+  subscriptionMap = {
+    crowdloan: undefined,
+    balance: undefined,
+    stakingOnChain: undefined
+  };
+  constructor(state, dbService) {
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = (0, _util.logger)('Subscription');
+    this.init();
+  }
+  getSubscriptionMap() {
+    return this.subscriptionMap;
+  }
+  getSubscription(name) {
+    return this.subscriptionMap[name];
+  }
+  updateSubscription(name, func) {
+    const oldFunc = this.subscriptionMap[name];
+    oldFunc && oldFunc();
+    func && (this.subscriptionMap[name] = func);
+  }
+  stopAllSubscription() {
+    if (this.subscriptionMap.balance) {
+      this.subscriptionMap.balance();
+      delete this.subscriptionMap.balance;
+    }
+    if (this.subscriptionMap.crowdloan) {
+      this.subscriptionMap.crowdloan();
+      delete this.subscriptionMap.crowdloan;
+    }
+    if (this.subscriptionMap.stakingOnChain) {
+      this.subscriptionMap.stakingOnChain();
+      delete this.subscriptionMap.stakingOnChain;
+    }
+  }
+  start() {
+    var _this$state$keyringSe;
+    this.logger.log('Starting subscription');
+    const currentAddress = (_this$state$keyringSe = this.state.keyringService.currentAccount) === null || _this$state$keyringSe === void 0 ? void 0 : _this$state$keyringSe.address;
+    if (currentAddress) {
+      this.subscribeBalancesAndCrowdloans(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+      this.subscribeStakingOnChain(currentAddress, this.state.getSubstrateApiMap());
+    }
+    if (!this.eventHandler) {
+      const reloadEvents = ['account.add', 'account.remove', 'account.updateCurrent', 'chain.add', 'chain.update', 'chain.enable', 'asset.update', 'asset.enable', 'transaction.done', 'transaction.failed'];
+      this.eventHandler = (events, eventTypes) => {
+        var _serviceInfo$currentA;
+        const serviceInfo = this.state.getServiceInfo();
+        const needReload = eventTypes.some(eT => reloadEvents.includes(eT));
+        if (!needReload) {
+          return;
+        }
+        this.logger.log('ServiceInfo updated, restarting...');
+        const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
+        if (!address) {
+          return;
+        }
+        this.subscribeBalancesAndCrowdloans(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
+        this.subscribeStakingOnChain(address, serviceInfo.chainApiMap.substrate);
+      };
+      this.state.eventService.onLazy(this.eventHandler);
+    }
+  }
+  stop() {
+    this.logger.log('Stopping subscription');
+    if (this.eventHandler) {
+      this.state.eventService.offLazy(this.eventHandler);
+    }
+    this.stopAllSubscription();
+  }
+  init() {
+    this.state.getAuthorize(value => {
+      const authString = localStorage.getItem('authUrls') || '{}';
+      const previousAuth = JSON.parse(authString);
+      if (previousAuth && Object.keys(previousAuth).length) {
+        Object.keys(previousAuth).forEach(url => {
+          if (previousAuth[url].isAllowed) {
+            previousAuth[url].isAllowedMap = this.state.getAddressList(true);
+          } else {
+            previousAuth[url].isAllowedMap = this.state.getAddressList();
+          }
+        });
+      }
+      const migrateValue = {
+        ...previousAuth,
+        ...value
+      };
+      this.state.setAuthorize(migrateValue);
+      localStorage.setItem('authUrls', '{}');
+    });
+  }
+  subscribeBalancesAndCrowdloans(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
+    this.state.switchAccount(address).then(() => {
+      const addresses = this.state.getDecodedAddresses(address);
+      if (!addresses.length) {
+        return;
+      }
+      this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
+      this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+    }).catch(err => this.logger.warn(err));
+  }
+  subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
+    this.state.resetStaking(address);
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+  }
+  initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const unsub = (0, _staking.stakingOnChainApi)(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setStakingItem(networkKey, rs);
+    }, this.state.getActiveChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
+    const filteredChainInfoMap = {};
+    Object.values(chainStateMap).forEach(chainState => {
+      if (chainState.active) {
+        filteredChainInfoMap[chainState.slug] = chainInfoMap[chainState.slug];
+      }
+    });
+    const unsub = (0, _balance.subscribeBalance)(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
+      this.state.setBalanceItem(result.tokenSlug, result);
+    });
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const subscriptionPromise = (0, _crowdloan.subscribeCrowdloan)(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setCrowdloanItem(networkKey, rs);
+    }, this.state.getChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+      return;
+    }
+    return () => {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+    };
+  }
+  subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap);
+  }
+  initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    var _this = this;
+    _handlers.nftHandler.setChainInfoMap(chainInfoMap);
+    _handlers.nftHandler.setDotSamaApiMap(substrateApiMap);
+    _handlers.nftHandler.setWeb3ApiMap(evmApiMap);
+    _handlers.nftHandler.setAddresses(addresses);
+    _handlers.nftHandler.handleNfts(smartContractNfts, function () {
+      return _this.state.updateNftData(...arguments);
+    }, function () {
+      return _this.state.setNftCollection(...arguments);
+    }).then(() => {
+      this.logger.log('nft state updated');
+    }).catch(this.logger.log);
+  }
+  async subscribeStakingReward(address) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetNetworkMap = {};
+    Object.entries(chainInfoMap).forEach(_ref => {
+      let [key, network] = _ref;
+      const chainState = this.state.getChainStateByKey(key);
+      if ((0, _utils._isChainEnabled)(chainState) && (0, _utils._isChainSupportSubstrateStaking)(network)) {
+        targetNetworkMap[key] = network;
+      }
+    });
+    const result = await (0, _staking.getNominationStakingRewardData)(addresses, targetNetworkMap);
+    this.state.updateStakingReward(result, 'slowInterval');
+    this.logger.log('Set staking reward state done', result);
+  }
+  async subscribeStakingRewardFastInterval(address) {
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const pooledStakingItems = await this.state.getPooledStakingRecordsByAddress(addresses);
+    const pooledAddresses = [];
+    pooledStakingItems.forEach(pooledItem => {
+      if (!pooledAddresses.includes(pooledItem.address)) {
+        pooledAddresses.push(pooledItem.address);
+      }
+    });
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetChainMap = {};
+    Object.entries(chainInfoMap).forEach(_ref2 => {
+      let [key, network] = _ref2;
+      const chainState = this.state.getChainStateByKey(key);
+      if ((0, _utils._isChainEnabled)(chainState) && (0, _utils._isChainSupportSubstrateStaking)(network)) {
+        targetChainMap[key] = network;
+      }
+    });
+    const activeNetworks = [];
+    Object.keys(targetChainMap).forEach(key => {
+      activeNetworks.push(key);
+    });
+    const [poolingStakingRewards, amplitudeUnclaimedStakingRewards] = await Promise.all([(0, _staking.getPoolingStakingRewardData)(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap()), (0, _paraChain.getAmplitudeUnclaimedStakingReward)(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks)]);
+    const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
+    this.state.updateStakingReward(result, 'fastInterval');
+    this.logger.log('Set staking reward state with fast interval done', result);
+  }
+  async fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap) {
+    await Promise.all(Object.values(chainInfoMap).map(async chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && (0, _utils._isChainSupportSubstrateStaking)(chainInfo)) {
+        const chainStakingMetadata = await (0, _bonding.getChainStakingMetadata)(chainInfo.slug, substrateApiMap[chainInfo.slug]);
+        this.state.updateChainStakingMetadata(chainStakingMetadata);
+      }
+    }));
+  }
+  async fetchNominatorMetadata(currentAddress, chainInfoMap, chainStateMap, substrateApiMap) {
+    const filteredChainInfoMap = {};
+    Object.values(chainInfoMap).forEach(chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && (0, _utils._isChainSupportSubstrateStaking)(chainInfo)) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    let addresses = [currentAddress];
+    if (currentAddress === _constants.ALL_ACCOUNT_KEY) {
+      addresses = await this.state.getStakingOwnersByChains(Object.keys(filteredChainInfoMap));
+    }
+    const validAddresses = addresses.filter(address => !(0, _utilCrypto.isEthereumAddress)(address));
+    await Promise.all(validAddresses.map(async address => {
+      const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(address);
+      await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
+        if (isEvmAddress && !(0, _utils._isChainEvmCompatible)(chainInfo)) {
+          return;
+        }
+        if ((0, _utils._isSubstrateRelayChain)(chainInfo) && _constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chainInfo.slug)) {
+          const poolMemberMetadata = await (0, _relayChain.getRelayChainPoolMemberMetadata)(chainInfo, address, substrateApiMap[chainInfo.slug]);
+          if (poolMemberMetadata) {
+            this.state.updateStakingNominatorMetadata(poolMemberMetadata);
+          }
+        }
+        const nominatorMetadata = await (0, _bonding.getNominatorMetadata)(chainInfo, address, substrateApiMap[chainInfo.slug]);
+        if (nominatorMetadata) {
+          this.state.updateStakingNominatorMetadata(nominatorMetadata);
+        }
+      }));
+    }));
+  }
+}
+exports.KoniSubscription = KoniSubscription;

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '0.8.4-0'
+  version: '1.0.2-1'
 };
 exports.packageInfo = packageInfo;

package/cjs/page/SubWalleEvmProvider.js

@@ -0,0 +1,142 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SubWalletEvmProvider = void 0;
+var _safeEventEmitter = _interopRequireDefault(require("@metamask/safe-event-emitter"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class SubWalletEvmProvider extends _safeEventEmitter.default {
+  isSubWallet = true;
+  isMetaMask = false;
+  _connected = false;
+  _subscribed = false;
+  constructor(sendMessage, version) {
+    super();
+    this.version = version;
+    this.sendMessage = sendMessage;
+    this._connected = true;
+  }
+  get connected() {
+    return this._connected;
+  }
+  isConnected() {
+    return this._connected;
+  }
+  subscribeExtensionEvents() {
+    if (this._subscribed) {
+      return;
+    }
+    this.sendMessage('evm(events.subscribe)', null, _ref => {
+      let {
+        payload,
+        type
+      } = _ref;
+      if (['connect', 'disconnect', 'accountsChanged', 'chainChanged', 'message', 'data', 'reconnect', 'error'].includes(type)) {
+        if (type === 'connect') {
+          this._connected = true;
+        } else if (type === 'disconnect') {
+          this._connected = false;
+        }
+        const finalType = type === 'data' ? 'message' : type;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        this.emit(finalType, payload);
+      } else {
+        console.warn('Can not handle event', type, payload);
+      }
+    }).then(done => {
+      this._subscribed = true;
+    }).catch(console.error);
+  }
+  async enable() {
+    return this.request({
+      method: 'eth_requestAccounts'
+    });
+  }
+  request(_ref2) {
+    let {
+      method,
+      params
+    } = _ref2;
+    switch (method) {
+      case 'eth_requestAccounts':
+        return new Promise((resolve, reject) => {
+          const origin = document.title !== '' ? document.title : window.location.hostname;
+          this.sendMessage('pub(authorize.tabV2)', {
+            origin,
+            accountAuthType: 'evm'
+          }).then(() => {
+            // Subscribe event
+            this.subscribeExtensionEvents();
+
+            // Return account list
+            this.request({
+              method: 'eth_accounts'
+            }).then(accounts => {
+              // @ts-ignore
+              resolve(accounts);
+            }).catch(e => {
+              reject(e);
+            });
+          }).catch(e => {
+            reject(e);
+          });
+        });
+      default:
+        return new Promise((resolve, reject) => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          this.sendMessage('evm(request)', {
+            params,
+            method
+          }).then(result => {
+            resolve(result);
+          }).catch(e => {
+            reject(e);
+          });
+        });
+    }
+  }
+  _sendSync(payload) {
+    let result;
+    switch (payload.method) {
+      case 'net_version':
+        result = this.version ? `SubWallet v${this.version}` : null;
+        break;
+      default:
+        throw new Error(`Not support ${payload.method}`);
+    }
+    return {
+      id: payload.id,
+      jsonrpc: payload.jsonrpc,
+      result
+    };
+  }
+  send(methodOrPayload, callbackOrArgs) {
+    if (typeof methodOrPayload === 'string' && (!callbackOrArgs || Array.isArray(callbackOrArgs))) {
+      return this.request({
+        method: methodOrPayload,
+        params: callbackOrArgs
+      });
+    } else if (methodOrPayload && typeof methodOrPayload === 'object' && typeof callbackOrArgs === 'function') {
+      return this.request(methodOrPayload).then(rs => {
+        callbackOrArgs(rs);
+      });
+    }
+    return this._sendSync(methodOrPayload);
+  }
+  sendAsync(payload, callback) {
+    this.request(payload).then(result => {
+      // @ts-ignore
+      callback(null, {
+        result
+      });
+    }).catch(e => {
+      callback(e);
+    });
+  }
+}
+exports.SubWalletEvmProvider = SubWalletEvmProvider;

package/cjs/page/index.js

@@ -6,8 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.enable = enable;
 exports.handleResponse = handleResponse;
+exports.initEvmProvider = initEvmProvider;
 exports.sendMessage = sendMessage;
-var _SubWalletProviderError = require("@subwallet/extension-base/errors/SubWalletProviderError");
+var _ProviderError = require("@subwallet/extension-base/background/errors/ProviderError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _SubWalleEvmProvider = require("@subwallet/extension-base/page/SubWalleEvmProvider");
 var _defaults = require("../defaults");
 var _getId = require("../utils/getId");
 var _Injected = _interopRequireDefault(require("./Injected"));
@@ -57,8 +60,11 @@ function handleResponse(data) {
     // eslint-disable-next-line @typescript-eslint/ban-types
     handler.subscriber(data.subscription);
   } else if (data.error) {
-    handler.reject(new _SubWalletProviderError.SubWalletProviderError(data.error, data.errorCode, data.errorData));
+    handler.reject(new _ProviderError.ProviderError(_KoniTypes.ProviderErrorType.INTERNAL_ERROR, data.error, data.errorCode));
   } else {
     handler.resolve(data.response);
   }
+}
+function initEvmProvider(version) {
+  return new _SubWalleEvmProvider.SubWalletEvmProvider(sendMessage, version);
 }

package/cjs/services/balance-service/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BalanceService = void 0;
+var _BalanceError = require("@subwallet/extension-base/background/errors/BalanceError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _balance = require("@subwallet/extension-base/koni/api/dotsama/balance");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class BalanceService {
+  constructor(chainService) {
+    this.chainService = chainService;
+
+    // Todo: Load data from db to balanceSubject
+    // Todo: Start  subscribe balance and data
+    // Todo: Listen change and apply to balanceSubject
+    // Todo: Active/Chain
+    // Todo: Add/remove account
+    // Todo: Add new account
+    // Todo: Optimize get balance for single account and chain with cache
+    // Todo: Move everything of fetching balance to this service
+  }
+
+  async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainState = this.chainService.getChainStateByKey(chain);
+    if (!chainInfo || !chainState || !chainState.active) {
+      return Promise.reject(new _BalanceError.BalanceError(_KoniTypes.BalanceErrorType.NETWORK_ERROR, `Chain ${chain} is not active`));
+    }
+    const tSlug = tokenSlug || (0, _utils._getChainNativeTokenSlug)(chainInfo);
+    const tokenInfo = this.chainService.getAssetBySlug(tSlug);
+    if (!tokenInfo) {
+      return Promise.reject(new _BalanceError.BalanceError(_KoniTypes.BalanceErrorType.TOKEN_ERROR, `Token ${tSlug} is not supported`));
+    }
+    return new Promise((resolve, reject) => {
+      let hasError = true;
+      const unsub = this.subscribeBalance([address], [chain], rs => {
+        if (rs.tokenSlug === tSlug) {
+          hasError = false;
+          const balance = {
+            value: rs.free,
+            decimals: tokenInfo.decimals || 0,
+            symbol: tokenInfo.symbol
+          };
+          if (callback) {
+            callback(balance);
+          } else {
+            // Auto unsubscribe if no callback
+            unsub();
+          }
+          resolve([unsub, balance]);
+        }
+      });
+      setTimeout(() => {
+        if (hasError) {
+          unsub();
+          reject(new Error('Get Balance Timeout'));
+        }
+      }, 9999);
+    });
+  }
+  async getTokenFreeBalance(address, chain, tokenSlug) {
+    const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
+    return balance;
+  }
+  subscribeBalance(addresses, chains, callback) {
+    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const chainInfoMap = this.chainService.getChainInfoMap();
+    const chainStateMap = this.chainService.getChainStateMap();
+    const substrateApiMap = this.chainService.getSubstrateApiMap();
+    const evmApiMap = this.chainService.getEvmApiMap();
+
+    // Get data from chain or all chains
+    const chainList = chains || Object.keys(chainInfoMap);
+    // Filter active chain only
+    const useChainInfos = chainList.filter(c => chainStateMap[c] && chainStateMap[c].active).map(c => chainInfoMap[c]);
+
+    // Looping over each chain
+    const unsubList = useChainInfos.map(async chainInfo => {
+      const chainSlug = chainInfo.slug;
+      const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfo) ? evmAddresses : substrateAddresses;
+      if ((0, _utils._isPureEvmChain)(chainInfo)) {
+        const nativeTokenInfo = _handlers.state.getNativeTokenInfo(chainSlug);
+        return (0, _balance.subscribeEVMBalance)(chainSlug, useAddresses, evmApiMap, callback, nativeTokenInfo);
+      }
+      if (!useAddresses || useAddresses.length === 0 || _constants._PURE_EVM_CHAINS.indexOf(chainSlug) > -1) {
+        return undefined;
+      }
+      const networkAPI = await substrateApiMap[chainSlug].isReady;
+      return (0, _balance.subscribeSubstrateBalance)(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
+    });
+    return () => {
+      unsubList.forEach(subProm => {
+        subProm.then(unsub => {
+          unsub && unsub();
+        }).catch(console.error);
+      });
+    };
+  }
+}
+exports.BalanceService = BalanceService;