@subwallet/extension-base 1.3.39-0 → 1.3.41-0

package/services/swap-service/handler/kyber-handler.js

@@ -6,52 +6,65 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { estimateTxFee, getERC20Allowance, getERC20SpendingApprovalTx } from '@subwallet/extension-base/koni/api/contract-handler/evm/web3';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
-import { _reformatAddressWithChain, combineEthFee } from '@subwallet/extension-base/utils';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { _reformatAddressWithChain, combineEthFee, fetchFromProxyService } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 import { _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
 import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
 import { SwapBaseHandler } from "./base-handler.js";
-export const KYBER_CLIENT_ID = process.env.KYBER_CLIENT_ID || '';
-const kyberUrl = 'https://aggregator-api.kyberswap.com';
-async function buildTxForSwap(params, chain) {
+async function buildTxForKyberSwap(params, chain) {
   const {
     recipient,
     sender,
     slippageTolerance
   } = params;
   let routeSummary = params.routeSummary;
+  console.log('routeSummary1', routeSummary);
   if (!routeSummary || !routeSummary.tokenIn || !routeSummary.tokenOut || !routeSummary.amountIn) {
-    const queryParams = new URLSearchParams({
-      tokenIn: routeSummary.tokenIn,
-      tokenOut: routeSummary.tokenOut,
-      amountIn: routeSummary.amountIn,
-      gasInclude: 'true'
-    });
-    const url = `${kyberUrl}/${chain}/api/v1/routes?${queryParams.toString()}`;
-    try {
-      var _routeData$data;
-      const res = await fetch(url, {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-client-id': KYBER_CLIENT_ID,
-          accept: 'application/json'
-        }
-      });
-      const routeData = await res.json();
-      if (!routeData.success || !((_routeData$data = routeData.data) !== null && _routeData$data !== void 0 && _routeData$data.routeSummary)) {
-        return {
-          error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, routeData.message)
-        };
+    return {
+      error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Invalid Route Summary')
+    };
+  }
+  const {
+    amountIn,
+    tokenIn,
+    tokenOut
+  } = routeSummary;
+  const queryParams = new URLSearchParams({
+    tokenIn,
+    tokenOut,
+    amountIn,
+    gasInclude: 'true'
+  });
+  const path = `/${chain}/api/v1/routes?${queryParams.toString()}`;
+  try {
+    var _routeData$data;
+    const res = await fetchFromProxyService(ProxyServiceRoute.KYBER, path, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        accept: 'application/json'
       }
-      routeSummary = routeData.data.routeSummary;
-    } catch (error) {
-      console.error('Error:', error);
+    });
+    if (!res.ok) {
+      const errorText = await res.text();
       return {
-        error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR)
+        error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, `Fetch Kyber routes failed: ${errorText}`)
       };
     }
