@subwallet/extension-base 1.3.30-0 → 1.3.31-0

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

@@ -1,7 +1,215 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { fetchParaSpellChainMap } from '@subwallet/extension-base/constants/paraspell-chain-map';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { assert, compactToU8a, isHex, u8aConcat, u8aEq } from '@polkadot/util';
+const paraSpellEndpoint = 'https://api.lightspell.xyz';
+const paraSpellApi = {
+  buildXcm: `${paraSpellEndpoint}/x-transfer`,
+  dryRunXcm: `${paraSpellEndpoint}/dry-run`
+};
+const paraSpellKey = process.env.PARASPELL_API_KEY || '';
+function txHexToSubmittableExtrinsic(api, hex) {
+  try {
+    assert(isHex(hex), 'Expected a hex-encoded call');
+    let extrinsicCall;
+    let extrinsicPayload = null;
+    let decoded = null;
+    try {
+      // attempt to decode with api.tx
+      const tx = api.tx(hex);
+
+      // ensure that the full data matches here
+      assert(tx.toHex() === hex, 'Cannot decode data as extrinsic, length mismatch');
+      decoded = tx;
+      extrinsicCall = api.createType('Call', decoded.method);
+    } catch {
+      try {
+        // attempt to decode as Call
+        extrinsicCall = api.createType('Call', hex);
+        const callHex = extrinsicCall.toHex();
+        if (callHex === hex) {
+          // ok
+        } else if (hex.startsWith(callHex)) {
+          // this could be an un-prefixed payload...
+          const prefixed = u8aConcat(compactToU8a(extrinsicCall.encodedLength), hex);
+          extrinsicPayload = api.createType('ExtrinsicPayload', prefixed);
+          assert(u8aEq(extrinsicPayload.toU8a(), prefixed), 'Unable to decode data as un-prefixed ExtrinsicPayload');
+          extrinsicCall = api.createType('Call', extrinsicPayload.method.toHex());
+        } else {
+          console.error('Unable to decode data as Call, length mismatch in supplied data');
+        }
+      } catch {
+        // final attempt, we try this as-is as a (prefixed) payload
+        extrinsicPayload = api.createType('ExtrinsicPayload', hex);
+        assert(extrinsicPayload.toHex() === hex, 'Unable to decode input data as Call, Extrinsic or ExtrinsicPayload');
+        extrinsicCall = api.createType('Call', extrinsicPayload.method.toHex());
+      }
+    }
+    const {
+      method,
+      section
+    } = api.registry.findMetaCall(extrinsicCall.callIndex);
+    const extrinsicFn = api.tx[section][method];
+    if (!decoded) {
+      decoded = extrinsicFn(...extrinsicCall.args);
+    }
+    return decoded;
+  } catch (e) {
+    console.error('Failed to decode extrinsic hex', e);
+    throw new Error('Failed to decode extrinsic hex');
+  }
+}
+export async function buildXcm(request) {
+  var _originTokenInfo$meta, _originTokenInfo$meta2;
+  const {
+    destinationChain,
+    originChain,
+    originTokenInfo,
+    recipient,
+    sendingValue,
+    substrateApi
+  } = request;
+  if (!substrateApi) {
+    return Promise.reject(new Error('Substrate API is not available'));
+  }
+  const psAssetType = (_originTokenInfo$meta = originTokenInfo.metadata) === null || _originTokenInfo$meta === void 0 ? void 0 : _originTokenInfo$meta.paraSpellAssetType;
+  const psAssetValue = (_originTokenInfo$meta2 = originTokenInfo.metadata) === null || _originTokenInfo$meta2 === void 0 ? void 0 : _originTokenInfo$meta2.paraSpellValue;
+  if (!psAssetType || !psAssetValue) {
+    throw new Error('Token is not support XCM at this time');
+  }
+  const paraSpellChainMap = await fetchParaSpellChainMap();
+  const bodyData = {
+    address: recipient,
+    from: paraSpellChainMap[originChain.slug],
+    to: paraSpellChainMap[destinationChain.slug],
+    currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
+  };
+  const response = await fetch(paraSpellApi.buildXcm, {
+    method: 'POST',
+    body: JSON.stringify(bodyData),
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      'X-API-KEY': paraSpellKey
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.message);
+  }
+  const extrinsicHex = await response.text();
+  const chainApi = await substrateApi.isReady;
+  return txHexToSubmittableExtrinsic(chainApi.api, extrinsicHex);
+}
+
+// dry run can fail due to sender address & amount token
+export async function dryRunXcm(request) {
+  var _originTokenInfo$meta3, _originTokenInfo$meta4;
+  const {
+    destinationChain,
+    originChain,
+    originTokenInfo,
+    recipient,
+    sender,
+    sendingValue
+  } = request;
+  const paraSpellChainMap = await fetchParaSpellChainMap();
+  const psAssetType = (_originTokenInfo$meta3 = originTokenInfo.metadata) === null || _originTokenInfo$meta3 === void 0 ? void 0 : _originTokenInfo$meta3.paraSpellAssetType;
+  const psAssetValue = (_originTokenInfo$meta4 = originTokenInfo.metadata) === null || _originTokenInfo$meta4 === void 0 ? void 0 : _originTokenInfo$meta4.paraSpellValue;
+  if (!psAssetType || !psAssetValue) {
+    throw new Error('Token is not support XCM at this time'); // todo: content
+  }
+
+  let dryRunInfo;
+  try {
+    const bodyData = {
+      senderAddress: sender,
+      address: recipient,
+      from: paraSpellChainMap[originChain.slug],
+      to: paraSpellChainMap[destinationChain.slug],
+      currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
+    };
+    const response = await fetch(paraSpellApi.dryRunXcm, {
+      method: 'POST',
+      body: JSON.stringify(bodyData),
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'X-API-KEY': paraSpellKey
+      }
+    });
+    dryRunInfo = await response.json();
+  } catch (e) {
+    console.error('Unable to dry run', e);
+  }
+  if (!dryRunInfo || !dryRunInfo.success) {
+    throw new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again');
+  }
+  return dryRunInfo;
+}
+export async function dryRunXcmV2(request) {
+  var _originTokenInfo$meta5, _originTokenInfo$meta6;
+  const {
+    destinationChain,
+    originChain,
+    originTokenInfo,
+    recipient,
+    sender,
+    sendingValue
+  } = request;
+  const paraSpellChainMap = await fetchParaSpellChainMap();
+  const psAssetType = (_originTokenInfo$meta5 = originTokenInfo.metadata) === null || _originTokenInfo$meta5 === void 0 ? void 0 : _originTokenInfo$meta5.paraSpellAssetType;
+  const psAssetValue = (_originTokenInfo$meta6 = originTokenInfo.metadata) === null || _originTokenInfo$meta6 === void 0 ? void 0 : _originTokenInfo$meta6.paraSpellValue;
+  if (!psAssetType || !psAssetValue) {
+    throw new Error('Token is not support XCM at this time');
+  }
+  const bodyData = {
+    senderAddress: sender,
+    address: recipient,
+    from: paraSpellChainMap[originChain.slug],
+    to: paraSpellChainMap[destinationChain.slug],
+    currency: createParaSpellCurrency(psAssetType, psAssetValue, sendingValue)
+  };
+  const response = await fetch(paraSpellApi.dryRunXcm, {
+    method: 'POST',
+    body: JSON.stringify(bodyData),
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+      'X-API-KEY': paraSpellKey
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.message);
+  }
+  return await response.json();
+}
+function createParaSpellCurrency(assetType, assetValue, amount) {
+  // todo: handle complex conditions for asset has same symbol in a chain: Id, Multi-location, ...
+  return {
+    [assetType]: assetValue,
+    amount
+  };
+}
+export function isChainNotSupportPolkadotApi(str) {
+  const regex = /(?=.*not yet supported)(?=.*Polkadot API).*/i; // Example: The node Interlay is not yet supported by the Polkadot API.
+
+  return regex.test(str);
+}
+export function isChainNotSupportDryRun(str) {
+  const regex = /(?=.*DryRunApi)(?=.*not available).*/i; // Example: DryRunApi is not available on node Acala
+
+  return regex.test(str);
+}
+
+// todo: remove
 export const STABLE_XCM_VERSION = 3;
