@subwallet/extension-base 0.8.3-2 → 1.0.1

package/cjs/koni/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/koni/page/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initEvmProvider = initEvmProvider;
+var _SubWalleEvmProvider = require("@subwallet/extension-base/koni/page/SubWalleEvmProvider");
+var _page = require("@subwallet/extension-base/page");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// the enable function, called by the dapp to allow access
+
+function initEvmProvider(version) {
+  return new _SubWalleEvmProvider.SubWalletEvmProvider(_page.sendMessage, version);
+}

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.3-2'
+  version: '1.0.1'
 };
 exports.packageInfo = packageInfo;

package/cjs/page/index.js

@@ -7,7 +7,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.enable = enable;
 exports.handleResponse = handleResponse;
 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 _defaults = require("../defaults");
 var _getId = require("../utils/getId");
 var _Injected = _interopRequireDefault(require("./Injected"));
@@ -57,7 +58,7 @@ 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);
   }

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

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssetService = void 0;
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class AssetService {
+  // Todo: Update to new store indexed DB
+
+  assetSettingSubject = new _rxjs.BehaviorSubject({});
+  constructor(store, chainService) {
+    this.chainService = chainService;
+    this.store = store;
+    this.initAssetSettings().catch(console.error);
+  }
+  async initAssetSettings() {
+    const assetSettings = await this.getAssetSettings();
+    const activeChainSlugs = this.chainService.getActiveChainSlugs();
+    const assetRegistry = this.chainService.getAssetRegistry();
+    if (Object.keys(assetSettings).length === 0) {
+      // only initiate the first time
+      Object.values(assetRegistry).forEach(assetInfo => {
+        const isSettingExisted = (assetInfo.slug in assetSettings);
+
+        // Set visible for every enabled chains
+        if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
+          // Setting only exist when set either by chain settings or user
+          assetSettings[assetInfo.slug] = {
+            visible: true
+          };
+        }
+      });
+      this.setAssetSettings(assetSettings);
+    }
+    console.log('Done init asset settings');
+  }
+  setAssetSettings(assetSettings) {
+    this.assetSettingSubject.next(assetSettings);
+    this.store.set('AssetSetting', assetSettings);
+  }
+  async getStoreAssetSettings() {
+    return new Promise(resolve => {
+      this.store.get('AssetSetting', resolve);
+    });
+  }
+  async getAssetSettings() {
+    if (Object.keys(this.assetSettingSubject.value).length === 0) {
+      const assetSettings = await this.getStoreAssetSettings();
+      this.assetSettingSubject.next(assetSettings);
+    }
+    return this.assetSettingSubject.value;
+  }
+  getAssetSettingSubject() {
+    return this.assetSettingSubject;
+  }
+  async updateAssetSetting(assetSlug, assetSetting) {
+    const currentAssetSettings = await this.getAssetSettings();
+
+    // Update settings
+    currentAssetSettings[assetSlug] = assetSetting;
+    this.setAssetSettings(currentAssetSettings);
+    if (assetSetting.visible) {
+      const assetInfo = this.chainService.getAssetBySlug(assetSlug);
+      const chainState = this.chainService.getChainStateByKey(assetInfo.originChain);
+
+      // if chain not enabled, then automatically enable
+      if (chainState && !chainState.active) {
+        this.chainService.enableChain(chainState.slug);
+      }
+    }
+  }
+  async updateAssetSettingByChain(chainSlug, visible) {
+    const storedAssetSettings = await this.getAssetSettings();
+    const assetsByChain = this.chainService.getFungibleTokensByChain(chainSlug);
+    const assetSettings = storedAssetSettings || {};
+    Object.values(assetsByChain).forEach(assetInfo => {
+      assetSettings[assetInfo.slug] = {
+        visible
+      };
+    });
+    this.setAssetSettings(assetSettings);
+  }
+  subscribeAssetSettings() {
+    return this.assetSettingSubject;
+  }
+}
+exports.AssetService = AssetService;

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;

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

