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

package/cjs/utils/fee/transfer.js

@@ -13,6 +13,7 @@ var _smartContract = require("@subwallet/extension-base/services/balance-service
 var _token = require("@subwallet/extension-base/services/balance-service/transfer/token");
 var _tonTransfer = require("@subwallet/extension-base/services/balance-service/transfer/ton-transfer");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _acrossBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge");
 var _availBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge");
 var _polygonBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge");
 var _posBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge");
@@ -36,7 +37,8 @@ const detectTransferTxType = (srcToken, srcChain, destChain) => {
     const isSnowBridgeEvmTransfer = (0, _utils._isPureEvmChain)(srcChain) && (0, _xcmParser._isSnowBridgeXcm)(srcChain, destChain) && !isAvailBridgeFromEvm;
     const isPolygonBridgeTransfer = (0, _polygonBridge._isPolygonChainBridge)(srcChain.slug, destChain.slug);
     const isPosBridgeTransfer = (0, _posBridge._isPosChainBridge)(srcChain.slug, destChain.slug);
-    return isAvailBridgeFromEvm || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer ? 'evm' : 'substrate';
+    const isAcrossBridgeTransfer = (0, _acrossBridge._isAcrossChainBridge)(srcChain.slug, destChain.slug);
+    return isAvailBridgeFromEvm || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer || isAcrossBridgeTransfer ? 'evm' : 'substrate';
   } else {
     if ((0, _utils._isChainEvmCompatible)(srcChain) && (0, _utils._isTokenTransferredByEvm)(srcToken)) {
       return 'evm';
@@ -86,7 +88,8 @@ const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) =
     srcChain,
     srcToken,
     substrateApi,
-    tonApi
+    tonApi,
+    value
   } = request;
   const feeChainType = fee.type;
   let estimatedFee;
@@ -114,7 +117,7 @@ const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) =
           from: address,
           to: recipient,
           transferAll: false,
-          value: '0',
+          value,
           fallbackFee: true
         });
       } else {
@@ -127,7 +130,7 @@ const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) =
           from: address,
           to: recipient,
           transferAll: false,
-          value: '0',
+          value,
           fallbackFee: true
         });
       }
@@ -137,19 +140,18 @@ const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) =
         from: address,
         to: address,
         networkKey: srcChain.slug,
