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

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

@@ -8,17 +8,19 @@ exports.subscribeSubstrateBalance = void 0;
 var _types = require("@subwallet/chain-list/types");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
+var _assetsPallet = require("@subwallet/extension-base/core/substrate/assets-pallet");
 var _foreignAssetPallet = require("@subwallet/extension-base/core/substrate/foreign-asset-pallet");
 var _nominationpoolsPallet = require("@subwallet/extension-base/core/substrate/nominationpools-pallet");
+var _ormlTokensPallet = require("@subwallet/extension-base/core/substrate/ormlTokens-pallet");
 var _systemPallet = require("@subwallet/extension-base/core/substrate/system-pallet");
+var _tokensPallet = require("@subwallet/extension-base/core/substrate/tokens-pallet");
+var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
 var _wasm = require("@subwallet/extension-base/koni/api/contract-handler/wasm");
 var _utils = require("@subwallet/extension-base/koni/api/contract-handler/wasm/utils");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
-var _rxjs = require("rxjs");
-var _util = require("@polkadot/util");
 var _evm = require("../evm");
 var _equilibrium = require("./equilibrium");
 var _gear = require("./gear");
@@ -43,7 +45,7 @@ const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap, substra
   };
   const substrateParams = {
     ...baseParams,
-    substrateApi: substrateApi.api
+    substrateApi
   };
   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(substrateParams);
@@ -119,43 +121,34 @@ const subscribeWithSystemAccountPallet = async _ref => {
     extrinsicType,
     substrateApi
   } = _ref;
