@subwallet/extension-base 1.1.24-0 → 1.1.24-2

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);
+    });
+  };
+}

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

@@ -0,0 +1,324 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeSubstrateBalance = subscribeSubstrateBalance;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
+var _utils = require("@subwallet/extension-base/koni/api/tokens/wasm/utils");
+var _handlers = require("@subwallet/extension-base/koni/background/handlers");
+var _evm = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/evm");
+var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _util = require("@polkadot/util");
+var _equilibrium = require("./equilibrium");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function subscribeSubstrateBalance(addresses, chainInfo, chain, networkAPI, evmApiMap, callBack) {
+  let unsubNativeToken;
+  if (!_constants2._BALANCE_CHAIN_GROUP.kintsugi.includes(chain) && !_constants2._BALANCE_CHAIN_GROUP.genshiro.includes(chain) && !_constants2._BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
+    unsubNativeToken = await subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI.api, callBack);
+  }
+  let unsubLocalToken;
+  let unsubEvmContractToken;
+  let unsubWasmContractToken;
+  try {
+    if (_constants2._BALANCE_CHAIN_GROUP.bifrost.includes(chain)) {
+      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.kintsugi.includes(chain)) {
+      unsubLocalToken = await subscribeTokensAccountsPallet(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.statemine.includes(chain)) {
+      unsubLocalToken = await subscribeAssetsAccountPallet(addresses, chain, networkAPI.api, callBack);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.genshiro.includes(chain)) {
+      unsubLocalToken = await (0, _equilibrium.subscribeEqBalanceAccountPallet)(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
+      unsubLocalToken = await (0, _equilibrium.subscribeEquilibriumTokenBalance)(addresses, chain, networkAPI.api, callBack, true);
+    } else if (_constants2._BALANCE_CHAIN_GROUP.centrifuge.includes(chain)) {
+      unsubLocalToken = await subscribeOrmlTokensPallet(addresses, chain, networkAPI.api, callBack);
+    }
+    if ((0, _utils2._isChainEvmCompatible)(chainInfo)) {
+      unsubEvmContractToken = (0, _evm.subscribeERC20Interval)(addresses, chain, evmApiMap, callBack);
+    }
+    if ((0, _utils2._checkSmartContractSupportByChain)(chainInfo, _types._AssetType.PSP22)) {
+      // Get sub-token for substrate-based chains
+      unsubWasmContractToken = subscribePSP22Balance(addresses, chain, networkAPI.api, callBack);
+    }
+  } catch (err) {
+    console.warn(err);
+  }
+  return () => {
+    unsubNativeToken && unsubNativeToken();
+    unsubLocalToken && unsubLocalToken();
+    unsubEvmContractToken && unsubEvmContractToken();
+    unsubWasmContractToken && unsubWasmContractToken();
+  };
+}
+
+// handler according to different logic
+async function subscribeWithSystemAccountPallet(addresses, chainInfo, networkAPI, callBack) {
+  const chainNativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(chainInfo);
+
+  // TODO: Need handle case error
+  const unsub = await networkAPI.query.system.account.multi(addresses, async balances => {
+    const pooledStakingBalances = [];
+    if ((0, _utils2._isSubstrateRelayChain)(chainInfo) && networkAPI.query.nominationPools) {
+      var _networkAPI$query$nom;
+      const poolMemberDatas = await ((_networkAPI$query$nom = networkAPI.query.nominationPools.poolMembers) === null || _networkAPI$query$nom === void 0 ? void 0 : _networkAPI$query$nom.multi(addresses));
+      if (poolMemberDatas) {
+        for (const _poolMemberData of poolMemberDatas) {
+          const poolMemberData = _poolMemberData.toPrimitive();
+          if (poolMemberData) {
+            let pooled = new _util.BN(poolMemberData.points.toString());
+            Object.entries(poolMemberData.unbondingEras).forEach(_ref => {
+              let [, amount] = _ref;
+              pooled = pooled.add(new _util.BN(amount));
+            });
+            pooledStakingBalances.push(pooled);
+          } else {
+            pooledStakingBalances.push(_util.BN_ZERO);
+          }
+        }
+      }
+    }
+    const items = balances.map((balance, index) => {
+      var _balance$data, _balance$data$free, _balance$data2, _balance$data2$reserv, _balance$data3, _balance$data3$miscFr, _balance$data4, _balance$data4$frozen, _balance$data5, _balance$data5$feeFro;
+      let total = ((_balance$data = balance.data) === null || _balance$data === void 0 ? void 0 : (_balance$data$free = _balance$data.free) === null || _balance$data$free === void 0 ? void 0 : _balance$data$free.toBn()) || new _util.BN(0);
+      const reserved = ((_balance$data2 = balance.data) === null || _balance$data2 === void 0 ? void 0 : (_balance$data2$reserv = _balance$data2.reserved) === null || _balance$data2$reserv === void 0 ? void 0 : _balance$data2$reserv.toBn()) || new _util.BN(0);
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+      const miscFrozen = ((_balance$data3 = balance.data) === null || _balance$data3 === void 0 ? void 0 : (_balance$data3$miscFr = _balance$data3.miscFrozen) === null || _balance$data3$miscFr === void 0 ? void 0 : _balance$data3$miscFr.toBn()) || (balance === null || balance === void 0 ? void 0 : (_balance$data4 = balance.data) === null || _balance$data4 === void 0 ? void 0 : (_balance$data4$frozen = _balance$data4.frozen) === null || _balance$data4$frozen === void 0 ? void 0 : _balance$data4$frozen.toBn()) || new _util.BN(0);
+      const feeFrozen = ((_balance$data5 = balance.data) === null || _balance$data5 === void 0 ? void 0 : (_balance$data5$feeFro = _balance$data5.feeFrozen) === null || _balance$data5$feeFro === void 0 ? void 0 : _balance$data5$feeFro.toBn()) || new _util.BN(0);
+      let locked = reserved.add(miscFrozen);
+      total = total.add(reserved);
+      const pooledStakingBalance = pooledStakingBalances[index] || _util.BN_ZERO;
+      if (pooledStakingBalance.gt(_util.BN_ZERO)) {
+        total = total.add(pooledStakingBalance);
+        locked = locked.add(pooledStakingBalance);
+      }
+      const free = total.sub(locked);
+      return {
+        address: addresses[index],
+        tokenSlug: chainNativeTokenSlug,
+        free: free.gte(_util.BN_ZERO) ? free.toString() : '0',
+        locked: locked.toString(),
+        state: _KoniTypes.APIItemState.READY,
+        substrateInfo: {
+          miscFrozen: miscFrozen.toString(),
+          reserved: reserved.toString(),
+          feeFrozen: feeFrozen.toString()
+        }
+      };
+    });
+    callBack(items);
+  });
+  return () => {
+    unsub();
+  };
+}
+function subscribePSP22Balance(addresses, chain, api, callBack) {
+  let tokenList = {};
+  const psp22ContractMap = {};
+  const getTokenBalances = () => {
+    Object.values(tokenList).map(async tokenInfo => {
+      try {
+        const contract = psp22ContractMap[tokenInfo.slug];
+        const balances = await Promise.all(addresses.map(async address => {
+          try {
+            var _balanceOf$output, _ref2;
+            const _balanceOf = await contract.query['psp22::balanceOf'](address, {
+              gasLimit: (0, _utils.getDefaultWeightV2)(api)
+            }, address);
+            const balanceObj = _balanceOf === null || _balanceOf === void 0 ? void 0 : (_balanceOf$output = _balanceOf.output) === null || _balanceOf$output === void 0 ? void 0 : _balanceOf$output.toPrimitive();
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: _balanceOf.output ? (_ref2 = balanceObj.ok) !== null && _ref2 !== void 0 ? _ref2 : balanceObj.Ok : '0',
+              locked: '0',
+              state: _KoniTypes.APIItemState.READY
+            };
+          } catch (err) {
+            console.error(`Error on get balance of account ${address} for token ${tokenInfo.slug}`, err);
+            return {
+              address: address,
+              tokenSlug: tokenInfo.slug,
+              free: '0',
+              locked: '0',
+              state: _KoniTypes.APIItemState.READY
+            };
+          }
+        }));
+        callBack(balances);
+      } catch (err) {
+        console.warn(tokenInfo.slug, err); // TODO: error createType
+      }
+    });
+  };
+
+  tokenList = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.PSP22]);
+  Object.entries(tokenList).forEach(_ref3 => {
+    let [slug, tokenInfo] = _ref3;
+    psp22ContractMap[slug] = (0, _wasm.getPSP22ContractPromise)(api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  });
+  getTokenBalances();
+  const interval = setInterval(getTokenBalances, _constants.SUB_TOKEN_REFRESH_BALANCE_INTERVAL);
+  return () => {
+    clearInterval(interval);
+  };
+}
+async function subscribeTokensAccountsPallet(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 = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+      const assetId = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+
+      // Get Token Balance
+      // @ts-ignore
+      return await api.query.tokens.accounts.multi(addresses.map(address => [address, onChainInfo || assetId]), balances => {
+        const items = balances.map((balance, index) => {
+          const tokenBalance = {
+            reserved: balance.reserved || new _util.BN(0),
+            frozen: balance.frozen || new _util.BN(0),
+            free: balance.free || new _util.BN(0) // free is actually total balance
+          };
+
+          const freeBalance = tokenBalance.free.sub(tokenBalance.frozen);
+          const lockedBalance = tokenBalance.frozen.add(tokenBalance.reserved);
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            state: _KoniTypes.APIItemState.READY,
+            free: freeBalance.toString(),
+            locked: lockedBalance.toString(),
+            substrateInfo: {
+              reserved: tokenBalance.reserved.toString(),
+              miscFrozen: tokenBalance.frozen.toString()
+            }
+          };
+        });
+        callBack(items);
+      });
+    } catch (err) {
+      console.warn(err);
+    }
+    return undefined;
+  }));
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+async function subscribeAssetsAccountPallet(addresses, chain, api, callBack) {
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, [_types._AssetType.LOCAL]);
+  Object.values(tokenMap).forEach(token => {
+    if (_constants2._MANTA_ZK_CHAIN_GROUP.includes(token.originChain) && token.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
+      delete tokenMap[token.slug];
+    }
+  });
+  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const assetIndex = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
+
+      // Get Token Balance
+      return await api.query.assets.account.multi(addresses.map(address => [assetIndex, address]), balances => {
+        const items = balances.map((balance, index) => {
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
+          const bdata = balance === null || balance === void 0 ? void 0 : balance.toHuman();
+          let frozen = _util.BN_ZERO;
+          let total = _util.BN_ZERO;
+          if (bdata) {
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument
+            const addressBalance = new _util.BN(String(bdata === null || bdata === void 0 ? void 0 : bdata.balance).replaceAll(',', '') || '0');
+
+            // @ts-ignore
+            if (bdata !== null && bdata !== void 0 && bdata.isFrozen) {
+              frozen = addressBalance;
+            } else {
+              total = addressBalance;
+            }
+          }
+          const free = total.sub(frozen);
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            free: free.toString(),
+            locked: frozen.toString(),
+            state: _KoniTypes.APIItemState.READY,
+            substrateInfo: {
+              miscFrozen: frozen.toString(),
+              reserved: '0'
+            }
+          };
+        });
+        callBack(items);
+      });
+    } catch (err) {
+      console.warn(err);
+    }
+    return undefined;
+  }));
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/require-await
+async function subscribeOrmlTokensPallet(addresses, chain, api, callBack) {
+  const tokenTypes = [_types._AssetType.LOCAL];
+  const tokenMap = _handlers.state.getAssetByChainAndAsset(chain, tokenTypes);
+  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+    try {
+      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+
+      // Get Token Balance
+      // @ts-ignore
+      const unsub = await api.query.ormlTokens.accounts.multi(addresses.map(address => [address, onChainInfo]), balances => {
+        const items = balances.map((balance, index) => {
+          const tokenBalance = {
+            reserved: balance.reserved || new _util.BN(0),
+            frozen: balance.frozen || new _util.BN(0),
+            free: balance.free || new _util.BN(0) // free is actually total balance
+          };
+
+          // free balance = total balance - frozen misc
+          // locked balance = reserved + frozen misc
+          const freeBalance = tokenBalance.free.sub(tokenBalance.frozen);
+          const lockedBalance = tokenBalance.frozen.add(tokenBalance.reserved);
+          return {
+            address: addresses[index],
+            tokenSlug: tokenInfo.slug,
+            state: _KoniTypes.APIItemState.READY,
+            free: freeBalance.toString(),
+            locked: lockedBalance.toString(),
+            substrateInfo: {
+              reserved: tokenBalance.reserved.toString(),
+              miscFrozen: tokenBalance.frozen.toString()
+            }
+          };
+        });
+        callBack(items);
+      });
+      return unsub;
+    } catch (err) {
+      console.warn(err);
+      return undefined;
+    }
+  });
+  return () => {
+    unsubList.forEach(subProm => {
+      subProm.then(unsub => {
+        unsub && unsub();
+      }).catch(console.error);
+    });
+  };
+}

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