+    const routeData = await res.json();
+    if (!((_routeData$data = routeData.data) !== null && _routeData$data !== void 0 && _routeData$data.routeSummary)) {
+      return {
+        error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, routeData.message)
+      };
+    }
+    routeSummary = routeData.data.routeSummary;
+  } catch (error) {
+    console.error('Error:', error);
+    return {
+      error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Unable to build Kyber swap transaction')
+    };
   }
   const body = {
     routeSummary,
@@ -61,12 +74,12 @@ async function buildTxForSwap(params, chain) {
     ignoreCappedSlippage: true,
     enableGasEstimation: true
   };
+  console.log('routeSummary2', routeSummary);
   try {
-    const res = await fetch(`${kyberUrl}/${chain}/api/v1/route/build`, {
+    const res = await fetchFromProxyService(ProxyServiceRoute.KYBER, `/${chain}/api/v1/route/build`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'x-client-id': KYBER_CLIENT_ID,
         accept: 'application/json'
       },
       body: JSON.stringify(body)
@@ -272,7 +285,7 @@ export class KyberHandler {
     const recipient = _reformatAddressWithChain((_params$recipient = params.recipient) !== null && _params$recipient !== void 0 ? _params$recipient : sender, toChainInfo);
     const metadata = params.quote.metadata;
     const slippageTolerance = params.slippage * 10000;
-    const rawTx = await buildTxForSwap({
+    const rawTx = await buildTxForKyberSwap({
       routeSummary: metadata.routeSummary,
       sender: params.address,
       recipient,

package/services/swap-service/handler/simpleswap-handler.d.ts

@@ -4,7 +4,6 @@ import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPa
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
 import { SwapBaseInterface } from './base-handler';
-export declare const simpleSwapApiKey: string;
 export declare class SimpleSwapHandler implements SwapBaseInterface {
     private swapBaseHandler;
     providerSlug: SwapProviderId;

package/services/swap-service/handler/simpleswap-handler.js

@@ -4,50 +4,81 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _getAssetDecimals, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
-import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { _reformatAddressWithChain, fetchFromProxyService, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN, { BigNumber } from 'bignumber.js';
 import { getERC20TransactionObject, getEVMTransactionObject } from "../../balance-service/transfer/smart-contract.js";
 import { createSubstrateExtrinsic } from "../../balance-service/transfer/token.js";
-import { SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING } from "../utils.js";
 import { SwapBaseHandler } from "./base-handler.js";
-const apiUrl = 'https://api.simpleswap.io';
-export const simpleSwapApiKey = process.env.SIMPLE_SWAP_API_KEY || '';
 const toBNString = (input, decimal) => {
   const raw = new BigNumber(input);
   return raw.shiftedBy(decimal).integerValue(BigNumber.ROUND_CEIL).toFixed();
 };
-const createSwapRequest = async params => {
-  const fromDecimals = _getAssetDecimals(params.fromAsset);
-  const toDecimals = _getAssetDecimals(params.toAsset);
-  const formatedAmount = formatNumber(params.fromAmount, fromDecimals, s => s);
-  const requestBody = {
-    fixed: false,
-    currency_from: params.fromSymbol,
-    currency_to: params.toSymbol,
-    amount: formatedAmount,
-    // Convert to small number due to require of api
-    address_to: params.receiver,
-    extra_id_to: '',
-    user_refund_address: params.sender,
-    user_refund_extra_id: ''
-  };
-  const response = await fetch(`${apiUrl}/create_exchange?api_key=${simpleSwapApiKey}`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Accept: 'application/json'
-    },
-    body: JSON.stringify(requestBody)
-  });
-  const depositAddressResponse = await response.json();
-  return {
-    id: depositAddressResponse.id,
-    addressFrom: depositAddressResponse.address_from,
-    amountTo: toBNString(depositAddressResponse.amount_to, toDecimals)
-  };
+const buildTxForSimpleSwap = async params => {
+  try {
+    const {
+      fromAmount,
+      fromAsset,
+      fromSymbol,
+      metadata,
+      receiver,
+      sender,
+      toAsset,
+      toSymbol
+    } = params;
+    const fromDecimals = _getAssetDecimals(fromAsset);
+    const toDecimals = _getAssetDecimals(toAsset);
+    const formattedAmount = formatNumber(fromAmount, fromDecimals, s => s);
+    const requestBody = {
+      fixed: false,
+      tickerFrom: fromSymbol,
+      tickerTo: toSymbol,
+      amount: formattedAmount,
+      networkFrom: metadata.fromChainSymbol,
+      networkTo: metadata.toChainSymbol,
+      addressTo: receiver,
+      extraIdTo: '',
+      userRefundAddress: sender,
+      userRefundExtraId: ''
+    };
+    const response = await fetchFromProxyService(ProxyServiceRoute.SIMPLESWAP, '/exchanges', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        accept: 'application/json'
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR, `Unable to create simpleswap transaction: ${errorText}`)
+      };
+    }
+    const depositAddressResponse = await response.json();
+    const result = depositAddressResponse.result;
+    console.log('simpleswapID', result.id);
+    if (!(result !== null && result !== void 0 && result.id) || !result.addressFrom || !result.amountTo) {
+      return {
+        error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR)
+      };
+    }
+    return {
+      data: {
+        id: result.id,
+        addressFrom: result.addressFrom,
+        amountTo: toBNString(result.amountTo, toDecimals)
+      }
+    };
+  } catch (err) {
+    console.error('Error:', err);
+    return {
+      error: new TransactionError(BasicTxErrorType.INTERNAL_ERROR)
+    };
+  }
 };
 export class SimpleSwapHandler {
   constructor(chainService, balanceService, feeService) {
@@ -131,25 +162,31 @@ export class SimpleSwapHandler {
     const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : ChainType.EVM;
     const sender = _reformatAddressWithChain(address, chainInfo);
     const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
-    const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
-    const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+    const fromSymbol = _getAssetSymbol(fromAsset).toLowerCase();
+    const toSymbol = _getAssetSymbol(toAsset).toLowerCase();
+    const metadata = quote.metadata;
     const {
       fromAmount
     } = quote;
-    const {
-      addressFrom,
-      amountTo,
-      id
-    } = await createSwapRequest({
+    const result = await buildTxForSimpleSwap({
       fromSymbol,
       toSymbol,
       fromAmount,
       fromAsset,
       receiver,
       sender,
-      toAsset
+      toAsset,
+      metadata
     });
-    console.log('simpleswap data', id, addressFrom);
+    if (result.error) {
+      console.error('Simple swap error:', result.error);
+      throw result.error;
+    }
+    const {
+      addressFrom,
+      amountTo,
+      id
+    } = result.data;
     if (!id || id.length === 0 || !addressFrom || addressFrom.length === 0) {
       throw new SwapError(SwapErrorType.UNKNOWN);
     }

package/services/swap-service/handler/uniswap-handler.js

@@ -9,16 +9,13 @@ import { createAcrossBridgeExtrinsic } from '@subwallet/extension-base/services/
 import { getAcrossQuote } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType, CommonStepType, DynamicSwapType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
-import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
+import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
+import { _reformatAddressWithChain, fetchFromProxyService } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
 import { _getAssetOriginChain, _getChainNativeTokenSlug, _getContractAddressOfToken, _getEvmChainId, _isNativeToken } from "../../chain-service/utils/index.js";
 import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
 import { SwapBaseHandler } from "./base-handler.js";
-const API_URL = 'https://trade-api.gateway.uniswap.org/v1';
-const headers = {
-  'x-api-key': process.env.UNISWAP_API_KEY || ''
-};
 async function fetchCheckApproval(request) {
   const {
     address,
@@ -49,10 +46,9 @@ async function fetchCheckApproval(request) {
   } else {
     return undefined;
   }
-  const response = await fetch(`${API_URL}/check_approval`, {
+  const response = await fetchFromProxyService(ProxyServiceRoute.UNISWAP, '/check_approval', {
     method: 'POST',
     headers: {
-      ...headers,
       'Content-Type': 'application/json'
     },
     body: JSON.stringify({
@@ -617,10 +613,9 @@ export class UniswapHandler {
       if (permitData) {
         body.permitData = permitData;
       }
-      postTransactionResponse = await fetch(`${API_URL}/swap`, {
+      postTransactionResponse = await fetchFromProxyService(ProxyServiceRoute.UNISWAP, '/swap', {
         method: 'POST',
         headers: {
-          ...headers,
           'Content-Type': 'application/json'
         },
         body: JSON.stringify(body)
@@ -631,10 +626,9 @@ export class UniswapHandler {
       const dutchQuote = quote;
       const submitSwapOrder = async () => {
         try {
-          const res = await fetch(`${API_URL}/order`, {
+          const res = await fetchFromProxyService(ProxyServiceRoute.UNISWAP, '/order', {
             method: 'POST',
             headers: {
-              ...headers,
               'Content-Type': 'application/json'
             },
             body: JSON.stringify({
@@ -675,10 +669,9 @@ export class UniswapHandler {
         const swapper = dutchQuote.orderInfo.swapper;
         return retryGetUniswapTx(async () => {
           try {
-            const response = await fetch(`${API_URL}/orders?orderId=${orderId}&swapper=${swapper}`, {
+            const response = await fetchFromProxyService(ProxyServiceRoute.UNISWAP, `/orders?orderId=${orderId}&swapper=${swapper}`, {
               method: 'GET',
               headers: {
-                ...headers,
                 'Content-Type': 'application/json'
               }
             });

package/services/swap-service/utils.d.ts

@@ -13,19 +13,6 @@ export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | un
 export declare function getSwapAltToken(chainAsset: _ChainAsset): string | undefined;
 export declare function calculateSwapRate(fromAmount: string, toAmount: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
 export declare function convertSwapRate(rate: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
-export declare function getChainflipOptions(isTestnet: boolean): {
-    network: string;
-    broker?: undefined;
-} | {
-    network: string;
-    broker: {
-        url: string;
-    };
-};
-export declare function getChainflipBroker(isTestnet: boolean): {
-    url: string;
-};
-export declare function getChainflipSwap(isTestnet: boolean): string;
 export declare function getBridgeStep(from: string, to: string): DynamicSwapAction;
 export declare function getSwapStep(from: string, to: string): DynamicSwapAction;
 export declare function findBridgeTransitDestination(assetRefMap: Record<string, _AssetRef>, fromToken: _ChainAsset, toToken: _ChainAsset): string | undefined;

package/services/swap-service/utils.js

@@ -4,13 +4,14 @@
 import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 import { _AssetRefPath } from '@subwallet/chain-list/types';
 import { _getAssetDecimals, _getAssetOriginChain, _getOriginChainOfAsset, _parseAssetRefKey } from '@subwallet/extension-base/services/chain-service/utils';
-import { CHAINFLIP_BROKER_API } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
 import { CommonStepType, DynamicSwapType, SwapStepType } from '@subwallet/extension-base/types';
 import { SwapProviderId } from '@subwallet/extension-base/types/swap';
 import BigN from 'bignumber.js';
 export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
 export const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
 export const SIMPLE_SWAP_EXPLORER = 'https://simpleswap.io';
+
+// Deprecated
 export const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
   'bittensor-NATIVE-TAO': 'tao',
   [COMMON_ASSETS.ETH]: 'eth',
@@ -68,39 +69,52 @@ export function convertSwapRate(rate, fromAsset, toAsset) {
   const bnRate = BigN(rate);
   return bnRate.times(10 ** decimalDiff).pow(-1).toNumber();
 }
-export function getChainflipOptions(isTestnet) {
-  if (isTestnet) {
-    return {
-      network: getChainflipNetwork(isTestnet)
-    };
-  }
-  return {
-    network: getChainflipNetwork(isTestnet),
-    broker: getChainflipBroker(isTestnet)
-  };
-}
-function getChainflipNetwork(isTestnet) {
-  return isTestnet ? 'perseverance' : 'mainnet';
-}
-export function getChainflipBroker(isTestnet) {
-  // noted: currently not use testnet broker
-  if (isTestnet) {
-    return {
-      url: `https://perseverance.chainflip-broker.io/rpc/${CHAINFLIP_BROKER_API}`
-    };
-  } else {
-    return {
-      url: `https://chainflip-broker.io/rpc/${CHAINFLIP_BROKER_API}`
-    };
-  }
-}
-export function getChainflipSwap(isTestnet) {
-  if (isTestnet) {
-    return `https://perseverance.chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
-  } else {
-    return `https://chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
-  }
-}
+
+// export function getChainflipOptions (isTestnet: boolean) {
+//   if (isTestnet) {
+//     return {
+//       network: getChainflipNetwork(isTestnet)
+//     };
+//   }
+
+//   return {
+//     network: getChainflipNetwork(isTestnet),
+//     broker: getChainflipBroker(isTestnet)
+//   };
+// }
+
+// function getChainflipNetwork (isTestnet: boolean) {
+//   return isTestnet ? 'perseverance' : 'mainnet';
+// }
+
+// export function getChainflipBroker (isTestnet: boolean) { // noted: currently not use testnet broker
+//   if (isTestnet) {
+//     return {
+//       url: `https://perseverance.chainflip-broker.io/rpc/${CHAINFLIP_BROKER_API}`
+//     };
+//   } else {
+//     return {
+//       url: `https://chainflip-broker.io/rpc/${CHAINFLIP_BROKER_API}`
+//     };
+//   }
+// }
+
+// export function getChainflipSwap (isTestnet: boolean) {
+//   if (isTestnet) {
+//     return `https://perseverance.chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
+//   } else {
+//     return `https://chainflip-broker.io/swap?apikey=${CHAINFLIP_BROKER_API}`;
+//   }
+// }
+
+// export function getAssetsUrl (isTestnet: boolean) {
+//   if (isTestnet) {
+//     return 'https://perseverance.chainflip-broker.io/assets';
+//   } else {
+//     return 'https://chainflip-broker.io/assets';
+//   }
+// }
+
 export function getBridgeStep(from, to) {
   return {
     action: DynamicSwapType.BRIDGE,

package/types/environment.d.ts

@@ -0,0 +1,9 @@
+export declare enum ProxyServiceRoute {
+    BITTENSOR = "/bittensor",
+    CHAINFLIP = "/chainflip",
+    KYBER = "/kyber",
+    SIMPLESWAP = "/simpleswap",
+    UNISWAP = "/uniswap",
+    CARDANO = "/cardano",
+    PARASPELL = "/paraspell"
+}

package/types/environment.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let ProxyServiceRoute;
+(function (ProxyServiceRoute) {
+  ProxyServiceRoute["BITTENSOR"] = "/bittensor";
+  ProxyServiceRoute["CHAINFLIP"] = "/chainflip";
+  ProxyServiceRoute["KYBER"] = "/kyber";
+  ProxyServiceRoute["SIMPLESWAP"] = "/simpleswap";
+  ProxyServiceRoute["UNISWAP"] = "/uniswap";
+  ProxyServiceRoute["CARDANO"] = "/cardano";
+  ProxyServiceRoute["PARASPELL"] = "/paraspell";
+})(ProxyServiceRoute || (ProxyServiceRoute = {}));

package/utils/environment.d.ts

@@ -1,5 +1,6 @@
 import Bowser from 'bowser';
 import { EnvironmentSupport, RuntimeEnvironmentInfo, TargetEnvironment } from '../background/KoniTypes';
+import { ProxyServiceRoute } from '../types/environment';
 export declare const RuntimeInfo: RuntimeEnvironmentInfo;
 export declare const BowserParser: Bowser.Parser.Parser;
 export declare const isBrave: boolean;
@@ -16,3 +17,4 @@ export declare const targetIsExtension: boolean;
 export declare const targetIsWeb: boolean;
 export declare const targetIsMobile: boolean;
 export declare const MODULE_SUPPORT: EnvironmentSupport;
+export declare function fetchFromProxyService(service: ProxyServiceRoute, path: string, options: RequestInit, isTestnet?: boolean): Promise<Response>;

package/utils/environment.js

@@ -5,6 +5,7 @@ var _navigator3;
 import { isSupportWindow } from '@subwallet/extension-base/utils/mv3';
 import Bowser from 'bowser';
 import { RuntimeEnvironment } from "../background/KoniTypes.js";
+import { SW_EXTERNAL_SERVICES_API } from "../constants/index.js";
 function detectRuntimeEnvironment() {
   if (isSupportWindow && typeof document !== 'undefined') {
     var _navigator, _window$location, _window$location2;
@@ -84,4 +85,29 @@ export const targetIsWeb = TARGET_ENV === 'webapp';
 export const targetIsMobile = TARGET_ENV === 'mobile';
 export const MODULE_SUPPORT = {
   MANTA_ZK: false
-};
+};
+var HEADERS;
+(function (HEADERS) {
+  HEADERS["PLATFORM"] = "Platform";
+})(HEADERS || (HEADERS = {}));
+function formatExternalServiceApi(url, isTestnet) {
+  if (isTestnet === true) {
+    return `${url}/testnet`;
+  }
+  if (isTestnet === false) {
+    return `${url}/mainnet`;
+  }
+  return url;
+}
+export async function fetchFromProxyService(service, path, options, isTestnet) {
+  const baseUrl = formatExternalServiceApi(`${SW_EXTERNAL_SERVICES_API}${service}`, isTestnet);
+  const url = `${baseUrl}${path}`;
+  const headers = {
+    [HEADERS.PLATFORM]: TARGET_ENV,
+    ...(options.headers || {})
+  };
+  return fetch(url, {
+    ...options,
+    headers
+  });
+}

package/utils/fee/transfer.js

@@ -8,11 +8,12 @@ import { createCardanoTransaction } from '@subwallet/extension-base/services/bal
 import { getERC20TransactionObject, getEVMTransactionObject } 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 { createAcrossBridgeExtrinsic, createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { createAcrossBridgeExtrinsic, createAvailBridgeExtrinsicFromAvail, createAvailBridgeTxFromEth, createPolygonBridgeExtrinsic, createSnowBridgeExtrinsic, createXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _isAcrossChainBridge, _isAcrossTestnetBridge } 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';
+import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _getAssetDecimals, _getContractAddressOfToken, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainTonCompatible, _isLocalToken, _isNativeToken, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool, FEE_COVERAGE_PERCENTAGE_SPECIAL_CASE } from '@subwallet/extension-base/services/fee-service/utils';
 import { getHydrationRate } from '@subwallet/extension-base/services/fee-service/utils/tokenPayFee';
@@ -369,8 +370,15 @@ export const calculateXcmMaxTransferable = async (id, request, freeBalance, fee)
     } else if (feeChainType === 'substrate') {
       // Calculate fee for substrate transaction
       if (isSubstrateXcm) {
-        const estimatedFeeByDryRun = await dryRunXcmExtrinsicV2(params);
-        estimatedFee = estimatedFeeByDryRun.fee || '0';
+        const xcmFeeInfo = await estimateXcmFee({
+          fromChainInfo: params.originChain,
+          fromTokenInfo: params.originTokenInfo,
+          toChainInfo: params.destinationChain,
+          recipient: params.recipient,
+          sender: params.sender,
+          value: params.sendingValue
+        });
+        estimatedFee = (xcmFeeInfo === null || xcmFeeInfo === void 0 ? void 0 : xcmFeeInfo.origin.fee) || '0';
       } else {
         try {
           var _paymentInfo$partialF2;