-        value: '0',
+        value,
         transferAll: false,
         // currently not used
         tonApi
       });
     } else if ((0, _keyring.isCardanoAddress)(address) && (0, _utils._isTokenTransferredByCardano)(srcToken)) {
-      const isTransferNativeToken = (0, _utils._isNativeToken)(srcToken);
       [transaction] = await (0, _cardanoTransfer.createCardanoTransaction)({
         tokenInfo: srcToken,
         from: address,
         to: address,
         networkKey: srcChain.slug,
-        value: isTransferNativeToken ? '1000000' : '1',
+        value,
         cardanoTtlOffset: _consts.DEFAULT_CARDANO_TTL_OFFSET,
         transferAll: false,
         cardanoApi,
@@ -158,7 +160,7 @@ const calculateTransferMaxTransferable = async (id, request, freeBalance, fee) =
     } else {
       [transaction] = await (0, _token.createSubstrateExtrinsic)({
         transferAll: false,
-        value: '0',
+        value,
         from: address,
         networkKey: srcChain.slug,
         tokenInfo: srcToken,
@@ -295,10 +297,11 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
     nativeToken,
     srcChain,
     srcToken,
-    substrateApi
+    substrateApi,
+    value
   } = request;
   const feeChainType = fee.type;
-  let estimatedFee;
+  let estimatedFee = '0';
   let feeOptions;
   let maxTransferable;
   let error;
@@ -307,20 +310,22 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
   const isSnowBridgeEvmTransfer = (0, _utils._isPureEvmChain)(srcChain) && (0, _xcmParser._isSnowBridgeXcm)(srcChain, destChain) && !isAvailBridgeFromEvm;
   const isPolygonBridgeTransfer = (0, _polygonBridge._isPolygonChainBridge)(srcChain.slug, destChain.slug);
   const isPosBridgeTransfer = (0, _posBridge._isPosChainBridge)(srcChain.slug, destChain.slug);
+  const isAcrossBridgeTransfer = (0, _acrossBridge._isAcrossChainBridge)(srcChain.slug, destChain.slug);
+  const isSubstrateXcm = !(isAvailBridgeFromEvm || isAvailBridgeFromAvail || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer || isAcrossBridgeTransfer);
   const fakeAddress = '5DRewsYzhJqZXU3SRaWy1FSt5iDr875ao91aw5fjrJmDG4Ap'; // todo: move this
   const substrateAddress = fakeAddress; // todo: move this
   const evmAddress = (0, _util.u8aToHex)((0, _utilCrypto.addressToEvm)(fakeAddress)); // todo: move this
-
+  const bnFreeBalance = new _bignumber.default(freeBalance.value);
   const recipient = (0, _utils._isChainEvmCompatible)(destChain) ? evmAddress : substrateAddress;
+  if (!destToken) {
+    throw Error('Destination token is not available');
+  }
   try {
-    if (!destToken) {
-      throw Error('Destination token is not available');
-    }
     const params = {
       destinationTokenInfo: destToken,
       originTokenInfo: srcToken,
       // If value is 0, substrate will throw error when estimating fee
-      sendingValue: feeChainType === 'substrate' ? '1000000000000000000' : '0',
+      sendingValue: value,
       sender: address,
       recipient,
       destinationChain: destChain,
@@ -334,6 +339,13 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
     let funcCreateExtrinsic;
     if (isPosBridgeTransfer || isPolygonBridgeTransfer) {
       funcCreateExtrinsic = _xcm.createPolygonBridgeExtrinsic;
+    } else if (isAcrossBridgeTransfer) {
+      funcCreateExtrinsic = _xcm.createAcrossBridgeExtrinsic;
+      if ((0, _acrossBridge._isAcrossTestnetBridge)(srcChain.slug)) {
+        params.sendingValue = (0, _bignumber.default)(0.0037).shiftedBy((0, _utils._getAssetDecimals)(srcToken)).toFixed(0, 1);
+      } else {
+        params.sendingValue = (0, _bignumber.default)(1).shiftedBy((0, _utils._getAssetDecimals)(srcToken)).toFixed(0, 1);
+      }
     } else if (isSnowBridgeEvmTransfer) {
       funcCreateExtrinsic = _xcm.createSnowBridgeExtrinsic;
     } else if (isAvailBridgeFromEvm) {
@@ -341,9 +353,12 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
     } else if (isAvailBridgeFromAvail) {
       funcCreateExtrinsic = _xcm.createAvailBridgeExtrinsicFromAvail;
     } else {
-      funcCreateExtrinsic = _xcm.createXcmExtrinsic;
+      funcCreateExtrinsic = _xcm.createXcmExtrinsicV2;
+      params.sendingValue = '1';
     }
     const extrinsic = await funcCreateExtrinsic(params);
+
+    // todo: refactor condition
     if (feeChainType === 'evm') {
       var _tx$gas2;
       // Calculate fee for evm transaction
@@ -363,12 +378,17 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
       };
     } else if (feeChainType === 'substrate') {
       // Calculate fee for substrate transaction
-      try {
-        var _paymentInfo$partialF2;
-        const paymentInfo = await extrinsic.paymentInfo(address);
-        estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF2 = paymentInfo.partialFee) === null || _paymentInfo$partialF2 === void 0 ? void 0 : _paymentInfo$partialF2.toString()) || '0';
-      } catch (e) {
-        estimatedFee = '0';
+      if (isSubstrateXcm) {
+        const estimatedFeeByDryRun = await (0, _xcm.dryRunXcmExtrinsicV2)(params);
+        estimatedFee = estimatedFeeByDryRun.fee || '0';
+      } else {
+        try {
+          var _paymentInfo$partialF2;
+          const paymentInfo = await extrinsic.paymentInfo(address);
+          estimatedFee = (paymentInfo === null || paymentInfo === void 0 ? void 0 : (_paymentInfo$partialF2 = paymentInfo.partialFee) === null || _paymentInfo$partialF2 === void 0 ? void 0 : _paymentInfo$partialF2.toString()) || '0';
+        } catch (e) {
+          estimatedFee = '0';
+        }
       }
       const _feeCustom = feeCustom;
       const tip = (0, _combine.combineSubstrateFee)(fee, feeOption, _feeCustom).tip;
@@ -408,12 +428,12 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
     if (_constants._SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(srcChain.slug)) {
       const estimatedFeeNative = (BigInt(estimatedFee) * BigInt(_utils2.FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE) / BigInt(100)).toString();
       const estimatedFeeLocal = await (0, _utils2.calculateToAmountByReservePool)(substrateApi.api, nativeToken, srcToken, estimatedFeeNative);
-      maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(estimatedFeeLocal);
+      maxTransferable = bnFreeBalance.minus(estimatedFeeLocal);
     } else if (_constants._SUPPORT_TOKEN_PAY_FEE_GROUP.hydration.includes(srcChain.slug)) {
       const rate = await (0, _tokenPayFee.getHydrationRate)(address, nativeToken, srcToken);
       if (rate) {
         const estimatedFeeLocal = new _bignumber.default(estimatedFee).multipliedBy(rate).integerValue(_bignumber.default.ROUND_UP).toString();
-        maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(estimatedFeeLocal);
+        maxTransferable = bnFreeBalance.minus(estimatedFeeLocal);
       } else {
         throw new Error(`Unable to estimate fee for ${srcChain.slug}.`);
       }
@@ -421,16 +441,20 @@ const calculateXcmMaxTransferable = async (id, request, freeBalance, fee) => {
       throw new Error(`Unable to estimate fee for ${srcChain.slug}.`);
     }
   } else if (isTransferNativeTokenAndPayLocalTokenAsFee) {
-    maxTransferable = (0, _bignumber.default)(freeBalance.value);
+    maxTransferable = bnFreeBalance;
   } else {
     if (!(0, _utils._isNativeToken)(srcToken)) {
-      maxTransferable = (0, _bignumber.default)(freeBalance.value);
+      maxTransferable = bnFreeBalance;
     } else {
-      maxTransferable = (0, _bignumber.default)(freeBalance.value).minus(new _bignumber.default(estimatedFee).multipliedBy(_constants.XCM_FEE_RATIO));
+      maxTransferable = bnFreeBalance.minus((0, _bignumber.default)(estimatedFee).multipliedBy(_constants.XCM_FEE_RATIO));
     }
   }
+  if (isAvailBridgeFromAvail) {
+    const addedAmount = (0, _bignumber.default)(1).shiftedBy((0, _utils._getAssetDecimals)(srcToken));
+    maxTransferable = maxTransferable.minus(addedAmount);
+  }
   return {
-    maxTransferable: maxTransferable.gt(_utils3.BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+    maxTransferable: maxTransferable.gt(_utils3.BN_ZERO) ? maxTransferable.toFixed(0) : '0',
     feeOptions: feeOptions,
     feeType: feeChainType,
     id: id,

package/cjs/utils/staticData/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.termAndCondition = exports.staticData = exports.remindNotificationTime = exports.oldChainPrefix = exports.marketingCampaigns = exports.currencySymbol = exports.crowdloanFunds = exports.buyTokenConfigs = exports.buyServiceInfos = exports.blockedActionsFeatures = exports.blockedActions = exports.StaticKey = void 0;
+exports.termAndCondition = exports.staticData = exports.remindNotificationTime = exports.paraSpellChainMap = exports.oldChainPrefix = exports.marketingCampaigns = exports.currencySymbol = exports.crowdloanFunds = exports.buyTokenConfigs = exports.buyServiceInfos = exports.blockedActionsFeatures = exports.blockedActions = exports.StaticKey = void 0;
 var _chainList = require("@subwallet/chain-list");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -39,7 +39,10 @@ const blockedActions = require('./blockedActions.json');
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
 exports.blockedActions = blockedActions;
 const oldChainPrefix = require('./oldChainPrefix.json');
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
 exports.oldChainPrefix = oldChainPrefix;
+const paraSpellChainMap = require('./paraSpellChainMap.json');
+exports.paraSpellChainMap = paraSpellChainMap;
 let StaticKey;
 exports.StaticKey = StaticKey;
 (function (StaticKey) {
@@ -54,6 +57,7 @@ exports.StaticKey = StaticKey;
   StaticKey["REMIND_NOTIFICATION_TIME"] = "remind-notification-time";
   StaticKey["BLOCKED_ACTIONS"] = "blocked-actions";
   StaticKey["OLD_CHAIN_PREFIX"] = "old-chain-prefix";
+  StaticKey["PARASPELL_CHAIN_MAP"] = "paraspell-chain-map";
 })(StaticKey || (exports.StaticKey = StaticKey = {}));
 const staticData = {
   [StaticKey.CHAINS]: Object.values(_chainList.ChainInfoMap),
@@ -66,6 +70,7 @@ const staticData = {
   [StaticKey.BLOCKED_ACTIONS_FEATURES]: blockedActionsFeatures,
   [StaticKey.REMIND_NOTIFICATION_TIME]: remindNotificationTime,
   [StaticKey.BLOCKED_ACTIONS]: blockedActions,
-  [StaticKey.OLD_CHAIN_PREFIX]: oldChainPrefix
+  [StaticKey.OLD_CHAIN_PREFIX]: oldChainPrefix,
+  [StaticKey.PARASPELL_CHAIN_MAP]: paraSpellChainMap
 };
 exports.staticData = staticData;

package/constants/paraspell-chain-map.d.ts

@@ -0,0 +1 @@
+export declare function fetchParaSpellChainMap(): Promise<Record<string, string>>;

package/constants/paraspell-chain-map.js

@@ -0,0 +1,7 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { fetchStaticData } from '@subwallet/extension-base/utils';
+export async function fetchParaSpellChainMap() {
+  return await fetchStaticData('paraspell-chain-map');
+}

package/core/logic-validation/transfer.d.ts

@@ -17,3 +17,4 @@ export declare function estimateFeeForTransaction(validationResponse: SWTransact
 export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse, chainInfoMap: Record<string, _ChainInfo>): void;
 export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;
 export declare function checkTonAddressBounceableAndAccountNotActive(tonApi: _TonApi, validationResponse: SWTransactionResponse): Promise<void>;
+export declare function validateXcmMinAmountToMythos(destChain: string, destToken: string, amount: string): TransactionError | undefined;

package/core/logic-validation/transfer.js

@@ -315,7 +315,8 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
   if (transaction) {
     try {
       if (isSubstrateTransaction(transaction)) {
-        estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+        var _validationResponse$x;
+        estimateFee.value = (_validationResponse$x = validationResponse.xcmFeeDryRun) !== null && _validationResponse$x !== void 0 ? _validationResponse$x : (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
       } else if (isTonTransaction(transaction)) {
         estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else if (isCardanoTransaction(transaction)) {
@@ -443,4 +444,14 @@ function isTonAddressBounceable(address) {
 async function isAccountActive(tonApi, address) {
   const state = await tonApi.getAccountState(address);
   return state === 'active';
+}
+export function validateXcmMinAmountToMythos(destChain, destToken, amount) {
+  const MYTHOS_DESTINATION_FEE = '2500000000000000000';
+  const errorMsg = 'Enter an amount higher than 2.5 MYTH to pay cross-chain fee and avoid your MYTH being lost after the transaction';
+  if (destChain === 'mythos' && destToken === 'mythos-NATIVE-MYTH') {
+    if (BigN(amount).lte(MYTHOS_DESTINATION_FEE)) {
+      return new TransactionError(TransferTxErrorType.NOT_ENOUGH_VALUE, t(errorMsg));
+    }
+  }
+  return undefined;
 }

package/core/substrate/xcm-parser.d.ts

@@ -55,4 +55,5 @@ export declare function _isAvailBridgeXcm(originChainInfo: _ChainInfo, destChain
 export declare function _isMythosFromHydrationToMythos(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo, assetSlug: string): boolean;
 export declare function _isPolygonBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
 export declare function _isPosBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
+export declare function _isAcrossBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
 export declare function _adaptX1Interior(_assetIdentifier: Record<string, any>, version: number): Record<string, any>;

package/core/substrate/xcm-parser.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _isAcrossChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { _isPolygonChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { _isPosChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
@@ -127,7 +128,9 @@ export function _isPolygonBridgeXcm(originChainInfo, destChainInfo) {
 export function _isPosBridgeXcm(originChainInfo, destChainInfo) {
   return _isPosChainBridge(originChainInfo.slug, destChainInfo.slug);
 }
-
+export function _isAcrossBridgeXcm(originChainInfo, destChainInfo) {
+  return _isAcrossChainBridge(originChainInfo.slug, destChainInfo.slug);
+}
 // ---------------------------------------------------------------------------------------------------------------------
 
 function _getMultiLocationParent(originChainInfo, isWithinSameConsensus) {

package/core/utils.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
-import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicType, SufficientChainsDetails } from '@subwallet/extension-base/background/KoniTypes';
 import { LedgerMustCheckType, ValidateRecipientParams } from '@subwallet/extension-base/core/types';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { AccountJson } from '@subwallet/extension-base/types';
@@ -15,4 +15,4 @@ export declare function _isValidTonAddressFormat(validateRecipientParams: Valida
 export declare function _isValidCardanoAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isNotDuplicateAddress(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isSupportLedgerAccount(validateRecipientParams: ValidateRecipientParams): string;
-export declare const _isSufficientToken: (tokenInfo: _ChainAsset, substrateApi: _SubstrateApi) => Promise<boolean>;
+export declare const _isSufficientToken: (tokenInfo: _ChainAsset, substrateApi: _SubstrateApi, sufficientChain: SufficientChainsDetails) => Promise<boolean>;

package/core/utils.js

@@ -5,7 +5,6 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BalanceAccountType } from '@subwallet/extension-base/core/substrate/types';
 import { tonAddressInfo } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
-import { SUFFICIENT_CHAIN } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getTokenOnChainAssetId, _getXcmAssetMultilocation, _isBridgedToken, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainSubstrateCompatible, _isChainTonCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { isAddressAndChainCompatible, isSameAddress, reformatAddress } from '@subwallet/extension-base/utils';
 import { isAddress, isCardanoTestnetAddress, isTonAddress } from '@subwallet/keyring';
@@ -132,27 +131,49 @@ export function _isSupportLedgerAccount(validateRecipientParams) {
   }
   return '';
 }
-export const _isSufficientToken = async (tokenInfo, substrateApi) => {
-  // todo: remove const and detect by pallets instead
-  if (SUFFICIENT_CHAIN.includes(tokenInfo.originChain) && tokenInfo.assetType !== _AssetType.NATIVE) {
+export const _isSufficientToken = async (tokenInfo, substrateApi, sufficientChain) => {
+  var _tokenInfo$metadata;
+  if (tokenInfo.assetType !== _AssetType.NATIVE) {
     const assetId = _isBridgedToken(tokenInfo) ? _getXcmAssetMultilocation(tokenInfo) : _getTokenOnChainAssetId(tokenInfo);
+    const chainSlug = tokenInfo.originChain;
     const queryParams = {
       section: 'query',
-      module: 'foreignAssets',
-      method: 'asset',
       args: [assetId]
     };
-    if (!_isBridgedToken(tokenInfo)) {
+    if (sufficientChain.assetHubPallet.includes(chainSlug)) {
+      if (!_isBridgedToken(tokenInfo)) {
+        queryParams.module = 'assets';
+      } else {
+        queryParams.module = 'foreignAssets';
+      }
+      queryParams.method = 'asset';
+    }
+    if (sufficientChain.assetRegistryPallet.includes(chainSlug)) {
+      queryParams.module = 'assetRegistry';
+      queryParams.method = 'assets';
+    }
+    if (sufficientChain.assetsPallet.includes(chainSlug)) {
       queryParams.module = 'assets';
+      queryParams.method = 'asset';
+    }
+    if (sufficientChain.foreignAssetsPallet.includes(chainSlug)) {
+      queryParams.module = 'foreignAsset';
+      queryParams.method = 'asset';
+    }
+    try {
+      if (queryParams.method && queryParams.module) {
+        const metadata = await substrateApi.makeRpcQuery(queryParams);
+        if ((metadata === null || metadata === void 0 ? void 0 : metadata.isSufficient) !== undefined) {
+          return metadata === null || metadata === void 0 ? void 0 : metadata.isSufficient;
+        }
+      }
+    } catch (e) {
+      console.error(e);
     }
-    const metadata = await substrateApi.makeRpcQuery(queryParams);
-    return (metadata === null || metadata === void 0 ? void 0 : metadata.isSufficient) || false;
   }
-
-  // todo
-  // if (tokenInfo.metadata?.isSufficient) {
-  //   return tokenInfo.metadata?.isSufficient;
-  // }
-
+  if ((_tokenInfo$metadata = tokenInfo.metadata) !== null && _tokenInfo$metadata !== void 0 && _tokenInfo$metadata.isSufficient) {
+    var _tokenInfo$metadata2;
+    return (_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.isSufficient;
+  }
   return false;
 };

package/koni/background/handlers/Extension.d.ts

@@ -129,6 +129,7 @@ export default class KoniExtension {
     private removeCustomChain;
     private disableChain;
     private enableChain;
+    private enableChainWithPriorityAssets;
     private reconnectChain;
     private validateNetwork;
     private resetDefaultNetwork;

package/koni/background/handlers/Extension.js

@@ -9,12 +9,12 @@ import { withErrorLog } from '@subwallet/extension-base/background/handlers/help
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
 import { CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingType } from '@subwallet/extension-base/background/KoniTypes';
 import { _SUPPORT_TOKEN_PAY_FEE_GROUP, ALL_ACCOUNT_KEY, LATEST_SESSION } from '@subwallet/extension-base/constants';
-import { additionalValidateTransferForRecipient, validateTransferRequest, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
+import { additionalValidateTransferForRecipient, validateTransferRequest, validateXcmMinAmountToMythos, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
 import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
 import { getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
-import { _ERC721_ABI, isAvailBridgeGatewayContract, isSnowBridgeGatewayContract } from '@subwallet/extension-base/koni/api/contract-handler/utils';
+import { _ERC721_ABI } from '@subwallet/extension-base/koni/api/contract-handler/utils';
 import { resolveAzeroAddressToDomain, resolveAzeroDomainToAddress } from '@subwallet/extension-base/koni/api/dotsama/domain';
 import { parseSubstrateTransaction } from '@subwallet/extension-base/koni/api/dotsama/parseTransaction';
 import { UNSUPPORTED_TRANSFER_EVM_CHAIN_NAME } from '@subwallet/extension-base/koni/api/nft/config';
@@ -29,7 +29,8 @@ import { createCardanoTransaction } from '@subwallet/extension-base/services/bal
 import { getERC20TransactionObject, getERC721Transaction, getEVMTransactionObject, getPSP34TransferExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
 import { createTonTransaction } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createAcrossBridgeExtrinsic, createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { _isAcrossChainBridge, getAcrossQuote } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { getClaimTxOnAvail, getClaimTxOnEthereum, isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { _isPolygonChainBridge, getClaimPolygonBridge, isClaimedPolygonBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
@@ -1104,9 +1105,10 @@ export default class KoniExtension {
       owner,
       spenderAddress
     } = params;
-    if (!isSnowBridgeGatewayContract(spenderAddress) && !isAvailBridgeGatewayContract(spenderAddress)) {
-      throw new Error('Only SnowBridge and AvailBridge is supported'); // todo: support all ERC20 spending approval
-    }
+
+    // if (!isSnowBridgeGatewayContract(spenderAddress) && !isAvailBridgeGatewayContract(spenderAddress)) {
+    //   throw new Error('Only SnowBridge and AvailBridge is supported'); // todo: support all ERC20 spending approval
+    // }
 
     const evmApi = this.#koniState.getEvmApi(chain);
     const transactionConfig = await getERC20SpendingApprovalTx(spenderAddress, owner, contractAddress, evmApi, amount);
@@ -1298,7 +1300,8 @@ export default class KoniExtension {
       const receiverSendingTokenKeepAliveBalance = BigInt(_receiverSendingTokenKeepAliveBalance);
       const amount = BigInt(transferAmount.value);
       const substrateApi = this.#koniState.getSubstrateApi(chain);
-      const isSendingTokenSufficient = await _isSufficientToken(transferTokenInfo, substrateApi);
+      const sufficientChain = this.#koniState.chainService.value.sufficientChains;
+      const isSendingTokenSufficient = await _isSufficientToken(transferTokenInfo, substrateApi, sufficientChain);
       const [warnings, errors] = additionalValidateTransferForRecipient(transferTokenInfo, nativeTokenInfo, extrinsicType, receiverSendingTokenKeepAliveBalance, amount, senderSendingTokenTransferable, receiverSystemAccountInfo, isSendingTokenSufficient);
       warnings.length && inputTransaction.warnings.push(...warnings);
       errors.length && inputTransaction.errors.push(...errors);
@@ -1350,7 +1353,7 @@ export default class KoniExtension {
     const destinationNativeTokenInfo = this.#koniState.getNativeTokenInfo(destinationNetworkKey);
     const destinationNativeTokenSlug = destinationNativeTokenInfo.slug;
     const [errors, fromKeyPair] = validateXcmTransferRequest(destinationTokenInfo, from, value);
-    let extrinsic = null;
+    let extrinsic;
     if (errors.length > 0) {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(errors);
     }
@@ -1360,9 +1363,12 @@ export default class KoniExtension {
     const isSnowBridgeEvmTransfer = _isPureEvmChain(chainInfoMap[originNetworkKey]) && _isSnowBridgeXcm(chainInfoMap[originNetworkKey], chainInfoMap[destinationNetworkKey]) && !isAvailBridgeFromEvm;
     const isPolygonBridgeTransfer = _isPolygonChainBridge(originNetworkKey, destinationNetworkKey);
     const isPosBridgeTransfer = _isPosChainBridge(originNetworkKey, destinationNetworkKey);
+    const isAcrossBridgeTransfer = _isAcrossChainBridge(originNetworkKey, destinationNetworkKey);
     const extrinsicType = ExtrinsicType.TRANSFER_XCM;
+    const isSubstrateXcm = !(isAvailBridgeFromEvm || isAvailBridgeFromAvail || isSnowBridgeEvmTransfer || isPolygonBridgeTransfer || isPosBridgeTransfer);
     const isTransferNative = this.#koniState.getNativeTokenInfo(originNetworkKey).slug === tokenSlug;
     const isTransferLocalTokenAndPayThatTokenAsFee = !isTransferNative && tokenSlug === tokenPayFeeSlug;
+    let xcmFeeDryRun;
     let additionalValidator;
     let eventsHandler;
     if (fromKeyPair && destinationTokenInfo) {
@@ -1373,6 +1379,9 @@ export default class KoniExtension {
       if (isPosBridgeTransfer || isPolygonBridgeTransfer) {
         funcCreateExtrinsic = createPolygonBridgeExtrinsic;
         type = 'evm';
+      } else if (isAcrossBridgeTransfer) {
+        funcCreateExtrinsic = createAcrossBridgeExtrinsic;
+        type = 'evm';
       } else if (isSnowBridgeEvmTransfer) {
         funcCreateExtrinsic = createSnowBridgeExtrinsic;
         type = 'evm';
@@ -1383,7 +1392,7 @@ export default class KoniExtension {
         funcCreateExtrinsic = createAvailBridgeExtrinsicFromAvail;
         type = 'substrate';
       } else {
-        funcCreateExtrinsic = createXcmExtrinsic;
+        funcCreateExtrinsic = createXcmExtrinsicV2;
         type = 'substrate';
       }
       const feeInfo = await this.#koniState.feeService.subscribeChainFee(getId(), originNetworkKey, type);
@@ -1402,6 +1411,19 @@ export default class KoniExtension {
         feeInfo
       };
       extrinsic = await funcCreateExtrinsic(params);
+      let dryRunInfo;
+      if (isSubstrateXcm) {
+        dryRunInfo = await dryRunXcmExtrinsicV2(params);
+        xcmFeeDryRun = dryRunInfo.fee;
+      }
+      if (isAcrossBridgeTransfer) {
+        const metadata = await getAcrossQuote(params);
+        inputData.metadata = {
+          amountOut: metadata.outputAmount,
+          rate: metadata.rate,
+          destChainSlug: destinationTokenInfo.slug
+        };
+      }
       if (_SUPPORT_TOKEN_PAY_FEE_GROUP.hydration.includes(originNetworkKey)) {
         var _this$koniState$chain2, _substrateApi$api$que2;
         const hydrationFeeAssetId = tokenPayFeeSlug && ((_this$koniState$chain2 = this.#koniState.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$koniState$chain2 === void 0 ? void 0 : _this$koniState$chain2.assetId);
@@ -1411,11 +1433,20 @@ export default class KoniExtension {
         extrinsic = batchExtrinsicSetFeeHydration(substrateApi, _extrinsic, feeSetting, hydrationFeeAssetId);
       }
       additionalValidator = async inputTransaction => {
+        // hotfix xcm mythos to mythos chain
+        const mythosError = validateXcmMinAmountToMythos(destinationNetworkKey, destinationTokenInfo.slug, value);
+        if (mythosError) {
+          inputTransaction.errors.push(mythosError);
+        }
         let isSendingTokenSufficient = false;
         let receiverSystemAccountInfo;
         if (!_isChainSubstrateCompatible(chainInfoMap[destinationNetworkKey])) {
           return undefined;
         }
+        const setting = {
+          visible: true
+        };
+        await this.#koniState.chainService.updateAssetSetting(destinationTokenInfo.slug, setting, true);
         const {
           value: _senderTransferable
         } = await this.getAddressTransferableBalance({
@@ -1443,15 +1474,17 @@ export default class KoniExtension {
           });
           receiverSystemAccountInfo = _receiverNativeTotal.metadata;
         }
-        if (_isChainSubstrateCompatible(chainInfoMap[destinationNetworkKey])) {
-          const substrateApi = this.#koniState.getSubstrateApi(destinationNetworkKey);
-          isSendingTokenSufficient = await _isSufficientToken(destinationTokenInfo, substrateApi);
-        }
+        const substrateApi = this.#koniState.getSubstrateApi(destinationNetworkKey);
+        const sufficientChain = this.#koniState.chainService.value.sufficientChains;
+        isSendingTokenSufficient = await _isSufficientToken(destinationTokenInfo, substrateApi, sufficientChain);
         const [warning, error] = additionalValidateTransferForRecipient(destinationTokenInfo, destinationNativeTokenInfo, extrinsicType, receiverDestinationTokenKeepAliveBalance, sendingAmount, senderTransferable,
         // different from sendingTokenInfo being passed in
         receiverSystemAccountInfo, isSendingTokenSufficient);
         warning.length && inputTransaction.warnings.push(...warning);
         error.length && inputTransaction.errors.push(...error);
+        if (isSubstrateXcm && !dryRunInfo.success) {
+          inputTransaction.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, 'Unable to perform transaction. Select another token or destination chain and try again'));
+        }
       };
       eventsHandler = eventEmitter => {
         eventEmitter.on('send', () => {
@@ -1484,13 +1517,14 @@ export default class KoniExtension {
       transaction: extrinsic,
       data: inputData,
       extrinsicType,
-      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm && !isPolygonBridgeTransfer && !isPosBridgeTransfer ? ChainType.SUBSTRATE : ChainType.EVM,
+      chainType: !isSnowBridgeEvmTransfer && !isAvailBridgeFromEvm && !isPolygonBridgeTransfer && !isPosBridgeTransfer && !isAcrossBridgeTransfer ? ChainType.SUBSTRATE : ChainType.EVM,
       transferNativeAmount: _isNativeToken(originTokenInfo) ? value : '0',
       ignoreWarnings,
       tokenPayFeeSlug,
       isTransferAll: transferAll,
       isTransferLocalTokenAndPayThatTokenAsFee,
       isPassConfirmation,
+      xcmFeeDryRun,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -1621,6 +1655,12 @@ export default class KoniExtension {
   }) {
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
+  async enableChainWithPriorityAssets({
+    chainSlug,
+    enableTokens
+  }) {
+    return await this.#koniState.enableChainWithPriorityAssets(chainSlug, enableTokens);
+  }
   async reconnectChain(chainSlug) {
     return this.#koniState.chainService.reconnectChain(chainSlug);
   }
@@ -1729,7 +1769,8 @@ export default class KoniExtension {
       feeCustom,
       feeOption,
       token,
-      tokenPayFeeSlug
+      tokenPayFeeSlug,
+      value
     } = request;
     const cb = createSubscription(id, port);
     const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(token);
@@ -1749,6 +1790,8 @@ export default class KoniExtension {
     }
     const _request = {
       address: address,
+      value,
+      // todo: lazy subscribe to improve performance
       cardanoApi: this.#koniState.chainService.getCardanoApi(chain),
       destChain,
       destToken,
@@ -4389,6 +4432,8 @@ export default class KoniExtension {
         return this.getSupportedSmartContractTypes();
       case 'pri(chainService.enableChain)':
         return await this.enableChain(request);
+      case 'pri(chainService.enableChainWithPriorityAssets)':
+        return await this.enableChainWithPriorityAssets(request);
       case 'pri(chainService.reconnectChain)':
         return await this.reconnectChain(request);
       case 'pri(chainService.disableChain)':

package/koni/background/handlers/State.d.ts

@@ -185,6 +185,7 @@ export default class KoniState {
     private getDefaultNetworkKeys;
     disableChain(chainSlug: string): Promise<boolean>;
     enableChain(chainSlug: string, enableTokens?: boolean): Promise<boolean>;
+    enableChainWithPriorityAssets(chainSlug: string, enableTokens?: boolean): Promise<boolean>;
     resetDefaultChains(): boolean;
     getSubstrateApiMap(): Record<string, import("@subwallet/extension-base/services/chain-service/types")._SubstrateApi>;
     getSubstrateApi(networkKey: string): import("@subwallet/extension-base/services/chain-service/types")._SubstrateApi;