@@ -6,8 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 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 _group = require("@subwallet/extension-base/services/balance-service/helpers/group");
+var _evm = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/evm");
+var _substrate = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/substrate");
 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");
@@ -15,10 +16,17 @@ var _i18next = require("i18next");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+/**
+ * Balance service
+ * @class
+*/
 class BalanceService {
-  constructor(chainService) {
-    this.chainService = chainService;
-
+  /**
+   * @constructor
+   * @param {KoniState} state - The state of extension.
+   */
+  constructor(state) {
+    this.state = state;
     // Todo: Load data from db to balanceSubject
     // Todo: Start  subscribe balance and data
     // Todo: Listen change and apply to balanceSubject
@@ -29,9 +37,10 @@ class BalanceService {
     // Todo: Move everything of fetching balance to this service
   }
 
+  /* Subscribe token free balance on chain */
   async subscribeTokenFreeBalance(address, chain, tokenSlug, callback) {
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
-    const chainState = this.chainService.getChainStateByKey(chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(chain);
+    const chainState = this.state.chainService.getChainStateByKey(chain);
     if (!chainInfo || !chainState || !chainState.active) {
       return Promise.reject(new _BalanceError.BalanceError(_KoniTypes.BalanceErrorType.NETWORK_ERROR, (0, _i18next.t)('{{chain}} is inactive. Please enable network', {
         replace: {
@@ -40,7 +49,7 @@ class BalanceService {
       })));
     }
     const tSlug = tokenSlug || (0, _utils._getChainNativeTokenSlug)(chainInfo);
-    const tokenInfo = this.chainService.getAssetBySlug(tSlug);
+    const tokenInfo = this.state.chainService.getAssetBySlug(tSlug);
     if (!tokenInfo) {
       return Promise.reject(new _BalanceError.BalanceError(_KoniTypes.BalanceErrorType.TOKEN_ERROR, (0, _i18next.t)('Transfer is currently not available for this token: {{tSlug}}', {
         replace: {
@@ -75,35 +84,51 @@ class BalanceService {
       }, 9999);
     });
   }
+
+  /**
+   * @public
+   * @async
+   * @function getTokenFreeBalance
+   * @desc Fetch free balance on chain
+   * @param {string} address - Address
+   * @param {string} chain - Slug of chain
+   * @param {string} [tokenSlug] - Slug of token
+   * @return {Promise<AmountData>} - Free token balance of address on chain
+  */
   async getTokenFreeBalance(address, chain, tokenSlug) {
     const [, balance] = await this.subscribeTokenFreeBalance(address, chain, tokenSlug);
     return balance;
   }
-  subscribeBalance(addresses, chains, callback) {
+  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();
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const chainStateMap = this.state.chainService.getChainStateMap();
+    const substrateApiMap = this.state.chainService.getSubstrateApiMap();
+    const evmApiMap = this.state.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]);
+    const callback = items => {
+      if (items.length) {
+        _callback((0, _group.groupBalance)(items, 'GROUPED', items[0].tokenSlug));
+      }
+    };
 
     // 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);
+        const nativeTokenInfo = this.state.getNativeTokenInfo(chainSlug);
+        return (0, _evm.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 (0, _substrate.subscribeSubstrateBalance)(useAddresses, chainInfo, chainSlug, networkAPI, evmApiMap, callback);
     });
     return () => {
       unsubList.forEach(subProm => {

package/cjs/services/chain-service/constants.js

@@ -66,13 +66,13 @@ const _NFT_CHAIN_GROUP = {
 // Staking--------------------------------------------------------------------------------------------------------------
 exports._NFT_CHAIN_GROUP = _NFT_CHAIN_GROUP;
 const _STAKING_CHAIN_GROUP = {
-  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network'],
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari'],
   astar: ['astar', 'shiden', 'shibuya'],
   amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum'],
   // amplitude and kilt only share some common logic
   kilt: ['kilt', 'kilt_peregrine'],
-  nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network'],
+  nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network', 'goldberg_testnet'],
   bifrost: ['bifrost', 'bifrost_testnet'],
   aleph: ['aleph', 'alephTest'],
   // A0 has distinct tokenomics
@@ -109,7 +109,8 @@ const _STAKING_ERA_LENGTH_MAP = {
   edgeware: 6,
   kate: 6,
   creditcoin: 24,
-  vara_network: 12
+  vara_network: 12,
+  goldberg_testnet: 24
 };
 exports._STAKING_ERA_LENGTH_MAP = _STAKING_ERA_LENGTH_MAP;
 const _PARACHAIN_INFLATION_DISTRIBUTION = {

package/cjs/services/history-service/helpers/subscan-extrinsic-parser-helper.js

@@ -20,6 +20,12 @@ function paramJsonParse(item) {
     return [];
   }
 }
+function autoAddPublicKeyPrefix(publicKey) {
+  if (!publicKey.startsWith('0x')) {
+    return `0x${publicKey}`;
+  }
+  return publicKey;
+}
 function balanceTransferParserFunction(item) {
   const params = paramJsonParse(item);
   params.forEach(p => {
@@ -27,7 +33,7 @@ function balanceTransferParserFunction(item) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const toPublicKey = p.value.id || p.value.Id;
       if (toPublicKey) {
-        item.to = (0, _utilCrypto.encodeAddress)(toPublicKey, 42);
+        item.to = (0, _utilCrypto.encodeAddress)(autoAddPublicKeyPrefix(toPublicKey), 42);
       }
     } else if (p.name === 'value') {
       if (item.amount) {

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

@@ -83,7 +83,7 @@ class HistoryService {
     const excludeExtrinsicParserKeys = ['balances.transfer_all'];
 
     // Note: fetchAllPossibleExtrinsicItems and fetchAllPossibleTransferItems-receive can run parallelly
-    // Hover, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
+    // However, fetchAllPossibleTransferItems-sent must run after fetchAllPossibleExtrinsicItems,
     // to avoid "duplicate Extrinsic Hash between items" problem
 
     this.subscanService.fetchAllPossibleExtrinsicItems(chain, address, extrinsicItems => {
@@ -104,11 +104,12 @@ class HistoryService {
           excludeTransferExtrinsicHash.push(x.extrinsic_hash);
         }
       });
-      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent', transferItems => {
+      this.subscanService.fetchAllPossibleTransferItems(chain, address, 'sent').then(rsMap => {
         const result = [];
-        transferItems.forEach(t => {
-          if (!excludeTransferExtrinsicHash.includes(t.hash)) {
-            result.push((0, _subscanHistory.parseSubscanTransferData)(address, t, chainInfo));
+        Object.keys(rsMap).forEach(hash => {
+          // only push item that does not have same hash with another item
+          if (!excludeTransferExtrinsicHash.includes(hash) && rsMap[hash].length === 1) {
+            result.push((0, _subscanHistory.parseSubscanTransferData)(address, rsMap[hash][0], chainInfo));
           }
         });
         this.addHistoryItems(result).catch(e => {
@@ -120,10 +121,13 @@ class HistoryService {
     }).catch(e => {
       console.log('fetchAllPossibleExtrinsicItems error', e);
     });
-    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received', transferItems => {
+    this.subscanService.fetchAllPossibleTransferItems(chain, address, 'received').then(rsMap => {
       const result = [];
-      transferItems.forEach(t => {
-        result.push((0, _subscanHistory.parseSubscanTransferData)(address, t, chainInfo));
+      Object.keys(rsMap).forEach(hash => {
+        // only push item that does not have same hash with another item
+        if (rsMap[hash].length === 1) {
+          result.push((0, _subscanHistory.parseSubscanTransferData)(address, rsMap[hash][0], chainInfo));
+        }
       });
       this.addHistoryItems(result).catch(e => {
         console.log('addHistoryItems in fetchAllPossibleTransferItems-receive error', e);

package/cjs/services/migration-service/scripts/MigrateProvider.js

@@ -14,7 +14,7 @@ class MigrateProvider extends _Base.default {
     const state = this.state;
     const chainState = state.getChainStateByKey(this.slug);
     const chainInfo = state.getChainInfo(this.slug);
-    if (chainState.active && chainState.currentProvider === this.oldProvider) {
+    if (chainState && chainState.active && chainState.currentProvider === this.oldProvider) {
       await state.upsertChainInfo({
         mode: 'update',
         chainEditInfo: {