@subwallet/extension-base 1.2.23-0 → 1.2.24-1

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

@@ -4,17 +4,19 @@
 import { _AssetType } from '@subwallet/chain-list/types';
 import { APIItemState } from '@subwallet/extension-base/background/KoniTypes';
 import { SUB_TOKEN_REFRESH_BALANCE_INTERVAL } from '@subwallet/extension-base/constants';
+import { _getAssetsPalletLockedBalance, _getAssetsPalletTransferable } from '@subwallet/extension-base/core/substrate/assets-pallet';
 import { _getForeignAssetPalletLockedBalance, _getForeignAssetPalletTransferable } from '@subwallet/extension-base/core/substrate/foreign-asset-pallet';
 import { _getTotalStakeInNominationPool } from '@subwallet/extension-base/core/substrate/nominationpools-pallet';
+import { _getOrmlTokensPalletLockedBalance, _getOrmlTokensPalletTransferable } from '@subwallet/extension-base/core/substrate/ormlTokens-pallet';
 import { _getSystemPalletTotalBalance, _getSystemPalletTransferable } from '@subwallet/extension-base/core/substrate/system-pallet';
+import { _getTokensPalletLocked, _getTokensPalletTransferable } from '@subwallet/extension-base/core/substrate/tokens-pallet';
+import { _adaptX1Interior } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { getPSP22ContractPromise } from '@subwallet/extension-base/koni/api/contract-handler/wasm';
 import { getDefaultWeightV2 } from '@subwallet/extension-base/koni/api/contract-handler/wasm/utils';
 import { _BALANCE_CHAIN_GROUP, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
-import { _checkSmartContractSupportByChain, _getChainExistentialDeposit, _getChainNativeTokenSlug, _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getTokenTypesSupportedByChain, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _checkSmartContractSupportByChain, _getAssetExistentialDeposit, _getChainExistentialDeposit, _getChainNativeTokenSlug, _getContractAddressOfToken, _getTokenOnChainAssetId, _getTokenOnChainInfo, _getTokenTypesSupportedByChain, _getXcmAssetMultilocation, _isBridgedToken, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { filterAssetsByChainAndType } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
-import { combineLatest, Observable } from 'rxjs';
-import { BN, BN_ZERO } from '@polkadot/util';
 import { subscribeERC20Interval } from "../evm.js";
 import { subscribeEquilibriumTokenBalance } from "./equilibrium.js";
 import { subscribeGRC20Balance, subscribeVftBalance } from "./gear.js";
@@ -36,7 +38,7 @@ export const subscribeSubstrateBalance = async (addresses, chainInfo, assetMap,
   };
   const substrateParams = {
     ...baseParams,
-    substrateApi: substrateApi.api
+    substrateApi
   };
   if (!_BALANCE_CHAIN_GROUP.kintsugi.includes(chain) && !_BALANCE_CHAIN_GROUP.genshiro.includes(chain) && !_BALANCE_CHAIN_GROUP.equilibrium_parachain.includes(chain)) {
     unsubNativeToken = await subscribeWithSystemAccountPallet(substrateParams);
@@ -110,42 +112,34 @@ const subscribeWithSystemAccountPallet = async ({
   extrinsicType,
   substrateApi
 }) => {
-  const chainNativeTokenSlug = _getChainNativeTokenSlug(chainInfo);
-  const balanceSubscribe = substrateApi.rx.query.system.account.multi(addresses);
-  let poolSubscribe; // add points in nomination pool back to user's balance
-
-  if (_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 Observable(subscriber => {
-      subscriber.next(addresses.map(() => ({
-        toPrimitive() {
-          return null;
-        }
-      })));
-    });
-  }
-  const subscription = combineLatest({
-    balances: balanceSubscribe,
-    poolMemberInfos: poolSubscribe
-  }).subscribe(({
-    balances,
-    poolMemberInfos
-  }) => {
+  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 ? _getTotalStakeInNominationPool(poolMemberInfo) : new BigN(0);
+      const balanceInfo = _balance;
+      const poolMemberInfo = poolMemberInfos[index];
+      const nominationPoolBalance = poolMemberInfo ? _getTotalStakeInNominationPool(poolMemberInfo) : BigInt(0);
       const transferableBalance = _getSystemPalletTransferable(balanceInfo, _getChainExistentialDeposit(chainInfo), extrinsicType);
       const totalBalance = _getSystemPalletTotalBalance(balanceInfo);
-      const totalLockedFromTransfer = new BigN(totalBalance).minus(transferableBalance).plus(nominationPoolBalance);
+      const totalLockedFromTransfer = totalBalance - transferableBalance + nominationPoolBalance;
       return {
         address: addresses[index],
-        tokenSlug: chainNativeTokenSlug,
-        free: transferableBalance,
-        locked: totalLockedFromTransfer.toFixed(),
+        tokenSlug: _getChainNativeTokenSlug(chainInfo),
+        free: transferableBalance.toString(),
+        locked: totalLockedFromTransfer.toString(),
         state: APIItemState.READY,
         metadata: balanceInfo
       };
@@ -161,25 +155,31 @@ const subscribeForeignAssetBalance = async ({
   assetMap,
   callback,
   chainInfo,
+  extrinsicType,
   substrateApi
 }) => {
-  const chain = chainInfo.slug;
-  const tokenMap = filterAssetsByChainAndType(assetMap, chain, [_AssetType.LOCAL]);
-
-  // @ts-ignore
-  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+  const foreignAssetsAccountKey = 'query_foreignAssets_account';
+  const tokenMap = filterAssetsByChainAndType(assetMap, chainInfo.slug, [_AssetType.LOCAL]);
+  const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
-      const isBridgedToken = _isBridgedToken(tokenInfo);
-      if (isBridgedToken) {
-        const assetLocation = _getTokenOnChainInfo(tokenInfo) || _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 (_isBridgedToken(tokenInfo)) {
+        const params = [{
+          section: 'query',
+          module: foreignAssetsAccountKey.split('_')[1],
+          method: foreignAssetsAccountKey.split('_')[2],
+          args: addresses.map(address => [_getTokenOnChainInfo(tokenInfo) || _adaptX1Interior(_getXcmAssetMultilocation(tokenInfo), 3), address])
+        }];
+        return substrateApi.subscribeDataWithMulti(params, rs => {
+          const balances = rs[foreignAssetsAccountKey];
+          const items = balances.map((_balance, index) => {
+            const balanceInfo = _balance;
+            const transferableBalance = _getForeignAssetPalletTransferable(balanceInfo, _getAssetExistentialDeposit(tokenInfo), extrinsicType);
+            const totalLockedFromTransfer = _getForeignAssetPalletLockedBalance(balanceInfo);
             return {
               address: addresses[index],
               tokenSlug: tokenInfo.slug,
-              free: accountInfo ? _getForeignAssetPalletTransferable(accountInfo).toString() : '0',
-              locked: accountInfo ? _getForeignAssetPalletLockedBalance(accountInfo).toString() : '0',
+              free: transferableBalance.toString(),
+              locked: totalLockedFromTransfer.toString(),
               state: APIItemState.READY
             };
           });
@@ -193,7 +193,7 @@ const subscribeForeignAssetBalance = async ({
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
@@ -217,7 +217,7 @@ const subscribePSP22Balance = ({
   const psp22ContractMap = {};
   const tokenList = filterAssetsByChainAndType(assetMap, chain, [_AssetType.PSP22]);
   Object.entries(tokenList).forEach(([slug, tokenInfo]) => {
-    psp22ContractMap[slug] = getPSP22ContractPromise(substrateApi, _getContractAddressOfToken(tokenInfo));
+    psp22ContractMap[slug] = getPSP22ContractPromise(substrateApi.api, _getContractAddressOfToken(tokenInfo));
   });
   const getTokenBalances = () => {
     Object.values(tokenList).map(async tokenInfo => {
@@ -227,7 +227,7 @@ const subscribePSP22Balance = ({
           try {
             var _balanceOf$output;
             const _balanceOf = await contract.query['psp22::balanceOf'](address, {
-              gasLimit: getDefaultWeightV2(substrateApi)
+              gasLimit: 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);
@@ -268,35 +268,33 @@ const subscribeTokensAccountsPallet = async ({
   assetMap,
   callback,
   chainInfo,
+  extrinsicType,
   includeNativeToken,
   substrateApi
 }) => {
-  const chain = chainInfo.slug;
+  const tokensAccountsKey = 'query_tokens_accounts';
   const tokenTypes = includeNativeToken ? [_AssetType.NATIVE, _AssetType.LOCAL] : [_AssetType.LOCAL];
-  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
-  const unsubList = await Promise.all(Object.values(tokenMap).map(async tokenInfo => {
+  const tokenMap = filterAssetsByChainAndType(assetMap, chainInfo.slug, tokenTypes);
+  const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
-      const onChainInfo = _getTokenOnChainInfo(tokenInfo);
-      const assetId = _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 BN(0),
-            frozen: balance.frozen || new BN(0),
-            free: balance.free || new 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, _getTokenOnChainInfo(tokenInfo) || _getTokenOnChainAssetId(tokenInfo)])
+      }];
+      return substrateApi.subscribeDataWithMulti(params, rs => {
+        const balances = rs[tokensAccountsKey];
+        const items = balances.map((_balance, index) => {
+          const balanceInfo = _balance;
+          const transferableBalance = _getTokensPalletTransferable(balanceInfo, _getAssetExistentialDeposit(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = _getTokensPalletLocked(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
             state: APIItemState.READY,
-            free: freeBalance.toString(),
-            locked: lockedBalance.toString()
+            free: transferableBalance.toString(),
+            locked: totalLockedFromTransfer.toString()
           };
         });
         callback(items);
@@ -308,7 +306,7 @@ const subscribeTokensAccountsPallet = async ({
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
@@ -317,46 +315,41 @@ const subscribeAssetsAccountPallet = async ({
   assetMap,
   callback,
   chainInfo,
-  includeNativeToken,
+  extrinsicType,
   substrateApi
 }) => {
-  const chain = chainInfo.slug;
-  const tokenMap = filterAssetsByChainAndType(assetMap, chain, [_AssetType.LOCAL]);
+  const assetsAccountKey = 'query_assets_account';
+  const tokenMap = filterAssetsByChainAndType(assetMap, chainInfo.slug, [_AssetType.LOCAL]);
   Object.values(tokenMap).forEach(token => {
     if (_MANTA_ZK_CHAIN_GROUP.includes(token.originChain) && token.symbol.startsWith(_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 = _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 = BN_ZERO;
-          let total = BN_ZERO;
-          if (bdata) {
-            // @ts-ignore
-            const addressBalance = new 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 = _getAssetsPalletTransferable(balanceInfo, _getAssetExistentialDeposit(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = _getAssetsPalletLockedBalance(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
-            free: free.toString(),
-            locked: frozen.toString(),
+            free: transferableBalance.toString(),
+            locked: totalLockedFromTransfer.toString(),
             state: APIItemState.READY
           };
         });
@@ -369,7 +362,7 @@ const subscribeAssetsAccountPallet = async ({
   }));
   return () => {
     unsubList.forEach(unsub => {
-      unsub && unsub();
+      unsub && unsub.unsubscribe();
     });
   };
 };
@@ -380,50 +373,45 @@ const subscribeOrmlTokensPallet = async ({
   assetMap,
   callback,
   chainInfo,
+  extrinsicType,
   substrateApi
 }) => {
-  const chain = chainInfo.slug;
-  const tokenTypes = [_AssetType.LOCAL];
-  const tokenMap = filterAssetsByChainAndType(assetMap, chain, tokenTypes);
-  const unsubList = Object.values(tokenMap).map(async tokenInfo => {
+  const ormlTokensAccountsKey = 'query_ormlTokens_accounts';
+  const tokenMap = filterAssetsByChainAndType(assetMap, chainInfo.slug, [_AssetType.LOCAL]);
+  const unsubList = Object.values(tokenMap).map(tokenInfo => {
     try {
-      const onChainInfo = _getTokenOnChainInfo(tokenInfo);
+      const params = [{
+        section: 'query',
+        module: ormlTokensAccountsKey.split('_')[1],
+        method: ormlTokensAccountsKey.split('_')[2],
+        args: addresses.map(address => [address, _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 BN(0),
-            frozen: balance.frozen || new BN(0),
-            free: balance.free || new 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 = _getOrmlTokensPalletTransferable(balanceInfo, _getAssetExistentialDeposit(tokenInfo), extrinsicType);
+          const totalLockedFromTransfer = _getOrmlTokensPalletLockedBalance(balanceInfo);
           return {
             address: addresses[index],
             tokenSlug: tokenInfo.slug,
             state: 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/services/balance-service/transfer/xcm/index.d.ts

@@ -17,5 +17,5 @@ declare type CreateSnowBridgeExtrinsicProps = Omit<CreateXcmExtrinsicProps, 'sub
 };
 export declare const createSnowBridgeExtrinsic: ({ chainInfoMap, destinationTokenInfo, evmApi, originTokenInfo, recipient, sender, sendingValue }: CreateSnowBridgeExtrinsicProps) => Promise<TransactionConfig>;
 export declare const createXcmExtrinsic: ({ chainInfoMap, destinationTokenInfo, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
-export declare const getXcmMockTxFee: (substrateApi: _SubstrateApi, chainInfoMap: Record<string, _ChainInfo>, address: string, originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset) => Promise<BigN>;
+export declare const getXcmMockTxFee: (substrateApi: _SubstrateApi, chainInfoMap: Record<string, _ChainInfo>, originTokenInfo: _ChainAsset, destinationTokenInfo: _ChainAsset) => Promise<BigN>;
 export {};

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

@@ -53,11 +53,12 @@ export const createXcmExtrinsic = async ({
   }
   return extrinsic;
 };
-export const getXcmMockTxFee = async (substrateApi, chainInfoMap, address, originTokenInfo, destinationTokenInfo) => {
+export 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 = !isEthereumAddress(address) && _isChainEvmCompatible(destChainInfo) && !_isChainEvmCompatible(originChainInfo) ? u8aToHex(addressToEvm(address)) : address;

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

@@ -11,7 +11,7 @@ export function getExtrinsicByPolkadotXcmPallet(tokenInfo, originChainInfo, dest
     version = 4;
     method = 'transferAssets';
   }
-  if (isUseTeleportProtocol(originChainInfo, destinationChainInfo)) {
+  if (isUseTeleportProtocol(originChainInfo, destinationChainInfo, tokenInfo.slug)) {
     method = 'limitedTeleportAssets';
   }
   const weightParam = _getXcmDestWeight(originChainInfo);

package/services/balance-service/transfer/xcm/utils.d.ts

@@ -1,3 +1,3 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 export declare const STABLE_XCM_VERSION = 3;
-export declare function isUseTeleportProtocol(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
+export declare function isUseTeleportProtocol(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo, tokenSlug?: string): boolean;

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

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export const STABLE_XCM_VERSION = 3;
-export function isUseTeleportProtocol(originChainInfo, destChainInfo) {
+export 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/services/chain-service/constants.js

@@ -256,7 +256,7 @@ export const _DEFAULT_MANTA_ZK_CHAIN = 'calamari';
 // XCM------------------------------------------------------------------------------------------------------------------
 
 export 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
 };

package/services/chain-service/handler/SubstrateApi.d.ts

@@ -1,12 +1,11 @@
 import '@polkadot/types-augment';
 import { MetadataItem } from '@subwallet/extension-base/background/KoniTypes';
 import { _ApiOptions } from '@subwallet/extension-base/services/chain-service/handler/types';
-import { _ChainConnectionStatus, _SubstrateApi, _SubstrateDefaultFormatBalance } from '@subwallet/extension-base/services/chain-service/types';
-import { BehaviorSubject } from 'rxjs';
+import { _ChainConnectionStatus, _SubstrateAdapterQueryArgs, _SubstrateAdapterSubscriptionArgs, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BehaviorSubject, Subscription } from 'rxjs';
 import { ApiPromise } from '@polkadot/api';
-import { SubmittableExtrinsicFunction } from '@polkadot/api/promise/types';
 import { ProviderInterface } from '@polkadot/rpc-provider/types';
-import { Registry } from '@polkadot/types/types';
+import { AnyJson, Registry } from '@polkadot/types/types';
 export declare class SubstrateApi implements _SubstrateApi {
     chainSlug: string;
     api: ApiPromise;
@@ -25,9 +24,6 @@ export declare class SubstrateApi implements _SubstrateApi {
     substrateRetry: number;
     get connectionStatus(): _ChainConnectionStatus;
     private updateConnectionStatus;
-    apiDefaultTx?: SubmittableExtrinsicFunction;
-    apiDefaultTxSudo?: SubmittableExtrinsicFunction;
-    defaultFormatBalance?: _SubstrateDefaultFormatBalance;
     registry: Registry;
     specName: string;
     specVersion: string;
@@ -48,4 +44,6 @@ export declare class SubstrateApi implements _SubstrateApi {
     onDisconnect(): void;
     onError(e: Error): void;
     fillApiInfo(): Promise<void>;
+    makeRpcQuery<T>({ args, method, module, section }: _SubstrateAdapterQueryArgs): Promise<T>;
+    subscribeDataWithMulti(params: _SubstrateAdapterSubscriptionArgs[], callback: (rs: Record<string, AnyJson[]>) => void): Subscription;
 }