+
+// todo: remove
 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) || ['westend'].includes(originChainInfo.slug) && ['westend_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) || ['westend'].includes(destChainInfo.slug) && ['westend_assethub'].includes(originChainInfo.slug);

package/services/chain-service/constants.d.ts

@@ -83,7 +83,6 @@ export declare const _XCM_CHAIN_GROUP: {
     polkadotXcmSpecialCases: string[];
     xcmPallet: string[];
 };
-export declare const SUFFICIENT_CHAIN: string[];
 export declare const _XCM_TYPE: {
     RP: string;
     PP: string;

package/services/chain-service/constants.js

@@ -29,7 +29,7 @@ export const _BALANCE_CHAIN_GROUP = {
   kintsugi: ['kintsugi', 'interlay', 'kintsugi_test', 'mangatax_para'],
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
-  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'hydradx_rococo', 'pendulum', 'amplitude', 'continuum_network'],
+  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'hydradx_rococo', 'pendulum', 'amplitude', 'continuum_network', 'truth_network'],
   statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network', 'rococo_assethub', 'liberlandTest', 'liberland', 'dentnet', 'pangolin', 'crust', 'phala', 'shibuya', 'dbcchain', 'westend_assethub'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
@@ -278,7 +278,6 @@ export const _XCM_CHAIN_GROUP = {
   // default is xTokens pallet
 };
 
-export const SUFFICIENT_CHAIN = ['astar', 'calamari', 'parallel', 'darwinia2', 'crabParachain', 'pangolin', 'statemint', 'moonriver', 'shiden', 'moonbeam', 'statemine', 'liberland', 'dentnet', 'phala', 'crust', 'dbcchain', 'rococo_assethub'];
 export const _XCM_TYPE = {
   RP: `${_SubstrateChainType.RELAYCHAIN}-${_SubstrateChainType.PARACHAIN}`,
   // DMP

package/services/chain-service/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-import { AssetSetting, MetadataItem, TokenPriorityDetails, ValidateNetworkResponse } from '@subwallet/extension-base/background/KoniTypes';
+import { AssetSetting, MetadataItem, SufficientChainsDetails, TokenPriorityDetails, ValidateNetworkResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { MantaPrivateHandler } from '@subwallet/extension-base/services/chain-service/handler/manta/MantaPrivateHandler';
 import { _ChainApiStatus, _ChainConnectionStatus, _ChainState, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse } from '@subwallet/extension-base/services/chain-service/types';
 import { EventService } from '@subwallet/extension-base/services/event-service';
@@ -32,6 +32,7 @@ export declare class ChainService {
     private chainLogoMapSubject;
     private ledgerGenericAllowChainsSubject;
     private priorityTokensSubject;
+    private sufficientChainsSubject;
     private store;
     private assetSettingSubject;
     private logger;
@@ -39,10 +40,12 @@ export declare class ChainService {
     get value(): {
         readonly ledgerGenericAllowChains: string[];
         readonly priorityTokens: TokenPriorityDetails;
+        readonly sufficientChains: SufficientChainsDetails;
     };
     get observable(): {
         readonly ledgerGenericAllowChains: import("rxjs").Observable<string[]>;
         readonly priorityTokens: import("rxjs").Observable<TokenPriorityDetails>;
+        readonly sufficientChains: import("rxjs").Observable<SufficientChainsDetails>;
     };
     subscribeSwapRefMap(): Subject<Record<string, _AssetRef>>;
     get xcmRefMap(): Record<string, _AssetRef>;
@@ -111,8 +114,10 @@ export declare class ChainService {
     stopCheckLatestChainData(): void;
     handleLatestChainData(latestChainInfo: _ChainInfo[]): void;
     autoEnableTokens(): Promise<void>;
+    enablePopularTokens(): Promise<void>;
     handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains: string[]): void;
     handleLatestPriorityTokens(latestPriorityTokens: TokenPriorityDetails): void;
+    handleLatestSufficientChains(latestSufficientChains: SufficientChainsDetails): void;
     handleLatestData(): void;
     private initApis;
     initSingleApi(slug: string): Promise<boolean>;
@@ -127,6 +132,7 @@ export declare class ChainService {
     private fetchLatestPriceIdsData;
     private fetchLatestLedgerGenericAllowChains;
     private fetchLatestPriorityTokens;
+    private fetchLatestSufficientChains;
     private initChains;
     private initAssetRegistry;
     private updateChainStateMapSubscription;
@@ -148,13 +154,14 @@ export declare class ChainService {
     refreshEvmApi(slug: string): void;
     stopAllChainApis(): Promise<void>;
     resumeAllChainApis(): Promise<void>;
-    initAssetSettings(): Promise<void>;
+    initAssetSettings(): void;
     setAssetSettings(assetSettings: Record<string, AssetSetting>, emitEvent?: boolean): void;
     setMantaZkAssetSettings(visible: boolean): void;
     getStoreAssetSettings(): Promise<Record<string, AssetSetting>>;
     getAssetSettings(): Promise<Record<string, AssetSetting>>;
     updateAssetSetting(assetSlug: string, assetSetting: AssetSetting, autoEnableNativeToken?: boolean): Promise<boolean | undefined>;
     updateAssetSettingByChain(chainSlug: string, visible: boolean): Promise<void>;
+    updatePriorityAssetsByChain(chainSlug: string, visible: boolean): Promise<void>;
     subscribeAssetSettings(): BehaviorSubject<Record<string, AssetSetting>>;
     getAssetLogoMap(): Record<string, string>;
     subscribeAssetLogoMap(): BehaviorSubject<Record<string, string>>;

package/services/chain-service/index.js

@@ -11,7 +11,7 @@ import { SubstrateChainHandler } from '@subwallet/extension-base/services/chain-
 import { TonChainHandler } from '@subwallet/extension-base/services/chain-service/handler/TonChainHandler';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _ChainConnectionStatus, _CUSTOM_PREFIX, _NFT_CONTRACT_STANDARDS, _SMART_CONTRACT_STANDARDS } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetOriginChain, _getTokenOnChainAssetId, _isAssetAutoEnable, _isAssetCanPayTxFee, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isLocalToken, _isMantaZkAsset, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetOriginChain, _getTokenOnChainAssetId, _isAssetAutoEnable, _isAssetCanPayTxFee, _isAssetFungibleToken, _isChainEnabled, _isCustomAsset, _isCustomChain, _isCustomProvider, _isEqualContractAddress, _isEqualSmartContractAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isPureEvmChain, _isPureSubstrateChain, _parseAssetRefKey, randomizeProvider, updateLatestChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { MYTHOS_MIGRATION_KEY } from '@subwallet/extension-base/services/migration-service/scripts';
 import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
 import { addLazy, calculateMetadataHash, fetchStaticData, filterAssetsByChainAndType, getShortMetadata, MODULE_SUPPORT } from '@subwallet/extension-base/utils';
@@ -50,6 +50,7 @@ export class ChainService {
   chainLogoMapSubject = new BehaviorSubject(ChainLogoMap);
   ledgerGenericAllowChainsSubject = new BehaviorSubject([]);
   priorityTokensSubject = new BehaviorSubject({});
+  sufficientChainsSubject = new BehaviorSubject({});
 
   // Todo: Update to new store indexed DB
   store = new AssetSettingStore();
@@ -75,24 +76,32 @@ export class ChainService {
   get value() {
     const ledgerGenericAllowChains = this.ledgerGenericAllowChainsSubject;
     const priorityTokens = this.priorityTokensSubject;
+    const sufficientChains = this.sufficientChainsSubject;
     return {
       get ledgerGenericAllowChains() {
         return ledgerGenericAllowChains.value;
       },
       get priorityTokens() {
         return priorityTokens.value;
+      },
+      get sufficientChains() {
+        return sufficientChains.value;
       }
     };
   }
   get observable() {
     const ledgerGenericAllowChains = this.ledgerGenericAllowChainsSubject;
     const priorityTokens = this.priorityTokensSubject;
+    const sufficientChains = this.sufficientChainsSubject;
     return {
       get ledgerGenericAllowChains() {
         return ledgerGenericAllowChains.asObservable();
       },
       get priorityTokens() {
         return priorityTokens.asObservable();
+      },
+      get sufficientChains() {
+        return sufficientChains.asObservable();
       }
     };
   }
@@ -526,7 +535,7 @@ export class ChainService {
     this.initAssetRefMap();
     this.xcmRefMapSubject.next(this.xcmRefMap);
     await this.initApis();
-    await this.initAssetSettings();
+    this.initAssetSettings();
     await this.autoEnableTokens();
   }
   initAssetRefMap() {
@@ -605,14 +614,47 @@ export class ChainService {
       }
     }
   }
+  async enablePopularTokens() {
+    const assetSettings = this.assetSettingSubject.value;
+    const chainStateMap = this.getChainStateMap();
+    const priorityTokensMap = this.priorityTokensSubject.value || {};
+    const priorityTokensList = priorityTokensMap.token && typeof priorityTokensMap.token === 'object' ? Object.keys(priorityTokensMap.token) : [];
+    for (const assetSlug of priorityTokensList) {
+      const assetState = assetSettings[assetSlug];
+      const assetInfo = this.getAssetBySlug(assetSlug);
+      const chainState = chainStateMap[assetInfo.originChain];
+      if (!assetState) {
+        // If this asset not has asset setting, this token is not enabled before (not turned off before)
+        if (!chainState || !chainState.manualTurnOff) {
+          await this.updateAssetSetting(assetSlug, {
+            visible: true
+          }, true);
+        }
+      }
+    }
+  }
   handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains) {
     this.ledgerGenericAllowChainsSubject.next(latestledgerGenericAllowChains);
     this.eventService.emit('ledger.ready', true);
     this.logger.log('Finished updating latest ledger generic allow chains');
   }
   handleLatestPriorityTokens(latestPriorityTokens) {
+    const currentTokens = this.priorityTokensSubject.value || {};
     this.priorityTokensSubject.next(latestPriorityTokens);
     this.logger.log('Finished updating latest popular tokens');
+    const currentTokenKeys = Object.keys(currentTokens.token || {}); // Extract keys from current tokens
+    const newTokenKeys = Object.keys(latestPriorityTokens.token || {}); // Extract keys from new tokens
+
+    if (JSON.stringify(currentTokenKeys) !== JSON.stringify(newTokenKeys)) {
+      // Check if token keys have changed
+      this.enablePopularTokens().then(() => this.logger.log('Popular tokens enabled due to priority tokens change')) // Log success after enabling tokens
+      .catch(e => console.error('Error enabling popular tokens:', e)); // Log error if enabling fails
+    }
+  }
+
+  handleLatestSufficientChains(latestSufficientChains) {
+    this.sufficientChainsSubject.next(latestSufficientChains);
+    this.logger.log('Finished updating latest supported sufficient chains');
   }
   handleLatestData() {
     this.fetchLatestChainData().then(latestChainInfo => {
@@ -634,6 +676,9 @@ export class ChainService {
     this.fetchLatestPriorityTokens().then(latestPriorityTokens => {
       this.handleLatestPriorityTokens(latestPriorityTokens);
     }).catch(console.error);
+    this.fetchLatestSufficientChains().then(latestSufficientChains => {
+      this.handleLatestSufficientChains(latestSufficientChains);
+    }).catch(console.error);
   }
   async initApis() {
     const chainInfoMap = this.getChainInfoMap();
@@ -913,6 +958,9 @@ export class ChainService {
       token: {}
     };
   }
+  async fetchLatestSufficientChains() {
+    return (await fetchStaticData('chains/supported-sufficient-chains')) || [];
+  }
   async initChains() {
     const storedChainSettings = await this.dbService.getAllChainStore();
     const defaultChainInfoMap = filterChainInfoMap(ChainInfoMap, ignoredList);
@@ -1616,22 +1664,7 @@ export class ChainService {
     await Promise.all([this.substrateChainHandler.wakeUp(), this.evmChainHandler.wakeUp(), this.tonChainHandler.wakeUp(), this.cardanoChainHandler.wakeUp()]);
     this.checkLatestData();
   }
-  async initAssetSettings() {
-    const assetSettings = await this.getAssetSettings();
-    const activeChainSlugs = this.getActiveChainSlugs();
-    const assetRegistry = this.getAssetRegistry();
-    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, false);
+  initAssetSettings() {
     this.eventService.emit('asset.ready', true);
   }
   setAssetSettings(assetSettings, emitEvent = true) {
@@ -1719,6 +1752,27 @@ export class ChainService {
     });
     this.setAssetSettings(assetSettings);
   }
+  async updatePriorityAssetsByChain(chainSlug, visible) {
+    const currentAssetSettings = await this.getAssetSettings();
+    const assetsByChain = this.getFungibleTokensByChain(chainSlug);
+    const priorityTokensMap = this.priorityTokensSubject.value || {};
+    const priorityTokensList = priorityTokensMap.token && typeof priorityTokensMap.token === 'object' ? Object.keys(priorityTokensMap.token) : [];
+    for (const asset of Object.values(assetsByChain)) {
+      if (visible) {
+        const isPriorityToken = priorityTokensList.includes(asset.slug);
+        if (isPriorityToken || _isNativeToken(asset)) {
+          currentAssetSettings[asset.slug] = {
+            visible: true
+          };
+        }
+      } else {
+        currentAssetSettings[asset.slug] = {
+          visible: false
+        };
+      }
+    }
+    this.setAssetSettings(currentAssetSettings);
+  }
   subscribeAssetSettings() {
     return this.assetSettingSubject;
   }

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-const ChainListVersion = '0.2.102'; // update this when build chainlist
+const ChainListVersion = '0.2.103'; // update this when build chainlist
 
 // todo: move this interface to chainlist
 

package/services/earning-service/handlers/special.js

@@ -5,11 +5,12 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { ALL_ACCOUNT_KEY, XCM_FEE_RATIO, XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { YIELD_POOL_STAT_REFRESH_INTERVAL } from '@subwallet/extension-base/koni/api/yield/helper/utils';
-import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _getAssetDecimals, _getAssetExistentialDeposit, _getAssetName, _getAssetSymbol, _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, YieldStepType, YieldValidationStatus } from '@subwallet/extension-base/types';
 import { createPromiseHandler, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
+import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BN, BN_TEN, BN_ZERO, noop } from '@polkadot/util';
 import BasePoolHandler from "./base.js";
@@ -219,7 +220,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
           const xcmOriginSubstrateApi = await this.state.getSubstrateApi(altInputTokenInfo.originChain).isReady;
           const id = getId();
           const feeInfo = await this.state.feeService.subscribeChainFee(id, altChainInfo.slug, 'substrate');
-          const xcmTransfer = await createXcmExtrinsic({
+          const xcmRequest = {
             sender: address,
             originTokenInfo: altInputTokenInfo,
             destinationTokenInfo: inputTokenInfo,
@@ -229,16 +230,20 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
             originChain: altChainInfo,
             substrateApi: xcmOriginSubstrateApi,
             feeInfo
-          });
-          const _xcmFeeInfo = await xcmTransfer.paymentInfo(address);
-          const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
-          // TODO: calculate fee for destination chain
+          };
 
+          // TODO: calculate fee for destination chain
+          let xcmFee;
+          const xcmFeeByDryRun = await dryRunXcmExtrinsicV2(xcmRequest);
+          if (xcmFeeByDryRun.fee) {
+            xcmFee = BigN(xcmFeeByDryRun.fee).multipliedBy(XCM_MIN_AMOUNT_RATIO).toFixed(0, 1);
+          } else {
+            throw new Error('Error estimating XCM fee');
+          }
           const fee = {
             slug: altInputTokenSlug,
-            amount: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString() // TODO
+            amount: xcmFee
           };
-
           let bnTransferAmount = bnAmount.sub(bnInputTokenBalance);
           if (_isNativeToken(altInputTokenInfo)) {
             const bnXcmFee = new BN(fee.amount || 0); // xcm fee is paid in native token but swap token is not always native token
@@ -442,7 +447,7 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
     const bnTotalAmount = bnAmount.sub(bnInputTokenBalance).add(bnXcmFee);
     const id = getId();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, originChainInfo.slug, 'substrate');
-    const extrinsic = await createXcmExtrinsic({
+    const xcmRequest = {
       destinationTokenInfo,
       originTokenInfo,
       recipient: address,
@@ -452,7 +457,11 @@ export default class BaseSpecialStakingPoolHandler extends BasePoolHandler {
       originChain: originChainInfo,
       destinationChain: this.chainInfo,
       feeInfo
-    });
+    };
+    const extrinsic = await createXcmExtrinsicV2(xcmRequest);
+    if (!extrinsic) {
+      throw new Error('Error handling XCM extrinsic');
+    }
     const xcmData = {
       originNetworkKey: originChainInfo.slug,
       destinationNetworkKey: destinationTokenInfo.originChain,

package/services/keyring-service/context/handlers/Ledger.js

@@ -150,7 +150,7 @@ export class AccountLedgerHandler extends AccountBaseHandler {
     }
     if (Object.keys(slugMap).length) {
       for (const chainSlug of Object.keys(slugMap)) {
-        this.state.enableChain(chainSlug);
+        this.state.enableChainWithPriorityAssets(chainSlug);
       }
     }
     return true;

package/services/keyring-service/context/state.d.ts

@@ -88,6 +88,7 @@ export declare class AccountState {
     updateMetadataForProxy(): void;
     findNetworkKeyByGenesisHash(genesisHash?: string): string | undefined;
     enableChain(slug: string): void;
+    enableChainWithPriorityAssets(slug: string): void;
     resetWallet(): void;
 }
 export {};

package/services/keyring-service/context/state.js

@@ -619,6 +619,9 @@ export class AccountState {
   enableChain(slug) {
     this.koniState.enableChain(slug, true).catch(console.error);
   }
+  enableChainWithPriorityAssets(slug) {
+    this.koniState.enableChainWithPriorityAssets(slug, true).catch(console.error);
+  }
 
   /* Others */
 

package/services/migration-service/scripts/DisableZeroBalanceTokens.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class DisableZeroBalanceTokens extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/DisableZeroBalanceTokens.js

@@ -0,0 +1,51 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _isAssetAutoEnable } from '@subwallet/extension-base/services/chain-service/utils';
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import { fetchStaticData } from '@subwallet/extension-base/utils';
+// Usage:
+// 1. Disable tokens with a balance of 0
+// 2. Exclude tokens that belong to the popular list
+// 3. Exclude tokens with the "auto enable" attribute
+
+export default class DisableZeroBalanceTokens extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    try {
+      const rawBalanceMap = await state.dbService.getStoredBalance();
+      const tokensList = await state.chainService.getAssetSettings();
+      const filteredEnabledTokens = Object.entries(tokensList).reduce((acc, [key, value]) => {
+        if (value.visible) {
+          acc[key] = value;
+        }
+        return acc;
+      }, {});
+      const balanceNonZero = rawBalanceMap.filter(item => {
+        return BigInt(item.free) + BigInt(item.locked) > 0;
+      });
+      const priorityTokensMap = (await fetchStaticData('chain-assets/priority-tokens')) || {
+        tokenGroup: {},
+        token: {}
+      };
+      const priorityTokensList = priorityTokensMap.token && typeof priorityTokensMap.token === 'object' ? Object.keys(priorityTokensMap.token) : [];
+      const autoEnableTokenSlugs = Object.values(this.state.chainService.getAssetRegistry()).filter(asset => _isAssetAutoEnable(asset)).map(asset => asset.slug);
+      // Extract the slugs of tokens with balance > 0
+      const nonZeroBalanceSlugs = new Set(balanceNonZero.map(item => item.tokenSlug));
+      const updatedSettings = structuredClone(tokensList);
+      Object.keys(filteredEnabledTokens).forEach(slug => {
+        const hasBalance = nonZeroBalanceSlugs.has(slug);
+        const isPopularToken = priorityTokensList.includes(slug);
+        const isAutoEnableToken = autoEnableTokenSlugs.includes(slug);
+        if (!hasBalance && !isPopularToken && !isAutoEnableToken) {
+          updatedSettings[slug] = {
+            visible: false
+          };
+        }
+      });
+      state.chainService.setAssetSettings(updatedSettings);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+}

package/services/migration-service/scripts/EnableChain.js

@@ -5,6 +5,6 @@ import BaseMigrationJob from '@subwallet/extension-base/services/migration-servi
 export default class EnableChain extends BaseMigrationJob {
   async run() {
     const state = this.state;
-    await state.enableChain(this.slug, true);
+    await state.enableChainWithPriorityAssets(this.slug, true);
   }
 }