@subwallet/extension-base 1.3.29-1 → 1.3.31-0

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

@@ -0,0 +1,216 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _isAcrossBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
+// Across Bridge
+const acrossPairsMap = new Map([[COMMON_CHAIN_SLUGS.ETHEREUM, new Set(['optimism', 'base_mainnet', 'arbitrum_one'])], ['optimism', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'base_mainnet', 'arbitrum_one'])], ['base_mainnet', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'arbitrum_one'])], ['arbitrum_one', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'base_mainnet'])], [COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, new Set(['base_sepolia', 'arbitrum_sepolia'])],
+// TESTNET START HERE
+['base_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])], ['arbitrum_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])]]);
+export function _isAcrossChainBridge(srcChain, destChain) {
+  var _acrossPairsMap$get$h, _acrossPairsMap$get;
+  return (_acrossPairsMap$get$h = (_acrossPairsMap$get = acrossPairsMap.get(srcChain)) === null || _acrossPairsMap$get === void 0 ? void 0 : _acrossPairsMap$get.has(destChain)) !== null && _acrossPairsMap$get$h !== void 0 ? _acrossPairsMap$get$h : false;
+}
+export function _isAcrossTestnetBridge(srcChain) {
+  return srcChain === 'base_sepolia' || srcChain === 'arbitrum_sepolia' || srcChain === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA;
+}
+export const SpokePoolMapping = {
+  1: {
+    SpokePool: {
+      address: '0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5',
+      blockNumber: 17117454
+    }
+  },
+  10: {
+    SpokePool: {
+      address: '0x6f26Bf09B1C792e3228e5467807a900A503c0281',
+      blockNumber: 93903076
+    }
+  },
+  11155111: {
+    SpokePool: {
+      address: '0x5ef6C01E11889d86803e0B23e3cB3F9E9d97B662',
+      blockNumber: 5288470
+    }
+  },
+  11155420: {
+    SpokePool: {
+      address: '0x4e8E101924eDE233C13e2D8622DC8aED2872d505',
+      blockNumber: 7762656
+    }
+  },
+  1135: {
+    SpokePool: {
+      address: '0x9552a0a6624A23B848060AE5901659CDDa1f83f8',
+      blockNumber: 2602337
+    }
+  },
+  130: {
+    SpokePool: {
+      address: '0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64',
+      blockNumber: 7915488
+    }
+  },
+  137: {
+    SpokePool: {
+      address: '0x9295ee1d8C5b022Be115A2AD3c30C72E34e7F096',
+      blockNumber: 41908657
+    }
+  },
+  168587773: {
+    SpokePool: {
+      address: '0x5545092553Cf5Bf786e87a87192E902D50D8f022',
+      blockNumber: 7634204
+    }
+  },
+  1868: {
+    SpokePool: {
+      address: '0x3baD7AD0728f9917d1Bf08af5782dCbD516cDd96',
+      blockNumber: 1709997
+    }
+  },
+  288: {
+    SpokePool: {
+      address: '0xBbc6009fEfFc27ce705322832Cb2068F8C1e0A58',
+      blockNumber: 619993
+    }
+  },
+  324: {
+    SpokePool: {
+      address: '0xE0B015E54d54fc84a6cB9B666099c46adE9335FF',
+      blockNumber: 10352565
+    }
+  },
+  34443: {
+    SpokePool: {
+      address: '0x3baD7AD0728f9917d1Bf08af5782dCbD516cDd96',
+      blockNumber: 8043187
+    }
+  },
+  37111: {
+    SpokePool: {
+      address: '0x6A0a7f39530923911832Dd60667CE5da5449967B',
+      blockNumber: 156275
+    }
+  },
+  41455: {
+    SpokePool: {
+      address: '0x13fDac9F9b4777705db45291bbFF3c972c6d1d97',
+      blockNumber: 4240318
+    }
+  },
+  4202: {
+    SpokePool: {
+      address: '0xeF684C38F94F48775959ECf2012D7E864ffb9dd4',
+      blockNumber: 7267988
+    }
+  },
+  42161: {
+    SpokePool: {
+      address: '0xe35e9842fceaCA96570B734083f4a58e8F7C5f2A',
+      blockNumber: 83868041
+    }
+  },
+  421614: {
+    SpokePool: {
+      address: '0x7E63A5f1a8F0B4d0934B2f2327DAED3F6bb2ee75',
+      blockNumber: 12411026
+    }
+  },
+  480: {
+    SpokePool: {
+      address: '0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64',
+      blockNumber: 4524742
+    }
+  },
+  534352: {
+    SpokePool: {
+      address: '0x3baD7AD0728f9917d1Bf08af5782dCbD516cDd96',
+      blockNumber: 7489705
+    }
+  },
+  57073: {
+    SpokePool: {
+      address: '0xeF684C38F94F48775959ECf2012D7E864ffb9dd4',
+      blockNumber: 1139240
+    }
+  },
+  59144: {
+    SpokePool: {
+      address: '0x7E63A5f1a8F0B4d0934B2f2327DAED3F6bb2ee75',
+      blockNumber: 2721169
+    }
+  },
+  690: {
+    SpokePool: {
+      address: '0x13fDac9F9b4777705db45291bbFF3c972c6d1d97',
+      blockNumber: 5512122
+    }
+  },
+  7777777: {
+    SpokePool: {
+      address: '0x13fDac9F9b4777705db45291bbFF3c972c6d1d97',
+      blockNumber: 18382867
+    }
+  },
+  80002: {
+    SpokePool: {
+      address: '0xd08baaE74D6d2eAb1F3320B2E1a53eeb391ce8e5',
+      blockNumber: 7529960
+    }
+  },
+  81457: {
+    SpokePool: {
+      address: '0x2D509190Ed0172ba588407D4c2df918F955Cc6E1',
+      blockNumber: 5574280
+    }
+  },
+  8453: {
+    SpokePool: {
+      address: '0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64',
+      blockNumber: 2164878
+    }
+  },
+  84532: {
+    SpokePool: {
+      address: '0x82B564983aE7274c86695917BBf8C99ECb6F0F8F',
+      blockNumber: 6082004
+    }
+  },
+  919: {
+    SpokePool: {
+      address: '0xbd886FC0725Cc459b55BbFEb3E4278610331f83b',
+      blockNumber: 13999465
+    }
+  }
+};
+// Calculate fee for across bridge transfer
+export const getAcrossQuote = async ({
+  destinationChain,
+  destinationTokenInfo,
+  originChain,
+  originTokenInfo,
+  recipient,
+  sender,
+  sendingValue
+}) => {
+  const isAcrossBridgeXcm = _isAcrossBridgeXcm(originChain, destinationChain);
+  console.log('sendingValue', sendingValue);
+  if (!isAcrossBridgeXcm) {
+    throw new Error('This is not a valid AcrossBridge transfer');
+  }
+  if (!sender) {
+    throw new Error('Sender is required');
+  }
+  try {
+    var _subwalletApiSdk$xcmA;
+    const data = await ((_subwalletApiSdk$xcmA = subwalletApiSdk.xcmApi) === null || _subwalletApiSdk$xcmA === void 0 ? void 0 : _subwalletApiSdk$xcmA.fetchXcmData(sender, originTokenInfo.slug, destinationTokenInfo.slug, recipient, sendingValue));
+    if (!data || !data.metadata) {
+      throw new Error('Failed to get AcrossBridge quote');
+    }
+    return data.metadata;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};

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

@@ -55,12 +55,12 @@ export async function getClaimTxOnAvail(notification, substrateApi) {
   const chainApi = await substrateApi.isReady;
   const chainSlug = chainApi.chainSlug;
   const metadata = notification.metadata;
-  const lastestEthHeadSlot = await getLastestEthHeadSlot(chainSlug);
-  const lastestBlockHash = await getLastestBlockHash(chainSlug, lastestEthHeadSlot);
-  const proof = await getClaimProofOnAvail(chainSlug, lastestBlockHash, metadata.messageId);
-  return chainApi.api.tx.vector.execute(lastestEthHeadSlot, getAddressMessage(notification), proof.accountProof, proof.storageProof);
+  const latestEthHeadSlot = await getLatestEthHeadSlot(chainSlug);
+  const latestBlockHash = await getLatestBlockHash(chainSlug, latestEthHeadSlot);
+  const proof = await getClaimProofOnAvail(chainSlug, latestBlockHash, metadata.messageId);
+  return chainApi.api.tx.vector.execute(latestEthHeadSlot, getAddressMessage(notification), proof.accountProof, proof.storageProof);
 }
-async function getLastestEthHeadSlot(chainSlug) {
+async function getLatestEthHeadSlot(chainSlug) {
   try {
     const api = getAvailBridgeApi(chainSlug);
     const rawResponse = await fetch(`${api}/eth/head`);
@@ -71,7 +71,7 @@ async function getLastestEthHeadSlot(chainSlug) {
     throw e;
   }
 }
-async function getLastestBlockHash(chainSlug, slot) {
+async function getLatestBlockHash(chainSlug, slot) {
   try {
     const api = getAvailBridgeApi(chainSlug);
     const rawResponse = await fetch(`${api}/beacon/slot/${slot}`);

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

@@ -1,4 +1,5 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { DryRunInfo } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { FeeInfo, TransactionFee } from '@subwallet/extension-base/types';
 import { TransactionConfig } from 'web3-core';
@@ -15,9 +16,12 @@ export declare type CreateXcmExtrinsicProps = {
     substrateApi?: _SubstrateApi;
     feeInfo: FeeInfo;
 } & TransactionFee;
-export declare type FunctionCreateXcmExtrinsic = (props: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | TransactionConfig>;
+export declare type FunctionCreateXcmExtrinsic = (props: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | TransactionConfig | undefined>;
 export declare const createSnowBridgeExtrinsic: ({ destinationChain, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
 export declare const createXcmExtrinsic: ({ destinationChain, originChain, originTokenInfo, recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
 export declare const createAvailBridgeTxFromEth: ({ evmApi, feeCustom, feeInfo, feeOption, originChain, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
 export declare const createAvailBridgeExtrinsicFromAvail: ({ recipient, sendingValue, substrateApi }: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'>>;
 export declare const createPolygonBridgeExtrinsic: ({ destinationChain, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;
+export declare const createXcmExtrinsicV2: (request: CreateXcmExtrinsicProps) => Promise<SubmittableExtrinsic<'promise'> | undefined>;
+export declare const dryRunXcmExtrinsicV2: (request: CreateXcmExtrinsicProps) => Promise<DryRunInfo>;
+export declare const createAcrossBridgeExtrinsic: ({ destinationChain, destinationTokenInfo, evmApi, feeCustom, feeInfo, feeOption, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<TransactionConfig>;

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

@@ -1,15 +1,19 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { _isPolygonBridgeXcm, _isPosBridgeXcm, _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
+import { _isAcrossBridgeXcm, _isPolygonBridgeXcm, _isPosBridgeXcm, _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { getAvailBridgeExtrinsicFromAvail, getAvailBridgeTxFromEth } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { getExtrinsicByPolkadotXcmPallet } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polkadotXcm';
 import { _createPolygonBridgeL1toL2Extrinsic, _createPolygonBridgeL2toL1Extrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { getSnowBridgeEvmTransfer } from '@subwallet/extension-base/services/balance-service/transfer/xcm/snowBridge';
+import { buildXcm, dryRunXcmV2, isChainNotSupportDryRun, isChainNotSupportPolkadotApi } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { getExtrinsicByXcmPalletPallet } from '@subwallet/extension-base/services/balance-service/transfer/xcm/xcmPallet';
 import { getExtrinsicByXtokensPallet } from '@subwallet/extension-base/services/balance-service/transfer/xcm/xTokens';
 import { _XCM_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { combineEthFee } from '@subwallet/extension-base/utils';
+import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
 import { _createPosBridgeL1toL2Extrinsic, _createPosBridgeL2toL1Extrinsic } from "./posBridge.js";
 // SnowBridge
 export const createSnowBridgeExtrinsic = async ({
@@ -111,4 +115,84 @@ export const createPolygonBridgeExtrinsic = async ({
   const sourceChain = originChain.slug;
   const createExtrinsic = isPolygonBridgeXcm ? sourceChain === 'polygonzkEvm_cardona' || sourceChain === 'polygonZkEvm' ? _createPolygonBridgeL2toL1Extrinsic : _createPolygonBridgeL1toL2Extrinsic : sourceChain === 'polygon_amoy' || sourceChain === 'polygon' ? _createPosBridgeL2toL1Extrinsic : _createPosBridgeL1toL2Extrinsic;
   return createExtrinsic(originTokenInfo, originChain, sender, recipient, sendingValue, evmApi, feeInfo, feeCustom, feeOption);
+};
+export const createXcmExtrinsicV2 = async request => {
+  try {
+    return await buildXcm(request);
+  } catch (e) {
+    console.log('createXcmExtrinsicV2 error: ', e);
+    const errorMessage = e instanceof Error ? e.message : 'Unknown error occurred';
+    if (isChainNotSupportPolkadotApi(errorMessage)) {
+      return createXcmExtrinsic(request);
+    }
+    return undefined;
+  }
+};
+export const dryRunXcmExtrinsicV2 = async request => {
+  try {
+    return await dryRunXcmV2(request);
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : 'Unknown error occurred';
+    if (isChainNotSupportDryRun(errorMessage) || isChainNotSupportPolkadotApi(errorMessage)) {
+      const xcmTransfer = await createXcmExtrinsicV2(request);
+      if (!xcmTransfer) {
+        return {
+          success: false
+        };
+      }
+      const _xcmFeeInfo = await xcmTransfer.paymentInfo(request.sender);
+      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
+
+      // skip dry run in this case
+      return {
+        success: true,
+        fee: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString()
+      };
+    }
+    return {
+      success: false
+    };
+  }
+};
+export const createAcrossBridgeExtrinsic = async ({
+  destinationChain,
+  destinationTokenInfo,
+  evmApi,
+  feeCustom,
+  feeInfo,
+  feeOption,
+  originChain,
+  originTokenInfo,
+  recipient,
+  sender,
+  sendingValue
+}) => {
+  const isAcrossBridgeXcm = _isAcrossBridgeXcm(originChain, destinationChain);
+  if (!isAcrossBridgeXcm) {
+    throw new Error('This is not a valid AcrossBridge transfer');
+  }
+  if (!evmApi) {
+    throw new Error('Evm API is not available');
+  }
+  if (!sender) {
+    throw new Error('Sender is required');
+  }
+  try {
+    var _subwalletApiSdk$xcmA;
+    const data = await ((_subwalletApiSdk$xcmA = subwalletApiSdk.xcmApi) === null || _subwalletApiSdk$xcmA === void 0 ? void 0 : _subwalletApiSdk$xcmA.fetchXcmData(sender, originTokenInfo.slug, destinationTokenInfo.slug, recipient, sendingValue));
+    const _feeCustom = feeCustom;
+    const feeCombine = combineEthFee(feeInfo, feeOption, _feeCustom);
+    const transactionConfig = {
+      from: data === null || data === void 0 ? void 0 : data.sender,
+      to: data === null || data === void 0 ? void 0 : data.to,
+      value: data === null || data === void 0 ? void 0 : data.value,
+      data: data === null || data === void 0 ? void 0 : data.transferEncodedCall,
+      ...feeCombine
+    };
+    const gasLimit = await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 200000);
+    transactionConfig.gas = gasLimit.toString();
+    return transactionConfig;
+  } catch (error) {
+    return Promise.reject(error);
+  }
 };

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

@@ -1,3 +1,14 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
+import { CreateXcmExtrinsicProps } from '@subwallet/extension-base/services/balance-service/transfer/xcm/index';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+export interface DryRunInfo {
+    success: boolean;
+    fee?: string;
+}
+export declare function buildXcm(request: CreateXcmExtrinsicProps): Promise<SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function dryRunXcm(request: CreateXcmExtrinsicProps): Promise<DryRunInfo>;
+export declare function dryRunXcmV2(request: CreateXcmExtrinsicProps): Promise<DryRunInfo>;
+export declare function isChainNotSupportPolkadotApi(str: string): boolean;
+export declare function isChainNotSupportDryRun(str: string): boolean;
 export declare const STABLE_XCM_VERSION = 3;
 export declare function isUseTeleportProtocol(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo, tokenSlug?: string): boolean;

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/base/types.d.ts

@@ -1,4 +1,3 @@
-import { OptimalProcessParams, OptimalProcessResult } from '@subwallet/extension-base/types/service-base';
 import { PromiseHandler } from '@subwallet/extension-base/utils/promise';
 export declare enum ServiceStatus {
     NOT_INITIALIZED = "not_initialized",
@@ -33,6 +32,3 @@ export interface CronServiceInterface {
     startCron: () => Promise<void>;
     stopCron: () => Promise<void>;
 }
-export interface ServiceWithProcessInterface {
-    generateOptimalProcess(params: OptimalProcessParams): Promise<OptimalProcessResult>;
-}

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