@@ -0,0 +1,231 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._XCM_TYPE = exports._XCM_CHAIN_USE_LIMITED_WEIGHT = exports._XCM_CHAIN_GROUP = exports._TRANSFER_NOT_SUPPORTED_CHAINS = exports._TRANSFER_CHAIN_GROUP = exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = exports._STAKING_ERA_LENGTH_MAP = exports._STAKING_CHAIN_GROUP = exports._PURE_EVM_CHAINS = exports._PREDEFINED_SINGLE_MODES = exports._PARACHAIN_INFLATION_DISTRIBUTION = exports._NFT_CHAIN_GROUP = exports._KNOWN_CHAIN_INFLATION_PARAMS = exports._DEFAULT_ACTIVE_CHAINS = exports._BALANCE_TOKEN_GROUP = exports._BALANCE_PARSING_CHAIN_GROUP = exports._BALANCE_CHAIN_GROUP = exports._API_OPTIONS_CHAIN_GROUP = exports.API_MAX_RETRY = exports.API_AUTO_CONNECT_MS = void 0;
+var _chainList = require("@subwallet/chain-list");
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const API_AUTO_CONNECT_MS = 3000;
+exports.API_AUTO_CONNECT_MS = API_AUTO_CONNECT_MS;
+const API_MAX_RETRY = 2;
+exports.API_MAX_RETRY = API_MAX_RETRY;
+const _API_OPTIONS_CHAIN_GROUP = {
+  acala: ['acala', 'karura', 'origintrail', 'kintsugi'],
+  turing: ['turingStaging', 'turing']
+};
+exports._API_OPTIONS_CHAIN_GROUP = _API_OPTIONS_CHAIN_GROUP;
+const _PREDEFINED_SINGLE_MODES = {
+  subspace: {
+    networkKeys: ['subspace_gemini_2a', 'subspace_test', 'subspace_gemini_3a'],
+    theme: _KoniTypes.ThemeNames.SUBSPACE,
+    autoTriggerDomain: 'subspace.network'
+  }
+};
+exports._PREDEFINED_SINGLE_MODES = _PREDEFINED_SINGLE_MODES;
+const _PURE_EVM_CHAINS = ['binance', 'binance_test', 'ethereum', 'ethereum_goerli', 'astarEvm', 'shidenEvm', 'shibuyaEvm', 'crabEvm', 'pangolinEvm', 'cloverEvm', 'boba_rinkeby', 'boba', 'bobabase', 'bobabeam', 'watr_network_evm'];
+
+// Get balance----------------------------------------------------------------------------------------------------------
+exports._PURE_EVM_CHAINS = _PURE_EVM_CHAINS;
+const _BALANCE_CHAIN_GROUP = {
+  kintsugi: ['kintsugi', 'interlay', 'kintsugi_test'],
+  genshiro: ['genshiro_testnet', 'genshiro'],
+  equilibrium_parachain: ['equilibrium_parachain'],
+  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain'],
+  kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
+};
+exports._BALANCE_CHAIN_GROUP = _BALANCE_CHAIN_GROUP;
+const _BALANCE_TOKEN_GROUP = {
+  crab: ['CKTON', 'PKTON'],
+  bitcountry: ['BIT']
+};
+exports._BALANCE_TOKEN_GROUP = _BALANCE_TOKEN_GROUP;
+const _NFT_CHAIN_GROUP = {
+  acala: ['acala'],
+  karura: ['karura'],
+  // TODO: karura and acala should be the same
+  rmrk: ['kusama'],
+  statemine: ['statemine', 'statemint'],
+  unique_network: ['unique_network'],
+  bitcountry: ['bitcountry', 'pioneer']
+};
+
+// Staking--------------------------------------------------------------------------------------------------------------
+exports._NFT_CHAIN_GROUP = _NFT_CHAIN_GROUP;
+const _STAKING_CHAIN_GROUP = {
+  relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend'],
+  para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari'],
+  astar: ['astar', 'shiden', 'shibuya'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine'],
+  // amplitude and kilt only share some common logic
+  kilt: ['kilt', 'kilt_peregrine'],
+  nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph'],
+  bifrost: ['bifrost', 'bifrost_testnet'],
+  aleph: ['aleph, alephTest'] // A0 has distinct tokenomics
+};
+exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;
+const _STAKING_ERA_LENGTH_MAP = {
+  // in hours
+  alephTest: 24,
+  aleph: 24,
+  polkadot: 24,
+  kusama: 6,
+  westend: 6,
+  hydradx: 24,
+  default: 24,
+  moonbeam: 6,
+  moonriver: 2,
+  moonbase: 2,
+  turing: 2,
+  turingStaging: 2,
+  astar: 24,
+  shiden: 24,
+  shibuya: 24,
+  bifrost_testnet: 0.5,
+  bifrost: 2,
+  ternoa: 24,
+  calamari: 6,
+  calamari_test: 6,
+  amplitude: 2,
+  amplitude_test: 2,
+  kilt: 2,
+  kilt_peregrine: 2
+};
+exports._STAKING_ERA_LENGTH_MAP = _STAKING_ERA_LENGTH_MAP;
+const _PARACHAIN_INFLATION_DISTRIBUTION = {
+  moonbeam: {
+    // https://docs.moonbeam.network/learn/features/staking/#annual-inflation
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  moonriver: {
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  moonbase: {
+    reward: 0.5,
+    collatorCommission: 0.2,
+    bondReserve: 0.3
+  },
+  turing: {
+    // https://docs.oak.tech/docs/delegators/
+    reward: 0.5
+  },
+  turingStaging: {
+    // https://docs.oak.tech/docs/delegators/
+    reward: 0.5
+  },
+  bifrost: {
+    reward: 0
+  },
+  bifrost_testnet: {
+    reward: 0
+  },
+  calamari_test: {
+    reward: 0.9
+  },
+  calamari: {
+    reward: 0.9
+  },
+  default: {
+    reward: 0
+  }
+};
+exports._PARACHAIN_INFLATION_DISTRIBUTION = _PARACHAIN_INFLATION_DISTRIBUTION;
+const _SUBSTRATE_DEFAULT_INFLATION_PARAMS = {
+  auctionAdjust: 0,
+  auctionMax: 0,
+  // 5% for falloff, as per the defaults, see
+  // https://github.com/paritytech/polkadot/blob/816cb64ea16102c6c79f6be2a917d832d98df757/runtime/kusama/src/lib.rs#L534
+  falloff: 0.05,
+  // 10% max, 0.25% min, see
+  // https://github.com/paritytech/polkadot/blob/816cb64ea16102c6c79f6be2a917d832d98df757/runtime/kusama/src/lib.rs#L523
+  maxInflation: 0.1,
+  minInflation: 0.025,
+  stakeTarget: 0.5
+};
+exports._SUBSTRATE_DEFAULT_INFLATION_PARAMS = _SUBSTRATE_DEFAULT_INFLATION_PARAMS;
+const _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS = {
+  ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+  yearlyInflationInTokens: 30000000
+};
+const _KNOWN_CHAIN_INFLATION_PARAMS = {
+  aleph: _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS,
+  alephTest: _ALEPH_DEFAULT_UNIFORM_ERA_PAYOUT_PARAMS,
+  dock_pos: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  },
+  kusama: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    auctionAdjust: 0.3 / 60,
+    auctionMax: 60,
+    stakeTarget: 0.75
+  },
+  neatcoin: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  },
+  nft_mart: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    falloff: 0.04,
+    stakeTarget: 0.60
+  },
+  polkadot: {
+    ..._SUBSTRATE_DEFAULT_INFLATION_PARAMS,
+    stakeTarget: 0.75
+  }
+};
+
+// Send fund------------------------------------------------------------------------------------------------------------
+exports._KNOWN_CHAIN_INFLATION_PARAMS = _KNOWN_CHAIN_INFLATION_PARAMS;
+const _TRANSFER_NOT_SUPPORTED_CHAINS = ['subspace_gemini_3a', 'kulupu', 'joystream', 'equilibrium_parachain', 'genshiro_testnet', 'genshiro'];
+exports._TRANSFER_NOT_SUPPORTED_CHAINS = _TRANSFER_NOT_SUPPORTED_CHAINS;
+const _TRANSFER_CHAIN_GROUP = {
+  acala: ['karura', 'acala', 'acala_testnet'],
+  kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
+  genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
+  crab: ['crab', 'pangolin'],
+  bitcountry: ['pioneer', 'bitcountry'],
+  statemine: ['statemint', 'statemine']
+};
+exports._TRANSFER_CHAIN_GROUP = _TRANSFER_CHAIN_GROUP;
+const _BALANCE_PARSING_CHAIN_GROUP = {
+  bobabeam: ['bobabeam', 'bobabase']
+};
+
+// XCM------------------------------------------------------------------------------------------------------------------
+exports._BALANCE_PARSING_CHAIN_GROUP = _BALANCE_PARSING_CHAIN_GROUP;
+const _XCM_CHAIN_GROUP = {
+  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint'],
+  xcmPallet: ['polkadot', 'kusama']
+  // default is xTokens pallet
+  // moonbeam: ['moonbeam', 'moonriver', 'moonbase'],
+  // astar: ['astar', 'shiden'],
+  // statemine: ['statemint', 'statemine'],
+  // bifrost: ['bifrost'],
+  // genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
+  // kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
+  // acala: ['karura', 'acala', 'acala_testnet'],
+  // astarEvm: ['astarEvm', 'shidenEvm']
+};
+exports._XCM_CHAIN_GROUP = _XCM_CHAIN_GROUP;
+const _XCM_CHAIN_USE_LIMITED_WEIGHT = ['acala', 'karura', 'statemint'];
+exports._XCM_CHAIN_USE_LIMITED_WEIGHT = _XCM_CHAIN_USE_LIMITED_WEIGHT;
+const _XCM_TYPE = {
+  RP: `${_types._SubstrateChainType.RELAYCHAIN}-${_types._SubstrateChainType.PARACHAIN}`,
+  // DMP
+  PP: `${_types._SubstrateChainType.PARACHAIN}-${_types._SubstrateChainType.PARACHAIN}`,
+  // HRMP
+  PR: `${_types._SubstrateChainType.PARACHAIN}-${_types._SubstrateChainType.RELAYCHAIN}` // UMP
+};
+exports._XCM_TYPE = _XCM_TYPE;
+const _DEFAULT_ACTIVE_CHAINS = [..._chainList._DEFAULT_CHAINS];
+exports._DEFAULT_ACTIVE_CHAINS = _DEFAULT_ACTIVE_CHAINS;