-  const chainNativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(chainInfo);
-  const balanceSubscribe = substrateApi.rx.query.system.account.multi(addresses);
-  let poolSubscribe; // add points in nomination pool back to user's balance
-
-  if ((0, _utils2._isSubstrateRelayChain)(chainInfo) && substrateApi.query.nominationPools) {
-    var _substrateApi$rx$quer;
-    poolSubscribe = (_substrateApi$rx$quer = substrateApi.rx.query.nominationPools.poolMembers) === null || _substrateApi$rx$quer === void 0 ? void 0 : _substrateApi$rx$quer.multi(addresses);
-  }
-  if (!poolSubscribe) {
-    poolSubscribe = new _rxjs.Observable(subscriber => {
-      subscriber.next(addresses.map(() => ({
-        toPrimitive() {
-          return null;
-        }
-      })));
-    });
-  }
-  const subscription = (0, _rxjs.combineLatest)({
-    balances: balanceSubscribe,
-    poolMemberInfos: poolSubscribe
-  }).subscribe(_ref2 => {
-    let {
-      balances,
-      poolMemberInfos
-    } = _ref2;
+  const systemAccountKey = 'query_system_account';
+  const poolMembersKey = 'query_nominationPools_poolMembers';
+  const params = [{
+    section: 'query',
+    module: systemAccountKey.split('_')[1],
+    method: systemAccountKey.split('_')[2],
+    args: addresses
+  }, {
+    section: 'query',
+    module: poolMembersKey.split('_')[1],
+    method: poolMembersKey.split('_')[2],
+    args: addresses
+  }];
+  const subscription = substrateApi.subscribeDataWithMulti(params, rs => {
+    const balances = rs[systemAccountKey];
+    const poolMemberInfos = rs[poolMembersKey];
     const items = balances.map((_balance, index) => {
-      const balanceInfo = _balance.toPrimitive();
-      const poolMemberInfo = poolMemberInfos[index].toPrimitive();
-      const nominationPoolBalance = poolMemberInfo ? (0, _nominationpoolsPallet._getTotalStakeInNominationPool)(poolMemberInfo) : new _bignumber.default(0);
+      const balanceInfo = _balance;
+      const poolMemberInfo = poolMemberInfos[index];
+      const nominationPoolBalance = poolMemberInfo ? (0, _nominationpoolsPallet._getTotalStakeInNominationPool)(poolMemberInfo) : BigInt(0);
       const transferableBalance = (0, _systemPallet._getSystemPalletTransferable)(balanceInfo, (0, _utils2._getChainExistentialDeposit)(chainInfo), extrinsicType);
       const totalBalance = (0, _systemPallet._getSystemPalletTotalBalance)(balanceInfo);
-      const totalLockedFromTransfer = new _bignumber.default(totalBalance).minus(transferableBalance).plus(nominationPoolBalance);
+      const totalLockedFromTransfer = totalBalance - transferableBalance + nominationPoolBalance;
       return {
         address: addresses[index],
-        tokenSlug: chainNativeTokenSlug,
-        free: transferableBalance,
-        locked: totalLockedFromTransfer.toFixed(),
+        tokenSlug: (0, _utils2._getChainNativeTokenSlug)(chainInfo),
+        free: transferableBalance.toString(),
+        locked: totalLockedFromTransfer.toString(),
         state: _KoniTypes.APIItemState.READY,
         metadata: balanceInfo
       };
@@ -166,31 +159,37 @@ const subscribeWithSystemAccountPallet = async _ref => {
     subscription.unsubscribe();
   };
 };
-const subscribeForeignAssetBalance = async _ref3 => {
+const subscribeForeignAssetBalance = async _ref2 => {
   let {
     addresses,
     assetMap,
     callback,
     chainInfo,
+    extrinsicType,
     substrateApi
-  } = _ref3;
-  const chain = chainInfo.slug;
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.LOCAL]);
-
-  // @ts-ignore
-  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+  } = _ref2;
+  const foreignAssetsAccountKey = 'query_foreignAssets_account';
+  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
+  const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
-      const isBridgedToken = (0, _utils2._isBridgedToken)(tokenInfo);
-      if (isBridgedToken) {
-        const assetLocation = (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getXcmAssetMultilocation)(tokenInfo);
-        return await substrateApi.query.foreignAssets.account.multi(addresses.map(address => [assetLocation, address]), balances => {
-          const items = balances.map((balance, index) => {
-            const accountInfo = balance === null || balance === void 0 ? void 0 : balance.toPrimitive();
+      if ((0, _utils2._isBridgedToken)(tokenInfo)) {
+        const params = [{
+          section: 'query',
+          module: foreignAssetsAccountKey.split('_')[1],
+          method: foreignAssetsAccountKey.split('_')[2],
+          args: addresses.map(address => [(0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _xcmParser._adaptX1Interior)((0, _utils2._getXcmAssetMultilocation)(tokenInfo), 3), address])
+        }];
+        return substrateApi.subscribeDataWithMulti(params, rs => {
+          const balances = rs[foreignAssetsAccountKey];
+          const items = balances.map((_balance, index) => {
+            const balanceInfo = _balance;
+            const transferableBalance = (0, _foreignAssetPallet._getForeignAssetPalletTransferable)(balanceInfo, (0, _utils2._getAssetExistentialDeposit)(tokenInfo), extrinsicType);
+            const totalLockedFromTransfer = (0, _foreignAssetPallet._getForeignAssetPalletLockedBalance)(balanceInfo);
             return {
               address: addresses[index],
               tokenSlug: tokenInfo.slug,
-              free: accountInfo ? (0, _foreignAssetPallet._getForeignAssetPalletTransferable)(accountInfo).toString() : '0',
-              locked: accountInfo ? (0, _foreignAssetPallet._getForeignAssetPalletLockedBalance)(accountInfo).toString() : '0',
+              free: transferableBalance.toString(),
+              locked: totalLockedFromTransfer.toString(),
               state: _KoniTypes.APIItemState.READY
             };
           });
@@ -204,7 +203,7 @@ const subscribeForeignAssetBalance = async _ref3 => {
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
@@ -217,20 +216,20 @@ function extractOkResponse(response) {
   }
   return undefined;
 }
-const subscribePSP22Balance = _ref4 => {
+const subscribePSP22Balance = _ref3 => {
   let {
     addresses,
     assetMap,
     callback,
     chainInfo,
     substrateApi
-  } = _ref4;
+  } = _ref3;
   const chain = chainInfo.slug;
   const psp22ContractMap = {};
   const tokenList = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.PSP22]);
-  Object.entries(tokenList).forEach(_ref5 => {
-    let [slug, tokenInfo] = _ref5;
-    psp22ContractMap[slug] = (0, _wasm.getPSP22ContractPromise)(substrateApi, (0, _utils2._getContractAddressOfToken)(tokenInfo));
+  Object.entries(tokenList).forEach(_ref4 => {
+    let [slug, tokenInfo] = _ref4;
+    psp22ContractMap[slug] = (0, _wasm.getPSP22ContractPromise)(substrateApi.api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
   });
   const getTokenBalances = () => {
     Object.values(tokenList).map(async tokenInfo => {
@@ -240,7 +239,7 @@ const subscribePSP22Balance = _ref4 => {
           try {
             var _balanceOf$output;
             const _balanceOf = await contract.query['psp22::balanceOf'](address, {
-              gasLimit: (0, _utils.getDefaultWeightV2)(substrateApi)
+              gasLimit: (0, _utils.getDefaultWeightV2)(substrateApi.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();
             const freeResponse = extractOkResponse(balanceObj);
@@ -276,41 +275,39 @@ const subscribePSP22Balance = _ref4 => {
     clearInterval(interval);
   };
 };
-const subscribeTokensAccountsPallet = async _ref6 => {
+const subscribeTokensAccountsPallet = async _ref5 => {
   let {
     addresses,
     assetMap,
     callback,
     chainInfo,
+    extrinsicType,
     includeNativeToken,
     substrateApi
-  } = _ref6;
-  const chain = chainInfo.slug;
+  } = _ref5;
+  const tokensAccountsKey = 'query_tokens_accounts';
   const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, tokenTypes);
-  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, tokenTypes);
+  const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
-      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
-      const assetId = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
-
-      // Get Token Balance
-      // @ts-ignore
-      return await substrateApi.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);
+      const params = [{
+        section: 'query',
+        module: tokensAccountsKey.split('_')[1],
+        method: tokensAccountsKey.split('_')[2],
+        args: addresses.map(address => [address, (0, _utils2._getTokenOnChainInfo)(tokenInfo) || (0, _utils2._getTokenOnChainAssetId)(tokenInfo)])
+      }];
+      return substrateApi.subscribeDataWithMulti(params, rs => {
+        const balances = rs[tokensAccountsKey];
+        const items = balances.map((_balance, index) => {
+          const balanceInfo = _balance;
+          const transferableBalance = (0, _tokensPallet._getTokensPalletTransferable)(balanceInfo, (0, _utils2._getAssetExistentialDeposit)(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = (0, _tokensPallet._getTokensPalletLocked)(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
             state: _KoniTypes.APIItemState.READY,
-            free: freeBalance.toString(),
-            locked: lockedBalance.toString()
+            free: transferableBalance.toString(),
+            locked: totalLockedFromTransfer.toString()
           };
         });
         callback(items);
@@ -322,56 +319,51 @@ const subscribeTokensAccountsPallet = async _ref6 => {
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
-const subscribeAssetsAccountPallet = async _ref7 => {
+const subscribeAssetsAccountPallet = async _ref6 => {
   let {
     addresses,
     assetMap,
     callback,
     chainInfo,
-    includeNativeToken,
+    extrinsicType,
     substrateApi
-  } = _ref7;
-  const chain = chainInfo.slug;
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.LOCAL]);
+  } = _ref6;
+  const assetsAccountKey = 'query_assets_account';
+  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_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 => {
+  const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
       const assetIndex = (0, _utils2._getTokenOnChainAssetId)(tokenInfo);
       if (assetIndex === '-1') {
         return undefined;
       }
+      const params = [{
+        section: 'query',
+        module: assetsAccountKey.split('_')[1],
+        method: assetsAccountKey.split('_')[2],
+        args: addresses.map(address => [assetIndex, address])
+      }];
 
       // Get Token Balance
-      return await substrateApi.query.assets.account.multi(addresses.map(address => [assetIndex, address]), balances => {
-        const items = balances.map((balance, index) => {
-          const bdata = balance === null || balance === void 0 ? void 0 : balance.toPrimitive();
-          let frozen = _util.BN_ZERO;
-          let total = _util.BN_ZERO;
-          if (bdata) {
-            // @ts-ignore
-            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 || ['Blocked', 'Frozen'].includes(bdata === null || bdata === void 0 ? void 0 : bdata.status)) {
-              // Status 'Frozen' and 'Blocked' are for frozen balance
-              frozen = addressBalance;
-            }
-            total = addressBalance;
-          }
-          const free = total.sub(frozen);
+      return substrateApi.subscribeDataWithMulti(params, rs => {
+        const balances = rs[assetsAccountKey];
+        const items = balances.map((_balance, index) => {
+          const balanceInfo = _balance;
+          const transferableBalance = (0, _assetsPallet._getAssetsPalletTransferable)(balanceInfo, (0, _utils2._getAssetExistentialDeposit)(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = (0, _assetsPallet._getAssetsPalletLockedBalance)(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
-            free: free.toString(),
-            locked: frozen.toString(),
+            free: transferableBalance.toString(),
+            locked: totalLockedFromTransfer.toString(),
             state: _KoniTypes.APIItemState.READY
           };
         });
@@ -384,62 +376,57 @@ const subscribeAssetsAccountPallet = async _ref7 => {
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
 
 // eslint-disable-next-line @typescript-eslint/require-await
-const subscribeOrmlTokensPallet = async _ref8 => {
+const subscribeOrmlTokensPallet = async _ref7 => {
   let {
     addresses,
     assetMap,
     callback,
     chainInfo,
+    extrinsicType,
     substrateApi
-  } = _ref8;
-  const chain = chainInfo.slug;
-  const tokenTypes = [_types._AssetType.LOCAL];
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, tokenTypes);
-  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+  } = _ref7;
+  const ormlTokensAccountsKey = 'query_ormlTokens_accounts';
+  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
+  const unsubList = Object.values(tokenMap).map(tokenInfo => {
     try {
-      const onChainInfo = (0, _utils2._getTokenOnChainInfo)(tokenInfo);
+      const params = [{
+        section: 'query',
+        module: ormlTokensAccountsKey.split('_')[1],
+        method: ormlTokensAccountsKey.split('_')[2],
+        args: addresses.map(address => [address, (0, _utils2._getTokenOnChainInfo)(tokenInfo)])
+      }];
 
-      // Get Token Balance
       // @ts-ignore
-      const unsub = await substrateApi.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 substrateApi.subscribeDataWithMulti(params, rs => {
+        const balances = rs[ormlTokensAccountsKey];
+        const items = balances.map((_balance, index) => {
+          const balanceInfo = _balance;
+          const transferableBalance = (0, _ormlTokensPallet._getOrmlTokensPalletTransferable)(balanceInfo, (0, _utils2._getAssetExistentialDeposit)(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = (0, _ormlTokensPallet._getOrmlTokensPalletLockedBalance)(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
             state: _KoniTypes.APIItemState.READY,
-            free: freeBalance.toString(),
-            locked: lockedBalance.toString()
+            free: transferableBalance.toString(),
+            locked: totalLockedFromTransfer.toString()
           };
         });
         callback(items);
       });
-      return unsub;
     } catch (err) {
       console.warn(err);
       return undefined;
     }
   });
   return () => {
-    unsubList.forEach(subProm => {
-      subProm.then(unsub => {
-        unsub && unsub();
-      }).catch(console.error);
+    unsubList.forEach(unsub => {
+      unsub && unsub.unsubscribe();
     });
   };
 };

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

@@ -64,11 +64,12 @@ const createXcmExtrinsic = async _ref2 => {
   return extrinsic;
 };
 exports.createXcmExtrinsic = createXcmExtrinsic;
-const getXcmMockTxFee = async (substrateApi, chainInfoMap, address, originTokenInfo, destinationTokenInfo) => {
+const getXcmMockTxFee = async (substrateApi, chainInfoMap, originTokenInfo, destinationTokenInfo) => {
   try {
     var _paymentInfo$partialF;
     const destChainInfo = chainInfoMap[destinationTokenInfo.originChain];
     const originChainInfo = chainInfoMap[originTokenInfo.originChain];
+    const address = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap';
 
     // mock receiving account from sender
     const recipient = !(0, _utilCrypto.isEthereumAddress)(address) && (0, _utils._isChainEvmCompatible)(destChainInfo) && !(0, _utils._isChainEvmCompatible)(originChainInfo) ? (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(address)) : address;

package/cjs/services/balance-service/transfer/xcm/polkadotXcm.js

@@ -17,7 +17,7 @@ function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, destination
     version = 4;
     method = 'transferAssets';
   }
-  if ((0, _utils.isUseTeleportProtocol)(originChainInfo, destinationChainInfo)) {
+  if ((0, _utils.isUseTeleportProtocol)(originChainInfo, destinationChainInfo, tokenInfo.slug)) {
     method = 'limitedTeleportAssets';
   }
   const weightParam = (0, _xcmParser._getXcmDestWeight)(originChainInfo);

package/cjs/services/balance-service/transfer/xcm/utils.js

@@ -10,8 +10,9 @@ exports.isUseTeleportProtocol = isUseTeleportProtocol;
 
 const STABLE_XCM_VERSION = 3;
 exports.STABLE_XCM_VERSION = STABLE_XCM_VERSION;
-function isUseTeleportProtocol(originChainInfo, destChainInfo) {
+function isUseTeleportProtocol(originChainInfo, destChainInfo, tokenSlug) {
   const relayChainToSystemChain = ['polkadot'].includes(originChainInfo.slug) && ['statemint'].includes(destChainInfo.slug) || ['kusama'].includes(originChainInfo.slug) && ['statemine'].includes(destChainInfo.slug) || ['rococo'].includes(originChainInfo.slug) && ['rococo_assethub'].includes(destChainInfo.slug);
   const systemChainToRelayChain = ['polkadot'].includes(destChainInfo.slug) && ['statemint'].includes(originChainInfo.slug) || ['kusama'].includes(destChainInfo.slug) && ['statemine'].includes(originChainInfo.slug) || ['rococo'].includes(destChainInfo.slug) && ['rococo_assethub'].includes(originChainInfo.slug);
-  return relayChainToSystemChain || systemChainToRelayChain;
+  const isXcmMythos = originChainInfo.slug === 'mythos' && destChainInfo.slug === 'statemint' && tokenSlug === 'mythos-NATIVE-MYTH' || originChainInfo.slug === 'statemint' && destChainInfo.slug === 'mythos' && tokenSlug === 'statemint-LOCAL-MYTH';
+  return relayChainToSystemChain || systemChainToRelayChain || isXcmMythos;
 }

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

@@ -278,7 +278,7 @@ const _DEFAULT_MANTA_ZK_CHAIN = 'calamari';
 // XCM------------------------------------------------------------------------------------------------------------------
 exports._DEFAULT_MANTA_ZK_CHAIN = _DEFAULT_MANTA_ZK_CHAIN;
 const _XCM_CHAIN_GROUP = {
-  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint', 'equilibrium_parachain', 'rococo_assethub'],
+  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint', 'equilibrium_parachain', 'rococo_assethub', 'mythos'],
   xcmPallet: ['polkadot', 'kusama', 'rococo']
   // default is xTokens pallet
 };